[SECIOTSW-693] Remove maintenance check logic

Change-Id: I83e5ed45cc05163fb5fc0d0f55e06f4f6e43963b
Signed-off-by: Seok Hong <seok85.hong@samsung.com>

diff --git a/libs/administration.cpp b/libs/administration.cpp
index b1b4c87..507076f 100644 (file)
--- a/libs/administration.cpp
+++ b/libs/administration.cpp
@@ -14,6 +14,7 @@
  *  limitations under the License
  */
 
+#include "status.h"
 #include "administration.hxx"
 
 namespace DevicePolicyManager {
@@ -57,21 +58,23 @@ AdministrationPolicy::~AdministrationPolicy()
 int AdministrationPolicy::registerPolicyClient(const std::string& name, uid_t uid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("AdministrationPolicy::registerPolicyClient", name, uid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("AdministrationPolicy::registerPolicyClient", name, uid);
+
+       return status.get();
 }
 
 int AdministrationPolicy::deregisterPolicyClient(const std::string& name, uid_t uid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("AdministrationPolicy::deregisterPolicyClient", name, uid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("AdministrationPolicy::deregisterPolicyClient", name, uid);
+
+       return status.get();
 }
 
 } // namespace DevicePolicyManager

diff --git a/libs/application.cpp b/libs/application.cpp
index e791b43..429e6bd 100644 (file)
--- a/libs/application.cpp
+++ b/libs/application.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "application.hxx"
 
 namespace DevicePolicyManager {
@@ -55,80 +57,88 @@ ApplicationPolicy::~ApplicationPolicy()
 int ApplicationPolicy::installPackage(const std::string& pkgpath)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::installPackage", pkgpath);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("ApplicationPolicy::installPackage", pkgpath);
+
+       return status.get();
 }
 
 int ApplicationPolicy::uninstallPackage(const std::string& pkgid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::uninstallPackage", pkgid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("ApplicationPolicy::uninstallPackage", pkgid);
+
+       return status.get();
 }
 
 int ApplicationPolicy::setModeRestriction(int mode)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::setModeRestriction", mode);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("ApplicationPolicy::setModeRestriction", mode);
+
+       return status.get();
 }
 
 int ApplicationPolicy::unsetModeRestriction(int mode)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::unsetModeRestriction", mode);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("ApplicationPolicy::unsetModeRestriction", mode);
+
+       return status.get();
 }
 
 int ApplicationPolicy::getModeRestriction()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::getModeRestriction");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("ApplicationPolicy::getModeRestriction");
+
+       return status.get();
 }
 
 int ApplicationPolicy::addPrivilegeToBlacklist(int type, const std::string& privilege)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::addPrivilegeToBlacklist", type, privilege);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("ApplicationPolicy::addPrivilegeToBlacklist", type, privilege);
+
+       return status.get();
 }
 
 int ApplicationPolicy::removePrivilegeFromBlacklist(int type, const std::string& privilege)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::removePrivilegeFromBlacklist", type, privilege);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("ApplicationPolicy::removePrivilegeFromBlacklist", type, privilege);
+
+       return status.get();
 }
 
 int ApplicationPolicy::checkPrivilegeIsBlacklisted(int type, const std::string& privilege)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("ApplicationPolicy::checkPrivilegeIsBlacklisted", type, privilege);
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("ApplicationPolicy::checkPrivilegeIsBlacklisted", type, privilege);
+
+       return status.get();
 }
 } // namespace DevicePolicyManager

diff --git a/libs/bluetooth.cpp b/libs/bluetooth.cpp
index 4b4637a..ade8f32 100644 (file)
--- a/libs/bluetooth.cpp
+++ b/libs/bluetooth.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "bluetooth.hxx"
 
 namespace DevicePolicyManager {
@@ -56,161 +58,177 @@ BluetoothPolicy::~BluetoothPolicy()
 int BluetoothPolicy::setModeChangeState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::setModeChangeState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::setModeChangeState", enable);
+
+       return status.get();
 }
 
 bool BluetoothPolicy::getModeChangeState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("BluetoothPolicy::getModeChangeState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("BluetoothPolicy::getModeChangeState");
+
+       return status.get();
 }
 
 int BluetoothPolicy::setDesktopConnectivityState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("BluetoothPolicy::setDesktopConnectivityState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<bool>("BluetoothPolicy::setDesktopConnectivityState", enable);
+
+       return status.get();
 }
 
 bool BluetoothPolicy::getDesktopConnectivityState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("BluetoothPolicy::getDesktopConnectivityState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("BluetoothPolicy::getDesktopConnectivityState");
+
+       return status.get();
 }
 
 int BluetoothPolicy::setTetheringState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::setTetheringState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::setTetheringState", enable);
+
+       return status.get();
 }
 
 bool BluetoothPolicy::getTetheringState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("BluetoothPolicy::getTetheringState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("BluetoothPolicy::getTetheringState");
+
+       return status.get();
 }
 
 int BluetoothPolicy::setPairingState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::setPairingState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::setPairingState", enable);
+
+       return status.get();
 }
 
 bool BluetoothPolicy::getPairingState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("BluetoothPolicy::getPairingState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("BluetoothPolicy::getPairingState");
+
+       return status.get();
 }
 
 int BluetoothPolicy::addDeviceToBlacklist(const std::string& mac)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::addDeviceToBlacklist", mac);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::addDeviceToBlacklist", mac);
+
+       return status.get();
 }
 
 int BluetoothPolicy::removeDeviceFromBlacklist(const std::string& mac)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::removeDeviceFromBlacklist", mac);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::removeDeviceFromBlacklist", mac);
+
+       return status.get();
 }
 
 int BluetoothPolicy::setDeviceRestriction(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::setDeviceRestriction", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::setDeviceRestriction", enable);
+
+       return status.get();
 }
 
 bool BluetoothPolicy::isDeviceRestricted()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("BluetoothPolicy::isDeviceRestricted");
-       }
 
-       return false;
+       Status<bool> status { false };
+
+       status = context.methodCall<bool>("BluetoothPolicy::isDeviceRestricted");
+
+       return status.get();
 }
 
 int BluetoothPolicy::addUuidToBlacklist(const std::string& uuid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::addUuidToBlacklist", uuid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::addUuidToBlacklist", uuid);
+
+       return status.get();
 }
 
 int BluetoothPolicy::removeUuidFromBlacklist(const std::string& uuid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::removeUuidFromBlacklist", uuid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::removeUuidFromBlacklist", uuid);
+
+       return status.get();
 }
 
 int BluetoothPolicy::setUuidRestriction(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("BluetoothPolicy::setUuidRestriction", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("BluetoothPolicy::setUuidRestriction", enable);
+
+       return status.get();
 }
 
 bool BluetoothPolicy::isUuidRestricted()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("BluetoothPolicy::isUuidRestricted");
-       }
 
-       return false;
+       Status<bool> status { false };
+
+       status = context.methodCall<bool>("BluetoothPolicy::isUuidRestricted");
+
+       return status.get();
 }
 
 } // namespace DevicePolicyManager

diff --git a/libs/dsm/CMakeLists.txt b/libs/dsm/CMakeLists.txt
index 409b51f..5af3f4b 100644 (file)
--- a/libs/dsm/CMakeLists.txt
+++ b/libs/dsm/CMakeLists.txt
@@ -44,7 +44,7 @@ PKG_CHECK_MODULES(DSM_LIBS_DEPS       REQUIRED
                                                                glib-2.0
 )
 
-INCLUDE_DIRECTORIES(SYSTEM ${DSM_LIBS_DEPS_INCLUDE_DIRS} ../dpm dsm)
+INCLUDE_DIRECTORIES(SYSTEM ${DSM_LIBS_DEPS_INCLUDE_DIRS} ../ ../dpm dsm)
 TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${DSM_LIBS_DEPS_LIBRARIES} pthread)
 
 CONFIGURE_FILE(${PC_FILE}.in ${CMAKE_BINARY_DIR}/${PC_FILE} @ONLY)

diff --git a/libs/dsm/smack.cpp b/libs/dsm/smack.cpp
index ee9f9c8..20a0bdf 100644 (file)
--- a/libs/dsm/smack.cpp
+++ b/libs/dsm/smack.cpp
@@ -14,6 +14,7 @@
  *  limitations under the License
  */
 
+#include "status.h"
 #include "smack.hxx"
 
 namespace DevicePolicyManager {
@@ -57,21 +58,23 @@ SmackSecurityMonitor::~SmackSecurityMonitor()
 std::string SmackSecurityMonitor::getReport()
 {
        PolicyControlContext &context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<std::string>("SmackSecurityMonitor::getReport");
-       }
 
-       return "";
+       Status<std::string> status { std::string() };
+
+       status = context.methodCall<std::string>("SmackSecurityMonitor::getReport");
+
+       return status.get();
 }
 
 int SmackSecurityMonitor::getIssueCount()
 {
        PolicyControlContext &context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("SmackSecurityMonitor::getIssueCount");
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("SmackSecurityMonitor::getIssueCount");
+
+       return status.get();
 }
 
 } // namespace DevicePolicyManager

diff --git a/libs/krate.cpp b/libs/krate.cpp
index 0fba4c4..b49ac3f 100644 (file)
--- a/libs/krate.cpp
+++ b/libs/krate.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "krate.hxx"
 
 namespace DevicePolicyManager {
@@ -55,41 +57,45 @@ KratePolicy::~KratePolicy()
 int KratePolicy::createKrate(const std::string& name, const std::string& setupWizAppid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("KratePolicy::createKrate", name, setupWizAppid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("KratePolicy::createKrate", name, setupWizAppid);
+
+       return status.get();
 }
 
 int KratePolicy::removeKrate(const std::string& name)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("KratePolicy::removeKrate", name);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("KratePolicy::removeKrate", name);
+
+       return status.get();
 }
 
 int KratePolicy::getKrateState(const std::string& name)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("KratePolicy::getKrateState", name);
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("KratePolicy::getKrateState", name);
+
+       return status.get();
 }
 
 std::vector<std::string> KratePolicy::getKrateList(int state)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<std::vector<std::string>>("KratePolicy::getKrateList", state);
-       }
 
-       return std::vector<std::string>();
+       Status<std::vector<std::string>> status { std::vector<std::string>() };
+
+       status = context.methodCall<std::vector<std::string>>("KratePolicy::getKrateList", state);
+
+       return status.get();
 }
 
 } // namespace DevicePolicyManager

diff --git a/libs/location.cpp b/libs/location.cpp
index d3b0c0d..5a5bcb6 100644 (file)
--- a/libs/location.cpp
+++ b/libs/location.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "location.hxx"
 
 namespace DevicePolicyManager {
@@ -55,21 +57,23 @@ LocationPolicy::~LocationPolicy()
 int LocationPolicy::setLocationState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("LocationPolicy::setLocationState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("LocationPolicy::setLocationState", enable);
+
+       return status.get();
 }
 
 bool LocationPolicy::getLocationState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("LocationPolicy::getLocationState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("LocationPolicy::getLocationState");
+
+       return status.get();
 }
 
 } //namespace DevicePolicyManager

diff --git a/libs/password.cpp b/libs/password.cpp
index 31d1d90..8724c47 100644 (file)
--- a/libs/password.cpp
+++ b/libs/password.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "password.hxx"
 
 namespace DevicePolicyManager {
@@ -55,289 +57,319 @@ PasswordPolicy::~PasswordPolicy()
 int PasswordPolicy::setQuality(const int quality)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setQuality", quality);
-       }
-       return -1;
+
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setQuality", quality);
+
+       return status.get();
 }
 
 int PasswordPolicy::getQuality()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getQuality");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getQuality");
+
+       return status.get();
 }
 
 int PasswordPolicy::setMinimumLength(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setMinimumLength", value);
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::setMinimumLength", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getMinimumLength()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getMinimumLength");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getMinimumLength");
+
+       return status.get();
 }
 
 int PasswordPolicy::setMinComplexChars(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setMinComplexChars", value);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setMinComplexChars", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getMinComplexChars()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getMinComplexChars");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getMinComplexChars");
+
+       return status.get();
 }
 
 int PasswordPolicy::setMaximumFailedForWipe(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setMaximumFailedForWipe", value);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setMaximumFailedForWipe", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getMaximumFailedForWipe()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getMaximumFailedForWipe");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getMaximumFailedForWipe");
+
+       return status.get();
 }
 
 int PasswordPolicy::setExpires(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setExpires", value);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setExpires", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getExpires()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getExpires");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getExpires");
+
+       return status.get();
 }
 
 int PasswordPolicy::setHistory(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setHistory", value);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setHistory", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getHistory()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getHistory");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getHistory");
+
+       return status.get();
 }
 
 int PasswordPolicy::setPattern(const std::string &pattern)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setPattern", pattern);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setPattern", pattern);
+
+       return status.get();
 }
 
 int PasswordPolicy::reset(const std::string &passwd)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::reset", passwd);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::reset", passwd);
+
+       return status.get();
 }
 
 int PasswordPolicy::enforceChange()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::enforceChange");
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::enforceChange");
+
+       return status.get();
 }
 
 int PasswordPolicy::setMaxInactivityTimeDeviceLock(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setMaxInactivityTimeDeviceLock", value);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setMaxInactivityTimeDeviceLock", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getMaxInactivityTimeDeviceLock()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getMaxInactivityTimeDeviceLock");;
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getMaxInactivityTimeDeviceLock");;
+
+       return status.get();
 }
 
 int PasswordPolicy::setStatus(int status)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setStatus", status);
-       }
 
-       return -1;
+       Status<int> rstatus { -1 };
+
+       rstatus = context.methodCall<int>("PasswordPolicy::setStatus", status);
+
+       return rstatus.get();
 }
 
 int PasswordPolicy::getStatus()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getStatus");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getStatus");
+
+       return status.get();
 }
 
 int PasswordPolicy::deletePattern()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::deletePattern");
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::deletePattern");
+
+       return status.get();
 }
 
 std::string PasswordPolicy::getPattern()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<std::string>("PasswordPolicy::getPattern");
-       }
 
-       return std::string();
+       Status<std::string> status { std::string() };
+
+       status = context.methodCall<std::string>("PasswordPolicy::getPattern");
+
+       return status.get();
 }
 
 int PasswordPolicy::setMaximumCharacterOccurrences(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setMaximumCharacterOccurrences", value);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setMaximumCharacterOccurrences", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getMaximumCharacterOccurrences()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getMaximumCharacterOccurrences");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getMaximumCharacterOccurrences");
+
+       return status.get();
 }
 
 int PasswordPolicy::setMaximumNumericSequenceLength(int value)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setMaximumNumericSequenceLength", value);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setMaximumNumericSequenceLength", value);
+
+       return status.get();
 }
 
 int PasswordPolicy::getMaximumNumericSequenceLength()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getMaximumNumericSequenceLength");
-       }
 
-       return 0;
+       Status<int> status { 0 };
+
+       status = context.methodCall<int>("PasswordPolicy::getMaximumNumericSequenceLength");
+
+       return status.get();
 }
 
 int PasswordPolicy::setForbiddenStrings(const std::vector<std::string> &forbiddenStrings)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setForbiddenStrings", forbiddenStrings);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setForbiddenStrings", forbiddenStrings);
+
+       return status.get();
 }
 
 std::vector<std::string> PasswordPolicy::getForbiddenStrings()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<std::vector<std::string>>("PasswordPolicy::getForbiddenStrings");
-       }
 
-       return std::vector<std::string>();
+       Status<std::vector<std::string>> status { std::vector<std::string>() };
+
+       status = context.methodCall<std::vector<std::string>>("PasswordPolicy::getForbiddenStrings");
+
+       return status.get();
 }
 
 int PasswordPolicy::setRecovery(int enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::setRecovery", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("PasswordPolicy::setRecovery", enable);
+
+       return status.get();
 }
 
 int PasswordPolicy::getRecovery()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("PasswordPolicy::getRecovery");
-       }
 
-       return false;
+       Status<int> status { false };
+
+       status = context.methodCall<int>("PasswordPolicy::getRecovery");
+
+       return status.get();
 }
 } /* namespace DevicePolicyManager */

diff --git a/libs/policy-client.cpp b/libs/policy-client.cpp
index 6d6d3ef..ebcc32a 100644 (file)
--- a/libs/policy-client.cpp
+++ b/libs/policy-client.cpp
@@ -13,8 +13,11 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
-#include "policy-client.h"
+
 #include <system_info.h>
+#include <klay/filesystem.h>
+
+#include "policy-client.h"
 
 namespace {
 
@@ -25,20 +28,11 @@ const std::string POLICY_MANAGER_ADDRESS = "/tmp/.device-policy-manager.sock";
 
 int GetPolicyEnforceMode()
 {
-       char *profileName;
-
-       system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
-       switch (*profileName) {
-       case 'w':
-       case 'W':
-       case 'm':
-       case 'M':
-       case 't':
-       case 'T':
-               free(profileName);
+       runtime::File policyManagerSocket(POLICY_MANAGER_ADDRESS);
+
+       if (policyManagerSocket.exists()) {
                return 1;
        }
-       free(profileName);
 
        return 0;
 }

diff --git a/libs/policy-client.h b/libs/policy-client.h
index 86570a8..4d5145d 100644 (file)
--- a/libs/policy-client.h
+++ b/libs/policy-client.h
@@ -20,6 +20,7 @@
 #include <string>
 #include <memory>
 #include <functional>
+#include <cerrno>
 
 #include <klay/rmi/client.h>
 
@@ -52,13 +53,14 @@ public:
        template<typename Type, typename... Args>
        Type methodCall(const std::string& method, Args&&... args)
        {
-               return client->methodCall<Type, Args...>(method, std::forward<Args>(args)...);
-       }
+               if (maintenanceMode) {
+                       return client->methodCall<Type, Args...>(method, std::forward<Args>(args)...);
+               }
 
-       bool isMaintenanceMode()
-       {
-               return maintenanceMode;
+               errno = EPROTONOSUPPORT;
+               return Type();
        }
+
 private:
        PolicyControlContext& getPolicyControlContext()
        {
@@ -71,4 +73,5 @@ private:
 };
 
 DevicePolicyContext& GetDevicePolicyContext(void* handle);
+
 #endif //__POLICY_CLIENT_H__

diff --git a/libs/restriction.cpp b/libs/restriction.cpp
index 0bcf23a..9decd7f 100644 (file)
--- a/libs/restriction.cpp
+++ b/libs/restriction.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "restriction.hxx"
 
 namespace DevicePolicyManager {
@@ -57,181 +59,199 @@ RestrictionPolicy::~RestrictionPolicy()
 int RestrictionPolicy::setMicrophoneState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setMicrophoneState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setMicrophoneState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getMicrophoneState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getMicrophoneState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getMicrophoneState");
+
+       return status.get();
 }
 
 int RestrictionPolicy::setCameraState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setCameraState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setCameraState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getCameraState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getCameraState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getCameraState");
+
+       return status.get();
 }
 
 int RestrictionPolicy::setClipboardState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setClipboardState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setClipboardState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getClipboardState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getClipboardState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getClipboardState");
+
+       return status.get();
 }
 
 int RestrictionPolicy::setUsbDebuggingState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setUsbDebuggingState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setUsbDebuggingState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getUsbDebuggingState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getUsbDebuggingState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getUsbDebuggingState");
+
+       return status.get();
 }
 
 int RestrictionPolicy::setUsbTetheringState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setUsbTetheringState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setUsbTetheringState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getUsbTetheringState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getUsbTetheringState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getUsbTetheringState");
+
+       return status.get();
 }
 
 int RestrictionPolicy::setExternalStorageState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setExternalStorageState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setExternalStorageState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getExternalStorageState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getExternalStorageState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getExternalStorageState");
+
+       return status.get();
 }
 
 int RestrictionPolicy::setPopImapEmailState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setPopImapEmailState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setPopImapEmailState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getPopImapEmailState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getPopImapEmailState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getPopImapEmailState");
+
+       return status.get();
 }
 
 int RestrictionPolicy::setMessagingState(const std::string &sim_id, bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setMessagingState", sim_id, enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setMessagingState", sim_id, enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getMessagingState(const std::string &sim_id)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getMessagingState", sim_id);
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getMessagingState", sim_id);
+
+       return status.get();
 }
 
 int RestrictionPolicy::setBrowserState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("RestrictionPolicy::setBrowserState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("RestrictionPolicy::setBrowserState", enable);
+
+       return status.get();
 }
 
 bool RestrictionPolicy::getBrowserState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("RestrictionPolicy::getBrowserState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("RestrictionPolicy::getBrowserState");
+
+       return status.get();
 }
 
 } //namespace DevicePolicyManager

diff --git a/libs/security.cpp b/libs/security.cpp
index 290169b..cb2513d 100644 (file)
--- a/libs/security.cpp
+++ b/libs/security.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "security.hxx"
 
 namespace DevicePolicyManager {
@@ -55,51 +57,56 @@ SecurityPolicy::~SecurityPolicy()
 int SecurityPolicy::lockoutScreen()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("SecurityPolicy::lockoutScreen");
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("SecurityPolicy::lockoutScreen");
+
+       return status.get();
 }
 
 int SecurityPolicy::setInternalStorageEncryption(bool encrypt)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("SecurityPolicy::setInternalStorageEncryption", encrypt);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("SecurityPolicy::setInternalStorageEncryption", encrypt);
+
+       return status.get();
 }
 
 bool SecurityPolicy::isInternalStorageEncrypted()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("SecurityPolicy::isInternalStorageEncrypted");
-       }
 
-       return false;
+       Status<bool> status { false };
+
+       status = context.methodCall<int>("SecurityPolicy::isInternalStorageEncrypted");
+
+       return status.get();
 }
 
 int SecurityPolicy::setExternalStorageEncryption(bool encrypt)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("SecurityPolicy::setExternalStorageEncryption", encrypt);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("SecurityPolicy::setExternalStorageEncryption", encrypt);
+
+       return status.get();
 }
 
 bool SecurityPolicy::isExternalStorageEncrypted()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("SecurityPolicy::isExternalStorageEncrypted");
-       }
 
-       return false;
+       Status<bool> status { false };
+
+       status = context.methodCall<int>("SecurityPolicy::isExternalStorageEncrypted");
+
+       return status.get();
 }
 
 } // namespace DevicePolicyManager

diff --git a/libs/status.h b/libs/status.h
new file mode 100644 (file)
index 0000000..2336af6
--- /dev/null
+++ b/libs/status.h
@@ -0,0 +1,47 @@
+/*
+ *  Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License
+ */
+
+#ifndef __STATUS_H__
+#define __STATUS_H__
+
+#include <cerrno>
+#include <utility>
+
+template<typename Type>
+class Status {
+public:
+       Status() = delete;
+       Status(Type&& defaultValue) : value(std::forward<Type>(defaultValue))
+       {
+               errno = 0;
+       }
+
+       void operator=(Type&& newValue)
+       {
+               if (errno == 0)
+                       value = newValue;
+       }
+
+       Type get() const
+       {
+               return value;
+       }
+
+private:
+       Type value;
+};
+
+#endif //!__STATUS_H__

diff --git a/libs/storage.cpp b/libs/storage.cpp
index c702e40..2d98adc 100644 (file)
--- a/libs/storage.cpp
+++ b/libs/storage.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "storage.hxx"
 
 namespace DevicePolicyManager {
@@ -55,11 +57,12 @@ StoragePolicy::~StoragePolicy()
 int StoragePolicy::wipeData(int type)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("StoragePolicy::wipeData", type);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("StoragePolicy::wipeData", type);
+
+       return status.get();
 }
 
 } //namespace DevicePolicyManager

diff --git a/libs/wifi.cpp b/libs/wifi.cpp
index 179270d..69d338e 100644 (file)
--- a/libs/wifi.cpp
+++ b/libs/wifi.cpp
@@ -13,6 +13,8 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License
  */
+
+#include "status.h"
 #include "wifi.hxx"
 
 namespace DevicePolicyManager {
@@ -56,102 +58,111 @@ WifiPolicy::~WifiPolicy()
 int WifiPolicy::setState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("WifiPolicy::setState", enable);
-       }
 
+       Status<int> status { -1 };
 
-       return -1;
+       status = context.methodCall<int>("WifiPolicy::setState", enable);
+
+       return status.get();
 }
 
 bool WifiPolicy::getState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("WifiPolicy::getState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("WifiPolicy::getState");
+
+       return status.get();
 }
 
 int WifiPolicy::setHotspotState(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("WifiPolicy::setHotspotState", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("WifiPolicy::setHotspotState", enable);
+
+       return status.get();
 }
 
 bool WifiPolicy::getHotspotState()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("WifiPolicy::getHotspotState");
-       }
 
-       return true;
+       Status<bool> status { true };
+
+       status = context.methodCall<bool>("WifiPolicy::getHotspotState");
+
+       return status.get();
 }
 
 int WifiPolicy::setProfileChangeRestriction(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("WifiPolicy::setProfileChangeRestriction", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("WifiPolicy::setProfileChangeRestriction", enable);
+
+       return status.get();
 }
 
 bool WifiPolicy::isProfileChangeRestricted()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("WifiPolicy::isProfileChangeRestricted");
-       }
 
-       return false;
+       Status<bool> status { false };
+
+       status = context.methodCall<bool>("WifiPolicy::isProfileChangeRestricted");
+
+       return status.get();
 }
 
 int WifiPolicy::setNetworkAccessRestriction(bool enable)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("WifiPolicy::setNetworkAccessRestriction", enable);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("WifiPolicy::setNetworkAccessRestriction", enable);
+
+       return status.get();
 }
 
 bool WifiPolicy::isNetworkAccessRestricted()
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<bool>("WifiPolicy::isNetworkAccessRestricted");
-       }
 
-       return false;
+       Status<bool> status { false };
+
+       status = context.methodCall<bool>("WifiPolicy::isNetworkAccessRestricted");
+
+       return status.get();
 }
 
 int WifiPolicy::addSsidToBlocklist(const std::string& ssid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("WifiPolicy::addSsidToBlocklist", ssid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("WifiPolicy::addSsidToBlocklist", ssid);
+
+       return status.get();
 }
 
 int WifiPolicy::removeSsidFromBlocklist(const std::string& ssid)
 {
        PolicyControlContext& context = pimpl->context;
-       if (context.isMaintenanceMode()) {
-               return context.methodCall<int>("WifiPolicy::removeSsidFromBlocklist", ssid);
-       }
 
-       return -1;
+       Status<int> status { -1 };
+
+       status = context.methodCall<int>("WifiPolicy::removeSsidFromBlocklist", ssid);
+
+       return status.get();
 }
 
 } // namespace DevicePolicyManager