Refactor DBManager

- Use RAII idiom

Change-Id: I23adf5cffb6f1c6f603499e84db642950a377a32
Signed-off-by: Junghoon Park <jh9216.park@samsung.com>

diff --git a/watchface-complication/db-manager.cc b/watchface-complication/db-manager.cc
index 2dc584d..28b4e13 100644 (file)
--- a/watchface-complication/db-manager.cc
+++ b/watchface-complication/db-manager.cc
@@ -36,370 +36,326 @@
 #define ROOT_USER 0
 
 using namespace tizen_base;
-namespace watchface_complication {
 
-DBManager::DBManager() = default;
-DBManager::~DBManager() = default;
+namespace {
+class DBHelper {
+ public:
+  using Cursor = std::unique_ptr<sqlite3_stmt, decltype(sqlite3_finalize)*>;
+  DBHelper()
+      : db_(nullptr, sqlite3_close_v2), stmt_(nullptr, sqlite3_finalize) {}
 
-sqlite3* DBManager::OpenDB() {
-  int ret;
-  const char* path;
-  sqlite3* db = nullptr;
+  bool Open() {
+    const char* path = GetParserDataPath();
+    if (path == nullptr)
+      return false;
 
-  path = GetParserDataPath();
-  if (path == nullptr)
-    return nullptr;
+    sqlite3* db = nullptr;
+    int ret = sqlite3_open_v2(path, &db, SQLITE_OPEN_READONLY, nullptr);
+    if (ret != SQLITE_OK) {
+      LOGE("open db(%s) error: %d", path, ret);
+      return false;
+    }
 
-  ret = sqlite3_open_v2(path, &db, SQLITE_OPEN_READONLY, nullptr);
-  if (ret != SQLITE_OK) {
-    LOGE("open db(%s) error: %d", path, ret);
-    return nullptr;
+    db_.reset(db);
+
+    return true;
   }
 
-  return db;
-}
+  void Close() {
+    db_.reset();
+  }
 
-void DBManager::CloseDB(sqlite3* db) {
-  int ret = SQLITE_OK;
+  bool Prepare(const std::string& query) {
+    sqlite3_stmt* stmt = nullptr;
+    if (sqlite3_prepare_v2(db_.get(), query.c_str(), query.size(), &stmt,
+        nullptr) != SQLITE_OK) {
+      LOGE("prepare error: %s", sqlite3_errmsg(db_.get()));
+      return false;
+    }
 
-  if (db)
-    ret = sqlite3_close_v2(db);
+    stmt_.reset(stmt);
 
-  if (ret != SQLITE_OK)
-    LOGE("close db error");
-}
+    return true;
+  }
+
+  const Cursor& GetCursor() const {
+    return stmt_;
+  }
+
+  int Step() const {
+    return sqlite3_step(stmt_.get());
+  }
+
+  bool Bind(int pos, std::string text) {
+    int ret = sqlite3_bind_text(stmt_.get(), pos, text.c_str(),
+      -1, SQLITE_TRANSIENT);
+    if (ret != SQLITE_OK) {
+      LOGE("bind error: %s", sqlite3_errmsg(db_.get()));
+      return false;
+    }
+
+    return true;
+  }
+
+  bool Bind(int pos, int val) {
+    if (sqlite3_bind_int(stmt_.get(), pos, val) != SQLITE_OK) {
+      LOGE("bind error: %s", sqlite3_errmsg(db_.get()));
+      return false;
+    }
+
+    return true;
+  }
+
+  const char* GetText(int pos) const {
+    return reinterpret_cast<const char*>(sqlite3_column_text(stmt_.get(), pos));
+  }
+
+  int GetInt(int pos) const {
+    return sqlite3_column_int(stmt_.get(), pos);
+  }
+
+ private:
+  const char* GetParserDataPath() const {
+    uid_t target_uid;
+    const char* path;
+    bool is_global;
+
+    pkgmgr_installer_info_get_target_uid(&target_uid);
+
+    if (target_uid == ROOT_USER
+      || target_uid == tzplatform_getuid(TZ_SYS_GLOBALAPP_USER))
+      is_global = true;
+    else
+      is_global = false;
+
+    if (!is_global)
+        tzplatform_set_user(target_uid);
+
+    path = tzplatform_mkpath(is_global ? TZ_SYS_DB : TZ_USER_DB,
+        ".complication_provider.db");
+    tzplatform_reset_user();
+
+    return path;
+  }
+
+ private:
+  std::unique_ptr<sqlite3, decltype(sqlite3_close_v2)*> db_;
+  Cursor stmt_;
+};
+}  // namespace
+
+namespace watchface_complication {
+
+DBManager::DBManager() = default;
+DBManager::~DBManager() = default;
 
 std::unique_ptr<Bundle> DBManager::GetDefaultData(const char* provider_id,
                                                   int support_type) {
-  std::unique_ptr<Bundle> default_data = nullptr;
-  const char* raw_data;
-  sqlite3_stmt* stmt;
-  sqlite3* db;
-  int trusted;
-  std::string provider_app_id;
-  int ret;
-
   static const char query[] =
     "SELECT trusted, appid, default_data FROM complication_provider "
     "WHERE provider_id=? AND support_type=?";
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  ::DBHelper db;
+
+  if (!db.Open())
     return nullptr;
-  }
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return nullptr;
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    goto out;
-  }
+  if (!db.Bind(1, provider_id))
+    return nullptr;
+
+  if (!db.Bind(2, support_type))
+    return nullptr;
+
+  if (db.Step() != SQLITE_ROW)
+    return nullptr;
 
-  ret = sqlite3_bind_int(stmt, 2, support_type);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    goto out;
+  int trusted = db.GetInt(0);
+  const char* app_id = db.GetText(1);
+  if (app_id == nullptr) {
+    LOGE("app_id is nullptr");
+    return nullptr;
   }
 
-  if (sqlite3_step(stmt) == SQLITE_ROW) {
-    trusted = sqlite3_column_int(stmt, 0);
-    const char* app_id = reinterpret_cast<const char*>(
-        sqlite3_column_text(stmt, 1));
-    if (app_id == nullptr) {
-      LOGE("app_id is nullptr");
-      goto out;
-    }
-    provider_app_id = std::string(app_id);
-    if (trusted &&
-         util::CheckCertificate(provider_app_id) == false) {
-      goto out;
-    }
-    raw_data = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
-    if (raw_data == nullptr) {
-      LOGE("raw_data is nullptr");
-      goto out;
-    }
+  std::string provider_app_id = app_id;
+  if (trusted && util::CheckCertificate(provider_app_id) == false)
+    return nullptr;
 
-    try {
-      default_data = std::unique_ptr<Bundle>(new Bundle(std::string(raw_data)));
-    } catch (const std::exception& e) {
-      LOGE("Exception occurred : %s", e.what());
-      goto out;
-    }
+  const char* raw_data = db.GetText(2);
+  if (raw_data == nullptr) {
+    LOGE("raw_data is nullptr");
+    return nullptr;
+  }
 
-    util::ConvertPathToAppPath(
-        provider_app_id.c_str(), default_data.get()->GetHandle());
+  std::unique_ptr<Bundle> default_data;
+  try {
+    default_data = std::unique_ptr<Bundle>(new Bundle(std::string(raw_data)));
+  } catch (const std::exception& e) {
+    LOGE("Exception occurred : %s", e.what());
+    return nullptr;
   }
 
-out:
-  sqlite3_finalize(stmt);
-  CloseDB(db);
+  util::ConvertPathToAppPath(provider_app_id.c_str(),
+      default_data.get()->GetHandle());
 
-  return std::move(default_data);
+  return default_data;
 }
 
 int DBManager::GetProviderPeriod(std::string& provider_id, int* period) {
-  sqlite3_stmt* stmt = nullptr;
-  sqlite3* db;
-  int ret;
-
   static const char query[] =
     "SELECT period FROM complication_provider WHERE provider_id=?";
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  ::DBHelper db;
+
+  if (!db.Open())
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(1, provider_id))
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
   /* complication_provider table's default value of period is -1.
   *  So, if nothing specified in period, it will return -1
   */
-  if (sqlite3_step(stmt) == SQLITE_ROW)
-    *period = sqlite3_column_int(stmt, 0);
-
-  sqlite3_finalize(stmt);
-  CloseDB(db);
+  if (db.Step() == SQLITE_ROW)
+    *period = db.GetInt(0);
 
   return WATCHFACE_COMPLICATION_ERROR_NONE;
 }
 
 bool DBManager::IsProviderExist(std::string& provider_id, int support_type) {
-  sqlite3_stmt* stmt = nullptr;
-  sqlite3* db;
-  bool is_exist = false;
-  int trusted;
-  std::string provider_app_id;
-  int ret;
-
   static const char query[] =
     "SELECT trusted, appid FROM complication_provider "
     "WHERE provider_id=? AND support_type=?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
-    return false;
-  }
+  if (!db.Open())
+    return false;;
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return false;
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(1, provider_id))
     return false;
-  }
 
-  ret = sqlite3_bind_int(stmt, 2, support_type);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(2, support_type))
     return false;
-  }
 
-  if (sqlite3_step(stmt) == SQLITE_ROW) {
-    trusted = sqlite3_column_int(stmt, 0);
-    const char* app_id = reinterpret_cast<const char*>(
-        sqlite3_column_text(stmt, 1));
+  bool is_exist = false;
+  if (db.Step() == SQLITE_ROW) {
+    int trusted;
+
+    trusted = db.GetInt(0);
+    const char* app_id = db.GetText(1);
     if (app_id == nullptr) {
       LOGE("app_id is nullptr");
-      sqlite3_finalize(stmt);
-      CloseDB(db);
       return false;
     }
-    provider_app_id = std::string(app_id);
-    if (trusted &&
-      util::CheckCertificate(provider_app_id) == false)
+    std::string provider_app_id = app_id;
+    if (trusted && util::CheckCertificate(provider_app_id) == false)
       is_exist = false;
     else
       is_exist = true;
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
-
   return is_exist;
 }
 
 std::string DBManager::GetProviderAppId(const char* provider_id) {
-  sqlite3_stmt* stmt = nullptr;
-  sqlite3* db;
-  int trusted;
-  std::string provider_app_id;
-  int ret;
-
   static const char query[] =
     "SELECT trusted, appid FROM complication_provider WHERE provider_id=?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  if (!db.Open())
     return std::string();
-  }
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return std::string();
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(1, provider_id))
     return std::string();
-  }
 
-  if (sqlite3_step(stmt) == SQLITE_ROW) {
-    trusted = sqlite3_column_int(stmt, 0);
-    const char* app_id = reinterpret_cast<const char*>(
-        sqlite3_column_text(stmt, 1));
-    if (app_id == nullptr) {
-      LOGE("app_id is nullptr");
-      sqlite3_finalize(stmt);
-      CloseDB(db);
-      return std::string();
-    }
-    provider_app_id = std::string(app_id);
-    if (trusted &&
-      util::CheckCertificate(provider_app_id) == false) {
-      sqlite3_finalize(stmt);
-      CloseDB(db);
-      return std::string();
-    }
+  if (db.Step() != SQLITE_ROW)
+    return std::string();
+
+  int trusted = db.GetInt(0);
+  const char* app_id = db.GetText(1);
+
+  if (app_id == nullptr) {
+    LOGE("app_id is nullptr");
+    return std::string();
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
+  std::string provider_app_id = app_id;
+  if (trusted && util::CheckCertificate(provider_app_id) == false)
+    return std::string();
 
   return provider_app_id;
 }
 
 std::list<std::unique_ptr<DBManager::ProviderInfo>>
 DBManager::GetProviderListWithTypes(int supported_types) {
-  const char* provider_id;
-  int type = 0;
-  sqlite3_stmt* stmt;
-  sqlite3* db = nullptr;
-  std::list<std::unique_ptr<DBManager::ProviderInfo>> provider_list;
-  int trusted;
-  std::string provider_app_id;
-  int ret;
-
   static const char query[] =
     "SELECT trusted, appid, provider_id, support_type FROM complication_provider "
     "WHERE (support_type & ?) > 0";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
-    return provider_list;
-  }
+  if (!db.Open())
+    return {};
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
-    return provider_list;
-  }
+  if (!db.Prepare(query))
+    return {};
 
-  ret = sqlite3_bind_int(stmt, 1, supported_types);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
-    return provider_list;
-  }
+  if (!db.Bind(1, supported_types))
+    return {};
 
-  while (sqlite3_step(stmt) == SQLITE_ROW) {
-    trusted = sqlite3_column_int(stmt, 0);
-    const char* app_id = reinterpret_cast<const char*>(
-        sqlite3_column_text(stmt, 1));
+  std::list<std::unique_ptr<DBManager::ProviderInfo>> provider_list;
+  while (db.Step() == SQLITE_ROW) {
+    int trusted = db.GetInt(0);
+    const char* app_id = db.GetText(1);
     if (app_id == nullptr) {
       LOGE("app_id is nullptr");
       continue;
     }
 
-    provider_app_id = std::string(app_id);
-    if (trusted && util::CheckCertificate(provider_app_id) == false)
+    if (trusted && util::CheckCertificate(std::string(app_id)) == false)
       continue;
 
-    provider_id = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
+    const char* provider_id = db.GetText(2);
     if (provider_id == nullptr) {
       LOGE("prodiver_id is nullptr");
       continue;
     }
-    type = sqlite3_column_int(stmt, 3);
+    int type = db.GetInt(3);
     provider_list.emplace_back(
         std::unique_ptr<ProviderInfo>(new ProviderInfo(provider_id, type)));
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
-
   return std::move(provider_list);
 }
 
 std::list<std::string> DBManager::GetProviderListWithAppId(
     const char* provider_app_id) {
-  const char* provider;
-  sqlite3_stmt* stmt;
-  sqlite3* db;
-  std::list<std::string> provider_list;
-  int ret;
-
   static const char query[] =
     "SELECT DISTINCT provider_id FROM complication_provider WHERE appid=?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
-    return provider_list;
-  }
+  if (!db.Open())
+    return {};
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
-    return provider_list;
-  }
+  if (!db.Prepare(query))
+    return {};
 
-  ret = sqlite3_bind_text(stmt, 1, provider_app_id, -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
-    return provider_list;
-  }
+  if (!db.Bind(1, std::string(provider_app_id)))
+    return {};
 
-  while (sqlite3_step(stmt) == SQLITE_ROW) {
-    provider = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+  std::list<std::string> provider_list;
+  while (db.Step() == SQLITE_ROW) {
+    const char* provider = db.GetText(0);
     if (provider == nullptr) {
       LOGW("provider is nullptr");
       continue;
@@ -407,64 +363,39 @@ std::list<std::string> DBManager::GetProviderListWithAppId(
     provider_list.push_back(std::string(provider));
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
-
   return provider_list;
 }
 
 int DBManager::GetSupportTypes(std::string& provider_id, int* types) {
-  int supported_types = 0;
-  sqlite3_stmt* stmt;
-  sqlite3* db;
-  int trusted;
-  std::string provider_app_id;
-  int ret;
-
   static const char query[] =
       "SELECT trusted, appid, SUM(support_type) FROM complication_provider "
       "WHERE provider_id = ?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  if (!db.Open())
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(1, provider_id))
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  if (sqlite3_step(stmt) == SQLITE_ROW) {
-    trusted = sqlite3_column_int(stmt, 0);
-    const char* app_id = reinterpret_cast<const char*>(
-        sqlite3_column_text(stmt, 1));
+  int supported_types = 0;
+  if (db.Step() == SQLITE_ROW) {
+    int trusted = db.GetInt(0);
+    const char* app_id = db.GetText(1);
     if (app_id == nullptr) {
       LOGE("app_id is nullptr");
-      sqlite3_finalize(stmt);
-      CloseDB(db);
       return WATCHFACE_COMPLICATION_ERROR_DB;
     }
-    provider_app_id = std::string(app_id);
+    std::string provider_app_id = app_id;
     if (trusted && util::CheckCertificate(provider_app_id) == false)
       supported_types = 0;
     else
-      supported_types = sqlite3_column_int(stmt, 2);
+      supported_types = db.GetInt(2);
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
-
   *types = supported_types;
 
   return WATCHFACE_COMPLICATION_ERROR_NONE;
@@ -472,37 +403,22 @@ int DBManager::GetSupportTypes(std::string& provider_id, int* types) {
 
 std::list<std::string> DBManager::GetRequiredPrivilegeList(
     std::string& provider_id) {
-  const char* privilege;
-  sqlite3_stmt* stmt;
-  sqlite3* db;
-  std::list<std::string> privlege_list;
-  int ret;
-
   static const char query[] =
     "SELECT DISTINCT privilege FROM provider_privilege WHERE provider_id=?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
-    return privlege_list;
-  }
+  if (!db.Open())
+    return {};
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
-    return privlege_list;
-  }
+  if (!db.Prepare(query))
+    return {};
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
-    return privlege_list;
-  }
+  if (!db.Bind(1, provider_id))
+    return {};
 
-  while (sqlite3_step(stmt) == SQLITE_ROW) {
-    privilege = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+  std::list<std::string> privlege_list;
+  while (db.Step() == SQLITE_ROW) {
+    const char* privilege = db.GetText(0);
     if (privilege == nullptr) {
       LOGW("privilege is nullptr");
       continue;
@@ -510,9 +426,6 @@ std::list<std::string> DBManager::GetRequiredPrivilegeList(
     privlege_list.push_back(std::string(privilege));
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
-
   return privlege_list;
 }
 
@@ -524,39 +437,21 @@ Return -1 if error occurs.
 int DBManager::GetRequiredSupportEvents(
     std::string& provider_id) {
   int support_events = WATCHFACE_COMPLICATION_EVENT_NONE;
-  sqlite3_stmt* stmt;
-  sqlite3* db;
-  std::list<std::string> privlege_list;
-  int ret;
-
   static const char query[] =
     "SELECT support_events FROM provider_support_events WHERE provider_id=?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  if (!db.Open())
     return -1;
-  }
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return -1;
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(1, provider_id))
     return -1;
-  }
-
-  if (sqlite3_step(stmt) == SQLITE_ROW)
-    support_events = sqlite3_column_int(stmt, 0);
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
+  if (db.Step() == SQLITE_ROW)
+    support_events = db.GetInt(0);
 
   return support_events;
 }
@@ -605,205 +500,112 @@ char* DBManager::GetSystemLocale() {
 }
 
 std::string DBManager::GetLabel(const char* provider_id) {
-  std::string label;
-  sqlite3_stmt *stmt;
-  sqlite3* db;
-  const char* lb;
-  char* locale = nullptr;
-  int ret;
-
   static const char query[] =
     "SELECT provider_label FROM provider_localized_info "
     "WHERE provider_id=? AND locale=?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  if (!db.Open())
     return std::string();
-  }
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return std::string();
-  }
 
-  locale = GetSystemLocale();
-  if (locale == nullptr) {
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  char* locale = GetSystemLocale();
+  if (locale == nullptr)
     return std::string();
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
-    free(locale);
+  std::unique_ptr<char, decltype(std::free)*> locale_ptr(locale, std::free);
+
+  if (!db.Bind(1, provider_id))
     return std::string();
-  }
 
-  ret = sqlite3_bind_text(stmt, 2, locale, -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
-    free(locale);
+  if (!db.Bind(2, locale_ptr.get()))
     return std::string();
-  }
 
-  if (sqlite3_step(stmt) == SQLITE_ROW) {
-    lb = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+  std::string label;
+  if (db.Step() == SQLITE_ROW) {
+    const char* lb = db.GetText(0);
     if (lb == nullptr) {
       LOGW("lb is nullptr");
     } else {
-      label = std::string(lb);
+      label = lb;
     }
   }
 
   if (label.empty()) {
-    sqlite3_reset(stmt);
-    sqlite3_clear_bindings(stmt);
+    sqlite3_reset(db.GetCursor().get());
+    sqlite3_clear_bindings(db.GetCursor().get());
 
-    sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
-    sqlite3_bind_text(stmt, 2, DEFAULT_LOCALE, -1, SQLITE_TRANSIENT);
+    db.Bind(1, provider_id);
+    db.Bind(2, DEFAULT_LOCALE);
 
-    if (sqlite3_step(stmt) == SQLITE_ROW) {
-      lb = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
+    if (db.Step() == SQLITE_ROW) {
+      const char* lb = db.GetText(0);
       if (lb == nullptr) {
         LOGW("lb is nullptr");
       } else {
-        label = std::string(lb);
+        label = lb;
       }
     }
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
-  free(locale);
-
   return label;
 }
 
 std::string DBManager::GetSetupAppId(const char* provider_id) {
-  std::string setup_appid;
-  sqlite3_stmt* stmt;
-  sqlite3* db;
-  int ret;
-
   static const char query[] =
     "SELECT DISTINCT setup_appid FROM provider_setup_appid WHERE provider_id=?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  if (!db.Open())
     return std::string();
-  }
 
-  if (sqlite3_prepare_v2(db, query, strlen(query), &stmt, nullptr) != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return std::string();
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id, -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(1, provider_id))
     return std::string();
-  }
 
-  if (sqlite3_step(stmt) == SQLITE_ROW) {
-    const char* appid = reinterpret_cast<const char*>(
-        sqlite3_column_text(stmt, 0));
+  std::string setup_appid;
+  if (db.Step() == SQLITE_ROW) {
+    const char* appid = db.GetText(0);
     if (appid == nullptr) {
       LOGE("appid is nullptr");
-      sqlite3_finalize(stmt);
-      CloseDB(db);
       return std::string();
     }
-    setup_appid = std::string(appid);
+    setup_appid = appid;
   }
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
-
   return setup_appid;
 }
 
-const char* DBManager::GetParserDataPath() {
-  uid_t target_uid;
-  const char* path;
-  bool is_global;
-
-  pkgmgr_installer_info_get_target_uid(&target_uid);
-
-  if (target_uid == ROOT_USER
-    || target_uid == tzplatform_getuid(TZ_SYS_GLOBALAPP_USER))
-    is_global = true;
-  else
-    is_global = false;
-
-  if (!is_global)
-      tzplatform_set_user(target_uid);
-
-  path = tzplatform_mkpath(is_global ? TZ_SYS_DB : TZ_USER_DB,
-      ".complication_provider.db");
-
-  tzplatform_reset_user();
-
-  return path;
-}
-
 int DBManager::GetTrustedInfo(std::string& provider_id, bool* trusted) {
-  int ret = WATCHFACE_COMPLICATION_ERROR_NONE;
-  int trusted_info;
-  sqlite3_stmt* stmt;
-  sqlite3* db;
-
   static const char query[] =
       "SELECT trusted FROM complication_provider WHERE provider_id = ?";
+  ::DBHelper db;
 
-  db = OpenDB();
-  if (db == nullptr) {
-    LOGE("parser db not exist");
+  if (!db.Open())
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  ret = sqlite3_prepare_v2(db, query, strlen(query),
-                        &stmt, nullptr);
-  if (ret != SQLITE_OK) {
-    LOGE("prepare error: %s", sqlite3_errmsg(db));
-    CloseDB(db);
+  if (!db.Prepare(query))
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  ret = sqlite3_bind_text(stmt, 1, provider_id.c_str(), -1, SQLITE_TRANSIENT);
-  if (ret != SQLITE_OK) {
-    LOGE("bind error: %s", sqlite3_errmsg(db));
-    sqlite3_finalize(stmt);
-    CloseDB(db);
+  if (!db.Bind(1, provider_id))
     return WATCHFACE_COMPLICATION_ERROR_DB;
-  }
 
-  if (sqlite3_step(stmt) == SQLITE_ROW) {
-    trusted_info = sqlite3_column_int(stmt, 0);
-    if (trusted_info == 0)
-      *trusted = false;
-    else if (trusted_info == 1)
-      *trusted = true;
-    else
-      ret = WATCHFACE_COMPLICATION_ERROR_DB;
-  } else {
-    ret = WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
-  }
+  if (db.Step() != SQLITE_ROW)
+    return WATCHFACE_COMPLICATION_ERROR_INVALID_PARAMETER;
 
-  sqlite3_finalize(stmt);
-  CloseDB(db);
+  int trusted_info = db.GetInt(0);
+  if (trusted_info == 0)
+    *trusted = false;
+  else if (trusted_info == 1)
+    *trusted = true;
+  else
+    return WATCHFACE_COMPLICATION_ERROR_DB;
 
-  return ret;
+  return WATCHFACE_COMPLICATION_ERROR_NONE;
 }
 
 }  // namespace watchface_complication

diff --git a/watchface-complication/db-manager.h b/watchface-complication/db-manager.h
index 6ad36ad..8c2afc6 100644 (file)
--- a/watchface-complication/db-manager.h
+++ b/watchface-complication/db-manager.h
@@ -63,9 +63,6 @@ class EXPORT_API DBManager {
  private:
   DBManager(); /* LCOV_EXCL_LINE */
   virtual ~DBManager(); /* LCOV_EXCL_LINE */
-  static sqlite3* OpenDB();
-  static void CloseDB(sqlite3* db);
-  static const char* GetParserDataPath();
   static char* GetSystemLocale();
 };