X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=doc%2Fapi-ref%2Fhtml%2Fdd%2Fd30%2Fhs-clientmanager_8cpp_source.html;fp=doc%2Fapi-ref%2Fhtml%2Fdd%2Fd30%2Fhs-clientmanager_8cpp_source.html;h=9fd56e9989ab0feeb1365084c53acd48931182cb;hb=31ff5ce755d00cf12ea2ffc96c33ed9acd36358f;hp=0000000000000000000000000000000000000000;hpb=bbb4ee8e9974c4b008da84a1e504120f70606c92;p=apps%2Fagl-service-homescreen.git diff --git a/doc/api-ref/html/dd/d30/hs-clientmanager_8cpp_source.html b/doc/api-ref/html/dd/d30/hs-clientmanager_8cpp_source.html new file mode 100644 index 0000000..9fd56e9 --- /dev/null +++ b/doc/api-ref/html/dd/d30/hs-clientmanager_8cpp_source.html @@ -0,0 +1,133 @@ + + + + + + +HomeScreenBinding: src/hs-clientmanager.cpp Source File + + + + + + + + + + +
+
+ + + + + + +
+
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 {
26  HS_ClientManager::instance()->removeClientCtxt(data);
27 }
28 
39 HS_ClientManager::HS_ClientManager()
40 {
41 }
42 
53 HS_ClientManager* HS_ClientManager::instance(void)
54 {
55  if(me == nullptr)
56  me = new HS_ClientManager();
57 
58  return me;
59 }
60 
71 int HS_ClientManager::init(void)
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 
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 
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 
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 
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");
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 
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 
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 
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 
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 }
HS_Client::subscribe
int subscribe(afb_req_t request, const char *event)
Definition: hs-client.cpp:139
+
HS_ClientManager::init
int init(void)
Definition: hs-clientmanager.cpp:71
+
HS_ClientManager::hideWindow
int hideWindow(afb_req_t request)
Definition: hs-clientmanager.cpp:356
+ +
HS_ClientManager::subscribe
int subscribe(afb_req_t request)
Definition: hs-clientmanager.cpp:251
+
HS_ClientManager::tap_shortcut
int tap_shortcut(afb_req_t request)
Definition: hs-clientmanager.cpp:166
+
AFB_REQ_SHOWNOTIFICATION_ERROR
#define AFB_REQ_SHOWNOTIFICATION_ERROR
Definition: hs-helper.h:26
+
HS_ClientCtxt
Definition: hs-clientmanager.h:27
+
_reply_message
const char _reply_message[]
Definition: homescreen.cpp:30
+
HS_Client
Definition: hs-client.h:25
+
HS_ClientManager::on_screen_reply
int on_screen_reply(afb_req_t request)
Definition: hs-clientmanager.cpp:223
+
HMI_NOTICE
#define HMI_NOTICE(prefix, args,...)
Definition: hmi-debug.h:40
+
HS_ClientManager::showWindow
int showWindow(afb_req_t request)
Definition: hs-clientmanager.cpp:326
+
HS_ClientCtxt
struct HS_ClientCtxt HS_ClientCtxt
+
HS_ClientManager::unsubscribe
int unsubscribe(afb_req_t request)
Definition: hs-clientmanager.cpp:292
+
HS_ClientManager::HS_ClientManager
HS_ClientManager()
Definition: hs-clientmanager.cpp:39
+
_homescreen
static const char _homescreen[]
Definition: hs-clientmanager.cpp:20
+
HS_ClientManager::replyShowWindow
int replyShowWindow(afb_req_t request)
Definition: hs-clientmanager.cpp:386
+
HS_ClientManager
Definition: hs-clientmanager.h:37
+
_display_message
const char _display_message[]
Definition: homescreen.cpp:29
+
HS_ClientManager::removeClientCtxt
void removeClientCtxt(void *data)
Definition: hs-clientmanager.cpp:140
+
HS_ClientManager::instance
static HS_ClientManager * instance(void)
Definition: hs-clientmanager.cpp:53
+
cbRemoveClientCtxt
static void cbRemoveClientCtxt(void *data)
Definition: hs-clientmanager.cpp:24
+
HS_ClientCtxt::id
std::string id
Definition: hs-clientmanager.h:29
+ +
AFB_REQ_UNSUBSCRIBE_ERROR
#define AFB_REQ_UNSUBSCRIBE_ERROR
Definition: hs-helper.h:25
+
HS_ClientManager::showInformation
int showInformation(afb_req_t request)
Definition: hs-clientmanager.cpp:443
+
HMI_ERROR
#define HMI_ERROR(prefix, args,...)
Definition: hmi-debug.h:38
+
HS_ClientManager::on_screen_message
int on_screen_message(afb_req_t request)
Definition: hs-clientmanager.cpp:195
+
_application_id
const char _application_id[]
Definition: homescreen.cpp:28
+
AFB_EVENT_BAD_REQUEST
#define AFB_EVENT_BAD_REQUEST
Definition: hs-helper.h:23
+
HS_ClientManager::showNotification
int showNotification(afb_req_t request)
Definition: hs-clientmanager.cpp:416
+
AFB_REQ_SUBSCRIBE_ERROR
#define AFB_REQ_SUBSCRIBE_ERROR
Definition: hs-helper.h:24
+
AFB_REQ_SHOWINFORMATION_ERROR
#define AFB_REQ_SHOWINFORMATION_ERROR
Definition: hs-helper.h:27
+
+ +
+Generated by   +doxygen + 1.8.11 +
+ +