#define WINDOWMANAGER_LAYER_NUM 4
-// the HomeScreen app has to have the surface id 1000
-#define WINDOWMANAGER_HOMESCREEN_MAIN_SURFACE_ID 1000
+#define WINDOWMANAGER_SURFACE_ID_SHIFT 22
+// the HomeScreen app has to have the surface id 4194304
+#define WINDOWMANAGER_HOMESCREEN_MAIN_SURFACE_ID (1 << WINDOWMANAGER_SURFACE_ID_SHIFT)
+
+// Quick hack for scaling layer to fit non-FHD(1920x1080) screen
+// * source rect of layer should be 1920x1080
+// * destination rect of layer should fit physical display resolution
+// * source rect of surface shoud be based on 1920x1080
+// * destination rect of surface should be based on 1920x1080
+#define WINDOWMANAGER_HOMESCREEN_WIDTH 1080
+#define WINDOWMANAGER_HOMESCREEN_HEIGHT 1920
void* WindowManager::myThis = 0;
-WindowManager::WindowManager(QObject *parent) :
+WindowManager::WindowManager(int displayId, QObject *parent) :
QObject(parent),
m_layouts(),
- m_appSurfaces(),
mp_layoutAreaToSurfaceIdAssignment(0),
m_currentLayout(-1),
- m_screenId(0), // use screen "0"
+ m_screenId(displayId),
m_screenWidth(0),
m_screenHeight(0)
+#ifdef HAVE_IVI_LAYERMANAGEMENT_API
+ ,
+ m_appSurfaces(),
+ m_appLayers(),
+ m_pending_to_show(-1)
+#endif
{
+#ifdef HAVE_IVI_LAYERMANAGEMENT_API
+ m_showLayers = new t_ilm_layer[WINDOWMANAGER_LAYER_NUM];
+
+ m_showLayers[0] = 0; /* POPUP is not shown by default */
+ m_showLayers[1] = 0; /* HOMESCREEN_OVERLAY is not shown by default */
+ m_showLayers[2] = 0; /* APPLICATIONS is not shown by default */
+ m_showLayers[3] = WINDOWMANAGER_LAYER_HOMESCREEN; /* HOMESCREEN is shwon by default */
+
+#endif
qDebug("-=[WindowManager]=-");
}
createNewLayer(WINDOWMANAGER_LAYER_POPUP);
createNewLayer(WINDOWMANAGER_LAYER_HOMESCREEN_OVERLAY);
- createNewLayer(WINDOWMANAGER_LAYER_APPLICATIONS);
createNewLayer(WINDOWMANAGER_LAYER_HOMESCREEN);
ilm_registerNotification(WindowManager::notificationFunc_static, this);
delete mp_layoutAreaToSurfaceIdAssignment;
}
+#ifdef HAVE_IVI_LAYERMANAGEMENT_API
+int WindowManager::getLayerRenderOrder(t_ilm_layer id_array[])
+{
+ int i, j;
+
+ for (i = WINDOWMANAGER_LAYER_NUM - 1, j = 0; i >= 0; i--) {
+ if (m_showLayers[i] != 0) {
+ id_array[j++] = m_showLayers[i];
+ }
+ }
+
+ return j;
+}
+#endif
+
void WindowManager::dumpScene()
{
qDebug("\n");
qDebug(" layerId %d", layerId);
t_ilm_layer newLayerId = layerId;
- ilm_layerCreateWithDimension(&newLayerId, m_screenWidth, m_screenHeight);
- ilm_layerSetOpacity(newLayerId, 1.0);
- ilm_layerSetVisibility(newLayerId, ILM_TRUE);
+ ilm_layerCreateWithDimension(&newLayerId,
+ WINDOWMANAGER_HOMESCREEN_WIDTH,
+ WINDOWMANAGER_HOMESCREEN_HEIGHT);
+ ilm_commitChanges();
ilm_layerSetSourceRectangle(newLayerId,
0,
0,
- m_screenWidth,
- m_screenHeight);
+ WINDOWMANAGER_HOMESCREEN_WIDTH,
+ WINDOWMANAGER_HOMESCREEN_HEIGHT);
ilm_layerSetDestinationRectangle(newLayerId,
0,
0,
m_screenWidth,
m_screenHeight);
-
+ ilm_commitChanges();
+ ilm_layerSetOpacity(newLayerId, 1.0);
+ ilm_layerSetVisibility(newLayerId, ILM_TRUE);
ilm_commitChanges();
}
-void WindowManager::addSurfaceToLayer(int surfaceId, int layerId)
+t_ilm_layer WindowManager::getAppLayerID(pid_t pid)
{
- qDebug("-=[addSurfaceToLayer]=-");
- qDebug(" surfaceId %d", surfaceId);
- qDebug(" layerId %d", layerId);
+ t_ilm_layer layer_id;
- if (layerId == WINDOWMANAGER_LAYER_HOMESCREEN)
- {
- struct ilmSurfaceProperties surfaceProperties;
- ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
+// layer_id = pid + (WINDOWMANAGER_LAYER_APPLICATIONS << WINDOWMANAGER_LAYER_ID_SHIFT);
+ layer_id = pid + (WINDOWMANAGER_LAYER_APPLICATIONS * 100000); /* for debug */
+
+ return layer_id;
+}
- // homescreen app always fullscreen in the back
- ilm_surfaceSetDestinationRectangle(surfaceId, 0, 0, m_screenWidth, m_screenHeight);
- //ilm_surfaceSetSourceRectangle(surfaceId, 0, 0, m_screenWidth, m_screenHeight);
- ilm_surfaceSetOpacity(surfaceId, 1.0);
- ilm_surfaceSetVisibility(surfaceId, ILM_TRUE);
+void WindowManager::addSurface(t_ilm_surface surfaceId)
+{
+ struct ilmSurfaceProperties surfaceProperties;
+ pid_t pid;
- ilm_layerAddSurface(layerId, surfaceId);
+ ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
+ pid = surfaceProperties.creatorPid;
+
+ QMap<pid_t, t_ilm_surface>::const_iterator i = m_appSurfaces.find(pid);
+ if (i != m_appSurfaces.end() && i.value() == 0) {
+ /* Only the 1st surface is handled by Window Manager */
+ qDebug("This surface (%d) is 1st one for app (%d)", surfaceId, pid);
+ /* update surface id */
+ m_appSurfaces.insert(pid, surfaceId);
+
+ /* this surface should be handled by WindowManager */
+ ilm_surfaceAddNotification(surfaceId, surfaceCallbackFunction_static);
+ ilm_commitChanges();
}
+}
- if (layerId == WINDOWMANAGER_LAYER_APPLICATIONS)
- {
- struct ilmSurfaceProperties surfaceProperties;
- ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
+t_ilm_layer WindowManager::addSurfaceToAppLayer(pid_t pid, int surfaceId)
+{
+ struct ilmSurfaceProperties surfaceProperties;
+ t_ilm_layer layer_id;
+ int found = 0;
- //ilm_surfaceSetDestinationRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
- //ilm_surfaceSetSourceRectangle(surfaceId, 0, 0, surfaceProperties.origSourceWidth, surfaceProperties.origSourceHeight);
- //ilm_surfaceSetOpacity(surfaceId, 0.0);
- //ilm_surfaceSetVisibility(surfaceId, ILM_FALSE);
+ qDebug("-=[addSurfaceToAppLayer]=-");
+ qDebug(" surfaceId %d", surfaceId);
- ilm_layerAddSurface(layerId, surfaceId);
+ if (pid < 0)
+ return 0;
+
+ QMap<pid_t, t_ilm_layer>::const_iterator i = m_appLayers.find(pid);
+ if (i == m_appLayers.end()) {
+ qDebug("No layer found, create new for app(pid=%d)", pid);
+
+ /* not found, create new one */
+ layer_id = getAppLayerID(pid);
+
+ createNewLayer(layer_id);
+ m_appLayers.insert(pid, layer_id);
+ } else {
+ layer_id = i.value();
}
- if (layerId == WINDOWMANAGER_LAYER_HOMESCREEN_OVERLAY)
+ return layer_id;
+}
+
+void WindowManager::addSurfaceToLayer(int surfaceId, int layerId)
+{
+ qDebug("-=[addSurfaceToLayer]=-");
+ qDebug(" surfaceId %d", surfaceId);
+ qDebug(" layerId %d", layerId);
+
+ if (layerId == WINDOWMANAGER_LAYER_HOMESCREEN)
+ {
+ ilm_layerAddSurface(layerId, surfaceId);
+ }
+ else if (layerId == WINDOWMANAGER_LAYER_HOMESCREEN_OVERLAY)
{
struct ilmSurfaceProperties surfaceProperties;
ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
ilm_layerAddSurface(layerId, surfaceId);
}
-
- if (layerId == WINDOWMANAGER_LAYER_POPUP)
+ else if (layerId == WINDOWMANAGER_LAYER_POPUP)
{
struct ilmSurfaceProperties surfaceProperties;
ilm_getPropertiesOfSurface(surfaceId, &surfaceProperties);
//ilm_surfaceSetVisibility(surfaceId, ILM_FALSE);
ilm_layerAddSurface(layerId, surfaceId);
+ } else {
+ return;
}
ilm_commitChanges();
}
+void WindowManager::configureHomeScreenMainSurface(t_ilm_surface surface, t_ilm_int width, t_ilm_int height)
+{
+ // homescreen app always fullscreen in the back
+ ilm_surfaceSetDestinationRectangle(surface, 0, 0,
+ WINDOWMANAGER_HOMESCREEN_WIDTH,
+ WINDOWMANAGER_HOMESCREEN_HEIGHT);
+ ilm_surfaceSetSourceRectangle(surface, 0, 0, width, height);
+ ilm_surfaceSetOpacity(surface, 1.0);
+ ilm_surfaceSetVisibility(surface, ILM_TRUE);
+
+ ilm_commitChanges();
+}
+
+void WindowManager::configureAppSurface(pid_t pid, t_ilm_surface surface, t_ilm_int width, t_ilm_int height)
+{
+ /* Dirty hack! cut & paste from HomeScreen/src/layouthandler.cpp */
+ const int SCREEN_WIDTH = 1080;
+ const int SCREEN_HEIGHT = 1920;
+
+ const int TOPAREA_HEIGHT = 218;
+ const int TOPAREA_WIDTH = SCREEN_WIDTH;
+ const int TOPAREA_X = 0;
+ const int TOPAREA_Y = 0;
+ const int MEDIAAREA_HEIGHT = 215;
+ const int MEDIAAREA_WIDTH = SCREEN_WIDTH;
+ const int MEDIAAREA_X = 0;
+ const int MEDIAAREA_Y = SCREEN_HEIGHT - MEDIAAREA_HEIGHT;
+
+ ilm_surfaceSetDestinationRectangle(surface,
+ 0,
+ TOPAREA_HEIGHT,
+ SCREEN_WIDTH,
+ SCREEN_HEIGHT - TOPAREA_HEIGHT - MEDIAAREA_HEIGHT);
+ ilm_surfaceSetSourceRectangle(surface, 0, 0, width, height);
+ ilm_surfaceSetOpacity(surface, 1.0);
+ ilm_surfaceSetVisibility(surface, ILM_TRUE); /* Hack to avoid blank screen when switch apps */
+
+ ilm_commitChanges();
+}
#endif
void WindowManager::updateScreen()
{
qDebug("-=[updateScreen]=-");
-#ifdef HAVE_IVI_LAYERMANAGEMENT_API
+#if 0
+//#ifdef HAVE_IVI_LAYERMANAGEMENT_API
if (-1 != m_currentLayout)
{
// hide all surfaces
ilm_getSurfaceIDsOnLayer(WINDOWMANAGER_LAYER_POPUP, &length, &pArray);
ilm_layerSetRenderOrder(WINDOWMANAGER_LAYER_POPUP, pArray, length);
ilm_commitChanges();
-
- // display layer render order
- t_ilm_layer renderOrder[WINDOWMANAGER_LAYER_NUM];
- renderOrder[0] = WINDOWMANAGER_LAYER_HOMESCREEN;
- renderOrder[1] = WINDOWMANAGER_LAYER_APPLICATIONS;
- renderOrder[2] = WINDOWMANAGER_LAYER_HOMESCREEN_OVERLAY;
- renderOrder[3] = WINDOWMANAGER_LAYER_POPUP;
- ilm_displaySetRenderOrder(0, renderOrder, WINDOWMANAGER_LAYER_NUM);
- ilm_displaySetRenderOrder(1, renderOrder, WINDOWMANAGER_LAYER_NUM);
- ilm_commitChanges();
+#endif
+#ifdef HAVE_IVI_LAYERMANAGEMENT_API
+ if (m_pending_to_show != -1) {
+ qDebug("show pending app (%d)", m_pending_to_show);
+ showAppLayer(m_pending_to_show);
+ } else {
+ // display layer render order
+ t_ilm_layer renderOrder[WINDOWMANAGER_LAYER_NUM];
+ int num_layers = getLayerRenderOrder(renderOrder);
+
+ qDebug("Screen render order %d, %d layers", m_screenId, num_layers);
+ ilm_displaySetRenderOrder(m_screenId, renderOrder, num_layers);
+ ilm_commitChanges();
+ }
#endif
}
if (created)
{
- qDebug("Surface created, ID: %d", id);
- ilm_getPropertiesOfSurface(id, &surfaceProperties);
- qDebug(" origSourceWidth : %d", surfaceProperties.origSourceWidth);
- qDebug(" origSourceHeight: %d", surfaceProperties.origSourceHeight);
-
if (WINDOWMANAGER_HOMESCREEN_MAIN_SURFACE_ID == id)
{
- qDebug("HomeScreen app detected");
- addSurfaceToLayer(id, WINDOWMANAGER_LAYER_HOMESCREEN);
- updateScreen();
+ ilm_surfaceAddNotification(id, surfaceCallbackFunction_static);
+ ilm_commitChanges();
}
else
{
- //addSurfaceToLayer(id, WINDOWMANAGER_LAYER_APPLICATIONS);
-
- m_appSurfaces.append(id);
+ addSurface(id);
}
- ilm_surfaceAddNotification(id, surfaceCallbackFunction_static);
-
- ilm_commitChanges();
}
else
{
qDebug("Surface destroyed, ID: %d", id);
+#if 0
m_appSurfaces.removeAt(m_appSurfaces.indexOf(id));
ilm_surfaceRemoveNotification(id);
ilm_commitChanges();
+#endif
}
}
if (ILM_LAYER == object)
{
qDebug("ILM_NOTIFICATION_VISIBILITY");
surfaceVisibilityChanged(surface, surfaceProperties->visibility);
+ updateScreen();
}
if (ILM_NOTIFICATION_OPACITY & mask)
{
if (ILM_NOTIFICATION_CONTENT_AVAILABLE & mask)
{
qDebug("ILM_NOTIFICATION_CONTENT_AVAILABLE");
- //updateScreen();
}
if (ILM_NOTIFICATION_CONTENT_REMOVED & mask)
{
qDebug("ILM_NOTIFICATION_CONTENT_REMOVED");
+
+ /* application being down */
+ m_appLayers.remove(surfaceProperties->creatorPid);
}
if (ILM_NOTIFICATION_CONFIGURED & mask)
{
qDebug(" surfaceProperties.origSourceWidth: %d", surfaceProperties->origSourceWidth);
qDebug(" surfaceProperties.origSourceHeight: %d", surfaceProperties->origSourceHeight);
- ilm_surfaceSetSourceRectangle(surface,
- 0,
- 0,
- surfaceProperties->origSourceWidth,
- surfaceProperties->origSourceHeight);
-
- ilm_commitChanges();
+ if (surface == WINDOWMANAGER_HOMESCREEN_MAIN_SURFACE_ID) {
+ addSurfaceToLayer(surface, WINDOWMANAGER_LAYER_HOMESCREEN);
+ configureHomeScreenMainSurface(surface, surfaceProperties->origSourceWidth, surfaceProperties->origSourceHeight);
+ } else {
+ ilmErrorTypes result;
+ pid_t pid = surfaceProperties->creatorPid;
+ t_ilm_layer layer = addSurfaceToAppLayer(pid, surface);
+
+ if (layer != 0) {
+ configureAppSurface(pid, surface,
+ surfaceProperties->origSourceWidth,
+ surfaceProperties->origSourceHeight);
+
+ result = ilm_layerAddSurface(layer, surface);
+ if (result != ILM_SUCCESS) {
+ qDebug("ilm_layerAddSurface(%d,%d) failed.", layer, surface);
+ }
+ ilm_commitChanges();
+ }
+ }
updateScreen();
}
}
return m_layouts;
}
+#if 0
QList<int> WindowManager::getAllSurfacesOfProcess(int pid)
{
QList<int> result;
#endif
return result;
}
+#endif
QList<int> WindowManager::getAvailableLayouts(int numberOfAppSurfaces)
{
return result;
}
+#if 0
QList<int> WindowManager::getAvailableSurfaces()
{
qDebug("-=[getAvailableSurfaces]=-");
return m_appSurfaces;
}
+#endif
QString WindowManager::getLayoutName(int layoutId)
{
qDebug("layer %d", layer);
#ifdef HAVE_IVI_LAYERMANAGEMENT_API
- if (0 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_POPUP, ILM_FALSE);
- }
- if (1 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_HOMESCREEN_OVERLAY, ILM_FALSE);
- }
- if (2 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_APPLICATIONS, ILM_FALSE);
- }
- if (3 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_HOMESCREEN, ILM_FALSE);
+ // POPUP=0, HOMESCREEN_OVERLAY=1, APPS=2, HOMESCREEN=3
+ if (layer >= 0 && layer < WINDOWMANAGER_LAYER_NUM) {
+ /* hide target layer */
+ m_showLayers[layer] = 0;
+ if (layer == 2) {
+ /* clear pending flag */
+ m_pending_to_show = -1;
+ }
+
+ t_ilm_layer renderOrder[WINDOWMANAGER_LAYER_NUM];
+ int num_layers = getLayerRenderOrder(renderOrder);
+ ilm_displaySetRenderOrder(m_screenId, renderOrder, num_layers);
+ ilm_commitChanges();
}
- ilm_commitChanges();
#endif
}
qDebug("layer %d", layer);
#ifdef HAVE_IVI_LAYERMANAGEMENT_API
- if (0 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_POPUP, ILM_TRUE);
- }
- if (1 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_HOMESCREEN_OVERLAY, ILM_TRUE);
+ // POPUP=0, HOMESCREEN_OVERLAY=1, APPS=2, HOMESCREEN=3
+ if (layer >= 0 && layer < WINDOWMANAGER_LAYER_NUM) {
+ static const int layer_id_array[] = {
+ WINDOWMANAGER_LAYER_POPUP,
+ WINDOWMANAGER_LAYER_HOMESCREEN_OVERLAY,
+ WINDOWMANAGER_LAYER_APPLICATIONS,
+ WINDOWMANAGER_LAYER_HOMESCREEN,
+ };
+
+ m_showLayers[layer] = layer_id_array[layer];
+
+ t_ilm_layer renderOrder[WINDOWMANAGER_LAYER_NUM];
+ int num_layers = getLayerRenderOrder(renderOrder);
+ ilm_displaySetRenderOrder(m_screenId, renderOrder, num_layers);
+ ilm_commitChanges();
}
- if (2 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_APPLICATIONS, ILM_TRUE);
+#endif
+}
+
+void WindowManager::showAppLayer(int pid)
+{
+ qDebug("-=[showAppLayer]=-");
+ qDebug("pid %d", pid);
+
+ if (pid == -1) {
+ /* nothing to show */
+ return;
}
- if (3 == layer)
- {
- ilm_layerSetVisibility(WINDOWMANAGER_LAYER_HOMESCREEN, ILM_TRUE);
+#ifdef HAVE_IVI_LAYERMANAGEMENT_API
+ /* clear pending flag */
+ m_pending_to_show = -1;
+
+ /* search layer id for application to show */
+ QMap<pid_t, t_ilm_layer>::const_iterator i = m_appLayers.find(pid);
+ QMap<pid_t, t_ilm_surface>::const_iterator j = m_appSurfaces.find(pid);
+
+ if (i != m_appLayers.end()) {
+ m_showLayers[2] = i.value();
+ qDebug("Found layer(%d) to show for app(pid=%d)", m_showLayers[2], pid);
+ } else {
+ /* check if this app is registered */
+ if (j == m_appSurfaces.end()) {
+ qDebug("New app %d", pid);
+ m_appSurfaces.insert(pid, 0); /* register pid only so far */
+ }
+
+ /* Probably app layer hasn't been made yet */
+ m_pending_to_show = pid;
+ /* hide current app once, back to default screen */
+ m_showLayers[2] = 0;
+ qDebug("No layer to show for app(pid=%d)", pid);
}
+ t_ilm_layer renderOrder[WINDOWMANAGER_LAYER_NUM];
+
+ int num_layers = getLayerRenderOrder(renderOrder);
+ ilm_displaySetRenderOrder(m_screenId, renderOrder, num_layers);
ilm_commitChanges();
#endif
}
Code Review / staging / HomeScreen.git / blobdiff