send showWindow event when app start over

[apps/agl-service-homescreen.git] / src / hs-apprecover.cpp

diff --git a/src/hs-apprecover.cpp b/src/hs-apprecover.cpp
index 8e5545c..5ccd039 100644 (file)
--- a/src/hs-apprecover.cpp
+++ b/src/hs-apprecover.cpp
@@ -19,7 +19,63 @@
 #include "hs-proxy.h"
 #include "hs-clientmanager.h"
 
-const char _keyArea[] = "area";
+
+HS_AppRecover* HS_AppRecover::me = nullptr;
+
+/**
+ * screen_update event handler
+ *
+ * #### Parameters
+ * - api : the api
+ * - event : received event name
+ * - object : received json object
+ *
+ * #### Return
+ * 0 : event can transfer to others
+ * 1 : event not transfer to others
+ */
+int on_screen_update_event(afb_api_t api, const char *event, struct json_object *object)
+{
+    HS_AppRecover::instance()->screenUpdated(object);
+    return 0;
+}
+
+/**
+ * get instance
+ *
+ * #### Parameters
+ *  - Nothing
+ *
+ * #### Return
+ * HS_AppRecover instance pointer
+ *
+ */
+HS_AppRecover* HS_AppRecover::instance(void)
+{
+    if(me == nullptr)
+        me = new HS_AppRecover();
+
+    return me;
+}
+
+/**
+ * HS_AppRecover initialize function
+ *
+ * #### Parameters
+ *  - api : the api serving the request
+ *
+ * #### Return
+ * 0 : init success
+ * 1 : init fail
+ *
+ */
+int HS_AppRecover::init(afb_api_t api)
+{
+    HS_WmProxy wm_proxy;
+    wm_proxy.subscribe(api, HS_WmProxy::Event_ScreenUpdated);
+    setEventHook("windowmanager/screenUpdated", on_screen_update_event);
+    return 0;
+}
 
 /**
  * starting recover applications
@@ -39,9 +95,11 @@ void HS_AppRecover::startRecovery(afb_api_t api, recover_map &map)
         for(auto &m : map[key]){
             struct app_recover_info recover_info;
             recover_info.recover_type = key;
-            recover_info.area = m.area;
             recover_info.visibility = m.visibility;
             m_recover_apps_list[m.appid] = std::move(recover_info);
+            if(key == HS_Config::keys_recover_type[1]) {
+                m_lastmode_list.insert(m.appid);
+            }
 
             // recover application
             m_recovering_set.insert(m.appid);
@@ -57,23 +115,122 @@ void HS_AppRecover::startRecovery(afb_api_t api, recover_map &map)
  *  - appid : application id liked "dashboard"
  *
  * #### Return
- * false : not all application recovered
- * true : all applications recovered
+ * false : not recover app
+ * true : recover app
+ * 
  */
-bool HS_AppRecover::registerRecoveredApp(std::string &appid)
+bool HS_AppRecover::registerRecoveredApp(const std::string &appid)
 {
+    bool ret = false;
+    if(m_recovering_set.empty()) {
+        return ret;
+    }
+
     auto it = m_recovering_set.find(appid);
     if(it != m_recovering_set.end()) {
         m_recovering_set.erase(appid);
         auto ip = m_recover_apps_list.find(appid);
         if(ip != m_recover_apps_list.end()
         && ip->second.visibility) {
-            // TBD, call setWindowResource
-            struct json_object *push_obj = json_object_new_object();
-            json_object_object_add(push_obj, _keyArea, json_object_new_string(ip->second.area.c_str()));
-            HS_ClientManager::instance()->pushEvent("showWindow", push_obj, appid);
+            HS_ClientManager::instance()->pushEvent("showWindow", nullptr, appid);
         }
+        ret = true;
     }
+    return ret;
+}
 
-    return m_recovering_set.empty() ? true : false;
+/**
+ * screenUpdated event handler
+ *
+ * #### Parameters
+ *  - obj : screenUpdate object
+ *
+ * #### Return
+ * None
+ * 
+ */
+void HS_AppRecover::screenUpdated(struct json_object *obj)
+{
+    std::set<std::string> s_mode;
+    struct json_object *ids_obj;
+    if(json_object_object_get_ex(obj, key_ids.c_str(), &ids_obj)) {
+        if(json_object_get_type(ids_obj) == json_type_array) {
+            int array_len = json_object_array_length(ids_obj);
+            for (int i = 0; i < array_len; ++i) {
+                struct json_object *j_id = json_object_array_get_idx(ids_obj, i);
+                std::string appid = json_object_get_string(j_id);
+                if(!isHomescreenApp(appid)) {
+                    s_mode.insert(appid);
+                }
+            }
+            if(!s_mode.empty()) {
+                updateLastmode(s_mode);
+            }
+        }
+        else {
+            AFB_WARNING("screenUpdated list isn't array.");
+        }
+    }
+}
+
+/**
+ * update lastmode file
+ *
+ * #### Parameters
+ *  - set : new lastmode set
+ *
+ * #### Return
+ * None
+ * 
+ */
+void HS_AppRecover::updateLastmode(std::set<std::string> &set)
+{
+    if(set.size() == m_lastmode_list.size()) {
+        bool is_same = true;
+        for(auto &m : set) {
+            auto it = m_lastmode_list.find(m);
+            if(it == m_lastmode_list.end()) {
+                is_same = false;
+                break;
+            }
+        }
+        if(is_same) {   // lastmode aren't changed
+            return;
+        }
+    }
+
+    m_lastmode_list.swap(set);
+    struct json_object *arr_obj = json_object_new_array();
+    for(auto &it : m_lastmode_list) {
+        struct json_object *j_obj = json_object_new_object();
+        json_object_object_add(j_obj, HS_Config::key_appid.c_str(), json_object_new_string(it.c_str()));
+        json_object_object_add(j_obj, HS_Config::key_visibility.c_str(), json_object_new_string("visible"));
+        json_object_array_add(arr_obj, j_obj);
+    }
+
+    auto path = HS_Config::root_dir + "/etc/" + HS_Config::lastmode_json;
+    if(writeJsonFile(path.c_str(), arr_obj) < 0) {
+        AFB_ERROR("write lastmode error.");
+    }
+}
+
+/**
+ * judge whether app is Homescreen app
+ *
+ * #### Parameters
+ *  - appid : application id
+ *
+ * #### Return
+ * true : homescreen app
+ * false : not homescreen app
+ *
+ */
+bool HS_AppRecover::isHomescreenApp(const std::string &appid) const
+{
+    auto it = m_recover_apps_list.find(appid);
+    if(it != m_recover_apps_list.end()
+    && it->second.recover_type == HS_Config::keys_recover_type[0]) {
+            return true;
+    }
+    return false;
 }
\ No newline at end of file