Fix setRole
[apps/agl-service-windowmanager.git] / src / window_manager.cpp
1 /*
2  * Copyright (c) 2017 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 <fstream>
18 #include <regex>
19 #include <sstream>
20
21 #include "window_manager.hpp"
22 #include "json_helper.hpp"
23 #include "applist.hpp"
24
25 extern "C"
26 {
27 #include <systemd/sd-event.h>
28 }
29
30 using std::string;
31 using std::vector;
32
33 namespace wm
34 {
35
36 static const uint64_t kTimeOut = 3ULL; /* 3s */
37
38 /* DrawingArea name used by "{layout}.{area}" */
39 const char kNameLayoutNormal[] = "normal";
40 const char kNameLayoutSplit[]  = "split";
41 const char kNameAreaFull[]     = "full";
42 const char kNameAreaMain[]     = "main";
43 const char kNameAreaSub[]      = "sub";
44
45 /* Key for json obejct */
46 const char kKeyDrawingName[] = "drawing_name";
47 const char kKeyDrawingArea[] = "drawing_area";
48 const char kKeyDrawingRect[] = "drawing_rect";
49 const char kKeyX[]           = "x";
50 const char kKeyY[]           = "y";
51 const char kKeyWidth[]       = "width";
52 const char kKeyHeight[]      = "height";
53 const char kKeyWidthPixel[]  = "width_pixel";
54 const char kKeyHeightPixel[] = "height_pixel";
55 const char kKeyWidthMm[]     = "width_mm";
56 const char kKeyHeightMm[]    = "height_mm";
57 const char kKeyScale[]       = "scale";
58 const char kKeyIds[]         = "ids";
59
60 static sd_event_source *g_timer_ev_src = nullptr;
61 static AppList g_app_list;
62 static WindowManager *g_context;
63
64 namespace
65 {
66
67 static int processTimerHandler(sd_event_source *s, uint64_t usec, void *userdata)
68 {
69     HMI_NOTICE("Time out occurs because the client replys endDraw slow, so revert the request");
70     reinterpret_cast<wm::WindowManager *>(userdata)->timerHandler();
71     return 0;
72 }
73
74 static void onStateTransitioned(vector<WMAction> actions)
75 {
76     g_context->startTransitionWrapper(actions);
77 }
78
79 static void onError()
80 {
81     g_context->processError(WMError::LAYOUT_CHANGE_FAIL);
82 }
83 } // namespace
84
85 /**
86  * WindowManager Impl
87  */
88 WindowManager::WindowManager()
89     : id_alloc{}
90 {
91     const char *path = getenv("AFM_APP_INSTALL_DIR");
92     if (!path)
93     {
94         HMI_ERROR("AFM_APP_INSTALL_DIR is not defined");
95     }
96     string root = path;
97
98     this->lc = std::make_shared<LayerControl>(root);
99
100     HMI_DEBUG("Layer Controller initialized");
101 }
102
103 int WindowManager::init()
104 {
105     // TODO: application requests by old role,
106     //       so create role map (old, new)
107     // Load old_role.db
108     LayerControlCallbacks lmcb;
109     lmcb.surfaceCreated = [&](unsigned pid, unsigned surface){
110         this->surface_created(pid, surface);
111         };
112     lmcb.surfaceDestroyed = [&](unsigned surface){
113         this->surface_removed(surface);
114     };
115     this->lc->init(lmcb);
116     this->loadOldRoleDb();
117
118     // Store my context for calling callback from PolicyManager
119     g_context = this;
120
121     // Initialize PMWrapper
122     this->pmw.initialize();
123
124     // Register callback to PolicyManager
125     this->pmw.registerCallback(onStateTransitioned, onError);
126
127     // Make afb event
128     for (int i = Event_Val_Min; i <= Event_Val_Max; i++)
129     {
130         map_afb_event[kListEventName[i]] = afb_daemon_make_event(kListEventName[i]);
131     }
132
133     const struct rect css_bg = this->lc->getAreaSize("fullscreen");
134     Screen screen = this->lc->getScreenInfo();
135     rectangle dp_bg(screen.width(), screen.height());
136
137     dp_bg.set_aspect(static_cast<double>(css_bg.w) / css_bg.h);
138     dp_bg.fit(screen.width(), screen.height());
139     dp_bg.center(screen.width(), screen.height());
140     HMI_DEBUG("SCALING: CSS BG(%dx%d) -> DDP %dx%d,(%dx%d)",
141               css_bg.w, css_bg.h, dp_bg.left(), dp_bg.top(), dp_bg.width(), dp_bg.height());
142
143     double scale = static_cast<double>(dp_bg.height()) / css_bg.h;
144     this->lc->setupArea(dp_bg, scale);
145
146     return 0; //init_layers();
147 }
148
149 result<int> WindowManager::api_request_surface(char const *appid, char const *drawing_name)
150 {
151     // TODO: application requests by old role,
152     //       so convert role old to new
153     const char *role = this->convertRoleOldToNew(drawing_name);
154     string l_name;
155     string s_appid = appid;
156     string s_role = role;
157
158     if(!g_app_list.contains(s_appid))
159     {
160         // auto lid = this->layers.get_layer_id(string(role));
161         unsigned l_id = this->lc->getNewLayerID(s_role, &l_name);
162         if (l_id == 0)
163         {
164             /**
165              * register drawing_name as fallback and make it displayed.
166              */
167             l_id = this->lc->getNewLayerID("fallback", &l_name);
168             HMI_DEBUG("%s is not registered in layers.json, then fallback as normal app", role);
169             if (l_id == 0)
170             {
171                 return Err<int>("Designated role does not match any role, fallback is disabled");
172             }
173         }
174         this->lc->createNewLayer(l_id);
175         // add client into the db
176         g_app_list.addClient(s_appid, l_id, s_role);
177     }
178
179     // generate surface ID for ivi-shell application
180
181     auto rname = this->id_alloc.lookup(string(role));
182     if (!rname)
183     {
184         // name does not exist yet, allocate surface id...
185         auto id = int(this->id_alloc.generate_id(role));
186         this->tmp_surface2app[id] = {s_appid, 0};
187
188         // Set role map of (new, old)
189         this->rolenew2old[role] = string(drawing_name);
190
191         return Ok<int>(id);
192     }
193
194     // Check currently registered drawing names if it is already there.
195     return Err<int>("Surface already present");
196 }
197
198 char const *WindowManager::api_request_surface(char const *appid, char const *drawing_name,
199                                      char const *ivi_id)
200 {
201     unsigned sid = std::stol(ivi_id);
202
203     HMI_DEBUG("This API(requestSurfaceXDG) is for XDG Application using runXDG");
204     /*
205      * IVI-shell doesn't send surface_size event via ivi-wm protocol
206      * if the application is using XDG surface.
207      * So WM has to set surface size with original size here
208      */
209     WMError ret = this->lc->setXDGSurfaceOriginSize(sid);
210     if(ret != SUCCESS)
211     {
212         HMI_ERROR("%s", errorDescription(ret));
213         HMI_WARNING("The main user of this API is runXDG");
214         return "fail";
215     }
216
217     // TODO: application requests by old role,
218     //       so convert role old to new
219     const char *role = this->convertRoleOldToNew(drawing_name);
220     string s_role = role;
221     string s_appid = appid;
222     string l_name;
223
224     if(!g_app_list.contains(s_appid))
225     {
226         // auto lid = this->layers.get_layer_id(string(role));
227         unsigned l_id = this->lc->getNewLayerID(s_role, &l_name);
228         if (l_id == 0)
229         {
230             /**
231              * register drawing_name as fallback and make it displayed.
232              */
233             l_id = this->lc->getNewLayerID("fallback", &l_name);
234             HMI_DEBUG("%s is not registered in layers.json, then fallback as normal app", role);
235             if (l_id == 0)
236             {
237                 return "Designated role does not match any role, fallback is disabled";
238             }
239         }
240         this->lc->createNewLayer(l_id);
241         // add client into the db
242         g_app_list.addClient(s_appid, l_id, s_role);
243     }
244
245     auto rname = this->id_alloc.lookup(s_role);
246     if (rname)
247     {
248         return "Surface already present";
249     }
250
251     // register pair drawing_name and ivi_id
252     this->id_alloc.register_name_id(role, sid);
253
254     auto client = g_app_list.lookUpClient(s_appid);
255     client->addSurface(sid);
256
257     // Set role map of (new, old)
258     this->rolenew2old[role] = string(drawing_name);
259
260     return nullptr;
261 }
262
263 bool WindowManager::api_set_role(char const *appid, char const *drawing_name)
264 {
265     bool ret = false;
266
267     // TODO: application requests by old role,
268     //       so convert role old to new
269     const char *role = this->convertRoleOldToNew(drawing_name);
270     string s_role = role;
271     string s_appid = appid;
272     string l_name;
273
274     // Create WMClient
275     if(!g_app_list.contains(s_appid))
276     {
277         // auto lid = this->layers.get_layer_id(string(role));
278         unsigned l_id = this->lc->getNewLayerID(s_role, &l_name);
279         if (l_id == 0)
280         {
281             /**
282              * register drawing_name as fallback and make it displayed.
283              */
284             l_id = this->lc->getNewLayerID("fallback", &l_name);
285             HMI_DEBUG("%s is not registered in layers.json, then fallback as normal app", role);
286             if (l_id == 0)
287             {
288                 HMI_ERROR("Designated role does not match any role, fallback is disabled");
289                 return ret;
290             }
291         }
292         this->lc->createNewLayer(l_id);
293         // add client into the db
294         g_app_list.addClient(s_appid, l_id, s_role);
295         // Set role map of (new, old)
296         this->rolenew2old[role] = s_role;
297     }
298
299     // for(auto itr = this->tmp_surface2app.begin();
300     //         itr != this->tmp_surface2app.end() ; ++itr)
301     // {
302     for(auto& x : this->tmp_surface2app)
303     {
304         if(x.second.appid == s_appid)
305         {
306             unsigned surface = x.first;
307             auto client = g_app_list.lookUpClient(s_appid);
308             client->addSurface(surface);
309             this->tmp_surface2app.erase(surface);
310             this->id_alloc.register_name_id(s_role, surface);
311             break;
312         }
313     }
314
315 /*     if(0 != pid){
316         // search floating surfaceID from pid if pid is designated.
317         wm_err = g_app_list.popFloatingSurface(pid, &surface);
318     }
319     else{
320         // get floating surface with appid. If WM queries appid from pid,
321         // WM can bind surface and role with appid(not implemented yet)
322         //wm_err = g_app_list.popFloatingSurface(id);
323     }
324     if(wm_err != WMError::SUCCESS){
325         HMI_ERROR("No floating surface for app: %s", id.c_str());
326         g_app_list.addFloatingClient(id, lid, role);
327         HMI_NOTICE("%s : Waiting for surface creation", id.c_str());
328         return ret;
329     }
330
331     ret = true;
332     if (g_app_list.contains(id))
333     {
334         HMI_INFO("Add role: %s with surface: %d. Client %s has multi surfaces.",
335                  role.c_str(), surface, id.c_str());
336         auto client = g_app_list.lookUpClient(id);
337         client->appendRole(role);
338     }
339     else{
340         HMI_INFO("Create new client: %s, surface: %d into layer: %d with role: %s",
341                  id.c_str(), surface, lid, role.c_str());
342         g_app_list.addClient(id, lid, role);
343     } */
344
345     // register pair drawing_name and ivi_id
346
347     return true;
348 }
349
350 void WindowManager::api_activate_surface(char const *appid, char const *drawing_name,
351                                char const *drawing_area, const reply_func &reply)
352 {
353     // TODO: application requests by old role,
354     //       so convert role old to new
355     const char *c_role = this->convertRoleOldToNew(drawing_name);
356
357     string id = appid;
358     string role = c_role;
359     string area = drawing_area;
360
361     if(!g_app_list.contains(id))
362     {
363         reply("app doesn't request 'requestSurface' or 'setRole' yet");
364         return;
365     }
366     auto client = g_app_list.lookUpClient(id);
367
368     // unsigned srfc = client->surfaceID(role);
369     // unsigned layer = client->layerID();
370
371     // g_app_list.removeFloatingSurface(client->surfaceID());
372     // g_app_list.removeFloatingSurface(client);
373
374     Task task = Task::TASK_ALLOCATE;
375     unsigned req_num = 0;
376     WMError ret = WMError::UNKNOWN;
377
378     ret = this->setRequest(id, role, area, task, &req_num);
379
380     //vector<WMLayerState> current_states = this->lc->getCurrentStates();
381     // ret = this->setRequest(id, role, area, task, current_states, &req_num);
382
383     if(ret != WMError::SUCCESS)
384     {
385         HMI_ERROR(errorDescription(ret));
386         reply("Failed to set request");
387         return;
388     }
389
390     reply(nullptr);
391     if (req_num != g_app_list.currentRequestNumber())
392     {
393         // Add request, then invoked after the previous task is finished
394         HMI_SEQ_DEBUG(req_num, "request is accepted");
395         return;
396     }
397
398     /*
399      * Do allocate tasks
400      */
401     ret = this->checkPolicy(req_num);
402
403     if (ret != WMError::SUCCESS)
404     {
405         //this->emit_error()
406         HMI_SEQ_ERROR(req_num, errorDescription(ret));
407         g_app_list.removeRequest(req_num);
408         this->processNextRequest();
409     }
410 }
411
412 void WindowManager::api_deactivate_surface(char const *appid, char const *drawing_name,
413                                  const reply_func &reply)
414 {
415     // TODO: application requests by old role,
416     //       so convert role old to new
417     const char *c_role = this->convertRoleOldToNew(drawing_name);
418
419     /*
420     * Check Phase
421     */
422     string id = appid;
423     string role = c_role;
424     string area = ""; //drawing_area;
425     Task task = Task::TASK_RELEASE;
426     unsigned req_num = 0;
427     WMError ret = WMError::UNKNOWN;
428
429     ret = this->setRequest(id, role, area, task, &req_num);
430
431     if (ret != WMError::SUCCESS)
432     {
433         HMI_ERROR(errorDescription(ret));
434         reply("Failed to set request");
435         return;
436     }
437
438     reply(nullptr);
439     if (req_num != g_app_list.currentRequestNumber())
440     {
441         // Add request, then invoked after the previous task is finished
442         HMI_SEQ_DEBUG(req_num, "request is accepted");
443         return;
444     }
445
446     /*
447     * Do allocate tasks
448     */
449     ret = this->checkPolicy(req_num);
450
451     if (ret != WMError::SUCCESS)
452     {
453         //this->emit_error()
454         HMI_SEQ_ERROR(req_num, errorDescription(ret));
455         g_app_list.removeRequest(req_num);
456         this->processNextRequest();
457     }
458 }
459
460 void WindowManager::api_enddraw(char const *appid, char const *drawing_name)
461 {
462     // TODO: application requests by old role,
463     //       so convert role old to new
464     const char *c_role = this->convertRoleOldToNew(drawing_name);
465
466     string id = appid;
467     string role = c_role;
468     unsigned current_req = g_app_list.currentRequestNumber();
469     bool result = g_app_list.setEndDrawFinished(current_req, id, role);
470
471     if (!result)
472     {
473         HMI_ERROR("%s is not in transition state", id.c_str());
474         return;
475     }
476
477     if (g_app_list.endDrawFullfilled(current_req))
478     {
479         // do task for endDraw
480         this->stopTimer();
481         WMError ret = this->doEndDraw(current_req);
482
483         if(ret != WMError::SUCCESS)
484         {
485             //this->emit_error();
486
487             // Undo state of PolicyManager
488             this->pmw.undoState();
489             this->lc->undoUpdate();
490         }
491         this->emitScreenUpdated(current_req);
492         HMI_SEQ_INFO(current_req, "Finish request status: %s", errorDescription(ret));
493
494         g_app_list.removeRequest(current_req);
495
496         this->processNextRequest();
497     }
498     else
499     {
500         HMI_SEQ_INFO(current_req, "Wait other App call endDraw");
501         return;
502     }
503 }
504
505 result<json_object *> WindowManager::api_get_display_info()
506 {
507     Screen screen = this->lc->getScreenInfo();
508
509     json_object *object = json_object_new_object();
510     json_object_object_add(object, kKeyWidthPixel, json_object_new_int(screen.width()));
511     json_object_object_add(object, kKeyHeightPixel, json_object_new_int(screen.height()));
512     // TODO: set size
513     json_object_object_add(object, kKeyWidthMm, json_object_new_int(0));
514     json_object_object_add(object, kKeyHeightMm, json_object_new_int(0));
515     json_object_object_add(object, kKeyScale, json_object_new_double(this->lc->scale()));
516
517     return Ok<json_object *>(object);
518 }
519
520 result<json_object *> WindowManager::api_get_area_info(char const *drawing_name)
521 {
522     HMI_DEBUG("called");
523
524     // TODO: application requests by old role,
525     //       so convert role old to new
526     const char *role = this->convertRoleOldToNew(drawing_name);
527
528     // Check drawing name, surface/layer id
529     auto const &surface_id = this->id_alloc.lookup(string(role));
530     if (!surface_id)
531     {
532         return Err<json_object *>("Surface does not exist");
533     }
534
535     // Set area rectangle
536     rect area_info = this->area_info[*surface_id];
537     json_object *object = json_object_new_object();
538     json_object_object_add(object, kKeyX, json_object_new_int(area_info.x));
539     json_object_object_add(object, kKeyY, json_object_new_int(area_info.y));
540     json_object_object_add(object, kKeyWidth, json_object_new_int(area_info.w));
541     json_object_object_add(object, kKeyHeight, json_object_new_int(area_info.h));
542
543     return Ok<json_object *>(object);
544 }
545
546 void WindowManager::send_event(char const *evname, char const *label)
547 {
548     HMI_DEBUG("%s: %s(%s)", __func__, evname, label);
549
550     json_object *j = json_object_new_object();
551     json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
552
553     int ret = afb_event_push(this->map_afb_event[evname], j);
554     if (ret != 0)
555     {
556         HMI_DEBUG("afb_event_push failed: %m");
557     }
558 }
559
560 void WindowManager::send_event(char const *evname, char const *label, char const *area,
561                      int x, int y, int w, int h)
562 {
563     HMI_DEBUG("%s: %s(%s, %s) x:%d y:%d w:%d h:%d",
564               __func__, evname, label, area, x, y, w, h);
565
566     json_object *j_rect = json_object_new_object();
567     json_object_object_add(j_rect, kKeyX, json_object_new_int(x));
568     json_object_object_add(j_rect, kKeyY, json_object_new_int(y));
569     json_object_object_add(j_rect, kKeyWidth, json_object_new_int(w));
570     json_object_object_add(j_rect, kKeyHeight, json_object_new_int(h));
571
572     json_object *j = json_object_new_object();
573     json_object_object_add(j, kKeyDrawingName, json_object_new_string(label));
574     json_object_object_add(j, kKeyDrawingArea, json_object_new_string(area));
575     json_object_object_add(j, kKeyDrawingRect, j_rect);
576
577     int ret = afb_event_push(this->map_afb_event[evname], j);
578     if (ret != 0)
579     {
580         HMI_DEBUG("afb_event_push failed: %m");
581     }
582 }
583
584 /**
585  * proxied events
586  */
587 void WindowManager::surface_created(unsigned pid, unsigned surface_id)
588 {
589     if(this->tmp_surface2app.count(surface_id) != 0)
590     {
591         string appid = this->tmp_surface2app[surface_id].appid;
592         auto client = g_app_list.lookUpClient(appid);
593         if(client != nullptr)
594         {
595             WMError ret = client->addSurface(surface_id);
596             HMI_INFO("Add surface %d to \"%s\"", surface_id, appid.c_str());
597             if(ret != WMError::SUCCESS)
598             {
599                 HMI_ERROR("Failed to add surface to client %s", client->appID().c_str());
600             }
601         }
602         this->tmp_surface2app.erase(surface_id);
603     }
604     else
605     {
606         HMI_NOTICE("Unknown surface %d", surface_id);
607         // retrieve ppid
608         std::ostringstream os;
609         os << pid ;
610         string path = "/proc/" + os.str() + "/stat";
611         std::ifstream ifs(path.c_str());
612         string str;
613         unsigned ppid = 0;
614         if(!ifs.fail() && std::getline(ifs, str))
615         {
616             std::sscanf(str.data(), "%*d %*s %*c %d", &ppid);
617             HMI_INFO("Retrieve ppid %d", ppid);
618         }
619         else
620         {
621             HMI_ERROR("Failed to open /proc/%d/stat", pid);
622             HMI_ERROR("File system may be different");
623             return;
624         }
625         // search pid from surfaceID
626         json_object *response;
627         afb_service_call_sync("afm-main", "runners", nullptr, &response);
628
629         // retrieve appid from pid from application manager
630         string appid = "";
631         if(response == nullptr)
632         {
633             HMI_ERROR("No runners");
634         }
635         else
636         {
637             // check appid then add it to the client
638             HMI_INFO("Runners:%s", json_object_get_string(response));
639             int size = json_object_array_length(response);
640             for(int i = 0; i < size; i++)
641             {
642                 json_object *j = json_object_array_get_idx(response, i);
643                 const char* id = jh::getStringFromJson(j, "id");
644                 int runid      = jh::getIntFromJson(j, "runid");
645                 if(id && (runid > 0))
646                 {
647                     if(runid == ppid)
648                     {
649                         appid = id;
650                         break;
651                     }
652                 }
653             }
654             if(appid == "")
655             {
656                 HMI_ERROR("Not found");
657             }
658         }
659         json_object_put(response);
660         auto client = g_app_list.lookUpClient(appid);
661         if(client != nullptr)
662         {
663             client->addSurface(surface_id);
664             this->id_alloc.register_name_id(client->role(), surface_id);
665         }
666         else
667         {
668             /*
669              * Store tmp surface and appid for application
670              * who requests setRole after creating shell surface
671              */
672             this->tmp_surface2app.emplace(surface_id, TmpClient{appid, ppid});
673         }
674     }
675 }
676
677 void WindowManager::surface_removed(unsigned surface_id)
678 {
679     HMI_DEBUG("Delete surface_id %u", surface_id);
680     this->id_alloc.remove_id(surface_id);
681     // this->layers.remove_surface(surface_id);
682     g_app_list.removeSurface(surface_id);
683 }
684
685 void WindowManager::removeClient(const string &appid)
686 {
687     HMI_DEBUG("Remove clinet %s from list", appid.c_str());
688     auto client = g_app_list.lookUpClient(appid);
689     this->lc->terminateApp(client);
690     g_app_list.removeClient(appid);
691 }
692
693 void WindowManager::exceptionProcessForTransition()
694 {
695     unsigned req_num = g_app_list.currentRequestNumber();
696     HMI_SEQ_NOTICE(req_num, "Process exception handling for request. Remove current request %d", req_num);
697     g_app_list.removeRequest(req_num);
698     HMI_SEQ_NOTICE(g_app_list.currentRequestNumber(), "Process next request if exists");
699     this->processNextRequest();
700 }
701
702 void WindowManager::timerHandler()
703 {
704     unsigned req_num = g_app_list.currentRequestNumber();
705     HMI_SEQ_DEBUG(req_num, "Timer expired remove Request");
706     g_app_list.reqDump();
707     g_app_list.removeRequest(req_num);
708     this->processNextRequest();
709 }
710
711 void WindowManager::startTransitionWrapper(vector<WMAction> &actions)
712 {
713     WMError ret;
714     // req_num is guaranteed by Window Manager
715     unsigned req_num = g_app_list.currentRequestNumber();
716
717     if (actions.empty())
718     {
719         if (g_app_list.haveRequest())
720         {
721             HMI_SEQ_DEBUG(req_num, "There is no WMAction for this request");
722             goto proc_remove_request;
723         }
724         else
725         {
726             HMI_SEQ_DEBUG(req_num, "There is no request");
727             return;
728         }
729     }
730
731     for (auto &act : actions)
732     {
733         if ("" != act.role)
734         {
735             bool found;
736             auto const &surface_id = this->id_alloc.lookup(act.role.c_str());
737             if(surface_id == nullopt)
738             {
739                 goto proc_remove_request;
740             }
741             std::string appid = g_app_list.getAppID(*surface_id, &found);
742             if (!found)
743             {
744                 if (TaskVisible::INVISIBLE == act.visible)
745                 {
746                     // App is killed, so do not set this action
747                     continue;
748                 }
749                 else
750                 {
751                     HMI_SEQ_ERROR(req_num, "appid which is visible is not found");
752                     ret = WMError::FAIL;
753                     goto error;
754                 }
755             }
756             auto client = g_app_list.lookUpClient(appid);
757             act.req_num = req_num;
758             act.client = client;
759         }
760
761         ret = g_app_list.setAction(req_num, act);
762         if (ret != WMError::SUCCESS)
763         {
764             HMI_SEQ_ERROR(req_num, "Setting action is failed");
765             goto error;
766         }
767     }
768
769     HMI_SEQ_DEBUG(req_num, "Start transition.");
770     ret = this->startTransition(req_num);
771     if (ret != WMError::SUCCESS)
772     {
773         if (ret == WMError::NO_LAYOUT_CHANGE)
774         {
775             goto proc_remove_request;
776         }
777         else
778         {
779             HMI_SEQ_ERROR(req_num, "Transition state is failed");
780             goto error;
781         }
782     }
783
784     return;
785
786 error:
787     //this->emit_error()
788     HMI_SEQ_ERROR(req_num, errorDescription(ret));
789     this->pmw.undoState();
790
791 proc_remove_request:
792     g_app_list.removeRequest(req_num);
793     this->processNextRequest();
794 }
795
796 void WindowManager::processError(WMError error)
797 {
798     unsigned req_num = g_app_list.currentRequestNumber();
799
800     //this->emit_error()
801     HMI_SEQ_ERROR(req_num, errorDescription(error));
802     g_app_list.removeRequest(req_num);
803     this->processNextRequest();
804 }
805
806 /*
807  ******* Private Functions *******
808  */
809
810 void WindowManager::emit_activated(char const *label)
811 {
812     this->send_event(kListEventName[Event_Active], label);
813 }
814
815 void WindowManager::emit_deactivated(char const *label)
816 {
817     this->send_event(kListEventName[Event_Inactive], label);
818 }
819
820 void WindowManager::emit_syncdraw(char const *label, char const *area, int x, int y, int w, int h)
821 {
822     this->send_event(kListEventName[Event_SyncDraw], label, area, x, y, w, h);
823 }
824
825 void WindowManager::emit_syncdraw(const string &role, const string &area)
826 {
827     rect rect = this->lc->getAreaSize(area);
828     this->send_event(kListEventName[Event_SyncDraw],
829         role.c_str(), area.c_str(), rect.x, rect.y, rect.w, rect.h);
830 }
831
832 void WindowManager::emit_flushdraw(char const *label)
833 {
834     this->send_event(kListEventName[Event_FlushDraw], label);
835 }
836
837 void WindowManager::emit_visible(char const *label, bool is_visible)
838 {
839     this->send_event(is_visible ? kListEventName[Event_Visible] : kListEventName[Event_Invisible], label);
840 }
841
842 void WindowManager::emit_invisible(char const *label)
843 {
844     return emit_visible(label, false);
845 }
846
847 void WindowManager::emit_visible(char const *label) { return emit_visible(label, true); }
848
849 void WindowManager::activate(int id)
850 {
851     // TODO: application requests by old role,
852     //       so convert role new to old for emitting event
853     /* const char* old_role = this->rolenew2old[label].c_str();
854
855     this->emit_visible(old_role);
856     this->emit_activated(old_role); */
857 }
858
859 void WindowManager::deactivate(int id)
860 {
861     // TODO: application requests by old role,
862     //       so convert role new to old for emitting event
863     /* const char* old_role = this->rolenew2old[label].c_str();
864
865     this->emit_deactivated(old_role);
866     this->emit_invisible(old_role); */
867 }
868
869 WMError WindowManager::setRequest(const string& appid, const string &role, const string &area,
870                             Task task, unsigned* req_num)
871 {
872     if (!g_app_list.contains(appid))
873     {
874         return WMError::NOT_REGISTERED;
875     }
876
877     auto client = g_app_list.lookUpClient(appid);
878
879     /*
880      * Queueing Phase
881      */
882     unsigned current = g_app_list.currentRequestNumber();
883     unsigned requested_num = g_app_list.getRequestNumber(appid);
884     if (requested_num != 0)
885     {
886         HMI_SEQ_INFO(requested_num,
887             "%s %s %s request is already queued", appid.c_str(), role.c_str(), area.c_str());
888         return REQ_REJECTED;
889     }
890
891     WMRequest req = WMRequest(appid, role, area, task);
892     unsigned new_req = g_app_list.addRequest(req);
893     *req_num = new_req;
894     g_app_list.reqDump();
895
896     HMI_SEQ_DEBUG(current, "%s start sequence with %s, %s", appid.c_str(), role.c_str(), area.c_str());
897
898     return WMError::SUCCESS;
899 }
900
901 WMError WindowManager::checkPolicy(unsigned req_num)
902 {
903     /*
904     * Check Policy
905     */
906     // get current trigger
907     bool found = false;
908     WMError ret = WMError::LAYOUT_CHANGE_FAIL;
909     auto trigger = g_app_list.getRequest(req_num, &found);
910     if (!found)
911     {
912         ret = WMError::NO_ENTRY;
913         return ret;
914     }
915     string req_area = trigger.area;
916
917     if (trigger.task == Task::TASK_ALLOCATE)
918     {
919         const char *msg = this->check_surface_exist(trigger.role.c_str());
920
921         if (msg)
922         {
923             HMI_SEQ_ERROR(req_num, msg);
924             return ret;
925         }
926     }
927
928     // Input event data to PolicyManager
929     if (0 > this->pmw.setInputEventData(trigger.task, trigger.role, trigger.area))
930     {
931         HMI_SEQ_ERROR(req_num, "Failed to set input event data to PolicyManager");
932         return ret;
933     }
934
935     // Execute state transition of PolicyManager
936     if (0 > this->pmw.executeStateTransition())
937     {
938         HMI_SEQ_ERROR(req_num, "Failed to execute state transition of PolicyManager");
939         return ret;
940     }
941
942     ret = WMError::SUCCESS;
943
944     g_app_list.reqDump();
945
946     return ret;
947 }
948
949 WMError WindowManager::startTransition(unsigned req_num)
950 {
951     bool sync_draw_happen = false;
952     bool found = false;
953     WMError ret = WMError::SUCCESS;
954     auto actions = g_app_list.getActions(req_num, &found);
955     if (!found)
956     {
957         ret = WMError::NO_ENTRY;
958         HMI_SEQ_ERROR(req_num,
959             "Window Manager bug :%s : Action is not set", errorDescription(ret));
960         return ret;
961     }
962
963     g_app_list.reqDump();
964     for (const auto &action : actions)
965     {
966         if (action.visible == TaskVisible::VISIBLE)
967         {
968             sync_draw_happen = true;
969
970             // TODO: application requests by old role,
971             //       so convert role new to old for emitting event
972             string old_role = this->rolenew2old[action.role];
973
974             this->emit_syncdraw(old_role, action.area);
975             /* TODO: emit event for app not subscriber
976             if(g_app_list.contains(y.appid))
977                 g_app_list.lookUpClient(y.appid)->emit_syncdraw(y.role, y.area); */
978         }
979     }
980
981     if (sync_draw_happen)
982     {
983         this->setTimer();
984     }
985     else
986     {
987         // deactivate only, no syncDraw
988         // Make it deactivate here
989         for (const auto &x : actions)
990         {
991             this->lc->visibilityChange(x);
992             string old_role = this->rolenew2old[x.role];
993             emit_deactivated(old_role.c_str());
994
995             /* if (g_app_list.contains(x.appid))
996             {
997                 auto client = g_app_list.lookUpClient(x.appid);
998                 //this->deactivate(client->surfaceID(x.role));
999             } */
1000         }
1001         this->lc->renderLayers();
1002         ret = WMError::NO_LAYOUT_CHANGE;
1003     }
1004     return ret;
1005 }
1006
1007 WMError WindowManager::doEndDraw(unsigned req_num)
1008 {
1009     // get actions
1010     bool found;
1011     auto actions = g_app_list.getActions(req_num, &found);
1012     WMError ret = WMError::SUCCESS;
1013     if (!found)
1014     {
1015         ret = WMError::NO_ENTRY;
1016         return ret;
1017     }
1018
1019     HMI_SEQ_INFO(req_num, "do endDraw");
1020
1021     // layout change and make it visible
1022     for (const auto &act : actions)
1023     {
1024         if(act.visible != TaskVisible::NO_CHANGE)
1025         {
1026             // layout change
1027             ret = this->lc->layoutChange(act);
1028             if(ret != WMError::SUCCESS)
1029             {
1030                 HMI_SEQ_WARNING(req_num,
1031                     "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1032                 return ret;
1033             }
1034             ret = this->lc->visibilityChange(act);
1035
1036             // Emit active/deactive event
1037             string old_role = this->rolenew2old[act.role];
1038             if(act.visible == VISIBLE)
1039             {
1040                 emit_activated(old_role.c_str());
1041             }
1042             else
1043             {
1044                 emit_deactivated(old_role.c_str());
1045             }
1046
1047             if (ret != WMError::SUCCESS)
1048             {
1049                 HMI_SEQ_WARNING(req_num,
1050                     "Failed to manipulate surfaces while state change : %s", errorDescription(ret));
1051                 return ret;
1052             }
1053             HMI_SEQ_DEBUG(req_num, "visible %s", act.role.c_str());
1054         }
1055     }
1056     this->lc->renderLayers();
1057
1058     HMI_SEQ_INFO(req_num, "emit flushDraw");
1059
1060     for(const auto &act_flush : actions)
1061     {
1062         if(act_flush.visible == TaskVisible::VISIBLE)
1063         {
1064             // TODO: application requests by old role,
1065             //       so convert role new to old for emitting event
1066             string old_role = this->rolenew2old[act_flush.role];
1067
1068             this->emit_flushdraw(old_role.c_str());
1069         }
1070     }
1071
1072     return ret;
1073 }
1074
1075 void WindowManager::emitScreenUpdated(unsigned req_num)
1076 {
1077     // Get visible apps
1078     HMI_SEQ_DEBUG(req_num, "emit screen updated");
1079     bool found = false;
1080     auto actions = g_app_list.getActions(req_num, &found);
1081
1082     // create json object
1083     json_object *j = json_object_new_object();
1084     json_object *jarray = json_object_new_array();
1085
1086     for(const auto& action: actions)
1087     {
1088         if(action.visible != TaskVisible::INVISIBLE)
1089         {
1090             json_object_array_add(jarray, json_object_new_string(action.client->appID().c_str()));
1091         }
1092     }
1093     json_object_object_add(j, kKeyIds, jarray);
1094     HMI_SEQ_INFO(req_num, "Visible app: %s", json_object_get_string(j));
1095
1096     int ret = afb_event_push(
1097         this->map_afb_event[kListEventName[Event_ScreenUpdated]], j);
1098     if (ret != 0)
1099     {
1100         HMI_DEBUG("afb_event_push failed: %m");
1101     }
1102 }
1103
1104 void WindowManager::setTimer()
1105 {
1106     struct timespec ts;
1107     if (clock_gettime(CLOCK_BOOTTIME, &ts) != 0) {
1108         HMI_ERROR("Could't set time (clock_gettime() returns with error");
1109         return;
1110     }
1111
1112     HMI_SEQ_DEBUG(g_app_list.currentRequestNumber(), "Timer set activate");
1113     if (g_timer_ev_src == nullptr)
1114     {
1115         // firsttime set into sd_event
1116         int ret = sd_event_add_time(afb_daemon_get_event_loop(), &g_timer_ev_src,
1117             CLOCK_BOOTTIME, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL, 1, processTimerHandler, this);
1118         if (ret < 0)
1119         {
1120             HMI_ERROR("Could't set timer");
1121         }
1122     }
1123     else
1124     {
1125         // update timer limitation after second time
1126         sd_event_source_set_time(g_timer_ev_src, (uint64_t)(ts.tv_sec + kTimeOut) * 1000000ULL);
1127         sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_ONESHOT);
1128     }
1129 }
1130
1131 void WindowManager::stopTimer()
1132 {
1133     unsigned req_num = g_app_list.currentRequestNumber();
1134     HMI_SEQ_DEBUG(req_num, "Timer stop");
1135     int rc = sd_event_source_set_enabled(g_timer_ev_src, SD_EVENT_OFF);
1136     if (rc < 0)
1137     {
1138         HMI_SEQ_ERROR(req_num, "Timer stop failed");
1139     }
1140 }
1141
1142 void WindowManager::processNextRequest()
1143 {
1144     g_app_list.next();
1145     g_app_list.reqDump();
1146     unsigned req_num = g_app_list.currentRequestNumber();
1147     if (g_app_list.haveRequest())
1148     {
1149         HMI_SEQ_DEBUG(req_num, "Process next request");
1150         WMError rc = checkPolicy(req_num);
1151         if (rc != WMError::SUCCESS)
1152         {
1153             HMI_SEQ_ERROR(req_num, errorDescription(rc));
1154         }
1155     }
1156     else
1157     {
1158         HMI_SEQ_DEBUG(req_num, "Nothing Request. Waiting Request");
1159     }
1160 }
1161
1162 const char* WindowManager::convertRoleOldToNew(char const *old_role)
1163 {
1164     const char *new_role = nullptr;
1165
1166     for (auto const &on : this->roleold2new)
1167     {
1168         std::regex regex = std::regex(on.first);
1169         if (std::regex_match(old_role, regex))
1170         {
1171             // role is old. So convert to new.
1172             new_role = on.second.c_str();
1173             break;
1174         }
1175     }
1176
1177     if (nullptr == new_role)
1178     {
1179         // role is new or fallback.
1180         new_role = old_role;
1181     }
1182
1183     HMI_DEBUG("old:%s -> new:%s", old_role, new_role);
1184
1185     return new_role;
1186 }
1187
1188 int WindowManager::loadOldRoleDb()
1189 {
1190     // Get afm application installed dir
1191     char const *afm_app_install_dir = getenv("AFM_APP_INSTALL_DIR");
1192     HMI_DEBUG("afm_app_install_dir:%s", afm_app_install_dir);
1193
1194     string file_name;
1195     if (!afm_app_install_dir)
1196     {
1197         HMI_ERROR("AFM_APP_INSTALL_DIR is not defined");
1198     }
1199     else
1200     {
1201         file_name = string(afm_app_install_dir) + string("/etc/old_roles.db");
1202     }
1203
1204     // Load old_role.db
1205     json_object* json_obj;
1206     int ret = jh::inputJsonFilie(file_name.c_str(), &json_obj);
1207     if (0 > ret)
1208     {
1209         HMI_ERROR("Could not open old_role.db, so use default old_role information");
1210         json_obj = json_tokener_parse(kDefaultOldRoleDb);
1211     }
1212     HMI_DEBUG("json_obj dump:%s", json_object_get_string(json_obj));
1213
1214     // Perse apps
1215     json_object* json_cfg;
1216     if (!json_object_object_get_ex(json_obj, "old_roles", &json_cfg))
1217     {
1218         HMI_ERROR("Parse Error!!");
1219         return -1;
1220     }
1221
1222     int len = json_object_array_length(json_cfg);
1223     HMI_DEBUG("json_cfg len:%d", len);
1224     HMI_DEBUG("json_cfg dump:%s", json_object_get_string(json_cfg));
1225
1226     for (int i=0; i<len; i++)
1227     {
1228         json_object* json_tmp = json_object_array_get_idx(json_cfg, i);
1229
1230         const char* old_role = jh::getStringFromJson(json_tmp, "name");
1231         if (nullptr == old_role)
1232         {
1233             HMI_ERROR("Parse Error!!");
1234             return -1;
1235         }
1236
1237         const char* new_role = jh::getStringFromJson(json_tmp, "new");
1238         if (nullptr == new_role)
1239         {
1240             HMI_ERROR("Parse Error!!");
1241             return -1;
1242         }
1243
1244         this->roleold2new[old_role] = string(new_role);
1245     }
1246
1247     // Check
1248     for(auto itr = this->roleold2new.begin();
1249       itr != this->roleold2new.end(); ++itr)
1250     {
1251         HMI_DEBUG(">>> role old:%s new:%s",
1252                   itr->first.c_str(), itr->second.c_str());
1253     }
1254
1255     // Release json_object
1256     json_object_put(json_obj);
1257
1258     return 0;
1259 }
1260
1261 const char *WindowManager::check_surface_exist(const char *drawing_name)
1262 {
1263     auto const &surface_id = this->id_alloc.lookup(string(drawing_name));
1264     if (!surface_id)
1265     {
1266         return "Surface does not exist";
1267     }
1268
1269     /* if (!this->controller->surface_exists(*surface_id))
1270     {
1271         return "Surface does not exist in controller!";
1272     } */
1273
1274     /* auto layer_id = this->layers.get_layer_id(*surface_id);
1275
1276     if (!layer_id)
1277     {
1278         return "Surface is not on any layer!";
1279     } */
1280
1281     HMI_DEBUG("surface %d is detected", *surface_id);
1282     return nullptr;
1283 }
1284
1285 const char* WindowManager::kDefaultOldRoleDb = "{ \
1286     \"old_roles\": [ \
1287         { \
1288             \"name\": \"HomeScreen\", \
1289             \"new\": \"homescreen\" \
1290         }, \
1291         { \
1292             \"name\": \"Music\", \
1293             \"new\": \"music\" \
1294         }, \
1295         { \
1296             \"name\": \"MediaPlayer\", \
1297             \"new\": \"music\" \
1298         }, \
1299         { \
1300             \"name\": \"Video\", \
1301             \"new\": \"video\" \
1302         }, \
1303         { \
1304             \"name\": \"VideoPlayer\", \
1305             \"new\": \"video\" \
1306         }, \
1307         { \
1308             \"name\": \"WebBrowser\", \
1309             \"new\": \"browser\" \
1310         }, \
1311         { \
1312             \"name\": \"Radio\", \
1313             \"new\": \"radio\" \
1314         }, \
1315         { \
1316             \"name\": \"Phone\", \
1317             \"new\": \"phone\" \
1318         }, \
1319         { \
1320             \"name\": \"Navigation\", \
1321             \"new\": \"map\" \
1322         }, \
1323         { \
1324             \"name\": \"HVAC\", \
1325             \"new\": \"hvac\" \
1326         }, \
1327         { \
1328             \"name\": \"Settings\", \
1329             \"new\": \"settings\" \
1330         }, \
1331         { \
1332             \"name\": \"Dashboard\", \
1333             \"new\": \"dashboard\" \
1334         }, \
1335         { \
1336             \"name\": \"POI\", \
1337             \"new\": \"poi\" \
1338         }, \
1339         { \
1340             \"name\": \"Mixer\", \
1341             \"new\": \"mixer\" \
1342         }, \
1343         { \
1344             \"name\": \"Restriction\", \
1345             \"new\": \"restriction\" \
1346         }, \
1347         { \
1348             \"name\": \"^OnScreen.*\", \
1349             \"new\": \"on_screen\" \
1350         } \
1351     ] \
1352 }";
1353
1354 } // namespace wm