Add gitlab issue/merge request templates
[apps/agl-service-homescreen.git] / src / hs-client.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
17 #include <cstring>
18 #include "hs-client.h"
19 #include "hs-helper.h"
20
21 static const char _event[] = "event";
22 static const char _type[] = "type";
23 static const char _text[] = "text";
24 static const char _info[] = "info";
25 static const char _icon[] = "icon";
26 static const char _parameter[] = "parameter";
27 static const char _replyto[] = "replyto";
28 static const char _caller[] = "caller";
29
30 // homescreen-service event and event handler function list
31 const std::unordered_map<std::string, HS_Client::func_handler> HS_Client::func_list {
32     {"tap_shortcut",        &HS_Client::tap_shortcut},
33     {"showWindow",          &HS_Client::showWindow},
34     {"hideWindow",          &HS_Client::hideWindow},
35     {"replyShowWindow",     &HS_Client::replyShowWindow},
36     {"on_screen_message",   &HS_Client::on_screen_message},
37     {"on_screen_reply",     &HS_Client::on_screen_reply},
38     {"subscribe",           &HS_Client::subscribe},
39     {"unsubscribe",         &HS_Client::unsubscribe},
40     {"showNotification",    &HS_Client::showNotification},
41     {"showInformation",     &HS_Client::showInformation},
42     {"application-list-changed", nullptr}
43 };
44
45 /**
46  * HS_Client construction function
47  *
48  * #### Parameters
49  *  - id: app's id
50  *
51  * #### Return
52  * None
53  *
54  */
55 HS_Client::HS_Client(afb_req_t request, std::string id) : my_id(id)
56 {
57     my_event = afb_api_make_event(request->api, id.c_str());
58 }
59
60 /**
61  * HS_Client destruction function
62  *
63  * #### Parameters
64  *  - null
65  *
66  * #### Return
67  * None
68  *
69  */
70 HS_Client::~HS_Client()
71 {
72     afb_event_unref(my_event);
73 }
74
75 /**
76  * push tap_shortcut event
77  *
78  * #### Parameters
79  *  - request : the request
80  *
81  * #### Return
82  * 0 : success
83  * others : fail
84  *
85  */
86 int HS_Client::tap_shortcut(afb_req_t request)
87 {
88     (void) request;
89
90     AFB_INFO("request appid = %s.", my_id.c_str());
91     struct json_object* push_obj = json_object_new_object();
92     hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(),
93     _type, __FUNCTION__);
94     afb_event_push(my_event, push_obj);
95     return 0;
96 }
97
98 /**
99  * push on_screen_message event
100  *
101  * #### Parameters
102  *  - request : the request
103  *
104  * #### Return
105  * 0 : success
106  * others : fail
107  *
108  */
109 int HS_Client::on_screen_message(afb_req_t request)
110 {
111     int ret = 0;
112     const char* value = afb_req_value(request, _display_message);
113     if (value) {
114         AFB_INFO("push %s event message [%s].", __FUNCTION__, value);
115         struct json_object* push_obj = json_object_new_object();
116         hs_add_object_to_json_object_str( push_obj, 4, _display_message, value,
117         _type, __FUNCTION__);
118         afb_event_push(my_event, push_obj);
119     }
120     else {
121         AFB_WARNING("Please input display_message");
122         ret = AFB_EVENT_BAD_REQUEST;
123     }
124     return ret;
125 }
126
127 /**
128  * push on_screen_reply event
129  *
130  * #### Parameters
131  *  - request : the request
132  *
133  * #### Return
134  * 0 : success
135  * others : fail
136  *
137  */
138 int HS_Client::on_screen_reply(afb_req_t request)
139 {
140     int ret = 0;
141     const char* value = afb_req_value(request, _reply_message);
142     if (value) {
143         AFB_INFO("push %s event message [%s].", __FUNCTION__, value);
144         struct json_object* push_obj = json_object_new_object();
145         hs_add_object_to_json_object_str( push_obj, 4, _reply_message, value,
146         _type, __FUNCTION__);
147         afb_event_push(my_event, push_obj);
148     }
149     else {
150         AFB_WARNING("Please input reply_message");
151         ret = AFB_EVENT_BAD_REQUEST;
152     }
153     return ret;
154 }
155
156 /**
157  * subscribe event
158  *
159  * #### Parameters
160  *  - request : the request
161  *
162  * #### Return
163  * 0 : success
164  * others : fail
165  *
166  */
167 int HS_Client::subscribe(afb_req_t request)
168 {
169     int ret = 0;
170     const char *value = afb_req_value(request, _event);
171     if(value) {
172         AFB_INFO("subscribe event %s", value);
173         if(!isSupportEvent(value)) {
174             AFB_WARNING("subscibe event isn't existing.");
175             ret = AFB_EVENT_BAD_REQUEST;
176         }
177         else {
178             event_list.insert(std::string(value));
179             if(!subscription) {
180                 ret = afb_req_subscribe(request, my_event);
181                 if(ret == 0) {
182                     subscription = true;
183                 }
184             }
185         }
186     }
187     else {
188         AFB_WARNING("Please input event name");
189         ret = AFB_EVENT_BAD_REQUEST;
190     }
191     return ret;
192 }
193
194 /**
195  * unsubscribe event
196  *
197  * #### Parameters
198  *  - request : the request
199  *
200  * #### Return
201  * 0 : success
202  * others : fail
203  *
204  */
205 int HS_Client::unsubscribe(afb_req_t request)
206 {
207     int ret = 0;
208     const char *value = afb_req_value(request, _event);
209     if(value) {
210         AFB_INFO("unsubscribe %s event", value);
211         event_list.erase(std::string(value));
212         if(event_list.empty()) {
213             ret = afb_req_unsubscribe(request, my_event);
214         }
215     }
216     else {
217         AFB_WARNING("Please input event name");
218         ret = AFB_EVENT_BAD_REQUEST;
219     }
220     return ret;
221 }
222
223 /**
224  * showWindow event
225  *
226  * #### Parameters
227  * - request : the request
228  *
229  * #### Return
230  * 0 : success
231  * others : fail
232  *
233  */
234 int HS_Client::showWindow(afb_req_t request)
235 {
236     AFB_INFO("%s application_id = %s.", __FUNCTION__, my_id.c_str());
237     int ret = 0;
238     const char* param = afb_req_value(request, _parameter);
239     if(param) {
240         std::string req_appid = std::move(get_application_id(request));
241         if(req_appid.empty()) {
242             AFB_WARNING("can't get application identifier");
243             return AFB_REQ_GETAPPLICATIONID_ERROR;
244         }
245
246         struct json_object* push_obj = json_object_new_object();
247         hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(), _type, __FUNCTION__);
248         struct json_object* param_obj = json_tokener_parse(param);
249         json_object_object_add(param_obj, _replyto, json_object_new_string(req_appid.c_str()));
250         json_object_object_add(push_obj, _parameter, param_obj);
251         afb_event_push(my_event, push_obj);
252     }
253     else {
254         AFB_WARNING("please input correct parameter.");
255         ret = AFB_EVENT_BAD_REQUEST;
256     }
257     return ret;
258 }
259
260 /**
261  * hideWindow event
262  *
263  * #### Parameters
264  * - request : the request
265  *
266  * #### Return
267  * 0 : success
268  * others : fail
269  *
270  */
271 int HS_Client::hideWindow(afb_req_t request)
272 {
273     std::string req_appid = std::move(get_application_id(request));
274     if(req_appid.empty()) {
275         AFB_WARNING("can't get application identifier");
276         return AFB_REQ_GETAPPLICATIONID_ERROR;
277     }
278
279     struct json_object* push_obj = json_object_new_object();
280     hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(),
281     _type, __FUNCTION__);
282     struct json_object* param_obj = json_object_new_object();
283     json_object_object_add(param_obj, _caller, json_object_new_string(req_appid.c_str()));
284     json_object_object_add(push_obj, _parameter, param_obj);
285     afb_event_push(my_event, push_obj);
286     return 0;
287 }
288
289 /**
290  * replyShowWindow event
291  *
292  * #### Parameters
293  * - request : the request
294  *
295  * #### Return
296  * 0 : success
297  * others : fail
298  *
299  */
300 int HS_Client::replyShowWindow(afb_req_t request)
301 {
302     AFB_INFO("%s application_id = %s.", __FUNCTION__, my_id.c_str());
303     int ret = 0;
304     const char* param = afb_req_value(request, _parameter);
305     if(param) {
306         struct json_object* push_obj = json_object_new_object();
307         hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(), _type, __FUNCTION__);
308         json_object_object_add(push_obj, _parameter, json_tokener_parse(param));
309         afb_event_push(my_event, push_obj);
310     }
311     else {
312         AFB_WARNING("please input correct parameter.");
313         ret = AFB_EVENT_BAD_REQUEST;
314     }
315     return ret;
316 }
317
318 /**
319  * showNotification event
320  *
321  * #### Parameters
322  *  - request : the request
323  *
324  * #### Return
325  * 0 : success
326  * others : fail
327  *
328  */
329 int HS_Client::showNotification(afb_req_t request)
330 {
331     int ret = 0;
332     const char *value = afb_req_value(request, _text);
333     if(value) {
334         AFB_INFO("text is %s", value);
335         std::string appid =std::move(get_application_id(request));
336         if(appid.empty()) {
337             AFB_WARNING("can't get application identifier");
338             return AFB_REQ_GETAPPLICATIONID_ERROR;
339         }
340
341         const char *icon = afb_req_value(request, _icon);
342         if(icon) {
343             struct json_object* param_obj = json_object_new_object();
344             json_object_object_add(param_obj, _icon, json_object_new_string(icon));
345             json_object_object_add(param_obj, _text, json_object_new_string(value));
346             json_object_object_add(param_obj, _caller, json_object_new_string(appid.c_str()));
347             struct json_object* push_obj = json_object_new_object();
348             hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(), _type, __FUNCTION__);
349             json_object_object_add(push_obj, _parameter, param_obj);
350             afb_event_push(my_event, push_obj);
351         }
352         else {
353             AFB_WARNING("please input icon.");
354             ret = AFB_REQ_SHOWNOTIFICATION_ERROR;
355         }
356     }
357     else {
358         AFB_WARNING("please input text.");
359         ret = AFB_REQ_SHOWNOTIFICATION_ERROR;
360     }
361
362     return ret;
363 }
364
365 /**
366  * showInformation event
367  *
368  * #### Parameters
369  *  - request : the request
370  *
371  * #### Return
372  * 0 : success
373  * others : fail
374  *
375  */
376 int HS_Client::showInformation(afb_req_t request)
377 {
378     int ret = 0;
379     const char *value = afb_req_value(request, _info);
380     if(value) {
381         AFB_INFO("info is %s", value);
382         std::string appid = std::move(get_application_id(request));
383         if(appid.empty()) {
384             AFB_WARNING("can't get application identifier");
385             return AFB_REQ_GETAPPLICATIONID_ERROR;
386         }
387
388         struct json_object* param_obj = json_object_new_object();
389         json_object_object_add(param_obj, _info, json_object_new_string(value));
390         struct json_object* push_obj = json_object_new_object();
391         hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(), _type, __FUNCTION__);
392         json_object_object_add(push_obj, _parameter, param_obj);
393         afb_event_push(my_event, push_obj);
394     }
395     else {
396         AFB_WARNING("please input information.");
397         ret = AFB_REQ_SHOWINFORMATION_ERROR;
398     }
399
400     return ret;
401 }
402
403 /**
404  * check if client subscribe event
405  *
406  * #### Parameters
407  *  - event: homescreen event, tap_shortcut etc.
408  *
409  * #### Return
410  * true: found
411  * false: not found
412  *
413  */
414 bool HS_Client::checkEvent(const char* event)
415 {
416     auto ip = event_list.find(std::string(event));
417     if(ip == event_list.end())
418         return false;
419     else
420         return true;
421 }
422
423 /**
424  * check if event is supporting
425  *
426  * #### Parameters
427  *  - event: homescreen event, tap_shortcut etc.
428  *
429  * #### Return
430  * true: support
431  * false: not fosupportund
432  *
433  */
434 bool HS_Client::isSupportEvent(const char* event)
435 {
436     auto ip = func_list.find(std::string(event));
437     if(ip == func_list.end())
438         return false;
439     else
440         return true;
441 }
442
443 /**
444  * handle homescreen event
445  *
446  * #### Parameters
447  *  - request : the request
448  *  - verb: request verb name
449  *
450  * #### Return
451  * 0: success
452  * others: fail
453  *
454  */
455 int HS_Client::handleRequest(afb_req_t request, const char *verb)
456 {
457     if((strcasecmp(verb, "subscribe") && strcasecmp(verb, "unsubscribe")) && !checkEvent(verb))
458         return 0;
459
460     int ret = AFB_EVENT_BAD_REQUEST;
461     auto ip = func_list.find(std::string(verb));
462     if(ip != func_list.end() && ip->second != nullptr) {
463         AFB_INFO("[%s]verb found", verb);
464         ret = (this->*(ip->second))(request);
465     }
466     return ret;
467 }
468
469 /**
470  * push event
471  *
472  * #### Parameters
473  *  - event : the event want to push
474  *  - param : the parameter contents of event
475  *
476  * #### Return
477  * 0 : success
478  * others : fail
479  *
480  */
481 int HS_Client::pushEvent(const char *event, struct json_object *param)
482 {
483     if(!checkEvent(event))
484         return 0;
485
486     AFB_INFO("called, event=%s.",event);
487     struct json_object* push_obj = json_object_new_object();
488     hs_add_object_to_json_object_str( push_obj, 4, _application_id, my_id.c_str(), _type, event);
489     if(param != nullptr)
490         json_object_object_add(push_obj, _parameter, param);
491     afb_event_push(my_event, push_obj);
492     return 0;
493 }