HomeScreen/src/layouthandler.cpp

   1 #include "layouthandler.h"
   2 #include <QTimerEvent>
   3
   4 LayoutHandler::LayoutHandler(QObject *parent) :
   5     QObject(parent),
   6     m_secondsTimerId(-1),
   7     mp_dBusWindowManagerProxy(0),
   8     mp_dBusPopupProxy(0),
   9     m_visibleSurfaces(),
  10     m_invisibleSurfaces(),
  11     m_requestsToBeVisibleSurfaces()
  12 {
  13     qDBusRegisterMetaType<SimplePoint>();
  14     qDBusRegisterMetaType<QList<SimplePoint> >();
  15     qDBusRegisterMetaType<LayoutArea>();
  16     qDBusRegisterMetaType<QList<LayoutArea> >();
  17     qDBusRegisterMetaType<Layout>();
  18     qDBusRegisterMetaType<QList<Layout> >();
  19
  20     qDebug("D-Bus: connect to org.agl.windowmanager /windowmanager");
  21     mp_dBusWindowManagerProxy = new org::agl::windowmanager("org.agl.windowmanager",
  22                                               "/windowmanager",
  23                                               QDBusConnection::sessionBus(),
  24                                               0);
  25     qDebug("D-Bus: connect to org.agl.homescreen /Popup");
  26     mp_dBusPopupProxy = new org::agl::popup("org.agl.homescreen",
  27                                               "/Popup",
  28                                               QDBusConnection::sessionBus(),
  29                                               0);
  30
  31     QDBusConnection::sessionBus().connect("org.agl.windowmanager",
  32                                        "/windowmanager",
  33                                        "org.agl.windowmanager",
  34                                        "surfaceVisibilityChanged",
  35                                        this,
  36                                        SIGNAL(surfaceVisibilityChanged(int,bool)));
  37
  38     QList<LayoutArea> surfaceAreas;
  39     LayoutArea surfaceArea;
  40
  41     const int SCREEN_WIDTH = 1080;
  42     const int SCREEN_HEIGHT = 1920;
  43
  44     const int TOPAREA_HEIGHT = 218;
  45     const int TOPAREA_WIDTH = SCREEN_WIDTH;
  46     const int TOPAREA_X = 0;
  47     const int TOPAREA_Y = 0;
  48     const int MEDIAAREA_HEIGHT = 215;
  49     const int MEDIAAREA_WIDTH = SCREEN_WIDTH;
  50     const int MEDIAAREA_X = 0;
  51     const int MEDIAAREA_Y = SCREEN_HEIGHT - MEDIAAREA_HEIGHT;
  52
  53
  54     // only one Layout for CES2017 needed
  55     // layout 1:
  56     // one app surface, statusbar, control bar
  57     surfaceArea.x = 0;
  58     surfaceArea.y = TOPAREA_HEIGHT;
  59     surfaceArea.width = SCREEN_WIDTH;
  60     surfaceArea.height = SCREEN_HEIGHT - TOPAREA_HEIGHT - MEDIAAREA_HEIGHT;
  61
  62     surfaceAreas.append(surfaceArea);
  63
  64     mp_dBusWindowManagerProxy->addLayout(1, "one app", surfaceAreas);
  65 }
  66
  67 LayoutHandler::~LayoutHandler()
  68 {
  69     delete mp_dBusPopupProxy;
  70     delete mp_dBusWindowManagerProxy;
  71 }
  72
  73 void LayoutHandler::showAppLayer(int pid)
  74 {
  75     mp_dBusWindowManagerProxy->showAppLayer(pid);
  76 }
  77
  78 void LayoutHandler::hideAppLayer()
  79 {
  80     // POPUP=0, HOMESCREEN_OVERLAY=1, APPS=2, HOMESCREEN=3
  81     mp_dBusWindowManagerProxy->hideLayer(2); // TODO: enum
  82 }
  83
  84 void LayoutHandler::makeMeVisible(int pid)
  85 {
  86     qDebug("makeMeVisible %d", pid);
  87
  88 #if 0
  89     // if app does not request to be visible
  90     if (-1 == m_requestsToBeVisiblePids.indexOf(pid))
  91     {
  92         m_requestsToBeVisiblePids.append(pid);
  93
  94         // callback every second
  95         if (-1 != m_secondsTimerId)
  96         {
  97             killTimer(m_secondsTimerId);
  98             m_secondsTimerId = -1;
  99         }
 100         m_secondsTimerId = startTimer(1000);
 101     }
 102     else
 103     {
 104         checkToDoQueue();
 105     }
 106 #endif
 107 }
 108
 109 void LayoutHandler::checkToDoQueue()
 110 {
 111 #if 0
 112     if ((-1 != m_secondsTimerId) && (0 == m_requestsToBeVisiblePids.size()))
 113     {
 114         killTimer(m_secondsTimerId);
 115         m_secondsTimerId = -1;
 116     }
 117
 118     if (0 != m_requestsToBeVisiblePids.size())
 119     {
 120         int pid = m_requestsToBeVisiblePids.at(0);
 121         qDebug("pid %d wants to be visible", pid);
 122
 123         QList<int> allSurfaces;
 124         allSurfaces = mp_dBusWindowManagerProxy->getAllSurfacesOfProcess(pid);
 125         if (0 == allSurfaces.size())
 126         {
 127             qDebug("no surfaces for pid %d. retrying!", pid);
 128         }
 129         else
 130         {
 131             m_requestsToBeVisiblePids.removeAt(0);
 132             qSort(allSurfaces);
 133
 134             if (0 != allSurfaces.size())
 135             {
 136                 int firstSurface = allSurfaces.at(0);
 137
 138                 if (-1 != m_visibleSurfaces.indexOf(firstSurface))
 139                 {
 140                     qDebug("already visible");
 141                 }
 142                 else
 143                 {
 144                     if (-1 != m_invisibleSurfaces.indexOf(firstSurface))
 145                     {
 146                         m_invisibleSurfaces.removeAt(m_invisibleSurfaces.indexOf(firstSurface));
 147                     }
 148                     if (-1 == m_requestsToBeVisibleSurfaces.indexOf(firstSurface))
 149                     {
 150                         m_requestsToBeVisibleSurfaces.append(firstSurface);
 151                     }
 152
 153                     qDebug("before");
 154                     qDebug(" m_visibleSurfaces %d", m_visibleSurfaces.size());
 155                     qDebug(" m_invisibleSurfaces %d", m_invisibleSurfaces.size());
 156                     qDebug(" m_requestsToBeVisibleSurfaces %d", m_requestsToBeVisibleSurfaces.size());
 157
 158                     QList<int> availableLayouts = mp_dBusWindowManagerProxy->getAvailableLayouts(1); // one app only for CES2017
 159                     if (1 == availableLayouts.size())
 160                     {
 161                         qDebug("active layout: %d", availableLayouts.at(0));
 162                         m_invisibleSurfaces.append(m_visibleSurfaces);
 163                         m_visibleSurfaces.clear();
 164                         m_visibleSurfaces.append(m_requestsToBeVisibleSurfaces);
 165                         m_requestsToBeVisibleSurfaces.clear();
 166
 167                         mp_dBusWindowManagerProxy->setLayoutById(availableLayouts.at(0));
 168                         for (int i = 0; i < m_visibleSurfaces.size(); ++i)
 169                         {
 170                             mp_dBusWindowManagerProxy->setSurfaceToLayoutArea(m_visibleSurfaces.at(i), i);
 171                         }
 172
 173                         qDebug("after");
 174                         qDebug(" m_visibleSurfaces %d", m_visibleSurfaces.size());
 175                         qDebug(" m_invisibleSurfaces %d", m_invisibleSurfaces.size());
 176                         qDebug(" m_requestsToBeVisibleSurfaces %d", m_requestsToBeVisibleSurfaces.size());
 177                     }
 178                     else
 179                     {
 180                         qDebug("this should not happen!?");
 181                     }
 182                 }
 183             }
 184         }
 185     }
 186 #endif
 187 }
 188
 189 #if 0
 190 QList<int> LayoutHandler::requestGetAllSurfacesOfProcess(int pid)
 191 {
 192     qDebug("requestGetAllSurfacesOfProcess %d", pid);
 193
 194     return mp_dBusWindowManagerProxy->getAllSurfacesOfProcess(pid);
 195 }
 196 #endif
 197
 198 int LayoutHandler::requestGetSurfaceStatus(int surfaceId)
 199 {
 200     int result = -1;
 201
 202     if (-1 != m_visibleSurfaces.indexOf(surfaceId))
 203     {
 204         result = 0;
 205     }
 206     if (-1 != m_invisibleSurfaces.indexOf(surfaceId))
 207     {
 208         result = 1;
 209     }
 210     if (-1 != m_requestsToBeVisibleSurfaces.indexOf(surfaceId))
 211     {
 212         result = 1;
 213     }
 214
 215     return result;
 216 }
 217
 218 void LayoutHandler::requestRenderSurfaceToArea(int surfaceId, int layoutArea)
 219 {
 220     qDebug("requestRenderSurfaceToArea %d %d", surfaceId, layoutArea);
 221 }
 222
 223 bool LayoutHandler::requestRenderSurfaceToAreaAllowed(int surfaceId, int layoutArea)
 224 {
 225     qDebug("requestRenderSurfaceToAreaAllowed %d %d", surfaceId, layoutArea);
 226     bool result = true;
 227     return result;
 228 }
 229
 230 void LayoutHandler::requestSurfaceIdToFullScreen(int surfaceId)
 231 {
 232     qDebug("requestSurfaceIdToFullScreen %d", surfaceId);
 233 }
 234
 235 void LayoutHandler::setLayoutByName(QString layoutName)
 236 {
 237     // switch to new layout
 238     qDebug("setLayout: switch to new layout %s", layoutName.toStdString().c_str());
 239     m_visibleSurfaces.append(m_requestsToBeVisibleSurfaces);
 240     m_requestsToBeVisibleSurfaces.clear();
 241
 242     mp_dBusWindowManagerProxy->setLayoutByName(layoutName);
 243     for (int i = 0; i < m_visibleSurfaces.size(); ++i)
 244     {
 245         mp_dBusWindowManagerProxy->setSurfaceToLayoutArea(i, i);
 246     }
 247 }
 248
 249 void LayoutHandler::requestSurfaceVisibilityChanged(int surfaceId, bool visible)
 250 {
 251     qDebug("requestSurfaceVisibilityChanged %d %s", surfaceId, visible ? "true" : "false");
 252     emit surfaceVisibilityChanged(surfaceId, visible);
 253 }
 254
 255 void LayoutHandler::timerEvent(QTimerEvent *e)
 256 {
 257     if (e->timerId() == m_secondsTimerId)
 258     {
 259         checkToDoQueue();
 260     }
 261 }
 262