[Badge] Removed try/catch error handling

[Verification] Related TCT should pass

Change-Id: Ic389296b6c5b23413fe7f26f321a5a425684b9f3
Signed-off-by: Ryszard Matuszyk <r.matuszyk@samsung.com>

diff --git a/src/badge/badge_instance.cc b/src/badge/badge_instance.cc
index f68a91f78008117902685ddbf6073a6ad4f11591..7856ceb744aad8d8bfbcb870859d5086450a63e8 100644 (file)
--- a/src/badge/badge_instance.cc
+++ b/src/badge/badge_instance.cc
@@ -35,25 +35,48 @@ BadgeInstance::BadgeInstance() {
 
 BadgeInstance::~BadgeInstance() {}
 
-void BadgeInstance::BadgeManagerSetBadgeCount(const JsonValue& args, JsonObject& out) {
-  std::string appId = common::FromJson<std::string>(args.get<JsonObject>(), "appId");
+void BadgeInstance::BadgeManagerSetBadgeCount(const JsonValue& args,
+                                              JsonObject& out) {
+  std::string appId =
+      common::FromJson<std::string>(args.get<JsonObject>(), "appId");
   const double count = args.get("count").get<double>();
-  BadgeManager::GetInstance()->setBadgeCount(appId, static_cast<unsigned int>(count));
-  ReportSuccess(out);
+
+  PlatformResult status = BadgeManager::GetInstance()->setBadgeCount(
+      appId, static_cast<unsigned int>(count));
+  if (status.IsSuccess())
+    ReportSuccess(out);
+  else
+    ReportError(status, &out);
 }
 
-void BadgeInstance::BadgeManagerGetBadgeCount(const JsonValue& args, JsonObject& out) {
-  std::string appId = common::FromJson<std::string>(args.get<JsonObject>(), "appId");
-  unsigned int count = BadgeManager::GetInstance()->getBadgeCount(appId);
-  ReportSuccess(JsonValue(std::to_string(count)), out);
+void BadgeInstance::BadgeManagerGetBadgeCount(const JsonValue& args,
+                                              JsonObject& out) {
+  std::string appId =
+      common::FromJson<std::string>(args.get<JsonObject>(), "appId");
+
+  unsigned int count = 0;
+  PlatformResult status =
+      BadgeManager::GetInstance()->getBadgeCount(appId, &count);
+  if (status.IsSuccess())
+    ReportSuccess(JsonValue(std::to_string(count)), out);
+  else
+    ReportError(status, &out);
 }
 
-void BadgeInstance::BadgeManagerAddChangeListener(const JsonValue& args, JsonObject& out) {
-  BadgeManager::GetInstance()->addChangeListener(args.get<JsonObject>());
+void BadgeInstance::BadgeManagerAddChangeListener(const JsonValue& args,
+                                                  JsonObject& out) {
+  PlatformResult status =
+      BadgeManager::GetInstance()->addChangeListener(args.get<JsonObject>());
+
+  if (status.IsSuccess())
+    ReportSuccess(out);
+  else
+    ReportError(status, &out);
 }
 
 void BadgeInstance::BadgeManagerRemoveChangeListener(const JsonValue& args, JsonObject& out) {
   BadgeManager::GetInstance()->removeChangeListener(args.get<JsonObject>());
+  ReportSuccess(out);
 }
 
 }  // namespace badge

diff --git a/src/badge/badge_manager.cc b/src/badge/badge_manager.cc
index 4fe27c1f8f5dceaef3872ebac16f66d05c11fb75..1c55dadb0bb641ca73a6962d31b458bf70d727c2 100644 (file)
--- a/src/badge/badge_manager.cc
+++ b/src/badge/badge_manager.cc
@@ -42,43 +42,45 @@ BadgeManager *BadgeManager::GetInstance() {
   return &instance;
 }
 
-void BadgeManager::setBadgeCount(std::string appId, unsigned int count) {
+PlatformResult BadgeManager::setBadgeCount(std::string appId,
+                                           unsigned int count) {
   int ret = BADGE_ERROR_SERVICE_NOT_READY;
   bool badgeExist = false;
   const char *app_id = appId.c_str();
 
   if (!isAppInstalled(appId)) {
     LoggerE("fail to get pkgId");
-    throw InvalidValuesException("InvalidValues error : appId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : appId");
   }
 
   ret = badge_is_existing(app_id, &badgeExist);
   if (ret != BADGE_ERROR_NONE) {
     LoggerE("Unknown error : %d", ret);
-    throw UnknownException("Unknown error");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
   }
 
   if (!badgeExist) {
-    if (!checkPermisionForCreatingBadge(app_id)) {
-      LoggerE("Security error - cannot create badge");
-      throw SecurityException("Security error - cannot create badge");
-    }
+    PlatformResult status = checkPermisionForCreatingBadge(app_id);
+    if (status.IsError()) return status;
+
     ret = badge_create(app_id, app_id);
     LoggerD("badge create : %", ret);
 
     if (ret == BADGE_ERROR_PERMISSION_DENIED) {
       LoggerE("Security error");
-      throw SecurityException("Security error");
+      return PlatformResult(ErrorCode::SECURITY_ERR, "Security error");
 #ifdef PROFILE_WEARABLE
     } else if (ret == BADGE_ERROR_INVALID_DATA) {
 #else
     } else if (ret == BADGE_ERROR_INVALID_PARAMETER) {
 #endif
       LoggerE("Invalid values error");
-      throw InvalidValuesException("Invalid values error");
+      return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                            "Invalid values error");
     } else if (ret != BADGE_ERROR_NONE && ret != BADGE_ERROR_ALREADY_EXIST) {
       LoggerE("Unknown error");
-      throw InvalidValuesException("Unknown error");
+      return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Unknown error");
     }
   }
 
@@ -87,63 +89,73 @@ void BadgeManager::setBadgeCount(std::string appId, unsigned int count) {
 
   if (ret == BADGE_ERROR_PERMISSION_DENIED) {
     LoggerE("Security error");
-    throw SecurityException("Security error");
+    return PlatformResult(ErrorCode::SECURITY_ERR, "Security error");
 #ifdef PROFILE_WEARABLE
   } else if (ret == BADGE_ERROR_INVALID_DATA) {
 #else
   } else if (ret == BADGE_ERROR_INVALID_PARAMETER) {
 #endif
     LoggerE("Invalid values error");
-    throw InvalidValuesException("Invalid values error");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "Invalid values error");
   } else if (ret != BADGE_ERROR_NONE) {
     LoggerE("Unknown error : %d", ret);
-    throw InvalidValuesException("Unknown error");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
   }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-unsigned int BadgeManager::getBadgeCount(std::string appId) {
+PlatformResult BadgeManager::getBadgeCount(std::string appId,
+                                           unsigned int *count) {
   LoggerD("Enter");
 
+  assert(count);
+
   int ret = BADGE_ERROR_SERVICE_NOT_READY;
   bool badgeExist = false;
   if (!isAppInstalled(appId)) {
     LoggerE("fail to get pkgId");
-    throw InvalidValuesException("InvalidValues error : appId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : appId");
   }
   ret = badge_is_existing(appId.c_str(), &badgeExist);
   if (ret != BADGE_ERROR_NONE) {
     LoggerE("Unknown error : %d", ret);
-    throw UnknownException("Platform error while checking badge.");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while checking badge.");
   }
   LoggerD("badge exist : %d", badgeExist);
-  unsigned int count = 0;
 
   if (!badgeExist) {
-    throw UnknownException("badge not exist. appId: " + appId);
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "badge not exist. appId: " + appId);
   }
 
-  ret = badge_get_count(appId.c_str(), &count);
+  *count = 0;
+  ret = badge_get_count(appId.c_str(), count);
 
   if (ret == BADGE_ERROR_NONE) {
-    LoggerD("success get ret : %d count : ", count);
-    return count;
+    LoggerD("success get ret : %d count : ", *count);
+    return PlatformResult(ErrorCode::NO_ERROR);
   } else if (ret == BADGE_ERROR_PERMISSION_DENIED) {
     LoggerE("Security error");
-    throw SecurityException("Security error.");
+    return PlatformResult(ErrorCode::SECURITY_ERR, "Security error.");
 #ifdef PROFILE_WEARABLE
   } else if (ret == BADGE_ERROR_INVALID_DATA) {
 #else
   } else if (ret == BADGE_ERROR_INVALID_PARAMETER) {
 #endif
     LoggerE("Invalid values error");
-    throw InvalidValuesException("InvalidValues error : appId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : appId");
   } else {
     LoggerE("Unknown error : %d", ret);
-    throw UnknownException("Unknown error");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
   }
 }
 
-void BadgeManager::addChangeListener(const JsonObject &obj) {
+PlatformResult BadgeManager::addChangeListener(const JsonObject &obj) {
   LoggerD("entered here");
   auto &items = FromJson<picojson::array>(obj, "appIdList");
   for (auto item : items) {
@@ -154,10 +166,13 @@ void BadgeManager::addChangeListener(const JsonObject &obj) {
     ret = badge_register_changed_cb(badge_changed_cb, this);
     if (ret != BADGE_ERROR_NONE) {
       LoggerE("Unknown error %d:", ret);
-      throw UnknownException("Platform error while adding listener.");
+      return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                            "Platform error while adding listener.");
     }
     is_cb_registered_ = true;
   }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 void BadgeManager::removeChangeListener(const JsonObject &obj) {
@@ -200,10 +215,11 @@ bool BadgeManager::isAppInstalled(const std::string &appId) {
   return true;
 }
 
-bool BadgeManager::checkPermisionForCreatingBadge(const char *appId) {
+PlatformResult BadgeManager::checkPermisionForCreatingBadge(const char *appId) {
   if (!appId) {
     LoggerE("InvalidValues error : appId");
-    throw InvalidValuesException("InvalidValues error : appId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : appId");
   }
 
   char *caller_appid = NULL;
@@ -211,7 +227,8 @@ bool BadgeManager::checkPermisionForCreatingBadge(const char *appId) {
 
   if (!caller_appid) {
     LoggerE("fail to get caller pkgId");
-    throw UnknownException("Platform error while getting caller pkgId.");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting caller pkgId.");
   }
 
   char *caller_pkgname = NULL;
@@ -221,7 +238,8 @@ bool BadgeManager::checkPermisionForCreatingBadge(const char *appId) {
       free(caller_appid);
     }
     LoggerE("fail to get caller pkgId");
-    throw UnknownException("Platform error while getting caller pkgId.");
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Platform error while getting caller pkgId.");
   }
 
   char *pkgname = NULL;
@@ -234,13 +252,12 @@ bool BadgeManager::checkPermisionForCreatingBadge(const char *appId) {
       free(caller_pkgname);
     }
     LoggerE("fail to get pkgId");
-    throw InvalidValuesException("InvalidValues error : appId");
+    return PlatformResult(ErrorCode::INVALID_VALUES_ERR,
+                          "InvalidValues error : appId");
   }
 
-  bool flag = false;
-  if (isSameCertInfo(caller_pkgname, pkgname) == 1) {
-    flag = true;
-  } else {
+  bool flag = true;
+  if (isSameCertInfo(caller_pkgname, pkgname) != 1) {
     LoggerE("The author signature is not match");
     flag = false;
   }
@@ -255,7 +272,13 @@ bool BadgeManager::checkPermisionForCreatingBadge(const char *appId) {
     free(pkgname);
   }
 
-  return flag;
+  if (!flag) {
+    LoggerE("Security error - cannot create badge");
+    return PlatformResult(ErrorCode::SECURITY_ERR,
+                          "Security error - cannot create badge");
+  }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 char *BadgeManager::getPkgnameByAppid(const char *appId) {

diff --git a/src/badge/badge_manager.h b/src/badge/badge_manager.h
index 4e883dea825f163852b2375954461733faecc9f5..537229202f50817bcdfd9bf5edc58fed78e2a6d1 100644 (file)
--- a/src/badge/badge_manager.h
+++ b/src/badge/badge_manager.h
@@ -10,6 +10,7 @@
 
 #include "common/logger.h"
 #include "common/picojson.h"
+#include "common/platform_result.h"
 
 namespace extension {
 namespace badge {
@@ -23,9 +24,9 @@ class BadgeManager {
  public:
   static BadgeManager* GetInstance();
 
-  void setBadgeCount(std::string appId, unsigned int count);
-  unsigned int getBadgeCount(std::string appId);
-  void addChangeListener(const JsonObject& obj);
+  common::PlatformResult setBadgeCount(std::string appId, unsigned int count);
+  common::PlatformResult getBadgeCount(std::string appId, unsigned int* count);
+  common::PlatformResult addChangeListener(const JsonObject& obj);
   void removeChangeListener(const JsonObject& obj);
   static void badge_changed_cb(unsigned int, const char*, unsigned int, void*);
 
@@ -33,7 +34,7 @@ class BadgeManager {
   BadgeManager();
   virtual ~BadgeManager();
 
-  bool checkPermisionForCreatingBadge(const char* appId);
+  common::PlatformResult checkPermisionForCreatingBadge(const char* appId);
   char* getPkgnameByAppid(const char* appId);
   char* getPkgnameByPid();
   int isSameCertInfo(const char *caller, const char *pkgname);