sample/app/eventhandler.cpp

   1 /*
   2  * Copyright (c) 2019 TOYOTA MOTOR CORPORATION
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <functional>
  18 #include <QUrl>
  19 #include <QGuiApplication>
  20 #include <QJsonDocument>
  21 #include <QJsonObject>
  22 #include <QQuickWindow>
  23 #include <QtQml/QQmlContext>
  24 #include <QQmlContext>
  25 #include <QtQml/QQmlApplicationEngine>
  26 #include <qpa/qplatformnativeinterface.h>
  27
  28 #include "eventhandler.h"
  29
  30 static struct wl_output *
  31 getWlOutput(QScreen *screen)
  32 {
  33         QPlatformNativeInterface *native = qApp->platformNativeInterface();
  34         void *output = native->nativeResourceForScreen("output", screen);
  35         return static_cast<struct ::wl_output*>(output);
  36 }
  37
  38 static void
  39 global_add(void *data, struct wl_registry *reg, uint32_t name,
  40            const char *interface, uint32_t version)
  41 {
  42         struct agl_shell_desktop **shell =
  43                 static_cast<struct agl_shell_desktop **>(data);
  44
  45         if (strcmp(interface, agl_shell_desktop_interface.name) == 0) {
  46                 *shell = static_cast<struct agl_shell_desktop *>(
  47                         wl_registry_bind(reg, name, &agl_shell_desktop_interface, version)
  48                 );
  49         }
  50 }
  51
  52 static void global_remove(void *data, struct wl_registry *reg, uint32_t id)
  53 {
  54         (void) data;
  55         (void) reg;
  56         (void) id;
  57 }
  58
  59 static const struct wl_registry_listener registry_listener = {
  60         global_add,
  61         global_remove,
  62 };
  63
  64 static void
  65 application_id_event(void *data, struct agl_shell_desktop *agl_shell_desktop,
  66                 const char *app_id)
  67 {
  68         EventHandler *ev_handler = static_cast<EventHandler *>(data);
  69         (void) agl_shell_desktop;
  70
  71         // should probably add here to a list the application or trigger emit
  72         // for QML code, also note that we get here our own application
  73         if (strcmp(app_id, APP_ID) == 0)
  74                 return;
  75
  76         qInfo() << "app_id: " << app_id;
  77
  78         if (strcmp(app_id, "onescreenapp") == 0)
  79                 emit ev_handler->signalOnReplyShowWindow(app_id);
  80 }
  81
  82 static const struct agl_shell_desktop_listener agl_shell_desk_listener = {
  83         application_id_event,
  84 };
  85
  86 static struct agl_shell_desktop *
  87 register_agl_shell_desktop(void)
  88 {
  89         struct wl_display *wl;
  90         struct wl_registry *registry;
  91         struct agl_shell_desktop *shell = nullptr;
  92
  93         QPlatformNativeInterface *native = qApp->platformNativeInterface();
  94
  95         wl = static_cast<struct wl_display *>(native->nativeResourceForIntegration("display"));
  96         registry = wl_display_get_registry(wl);
  97
  98         wl_registry_add_listener(registry, &registry_listener, &shell);
  99         // Roundtrip to get all globals advertised by the compositor
 100         wl_display_roundtrip(wl);
 101         wl_registry_destroy(registry);
 102
 103         return shell;
 104 }
 105
 106
 107 void* EventHandler::myThis = 0;
 108
 109 const char _drawing_name[] = "drawing_name";
 110
 111 EventHandler::EventHandler(QObject *parent) :
 112     QObject(parent), mp_qw(NULL)
 113 {
 114
 115 }
 116
 117 EventHandler::~EventHandler()
 118 {
 119 #if 0
 120     if (mp_hs != NULL) {
 121         delete mp_hs;
 122     }
 123     if (mp_wm != NULL) {
 124         delete mp_wm;
 125     }
 126 #endif
 127     if (shell_desktop)
 128             agl_shell_desktop_destroy(shell_desktop);
 129 }
 130
 131 void EventHandler::init(int port, const char *token)
 132 {
 133         (void) port;
 134         (void) token;
 135
 136         shell_desktop = register_agl_shell_desktop();
 137         if (shell_desktop)
 138                 agl_shell_desktop_add_listener(shell_desktop, &agl_shell_desk_listener, this);
 139
 140 #if 0
 141     myThis = this;
 142     mp_wm = new QLibWindowmanager();
 143     mp_wm->init(port, token);
 144
 145     mp_hs = new QLibHomeScreen();
 146     mp_hs->init(port, token);
 147
 148     mp_hs->set_event_handler(QLibHomeScreen::Event_ShowWindow, [this](json_object *object){
 149         this->mp_wm->activateWindow(ROLE_NAME, "normal");
 150         HMI_DEBUG(APP_ID, "received showWindow event, end!, line=%d", __LINE__);
 151     });
 152
 153     mp_hs->set_event_handler(QLibHomeScreen::Event_ReplyShowWindow, [this](json_object *object){
 154         HMI_DEBUG(APP_ID, "got Event_ReplyShowWindow!\n");
 155         const char* msg = json_object_to_json_string(object);
 156         emit this->signalOnReplyShowWindow(msg);
 157     });
 158
 159     if (mp_wm->requestSurface(ROLE_NAME) != 0) {
 160         HMI_DEBUG(APP_ID, "!!!!LayoutHandler requestSurface Failed!!!!!");
 161         exit(EXIT_FAILURE);
 162     }
 163
 164     // Create an event callback against an event type. Here a lambda is called when SyncDraw event occurs
 165     mp_wm->set_event_handler(QLibWindowmanager::Event_SyncDraw, [this](json_object *object) {
 166         HMI_DEBUG(APP_ID, "Surface got syncDraw!");
 167         this->mp_wm->endDraw(ROLE_NAME);
 168     });
 169
 170     mp_wm->set_event_handler(QLibWindowmanager::Event_Visible, [this](json_object *object) {
 171         struct json_object *value;
 172         json_object_object_get_ex(object, _drawing_name, &value);
 173         const char *name = json_object_get_string(value);
 174
 175         HMI_DEBUG(APP_ID, "Event_Active kKeyDrawingName = %s", name);
 176     });
 177
 178     mp_wm->set_event_handler(QLibWindowmanager::Event_Invisible, [this](json_object *object) {
 179         struct json_object *value;
 180         json_object_object_get_ex(object, _drawing_name, &value);
 181         const char *name = json_object_get_string(value);
 182
 183         HMI_DEBUG(APP_ID, "Event_Inactive kKeyDrawingName = %s", name);
 184     });
 185
 186     HMI_DEBUG(APP_ID, "LayoutHander::init() finished.");
 187 #endif
 188 }
 189
 190 void EventHandler::setQuickWindow(QQuickWindow *qw)
 191 {
 192     mp_qw = qw;
 193     //QObject::connect(mp_qw, SIGNAL(frameSwapped()), mp_wm, SLOT(slotActivateSurface()));
 194 }
 195
 196 void EventHandler::showWindow(QString id, QString json)
 197 {
 198         if (shell_desktop) {
 199                 struct wl_output *output = getWlOutput(qApp->screens().first());
 200                 agl_shell_desktop_activate_app(shell_desktop, id.toStdString().c_str(), output);
 201         }
 202
 203         qInfo() << "data from json: " << json.toStdString().c_str();
 204 #if 0
 205     if(json.isNull())
 206         mp_hs->tapShortcut(id);
 207     else
 208         mp_hs->showWindow(id.toStdString().c_str(), json_tokener_parse(json.toStdString().c_str()));
 209 #endif
 210 }
 211
 212 void EventHandler::hideWindow(QString id)
 213 {
 214         if (shell_desktop)
 215                 agl_shell_desktop_deactivate_app(shell_desktop, id.toStdString().c_str());
 216 #if 0
 217     mp_hs->hideWindow(id.toStdString().c_str());
 218 #endif
 219 }