Add priority list APIs

Change-Id: Iacf4176a02757476c1ac20834679a95085827dde
Signed-off-by: Jusung Son <jusung07.son@samsung.com>

diff --git a/unittest/src/test-watchface-complication.cc b/unittest/src/test-watchface-complication.cc
index fa68bf0..c92366b 100644 (file)
--- a/unittest/src/test-watchface-complication.cc
+++ b/unittest/src/test-watchface-complication.cc
@@ -137,6 +137,7 @@ class CWC : public ::testing::Test {
   complication_allowed_list_h allowed_list_;
   complication_h complication_;
   complication_denied_list_h denied_list_;
+  complication_priority_list_h priority_list_;
   void RunLoop() {
     g_main_loop_run(loop_);
   }
@@ -144,6 +145,7 @@ class CWC : public ::testing::Test {
     complication_ = nullptr;
     allowed_list_ = nullptr;
     denied_list_ = nullptr;
+    priority_list_ = nullptr;
     loop_ = g_main_loop_new(NULL, FALSE);
     system_info_get_platform_bool_fake.custom_fake = __fake_system_info_get_platform_bool;
 
@@ -172,6 +174,8 @@ class CWC : public ::testing::Test {
       watchface_complication_allowed_list_destroy(allowed_list_);
     if (denied_list_!= nullptr)
       watchface_complication_denied_list_destroy(denied_list_);
+    if (priority_list_!= nullptr)
+      watchface_complication_priority_list_destroy(priority_list_);
     if (event_timer__ != 0) {
       g_source_remove(event_timer__);
       event_timer__ = 0;
@@ -737,4 +741,47 @@ TEST_F(CWC, watchface_complication_denied_list_apply)
   EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
 }
 
+TEST_F(CWC, watchface_complication_priority_list_apply)
+{
+  g_dbus_connection_signal_subscribe_fake.custom_fake =
+      __fake_signal_subscribe_on_data_updated;
+  int comp_id = 777;
+
+  int ret = watchface_complication_create(comp_id,
+    "org.tizen.gmock_comp_provider/test",
+    WATCHFACE_COMPLICATION_TYPE_SHORT_TEXT,
+    WATCHFACE_COMPLICATION_TYPE_SHORT_TEXT,
+    WATCHFACE_COMPLICATION_EVENT_TAP,
+    &complication_);
+  ret = watchface_complication_priority_list_create(&priority_list_);
+  EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
+
+  ret = watchface_complication_priority_list_add(priority_list_,
+      "org.tizen.gmock_comp_provider/test",
+      WATCHFACE_COMPLICATION_TYPE_SHORT_TEXT);
+  ret = watchface_complication_priority_list_add(priority_list_,
+      "org.tizen.gmock_comp_provider2/test",
+      WATCHFACE_COMPLICATION_TYPE_LONG_TEXT);
+  char* ret_provider_id;
+  int ret_type;
+
+  watchface_complication_priority_list_get_nth(priority_list_, 1,
+      &ret_provider_id, &ret_type);
+  EXPECT_STREQ(ret_provider_id, "org.tizen.gmock_comp_provider2/test");
+  free(ret_provider_id);
+
+  EXPECT_EQ(ret_type, WATCHFACE_COMPLICATION_TYPE_LONG_TEXT);
+
+  ret = watchface_complication_priority_list_apply(complication_,
+      priority_list_);
+  EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
+
+  ret = watchface_complication_priority_list_clear(complication_);
+  EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
+
+  ret = watchface_complication_priority_list_delete(priority_list_,
+      "org.tizen.gmock_comp_provider/test");
+  EXPECT_EQ(WATCHFACE_COMPLICATION_ERROR_NONE, ret);
+}
+
 }

diff --git a/watchface-complication/complication-implementation.h b/watchface-complication/complication-implementation.h
index d0c3cea..804535d 100644 (file)
--- a/watchface-complication/complication-implementation.h
+++ b/watchface-complication/complication-implementation.h
@@ -105,6 +105,7 @@ class Complication::Impl : IGDBus::IGDBusEvent, IPackageManager::IPackageEvent {
   std::list<std::shared_ptr<tizen_base::Bundle>> candidates_list_;
   std::list<std::unique_ptr<ProviderInfo>> allowed_list_;
   std::list<std::unique_ptr<ProviderInfo>> denied_list_;
+  std::list<std::unique_ptr<ProviderInfo>> priority_list_;
   std::list<std::string> privilege_list_;
   int cur_data_idx_ = -1;
   std::unique_ptr<tizen_base::Bundle> context_data_;

diff --git a/watchface-complication/complication.cc b/watchface-complication/complication.cc
index 124f416..7ca5b04 100644 (file)
--- a/watchface-complication/complication.cc
+++ b/watchface-complication/complication.cc
@@ -1052,6 +1052,24 @@ int Complication::Impl::UpdateCandidatesInfo() {
   if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
       return ret;
 
+  list<shared_ptr<tizen_base::Bundle>>::iterator it;
+  list<unique_ptr<ProviderInfo>>::reverse_iterator pri_it;
+
+  for (pri_it = priority_list_.rbegin(); pri_it != priority_list_.rend(); pri_it++) {
+    string priority_provider_id = (*pri_it)->GetProviderId();
+    string priority_type = std::to_string((*pri_it)->GetTypes());
+
+    for (it = candidates_list_.begin(); it != candidates_list_.end(); it++) {
+      string id = (*it)->GetString(provider_id_key_);
+      string type = (*it)->GetString(provider_type_key_);
+
+      if (priority_provider_id.compare(id) == 0 && priority_type.compare(type) == 0) {
+        candidates_list_.splice(candidates_list_.begin(), candidates_list_, it);
+        break;
+      }
+    }
+  }
+
   int idx = 0;
   for (auto& i : candidates_list_) {
     Bundle& data = *(i.get());
@@ -1108,6 +1126,15 @@ int Complication::ApplyDeniedList(
   return ret;
 }
 
+int Complication::ApplyPriorityList(
+      std::list<std::unique_ptr<ProviderInfo>> priority_list) {
+  impl_->priority_list_ = std::move(priority_list);
+  impl_->candidates_list_.clear();
+  impl_->UpdateCandidatesInfo();
+
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
+}
+
 int Complication::ClearAllowedList() {
   impl_->allowed_list_.clear();
   impl_->UpdateProviderInfo();
@@ -1120,6 +1147,12 @@ int Complication::ClearDeniedList() {
   return WATCHFACE_COMPLICATION_ERROR_NONE;
 }
 
+int Complication::ClearPriorityList() {
+  impl_->priority_list_.clear();
+  impl_->UpdateProviderInfo();
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
+}
+
 int Complication::GetDefaultData(
     string provider_id, int type, Bundle* default_data) {
   std::list<std::string> privlege_list =

diff --git a/watchface-complication/complication.h b/watchface-complication/complication.h
index f1d1845..9593f8c 100644 (file)
--- a/watchface-complication/complication.h
+++ b/watchface-complication/complication.h
@@ -104,7 +104,10 @@ class EXPORT_API Complication : public IEditable
       std::list<std::unique_ptr<ProviderInfo>> allowed_list);
   int ApplyDeniedList(
       std::list<std::unique_ptr<ProviderInfo>> denied_list);
+  int ApplyPriorityList(
+      std::list<std::unique_ptr<ProviderInfo>> allowed_list);
   int ClearAllowedList();
+  int ClearPriorityList();
   int ClearDeniedList();
   int Init();
   void SetListeningStatus(watchface_complication_consumer_status_e state);

diff --git a/watchface-complication/include/watchface-complication-internal.h b/watchface-complication/include/watchface-complication-internal.h
index 34a752f..9a73cd3 100644 (file)
--- a/watchface-complication/include/watchface-complication-internal.h
+++ b/watchface-complication/include/watchface-complication-internal.h
@@ -31,6 +31,7 @@ int watchface_complication_data_get_aod_image_path(const bundle *shared_data,
         char **image_path);
 
 typedef struct complication_denied_list_ *complication_denied_list_h;
+typedef struct complication_priority_list_ *complication_priority_list_h;
 
 int watchface_complication_denied_list_create(
         complication_denied_list_h *handle);
@@ -47,6 +48,21 @@ int watchface_complication_denied_list_apply(complication_h handle,
         complication_denied_list_h list_handle);
 int watchface_complication_denied_list_clear(complication_h handle);
 
+int watchface_complication_priority_list_create(
+        complication_priority_list_h *handle);
+int watchface_complication_priority_list_destroy(
+        complication_priority_list_h handle);
+int watchface_complication_priority_list_add(complication_priority_list_h handle,
+        const char *provider_id, int types);
+int watchface_complication_priority_list_delete(complication_priority_list_h handle,
+        const char *provider_id);
+int watchface_complication_priority_list_get_nth(
+        complication_priority_list_h handle, int index,
+        char **provider_id, int *types);
+int watchface_complication_priority_list_apply(complication_h handle,
+        complication_priority_list_h list_handle);
+int watchface_complication_priority_list_clear(complication_h handle);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/watchface-complication/watchface-complication.cc b/watchface-complication/watchface-complication.cc
index f990011..eeb3f7e 100644 (file)
--- a/watchface-complication/watchface-complication.cc
+++ b/watchface-complication/watchface-complication.cc
@@ -48,6 +48,10 @@ struct complication_denied_list_ {
   GList* denied_list;
 };
 
+struct complication_priority_list_ {
+  GList* priority_list;
+};
+
 using namespace std;
 using namespace tizen_base;
 using namespace watchface_complication;
@@ -1239,3 +1243,183 @@ extern "C" EXPORT_API int watchface_complication_denied_list_clear(
   return ptr.get()->ClearDeniedList();
 }
 
+extern "C" EXPORT_API int watchface_complication_priority_list_create(
+    complication_priority_list_h* handle) {
+  complication_priority_list_h h = nullptr;
+
+  if (!watchface_complication::util::CheckWatchFeatureEnabled())
+    return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
+
+  if (handle == nullptr) {
+    LOGE("Invalid param");
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
+  }
+
+  h = (complication_priority_list_h)calloc(1,
+      sizeof(struct complication_priority_list_));
+  if (h == nullptr) {
+    LOGE("Out of memory");
+    return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
+  }
+
+  *handle = h;
+
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
+}
+
+extern "C" EXPORT_API int watchface_complication_priority_list_destroy(
+    complication_priority_list_h handle) {
+  if (!watchface_complication::util::CheckWatchFeatureEnabled())
+    return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
+
+  if (handle == nullptr) {
+    LOGE("Invalid param");
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
+  }
+
+  if (handle->priority_list)
+    g_list_free_full(handle->priority_list, __free_provider_info);
+  free(handle);
+
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
+}
+
+extern "C" EXPORT_API int watchface_complication_priority_list_add(
+    complication_priority_list_h handle, const char* provider_id, int type) {
+  if (!watchface_complication::util::CheckWatchFeatureEnabled())
+    return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
+
+  if (handle == nullptr || provider_id == nullptr) {
+    LOGE("Invalid param");
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
+  }
+
+  GList* find = g_list_find_custom(handle->priority_list, provider_id,
+      __provider_info_cmp);
+  if (find) {
+    LOGE("Provider id (%s) already exist", provider_id);
+    return WATCHFACE_COMPLICATION_ERROR_EXIST_ID;
+  }
+
+  provider_info* info = reinterpret_cast<provider_info*>(calloc(1,
+                            sizeof(provider_info)));
+  if (info == nullptr) {
+    LOGE("Out of memory");
+    return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
+  }
+  info->provider_id = strdup(provider_id);
+  if (info->provider_id == nullptr) {
+    LOGE("Out of memory");
+    free(info);
+    return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
+  }
+  info->types = type;
+  handle->priority_list = g_list_append(handle->priority_list, info);
+
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
+}
+
+extern "C" EXPORT_API int watchface_complication_priority_list_delete(
+    complication_priority_list_h handle, const char* provider_id) {
+  if (!watchface_complication::util::CheckWatchFeatureEnabled())
+    return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
+
+  if (handle == nullptr || provider_id == nullptr || handle->priority_list == nullptr) {
+    LOGE("Invalid param");
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
+  }
+
+  GList* find = g_list_find_custom(handle->priority_list,
+      provider_id, __provider_info_cmp);
+  if (!find) {
+    LOGE("Provider id (%s) already exist", provider_id);
+    return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
+  }
+
+  provider_info* data = reinterpret_cast<provider_info*>(find->data);
+  handle->priority_list = g_list_remove(handle->priority_list, find->data);
+  __free_provider_info(data);
+
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
+}
+
+extern "C" EXPORT_API int watchface_complication_priority_list_get_nth(
+    complication_priority_list_h handle, int index, char** provider_id,
+    int* types) {
+  if (!watchface_complication::util::CheckWatchFeatureEnabled())
+    return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
+
+  if (handle == nullptr || provider_id == nullptr || types == nullptr ||
+      handle->priority_list == nullptr ||
+      index >= static_cast<int>(g_list_length(handle->priority_list)) ||
+      index < 0) {
+    LOGE("Invalid param");
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
+  }
+  provider_info* info =
+    reinterpret_cast<provider_info*>(g_list_nth_data(handle->priority_list,
+                    index));
+  if (info == nullptr || info->provider_id == nullptr) {
+    LOGE("fail to get provider id");
+    return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;
+  }
+  char* id = strdup(info->provider_id);
+  if (id == nullptr) {
+    LOGE("Out of memory");
+    return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
+  }
+  *provider_id = id;
+  *types = info->types;
+
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
+}
+
+extern "C" EXPORT_API int watchface_complication_priority_list_apply(
+    complication_h handle, complication_priority_list_h list_handle) {
+  if (!watchface_complication::util::CheckWatchFeatureEnabled())
+    return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
+
+  if (handle == nullptr || list_handle == nullptr || list_handle->priority_list == nullptr
+      || g_list_length(list_handle->priority_list) == 0) {
+    LOGE("Invalid param");
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
+  }
+
+  auto sh = static_cast<SharedHandle<WatchComplicationStub>*>(handle);
+  auto ptr = SharedHandle<WatchComplicationStub>::Share(sh);
+  std::list<std::unique_ptr<Complication::ProviderInfo>> priority_list;
+
+  for (unsigned int i = 0; i < g_list_length(list_handle->priority_list); i++) {
+    provider_info* info =
+      reinterpret_cast<provider_info*>(g_list_nth_data(
+                    list_handle->priority_list, i));
+    if (info == nullptr || info->provider_id == nullptr)
+      continue;
+    try {
+      priority_list.emplace_back(std::unique_ptr<Complication::ProviderInfo>(
+        new Complication::ProviderInfo(
+          std::string(info->provider_id), info->types)));
+    } catch(const std::bad_alloc &ba) {
+      LOGE("ProviderInfo::Exception bad_alloc");
+      return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;
+    }
+  }
+
+  return  ptr.get()->ApplyPriorityList(std::move(priority_list));
+}
+
+extern "C" EXPORT_API int watchface_complication_priority_list_clear(
+    complication_h handle) {
+  if (!watchface_complication::util::CheckWatchFeatureEnabled())
+    return WATCHFACE_COMPLICATION_ERROR_NOT_SUPPORTED;
+
+  if (handle == nullptr) {
+    LOGE("Invalid param");
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
+  }
+  auto sh = static_cast<SharedHandle<WatchComplicationStub>*>(handle);
+  auto ptr = SharedHandle<WatchComplicationStub>::Share(sh);
+
+  return ptr.get()->ClearPriorityList();
+}
+