Check coding style

Change-Id: Icdaa9b4b86d920aa170bc5640da6d5bb3fbe8138
Signed-off-by: mk5004.lee <mk5004.lee@samsung.com>

diff --git a/watchface-complication-provider/watchface-complication-provider.cc b/watchface-complication-provider/watchface-complication-provider.cc
index 35dcd1d..4cad514 100644 (file)
--- a/watchface-complication-provider/watchface-complication-provider.cc
+++ b/watchface-complication-provider/watchface-complication-provider.cc
@@ -356,7 +356,7 @@ static int _get_data_type(bundle* shared_data,
 
   ret = bundle_get_str(shared_data, DATA_TYPE_KEY, &type_str);
   if (ret != BUNDLE_ERROR_NONE) {
-    LOGE("Invalid data fail to get type !!");
+    LOGE("failed to get data type %d", ret);
     return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
   }
 
@@ -674,7 +674,7 @@ static int _get_value_from_touch_launch_data(app_control_h handle,
 
   ret = bundle_get_str(data, key, &bundle_val);
   if (ret != BUNDLE_ERROR_NONE) {
-    LOGE("Fail to get data from bundle");
+    LOGE("Fail to get data from bundle %d", ret);
     bundle_free(data);
     return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
   }

diff --git a/watchface-complication/complication-bundle.cc b/watchface-complication/complication-bundle.cc
index 00976bb..58033b8 100644 (file)
--- a/watchface-complication/complication-bundle.cc
+++ b/watchface-complication/complication-bundle.cc
@@ -86,14 +86,12 @@ bundle* Bundle::GetRaw() {
 
 const char* Bundle::ToString() {
   int str_len = 0;
-  int ret;
   bundle_raw* temp;
 
   if (str_raw_ != NULL)
     return str_raw_;
 
-  ret = bundle_encode(raw_, &temp, &str_len);
-  if (ret != BUNDLE_ERROR_NONE)
+  if (bundle_encode(raw_, &temp, &str_len) != BUNDLE_ERROR_NONE)
     THROW(WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY);
 
   str_raw_ = reinterpret_cast<char*>(temp);

diff --git a/watchface-complication/complication-connector.cc b/watchface-complication/complication-connector.cc
index 6004368..1cb0cd5 100644 (file)
--- a/watchface-complication/complication-connector.cc
+++ b/watchface-complication/complication-connector.cc
@@ -271,7 +271,7 @@ int ComplicationConnector::Init() {
   ret = aul_app_get_appid_bypid(pid, appid, sizeof(appid));
   if (ret != AUL_R_OK) {
     g_object_unref(tmp_impl->conn_);
-    LOGE("Fail to get appid");
+    LOGE("Fail to get appid %d", ret);
     return WATCHFACE_COMPLICATION_ERROR_IO_ERROR;;
   }
   tmp_impl->appid_ = std::string(appid);

diff --git a/watchface-complication/complication.cc b/watchface-complication/complication.cc
index ba1f444..00af3c9 100644 (file)
--- a/watchface-complication/complication.cc
+++ b/watchface-complication/complication.cc
@@ -499,7 +499,6 @@ int Complication::Impl::UpdateLastDataFields() {
 * cur_provider_id_, cur_provider_type_
 */
 int Complication::Impl::UpdateProviderInfo() {
-
   /* Update cur_data_idx_ */
   int ret = LoadCurDataIdx();
   if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
@@ -679,7 +678,6 @@ void Complication::SetLabel(const std::string& name) {
 
 void Complication::OnEditableUpdated(int selected_idx,
     IEditable::EditableState state) {
-
   if (state == OnGoing) {
     LOGI("ongoing editing : %d", impl_->complication_id_);
     std::unique_ptr<Bundle> ptr = nullptr;
@@ -840,8 +838,8 @@ int Complication::UpdateLastContext() {
   try {
     int ret = EditablesManager::GetInst().StoreContext(impl_->complication_id_,
         impl_->cur_provider_id_.c_str(), *impl_->context_data_.get());
-  if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
-    return ret;
+    if (ret != WATCHFACE_COMPLICATION_ERROR_NONE)
+      return ret;
   } catch (Exception &ex) {
     LOGE("%s %d", ex.what(), ex.GetErrorCode());
     return ex.GetErrorCode();
@@ -958,21 +956,16 @@ std::string Complication::Impl::GetNotSupportedPrivileges(
 
 int Complication::Impl::GetNotSupportedEvents(
     std::string provider_id) {
-
   int required_events = DBManager::GetRequiredSupportEvents(provider_id);
-  int not_supported_events = 0;
 
   LOGI("required events (%d) supported events(%d)",
       required_events, supported_event_types_);
   if (required_events > 0) {
-    not_supported_events =
-      (required_events & supported_event_types_) ^ required_events;
+    return (required_events & supported_event_types_) ^ required_events;
   } else {
     LOGE("fail to get required events");
     return -1;
   }
-
-  return not_supported_events;
 }
 
 int Complication::Impl::AddCandidate(std::string provider_id, int type) {

diff --git a/watchface-complication/db-manager.cc b/watchface-complication/db-manager.cc
index 2382f8a..605f70b 100644 (file)
--- a/watchface-complication/db-manager.cc
+++ b/watchface-complication/db-manager.cc
@@ -40,7 +40,7 @@ DBManager::DBManager() = default;
 DBManager::~DBManager() = default;
 
 sqlite3* DBManager::OpenDB() {
-  int ret = SQLITE_OK;
+  int ret;
   const char* path;
   sqlite3* db = NULL;
 
@@ -73,7 +73,6 @@ std::unique_ptr<Bundle> DBManager::GetDefaultData(const char* provider_id,
   const char* raw_data;
   sqlite3_stmt* stmt;
   sqlite3* db;
-  int ret;
   int trusted;
   std::string provider_app_id;
 
@@ -87,9 +86,7 @@ std::unique_ptr<Bundle> DBManager::GetDefaultData(const char* provider_id,
     return nullptr;
   }
 
-  ret = sqlite3_prepare_v2(db,
-                        query, strlen(query), &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return nullptr;
@@ -118,13 +115,11 @@ std::unique_ptr<Bundle> DBManager::GetDefaultData(const char* provider_id,
 }
 
 int DBManager::GetProviderPeriod(std::string& provider_id, int* period) {
-  int ret;
   sqlite3_stmt* stmt = NULL;
   sqlite3* db;
 
   static const char query[] =
-    "SELECT period FROM complication_provider "
-    "WHERE provider_id=?";
+    "SELECT period FROM complication_provider WHERE provider_id=?";
 
   db = OpenDB();
   if (db == NULL) {
@@ -132,9 +127,7 @@ int DBManager::GetProviderPeriod(std::string& provider_id, int* period) {
     return WATCHFACE_COMPLICATION_ERROR_DB;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return WATCHFACE_COMPLICATION_ERROR_DB;
@@ -154,9 +147,7 @@ int DBManager::GetProviderPeriod(std::string& provider_id, int* period) {
   return WATCHFACE_COMPLICATION_ERROR_NONE;
 }
 
-bool DBManager::IsProviderExist(std::string& provider_id,
-    int support_type) {
-  int ret;
+bool DBManager::IsProviderExist(std::string& provider_id, int support_type) {
   sqlite3_stmt* stmt = NULL;
   sqlite3* db;
   bool is_exist = false;
@@ -173,9 +164,7 @@ bool DBManager::IsProviderExist(std::string& provider_id,
     return false;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return false;
@@ -201,15 +190,13 @@ bool DBManager::IsProviderExist(std::string& provider_id,
 }
 
 std::string DBManager::GetProviderAppId(const char* provider_id) {
-  int ret;
   sqlite3_stmt* stmt = NULL;
   sqlite3* db;
   int trusted;
   std::string provider_app_id;
 
   static const char query[] =
-    "SELECT trusted, appid FROM complication_provider "
-    "WHERE provider_id=?";
+    "SELECT trusted, appid FROM complication_provider WHERE provider_id=?";
 
   db = OpenDB();
   if (db == NULL) {
@@ -217,9 +204,7 @@ std::string DBManager::GetProviderAppId(const char* provider_id) {
     return std::string();
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return std::string();
@@ -246,7 +231,6 @@ std::string DBManager::GetProviderAppId(const char* provider_id) {
 
 std::list<std::unique_ptr<DBManager::ProviderInfo>>
 DBManager::GetProviderListWithTypes(int supported_types) {
-  int ret;
   char* provider_id = NULL;
   int type = 0;
   sqlite3_stmt* stmt;
@@ -265,9 +249,7 @@ DBManager::GetProviderListWithTypes(int supported_types) {
     return provider_list;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return provider_list;
@@ -295,7 +277,6 @@ DBManager::GetProviderListWithTypes(int supported_types) {
 }
 
 std::list<std::string> DBManager::GetProviderList(int support_type) {
-  int ret;
   char* provider_id = NULL;
   sqlite3_stmt* stmt;
   sqlite3* db;
@@ -313,9 +294,7 @@ std::list<std::string> DBManager::GetProviderList(int support_type) {
     return provider_list;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return provider_list;
@@ -341,15 +320,13 @@ std::list<std::string> DBManager::GetProviderList(int support_type) {
 
 std::list<std::string> DBManager::GetProviderListWithAppId(
     const char* provider_app_id) {
-  int ret;
   char* provider = NULL;
   sqlite3_stmt* stmt;
   sqlite3* db;
   std::list<std::string> provider_list;
 
   static const char query[] =
-    "SELECT DISTINCT provider_id FROM complication_provider "
-    "WHERE appid=?";
+    "SELECT DISTINCT provider_id FROM complication_provider WHERE appid=?";
 
   db = OpenDB();
   if (db == NULL) {
@@ -357,9 +334,7 @@ std::list<std::string> DBManager::GetProviderListWithAppId(
     return provider_list;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return provider_list;
@@ -379,7 +354,6 @@ std::list<std::string> DBManager::GetProviderListWithAppId(
 }
 
 int DBManager::GetSupportTypes(std::string& provider_id, int* types) {
-  int ret;
   int supported_types = 0;
   sqlite3_stmt* stmt;
   sqlite3* db;
@@ -396,9 +370,7 @@ int DBManager::GetSupportTypes(std::string& provider_id, int* types) {
     return WATCHFACE_COMPLICATION_ERROR_DB;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return WATCHFACE_COMPLICATION_ERROR_DB;
@@ -425,15 +397,13 @@ int DBManager::GetSupportTypes(std::string& provider_id, int* types) {
 
 std::list<std::string> DBManager::GetRequiredPrivilegeList(
     std::string& provider_id) {
-  int ret;
   char* privlege = NULL;
   sqlite3_stmt* stmt;
   sqlite3* db;
   std::list<std::string> privlege_list;
 
   static const char query[] =
-    "SELECT DISTINCT privilege FROM provider_privilege "
-    "WHERE provider_id=?";
+    "SELECT DISTINCT privilege FROM provider_privilege WHERE provider_id=?";
 
   db = OpenDB();
   if (db == NULL) {
@@ -441,9 +411,7 @@ std::list<std::string> DBManager::GetRequiredPrivilegeList(
     return privlege_list;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return privlege_list;
@@ -469,15 +437,13 @@ Return -1 if error occurs.
 */
 int DBManager::GetRequiredSupportEvents(
     std::string& provider_id) {
-  int ret;
   int support_events = WATCHFACE_COMPLICATION_EVENT_NONE;
   sqlite3_stmt* stmt;
   sqlite3* db;
   std::list<std::string> privlege_list;
 
   static const char query[] =
-    "SELECT support_events FROM provider_support_events "
-    "WHERE provider_id=?";
+    "SELECT support_events FROM provider_support_events WHERE provider_id=?";
 
   db = OpenDB();
   if (db == NULL) {
@@ -485,9 +451,7 @@ int DBManager::GetRequiredSupportEvents(
     return -1;
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return -1;
@@ -548,7 +512,6 @@ char* DBManager::GetSystemLocale() {
 }
 
 std::string DBManager::GetLabel(const char* provider_id) {
-  int ret;
   std::string label;
   sqlite3_stmt *stmt;
   sqlite3* db;
@@ -564,9 +527,7 @@ std::string DBManager::GetLabel(const char* provider_id) {
     return std::string();
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return std::string();
@@ -606,14 +567,12 @@ std::string DBManager::GetLabel(const char* provider_id) {
 }
 
 std::string DBManager::GetSetupAppId(const char* provider_id) {
-  int ret;
   std::string setup_appid;
   sqlite3_stmt* stmt;
   sqlite3* db;
 
   static const char query[] =
-    "SELECT DISTINCT setup_appid FROM provider_setup_appid "
-    "WHERE provider_id=?";
+    "SELECT DISTINCT setup_appid FROM provider_setup_appid WHERE provider_id=?";
 
   db = OpenDB();
   if (db == NULL) {
@@ -621,9 +580,7 @@ std::string DBManager::GetSetupAppId(const char* provider_id) {
     return std::string();
   }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, NULL);
-  if (ret != SQLITE_OK) {
+  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL) != SQLITE_OK) {
     LOGE("prepare error: %s", sqlite3_errmsg(db));
     CloseDB(db);
     return std::string();
@@ -672,8 +629,7 @@ int DBManager::GetTrustedInfo(std::string& provider_id, bool* trusted) {
   sqlite3* db;
 
   static const char query[] =
-      "SELECT trusted FROM complication_provider "
-      "WHERE provider_id = ?";
+      "SELECT trusted FROM complication_provider WHERE provider_id = ?";
 
   db = OpenDB();
   if (db == NULL) {

diff --git a/watchface-complication/editables-manager.cc b/watchface-complication/editables-manager.cc
index caebc4d..90623b9 100644 (file)
--- a/watchface-complication/editables-manager.cc
+++ b/watchface-complication/editables-manager.cc
@@ -51,7 +51,7 @@ EditablesManager::~EditablesManager() = default;
 EditablesManager::Impl::Impl() = default;
 
 int EditablesManager::Init() {
-  int ret = SQLITE_OK;
+  int ret;
   int open_flags = (SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE);
   std::unique_ptr<Impl> tmp_impl;
 
@@ -114,9 +114,8 @@ int EditablesManager::Init() {
 }
 
 int EditablesManager::StoreSetting(int editable_id, bundle_raw* raw_data) {
-  int r;
-  char* error = NULL;
   char query[QUERY_MAXLEN] = {0, };
+  char* error = NULL;
 
   if (impl_->setting_db_ == NULL) {
     LOGE("DB is not initialized.");
@@ -124,12 +123,9 @@ int EditablesManager::StoreSetting(int editable_id, bundle_raw* raw_data) {
   }
 
   sqlite3_snprintf(QUERY_MAXLEN, query,
-      "INSERT OR REPLACE INTO editable_setting(editable_id, " \
-      "setting_data) " \
-      "VALUES (%d, %Q)",
-      editable_id, raw_data);
-  r = sqlite3_exec(impl_->setting_db_, query, NULL, NULL, &error);
-  if (r != SQLITE_OK) {
+      "INSERT OR REPLACE INTO editable_setting(editable_id, setting_data) " \
+      "VALUES (%d, %Q)", editable_id, raw_data);
+  if (sqlite3_exec(impl_->setting_db_, query, NULL, NULL, &error) != SQLITE_OK) {
     LOGE("sqlite3_exec error(editable_id %d, error = %s)", editable_id, error);
     sqlite3_free(error);
     return WATCHFACE_COMPLICATION_ERROR_DB;
@@ -154,7 +150,7 @@ std::unique_ptr<Bundle> EditablesManager::LoadSetting(int editable_id) {
   ret = sqlite3_prepare_v2(impl_->setting_db_,
       query, strlen(query), &stmt, NULL);
   if (ret != SQLITE_OK) {
-    LOGE("execute editable_id %d fail %s\n",
+    LOGE("sqlite3_prepare_v2 failed (editable_id : %d, error = %s)",
         editable_id, sqlite3_errmsg(impl_->setting_db_));
     sqlite3_close_v2(impl_->setting_db_);
     return nullptr;
@@ -171,9 +167,8 @@ std::unique_ptr<Bundle> EditablesManager::LoadSetting(int editable_id) {
 
 int EditablesManager::StoreContext(int editable_id, const char* provider_id,
     Bundle& context) {
-  int r;
-  char* error = NULL;
   char query[QUERY_MAXLEN] = {0, };
+  char* error = NULL;
 
   if (impl_->setting_db_ == NULL) {
     LOGE("DB is not initialized.");
@@ -182,11 +177,9 @@ int EditablesManager::StoreContext(int editable_id, const char* provider_id,
 
   sqlite3_snprintf(QUERY_MAXLEN, query,
       "INSERT OR REPLACE INTO editable_context(editable_id, provider_id, " \
-      "context_data) " \
-      "VALUES (%d, %Q, %Q)",
+      "context_data) VALUES (%d, %Q, %Q)",
       editable_id, provider_id, context.ToString());
-  r = sqlite3_exec(impl_->context_db_, query, NULL, NULL, &error);
-  if (r != SQLITE_OK) {
+  if (sqlite3_exec(impl_->context_db_, query, NULL, NULL, &error) != SQLITE_OK) {
     LOGE("sqlite3_exec error(editable_id : %d, provider_id : %s, error = %s)",
         editable_id, provider_id, error);
     sqlite3_free(error);
@@ -197,11 +190,10 @@ int EditablesManager::StoreContext(int editable_id, const char* provider_id,
 
 std::unique_ptr<Bundle> EditablesManager::LoadContext(int editable_id,
     const char* provider_id) {
-  char query[QUERY_MAXLEN];
+  char query[QUERY_MAXLEN] = {0, };
   std::unique_ptr<Bundle> context_data = nullptr;
   const char* raw_data;
   sqlite3_stmt* stmt;
-  int ret;
 
   if (impl_->context_db_ == NULL) {
     return nullptr;
@@ -211,10 +203,9 @@ std::unique_ptr<Bundle> EditablesManager::LoadContext(int editable_id,
       "SELECT context_data FROM editable_context WHERE " \
       "editable_id = %d AND provider_id = %Q ", editable_id, provider_id);
   LOGI("editable context select sql : %s", query);
-  ret = sqlite3_prepare_v2(impl_->context_db_,
-      query, strlen(query), &stmt, NULL);
-  if (ret != SQLITE_OK) {
-    LOGE("execute fail %s", sqlite3_errmsg(impl_->context_db_));
+  if (sqlite3_prepare_v2(impl_->context_db_, query, strlen(query), &stmt, NULL)
+      != SQLITE_OK) {
+    LOGE("sqlite3_prepare fail %s", sqlite3_errmsg(impl_->context_db_));
     sqlite3_close_v2(impl_->context_db_);
     return nullptr;
   }
@@ -242,8 +233,13 @@ int EditablesManager::DeleteContext(int editable_id,
       "DELETE FROM editable_context WHERE " \
       "editable_id = %d AND provider_id = %Q ", editable_id, provider_id);
   LOGI("editable context delete : (%d)(%s)", editable_id, provider_id);
-  ret = sqlite3_prepare_v2(impl_->context_db_,
-      query, strlen(query), &stmt, NULL);
+  ret = sqlite3_prepare_v2(impl_->context_db_, query, strlen(query), &stmt,
+      NULL);
+  if (ret != SQLITE_OK) {
+    LOGE("sqlite3_prepare fail %s", sqlite3_errmsg(impl_->context_db_));
+    sqlite3_close_v2(impl_->context_db_);
+    return WATCHFACE_COMPLICATION_ERROR_DB;
+  }
 
   ret = sqlite3_step(stmt);
   if (ret != SQLITE_DONE) {

diff --git a/watchface-complication/watchface-complication.cc b/watchface-complication/watchface-complication.cc
index 2e63800..d548422 100644 (file)
--- a/watchface-complication/watchface-complication.cc
+++ b/watchface-complication/watchface-complication.cc
@@ -352,7 +352,7 @@ extern "C" EXPORT_API int watchface_complication_data_get_type(
 
   ret = bundle_get_str(const_cast<bundle*>(data), DATA_TYPE_KEY, &type_str);
   if (ret != BUNDLE_ERROR_NONE) {
-    LOGE("Invalid data !!");
+    LOGE("failed to get data_type %d", ret);
     return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
   }
 
@@ -367,8 +367,8 @@ extern "C" EXPORT_API int watchface_complication_data_get_type(
 
 static int __get_complication_data(const bundle* data, const char* key,
     char** text) {
-  int ret;
   char* value = NULL;
+  int ret;
 
   if (key == NULL) {
     LOGE("Invalid param !!");
@@ -377,7 +377,7 @@ static int __get_complication_data(const bundle* data, const char* key,
 
   ret = bundle_get_str(const_cast<bundle*>(data), key, &value);
   if (ret != BUNDLE_ERROR_NONE) {
-    LOGE("Invalid data !!");
+    LOGE("failed to get bundle data %s, %d", key, ret);
     return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
   }
 
@@ -444,7 +444,7 @@ extern "C" EXPORT_API int watchface_complication_data_get_timestamp(
 
   ret = bundle_get_str(const_cast<bundle*>(data), TIME_KEY, &time_str);
   if (ret != BUNDLE_ERROR_NONE) {
-    LOGE("Invalid data !!");
+    LOGE("failed to get time %d", ret);
     return WATCHFACE_COMPLICATION_ERROR_NO_DATA;
   }
   *timestamp = strtol(time_str, NULL, 10);
@@ -585,7 +585,6 @@ extern "C" EXPORT_API int watchface_complication_allowed_list_create(
 
   h = (complication_allowed_list_h)calloc(1,
       sizeof(struct complication_allowed_list_));
-
   if (h == NULL) {
     LOGE("Out of memory");
     return WATCHFACE_COMPLICATION_ERROR_OUT_OF_MEMORY;

diff --git a/watchface-editor/watchface-editor.cc b/watchface-editor/watchface-editor.cc
index 354dbd4..60bfafa 100644 (file)
--- a/watchface-editor/watchface-editor.cc
+++ b/watchface-editor/watchface-editor.cc
@@ -542,6 +542,11 @@ extern "C" EXPORT_API int watchface_editor_launch_setup_app(
 
   ret = _add_extra_data(&service, SETUP_CONTEXT_DATA_KEY,
       context_data == nullptr ? "" : context_data->ToString());
+  if (ret != WATCHFACE_COMPLICATION_ERROR_NONE) {
+    LOGE("Fail to add setup_context_data %d", ret);
+    app_control_destroy(service);
+    return ret;
+  }
 
   ret = app_control_send_launch_request(service, NULL, NULL);
   if (ret != APP_CONTROL_ERROR_NONE) {