Apply notification of dpm

Change-Id: Ia114d84764dcfba001395b57150b5069c260dabd
Signed-off-by: yeji01kim <yeji01.kim@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 972cdd4..3f3679c 100755 (executable)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -74,7 +74,6 @@ SET(UI_SRCS  src/ui/widget.cpp
                         src/ui/conformant-window.cpp)
 
 SET(TESTCASES          src/policy/application.cpp
-                               src/policy/bluetooth.cpp
                                src/policy/password.cpp
                                src/policy/security.cpp
                                src/policy/restriction.cpp

diff --git a/src/policy/bluetooth.cpp b/src/policy/bluetooth.cpp
deleted file mode 100755 (executable)
index 903a826..0000000
--- a/src/policy/bluetooth.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-/*
- *
- * Copyright (c) 2017 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.
- *
- */
-
-#include "dpmtoolkit.h"
-#include "policy.h"
-
-#include <dpm/bluetooth.h>
-
-class BluetoothPolicy : public AbstractPolicy {
-public:
-       BluetoothPolicy(const std::string& name) :
-               AbstractPolicy(name)
-       {
-       }
-
-       std::vector<WorkbenchActionDelegate> inspect()
-       {
-               std::vector<WorkbenchActionDelegate> actionList = {
-                       WorkbenchActionDelegate("Set uuid restriction", this, &BluetoothPolicy::setUuidRestriction),
-                       WorkbenchActionDelegate("Get uuid restriction", this, &BluetoothPolicy::getUuidRestriction),
-                       WorkbenchActionDelegate("Set device restriction", this, &BluetoothPolicy::setDeviceRestriction),
-                       WorkbenchActionDelegate("Get device restriction", this, &BluetoothPolicy::getDeviceRestriction)
-               };
-               return actionList;
-       }
-
-       virtual ~BluetoothPolicy()
-       {
-       }
-
-       int setUuidRestriction(Workbench *workbench, std::string& desc)
-       {
-               device_policy_manager_h handle = NULL;
-               int state, enable;
-
-               if (workbench->showRadioPopup(desc, RESTRICTION_MODE_OPTIONS, enable) == -1)
-                       return POLICY_RESULT_FAIL;
-
-               handle = ::dpm_manager_create();
-               if (handle == NULL) {
-                       workbench->showMessagePopup(desc, "Failed to create device policy manager");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (::dpm_bluetooth_set_uuid_restriction(handle, enable) != DPM_ERROR_NONE) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, "Failed to enforce policy");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (::dpm_bluetooth_is_uuid_restricted(handle, &state) != DPM_ERROR_NONE) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, "Failed to query handle");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (state == enable) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, RESTRICTION_MODE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
-               }
-
-               ::dpm_manager_destroy(handle);
-               workbench->showMessagePopup(desc, "Failed to set uuid restriction");
-               return POLICY_RESULT_FAIL;
-       }
-
-       int getUuidRestriction(Workbench *workbench, std::string& desc)
-       {
-               int state;
-               device_policy_manager_h handle = NULL;
-
-               handle = ::dpm_manager_create();
-               if (handle == NULL) {
-                       workbench->showMessagePopup(desc, "Failed to create device policy manager");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (::dpm_bluetooth_is_uuid_restricted(handle, &state) == 0) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, RESTRICTION_MODE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
-               }
-
-               ::dpm_manager_destroy(handle);
-               workbench->showMessagePopup(desc, "Fail to get uuid restriction");
-               return POLICY_RESULT_FAIL;
-       }
-
-       int setDeviceRestriction(Workbench *workbench, std::string& desc)
-       {
-               device_policy_manager_h handle = NULL;
-               int state, enable;
-
-               if (workbench->showRadioPopup(desc, RESTRICTION_MODE_OPTIONS, enable) == -1)
-                       return POLICY_RESULT_FAIL;
-
-               handle = ::dpm_manager_create();
-               if (handle == NULL) {
-                       workbench->showMessagePopup(desc, "Failed to create device policy manager");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (::dpm_bluetooth_set_device_restriction(handle, enable) != DPM_ERROR_NONE) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, "Failed to enforce policy");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (::dpm_bluetooth_is_device_restricted(handle, &state) != DPM_ERROR_NONE) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, "Failed to query handle");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (state == enable) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, RESTRICTION_MODE_MESSAGE(state));
-                       return POLICY_RESULT_FAIL;
-               }
-
-               ::dpm_manager_destroy(handle);
-               workbench->showMessagePopup(desc, "Failed to set device restriction");
-               return POLICY_RESULT_SUCCESS;
-       }
-
-       int getDeviceRestriction(Workbench *workbench, std::string& desc) {
-               int state;
-               device_policy_manager_h handle = NULL;
-
-               handle = ::dpm_manager_create();
-               if (handle == NULL) {
-                       workbench->showMessagePopup(desc, "Failed to create device policy manager");
-                       return POLICY_RESULT_FAIL;
-               }
-
-               if (::dpm_bluetooth_is_device_restricted(handle, &state) == 0) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, RESTRICTION_MODE_MESSAGE(state));
-                       return POLICY_RESULT_FAIL;
-               }
-
-               ::dpm_manager_destroy(handle);
-               workbench->showMessagePopup(desc, "Fail to get device restriction");
-               return POLICY_RESULT_SUCCESS;
-       }
-};
-
-PolicyBuilder<BluetoothPolicy> bluetoothPolicy("Bluetooth");

diff --git a/src/policy/restriction.cpp b/src/policy/restriction.cpp
index 1a0b0e3..3a18e0f 100755 (executable)
--- a/src/policy/restriction.cpp
+++ b/src/policy/restriction.cpp
@@ -20,6 +20,19 @@
 #include "policy.h"
 
 #include <dpm/restriction.h>
+#include <unistd.h>
+
+#define MAX_CNT 600
+
+static void devicePolicyHandleCallback(const char* name, const char* state, void* user_data)
+{
+       ::dlog_print(DLOG_DEBUG, LOG_TAG, "devicePolicyHandleCallback, state %s", state);
+       int* changedState = (int*)user_data;
+       if (::strcmp(state, "allowed") == 0)
+               *changedState = 1;
+       else if (::strcmp(state, "disallowed") == 0)
+               *changedState = 0;
+}
 
 class RestrictionPolicy : public AbstractPolicy {
 public:
@@ -73,7 +86,10 @@ public:
 
        int setCameraStatus(Workbench *workbench, std::string& desc)
        {
-               int state, allow = 0;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -85,22 +101,61 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_camera_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       // Add call back function
+                       if (::dpm_add_policy_changed_cb(handle, "camera", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_camera_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_camera_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       //restore policy
+                       if (::dpm_restriction_set_camera_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -110,7 +165,7 @@ public:
 
        int getCameraStatus(Workbench *workbench, std::string& desc)
        {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -132,7 +187,10 @@ public:
 
        int setMicrophoneState(Workbench *workbench, std::string& desc)
        {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -144,22 +202,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_microphone_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "microphone", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_microphone_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_microphone_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handley");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_microphone_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -168,7 +263,7 @@ public:
        }
 
        int getMicrophoneState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -189,8 +284,10 @@ public:
        }
 
        int setLocationState(Workbench *workbench, std::string& desc) {
-               int state;
-               int allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -202,22 +299,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_location_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "location", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_location_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_location_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_location_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -226,7 +360,7 @@ public:
        }
 
        int getLocationState(Workbench *workbench, std::string& desc) {
-               int state, ret;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -235,8 +369,7 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
-               ret = ::dpm_restriction_get_location_state(handle, &state);
-               if (ret == 0) {
+               if (::dpm_restriction_get_location_state(handle, &state) == 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
                        return POLICY_RESULT_SUCCESS;
@@ -248,7 +381,10 @@ public:
        }
 
        int setClipboardState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -260,22 +396,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_clipboard_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "clipboard", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_clipboard_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_clipboard_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_clipboard_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -284,7 +457,7 @@ public:
        }
 
        int getClipboardState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -305,7 +478,10 @@ public:
        }
 
        int setUsbDebuggingState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1) {
@@ -318,22 +494,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_usb_debugging_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "usb-debugging", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_usb_debugging_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Fail to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_usb_debugging_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Fail to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_usb_debugging_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Fail to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -342,7 +555,7 @@ public:
        }
 
        int getUsbDebuggingState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -363,7 +576,10 @@ public:
        }
 
        int setWifiState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -375,22 +591,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_wifi_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "wifi", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_wifi_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_wifi_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_wifi_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -399,7 +652,7 @@ public:
        }
 
        int getWifiState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -420,8 +673,7 @@ public:
        }
 
        int setWifiHotspotState(Workbench *workbench, std::string& desc) {
-               int state;
-               int allow;
+               int state = -1, allow = 0;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -446,9 +698,9 @@ public:
                }
 
                if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
                }
 
                ::dpm_manager_destroy(handle);
@@ -457,7 +709,7 @@ public:
        }
 
        int getWifiHotspotState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -478,7 +730,7 @@ public:
        }
 
        int setBluetoothTetheringState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -514,7 +766,7 @@ public:
        }
 
        int getBluetoothTetheringState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -535,7 +787,10 @@ public:
        }
 
        int setUsbTetheringState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -547,22 +802,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_usb_tethering_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "usb-tethering", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_usb_tethering_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_usb_tethering_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_usb_tethering_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to enforce policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -571,7 +863,7 @@ public:
        }
 
        int getUsbTetheringState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -592,7 +884,7 @@ public:
        }
 
        int setExternalStorageState(Workbench *workbench, std::string& desc) {
-               int index, state;
+               int index = 0, state = -1;
                device_policy_manager_h handle = NULL;
                const std::string text[] = {
                        "Disallow External Storage",
@@ -622,7 +914,7 @@ public:
 
                if (state != index) {
                        ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, "Policy was not setted properly");;
+                       workbench->showMessagePopup(desc, "Policy was not setted properly");
                        return POLICY_RESULT_FAIL;
                }
 
@@ -633,7 +925,7 @@ public:
        }
 
        int getExternalStorageState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -656,7 +948,7 @@ public:
        }
 
        int setBluetoothModeChangeState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -692,7 +984,7 @@ public:
        }
 
        int getBluetoothModeChangeState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -713,7 +1005,10 @@ public:
        }
 
        int setBluetoothDesktopConnectivityState(Workbench *workbench, std::string& desc) {
-               int state, allow = 0;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -725,22 +1020,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
-               if (::dpm_restriction_set_camera_state(handle, allow) != 0) {
+               ::dpm_restriction_get_bluetooth_desktop_connectivity_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "bluetooth-desktop-connectivity", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
+               if (::dpm_restriction_set_bluetooth_desktop_connectivity_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (::dpm_restriction_get_camera_state(handle, &state) != 0) {
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
+               if (::dpm_restriction_get_bluetooth_desktop_connectivity_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_bluetooth_desktop_connectivity_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -749,7 +1081,7 @@ public:
        }
 
        int getBluetoothDesktopConnectivityState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -770,7 +1102,10 @@ public:
        }
 
        int setBluetoothPairingState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -782,22 +1117,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_bluetooth_pairing_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "bluetooth-pairing", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_bluetooth_pairing_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_bluetooth_pairing_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_bluetooth_pairing_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -806,7 +1178,7 @@ public:
        }
 
        int getBluetoothPairingState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -827,7 +1199,10 @@ public:
        }
 
        int setPopimapEmailState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -839,22 +1214,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_popimap_email_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "popimap-email", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_popimap_email_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_popimap_email_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_popimap_email_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -863,7 +1275,7 @@ public:
        }
 
        int getPopimapEmailState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -884,7 +1296,10 @@ public:
        }
 
        int setMessagingState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1) {
@@ -898,22 +1313,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_messaging_state(handle, "sim1", &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "messaging", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_messaging_state(handle, "sim1", allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_messaging_state(handle, "sim1", &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_messaging_state(handle, "sim1", originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to resotre policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -922,7 +1374,7 @@ public:
        }
 
        int getMessagingState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();
@@ -943,7 +1395,10 @@ public:
        }
 
        int setBrowserState(Workbench *workbench, std::string& desc) {
-               int state, allow;
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
@@ -955,22 +1410,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_restriction_get_browser_state(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "browser", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_restriction_set_browser_state(handle, allow) != 0) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_restriction_get_browser_state(handle, &state) != 0) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to query handle");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_restriction_set_browser_state(handle, originState) != 0) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to restore policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);
@@ -979,7 +1471,7 @@ public:
        }
 
        int getBrowserState(Workbench *workbench, std::string& desc) {
-               int state;
+               int state = -1;
                device_policy_manager_h handle = NULL;
 
                handle = ::dpm_manager_create();

diff --git a/src/policy/wifi.cpp b/src/policy/wifi.cpp
index 032f629..dd49321 100755 (executable)
--- a/src/policy/wifi.cpp
+++ b/src/policy/wifi.cpp
@@ -20,6 +20,18 @@
 #include "policy.h"
 
 #include <dpm/wifi.h>
+#include <unistd.h>
+
+#define MAX_CNT 600
+
+static void devicePolicyHandleCallback(const char* name, const char* state, void* user_data)
+{
+       int* changedState = (int*)user_data;
+       if (::strcmp(state, "allowed") == 0)
+               *changedState = 1;
+       else if (::strcmp(state, "disallowed") == 0)
+               *changedState = 0;
+}
 
 class WifiPolicy : public AbstractPolicy {
 public:
@@ -160,8 +172,11 @@ public:
        }
 
        int setProfileChangeState(Workbench *workbench, std::string& desc) {
+               int state = -1, allow = 0;
+               int originState = -1, changedState = -1;
+               int cnt = 0, id = 0;
+               bool callbackFlag = false;
                device_policy_manager_h handle = NULL;
-               int state, allow;
 
                if (workbench->showRadioPopup(desc, STATE_CHANGE_OPTIONS, allow) == -1)
                        return POLICY_RESULT_FAIL;
@@ -172,22 +187,59 @@ public:
                        return POLICY_RESULT_FAIL;
                }
 
+               ::dpm_wifi_is_profile_change_restricted(handle, &originState);
+               if (originState != allow)
+                       callbackFlag = true;
+
+               if (callbackFlag) {
+                       if (::dpm_add_policy_changed_cb(handle, "wifi-profile-change", devicePolicyHandleCallback, &changedState, &id) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to add callback");
+                               return POLICY_RESULT_FAIL;
+                       }
+               }
+
                if (::dpm_wifi_set_profile_change_restriction(handle, allow) != DPM_ERROR_NONE) {
+                       if (callbackFlag)
+                               ::dpm_remove_policy_changed_cb(handle, id);
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
+               if (callbackFlag) {
+                       while(1) {
+                               if (changedState >= 0 || cnt == MAX_CNT)
+                                       break;
+                               ::sleep(0.1);
+                               cnt++;
+                       }
+               }
+
+               ::dpm_remove_policy_changed_cb(handle, id);
                if (::dpm_wifi_is_profile_change_restricted(handle, &state) != DPM_ERROR_NONE) {
                        ::dpm_manager_destroy(handle);
                        workbench->showMessagePopup(desc, "Failed to enforce policy");
                        return POLICY_RESULT_FAIL;
                }
 
-               if (state == allow) {
-                       ::dpm_manager_destroy(handle);
-                       workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
-                       return POLICY_RESULT_SUCCESS;
+               if (callbackFlag) {
+                       if (state == changedState) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
+                       if (::dpm_wifi_set_profile_change_restriction(handle, originState) != DPM_ERROR_NONE) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, "Failed to enforce policy");
+                               return POLICY_RESULT_FAIL;
+                       }
+               } else {
+                       if (state == allow) {
+                               ::dpm_manager_destroy(handle);
+                               workbench->showMessagePopup(desc, STATE_CHANGE_MESSAGE(state));
+                               return POLICY_RESULT_SUCCESS;
+                       }
                }
 
                ::dpm_manager_destroy(handle);