Fix OnConsumerStatusChange bug

Change-Id: I73a1983f6e9dc3d45b66e1098af5b62b00683049
Signed-off-by: hyunho <hhstark.kang@samsung.com>

diff --git a/watchface-complication-provider/complication-provider-implementation.hh b/watchface-complication-provider/complication-provider-implementation.hh
index a5e8bab..e6fbee0 100644 (file)
--- a/watchface-complication-provider/complication-provider-implementation.hh
+++ b/watchface-complication-provider/complication-provider-implementation.hh
@@ -22,6 +22,7 @@
 #include <memory>
 #include <string>
 #include <list>
+#include <vector>
 #include <map>
 
 #include "watchface-complication/complication.hh"
@@ -62,7 +63,8 @@ class ComplicationProvider::Impl : IGDBus::IGDBusEvent {
     cynara_result GetPrivilegeResult();
     void SetPrivilegeResult(cynara_result result);
     int GetListeningCount() const;
-    void SetListeningCount(int count);
+    void AddListeningComp(int comp_id);
+    void RemoveListeningComp(int comp_id);
 
    private:
     std::string sender_name_;
@@ -71,7 +73,7 @@ class ComplicationProvider::Impl : IGDBus::IGDBusEvent {
     std::string watch_name_;
     std::list<std::string> sender_privileges_;
     cynara_result privilege_result_;
-    int listening_count_ = 0;
+    std::vector<int> listening_comps_;
   };
   SenderInfo* GetSenderInfo(std::string sender_name,
       GDBusConnection* connection, GVariant* parameters);

diff --git a/watchface-complication-provider/complication-provider.cc b/watchface-complication-provider/complication-provider.cc
index 037f825..1f6292b 100644 (file)
--- a/watchface-complication-provider/complication-provider.cc
+++ b/watchface-complication-provider/complication-provider.cc
@@ -18,12 +18,12 @@
 #include <unistd.h>
 
 #include <list>
+#include <algorithm>
 
 #include "watchface-common/watchface-util.hh"
 #include "watchface-common/watchface-common-internal.hh"
 #include "watchface-complication-provider/complication-provider.hh"
 #include "watchface-complication-provider/complication-provider-implementation.hh"
-#include "watchface-complication-provider/include/watchface-complication-provider.h"
 
 #ifdef LOG_TAG
 #undef LOG_TAG
@@ -37,7 +37,6 @@ namespace watchface_complication {
 
 ComplicationProvider::ComplicationProvider(const std::string& provider_id)
                                        : impl_(new Impl(this, provider_id)) {
-  impl_->NotifyProviderReady();
 }
 
 ComplicationProvider::~ComplicationProvider() = default;
@@ -133,11 +132,26 @@ int ComplicationProvider::Impl::SenderInfo::GetWatcherID() {
 }
 
 int ComplicationProvider::Impl::SenderInfo::GetListeningCount() const {
-  return listening_count_;
+  return listening_comps_.size();
 }
 
-void ComplicationProvider::Impl::SenderInfo::SetListeningCount(int count) {
-  listening_count_ = count;
+void ComplicationProvider::Impl::SenderInfo::AddListeningComp(int comp_id) {
+  if (std::find(listening_comps_.begin(), listening_comps_.end(), comp_id)
+          != listening_comps_.end()) {
+    LOGE("Already exist id (%d)", comp_id);
+    return;
+  }
+  listening_comps_.push_back(comp_id);
+}
+
+void ComplicationProvider::Impl::SenderInfo::RemoveListeningComp(int comp_id) {
+  std::vector<int>::iterator iter = std::find(listening_comps_.begin(),
+      listening_comps_.end(), comp_id);
+  if (iter == listening_comps_.end()) {
+    LOGW("Not exist id (%d)", comp_id);
+    return;
+  }
+  listening_comps_.erase(iter);
 }
 
 std::string& ComplicationProvider::Impl::SenderInfo::GetWatchName() {
@@ -164,8 +178,7 @@ void ComplicationProvider::Impl::OnVanish(const std::string& watch_name) {
     SenderInfo* si = iter->second;
     if (watch_name.compare(si->GetWatchName()) == 0) {
       if (si->GetListeningCount() > 0)
-        parent_->OnConsumerStatusChange(si->GetAppid(),
-            WATCHFACE_COMPLICATION_CONSUMER_LISTENING_STOP);
+        parent_->OnConsumerStatusChange(si->GetAppid(), false);
 
       gdbus_.get()->UnWatch(si->GetWatcherID());
       sender_info_.erase(iter);
@@ -176,15 +189,6 @@ void ComplicationProvider::Impl::OnVanish(const std::string& watch_name) {
   }
 }
 
-int ComplicationProvider::Impl::NotifyProviderReady() {
-  LOGI("notify %s", provider_id_.c_str());
-  if (!gdbus_.get()->EmitSignal(IGDBus::Complication, "",
-      provider_id_, -1, util::GetCmdStr(util::ProviderReady),
-      g_variant_new("(s)", provider_id_.c_str())))
-    return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;
-  return WATCHFACE_COMPLICATION_ERROR_NONE;
-}
-
 void ComplicationProvider::Impl::OnAppear(const std::string& name,
     const std::string& name_owner) {
 }
@@ -332,10 +336,11 @@ void ComplicationProvider::Impl::OnSignal(GDBusConnection* connection,
     }
   } else if(signal_name.compare(util::GetCmdStr(
                  util::CmdType::CompNotifyListeningStatus)) == 0) {
-    watchface_complication_consumer_status_e state;
+    int state;
     int type;
+    int comp_id;
     char* sender_app_id = nullptr;
-    g_variant_get(parameters, "(&sii)", &sender_app_id, &type, &state);
+    g_variant_get(parameters, "(&siii)", &sender_app_id, &type, &comp_id, &state);
 
     if (si->CheckAppid(sender_app_id) == false) {
       LOGE("invaild app id [%s]", sender_app_id);
@@ -352,19 +357,16 @@ void ComplicationProvider::Impl::OnSignal(GDBusConnection* connection,
       return;
     }
 
-    int listening_count = si->GetListeningCount();
-
-    if (state == WATCHFACE_COMPLICATION_CONSUMER_LISTENING_START)
-      listening_count++;
+    bool prev_is_listening = (bool)si->GetListeningCount();
+    if (state)
+      si->AddListeningComp(comp_id);
     else
-      listening_count--;
-
-    si->SetListeningCount(listening_count);
-
-    if ((state == WATCHFACE_COMPLICATION_CONSUMER_LISTENING_START && listening_count == 1)
-         || (state == WATCHFACE_COMPLICATION_CONSUMER_LISTENING_STOP && listening_count == 0))
-      parent_->OnConsumerStatusChange(sender_app_id, state);
+      si->RemoveListeningComp(comp_id);
 
+    bool is_listening = (bool)si->GetListeningCount();
+    LOGI("listening state %d -> %d", (int)prev_is_listening, (int)is_listening);
+    if (prev_is_listening != is_listening)
+      parent_->OnConsumerStatusChange(sender_app_id, (bool)state);
   }
 }
 
@@ -374,7 +376,7 @@ void ComplicationProvider::OnDataUpdateRequest(const std::string& sender_appid,
 }
 
 void ComplicationProvider::OnConsumerStatusChange(const std::string& sender_appid,
-    watchface_complication_consumer_status_e status) {
+    bool is_listening) {
 }
 
 /* LCOV_EXCL_STOP */

diff --git a/watchface-complication-provider/complication-provider.hh b/watchface-complication-provider/complication-provider.hh
index 876615b..6c47f1e 100644 (file)
--- a/watchface-complication-provider/complication-provider.hh
+++ b/watchface-complication-provider/complication-provider.hh
@@ -37,7 +37,7 @@ class EXPORT_API ComplicationProvider : public IComplicationEvent {
                            const tizen_base::Bundle& context,
                            tizen_base::Bundle* shared_data) override;
   void OnConsumerStatusChange(const std::string& sender_appid,
-       watchface_complication_consumer_status_e status) override;
+                           bool is_listening) override;
 
   int NotifyDataUpdate();
   const std::string& GetProviderId() const;

diff --git a/watchface-complication-provider/watchface-complication-provider.cc b/watchface-complication-provider/watchface-complication-provider.cc
index ca13357..3dff9d3 100644 (file)
--- a/watchface-complication-provider/watchface-complication-provider.cc
+++ b/watchface-complication-provider/watchface-complication-provider.cc
@@ -108,13 +108,19 @@ class WatchComplicationProviderStub : public ComplicationProvider {
   }
 
   void OnConsumerStatusChange(const std::string& sender_appid,
-        watchface_complication_consumer_status_e status) override {
-    if (status_cb_ == nullptr)
+        bool is_listening) override {
+    if (status_cb_ == nullptr) {
+      LOGI("status callback is not registered");
       return;
+    }
 
     LOGI("ConsumerStatusChange call done provider(%s) sender(%s) %d ",
-        GetProviderId().c_str(), sender_appid.c_str(), status);
-
+        GetProviderId().c_str(), sender_appid.c_str(), is_listening);
+    watchface_complication_consumer_status_e status;
+    if (is_listening)
+      status = WATCHFACE_COMPLICATION_CONSUMER_LISTENING_START;
+    else
+      status = WATCHFACE_COMPLICATION_CONSUMER_LISTENING_STOP;
     status_cb_(GetProviderId().c_str(), sender_appid.c_str(), status, user_data_);
   }
 
@@ -226,8 +232,10 @@ extern "C" EXPORT_API void watchface_complication_provider_set_consumer_status_c
   __status_cb = callback;
   __user_data = user_data;
 
-  for (auto& i : __providers)
+  for (auto& i : __providers) {
+    LOGI("Set status callback for (%s)", i.second->GetProviderId().c_str());
     i.second->SetStatusCallback(callback, user_data);
+  }
 }
 
 extern "C" EXPORT_API int watchface_complication_provider_notify_update(

diff --git a/watchface-complication/complication-event-interface.hh b/watchface-complication/complication-event-interface.hh
index de96935..4a17830 100644 (file)
--- a/watchface-complication/complication-event-interface.hh
+++ b/watchface-complication/complication-event-interface.hh
@@ -22,7 +22,6 @@
 #include <string>
 
 #include "watchface-complication/complication-internal.hh"
-#include "watchface-complication-provider/include/watchface-complication-provider-internal.h"
 
 namespace watchface_complication {
 
@@ -33,7 +32,7 @@ class EXPORT_API IComplicationEvent {
                                    const tizen_base::Bundle& context,
                                    tizen_base::Bundle* shared_data) = 0;
  virtual void OnConsumerStatusChange(const std::string& sender_appid,
-                                   watchface_complication_consumer_status_e status) = 0;
+                                   bool is_listening) = 0;
 };
 
 }  // namespace watchface_complication

diff --git a/watchface-complication/complication-implementation.hh b/watchface-complication/complication-implementation.hh
index 0d86092..bc9b438 100644 (file)
--- a/watchface-complication/complication-implementation.hh
+++ b/watchface-complication/complication-implementation.hh
@@ -84,7 +84,6 @@ class Complication::Impl : IGDBus::IGDBusEvent, IPackageManager::IPackageEvent {
                     const std::string& sender_name);
   void UpdatedProcess(GVariant* parameters);
   void NotifyDataUpdateProcess(GVariant* parameters);
-  void ProviderReadyProcess(GVariant* parameters);
   int UpdateCurProvider(std::string new_provider_id, ComplicationType type);
 
  private:
@@ -127,7 +126,7 @@ class Complication::Impl : IGDBus::IGDBusEvent, IPackageManager::IPackageEvent {
   EditablesManager& editables_manager_;
   bool mock_ = false;
   bool is_provider_ready_ = false;
-  int listening_status_ = 0;
+  bool is_listening_ = false;
 };
 
 }  // namespace watchface_complication

diff --git a/watchface-complication/complication.cc b/watchface-complication/complication.cc
index 67101d4..a6d2501 100644 (file)
--- a/watchface-complication/complication.cc
+++ b/watchface-complication/complication.cc
@@ -27,7 +27,6 @@
 #include "watchface-common/watchface-util.hh"
 #include "watchface-common/watchface-common-internal.hh"
 #include "watchface-complication/complication-internal.hh"
-#include "watchface-complication/include/watchface-complication-internal.h"
 
 #include <iostream>
 
@@ -165,6 +164,14 @@ void Complication::Impl::OnVanish(const std::string& name) {
 void Complication::Impl::OnAppear(const std::string& name,
     const std::string& name_owner) {
   LOGI("OnAppear %s  ", name.c_str());
+  string cur_name = util::EncodeStr(util::EncodeType::Name, cur_provider_appid_);
+  if (cur_name.compare(name) != 0) {
+    LOGW("It is not current provider (%s)", cur_provider_appid_.c_str());
+    return;
+  }
+  is_provider_ready_ = true;
+  if (is_listening_)
+    parent_->NotifyListeningStart();
 }
 
 bool Complication::Impl::IsValidSender(GDBusConnection* connection,
@@ -230,22 +237,6 @@ void Complication::Impl::NotifyDataUpdateProcess(GVariant* parameters) {
   parent_->OnNotifyDataUpdate();
 }
 
-void Complication::Impl::ProviderReadyProcess(GVariant* parameters) {
-  char* provider_id;
-  g_variant_get(parameters, "(&s)", &provider_id);
-  if (strcmp(cur_provider_id_.c_str(), provider_id) != 0) {
-    LOGI("It's not mine %s", provider_id);
-    return;
-  }
-
-  is_provider_ready_ = true;
-
-  if (listening_status_ == WATCHFACE_COMPLICATION_CONSUMER_LISTENING_START)
-    parent_->NotifyListeningStatus(WATCHFACE_COMPLICATION_CONSUMER_LISTENING_START);
-  else
-    LOGI("Not exist registered callback %s", provider_id);
-}
-
 void Complication::Impl::OnSignal(GDBusConnection* connection,
                                   const std::string& sender_name,
                                   const std::string& object_path,
@@ -262,9 +253,6 @@ void Complication::Impl::OnSignal(GDBusConnection* connection,
   } else if (signal_name.compare(
       util::GetCmdStr(util::CompNotifyDataUpdate)) == 0) {
     NotifyDataUpdateProcess(parameters);
-  } else if (signal_name.compare(
-      util::GetCmdStr(util::ProviderReady)) == 0) {
-    ProviderReadyProcess(parameters);
   }
 }
 
@@ -456,8 +444,6 @@ int Complication::Impl::UpdateProviderInfo() {
     LOGI("subscribe signal %d %d ", subscribe_id_, cur_type_);
   }
 
-  is_provider_ready_ = false;
-
   return ret;
 }
 
@@ -516,10 +502,8 @@ int Complication::Impl::UpdateCurProvider(std::string new_provider_id,
   if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
     return ret;
 
-  if (!cur_provider_id_.empty()) {
-    parent_->NotifyListeningStatus(WATCHFACE_COMPLICATION_CONSUMER_LISTENING_STOP);
-    is_provider_ready_ = false;
- }
+  if (!cur_provider_id_.empty())
+    parent_->NotifyListeningStatus(false);
 
   cur_type_ = type;
   cur_provider_id_ = new_provider_id;
@@ -545,19 +529,25 @@ int Complication::UpdateLastData() {
   return WATCHFACE_COMPLICATION_ERROR_NONE;
 }
 
-void Complication::SetListeningStatus(
-    watchface_complication_consumer_status_e state) {
-  impl_->listening_status_ = state;
-  NotifyListeningStatus(state);
+void Complication::NotifyListeningStart() {
+  LOGI("Listening start(%d)", (int)impl_->is_provider_ready_);
+  impl_->is_listening_ = true;
+  if (impl_->is_provider_ready_)
+    NotifyListeningStatus(impl_->is_listening_);
+}
+
+void Complication::NotifyListeningStop() {
+  LOGI("Listening stop(%d)", (int)impl_->is_provider_ready_);
+  impl_->is_listening_ = false;
+  if (impl_->is_provider_ready_)
+    NotifyListeningStatus(impl_->is_listening_);
 }
 
 void Complication::NotifyListeningStatus(
-    watchface_complication_consumer_status_e state) {
-  if (impl_->is_provider_ready_ == false)
-    return;
+    bool is_listening) {
 
   LOGI("emit signal comp_id %d, type %d %d",
-       impl_->complication_id_,  impl_->cur_type_, state);
+       impl_->complication_id_,  impl_->cur_type_, is_listening);
 
   std::string provider_appid = DBManager::GetProviderAppId(
       impl_->cur_provider_id_.c_str());
@@ -574,15 +564,16 @@ void Complication::NotifyListeningStatus(
       impl_->cur_provider_id_,
       -1,
       util::GetCmdStr(util::CompNotifyListeningStatus),
-      g_variant_new("(sii)",
+      g_variant_new("(siii)",
                     util::GetAppId().c_str(),
                     impl_->cur_type_,
-                    state));
+                    impl_->complication_id_,
+                    (int)is_listening));
   if (!emit_ret)
       LOGE("EmitSignal failed %s: %d",
-         impl_->cur_provider_id_.c_str(), state);
+         impl_->cur_provider_id_.c_str(), is_listening);
 
-  if (state == WATCHFACE_COMPLICATION_CONSUMER_LISTENING_START)
+  if (is_listening)
     SendDataUpdateRequest(false);
 
   LOGI("emit signal done");

diff --git a/watchface-complication/complication.hh b/watchface-complication/complication.hh
index 4b1c78a..5fc31c9 100755 (executable)
--- a/watchface-complication/complication.hh
+++ b/watchface-complication/complication.hh
@@ -31,7 +31,6 @@
 #include "watchface-complication/editables-manager.hh"
 #include "watchface-common/db-manager.hh"
 #include "watchface-common/watchface-exception.hh"
-#include "watchface-complication-provider/include/watchface-complication-provider-internal.h"
 
 namespace watchface_complication {
 
@@ -111,8 +110,9 @@ class EXPORT_API Complication : public IEditable
   int ClearPriorityList();
   int ClearDeniedList();
   int Init();
-  void SetListeningStatus(watchface_complication_consumer_status_e state);
-  void NotifyListeningStatus(watchface_complication_consumer_status_e state);
+  void NotifyListeningStart();
+  void NotifyListeningStop();
+  void NotifyListeningStatus(bool is_listening);
 
  public:
   static const char* GetProviderIdKey();

diff --git a/watchface-complication/watchface-complication.cc b/watchface-complication/watchface-complication.cc
index da1f9d5..c7afec9 100644 (file)
--- a/watchface-complication/watchface-complication.cc
+++ b/watchface-complication/watchface-complication.cc
@@ -164,28 +164,27 @@ class WatchComplicationStub : public Complication {
 
   int AddCallbackInfo(unique_ptr<CallbackInfo> ci) {
     for (auto& i : cb_list_) {
-      if (i.get()->GetCallback() == ci->GetCallback()) {
-        LOGI("already registered callback");
-        return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
-      }
+      if (i.get()->GetCallback() != ci->GetCallback())
+        continue;
+      LOGI("already registered callback");
+      return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
     }
+    if (cb_list_.empty())
+      NotifyListeningStart();
     cb_list_.emplace_back(move(ci));
-    if (cb_list_.size() == 1)
-      SetListeningStatus(WATCHFACE_COMPLICATION_CONSUMER_LISTENING_START);
-
     return WATCHFACE_COMPLICATION_ERROR_NONE;
   }
 
   int RemoveCallbackInfo(watchface_complication_updated_cb cb) {
     for (auto& i : cb_list_) {
-      if (i.get()->GetCallback() == cb) {
-        cb_list_.remove(i);
+      if (i.get()->GetCallback() != cb)
+        continue;
 
-        if (cb_list_.size() == 0)
-          SetListeningStatus(WATCHFACE_COMPLICATION_CONSUMER_LISTENING_STOP);
+      cb_list_.remove(i);
+      if (cb_list_.empty())
+        NotifyListeningStop();
 
-        return WATCHFACE_COMPLICATION_ERROR_NONE;
-      }
+      return WATCHFACE_COMPLICATION_ERROR_NONE;
     }
     return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
   }