src/homescreen.cpp

   1 /*
   2  * Copyright (c) 2017 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 #ifndef _GNU_SOURCE
  18 #define _GNU_SOURCE
  19 #endif
  20 #include <memory>
  21 #include <algorithm>
  22 #include "hs-helper.h"
  23 #include "hmi-debug.h"
  24 #include "hs-clientmanager.h"
  25 #include "hs-periphery.h"
  26
  27
  28 const char _error[] = "error";
  29 const char _application_id[] = "application_id";
  30 const char _display_message[] = "display_message";
  31 const char _reply_message[] = "reply_message";
  32
  33 struct hs_instance {
  34   HS_ClientManager *client_manager;   // the connection session manager
  35   HS_PeripheryManager *periphery_manager; // the periphery application manager
  36
  37   hs_instance() : client_manager(HS_ClientManager::instance()), periphery_manager(HS_PeripheryManager::instance()) {}
  38   int init(afb_api_t api);
  39 };
  40
  41 /**
  42  * init function
  43  *
  44  * #### Parameters
  45  * - api : the api serving the request
  46  *
  47  * #### Return
  48  * 0 : init success
  49  * 1 : init fail
  50  *
  51  */
  52 int hs_instance::init(afb_api_t api)
  53 {
  54     if(client_manager == nullptr) {
  55         HMI_ERROR("homescreen-service","FATAL ERROR: client_manager is nullptr.");
  56         return -1;
  57     }
  58     client_manager->init();
  59
  60     if(periphery_manager == nullptr) {
  61         HMI_ERROR("homescreen-service","FATAL ERROR: periphery_manager is nullptr.");
  62         return -1;
  63     }
  64     periphery_manager->init(api);
  65
  66     return 0;
  67 }
  68
  69 static struct hs_instance *g_hs_instance;
  70 // static HS_ClientManager* g_client_manager = HS_ClientManager::instance();
  71
  72 /*
  73 ********** Method of HomeScreen Service (API) **********
  74 */
  75
  76 static void pingSample(afb_req_t request)
  77 {
  78    static int pingcount = 0;
  79    afb_req_success_f(request, json_object_new_int(pingcount), "Ping count = %d", pingcount);
  80    HMI_NOTICE("homescreen-service","Verbosity macro at level notice invoked at ping invocation count = %d", pingcount);
  81    pingcount++;
  82 }
  83
  84 /**
  85  * tap_shortcut notify for homescreen
  86  * When Shortcut area is tapped,  notify these applciations
  87  *
  88  * #### Parameters
  89  * Request key
  90  * - application_id   : application id
  91  *
  92  * #### Return
  93  * None
  94  *
  95  */
  96 static void tap_shortcut (afb_req_t request)
  97 {
  98     HMI_NOTICE("homescreen-service","called.");
  99     int ret = 0;
 100     const char* value = afb_req_value(request, _application_id);
 101     if (value) {
 102         HMI_NOTICE("homescreen-service","request appid = %s.", value);
 103         ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
 104     }
 105     else {
 106         ret = AFB_EVENT_BAD_REQUEST;
 107     }
 108
 109     if (ret) {
 110         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 111     }
 112     else {
 113         struct json_object *res = json_object_new_object();
 114         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 115           _error,  ret);
 116         afb_req_success(request, res, "afb_event_push event [tap_shortcut]");
 117     }
 118 }
 119
 120 /**
 121  * HomeScreen OnScreen message
 122  *
 123  * #### Parameters
 124  * Request key
 125  * - display_message   : message for display
 126  *
 127  * #### Return
 128  * None
 129  *
 130  */
 131 static void on_screen_message (afb_req_t request)
 132 {
 133     HMI_NOTICE("homescreen-service","called.");
 134     int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__);
 135     if (ret) {
 136         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 137     }
 138     else {
 139         struct json_object *res = json_object_new_object();
 140         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 141           _error,  ret);
 142         afb_req_success(request, res, "afb_event_push event [on_screen_message]");
 143     }
 144 }
 145
 146 /**
 147  * HomeScreen OnScreen Reply
 148  *
 149  * #### Parameters
 150  * Request key
 151  * - reply_message   : message for reply
 152  *
 153  * #### Return
 154  * None
 155  *
 156  */
 157 static void on_screen_reply (afb_req_t request)
 158 {
 159     HMI_NOTICE("homescreen-service","called.");
 160     int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__);
 161     if (ret) {
 162         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 163     }
 164     else {
 165         struct json_object *res = json_object_new_object();
 166         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 167           _error,  ret);
 168         afb_req_success(request, res, "afb_event_push event [on_screen_reply]");
 169     }
 170 }
 171
 172 /**
 173  * Subscribe event
 174  *
 175  * #### Parameters
 176  *  - event  : Event name. Event list is written in libhomescreen.cpp
 177  *
 178  * #### Return
 179  * None
 180  *
 181  */
 182 static void subscribe(afb_req_t request)
 183 {
 184     HMI_NOTICE("homescreen-service","called.");
 185     int ret = 0;
 186     std::string req_appid = std::move(get_application_id(request));
 187     if(!req_appid.empty()) {
 188         ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, req_appid.c_str());
 189     }
 190     else {
 191         ret = AFB_EVENT_BAD_REQUEST;
 192     }
 193
 194     if(ret) {
 195         afb_req_fail_f(request, "afb_req_subscribe failed", "called %s.", __FUNCTION__);
 196     }
 197     else {
 198         struct json_object *res = json_object_new_object();
 199         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 200             _error, ret);
 201         afb_req_success_f(request, res, "homescreen binder subscribe.");
 202     }
 203 }
 204
 205 /**
 206  * Unsubscribe event
 207  *
 208  * #### Parameters
 209  *  - event  : Event name. Event list is written in libhomescreen.cpp
 210  *
 211  * #### Return
 212  * None
 213  *
 214  */
 215 static void unsubscribe(afb_req_t request)
 216 {
 217     HMI_NOTICE("homescreen-service","called.");
 218     int ret = 0;
 219     std::string req_appid = std::move(get_application_id(request));
 220     if(!req_appid.empty()) {
 221         ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, req_appid.c_str());
 222     }
 223     else {
 224         ret = AFB_EVENT_BAD_REQUEST;
 225     }
 226
 227     if(ret) {
 228         afb_req_fail_f(request, "afb_req_unsubscribe failed", "called %s.", __FUNCTION__);
 229     }
 230     else {
 231         struct json_object *res = json_object_new_object();
 232         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 233             _error, ret);
 234         afb_req_success_f(request, res, "homescreen binder unsubscribe success.");
 235     }
 236 }
 237
 238 /**
 239  * showWindow event
 240  *
 241  * #### Parameters
 242  *  - request : the request
 243  *
 244  * #### Return
 245  * None
 246  *
 247  */
 248 static void showWindow(afb_req_t request)
 249 {
 250     HMI_NOTICE("homescreen-service","called.");
 251     int ret = 0;
 252     const char* value = afb_req_value(request, _application_id);
 253     if (value) {
 254         ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
 255     }
 256     else {
 257         ret = AFB_EVENT_BAD_REQUEST;
 258     }
 259
 260     if (ret) {
 261         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 262     }
 263     else {
 264         struct json_object *res = json_object_new_object();
 265         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 266           _error,  ret);
 267         afb_req_success(request, res, "afb_event_push event [showWindow]");
 268     }
 269 }
 270
 271 /**
 272  * hideWindow event
 273  *
 274  * #### Parameters
 275  *  - request : the request
 276  *
 277  * #### Return
 278  * None
 279  *
 280  */
 281 static void hideWindow(afb_req_t request)
 282 {
 283     HMI_NOTICE("homescreen-service","called.");
 284     int ret = 0;
 285     const char* value = afb_req_value(request, _application_id);
 286     if (value) {
 287         ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
 288     }
 289     else {
 290         ret = AFB_EVENT_BAD_REQUEST;
 291     }
 292
 293     if (ret) {
 294         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 295     }
 296     else {
 297         struct json_object *res = json_object_new_object();
 298         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 299           _error,  ret);
 300         afb_req_success(request, res, "afb_event_push event [hideWindow]");
 301     }
 302 }
 303
 304 /**
 305  * replyShowWindow event
 306  *
 307  * #### Parameters
 308  *  - request : the request
 309  *
 310  * #### Return
 311  *  None
 312  *
 313  */
 314 static void replyShowWindow(afb_req_t request)
 315 {
 316     HMI_NOTICE("homescreen-service","called.");
 317     int ret = 0;
 318     const char* value = afb_req_value(request, _application_id);
 319     if (value) {
 320         ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, value);
 321     }
 322     else {
 323         ret = AFB_EVENT_BAD_REQUEST;
 324     }
 325
 326     if (ret) {
 327         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 328     }
 329     else {
 330         struct json_object *res = json_object_new_object();
 331         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 332           _error,  ret);
 333         afb_req_success(request, res, "afb_event_push event [replyShowWindow]");
 334     }
 335 }
 336
 337 /**
 338  * showNotification event
 339  *
 340  * the contents to homescreen which display at top area.
 341  *
 342  * #### Parameters
 343  *  - request : the request
 344  *
 345  * #### Return
 346  * None
 347  *
 348  */
 349 static void showNotification(afb_req_t request)
 350 {
 351     HMI_NOTICE("homescreen-service","called.");
 352     int ret = g_hs_instance->client_manager->handleRequest(request, __FUNCTION__, "homescreen");
 353     if (ret) {
 354         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 355     }
 356     else {
 357         struct json_object *res = json_object_new_object();
 358         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 359           _error,  ret);
 360         afb_req_success(request, res, "afb_event_push event [showNotification]");
 361     }
 362 }
 363
 364 /**
 365  * showInformation event
 366  *
 367  * the contents to homescreen which display at bottom area.
 368  *
 369  * #### Parameters
 370  *  - request : the request
 371  *
 372  * #### Return
 373  * None
 374  *
 375  */
 376 static void showInformation(afb_req_t request)
 377 {
 378     HMI_NOTICE("homescreen-service","called.");
 379     int ret = g_hs_instance->client_manager->handleRequest(request,  __FUNCTION__, "homescreen");
 380     if (ret) {
 381         afb_req_fail_f(request, "failed", "called %s, Unknown parameter", __FUNCTION__);
 382     }
 383     else {
 384         struct json_object *res = json_object_new_object();
 385         hs_add_object_to_json_object_func(res, __FUNCTION__, 2,
 386           _error,  ret);
 387         afb_req_success(request, res, "afb_event_push event [showInformation]");
 388     }
 389 }
 390
 391 /*
 392  * array of the verbs exported to afb-daemon
 393  */
 394 static const afb_verb_t verbs[]= {
 395     /* VERB'S NAME                 FUNCTION TO CALL                  */
 396     { .verb="ping",              .callback=pingSample             },
 397     { .verb="tap_shortcut",      .callback=tap_shortcut           },
 398     { .verb="showWindow",        .callback=showWindow             },
 399     { .verb="hideWindow",        .callback=hideWindow             },
 400     { .verb="replyShowWindow",   .callback=replyShowWindow        },
 401     { .verb="on_screen_message", .callback=on_screen_message      },
 402     { .verb="on_screen_reply",   .callback=on_screen_reply        },
 403     { .verb="subscribe",         .callback=subscribe              },
 404     { .verb="unsubscribe",       .callback=unsubscribe            },
 405     { .verb="showNotification",  .callback=showNotification       },
 406     { .verb="showInformation",   .callback=showInformation        },
 407     {NULL } /* marker for end of the array */
 408 };
 409
 410 /**
 411  * homescreen binding preinit function
 412  *
 413  * #### Parameters
 414  *  - api : the api serving the request
 415  *
 416  * #### Return
 417  * None
 418  *
 419  */
 420 static int preinit(afb_api_t api)
 421 {
 422    HMI_NOTICE("homescreen-service","binding preinit (was register)");
 423    return 0;
 424 }
 425
 426 /**
 427  * homescreen binding init function
 428  *
 429  * #### Parameters
 430  *  - api : the api serving the request
 431  *
 432  * #### Return
 433  * None
 434  *
 435  */
 436 static int init(afb_api_t api)
 437 {
 438     HMI_NOTICE("homescreen-service","binding init");
 439
 440     // g_client_manager->init();
 441     if(g_hs_instance != nullptr) {
 442         HMI_WARNING("homescreen-service", "g_hs_instance isn't null.");
 443         delete g_hs_instance->client_manager;
 444         delete g_hs_instance->periphery_manager;
 445         delete g_hs_instance;
 446         g_hs_instance = nullptr;
 447     }
 448     g_hs_instance = new hs_instance();
 449     if(g_hs_instance == nullptr) {
 450         HMI_ERROR("homescreen-service", "Fatal Error: new g_hs_instance failed.");
 451         return -1;
 452     }
 453
 454     return g_hs_instance->init(api);
 455 }
 456
 457 /**
 458  * homescreen binding event function
 459  *
 460  * #### Parameters
 461  *  - api : the api serving the request
 462  *  - event  : event name
 463  *  - object : event json object
 464  *
 465  * #### Return
 466  * None
 467  *
 468  */
 469 static void onevent(afb_api_t api, const char *event, struct json_object *object)
 470 {
 471    HMI_NOTICE("homescreen-service","on_event %s", event);
 472    g_hs_instance->periphery_manager->onEvent(api, event, object);
 473 }
 474
 475 const afb_binding_t afbBindingExport = {
 476     .api = "homescreen",
 477     .specification = NULL,
 478     .info = NULL,
 479     .verbs = verbs,
 480     .preinit = preinit,
 481     .init = init,
 482     .onevent = onevent
 483 };