HomeScreenBinding
hs-clientmanager.cpp
Go to the documentation of this file.
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 {
27 }
28 
40 {
41 }
42 
54 {
55  if(me == nullptr)
56  me = new HS_ClientManager();
57 
58  return me;
59 }
60 
72 {
73  HMI_NOTICE("homescreen-service","called.");
74 }
75 
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 
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 
124 void HS_ClientManager::removeClient(std::string appid)
125 {
126  delete client_list[appid];
127  client_list.erase(appid);
128 }
129 
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 
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 
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 
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 
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");
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 
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");
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 
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 
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 
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 
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");
427  }
428 
429  return ret;
430 }
431 
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");
454  }
455 
456  return ret;
457 }
int subscribe(afb_req_t request, const char *event)
Definition: hs-client.cpp:139
int hideWindow(afb_req_t request)
int subscribe(afb_req_t request)
int tap_shortcut(afb_req_t request)
#define AFB_REQ_SHOWNOTIFICATION_ERROR
Definition: hs-helper.h:26
const char _reply_message[]
Definition: homescreen.cpp:30
int on_screen_reply(afb_req_t request)
#define HMI_NOTICE(prefix, args,...)
Definition: hmi-debug.h:40
int showWindow(afb_req_t request)
struct HS_ClientCtxt HS_ClientCtxt
int unsubscribe(afb_req_t request)
static const char _homescreen[]
int replyShowWindow(afb_req_t request)
const char _display_message[]
Definition: homescreen.cpp:29
void removeClientCtxt(void *data)
static HS_ClientManager * instance(void)
static void cbRemoveClientCtxt(void *data)
std::string id
#define AFB_REQ_UNSUBSCRIBE_ERROR
Definition: hs-helper.h:25
int showInformation(afb_req_t request)
#define HMI_ERROR(prefix, args,...)
Definition: hmi-debug.h:38
int on_screen_message(afb_req_t request)
const char _application_id[]
Definition: homescreen.cpp:28
#define AFB_EVENT_BAD_REQUEST
Definition: hs-helper.h:23
int showNotification(afb_req_t request)
#define AFB_REQ_SUBSCRIBE_ERROR
Definition: hs-helper.h:24
#define AFB_REQ_SHOWINFORMATION_ERROR
Definition: hs-helper.h:27