[Release]wrt-installer_0.1.6
[framework/web/wrt-installer.git] / src / pkg-manager / backendlib.cpp
index 830ca84..37952c1 100644 (file)
  *             to package manager
  */
 #include "package-manager-plugin.h"
+#include <regex.h>
 #include <dlog.h>
 #include <dpl/wrt-dao-ro/global_config.h>
-#include <ace-dao-rw/AceDAO.h>
 #include <vcore/VCore.h>
 #include <dpl/wrt-dao-ro/WrtDatabase.h>
-#include <dpl/wrt-dao-rw/widget_dao.h>
+#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
 #include <dpl/wrt-dao-ro/feature_dao_read_only.h>
 #include <dpl/wrt-dao-ro/widget_config.h>
 #include <string>
@@ -44,53 +44,27 @@ using namespace WrtDB;
 #undef FALSE
 #define TRUE 0
 #define FALSE -1
-#define GET_DIRECTORY_SIZE_KB(x)    (x)/1024
+#define GET_DIRECTORY_SIZE_KB(x)    (x) / 1024
 
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
-class DatabaseConnection
-{
-  public:
-    void AttachDatabase()
-    {
-        WrtDB::WrtDatabase::attachToThreadRO();
-    }
-
-    void DetachDatabase()
-    {
-        WrtDB::WrtDatabase::detachFromThread();
-    }
-};
-
-static DPL::ScopedPtr<DatabaseConnection> g_databaseConnection;
-
 static void pkg_native_plugin_on_unload();
 static int pkg_plugin_app_is_installed(const char *pkg_name);
 static int pkg_plugin_get_installed_apps_list(const char *category,
-        const char *option, package_manager_pkg_info_t **list, int *count);
-static int pkg_plugin_get_app_detail_info(const char *pkg_name,
-        package_manager_pkg_detail_info_t *pkg_detail_info);
-static int pkg_plugin_get_app_detail_info_from_package(const char *pkg_path,
-        package_manager_pkg_detail_info_t *pkg_detail_info);
-
-static int is_connected()
-{
-    if (NULL == g_databaseConnection) {
-        Try {
-            g_databaseConnection.Reset(new DatabaseConnection());
-            g_databaseConnection->AttachDatabase();
-        }
-        Catch (DPL::DB::SqlConnection::Exception::Base) {
-            LogDebug("Fail to connect DB");
-            return FALSE;
-        }
-    }
-
-    return TRUE;
-}
+                                              const char *option,
+                                              package_manager_pkg_info_t **list,
+                                              int *count);
+static int pkg_plugin_get_app_detail_info(
+    const char *pkg_name,
+    package_manager_pkg_detail_info_t *
+    pkg_detail_info);
+static int pkg_plugin_get_app_detail_info_from_package(
+    const char *pkg_path,
+    package_manager_pkg_detail_info_t
+    *pkg_detail_info);
 
 static void pkg_native_plugin_on_unload()
 {
@@ -99,165 +73,157 @@ static void pkg_native_plugin_on_unload()
 
 static int pkg_plugin_app_is_installed(const char *pkg_name)
 {
+    const char* REG_PKGID_PATTERN = "^[a-zA-Z0-9]{10}$";
     LogDebug("pkg_plugin_app_is_installed() is called");
 
-    if (FALSE == is_connected()) {
-        LogError("Fail DB Connect");
-        return FALSE;
+    WrtDB::WrtDatabase::attachToThreadRO();
+
+    regex_t reg;
+    if (regcomp(&reg, REG_PKGID_PATTERN, REG_NOSUB | REG_EXTENDED) != 0) {
+        LogDebug("Regcomp failed");
     }
 
-    Try {
-        if (WidgetDAOReadOnly::isWidgetInstalled(
-                DPL::FromUTF8String(pkg_name))) {
-            return TRUE;
-        }
-    } Catch(DPL::DB::SqlConnection::Exception::Base) {
-        LogDebug("Databas Error");
-        return FALSE;
+    WrtDB::TizenAppId appid;
+
+    if ((regexec(&reg, pkg_name,
+                    static_cast<size_t>(0), NULL, 0) == 0))
+    {
+        WrtDB::TizenPkgId pkgid(DPL::FromUTF8String(pkg_name));
+        appid = WidgetDAOReadOnly::getTzAppId(pkgid);
+    } else {
+        appid = DPL::FromUTF8String(pkg_name);
     }
 
-    LogDebug("Widget Not Found");
-    return FALSE;
+    bool result = WidgetDAOReadOnly::isWidgetInstalled(appid);
+    WrtDB::WrtDatabase::detachFromThread();
+
+    if (result) {
+        return TRUE;
+    } else {
+        return FALSE;
+    }
 }
 
 static int pkg_plugin_get_installed_apps_list(const char * /*category*/,
-        const char * /*option*/, package_manager_pkg_info_t **list, int *count)
+                                              const char * /*option*/,
+                                              package_manager_pkg_info_t **list,
+                                              int *count)
 {
     LogDebug("pkg_plugin_get_installed_apps_list() is called");
 
     package_manager_pkg_info_t *pkg_list = NULL;
     package_manager_pkg_info_t *pkg_last = NULL;
 
-    Try {
-        if (FALSE == is_connected()) {
-            LogError("Fail DB Connect");
-            return FALSE;
-        }
+    WrtDB::WrtDatabase::attachToThreadRO();
+    TizenAppIdList tizenAppidList = WidgetDAOReadOnly::getTizenAppidList();
+    *count = 0;
+
+    FOREACH(iterator, tizenAppidList) {
+        package_manager_pkg_info_t *pkg_info =
+            static_cast<package_manager_pkg_info_t*>
+            (malloc(sizeof(package_manager_pkg_info_t)));
 
-        WidgetHandleList hndlList = WidgetDAO::getHandleList();
-        *count = 0;
-
-        FOREACH(iterator, hndlList) {
-            package_manager_pkg_info_t *pkg_info =
-                static_cast<package_manager_pkg_info_t*>
-                (malloc(sizeof(package_manager_pkg_info_t)));
-            if (NULL == pkg_info) {
-                LogError("Error in malloc");
-                return FALSE;
-            }
-
-            if (NULL == pkg_list) {
-                pkg_list = pkg_info;
-                pkg_last = pkg_info;
-            } else {
-                pkg_last->next = pkg_info;
-            }
-
-            WidgetDAO widget(*iterator);
-            DPL::Optional<DPL::String> pkgname = widget.getPkgname();
-            strncpy(pkg_info->pkg_type, "wgt", PKG_TYPE_STRING_LEN_MAX);
-            if(!pkgname.IsNull()) {
-                snprintf(pkg_info->pkg_name, PKG_NAME_STRING_LEN_MAX, "%s",
-                        DPL::ToUTF8String(*pkgname).c_str());
-            }
-
-            DPL::Optional<DPL::String> version = widget.getVersion();
-            if (!version.IsNull()) {
-                strncpy(pkg_info->version,
-                        DPL::ToUTF8String(*version).c_str(),
-                        PKG_VERSION_STRING_LEN_MAX);
-            }
-
-            (*count)++;
+        if (NULL == pkg_list) {
+            pkg_list = pkg_info;
             pkg_last = pkg_info;
+        } else {
+            pkg_last->next = pkg_info;
         }
-        *list = pkg_list;
-    }
-    Catch (WidgetDAO::Exception::DatabaseError) {
-        LogError("Database Error");
-        return FALSE;
+
+        TizenAppId tzAppid = *iterator;
+        WidgetDAOReadOnly widget(tzAppid);
+        strncpy(pkg_info->pkg_type, "wgt", PKG_TYPE_STRING_LEN_MAX);
+        snprintf(pkg_info->pkg_name, PKG_NAME_STRING_LEN_MAX, "%s",
+                 DPL::ToUTF8String(tzAppid).c_str());
+
+        DPL::Optional<DPL::String> version = widget.getVersion();
+        if (!version.IsNull()) {
+            strncpy(pkg_info->version,
+                    DPL::ToUTF8String(*version).c_str(),
+                    PKG_VERSION_STRING_LEN_MAX - 1);
+        }
+
+        (*count)++;
+        pkg_last = pkg_info;
     }
+    *list = pkg_list;
+    WrtDB::WrtDatabase::detachFromThread();
+
     return TRUE;
 }
 
-static int pkg_plugin_get_app_detail_info(const char *pkg_name,
-        package_manager_pkg_detail_info_t *pkg_detail_info)
+static int pkg_plugin_get_app_detail_info(
+    const char *pkg_name,
+    package_manager_pkg_detail_info_t *
+    pkg_detail_info)
 {
     LogDebug("pkg_plugin_get_app_detail_info() is called");
 
-    Try {
-        if (FALSE == is_connected()) {
-            LogError("Fail DB Connect");
-            return FALSE;
-        }
-
-        int handle = WidgetDAOReadOnly::getHandle(
-                        DPL::FromUTF8String(pkg_name));
-        WidgetDAO widget(handle);
+    WrtDB::WrtDatabase::attachToThreadRO();
+    int handle = WidgetDAOReadOnly::getHandle(
+            DPL::FromUTF8String(pkg_name));
+    WidgetDAOReadOnly widget(handle);
 
-        DPL::Optional<DPL::String> version = widget.getVersion();
-        DPL::Optional<DPL::String> id = widget.getGUID();
-        DPL::Optional<DPL::String> locale = widget.getDefaultlocale();
+    DPL::Optional<DPL::String> version = widget.getVersion();
+    DPL::Optional<DPL::String> id = widget.getGUID();
+    DPL::Optional<DPL::String> locale = widget.getDefaultlocale();
 
-        if (!version.IsNull()) {
-            strncpy(pkg_detail_info->version,
-                    DPL::ToUTF8String(*version).c_str(),
-                    PKG_VERSION_STRING_LEN_MAX);
-        }
-        snprintf(pkg_detail_info->optional_id, PKG_NAME_STRING_LEN_MAX, "%d",
-               handle);
-        WidgetLocalizedInfo localizedInfo;
-
-        if (locale.IsNull()) {
-            LogError("is NULL");
-            DPL::String languageTag(L"");
-            localizedInfo = widget.getLocalizedInfo(languageTag);
-        } else {
-            localizedInfo = widget.getLocalizedInfo(*locale);
-        }
-        DPL::Optional<DPL::String> desc(localizedInfo.description);
-
-        if (!desc.IsNull()) {
-            strncpy(pkg_detail_info->pkg_description,
-                    DPL::ToUTF8String(*desc).c_str(),
-                    PKG_VALUE_STRING_LEN_MAX);
-        }
-        strncpy(pkg_detail_info->pkg_type, "wgt", PKG_TYPE_STRING_LEN_MAX);
-        strncpy(pkg_detail_info->pkg_name, pkg_name, PKG_NAME_STRING_LEN_MAX);
-
-        /* set installed time */
-        pkg_detail_info->installed_time = widget.getInstallTime();
-
-        /* set Widget size */
-        DPL::String pkgName = DPL::FromUTF8String(pkg_name);
-        std::string installPath = WidgetConfig::GetWidgetBasePath(pkgName);
-        std::string persistentPath =
-            WidgetConfig::GetWidgetPersistentStoragePath(pkgName);
-        std::string tempPath =
-            WidgetConfig::GetWidgetTemporaryStoragePath(pkgName);
-        installPath += "/";
-        tempPath += "/";
-        persistentPath += "/";
-
-        size_t installedSize = Utils::getFolderSize(installPath);
-        size_t persistentSize = Utils::getFolderSize(persistentPath);
-        size_t appSize = installedSize - persistentSize;
-        size_t dataSize = persistentSize + Utils::getFolderSize(tempPath);
-
-        pkg_detail_info->installed_size = GET_DIRECTORY_SIZE_KB(installedSize);
-        pkg_detail_info->app_size = GET_DIRECTORY_SIZE_KB(appSize);
-        pkg_detail_info->data_size = GET_DIRECTORY_SIZE_KB(dataSize);
+    if (!version.IsNull()) {
+        strncpy(pkg_detail_info->version,
+                DPL::ToUTF8String(*version).c_str(),
+                PKG_VERSION_STRING_LEN_MAX - 1);
     }
-    Catch (WidgetDAO::Exception::DatabaseError) {
-        LogError("Database Error");
-        return FALSE;
+    snprintf(pkg_detail_info->optional_id, PKG_NAME_STRING_LEN_MAX, "%d",
+             handle);
+    WidgetLocalizedInfo localizedInfo;
+
+    if (locale.IsNull()) {
+        LogError("is NULL");
+        DPL::String languageTag(L"");
+        localizedInfo = widget.getLocalizedInfo(languageTag);
+    } else {
+        localizedInfo = widget.getLocalizedInfo(*locale);
+    }
+    DPL::Optional<DPL::String> desc(localizedInfo.description);
+
+    if (!desc.IsNull()) {
+        strncpy(pkg_detail_info->pkg_description,
+                DPL::ToUTF8String(*desc).c_str(),
+                PKG_VALUE_STRING_LEN_MAX - 1);
     }
+    strncpy(pkg_detail_info->pkg_type, "wgt", PKG_TYPE_STRING_LEN_MAX);
+    strncpy(pkg_detail_info->pkg_name, pkg_name, PKG_NAME_STRING_LEN_MAX - 1);
+
+    /* set installed time */
+    pkg_detail_info->installed_time = widget.getInstallTime();
+
+    /* set Widget size */
+    DPL::String pkgName = DPL::FromUTF8String(pkg_name);
+    std::string installPath = WidgetConfig::GetWidgetBasePath(pkgName);
+    std::string persistentPath =
+        WidgetConfig::GetWidgetPersistentStoragePath(pkgName);
+    std::string tempPath =
+        WidgetConfig::GetWidgetTemporaryStoragePath(pkgName);
+    installPath += "/";
+    tempPath += "/";
+    persistentPath += "/";
+
+    size_t installedSize = Utils::getFolderSize(installPath);
+    size_t persistentSize = Utils::getFolderSize(persistentPath);
+    size_t appSize = installedSize - persistentSize;
+    size_t dataSize = persistentSize + Utils::getFolderSize(tempPath);
+
+    pkg_detail_info->installed_size = GET_DIRECTORY_SIZE_KB(installedSize);
+    pkg_detail_info->app_size = GET_DIRECTORY_SIZE_KB(appSize);
+    pkg_detail_info->data_size = GET_DIRECTORY_SIZE_KB(dataSize);
+
+    WrtDB::WrtDatabase::detachFromThread();
     return TRUE;
 }
 
 static int pkg_plugin_get_app_detail_info_from_package(
-        const char * /*pkg_path*/,
-        package_manager_pkg_detail_info_t * /*pkg_detail_info*/)
+    const char * /*pkg_path*/,
+    package_manager_pkg_detail_info_t * /*pkg_detail_info*/)
 {
     LogDebug("pkg_plugin_get_app_detail_info_from_package() is called");