src/hs-clientmanager.cpp

   1 /*
   2  * Copyright (c) 2018 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 #include <algorithm>
  17 #include "hs-clientmanager.h"
  18 #include "hmi-debug.h"
  19
  20 static const char _homescreen[] = "homescreen";
  21
  22 HS_ClientManager* HS_ClientManager::me = nullptr;
  23
  24 static void cbRemoveClientCtxt(void *data)
  25 {
  26     HS_ClientManager::instance()->removeClientCtxt(data);
  27 }
  28
  29 /**
  30  * HS_ClientManager construction function
  31  *
  32  * #### Parameters
  33  *  - Nothing
  34  *
  35  * #### Return
  36  * None
  37  *
  38  */
  39 HS_ClientManager::HS_ClientManager()
  40 {
  41 }
  42
  43 /**
  44  * get instance
  45  *
  46  * #### Parameters
  47  *  - Nothing
  48  *
  49  * #### Return
  50  * HS_ClientManager instance pointer
  51  *
  52  */
  53 HS_ClientManager* HS_ClientManager::instance(void)
  54 {
  55     if(me == nullptr)
  56         me = new HS_ClientManager();
  57
  58     return me;
  59 }
  60
  61 /**
  62  * HS_ClientManager init function
  63  *
  64  * #### Parameters
  65  *  - Nothing
  66  *
  67  * #### Return
  68  * init result
  69  *
  70  */
  71 int HS_ClientManager::init(void)
  72 {
  73     HMI_NOTICE("homescreen-service","called.");
  74 }
  75
  76 /**
  77  * create client's afb_req_context
  78  *
  79  * #### Parameters
  80  *  - appid: app's id
  81  *
  82  * #### Return
  83  * HS_ClientCtxt pointer
  84  *
  85  */
  86 HS_ClientCtxt* HS_ClientManager::createClientCtxt(afb_req_t req, std::string appid)
  87 {
  88     HS_ClientCtxt *ctxt = (HS_ClientCtxt *)afb_req_context_get(req);
  89     if (!ctxt)
  90     {
  91         HMI_NOTICE("homescreen-service", "create new session for %s", appid.c_str());
  92         HS_ClientCtxt *ctxt = new HS_ClientCtxt(appid.c_str());
  93         afb_req_session_set_LOA(req, 1);
  94         afb_req_context_set(req, ctxt, cbRemoveClientCtxt);
  95     }
  96     return ctxt;
  97 }
  98
  99 /**
 100  * add Client
 101  *
 102  * #### Parameters
 103  *  - ctxt: app's id
 104  *
 105  * #### Return
 106  * HS_Client pointer
 107  *
 108  */
 109 HS_Client* HS_ClientManager::addClient(afb_req_t req, std::string appid)
 110 {
 111     return (client_list[appid] = new HS_Client(req, appid));
 112 }
 113
 114 /**
 115  * remove Client
 116  *
 117  * #### Parameters
 118  *  - appid: app's id
 119  *
 120  * #### Return
 121  * None
 122  *
 123  */
 124 void HS_ClientManager::removeClient(std::string appid)
 125 {
 126     delete client_list[appid];
 127     client_list.erase(appid);
 128 }
 129
 130 /**
 131  * remove Client from list
 132  *
 133  * #### Parameters
 134  *  - data: HS_ClientCtxt pointer
 135  *
 136  * #### Return
 137  * None
 138  *
 139  */
 140 void HS_ClientManager::removeClientCtxt(void *data)
 141 {
 142     HS_ClientCtxt *ctxt = (HS_ClientCtxt *)data;
 143     if(ctxt == nullptr)
 144     {
 145         HMI_ERROR("homescreen-service", "data is nullptr");
 146         return;
 147     }
 148
 149     HMI_NOTICE("homescreen-service", "remove app %s", ctxt->id.c_str());
 150     std::lock_guard<std::mutex> lock(this->mtx);
 151     removeClient(ctxt->id);
 152     delete appid2ctxt[ctxt->id];
 153     appid2ctxt.erase(ctxt->id);
 154 }
 155
 156 /**
 157  * tap_shortcut
 158  *
 159  * #### Parameters
 160  *  - request: the request to bindings
 161  *
 162  * #### Return
 163  * result
 164  *
 165  */
 166 int HS_ClientManager::tap_shortcut(afb_req_t request)
 167 {
 168     int ret = 0;
 169     const char* value = afb_req_value(request, _application_id);
 170     if (value) {
 171         HMI_NOTICE("homescreen-service","request params = %s.", value);
 172         std::lock_guard<std::mutex> lock(this->mtx);
 173         auto ip = client_list.find(std::string(value));
 174         if(ip != client_list.end()) {
 175             ip->second->tap_shortcut(value);
 176         }
 177     }
 178     else {
 179         HMI_NOTICE("homescreen-service","Please input application_id");
 180         ret = AFB_EVENT_BAD_REQUEST;
 181     }
 182     return ret;
 183 }
 184
 185 /**
 186  * on_screen_message
 187  *
 188  * #### Parameters
 189  *  - request: the request to bindings
 190  *
 191  * #### Return
 192  * result
 193  *
 194  */
 195 int HS_ClientManager::on_screen_message(afb_req_t request)
 196 {
 197     int ret = 0;
 198     const char* value = afb_req_value(request, _display_message);
 199     if (value) {
 200         HMI_NOTICE("homescreen-service","request params = %s.", value);
 201         std::lock_guard<std::mutex> lock(this->mtx);
 202         for(auto m : client_list) {
 203             m.second->on_screen_message(request, value);
 204         }
 205     }
 206     else {
 207         HMI_NOTICE("homescreen-service","Please input display_message");
 208         ret = AFB_EVENT_BAD_REQUEST;
 209     }
 210     return ret;
 211 }
 212
 213 /**
 214  * on_screen_reply
 215  *
 216  * #### Parameters
 217  *  - request: the request to bindings
 218  *
 219  * #### Return
 220  * result
 221  *
 222  */
 223 int HS_ClientManager::on_screen_reply(afb_req_t request)
 224 {
 225     int ret = 0;
 226     const char* value = afb_req_value(request, _reply_message);
 227     if (value) {
 228       HMI_NOTICE("homescreen-service","request params = %s.", value);
 229       std::lock_guard<std::mutex> lock(this->mtx);
 230       for(auto m : client_list) {
 231         m.second->on_screen_reply(request, value);
 232       }
 233     }
 234     else {
 235         HMI_NOTICE("homescreen-service","Please input reply_message");
 236         ret = AFB_EVENT_BAD_REQUEST;
 237     }
 238     return ret;
 239 }
 240
 241 /**
 242  * subscribe
 243  *
 244  * #### Parameters
 245  *  - request: the request to bindings
 246  *
 247  * #### Return
 248  * result
 249  *
 250  */
 251 int HS_ClientManager::subscribe(afb_req_t request)
 252 {
 253     int ret = 0;
 254     const char *value = afb_req_value(request, "event");
 255     HMI_NOTICE("homescreen-service","value is %s", value);
 256     if(value) {
 257         std::string appid(afb_req_get_application_id(request));
 258         std::lock_guard<std::mutex> lock(this->mtx);
 259
 260         HS_Client* client = nullptr;
 261         auto ip = client_list.find(appid);
 262         if(ip != client_list.end()) {
 263             client = client_list[appid];
 264         }
 265         else {
 266             appid2ctxt[appid] = createClientCtxt(request, appid);
 267             client = addClient(request, appid);
 268         }
 269
 270         if(client->subscribe(request, value) != 0) {
 271             HMI_NOTICE("homescreen-service","subscribe failed");
 272             ret = AFB_REQ_SUBSCRIBE_ERROR;
 273         }
 274     }
 275     else {
 276         HMI_NOTICE("homescreen-service","Please input event name");
 277         ret = AFB_EVENT_BAD_REQUEST;
 278     }
 279     return ret;
 280 }
 281
 282 /**
 283  * unsubscribe
 284  *
 285  * #### Parameters
 286  *  - request: the request to bindings
 287  *
 288  * #### Return
 289  * result
 290  *
 291  */
 292 int HS_ClientManager::unsubscribe(afb_req_t request)
 293 {
 294     const char *value = afb_req_value(request, "event");
 295     HMI_NOTICE("homescreen-service","value is %s", value);
 296     int ret = 0;
 297     if(value) {
 298         std::string appid(afb_req_get_application_id(request));
 299         std::lock_guard<std::mutex> lock(this->mtx);
 300
 301         auto ip = client_list.find(appid);
 302         if(ip != client_list.end()
 303         && ip->second->unsubscribe(request, value) != 0) {
 304             HMI_NOTICE("homescreen-service","unsubscribe failed");
 305             ret = AFB_REQ_UNSUBSCRIBE_ERROR;
 306         }
 307     }
 308     else {
 309         HMI_NOTICE("homescreen-service","Please input event name");
 310         ret = AFB_EVENT_BAD_REQUEST;
 311     }
 312     return ret;
 313 }
 314
 315 /**
 316  * showWindow event
 317  *
 318  * #### Parameters
 319  *  - request : the request
 320  *
 321  * #### Return
 322  * 0 : success
 323  * others : fail
 324  *
 325  */
 326 int HS_ClientManager::showWindow(afb_req_t request)
 327 {
 328     int ret = 0;
 329     const char* value = afb_req_value(request, _application_id);
 330     if (value) {
 331         HMI_NOTICE("homescreen-service","request params = %s.", value);
 332         std::lock_guard<std::mutex> lock(this->mtx);
 333         auto ip = client_list.find(std::string(value));
 334         if(ip != client_list.end()) {
 335             ret = ip->second->showWindow(request, value);
 336         }
 337     }
 338     else {
 339         HMI_NOTICE("homescreen-service","Please input application_id");
 340         ret = AFB_EVENT_BAD_REQUEST;
 341     }
 342     return ret;
 343 }
 344
 345 /**
 346  * hideWindow event
 347  *
 348  * #### Parameters
 349  *  - request : the request
 350  *
 351  * #### Return
 352  * 0 : success
 353  * others : fail
 354  *
 355  */
 356 int HS_ClientManager::hideWindow(afb_req_t request)
 357 {
 358     int ret = 0;
 359     const char* value = afb_req_value(request, _application_id);
 360     if (value) {
 361         HMI_NOTICE("homescreen-service","request params = %s.", value);
 362         std::lock_guard<std::mutex> lock(this->mtx);
 363         auto ip = client_list.find(std::string(value));
 364         if(ip != client_list.end()) {
 365             ret = ip->second->hideWindow(request);
 366         }
 367     }
 368     else {
 369         HMI_NOTICE("homescreen-service","Please input application_id");
 370         ret = AFB_EVENT_BAD_REQUEST;
 371     }
 372     return ret;
 373 }
 374
 375 /**
 376  * replyShowWindow event
 377  *
 378  * #### Parameters
 379  *  - request : the request
 380  *
 381  * #### Return
 382  * 0 : success
 383  * others : fail
 384  *
 385  */
 386 int HS_ClientManager::replyShowWindow(afb_req_t request)
 387 {
 388     int ret = 0;
 389     const char* value = afb_req_value(request, _application_id);
 390     if (value) {
 391         HMI_NOTICE("homescreen-service","request params = %s.", value);
 392         std::lock_guard<std::mutex> lock(this->mtx);
 393         auto ip = client_list.find(std::string(value));
 394         if(ip != client_list.end()) {
 395             ret = ip->second->replyShowWindow(request, value);
 396         }
 397     }
 398     else {
 399         HMI_NOTICE("homescreen-service","Please input application_id");
 400         ret = AFB_EVENT_BAD_REQUEST;
 401     }
 402     return ret;
 403 }
 404
 405 /**
 406  * showNotification event
 407  *
 408  * #### Parameters
 409  *  - request : the request
 410  *
 411  * #### Return
 412  * 0 : success
 413  * others : fail
 414  *
 415  */
 416 int HS_ClientManager::showNotification(afb_req_t request)
 417 {
 418     int ret = 0;
 419     std::lock_guard<std::mutex> lock(this->mtx);
 420     auto ip = client_list.find(_homescreen);
 421     if(ip != client_list.end()) {
 422         ret = ip->second->showNotification(request);
 423     }
 424     else {
 425         HMI_NOTICE("homescreen-service","not exist sessiion with homescreen");
 426         ret = AFB_REQ_SHOWNOTIFICATION_ERROR;
 427     }
 428
 429     return ret;
 430 }
 431
 432 /**
 433  * showInformation event
 434  *
 435  * #### Parameters
 436  *  - request : the request
 437  *
 438  * #### Return
 439  * 0 : success
 440  * others : fail
 441  *
 442  */
 443 int HS_ClientManager::showInformation(afb_req_t request)
 444 {
 445     int ret = 0;
 446     std::lock_guard<std::mutex> lock(this->mtx);
 447     auto ip = client_list.find(_homescreen);
 448     if(ip != client_list.end()) {
 449         ret = ip->second->showInformation(request);
 450     }
 451     else {
 452         HMI_NOTICE("homescreen-service","not exist sessiion with homescreen");
 453         ret = AFB_REQ_SHOWINFORMATION_ERROR;
 454     }
 455
 456     return ret;
 457 }