89b0ae25ce1a591017ab618ad55869c02c7270a1
[apps/agl-service-homescreen.git] / 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
17 #include <cstring>
18 #include <algorithm>
19 #include "hs-clientmanager.h"
20 #include "hs-apprecover.h"
21
22 static const char _homescreen[] = "homescreen";
23
24 HS_ClientManager* HS_ClientManager::me = nullptr;
25
26 static void cbRemoveClientCtxt(void *data)
27 {
28     HS_ClientManager::instance()->removeClientCtxt(data);
29 }
30
31 /**
32  * HS_ClientManager construction function
33  *
34  * #### Parameters
35  *  - Nothing
36  *
37  * #### Return
38  * None
39  *
40  */
41 HS_ClientManager::HS_ClientManager()
42 {
43 }
44
45 /**
46  * get instance
47  *
48  * #### Parameters
49  *  - Nothing
50  *
51  * #### Return
52  * HS_ClientManager instance pointer
53  *
54  */
55 HS_ClientManager* HS_ClientManager::instance(void)
56 {
57     if(me == nullptr)
58         me = new HS_ClientManager();
59
60     return me;
61 }
62
63 /**
64  * HS_ClientManager init function
65  *
66  * #### Parameters
67  *  - Nothing
68  *
69  * #### Return
70  * init result
71  *
72  */
73 int HS_ClientManager::init(void)
74 {
75     AFB_NOTICE("called.");
76 }
77
78 /**
79  * create client's afb_req_context
80  *
81  * #### Parameters
82  *  - appid: app's id
83  *
84  * #### Return
85  * HS_ClientCtxt pointer
86  *
87  */
88 HS_ClientCtxt* HS_ClientManager::createClientCtxt(afb_req_t req, std::string appid)
89 {
90     HS_ClientCtxt *ctxt = (HS_ClientCtxt *)afb_req_context_get(req);
91     if (!ctxt)
92     {
93         AFB_INFO( "create new session for %s", appid.c_str());
94         HS_ClientCtxt *ctxt = new HS_ClientCtxt(appid.c_str());
95         afb_req_session_set_LOA(req, 1);
96         afb_req_context_set(req, ctxt, cbRemoveClientCtxt);
97     }
98     return ctxt;
99 }
100
101 /**
102  * add Client
103  *
104  * #### Parameters
105  *  - ctxt: app's id
106  *
107  * #### Return
108  * HS_Client pointer
109  *
110  */
111 HS_Client* HS_ClientManager::addClient(afb_req_t req, std::string appid)
112 {
113     return (client_list[appid] = new HS_Client(req, appid));
114 }
115
116 /**
117  * remove Client
118  *
119  * #### Parameters
120  *  - appid: app's id
121  *
122  * #### Return
123  * None
124  *
125  */
126 void HS_ClientManager::removeClient(std::string appid)
127 {
128     delete client_list[appid];
129     client_list.erase(appid);
130 }
131
132 /**
133  * remove Client from list
134  *
135  * #### Parameters
136  *  - data: HS_ClientCtxt pointer
137  *
138  * #### Return
139  * None
140  *
141  */
142 void HS_ClientManager::removeClientCtxt(void *data)
143 {
144     HS_ClientCtxt *ctxt = (HS_ClientCtxt *)data;
145     if(ctxt == nullptr)
146     {
147         AFB_WARNING( "data is nullptr");
148         return;
149     }
150
151     AFB_INFO( "remove app %s", ctxt->id.c_str());
152     std::lock_guard<std::mutex> lock(this->mtx);
153     removeClient(ctxt->id);
154     delete appid2ctxt[ctxt->id];
155     appid2ctxt.erase(ctxt->id);
156 }
157
158 /**
159  * handle homescreen request
160  *
161  * #### Parameters
162  *  - request : the request
163  *  - verb : the verb name
164  *  - appid : to which application
165  *
166  * #### Return
167  * 0 : success
168  * others : fail
169  *
170  */
171 int HS_ClientManager::handleRequest(afb_req_t request, const char *verb, const char *appid)
172 {
173     AFB_INFO("verb=[%s],appid=[%s].", verb, appid);
174     int ret = 0;
175     std::lock_guard<std::mutex> lock(this->mtx);
176     if(appid == nullptr) {
177         for(auto m : client_list) {
178             m.second->handleRequest(request, verb);
179         }
180     }
181     else {
182         auto ip = client_list.find(std::string(appid));
183         if(ip != client_list.end()) {
184             ret = ip->second->handleRequest(request, verb);
185         }
186         else {
187             if(!strcasecmp(verb, "subscribe")) {
188                 appid2ctxt[appid] = createClientCtxt(request, appid);
189                 HS_Client* client = addClient(request, appid);
190                 ret = client->handleRequest(request, "subscribe");
191                 checkRegisterApp(std::string(appid));
192             }
193             else {
194                 AFB_NOTICE("not exist session");
195                 ret = AFB_REQ_NOT_STARTED_APPLICATION;
196             }
197         }
198     }
199     return ret;
200 }
201
202 /**
203  * push event
204  *
205  * #### Parameters
206  *  - event : the event want to push
207  *  - param : the parameter contents of event
208  *  - appid : the destination application's id
209  *
210  * #### Return
211  * 0 : success
212  * others : fail
213  *
214  */
215 int HS_ClientManager::pushEvent(const char *event, struct json_object *param, std::string appid)
216 {
217     if(event == nullptr) {
218         AFB_WARNING("event name is null.");
219         return -1;
220     }
221
222     std::lock_guard<std::mutex> lock(this->mtx);
223     if(appid.empty()) { // broadcast event to clients who subscribed this event
224         for(auto m : client_list) {
225             m.second->pushEvent(event, param);
226         }
227     }
228     else {  // push event to specific client
229         auto ip = client_list.find(appid);
230         if(ip != client_list.end()) {
231             ip->second->pushEvent(event, param);
232         }
233     }
234
235     return 0;
236 }
237
238 /**
239  * check register application
240  *
241  * #### Parameters
242  *  - appid : register application's id
243  *
244  * #### Return
245  * None
246  *
247  */
248 void HS_ClientManager::checkRegisterApp(const std::string &appid)
249 {
250     if(HS_AppRecover::instance()->registerRecoveredApp(appid)) {
251         AFB_NOTICE("register recover application.");
252         return;
253     }
254
255     if(startup_appid == appid) {
256         startup_appid.clear();
257         pushEvent("showWindow", nullptr, appid);
258     }
259 }