Add package mode restriction

Change-Id: Iecfbc3a7263e1b9867bf5ef0cc672cf7fdac1f3c
Signed-off-by: Jaemin Ryu <jm77.ryu@samsung.com>

diff --git a/libs/application.cpp b/libs/application.cpp
index 116349b..a94658c 100644 (file)
--- a/libs/application.cpp
+++ b/libs/application.cpp
@@ -29,43 +29,6 @@ ApplicationPolicy::~ApplicationPolicy()
 {
 }
 
-
-int ApplicationPolicy::setApplicationInstallationMode(int mode)
-{
-    try {
-        return context->methodCall<int>("ApplicationPolicy::setApplicationInstallationMode", mode);
-    } catch (runtime::Exception& e) {
-        return -1;
-    }
-}
-
-int ApplicationPolicy::getApplicationInstallationMode()
-{
-    try {
-        return context->methodCall<int>("ApplicationPolicy::getApplicationInstallationMode");
-    } catch (runtime::Exception& e) {
-        return -1;
-    }
-}
-
-int ApplicationPolicy::setApplicationUninstallationMode(int mode)
-{
-    try {
-        return context->methodCall<int>("ApplicationPolicy::setApplicationUninstallationMode", mode);
-    } catch (runtime::Exception& e) {
-        return -1;
-    }
-}
-
-int ApplicationPolicy::getApplicationUninstallationMode()
-{
-    try {
-        return context->methodCall<int>("ApplicationPolicy::getApplicationUninstallationMode");
-    } catch (runtime::Exception& e) {
-        return -1;
-    }
-}
-
 int ApplicationPolicy::setApplicationState(const std::string& appid, int state)
 {
     try {
@@ -147,28 +110,28 @@ int ApplicationPolicy::wipeApplicationData(const std::string& appid)
     }
 }
 
-int ApplicationPolicy::addPackageToBlacklist(const std::string& pkgid)
+int ApplicationPolicy::setModeRestriction(int mode)
 {
     try {
-        return context->methodCall<int>("ApplicationPolicy::addPackageToBlacklist", pkgid);
+        return context->methodCall<int>("ApplicationPolicy::setModeRestriction", mode);
     } catch (runtime::Exception& e) {
         return -1;
     }
 }
 
-int ApplicationPolicy::removePackageFromBlacklist(const std::string& pkgid)
+int ApplicationPolicy::unsetModeRestriction(int mode)
 {
     try {
-        return context->methodCall<int>("ApplicationPolicy::removePackageFromBlacklist", pkgid);
+        return context->methodCall<int>("ApplicationPolicy::unsetModeRestriction", mode);
     } catch (runtime::Exception& e) {
         return -1;
     }
 }
 
-int ApplicationPolicy::checkPackageIsBlacklisted(const std::string& pkgid)
+int ApplicationPolicy::getModeRestriction()
 {
     try {
-        return context->methodCall<int>("ApplicationPolicy::checkPackageIsBlacklisted", pkgid);
+        return context->methodCall<int>("ApplicationPolicy::getModeRestriction");
     } catch (runtime::Exception& e) {
         return -1;
     }

diff --git a/libs/dpm/application.cpp b/libs/dpm/application.cpp
index c05cb38..902e691 100644 (file)
--- a/libs/dpm/application.cpp
+++ b/libs/dpm/application.cpp
@@ -33,46 +33,34 @@ int dpm_context_release_application_policy(dpm_context_h context, dpm_applicatio
     return DPM_ERROR_NONE;
 }
 
-int dpm_application_set_installation_mode(dpm_application_policy_h handle, int mode)
-{
-    RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
-
-    DevicePolicyContext& client = GetDevicePolicyContext(handle);
-    ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
-    return application.setApplicationInstallationMode(mode);
-}
-
-int dpm_application_set_uninstallation_mode(dpm_application_policy_h handle, int mode)
+int dpm_application_set_mode_restriction(dpm_application_policy_h handle, int mode)
 {
     RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
+    RET_ON_FAILURE(mode, DPM_ERROR_INVALID_PARAMETER);
 
     DevicePolicyContext& client = GetDevicePolicyContext(handle);
     ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
-    return application.setApplicationUninstallationMode(mode);
+    return application.setModeRestriction(mode);
 }
 
-int dpm_application_get_installation_mode(dpm_application_policy_h handle, int *mode)
+int dpm_application_unset_mode_restriction(dpm_application_policy_h handle, int mode)
 {
     RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
+    RET_ON_FAILURE(mode, DPM_ERROR_INVALID_PARAMETER);
 
     DevicePolicyContext& client = GetDevicePolicyContext(handle);
     ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
-    int ret = application.getApplicationInstallationMode();
-    if (ret < 0) {
-        return -1;
-    }
-    *mode = ret;
-    return DPM_ERROR_NONE;
+    return application.unsetModeRestriction(mode);
 }
 
-int dpm_application_get_uninstallation_mode(dpm_application_policy_h handle, int *mode)
+int dpm_application_get_mode_restriction(dpm_application_policy_h handle, int *mode)
 {
     RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
     RET_ON_FAILURE(mode, DPM_ERROR_INVALID_PARAMETER);
 
     DevicePolicyContext& client = GetDevicePolicyContext(handle);
     ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
-    int ret = application.getApplicationUninstallationMode();
+    int ret = application.getModeRestriction();
     if (ret < 0) {
         return -1;
     }
@@ -106,43 +94,6 @@ int dpm_application_get_package_state(dpm_application_policy_h handle, const cha
     return DPM_ERROR_NONE;
 }
 
-int dpm_application_add_package_to_blacklist(dpm_application_policy_h handle, const char* pkgid)
-{
-    RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
-    RET_ON_FAILURE(pkgid, DPM_ERROR_INVALID_PARAMETER);
-
-    DevicePolicyContext& client = GetDevicePolicyContext(handle);
-    ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
-    return application.addPackageToBlacklist(pkgid);
-}
-
-int dpm_application_remove_package_from_blacklist(dpm_application_policy_h handle, const char* pkgid)
-{
-    RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
-    RET_ON_FAILURE(pkgid, DPM_ERROR_INVALID_PARAMETER);
-
-    DevicePolicyContext& client = GetDevicePolicyContext(handle);
-    ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
-    return application.removePackageFromBlacklist(pkgid);
-}
-
-int dpm_application_check_package_is_blacklisted(dpm_application_policy_h handle, const char* pkgid, int *blacklisted)
-{
-    RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
-    RET_ON_FAILURE(pkgid, DPM_ERROR_INVALID_PARAMETER);
-    RET_ON_FAILURE(blacklisted, DPM_ERROR_INVALID_PARAMETER);
-
-    DevicePolicyContext& client = GetDevicePolicyContext(handle);
-    ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
-    int ret = application.checkPackageIsBlacklisted(pkgid);
-    if (ret < 0) {
-        return -1;
-    }
-
-    *blacklisted = ret;
-    return DPM_ERROR_NONE;
-}
-
 int dpm_application_add_privilege_to_blacklist(dpm_application_policy_h handle, int type, const char* privilege)
 {
        RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
@@ -179,3 +130,23 @@ int dpm_application_check_privilege_is_blacklisted(dpm_application_policy_h hand
        *blacklisted = ret;
        return DPM_ERROR_NONE;
 }
+
+int dpm_application_install_package(dpm_application_policy_h handle, const char* pkgpath)
+{
+       RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
+       RET_ON_FAILURE(pkgpath, DPM_ERROR_INVALID_PARAMETER);
+
+       DevicePolicyContext& client = GetDevicePolicyContext(handle);
+       ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
+       return application.installPackage(pkgpath);
+}
+
+int dpm_application_uninstall_package(dpm_application_policy_h handle, const char* pkgid)
+{
+       RET_ON_FAILURE(handle, DPM_ERROR_INVALID_PARAMETER);
+       RET_ON_FAILURE(pkgid, DPM_ERROR_INVALID_PARAMETER);
+
+       DevicePolicyContext& client = GetDevicePolicyContext(handle);
+       ApplicationPolicy application = client.createPolicyInterface<ApplicationPolicy>();
+       return application.uninstallPackage(pkgid);
+}

diff --git a/libs/dpm/application.h b/libs/dpm/application.h
index 8dbe100..3beaaae 100644 (file)
--- a/libs/dpm/application.h
+++ b/libs/dpm/application.h
@@ -89,23 +89,17 @@ typedef enum {
  * @since_tizen 3.0
  */
 typedef enum {
-    PACKAGE_INSTALLATION_MODE_DISALLOW = 0, /**< Package installation disable */
-    PACKAGE_INSTALLATION_MODE_ALLOW  = 1    /**< Pasckage installation enable */
-} dpm_package_installation_mode_e;
+    DPM_PACKAGE_RESTRICTION_MODE_ALL        = 0x0F, /**< All package restriction mode */
+    DPM_PACKAGE_RESTRICTION_MODE_INSTALL    = 0x01, /**< Package install restriction */
+    DPM_PACKAGE_RESTRICTION_MODE_UNINSTALL  = 0x02, /**< Package uninstall restriction */
+    DPM_PACKAGE_RESTRICTION_MODE_REINSTALL  = 0x04, /**< Package reinstall restriction */
+    DPM_PACKAGE_RESTRICTION_MODE_MOVE       = 0x08  /**< Package move restriction */
+} dpm_package_restriction_mode_e;
 
 /**
- * @brief       Enumeration for uninstallation mode
- * @since_tizen 3.0
- */
-typedef enum {
-    PACKAGE_UNINSTALLATION_MODE_DISALLOW = 0, /**< Package uninstallation disable */
-    PACKAGE_UNINSTALLATION_MODE_ALLOW  = 1    /**< Package uninstallation enable */
-} dpm_package_uninstallation_mode_e;
-
-/**
- * @brief       Sets the default mode for application installation.
- * @details     If the mode is set to DPM_PACKAGE_INSTALLATION_MODE_DISALLOW,
- *              no application can be installed on the device.
+ * @brief       Restricts installation / uninstallation for all packages.
+ * @details     Administrator can use this api to restrict package installation, uninstallation,
+ *              reinstallation or move.
  * @since_tizen 3.0
  * @param[in]   handle The application policy handle
  * @param[in]   mode The installation mode to be set, one of DPM_PACKAGE_INSTALLATION_MODE_ALLOW or
@@ -118,32 +112,34 @@ typedef enum {
  * @pre         handle must be created by dpm_context_acquire_application_policy()
  * @see         dpm_context_acquire_application_policy()
  * @see         dpm_context_release_application_policy()
- * @see         dpm_application_get_installation_mode()
+ * @see         dpm_application_unset_mode_restriction()
+ * @see         dpm_application_get_mode_restriction()
  */
-DPM_API int dpm_application_set_installation_mode(dpm_application_policy_h handle, int mode);
+DPM_API int dpm_application_set_mode_restriction(dpm_application_policy_h handle, int mode);
 
 /**
- * @brief       Sets the default mode for application uninstallation.
- * @details     If the mode is set to DPM_PACKAGE_UNINSTALLATION_MODE_DISALLOW,
- *              no application can be uninstalled from the device.
+ * @brief       Allows installation / uninstallation for all packages.
+ * @details     If the mode is set to DPM_PACKAGE_INSTALLATION_MODE_DISALLOW,
+ *              no application can be installed on the device.
  * @since_tizen 3.0
  * @param[in]   handle The application policy handle
- * @param[in]   mode The unstallation mode to be set, one of DPM_PACKAGE_UNINSTALLATION_MODE_ALLOW of
- *              DPM_PACKAGE_UNINSTALLATION_MODE_DISALLOW
+ * @param[in]   mode The installation mode to be set, one of DPM_PACKAGE_INSTALLATION_MODE_ALLOW or
+ *              DPM_PACKAGE_INSTALLATION_MODE_DISALLOW
  * @return      #DPM_ERROR_NONE on success, otherwise a negative value
- * @retval      #DPM_ERROR_NONE Successful
+ * @retval      #DPM_ERROR_NONE No error
  * @retval      #DPM_ERROR_TIMEOUT Time out
  * @retval      #DPM_ERROR_ACCESS_DENIED The application does not have
  *              the privilege to call this API
  * @pre         handle must be created by dpm_context_acquire_application_policy()
  * @see         dpm_context_acquire_application_policy()
  * @see         dpm_context_release_application_policy()
- * @see         dpm_application_get_uninstallation_mode()
+ * @see         dpm_application_set_mode_restriction()
+ * @see         dpm_application_get_mode_restriction()
  */
-DPM_API int dpm_application_set_uninstallation_mode(dpm_application_policy_h handle, int mode);
+DPM_API int dpm_application_unset_mode_restriction(dpm_application_policy_h handle, int mode);
 
 /**
- * @brief       Gets the current installation mode for all packages.
+ * @brief       Gets the current restriction mode for all packages.
  * @details     The default mode is to allow any package to be installed.
  * @since_tizen 3.0
  * @param[in]   handle The application policy handle
@@ -156,27 +152,11 @@ DPM_API int dpm_application_set_uninstallation_mode(dpm_application_policy_h han
  * @pre         handle must be created by dpm_context_acquire_application_policy()
  * @see         dpm_context_acquire_application_policy()
  * @see         dpm_context_release_application_policy()
- * @see         dpm_application_set_installation_mode()
- */
-DPM_API int dpm_application_get_installation_mode(dpm_application_policy_h handle, int *mode);
-
-/**
- * @brief       Gets the current uninstallation mode for all packages.
- * @details     The default mode is to allow any package to be uninstalled.
- * @since_tizen 3.0
- * @param[in]   handle The application policy handle
- * @param[out]  mode Current mode of operation, which is one of the following:
- *              #DPM_PACKAGE_UNINSTALLATION_MODE_ALLOW Package uninstallation is allowed
- *              #DPM_PACKAGE_UNINSTALLATION_MODE_DISALLOW Package uninstallation is not allowed
- * @return      #DPM_ERROR_NONE on success, otherwise a negative value
- * @retval      #DPM_ERROR_NONE Successful
- * @retval      #DPM_ERROR_TIMEOUT Time out
- * @pre         handle must be created by dpm_context_acquire_application_policy()
- * @see         dpm_context_acquire_application_policy()
- * @see         dpm_context_release_application_policy()
- * @see         dpm_application_get_uninstallation_mode()
+ * @see         dpm_application_set_mode_restriction()
+ * @see         dpm_application_unset_mode_restriction()
+ * @see         dpm_application_get_mode_restriction()
  */
-DPM_API int dpm_application_get_uninstallation_mode(dpm_application_policy_h handle, int *mode);
+DPM_API int dpm_application_get_mode_restriction(dpm_application_policy_h handle, int *mode);
 
 /**
  * @brief       Enables/disables an package without installation/uninstallation.
@@ -218,64 +198,6 @@ DPM_API int dpm_application_set_package_state(dpm_application_policy_h handle, c
 DPM_API int dpm_application_get_package_state(dpm_application_policy_h handle, const char* pkgid, int *state);
 
 /**
- * @brief       Adds package to blacklist
- * @details     Administrator can use this API to disallow package installation
- *              corresponding to the given pkgid.
- * @since_tizen 3.0
- * @param[in]   handle The application policy handle
- * @param[in]   pkgid The package name to be blacklisted
- * @return      #DPM_ERROR_NONE on success, otherwise a negative value
- * @retval      #DPM_ERROR_NONE Successful
- * @retval      #DPM_ERROR_TIMEOUT Time out
- * @retval      #DPM_ERROR_ACCESS_DENIED The application does not have
- *              the privilege to call this API
- * @pre         handle must be created by dpm_context_acquire_application_policy()
- * @see         dpm_context_acquire_application_policy()
- * @see         dpm_context_release_application_policy()
- * @see         dpm_application_remove_package_from_blacklist()
- * @see         dpm_application_check_package_is_blacklisted()
- */
-DPM_API int dpm_application_add_package_to_blacklist(dpm_application_policy_h handle, const char* pkgid);
-
-/**
- * @brief       Removes package from blacklist
- * @details     Administrator can use this API to remove package from blacklist.
- * @since_tizen 3.0
- * @param[in]   handle The application policy handle
- * @param[in]   pkgid The package name which is removed from blacklist
- * @return      #DPM_ERROR_NONE on success, otherwise a negative value
- * @retval      #DPM_ERROR_NONE Successful
- * @retval      #DPM_ERROR_TIMEOUT Time out
- * @retval      #DPM_ERROR_ACCESS_DENIED The application does not have
- *              the privilege to call this API
- * @pre         handle must be created by dpm_context_acquire_application_policy()
- * @see         dpm_context_acquire_application_policy()
- * @see         dpm_context_release_application_policy()
- * @see         dpm_application_add_package_to_blacklist()
- * @see         dpm_application_check_package_is_blacklisted()
- */
-DPM_API int dpm_application_remove_package_from_blacklist(dpm_application_policy_h handle, const char* pkgid);
-
-/**
- * @brief       Checks whether a package is added to blacklist
- * @details     Administrator can use this API to check whether the package is blacklisted.
- *              Once package is added to blacklist, it is prohibited to install on the device.
- * @since_tizen 3.0
- * @param[in]   handle The application policy handle
- * @param[in]   pkgid The package name of the application
- * @param[out]  blacklisted TRUE if the package installation is disabled, else FALSE
- * @return      #DPM_ERROR_NONE on success, otherwise a negative value
- * @retval      #DPM_ERROR_NONE Successful
- * @retval      #DPM_ERROR_TIMEOUT Time out
- * @pre         handle must be created by dpm_context_acquire_application_policy()
- * @see         dpm_context_acquire_application_policy()
- * @see         dpm_context_release_application_policy()
- * @see         dpm_application_add_package_to_blacklist()
- * @see         dpm_application_remove_package_from_blacklist()
- */
-DPM_API int dpm_application_check_package_is_blacklisted(dpm_application_policy_h handle, const char* pkgid, int *blacklisted);
-
-/**
  * @brief       Adds privilege to blacklist
  * @details     Administrator can use this API to disallow package installation
  *              which requires the privilege.
@@ -337,6 +259,8 @@ DPM_API int dpm_application_remove_privilege_from_blacklist(dpm_application_poli
  */
 DPM_API int dpm_application_check_privilege_is_blacklisted(dpm_application_policy_h handle, int type, const char* privilege, int *blacklisted);
 
+DPM_API int dpm_application_install_package(dpm_application_policy_h handle, const char* pkgpath);
+DPM_API int dpm_application_uninstall_package(dpm_application_policy_h handle, const char* pkgid);
 /**
  * @}
  */

diff --git a/policy/application.hxx b/policy/application.hxx
index 36058ea..81fb63e 100644 (file)
--- a/policy/application.hxx
+++ b/policy/application.hxx
@@ -29,15 +29,17 @@ public:
         PRIVILEGE_TYPE_CORE = 1
     };
 
+    enum RestrictionMode {
+        RESTRICTION_MODE_ALL = 0x0F,
+        RESTRICTION_MODE_INSTALL = 0x01,
+        RESTRICTION_MODE_UNINSTALL = 0x02,
+        RESTRICTION_MODE_REINSTALL = 0x04,
+        RESTRICTION_MODE_MVOE = 0x08
+    };
+
     ApplicationPolicy(PolicyControlContext& ctxt);
     ~ApplicationPolicy();
 
-    int setApplicationInstallationMode(int mode);
-    int getApplicationInstallationMode();
-
-    int setApplicationUninstallationMode(int mode);
-    int getApplicationUninstallationMode();
-
     int setApplicationState(const std::string& appid, int state);
     int getApplicationState(const std::string& appid);
 
@@ -52,9 +54,9 @@ public:
 
     int wipeApplicationData(const std::string& appid);
 
-    int addPackageToBlacklist(const std::string& pkgid);
-    int removePackageFromBlacklist(const std::string& pkgid);
-    int checkPackageIsBlacklisted(const std::string& pkgid);
+    int setModeRestriction(int mode);
+    int unsetModeRestriction(int mode);
+    int getModeRestriction();
 
     int addPrivilegeToBlacklist(int type, const std::string& privilege);
     int removePrivilegeFromBlacklist(int type, const std::string& privilege);

diff --git a/server/application.cpp b/server/application.cpp
index aa12764..4d4f0de 100644 (file)
--- a/server/application.cpp
+++ b/server/application.cpp
@@ -34,11 +34,14 @@ namespace DevicePolicyManager {
 ApplicationPolicy::ApplicationPolicy(PolicyControlContext& ctxt) :
     context(ctxt)
 {
-    context.registerNonparametricMethod(this, (int)(ApplicationPolicy::getApplicationInstallationMode)());
-    context.registerNonparametricMethod(this, (int)(ApplicationPolicy::getApplicationUninstallationMode)());
+    context.registerNonparametricMethod(this, (int)(ApplicationPolicy::getModeRestriction)());
+    context.registerParametricMethod(this, (int)(ApplicationPolicy::setModeRestriction)(int));
+    context.registerParametricMethod(this, (int)(ApplicationPolicy::unsetModeRestriction)(int));
+
+    context.registerParametricMethod(this, (int)(ApplicationPolicy::addPrivilegeToBlacklist)(int, std::string));
+    context.registerParametricMethod(this, (int)(ApplicationPolicy::removePrivilegeFromBlacklist)(int, std::string));
+    context.registerParametricMethod(this, (int)(ApplicationPolicy::checkPrivilegeIsBlacklisted)(int, std::string));
 
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::setApplicationInstallationMode)(int));
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::setApplicationUninstallationMode)(int));
     context.registerParametricMethod(this, (int)(ApplicationPolicy::installPackage)(std::string));
     context.registerParametricMethod(this, (int)(ApplicationPolicy::uninstallPackage)(std::string));
     context.registerParametricMethod(this, (int)(ApplicationPolicy::disableApplication)(std::string));
@@ -48,51 +51,19 @@ ApplicationPolicy::ApplicationPolicy(PolicyControlContext& ctxt) :
     context.registerParametricMethod(this, (int)(ApplicationPolicy::startApplication)(std::string));
     context.registerParametricMethod(this, (int)(ApplicationPolicy::stopApplication)(std::string));
     context.registerParametricMethod(this, (int)(ApplicationPolicy::wipeApplicationData)(std::string));
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::addPackageToBlacklist)(std::string));
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::removePackageFromBlacklist)(std::string));
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::checkPackageIsBlacklisted)(std::string));
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::addPrivilegeToBlacklist)(int, std::string));
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::removePrivilegeFromBlacklist)(int, std::string));
-    context.registerParametricMethod(this, (int)(ApplicationPolicy::checkPrivilegeIsBlacklisted)(int, std::string));
-
-    context.createNotification("package-installation-mode");
-    context.createNotification("package-uninstallation-mode");
 }
 
 ApplicationPolicy::~ApplicationPolicy()
 {
 }
 
-int ApplicationPolicy::setApplicationInstallationMode(int mode)
-{
-    SetPolicyAllowed(context, "package-installation-mode", mode);
-
-    return 0;
-}
-
-int ApplicationPolicy::getApplicationInstallationMode()
-{
-    return IsPolicyAllowed(context, "package-installation-mode");
-}
-
-int ApplicationPolicy::setApplicationUninstallationMode(int mode)
-{
-    SetPolicyAllowed(context, "package-uninstallation-mode", mode);
-    return 0;
-}
-
-int ApplicationPolicy::getApplicationUninstallationMode()
-{
-    return IsPolicyAllowed(context, "package-uninstallation-mode");
-}
-
 int ApplicationPolicy::installPackage(const std::string& pkgpath)
 {
     try {
         PackageManager& packman = PackageManager::instance();
         packman.installPackage(pkgpath, context.getPeerUid());
     } catch (runtime::Exception& e) {
-        ERROR("Exception in Package Id");
+        ERROR("Exception on package installation: " + pkgpath);
         return -1;
     }
 
@@ -105,7 +76,7 @@ int ApplicationPolicy::uninstallPackage(const std::string& pkgid)
         PackageManager& packman = PackageManager::instance();
         packman.uninstallPackage(pkgid, context.getPeerUid());
     } catch (runtime::Exception& e) {
-        ERROR("Exception in Package Id");
+        ERROR("Exception on package uninstallation: " + pkgid);
         return -1;
     }
 
@@ -187,39 +158,39 @@ int ApplicationPolicy::wipeApplicationData(const std::string& appid)
     return 0;
 }
 
-int ApplicationPolicy::addPackageToBlacklist(const std::string& pkgid)
+int ApplicationPolicy::setModeRestriction(int mode)
 {
     try {
         PackageManager& packman = PackageManager::instance();
-        packman.addPackageToBlacklist(pkgid, context.getPeerUid());
+        packman.setModeRestriction(mode, context.getPeerUid());
     } catch (runtime::Exception& e) {
-        ERROR("Exception on adding package to blacklist: " + pkgid);
+        ERROR("Failed to set mode restriction");
         return -1;
     }
 
     return 0;
 }
 
-int ApplicationPolicy::removePackageFromBlacklist(const std::string& pkgid)
+int ApplicationPolicy::unsetModeRestriction(int mode)
 {
     try {
         PackageManager& packman = PackageManager::instance();
-        packman.removePackageFromBlacklist(pkgid, context.getPeerUid());
+        packman.unsetModeRestriction(mode, context.getPeerUid());
     } catch (runtime::Exception& e) {
-        ERROR("Exception on removing package to blacklist: " + pkgid);
+        ERROR("Failed to unset mode restriction");
         return -1;
     }
 
     return 0;
 }
 
-int ApplicationPolicy::checkPackageIsBlacklisted(const std::string& pkgid)
+int ApplicationPolicy::getModeRestriction()
 {
     try {
         PackageManager& packman = PackageManager::instance();
-        return packman.checkPackageIsBlacklisted(pkgid, context.getPeerUid());
+        return packman.getModeRestriction(context.getPeerUid());
     } catch (runtime::Exception& e) {
-        ERROR("Exception on checking package package blacklist: " + pkgid);
+        ERROR("Failed to get mode restriction");
         return -1;
     }
 }

diff --git a/server/packman.cpp b/server/packman.cpp
index ab16554..2ca3266 100644 (file)
--- a/server/packman.cpp
+++ b/server/packman.cpp
@@ -389,8 +389,7 @@ void PackageManager::deactivatePackage(const std::string& pkgid, const uid_t use
 void PackageManager::installPackage(const std::string& pkgpath, const uid_t user)
 {
     int ret = ::pkgmgr_client_usr_install(nativeRequestHandle, NULL, NULL, pkgpath.c_str(), NULL, PM_QUIET, PackageEventCallback, nullptr, user);
-    if (ret != PKGMGR_R_OK) {
-        ERROR("Error in pkgmgr_client_install");
+    if (ret < PKGMGR_R_OK) {
         throw runtime::Exception("Package installation failed");
     }
 }
@@ -399,7 +398,7 @@ void PackageManager::uninstallPackage(const std::string& pkgid, const uid_t user
 {
     std::string pkgtype;
 
-    PackageInfo pkgInfo(pkgid);
+    PackageInfo pkgInfo(pkgid, user);
     pkgtype = pkgInfo.getType();
 
     int ret = ::pkgmgr_client_usr_uninstall(nativeRequestHandle, pkgtype.c_str(), pkgid.c_str(), PM_QUIET, PackageEventCallback, nullptr, user);
@@ -442,15 +441,32 @@ std::vector<std::string> PackageManager::getAppList(const uid_t user)
     return appList;
 }
 
-void PackageManager::addPackageToBlacklist(const std::string& pkgid, const uid_t user)
+void PackageManager::setModeRestriction(int mode, uid_t user)
 {
+    if (::pkgmgr_client_usr_set_restriction_mode(nativeRequestHandle,
+                                                 mode,
+                                                 user) != PKGMGR_R_OK) {
+        throw runtime::Exception("Failed to set package restriction mode");
+    }
 }
 
-void PackageManager::removePackageFromBlacklist(const std::string& pkgid, const uid_t user)
+void PackageManager::unsetModeRestriction(int mode, uid_t user)
 {
+    if (::pkgmgr_client_usr_unset_restriction_mode(nativeRequestHandle,
+                                                   mode,
+                                                   user) != PKGMGR_R_OK) {
+        throw runtime::Exception("Failed to unset package mode restriction");
+    }
 }
 
-bool PackageManager::checkPackageIsBlacklisted(const std::string& pkgid, const uid_t user)
+int PackageManager::getModeRestriction(uid_t user)
 {
-    return false;
+    int mode;
+    if (::pkgmgr_client_usr_get_restriction_mode(nativeRequestHandle,
+                                                 &mode,
+                                                 user) != PKGMGR_R_OK) {
+        throw runtime::Exception("Failed to get package restriction mode");
+    }
+
+    return mode;
 }

diff --git a/server/packman.h b/server/packman.h
index 31bae63..ccca4f8 100644 (file)
--- a/server/packman.h
+++ b/server/packman.h
@@ -92,9 +92,13 @@ public:
     void setEventCallback(pkgmgrinfo_handler callback, void* user_data);
     void unsetEventCallback();
 
-    void addPackageToBlacklist(const std::string& pkgid, const uid_t user);
-    void removePackageFromBlacklist(const std::string& pkgid, const uid_t user);
-    bool checkPackageIsBlacklisted(const std::string& pkgid, const uid_t user);
+    void setModeRestriction(int mode, uid_t user);
+    void unsetModeRestriction(int mode, uid_t user);
+    int getModeRestriction(uid_t user);
+
+    void setPackageRestriction(const std::string& pkgid, int mode, uid_t user);
+    void unsetPackageRestriction(const std::string& pkgid, int mode, uid_t user);
+    int getPackageRestriction(const std::string& pkgid, uid_t user);
 
     static PackageManager& instance();