POI: AGL LifeCycle Management

[apps/agl-service-windowmanager.git] / src / main.cpp

diff --git a/src/main.cpp b/src/main.cpp
index 333df70..ac3050b 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -31,10 +31,16 @@ typedef struct WMClientCtxt
 {
     std::string name;
     std::string role;
+    void* lcm_obs_ctx;  // POI: LCM
+
     WMClientCtxt(const char *appName, const char* appRole)
+        : name(appName), role(appRole), lcm_obs_ctx(nullptr) {};
+    WMClientCtxt() : lcm_obs_ctx(nullptr) {};
+
+    void set_name_role(const char *appName, const char* appRole)
     {
-        name = appName;
-        role = appRole;
+      name = appName;
+      role = appRole;
     }
 } WMClientCtxt;
 
@@ -98,28 +104,45 @@ static void cbRemoveClientCtxt(void *data)
     {
         return;
     }
-    HMI_DEBUG("remove app %s", ctxt->name.c_str());
 
-    // Policy Manager does not know this app was killed,
-    // so notify it by deactivate request.
-    g_afb_instance->wmgr.api_deactivate_window(
-        ctxt->name.c_str(), ctxt->role.c_str(),
-        [](const char *) {});
+    if (!ctxt->name.empty()) {
+      HMI_DEBUG("remove app %s", ctxt->name.c_str());
+
+      // Policy Manager does not know this app was killed,
+      // so notify it by deactivate request.
+      g_afb_instance->wmgr.api_deactivate_window(
+          ctxt->name.c_str(), ctxt->role.c_str(),
+          [](const char *) {});
+
+      g_afb_instance->wmgr.removeClient(ctxt->name);
+    }
+
+    // POI: LCM
+    g_afb_instance->wmgr.amgr.lcm_clear_context(ctxt->lcm_obs_ctx);
 
-    g_afb_instance->wmgr.removeClient(ctxt->name);
     delete ctxt;
 }
 
-static void createSecurityContext(afb_req_t req, const char* appid, const char* role)
+static WMClientCtxt* getWMClientContext(afb_req_t req)
 {
-    WMClientCtxt *ctxt = (WMClientCtxt *)afb_req_context_get(req);
-    if (!ctxt)
-    {
+    WMClientCtxt *ctx = static_cast<WMClientCtxt *>(afb_req_context_get(req));
+    if (!ctx) {
         // Create Security Context at first time
-        WMClientCtxt *ctxt = new WMClientCtxt(appid, role);
-        HMI_DEBUG("create session for %s", ctxt->name.c_str());
+        ctx = new WMClientCtxt();
+        HMI_DEBUG("create session without name & role");
         afb_req_session_set_LOA(req, 1);
-        afb_req_context_set(req, ctxt, cbRemoveClientCtxt);
+        afb_req_context_set(req, ctx, cbRemoveClientCtxt);
+    }
+    return ctx;
+}
+
+static void createSecurityContext(afb_req_t req, const char* appid, const char* role)
+{
+    WMClientCtxt *ctx = getWMClientContext(req);
+    if (ctx && ctx->name.empty())
+    {
+        HMI_DEBUG("create session for name=\"%s\" & role=\"role\"", appid, role);
+        ctx->set_name_role(appid, role);
     }
 }
 
@@ -490,6 +513,80 @@ void windowmanager_debug_terminate(afb_req_t req) noexcept
     }
 }
 
+/* AGL Lifecycle Management API */
+static void lcm_register_activity_observer (afb_req_t req)
+{
+  std::lock_guard<std::mutex> guard(binding_m);
+  if (g_afb_instance == nullptr) {
+    afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+    return;
+  }
+
+  WMClientCtxt* wc_ctx = getWMClientContext(req);
+  if (wc_ctx == nullptr) {
+    afb_req_fail(req, "failed", "WMClientCtxt cannot create.");
+  } else {
+    // register new activity observer
+    // {
+    //      id: "app id of target to observe",
+    //    type: "type of lifecycle, APP, HMI or GUI to observe",
+    //  filter: { states which observer wants to know }
+    // }
+    g_afb_instance->wmgr.amgr.api_register_activity_observer(req, wc_ctx->lcm_obs_ctx);
+    afb_req_success(req, NULL, "success");
+  }
+}
+
+static void lcm_unregister_activity_observer (afb_req_t req)
+{
+  std::lock_guard<std::mutex> guard(binding_m);
+  if (g_afb_instance == nullptr)
+  {
+    afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+    return;
+  }
+
+  WMClientCtxt* wc_ctx = getWMClientContext(req);
+  if (wc_ctx == nullptr) {
+    afb_req_fail(req, "failed", "WMClientCtxt not exsit.");
+    return;
+  }
+
+  // unregister activity observer
+  // {
+  //    id: "uniq id of observer"
+  // }
+  g_afb_instance->wmgr.amgr.api_unregister_activity_observer(req, wc_ctx->lcm_obs_ctx);
+
+  afb_req_success(req, NULL, "success");
+}
+
+static void lcm_get_activity_status(afb_req_t req)
+{
+  std::lock_guard<std::mutex> guard(binding_m);
+
+  if (g_afb_instance == nullptr) {
+    afb_req_fail(req, "failed", "Binding not initialized, did the compositor die?");
+  } else {
+    json_object *object = afb_req_json(req);
+    json_object *j_target = nullptr;
+    if (!json_object_object_get_ex(object, "target", &j_target)) {
+      afb_req_fail(req, "failed", "Need const char* argument target");
+      return;
+    }
+
+    const char *target_id = json_object_get_string(j_target);
+
+    auto ret = g_afb_instance->wmgr.amgr.api_get_activity_status(target_id);
+
+    if (ret.is_err()) {
+      afb_req_fail(req, "failed", ret.unwrap_err());
+    } else {
+      afb_req_success(req, ret.unwrap(), "success");
+    }
+  }
+}
+
 const afb_verb_t windowmanager_verbs[] = {
     { .verb = "requestSurface", .callback = windowmanager_requestsurface },
     { .verb = "requestSurfaceXDG", .callback = windowmanager_requestsurfacexdg },
@@ -501,6 +598,10 @@ const afb_verb_t windowmanager_verbs[] = {
     { .verb = "wm_subscribe", .callback = windowmanager_wm_subscribe },
     { .verb = "ping", .callback = windowmanager_ping },
     { .verb = "debug_terminate", .callback = windowmanager_debug_terminate },
+    /* AGL Lifecycle Management API */
+    { .verb = "registerActivityObserver", .callback = lcm_register_activity_observer },
+    { .verb = "unregisterActivityObserver", .callback = lcm_unregister_activity_observer },
+    { .verb = "getActivityStatus", .callback = lcm_get_activity_status },
     {} };
 
 extern "C" const afb_binding_t afbBindingExport = {