Use vconf class instead of vconf in c style

Change-Id: I92999da9e560b3f617886747ec02904ee1fa6d3c

diff --git a/src/AccessibilityLauncherPage.cpp b/src/AccessibilityLauncherPage.cpp
index 8ab35f5..2addab1 100644 (file)
--- a/src/AccessibilityLauncherPage.cpp
+++ b/src/AccessibilityLauncherPage.cpp
@@ -21,6 +21,7 @@
 #include "Button.hpp"
 #include "Genlist.hpp"
 #include "Singleton.hpp"
+#include "VConf.hpp"
 #include "setting-accessibility.h"
 #include "utils.hpp"
 
@@ -30,27 +31,20 @@
 
 AccessibilityLauncherPage::AccessibilityLauncherPage()
 {
-       items_.resize(3);
-       int state = 0;
-
        auto naviframe = Singleton<AppContext>::instance().getNaviframe();
        auto genlist = Widget::make<Genlist>(naviframe);
        genlist->setMode(ELM_LIST_COMPRESS);
        genlist->setStyle("dialogue");
 
-       auto ret = vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_STATE, &state);
-       if (ret != VCONF_OK) {
-               ERROR("FAIL: vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_STATE)");
-       }
-
+       auto launcherState = Singleton<VConfInterface>::instance().get(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_STATE, false);
        auto item = genlist->appendItem({"type1",
-               state ? "IDS_ACCS_ACCESSIBILITY_LAUNCHER_ON" : "IDS_ACCS_ACCESSIBILITY_LAUNCHER_OFF",
+               launcherState ? "IDS_ACCS_ACCESSIBILITY_LAUNCHER_ON" : "IDS_ACCS_ACCESSIBILITY_LAUNCHER_OFF",
                {},
                [this](auto item) {
                        ERROR("onSelection_ lambda");
                        item->setText(item->getState() ? "IDS_ACCS_ACCESSIBILITY_LAUNCHER_ON" : "IDS_ACCS_ACCESSIBILITY_LAUNCHER_OFF");
 
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_STATE, item->getState());
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_STATE, item->getState());
 
                        if (item->getState())
                                for (auto it : items_)
@@ -58,54 +52,28 @@ AccessibilityLauncherPage::AccessibilityLauncherPage()
                        else
                                for (auto it : items_)
                                        it->disable();
-
                        item->update();
                },
                GenlistItem::WidgetType::toggle});
+       item->setState(launcherState);
 
        genlist->appendItem({"multiline", {}, "IDS_ACCS_ACCESSIBILITY_LAUNCHER_COMMENT"});
 
-       int vconf_state;
-       ret = vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_LAUNCH, &vconf_state);
-       if (ret != VCONF_OK) {
-               ERROR("FAIL: vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_LAUNCH)");
-       }
-
-       items_[0] = genlist->appendItem({"type1",
-               "IDS_ST_BODY_ACCESSIBILITY",
-               {},
-               [this](auto item) {
-                       int value = 0;
-                       for (auto i = 0u; i < items_.size(); i++)
-                               if (items_[i]->getState())
-                                       value = value | (1 << i);
-                       vconf_set_int(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_LAUNCH, value);
-               },
-               GenlistItem::WidgetType::toggle});
-
-       items_[1] = genlist->appendItem({"type1",
-               "IDS_ST_MBODY_SCREEN_READER_HTTS",
-               {},
-               [this](auto item) {
-                       int value = 0;
-                       for (auto i = 0u; i < items_.size(); i++)
-                               if (items_[i]->getState())
-                                       value = value | (1 << i);
-                       vconf_set_int(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_LAUNCH, value);
-               },
-               GenlistItem::WidgetType::toggle});
-
-       items_[2] = genlist->appendItem({"type1",
-               "IDS_ACCS_UNIVERSAL_SWITCH",
-               {},
-               [this](auto item) {
-                       int value = 0;
-                       for (auto i = 0u; i < items_.size(); i++)
-                               if (items_[i]->getState())
-                                       value = value | (1 << i);
-                       vconf_set_int(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_LAUNCH, value);
-               },
-               GenlistItem::WidgetType::toggle});
+       auto updateLaunchState = [this](GenlistItem *item) {
+               auto state = 0;
+               for (auto i = 0u; i < items_.size(); i++)
+                       if (items_[i]->getState())
+                               state = state | (1 << i);
+               Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_LAUNCH, state);
+       };
+
+       items_.push_back(genlist->appendItem({"type1", "IDS_ST_BODY_ACCESSIBILITY", {}, updateLaunchState, GenlistItem::WidgetType::toggle}));
+       items_.push_back(genlist->appendItem({"type1", "IDS_ST_MBODY_SCREEN_READER_HTTS", {}, updateLaunchState, GenlistItem::WidgetType::toggle}));
+       items_.push_back(genlist->appendItem({"type1", "IDS_ACCS_UNIVERSAL_SWITCH", {}, updateLaunchState, GenlistItem::WidgetType::toggle}));
+
+       auto accessibilityLauncherLaunchState = Singleton<VConfInterface>::instance().get(VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY_LAUNCHER_LAUNCH, 0);
+       for (auto i = 0u; i < items_.size(); ++i)
+               items_[i]->setState(accessibilityLauncherLaunchState & (1 << i));
 
        if (item->getState())
                for (auto it : items_)

diff --git a/src/MainPage.cpp b/src/MainPage.cpp
index a56e394..b50af97 100644 (file)
--- a/src/MainPage.cpp
+++ b/src/MainPage.cpp
@@ -16,23 +16,20 @@ MainPage::MainPage()
 
        auto grp = genlist_->appendItem({"group_index", "IDS_ST_HEADER_VISION"});
 
-       int screen_reader = 0;
-       auto r = vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, &screen_reader);
-       if (r != VCONF_OK)
-               ERROR("Could not get value for key: %s", VCONFKEY_SETAPPL_ACCESSIBILITY_TTS);
-
-       auto screenReaderItem = genlist_->appendItem(
-               {"type1",
-                       "IDS_ST_MBODY_SCREEN_READER_HTTS",
-                       screen_reader ? "IDS_ST_BODY_ON" : "IDS_ST_BODY_OFF",
-                       [this](auto item) { screenReaderPage_ = std::make_unique<ScreenReaderPage>(); }},
+       auto screenReaderItem = genlist_->appendItem({"type1",
+                                                                                                        "IDS_ST_MBODY_SCREEN_READER_HTTS",
+                                                                                                        "IDS_ST_BODY_OFF",
+                                                                                                        [this](auto item) {
+                                                                                                                screenReaderPage_ = std::make_unique<ScreenReaderPage>();
+                                                                                                        }},
                grp);
 
-       int vconf_ret = vconf_notify_key_changed(
-               VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, onScreenReaderVconfKeyChanged, screenReaderItem);
-       if (vconf_ret != 0) {
-               ERROR("FAIL: vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS)");
-       }
+       auto onVConfValueChangeCb = [=](auto state) {
+               screenReaderItem->setDescription(state ? "IDS_ST_BODY_ON" : "IDS_ST_BODY_OFF");
+               screenReaderItem->update();
+       };
+
+       screenReaderStateHandle_ = Singleton<VConfInterface>::instance().registerAndGet<bool>({VCONFKEY_SETAPPL_ACCESSIBILITY_TTS}, false, onVConfValueChangeCb);
 
        genlist_->appendItem({"multiline",
                                                         "IDS_ACCS_UNIVERSAL_SWITCH",
@@ -51,18 +48,9 @@ MainPage::MainPage()
                "IDS_ST_BUTTON_BACK",
                Button::BACK_BUTTON_ARROW_STYLE);
 
-       context_.getNaviframe()->pushBack("IDS_ST_BODY_ACCESSIBILITY",
-               genlist_,
-               [this]() {
-                       vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, onScreenReaderVconfKeyChanged);
-                       ui_app_exit();
-               },
+       context_.getNaviframe()->pushBack("IDS_ST_BODY_ACCESSIBILITY", genlist_, [this]() {
+               screenReaderStateHandle_ = {};
+               ui_app_exit();
+       },
                prevBtn);
 }
-
-void MainPage::onScreenReaderVconfKeyChanged(keynode_t *key, void *user_data)
-{
-       auto screenReaderItem = static_cast<GenlistItem *>(user_data);
-       screenReaderItem->setDescription(vconf_keynode_get_bool(key) ? "IDS_ST_BODY_ON" : "IDS_ST_BODY_OFF");
-       screenReaderItem->update();
-}

diff --git a/src/MainPage.hpp b/src/MainPage.hpp
index 93b84e7..9437687 100644 (file)
--- a/src/MainPage.hpp
+++ b/src/MainPage.hpp
@@ -5,6 +5,7 @@
 #include "AppContext.hpp"
 #include "ScreenReaderPage.hpp"
 #include "UniversalSwitchPage.hpp"
+#include "VConf.hpp"
 
 class MainPage
 {
@@ -12,13 +13,12 @@ class MainPage
        MainPage();
 
        private:
-       static void onScreenReaderVconfKeyChanged(keynode_t *key, void *user_data);
-
        AppContext &context_;
        Genlist *genlist_ = nullptr;
        std::unique_ptr<ScreenReaderPage> screenReaderPage_;
        std::unique_ptr<UniversalSwitchPage> universalSwitchPage_;
        std::unique_ptr<AccessibilityLauncherPage> accessibilityLauncherPage_;
+       VConfInterface::CallbackHandle screenReaderStateHandle_;
 };
 
 #endif

diff --git a/src/RemoveSwitchPage.cpp b/src/RemoveSwitchPage.cpp
index f98653a..0b581dc 100644 (file)
--- a/src/RemoveSwitchPage.cpp
+++ b/src/RemoveSwitchPage.cpp
@@ -21,6 +21,7 @@
 #include "Genlist.hpp"
 #include "Popup.hpp"
 #include "Singleton.hpp"
+#include "VConf.hpp"
 #include "setting-accessibility.h"
 
 #include <app.h>
@@ -93,14 +94,10 @@ void RemoveSwitchPage::createPopupForSwitchesRemoving()
        auto popup = Widget::make<Popup>(context_.getNaviframe(), "IDS_ACCS_UNIVERSAL_SWITCH_DELETE_SWITCHES");
 
        popup->setOrientation(ELM_POPUP_ORIENT_CENTER);
+       auto areAllSwitchesSelectedToRemove = switchesToRemoveCounter_ == genlist_->size();
 
-       int vconf_val;
-       int vconf_ret = vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, &vconf_val);
-       PRINT_ERROR_MESSAGE_IF(vconf_ret != 0,
-               "Failed to get vconf bool value VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE. Error: %d",
-               vconf_ret);
-
-       if (vconf_val && switchesToRemoveCounter_ == genlist_->size()) {
+       if (Singleton<VConfInterface>::instance().get(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, false) &&
+               areAllSwitchesSelectedToRemove) {
                popup->setText("IDS_ACCS_UNIVERSAL_SWITCH_DELETE_ALL_SWITCHES_DESC");
        } else {
                auto s = std::to_string(switchesToRemoveCounter_) + " " +
@@ -115,7 +112,7 @@ void RemoveSwitchPage::createPopupForSwitchesRemoving()
        auto cancelBtn = Widget::make<Button>(popup, removeCb, "IDS_ST_BUTTON_CANCEL", "bottom");
        popup->setPartContent("button1", cancelBtn);
 
-       auto removeSwitchCb = [removeCb, this]() {
+       auto removeSwitchCb = [removeCb, areAllSwitchesSelectedToRemove, this]() {
                auto item = genlist_->getLast();
                size_t i = genlist_->size() - 1;
                while (item) {
@@ -130,10 +127,8 @@ void RemoveSwitchPage::createPopupForSwitchesRemoving()
                context_.getNaviframe()->removeChild(removeSwitchPopupBtn_);
                context_.getNaviframe()->popBack();
 
-               bool disable_universal_switch = switchesToRemoveCounter_ == genlist_->size();
-               if (disable_universal_switch &&
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, 0))
-                       ERROR("Failed to set vconf key %s.", VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE);
+               if (areAllSwitchesSelectedToRemove)
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, false);
        };
 
        auto deleteSwitchBtn = Widget::make<Button>(popup, removeSwitchCb, "IDS_ACCS_DELETE", "bottom");

diff --git a/src/ScreenReaderPage.cpp b/src/ScreenReaderPage.cpp
index e4b11cf..b2ee774 100644 (file)
--- a/src/ScreenReaderPage.cpp
+++ b/src/ScreenReaderPage.cpp
@@ -36,13 +36,11 @@ ScreenReaderPage::ScreenReaderPage()
                {},
                [this](auto item) {
                        auto state = item->getState();
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, state);
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, state);
                        if (!state) {
-                               auto buf = TranslatedString{"IDS_ST_MBODY_SCREEN_READER_HTTS"}.str() + " " +
-                                                  TranslatedString{"IDS_ST_BODY_OFF"}.str();
+                               auto buf = TranslatedString{"IDS_ST_MBODY_SCREEN_READER_HTTS"}.str() + " " + TranslatedString{"IDS_ST_BODY_OFF"}.str();
                                int utterance_id;
-                               int ret = tts_add_text(
-                                       context_.ttsHandle_, buf.c_str(), NULL, TTS_VOICE_TYPE_AUTO, TTS_SPEED_AUTO, &utterance_id);
+                               int ret = tts_add_text(context_.ttsHandle_, buf.c_str(), NULL, TTS_VOICE_TYPE_AUTO, TTS_SPEED_AUTO, &utterance_id);
                                DEBUG("tts_add_text %d", ret);
                                ret = tts_play(context_.ttsHandle_);
                                DEBUG("tts_play %d", ret);
@@ -50,37 +48,20 @@ ScreenReaderPage::ScreenReaderPage()
                },
                GenlistItem::WidgetType::toggle});
 
-       int screenReaderState = 0;
-       auto r = vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, &screenReaderState);
-       if (r != VCONF_OK)
-               ERROR("Could not get value for key: %s", VCONFKEY_SETAPPL_ACCESSIBILITY_TTS);
+       auto onVConfValueChangeCb = [this](bool screenReaderState) {
+               screenReaderItem_->setState(screenReaderState);
+               screenReaderItem_->setDescription(screenReaderState ? "IDS_ST_BODY_ON" : "IDS_ST_BODY_OFF");
+               screenReaderItem_->update();
+       };
+       screenReaderStateHandle_ = Singleton<VConfInterface>::instance().registerAndGet<bool>({VCONFKEY_SETAPPL_ACCESSIBILITY_TTS}, false, onVConfValueChangeCb);
 
-       screenReaderItem_->setState(screenReaderState);
-
-       int vconf_ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, onVconfChangedCb, this);
-       if (vconf_ret != 0) {
-               ERROR("FAIL: vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS)");
-               return;
-       }
-
-       genlist->appendItem({"multiline",
-               {},
-               "IDS_ACCS_BODY_WHILE_SCREEN_READER_IS_ENABLED_YOUR_PHONE_WILL_PROVIDE_VOICE_FEEDBACK_FOR_EXAMPLE_SCREEN_READER_WILL_"
-               "MSG",
-               [this](auto item) {}});
+       genlist->appendItem({"multiline", {}, "IDS_ACCS_BODY_WHILE_SCREEN_READER_IS_ENABLED_YOUR_PHONE_WILL_PROVIDE_VOICE_FEEDBACK_FOR_EXAMPLE_SCREEN_READER_WILL_MSG"});
 
        genlist->appendItem({"type1", "IDS_ST_OPT_SETTINGS", {}, [this](auto item) {
                                                         this->screenReaderSettingsPage_ = std::make_unique<ScreenReaderSettingsPage>();
                                                 }});
 
        context_.getNaviframe()->pushBack("IDS_ST_MBODY_SCREEN_READER_HTTS", genlist, [this]() {
-               vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, onVconfChangedCb);
+               screenReaderStateHandle_ = {};
        });
-}
-
-void ScreenReaderPage::onVconfChangedCb(keynode_t *node, void *user_data)
-{
-       auto self = static_cast<ScreenReaderPage *>(user_data);
-       self->screenReaderItem_->setDescription(vconf_keynode_get_bool(node) ? "IDS_ST_BODY_ON" : "IDS_ST_BODY_OFF");
-       self->screenReaderItem_->update();
-}
+}
\ No newline at end of file

diff --git a/src/ScreenReaderPage.hpp b/src/ScreenReaderPage.hpp
index e2d73b1..fb907a8 100644 (file)
--- a/src/ScreenReaderPage.hpp
+++ b/src/ScreenReaderPage.hpp
@@ -20,6 +20,7 @@
 #include "AppContext.hpp"
 #include "GenlistItem.hpp"
 #include "ScreenReaderSettingsPage.hpp"
+#include "VConf.hpp"
 
 #include <Elementary.h>
 #include <vconf.h>
@@ -38,11 +39,10 @@ class ScreenReaderPage
        ScreenReaderPage();
 
        private:
-       static void onVconfChangedCb(keynode_t *node, void *user_data);
-
        AppContext &context_;
        std::unique_ptr<ScreenReaderSettingsPage> screenReaderSettingsPage_;
        GenlistItem *screenReaderItem_ = nullptr;
+       VConfInterface::CallbackHandle screenReaderStateHandle_;
 };
 
 #endif

diff --git a/src/ScreenReaderSettingsPage.cpp b/src/ScreenReaderSettingsPage.cpp
index 190c221..6a8b52e 100644 (file)
--- a/src/ScreenReaderSettingsPage.cpp
+++ b/src/ScreenReaderSettingsPage.cpp
@@ -38,7 +38,7 @@ namespace
        {
                std::string label;
                std::string vconf_key;
-               Eina_Bool status = EINA_FALSE;
+               bool state = false;
        };
 
        std::vector<VConfCheckData> vConfCheckData = {{"IDS_ST_HEADER_TIME", VCONFKEY_SETAPPL_ACCESSIBILITY_TTS_INDICATOR_INFORMATION_TIME},
@@ -169,11 +169,15 @@ void ScreenReaderSettingsPage::mouseUpGendialListCb()
        genlist->setAlignHint(EVAS_HINT_FILL, EVAS_HINT_FILL);
 
        for (auto i = 0u; i < vConfCheckData.size(); ++i) {
-               // TODO synchonize below items with below keys
-               auto screenreaderCheckbox = genlist->appendItem(
-                       {"type1", vConfCheckData[i].label, {}, [](auto item) {}, GenlistItem::WidgetType::toggle});
-
-               vConfCheckData[i].status = screenreaderCheckbox->getState();
+               auto screenreaderCheckbox = genlist->appendItem({"type1",
+                       vConfCheckData[i].label,
+                       {},
+                       [i](auto item) {
+                               vConfCheckData[i].state = item->getState();
+                       },
+                       GenlistItem::WidgetType::toggle});
+               vConfCheckData[i].state = Singleton<VConfInterface>::instance().get(vConfCheckData[i].vconf_key, vConfCheckData[i].state);
+               screenreaderCheckbox->setState(vConfCheckData[i].state);
        }
 
        genlist->blockScrolling(
@@ -192,12 +196,8 @@ void ScreenReaderSettingsPage::mouseUpGendialListCb()
        auto onDone = [removeCb]() {
                removeCb();
 
-               for (auto vConfData : vConfCheckData) {
-                       auto status = vConfData.status;
-                       auto key = vConfData.vconf_key;
-                       if (int ret = vconf_set_bool(key.c_str(), status))
-                               ERROR("Failed to set vconf key %s. Error: %d", key.c_str(), ret);
-               }
+               for (auto vConfData : vConfCheckData)
+                       Singleton<VConfInterface>::instance().set(vConfData.vconf_key, vConfData.state);
        };
 
        auto btnDone = Widget::make<Button>(this->popup_, onDone, "IDS_MSG_ACBUTTON_DONE_ABB", "popup");

diff --git a/src/UniversalSwitchPage.cpp b/src/UniversalSwitchPage.cpp
index f4216c4..7702787 100644 (file)
--- a/src/UniversalSwitchPage.cpp
+++ b/src/UniversalSwitchPage.cpp
@@ -25,25 +25,14 @@
 UniversalSwitchPage::UniversalSwitchPage()
        : context_(Singleton<AppContext>::instance())
 {
-       int state = false;
        auto naviframe = context_.getNaviframe();
        auto genlist = Widget::make<Genlist>(naviframe);
        genlist->setMode(ELM_LIST_COMPRESS);
        genlist->setStyle("dialogue");
        genlist->clear(); // TODO check if necessary
 
-       auto ret = vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, &state);
-       if (ret == VCONF_OK) {
-               ret = vconf_notify_key_changed(
-                       VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, onVconfKeyChange, this);
-               PRINT_ERROR_MESSAGE_IF(ret != VCONF_OK,
-                       "FAIL: vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE)");
-       } else {
-               ERROR("FAIL: vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE)");
-       }
-
        universalSwitchOffCheckbox_ = genlist->appendItem({"type1",
-               "IDS_ACCS_UNIVERSAL_SWITCH_OFF",
+               {},
                {},
                [this](auto item) {
                        auto state = item->getState();
@@ -51,42 +40,38 @@ UniversalSwitchPage::UniversalSwitchPage()
                        if (state && switch_count == 0) {
                                this->displayAddSwitchPopup();
                                item->setState(false);
-                       } else {
-                               auto ret = vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, state);
-                               if (ret != VCONF_OK)
-                                       ERROR("Failed to set Universal switch state.");
-                               item->setText(state ? "IDS_ACCS_UNIVERSAL_SWITCH_ON" : "IDS_ACCS_UNIVERSAL_SWITCH_OFF");
-                               item->update();
-                       }
+                       } else
+                               Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, state);
                },
                GenlistItem::WidgetType::toggle});
 
-       universalSwitchOffCheckbox_->setState(state ? true : false);
-       universalSwitchOffCheckbox_->setText(state ? "IDS_ACCS_UNIVERSAL_SWITCH_ON" : "IDS_ACCS_UNIVERSAL_SWITCH_OFF");
+       auto onUsVconfKeyChange = [this](auto state) {
+               universalSwitchOffCheckbox_->setText(state ? "IDS_ACCS_UNIVERSAL_SWITCH_ON" : "IDS_ACCS_UNIVERSAL_SWITCH_OFF");
+               universalSwitchOffCheckbox_->setState(state);
+               universalSwitchOffCheckbox_->update();
+       };
+       universalSwitchStateHandle_ = Singleton<VConfInterface>::instance().registerAndGet<bool>({VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE}, false, onUsVconfKeyChange);
 
        genlist->appendItem({"multiline", {}, "IDS_ACCS_UNIVERSAL_SWITCH_COMMENT", GenlistItem::Type::regular});
 
-       auto prevBtn = Widget::make<Button>(naviframe,
-               [this, naviframe]() {
-                       naviframe->removeChild(usSettingsBtn_);
-                       naviframe->popBack();
-               },
+       auto prevBtn = Widget::make<Button>(naviframe, [this, naviframe]() {
+               naviframe->removeChild(usSettingsBtn_);
+               naviframe->popBack();
+       },
                std::string{},
                Button::BACK_BUTTON_ARROW_STYLE);
 
-       naviframe->pushBack("IDS_ACCS_UNIVERSAL_SWITCH",
-               genlist,
-               [this]() {
-                       vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, onVconfKeyChange);
-                       stopUniversalSwitch();
-
-                       universalSwitchOffCheckbox_ = nullptr;
-               },
+       naviframe->pushBack("IDS_ACCS_UNIVERSAL_SWITCH", genlist, [this]() {
+               universalSwitchStateHandle_ = {};
+               stopUniversalSwitch();
+               universalSwitchOffCheckbox_ = nullptr;
+       },
                prevBtn);
 
        std::string title_str = "<font_size=30>" + TranslatedString{"IDS_ACCS_SETTINGS_CAPS"}.str() + "</font_size>";
-       usSettingsBtn_ = Widget::make<Button>(naviframe,
-               [this]() { universalSwitchSettingsPage_ = std::make_unique<UniversalSwitchSettingsPage>(); },
+       usSettingsBtn_ = Widget::make<Button>(naviframe, [this]() {
+               universalSwitchSettingsPage_ = std::make_unique<UniversalSwitchSettingsPage>();
+       },
                title_str,
                "naviframe/title_right");
        usSettingsBtn_->disable(true);
@@ -137,11 +122,8 @@ void UniversalSwitchPage::onNewSwitchAddition(
                &self->context_.config, switch_id.c_str(), switch_name.c_str(), switch_action.c_str());
        int switch_count = setting_accessibility_universal_switch_dbus_config_get_switch_count(&self->context_.config);
 
-       if (switch_count == 1) {
-               auto ret = vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, EINA_TRUE);
-               if (ret != VCONF_OK)
-                       ERROR("Failed to set Universal switch state.");
-       }
+       if (switch_count == 1)
+               Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_INTERACTION_SERVICE, true);
 
        DEBUG("New switch added. Id: %s, name: %s, action: %s. Switches count: %d",
                switch_id.c_str(),
@@ -155,21 +137,13 @@ void UniversalSwitchPage::stopUniversalSwitch()
        setting_accessibility_universal_switch_dbus_config_shutdown(&context_.config);
 
        DEBUG("Stopping universal-switch");
-       if (vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_CONFIGURATION_SERVICE, false) != VCONF_OK) {
-               ERROR("Failed to set vconf key %s", VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_CONFIGURATION_SERVICE);
-       } else {
-               DEBUG("universal-switch stopped");
-       }
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_CONFIGURATION_SERVICE, false);
 }
 
 void UniversalSwitchPage::startUniversalSwitch()
 {
        DEBUG("Starting universal-switch");
-       if (vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_CONFIGURATION_SERVICE, true) != VCONF_OK) {
-               ERROR("Failed to set vconf key %s", VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_CONFIGURATION_SERVICE);
-               return;
-       }
-
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_CONFIGURATION_SERVICE, true);
        setting_accessibility_universal_switch_dbus_config_init(&context_.config, onUniversalSwitchStarting, this);
 }
 

diff --git a/src/UniversalSwitchPage.hpp b/src/UniversalSwitchPage.hpp
index 75f3f5d..adba9f3 100644 (file)
--- a/src/UniversalSwitchPage.hpp
+++ b/src/UniversalSwitchPage.hpp
@@ -21,6 +21,7 @@
 #include "Button.hpp"
 #include "GenlistItem.hpp"
 #include "UniversalSwitchSettingsPage.hpp"
+#include "VConf.hpp"
 
 #include <vconf.h>
 
@@ -52,6 +53,7 @@ class UniversalSwitchPage
        GenlistItem *universalSwitchOffCheckbox_;
        Button *usSettingsBtn_ = nullptr;
        std::unique_ptr<AddSwitchPage> addSwitchPage_;
+       VConfInterface::CallbackHandle universalSwitchStateHandle_;
 };
 
 #endif

diff --git a/src/UniversalSwitchSettingsPage.cpp b/src/UniversalSwitchSettingsPage.cpp
index e595fa1..62b3c59 100644 (file)
--- a/src/UniversalSwitchSettingsPage.cpp
+++ b/src/UniversalSwitchSettingsPage.cpp
@@ -19,6 +19,7 @@
 #include "Button.hpp"
 #include "CtxPopup.hpp"
 #include "Singleton.hpp"
+#include "VConf.hpp"
 #include "setting-accessibility.h"
 #include "utils.hpp"
 
@@ -226,20 +227,20 @@ void UniversalSwitchSettingsPage::createFeedbackGroup()
                        break;
                }
 
-       cursorColor_ = genlist_->appendItem(
-               {"type1", "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_FEEDBACK_CURSOR_CL", str, [this](auto item) {
-                        setValuePage_ = std::make_unique<SetValuePage>(
-                                ValueEditorType::RADIOS, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_FEEDBACK_CURSOR_CL"));
-                        setValuePage_->addRadioItemChangedCb([this](auto val) { this->cursorColorListItemChangedCb(val); });
+       cursorColor_ = genlist_->appendItem({"type1",
+               "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_FEEDBACK_CURSOR_CL",
+               str,
+               [this](auto item) {
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::RADIOS, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_FEEDBACK_CURSOR_CL"));
+                       setValuePage_->addRadioItemChangedCb([this](auto val) {
+                               this->cursorColorListItemChangedCb(val);
+                       });
 
-                        for (auto i = 0u; i < CURSOR_COLORS_COUNT; i++)
-                                setValuePage_->addRadioItem(
-                                        _cursor_color[i].key, i, _cursor_color[i].id == context_.us_configuration.cursor_color);
-                }});
+                       for (auto i = 0u; i < CURSOR_COLORS_COUNT; i++)
+                               setValuePage_->addRadioItem(_cursor_color[i].key, i, _cursor_color[i].id == context_.us_configuration.cursor_color);
+               }});
 
-       str = getBoleanText(context_.us_configuration.feedback_sound_state,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON"),
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+       str = getBoleanText(context_.us_configuration.feedback_sound_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON"), _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
 
        feedbackSound_ = genlist_->appendItem({"type1",
                "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_FEEDBACK_SOUND",
@@ -248,20 +249,15 @@ void UniversalSwitchSettingsPage::createFeedbackGroup()
                [this](auto item) {
                        context_.us_configuration.feedback_sound_state = item->getState();
 
-                       item->setDescription(context_.us_configuration.feedback_sound_state
-                                                                        ? "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON"
-                                                                        : "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF");
+                       item->setDescription(context_.us_configuration.feedback_sound_state ? "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON" : "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF");
                        item->update();
 
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_SOUND_STATE, item->getState());
-               },
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_SOUND_STATE, item->getState()); },
                GenlistItem::WidgetType::toggle});
        if (context_.us_configuration.feedback_sound_state)
                feedbackSound_->setState(true);
 
-       str = getBoleanText(context_.us_configuration.feedback_voice_state,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON"),
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+       str = getBoleanText(context_.us_configuration.feedback_voice_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON"), _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
 
        feedbackVoice_ = genlist_->appendItem({"type1",
                "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_FEEDBACK_VOICE",
@@ -270,13 +266,10 @@ void UniversalSwitchSettingsPage::createFeedbackGroup()
                [this](auto item) {
                        context_.us_configuration.feedback_voice_state = item->getState();
 
-                       item->setDescription(context_.us_configuration.feedback_voice_state
-                                                                        ? "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON"
-                                                                        : "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF");
+                       item->setDescription(context_.us_configuration.feedback_voice_state ? "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON" : "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF");
                        item->update();
 
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_STATE, item->getState());
-               },
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_STATE, item->getState()); },
                GenlistItem::WidgetType::toggle});
        feedbackVoice_->setState(context_.us_configuration.feedback_voice_state);
 }
@@ -296,28 +289,24 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_PAUSE_ON_FIRST",
                str,
                [this](auto item) {
-                       char str[512] = {
-                               0,
-                       };
-                       auto ret = snprintf(str,
-                               sizeof(str),
-                               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_PAUSE_ON_FIRST"),
-                               context_.us_configuration.auto_scan_interval,
-                               context_.us_configuration.auto_scan_interval + context_.us_configuration.pause_on_first_value);
+                       char str[512] = {0,};
+                       auto ret = snprintf(str, sizeof(str), _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_PAUSE_ON_FIRST"), context_.us_configuration.auto_scan_interval, context_.us_configuration.auto_scan_interval + context_.us_configuration.pause_on_first_value);
                        if (ret > 511) {
                                ERROR("snprintf failed");
                                return;
                        }
 
-                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH,
-                               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_PAUSE_ON_FIRST"));
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_PAUSE_ON_FIRST"));
                        setValuePage_->setSwitch(context_.us_configuration.pause_on_first_state);
-                       setValuePage_->addValueChangedCb([this](auto val) { this->pauseOnFirstValueChangedCb(val); });
-                       setValuePage_->addSwitchChangedCb([this](auto state) { this->pauseOnFirstSwitchChangedCb(state); });
+                       setValuePage_->addValueChangedCb([this](auto val) {
+                               this->pauseOnFirstValueChangedCb(val);
+                       });
+                       setValuePage_->addSwitchChangedCb([this](auto state) {
+                               this->pauseOnFirstSwitchChangedCb(state);
+                       });
                        setValuePage_->setDescription(str);
                        setValuePage_->setRange(RANGE_MIN_PAUSE_ON_FIRST, RANGE_MAX_PAUSE_ON_FIRST, STEP_PAUSE_ON_FIRST);
-                       setValuePage_->setValue(context_.us_configuration.pause_on_first_value, "seconds");
-               },
+                       setValuePage_->setValue(context_.us_configuration.pause_on_first_value, "seconds"); },
                [this](auto item) {
                        context_.us_configuration.pause_on_first_state = item->getState();
                        auto str = getValueUnitText(NULL,
@@ -327,8 +316,7 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                                _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
                        item->setDescription(str);
                        item->update();
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_PAUSE_ON_FIRST_STATE, item->getState());
-               },
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_PAUSE_ON_FIRST_STATE, item->getState()); },
                GenlistItem::WidgetType::toggle});
        if (context_.us_configuration.pause_on_first_state) {
                pauseOnFirst_->setState(true);
@@ -343,25 +331,23 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
        if (!context_.us_configuration.auto_scan)
                pauseOnFirst_->disable();
 
-       str = getValueUnitText(NULL,
-               &context_.us_configuration.tap_duration_value,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"),
-               !context_.us_configuration.tap_duration_state,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+       str = getValueUnitText(NULL, &context_.us_configuration.tap_duration_value, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), !context_.us_configuration.tap_duration_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
 
        tapDuration_ = genlist_->appendItem({"type1",
                "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_TAP_DURATION",
                str,
                [this](auto item) {
-                       setValuePage_ = std::make_unique<SetValuePage>(
-                               ValueEditorType::NUMERIC_SWITCH, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_TAP_DURATION"));
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_TAP_DURATION"));
                        setValuePage_->setSwitch(context_.us_configuration.tap_duration_state);
-                       setValuePage_->addValueChangedCb([this](auto val) { this->tapDurationValueChangedCb(val); });
-                       setValuePage_->addSwitchChangedCb([this](auto state) { this->tapDurationSwitchChangedCb(state); });
+                       setValuePage_->addValueChangedCb([this](auto val) {
+                               this->tapDurationValueChangedCb(val);
+                       });
+                       setValuePage_->addSwitchChangedCb([this](auto state) {
+                               this->tapDurationSwitchChangedCb(state);
+                       });
                        setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_TAP_DURATION"));
                        setValuePage_->setRange(RANGE_MIN_TAP_DURATION, RANGE_MAX_TAP_DURATION, STEP_TAP_DURATION);
-                       setValuePage_->setValue(context_.us_configuration.tap_duration_value, "seconds");
-               },
+                       setValuePage_->setValue(context_.us_configuration.tap_duration_value, "seconds"); },
                [this](auto item) {
                        context_.us_configuration.tap_duration_state = item->getState();
                        auto str = getValueUnitText(NULL,
@@ -371,8 +357,7 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                                _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
                        item->setDescription(str);
                        item->update();
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_TAP_DURATION_STATE, item->getState());
-               },
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_TAP_DURATION_STATE, item->getState()); },
                GenlistItem::WidgetType::toggle});
 
        if (context_.us_configuration.tap_duration_state) {
@@ -386,25 +371,23 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                tapDuration_->update();
        }
 
-       str = getValueUnitText(NULL,
-               &context_.us_configuration.sgl_iaction_int_value,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"),
-               !context_.us_configuration.sgl_iaction_int_state,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+       str = getValueUnitText(NULL, &context_.us_configuration.sgl_iaction_int_value, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), !context_.us_configuration.sgl_iaction_int_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
 
        singleInteractionInterval_ = genlist_->appendItem({"type1",
                "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_SGL_IACTION_INT",
                str,
                [this](auto item) {
-                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH,
-                               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_SGL_IACTION_INT"));
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_SGL_IACTION_INT"));
                        setValuePage_->setSwitch(context_.us_configuration.sgl_iaction_int_state);
-                       setValuePage_->addValueChangedCb([this](auto val) { this->sglInactionIntervalValueChangedCb(val); });
-                       setValuePage_->addSwitchChangedCb([this](auto state) { this->sglInactionIntervalSwitchChangedCb(state); });
+                       setValuePage_->addValueChangedCb([this](auto val) {
+                               this->sglInactionIntervalValueChangedCb(val);
+                       });
+                       setValuePage_->addSwitchChangedCb([this](auto state) {
+                               this->sglInactionIntervalSwitchChangedCb(state);
+                       });
                        setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_SGL_IACTION_INT"));
                        setValuePage_->setRange(RANGE_MIN_SGL_IACTION_INT, RANGE_MAX_SGL_IACTION_INT, STEP_SGL_IACTION_INT);
-                       setValuePage_->setValue(context_.us_configuration.sgl_iaction_int_value, "seconds");
-               },
+                       setValuePage_->setValue(context_.us_configuration.sgl_iaction_int_value, "seconds"); },
                [this](auto item) {
                        context_.us_configuration.sgl_iaction_int_state = item->getState();
                        auto str = getValueUnitText(NULL,
@@ -414,9 +397,7 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                                _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
                        item->setDescription(str);
                        item->update();
-                       vconf_set_bool(
-                               VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SGL_IACTION_INT_STATE, item->getState());
-               },
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SGL_IACTION_INT_STATE, item->getState()); },
                GenlistItem::WidgetType::toggle});
 
        if (context_.us_configuration.sgl_iaction_int_state) {
@@ -430,25 +411,23 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                singleInteractionInterval_->update();
        }
 
-       str = getValueUnitText(NULL,
-               &context_.us_configuration.auto_tap_value,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"),
-               !context_.us_configuration.auto_tap_state,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+       str = getValueUnitText(NULL, &context_.us_configuration.auto_tap_value, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), !context_.us_configuration.auto_tap_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
 
        autoTap_ = genlist_->appendItem({"type1",
                "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_AUTO_TAP",
                str,
                [this](auto item) {
-                       setValuePage_ = std::make_unique<SetValuePage>(
-                               ValueEditorType::NUMERIC_SWITCH, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_AUTO_TAP"));
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_AUTO_TAP"));
                        setValuePage_->setSwitch(context_.us_configuration.auto_tap_state);
-                       setValuePage_->addSwitchChangedCb([this](auto val) { this->autoTapSwitchChangedCb(val); });
-                       setValuePage_->addValueChangedCb([this](auto val) { this->autoTapValueChangedCb(val); });
+                       setValuePage_->addSwitchChangedCb([this](auto val) {
+                               this->autoTapSwitchChangedCb(val);
+                       });
+                       setValuePage_->addValueChangedCb([this](auto val) {
+                               this->autoTapValueChangedCb(val);
+                       });
                        setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_AUTO_TAP"));
                        setValuePage_->setRange(RANGE_MIN_AUTO_TAP, RANGE_MAX_AUTO_TAP, STEP_AUTO_TAP);
-                       setValuePage_->setValue(context_.us_configuration.auto_tap_value, "seconds");
-               },
+                       setValuePage_->setValue(context_.us_configuration.auto_tap_value, "seconds"); },
                [this](auto item) {
                        context_.us_configuration.auto_tap_state = item->getState();
                        auto str = getValueUnitText(NULL,
@@ -458,8 +437,7 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                                _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
                        item->setDescription(str);
                        item->update();
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_STATE, item->getState());
-               },
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_STATE, item->getState()); },
                GenlistItem::WidgetType::toggle});
 
        if (context_.us_configuration.auto_tap_state) {
@@ -473,36 +451,30 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                autoTap_->update();
        }
 
-       str = getValueUnitText(NULL,
-               &context_.us_configuration.auto_move_int_value,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"),
-               !context_.us_configuration.auto_move_int_state,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+       str = getValueUnitText(NULL, &context_.us_configuration.auto_move_int_value, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), !context_.us_configuration.auto_move_int_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
 
        autoMoveInterval_ = genlist_->appendItem({"type1",
                "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_AUTO_MOVE_INT",
                str,
                [this](auto item) {
-                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH,
-                               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_AUTO_MOVE_INT"));
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC_SWITCH, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_ADD_SETTINGS_AUTO_MOVE_INT"));
                        setValuePage_->setSwitch(context_.us_configuration.auto_move_int_state);
-                       setValuePage_->addValueChangedCb([this](auto val) { this->autoMoveIntervalValueChangedCb(val); });
-                       setValuePage_->addSwitchChangedCb([this](auto state) { this->autoMoveIntervalSwitchChangedCb(state); });
+                       setValuePage_->addValueChangedCb([this](auto val) {
+                               this->autoMoveIntervalValueChangedCb(val);
+                       });
+                       setValuePage_->addSwitchChangedCb([this](auto state) {
+                               this->autoMoveIntervalSwitchChangedCb(state);
+                       });
                        setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_AUTO_MOVE_INT"));
                        setValuePage_->setRange(RANGE_MIN_AUTO_MOVE_INT, RANGE_MAX_AUTO_MOVE_INT, STEP_AUTO_MOVE_INT);
-                       setValuePage_->setValue(context_.us_configuration.auto_move_int_value, "seconds");
-               },
+                       setValuePage_->setValue(context_.us_configuration.auto_move_int_value, "seconds"); },
                [this](auto item) {
                        context_.us_configuration.auto_move_int_state = item->getState();
-                       auto str = getValueUnitText(NULL,
-                               &context_.us_configuration.auto_move_int_value,
-                               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"),
-                               !context_.us_configuration.auto_move_int_state,
-                               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+                       auto str = getValueUnitText(NULL, &context_.us_configuration.auto_move_int_value, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"),
+                                                                               !context_.us_configuration.auto_move_int_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
                        item->setDescription(str);
                        item->update();
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_MOVE_INT_STATE, item->getState());
-               },
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_MOVE_INT_STATE, item->getState()); },
                GenlistItem::WidgetType::toggle});
        if (context_.us_configuration.auto_move_int_state) {
                autoMoveInterval_->setState(true);
@@ -523,7 +495,7 @@ void UniversalSwitchSettingsPage::createAdditionalSettingsGroup()
                [this](auto item) {
                        auto state = item->getState();
                        context_.us_configuration.auto_tap_kbd_state = state;
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_KBD_STATE, state);
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_KBD_STATE, state);
                },
                GenlistItem::WidgetType::toggle});
        if (context_.us_configuration.auto_tap_kbd_state)
@@ -554,69 +526,79 @@ void UniversalSwitchSettingsPage::createScanningGroup()
                                scansNum_->disable();
                        }
 
-                       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCAN_ENABLED, state);
+                       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCAN_ENABLED, state);
                },
                GenlistItem::WidgetType::toggle});
        if (context_.us_configuration.auto_scan)
                item->setState(true);
 
-       str = getValueUnitText(
-               NULL, &context_.us_configuration.auto_scan_interval, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), false, NULL);
-       autoScanInterval_ = genlist_->appendItem(
-               {"type1", "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_AUTO_SCAN_INT", str, [this](auto item) {
-                        setValuePage_ = std::make_unique<SetValuePage>(
-                                ValueEditorType::NUMERIC, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_AUTO_SCAN_INT"));
-                        setValuePage_->addValueChangedCb([this](auto val) { this->autoScanIntervalChangedCb(val); });
-                        setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_AUTO_SCAN_INT"));
-                        setValuePage_->setRange(RANGE_MIN_AUTO_SCAN_INTERVAL, RANGE_MAX_AUTO_SCAN_INTERVAL, STEP_AUTO_SCAN_INTERVAL);
-                        setValuePage_->setValue(context_.us_configuration.auto_scan_interval, "seconds");
-                }});
+       str = getValueUnitText(NULL, &context_.us_configuration.auto_scan_interval, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), false, NULL);
+       autoScanInterval_ = genlist_->appendItem({"type1",
+               "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_AUTO_SCAN_INT",
+               str,
+               [this](auto item) {
+                       setValuePage_ = std::make_unique<SetValuePage>(
+                               ValueEditorType::NUMERIC, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_AUTO_SCAN_INT"));
+                       setValuePage_->addValueChangedCb([this](auto val) { this->autoScanIntervalChangedCb(val); });
+                       setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_AUTO_SCAN_INT"));
+                       setValuePage_->setRange(RANGE_MIN_AUTO_SCAN_INTERVAL, RANGE_MAX_AUTO_SCAN_INTERVAL, STEP_AUTO_SCAN_INTERVAL);
+                       setValuePage_->setValue(context_.us_configuration.auto_scan_interval, "seconds");
+               }});
        if (!context_.us_configuration.auto_scan)
                autoScanInterval_->disable();
 
        str = getValueUnitText(&context_.us_configuration.auto_scan_num, NULL, NULL, false, NULL);
-       scansNum_ = genlist_->appendItem(
-               {"type1", "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_NUM_OF_SCANS", str, [this](auto item) {
-                        setValuePage_ = std::make_unique<SetValuePage>(
-                                ValueEditorType::NUMERIC, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_NUM_OF_SCANS"));
-                        setValuePage_->addValueChangedCb([this](auto val) { this->scanNumberChangedCb(val); });
-                        setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_NUM_OF_SCANS"));
-                        setValuePage_->setRange(RANGE_MIN_SCANS_NUM, RANGE_MAX_SCANS_NUM, STEP_SCANS_NUM);
-                        setValuePage_->setValue(context_.us_configuration.auto_scan_num, "times");
-                }});
+       scansNum_ = genlist_->appendItem({"type1",
+               "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_NUM_OF_SCANS",
+               str,
+               [this](auto item) {
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_NUM_OF_SCANS"));
+                       setValuePage_->addValueChangedCb([this](auto val) { this->scanNumberChangedCb(val); });
+                       setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_NUM_OF_SCANS"));
+                       setValuePage_->setRange(RANGE_MIN_SCANS_NUM, RANGE_MAX_SCANS_NUM, STEP_SCANS_NUM);
+                       setValuePage_->setValue(context_.us_configuration.auto_scan_num, "times");
+               }});
        if (!context_.us_configuration.auto_scan)
                scansNum_->disable();
 
        str = getScanMethodText(context_.us_configuration.scan_method).str();
-       scanMethod_ = genlist_->appendItem(
-               {"type1", "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_SCAN_METHOD", str, [this](auto item) {
-                        this->createScanMethodCtxPopup();
-                }});
+       scanMethod_ = genlist_->appendItem({"type1",
+               "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_SCAN_METHOD",
+               str,
+               [this](auto item) {
+                       this->createScanMethodCtxPopup();
+               }});
 
        str = getScanDirectionText(context_.us_configuration.scan_dir).str();
-       scanDirection_ = genlist_->appendItem(
-               {"type1", "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_SCAN_DIR", str, [this](auto item) {
-                        this->createScanDirectionCtxPopup();
-                }});
+       scanDirection_ = genlist_->appendItem({"type1",
+               "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_SCAN_DIR",
+               str,
+               [this](auto item) {
+                       this->createScanDirectionCtxPopup();
+               }});
 
        str = getValueUnitText(&context_.us_configuration.scan_pt_speed, NULL, NULL, false, NULL);
-       scanSpeed_ = genlist_->appendItem(
-               {"type1", "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_PT_SPEED", str, [this](auto item) {
-                        setValuePage_ = std::make_unique<SetValuePage>(
-                                ValueEditorType::NUMERIC, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_PT_SPEED"));
-                        setValuePage_->addValueChangedCb([this](auto val) { this->scanSpeedChangedCb(val); });
-                        setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_SCAN_SPEED"));
-                        setValuePage_->setRange(RANGE_MIN_SCAN_SPEED, RANGE_MAX_SCAN_SPEED, STEP_SCAN_SPEED);
-                        setValuePage_->setValue(context_.us_configuration.scan_pt_speed, "");
-                }});
+       scanSpeed_ = genlist_->appendItem({"type1",
+               "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_PT_SPEED",
+               str,
+               [this](auto item) {
+                       setValuePage_ = std::make_unique<SetValuePage>(ValueEditorType::NUMERIC, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SCANNING_PT_SPEED"));
+                       setValuePage_->addValueChangedCb([this](auto val) { this->scanSpeedChangedCb(val); });
+                       setValuePage_->setDescription(_("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SET_VALUE_DESC_SCAN_SPEED"));
+                       setValuePage_->setRange(RANGE_MIN_SCAN_SPEED, RANGE_MAX_SCAN_SPEED, STEP_SCAN_SPEED);
+                       setValuePage_->setValue(context_.us_configuration.scan_pt_speed, "");
+               }});
 }
 
 void UniversalSwitchSettingsPage::createSwitchesGroup()
 {
-       switchesItem_ = genlist_->appendItem({"type1", "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SWITCHES", {}, [this](auto item) {
-                                                                                         switchesPage_ = std::make_unique<SwitchesPage>();
-                                                                                         switchesPage_->attachCallback(updateSwitchesCount, this);
-                                                                                 }});
+       switchesItem_ = genlist_->appendItem({"type1",
+               "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_SWITCHES",
+               {},
+               [this](auto item) {
+                       switchesPage_ = std::make_unique<SwitchesPage>();
+                       switchesPage_->attachCallback(updateSwitchesCount, this);
+               }});
        updateSwitchesCount(this);
 }
 
@@ -652,8 +634,7 @@ const char *UniversalSwitchSettingsPage::getBoleanText(bool bvalue, const char *
                return f_str;
 }
 
-std::string UniversalSwitchSettingsPage::getValueUnitText(
-       int *ivalue, double *dvalue, const char *units, bool def_trigger, const char *def)
+std::string UniversalSwitchSettingsPage::getValueUnitText(int *ivalue, double *dvalue, const char *units, bool def_trigger, const char *def)
 {
        if (def_trigger)
                return def ? def : std::string{};
@@ -800,37 +781,6 @@ int UniversalSwitchSettingsPage::getAndConvertVconfValue(const char *key)
        return value * 100;
 }
 
-bool UniversalSwitchSettingsPage::updateVconfValue(const char *key, bool *bvalue, int *ivalue, double *dvalue)
-{
-       int ret = VCONF_ERROR;
-       RETURN_DEFAULT_IF(key == NULL, "Key input argument is nullptr");
-       DEBUG("KEY: %s, %d, %d, %f", key, bvalue ? *bvalue : 0, ivalue ? *ivalue : 0, dvalue ? *dvalue : 0);
-
-       if (bvalue) {
-               bool b;
-               getVconfValue(key, &b, NULL, NULL);
-               RETURN_DEFAULT_IF(b == *bvalue, "Value already set");
-               ret = vconf_set_bool(key, *bvalue);
-               PRINT_ERROR_MESSAGE_IF(ret != VCONF_OK, "Failed to update %s value.", key);
-       } else if (ivalue) {
-               int i;
-               getVconfValue(key, NULL, &i, NULL);
-               RETURN_DEFAULT_IF(i == *ivalue, "Value already set");
-               ret = vconf_set_int(key, *ivalue);
-               PRINT_ERROR_MESSAGE_IF(ret != VCONF_OK, "Failed to update %s value.", key);
-       } else if (dvalue) {
-               double d;
-               getVconfValue(key, NULL, NULL, &d);
-               RETURN_DEFAULT_IF(d == *dvalue, "Value already set");
-               ret = vconf_set_dbl(key, *dvalue);
-               PRINT_ERROR_MESSAGE_IF(ret != VCONF_OK, "Failed to update %s value.", key);
-       } else {
-               PRINT_ERROR_MESSAGE_IF(ret != VCONF_OK, "One of the input arguments must not be NULL");
-       }
-
-       return (ret == VCONF_OK);
-}
-
 bool UniversalSwitchSettingsPage::getVconfValue(const char *key, bool *bvalue, int *ivalue, double *dvalue)
 {
        int ret = VCONF_ERROR;
@@ -881,12 +831,10 @@ void UniversalSwitchSettingsPage::feedbackVoiceCb(void *data, Evas_Object *obj,
                self->feedbackVoice_->setState(state);
                self->feedbackVoice_->update();
                self->context_.us_configuration.feedback_voice_state = state;
-               vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_STATE, state);
+               Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_STATE, state);
        });
        ;
-       int vconf_ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_STATE,
-               SetValuePage::syncPageWithVconf,
-               self->nestedSetValuePage_.get());
+       int vconf_ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_STATE, SetValuePage::syncPageWithVconf, self->nestedSetValuePage_.get());
        if (vconf_ret)
                ERROR("FAIL: "
                          "vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_STATE)");
@@ -937,8 +885,7 @@ void UniversalSwitchSettingsPage::feedbackVoiceSpeechVolumeChangedCb(int item_id
 
        context_.us_configuration.feedback_voice_speech_volume = _media_level[item_id].id;
        double media_level = _media_level[item_id].id / 100.0;
-       updateVconfValue(
-               VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_SPEECH_VOLUME, NULL, NULL, &media_level);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_SPEECH_VOLUME, media_level);
 
        feedbackVoiceSpeechVolume_->setDescription(_media_level[item_id].key ? _media_level[item_id].key : std::string{});
        feedbackVoiceSpeechVolume_->update();
@@ -950,8 +897,7 @@ void UniversalSwitchSettingsPage::feedbackVoiceSpeechRateChangedCb(int item_id)
 
        context_.us_configuration.feedback_voice_speech_rate = _media_level[item_id].id;
        double media_level = _media_level[item_id].id / 100.0;
-       updateVconfValue(
-               VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_SPEECH_RATE, NULL, NULL, &media_level);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_VOICE_SPEECH_RATE, media_level);
 
        feedbackVoiceSpeechRate_->setDescription(_media_level[item_id].key ? _media_level[item_id].key : std::string{});
        feedbackVoiceSpeechRate_->update();
@@ -998,7 +944,7 @@ void UniversalSwitchSettingsPage::feedbackSoundVolumeChangedCb(int item_id)
 
        context_.us_configuration.feedback_sound_volume = _media_level[item_id].id;
        double media_level = _media_level[item_id].id / 100.0;
-       updateVconfValue(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_SOUND_VOLUME, NULL, NULL, &media_level);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_SOUND_VOLUME, media_level);
 
        feedbackSoundVolume_->setDescription(_media_level[item_id].key ? _media_level[item_id].key : std::string{});
        feedbackSoundVolume_->update();
@@ -1007,7 +953,7 @@ void UniversalSwitchSettingsPage::feedbackSoundVolumeChangedCb(int item_id)
 void UniversalSwitchSettingsPage::feedbackSoundSwitchChangedCb(bool state)
 {
        context_.us_configuration.feedback_sound_state = state;
-       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_SOUND_STATE, state);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_SOUND_STATE, state);
        feedbackSound_->setState(state);
        feedbackSound_->setDescription(state ? "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_ON" : "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF");
        feedbackSound_->update();
@@ -1018,10 +964,7 @@ void UniversalSwitchSettingsPage::cursorColorListItemChangedCb(int item_id)
        PRINT_ERROR_MESSAGE_IF(item_id < 0 || item_id >= CURSOR_COLORS_COUNT, "Invalid cursor color id");
 
        context_.us_configuration.cursor_color = _cursor_color[item_id].id;
-       updateVconfValue(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_CURSOR_COLOR,
-               NULL,
-               &context_.us_configuration.cursor_color,
-               NULL);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_FEEDBACK_CURSOR_COLOR, context_.us_configuration.cursor_color);
 
        cursorColor_->setDescription(_cursor_color[item_id].key ? _cursor_color[item_id].key : std::string{});
        cursorColor_->update();
@@ -1030,7 +973,7 @@ void UniversalSwitchSettingsPage::cursorColorListItemChangedCb(int item_id)
 void UniversalSwitchSettingsPage::autoMoveIntervalSwitchChangedCb(bool state)
 {
        context_.us_configuration.auto_move_int_state = state;
-       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_MOVE_INT_STATE, state);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_MOVE_INT_STATE, state);
        autoMoveInterval_->setState(state);
        auto str = getValueUnitText(NULL,
                &context_.us_configuration.auto_move_int_value,
@@ -1044,7 +987,7 @@ void UniversalSwitchSettingsPage::autoMoveIntervalSwitchChangedCb(bool state)
 void UniversalSwitchSettingsPage::autoTapSwitchChangedCb(bool state)
 {
        context_.us_configuration.auto_tap_state = state;
-       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_STATE, state);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_STATE, state);
        autoTap_->setState(state);
        auto str = getValueUnitText(NULL,
                &context_.us_configuration.auto_tap_value,
@@ -1065,13 +1008,13 @@ void UniversalSwitchSettingsPage::autoTapValueChangedCb(double value)
                _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
        autoTap_->setDescription(str);
        autoTap_->update();
-       vconf_set_dbl(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_VALUE, value);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_VALUE, value);
 }
 
 void UniversalSwitchSettingsPage::sglInactionIntervalSwitchChangedCb(bool state)
 {
        context_.us_configuration.sgl_iaction_int_state = state;
-       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SGL_IACTION_INT_STATE, state);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SGL_IACTION_INT_STATE, state);
        singleInteractionInterval_->setState(state);
        auto str = getValueUnitText(NULL,
                &context_.us_configuration.sgl_iaction_int_value,
@@ -1085,12 +1028,8 @@ void UniversalSwitchSettingsPage::sglInactionIntervalSwitchChangedCb(bool state)
 void UniversalSwitchSettingsPage::sglInactionIntervalValueChangedCb(double value)
 {
        context_.us_configuration.sgl_iaction_int_value = value;
-       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SGL_IACTION_INT_VALUE, value);
-       auto str = getValueUnitText(NULL,
-               &context_.us_configuration.sgl_iaction_int_value,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"),
-               !context_.us_configuration.sgl_iaction_int_state,
-               _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SGL_IACTION_INT_VALUE, value);
+       auto str = getValueUnitText(NULL, &context_.us_configuration.sgl_iaction_int_value, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), !context_.us_configuration.sgl_iaction_int_state, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_OFF"));
        singleInteractionInterval_->setDescription(str);
        singleInteractionInterval_->update();
 }
@@ -1098,7 +1037,7 @@ void UniversalSwitchSettingsPage::sglInactionIntervalValueChangedCb(double value
 void UniversalSwitchSettingsPage::tapDurationSwitchChangedCb(bool state)
 {
        context_.us_configuration.tap_duration_state = state;
-       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_TAP_DURATION_STATE, state);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_TAP_DURATION_STATE, state);
 
        tapDuration_->setState(state);
        auto str = getValueUnitText(NULL,
@@ -1113,7 +1052,7 @@ void UniversalSwitchSettingsPage::tapDurationSwitchChangedCb(bool state)
 void UniversalSwitchSettingsPage::tapDurationValueChangedCb(double value)
 {
        context_.us_configuration.tap_duration_value = value;
-       vconf_set_dbl(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_TAP_DURATION_VALUE, value);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_TAP_DURATION_VALUE, value);
 
        auto str = getValueUnitText(NULL,
                &context_.us_configuration.tap_duration_value,
@@ -1127,7 +1066,7 @@ void UniversalSwitchSettingsPage::tapDurationValueChangedCb(double value)
 void UniversalSwitchSettingsPage::pauseOnFirstSwitchChangedCb(bool state)
 {
        context_.us_configuration.pause_on_first_state = state;
-       vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_PAUSE_ON_FIRST_STATE, state);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_PAUSE_ON_FIRST_STATE, state);
 
        pauseOnFirst_->setState(state);
        auto str = getValueUnitText(NULL,
@@ -1142,7 +1081,7 @@ void UniversalSwitchSettingsPage::pauseOnFirstSwitchChangedCb(bool state)
 void UniversalSwitchSettingsPage::pauseOnFirstValueChangedCb(double value)
 {
        context_.us_configuration.pause_on_first_value = value;
-       vconf_set_dbl(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_PAUSE_ON_FIRST_VALUE, value);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_PAUSE_ON_FIRST_VALUE, value);
 
        auto str = getValueUnitText(NULL,
                &context_.us_configuration.pause_on_first_value,
@@ -1159,7 +1098,7 @@ void UniversalSwitchSettingsPage::scanSpeedChangedCb(double value)
        int int_value = (int)value;
 
        context_.us_configuration.scan_pt_speed = (int)value;
-       updateVconfValue(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SCAN_PT_SPEED, NULL, &int_value, NULL);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SCAN_PT_SPEED, int_value);
 
        scanSpeed_->setDescription(getValueUnitText(&int_value, NULL, NULL, false, NULL));
        scanSpeed_->update();
@@ -1192,7 +1131,7 @@ void UniversalSwitchSettingsPage::createScanDirectionCtxPopup()
 
 void UniversalSwitchSettingsPage::scanDirectionCtxPopupItemClicked(ScanDirection scan_dir)
 {
-       vconf_set_int(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SCAN_DIR_VERTICAL, static_cast<int>(scan_dir));
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SCAN_DIR_VERTICAL, static_cast<int>(scan_dir));
        context_.us_configuration.scan_dir = scan_dir;
        scanDirection_->setDescription(getScanDirectionText(scan_dir));
        scanDirection_->update();
@@ -1225,7 +1164,7 @@ void UniversalSwitchSettingsPage::createScanMethodCtxPopup()
 
 void UniversalSwitchSettingsPage::scanMethodCtxPopupItemClicked(ScanMethod scan_method)
 {
-       vconf_set_int(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SCAN_METHOD, static_cast<int>(scan_method));
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SCAN_METHOD, static_cast<int>(scan_method));
        context_.us_configuration.scan_method = scan_method;
        scanMethod_->setDescription(getScanMethodText(scan_method));
        scanMethod_->update();
@@ -1236,7 +1175,7 @@ void UniversalSwitchSettingsPage::scanNumberChangedCb(double value)
        int int_value = (int)value;
 
        context_.us_configuration.auto_scan_num = (int)value;
-       updateVconfValue(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_NUM_OF_SCANS, NULL, &int_value, NULL);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_NUM_OF_SCANS, int_value);
 
        scansNum_->setDescription(getValueUnitText(&int_value, NULL, NULL, false, NULL));
        scansNum_->update();
@@ -1245,7 +1184,7 @@ void UniversalSwitchSettingsPage::scanNumberChangedCb(double value)
 void UniversalSwitchSettingsPage::autoScanIntervalChangedCb(double value)
 {
        context_.us_configuration.auto_scan_interval = value;
-       updateVconfValue(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCAN_INT, NULL, NULL, &value);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCAN_INT, value);
 
        autoScanInterval_->setDescription(
                getValueUnitText(NULL, &value, _("IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_SECONDS"), false, NULL));
@@ -1255,7 +1194,7 @@ void UniversalSwitchSettingsPage::autoScanIntervalChangedCb(double value)
 void UniversalSwitchSettingsPage::autoMoveIntervalValueChangedCb(double value)
 {
        context_.us_configuration.auto_move_int_value = value;
-       vconf_set_dbl(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_MOVE_INT_VALUE, value);
+       Singleton<VConfInterface>::instance().set(VCONFKEY_SETAPPL_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_MOVE_INT_VALUE, value);
 
        auto str = getValueUnitText(NULL,
                &context_.us_configuration.auto_move_int_value,
@@ -1279,13 +1218,11 @@ void UniversalSwitchSettingsPage::onManageMenuOptions()
        for (auto i = 0u; i < utils::lenOf(_manage_options); ++i) {
                auto it = genlist->appendItem({"multiline",
                        _manage_options[i].first,
-                       (i == UniversalSwitchConfiguration::MANAGE_OPTIONS_COUNT - 1)
-                               ? "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_MANAGE_CONTEXTUAL_MENU_DESC"
-                               : "",
+                       (i == UniversalSwitchConfiguration::MANAGE_OPTIONS_COUNT - 1) ? "IDS_ACCS_UNIVERSAL_SWITCH_SETTINGS_GROUP_MANAGE_CONTEXTUAL_MENU_DESC" : "",
                        [=](auto item) {
                                auto state = item->getState();
                                context_.us_configuration.manage_options_state[i] = state;
-                               vconf_set_bool(_manage_options_key_array[i], state);
+                               Singleton<VConfInterface>::instance().set(_manage_options_key_array[i], state);
                        },
                        GenlistItem::WidgetType::toggle});
 

diff --git a/src/UniversalSwitchSettingsPage.hpp b/src/UniversalSwitchSettingsPage.hpp
index fcfd1a9..84bf1f9 100644 (file)
--- a/src/UniversalSwitchSettingsPage.hpp
+++ b/src/UniversalSwitchSettingsPage.hpp
@@ -55,7 +55,6 @@ class UniversalSwitchSettingsPage
        static std::string getValueUnitText(int *ivalue, double *dvalue, const char *units, bool def_trigger, const char *def);
        void getVconfSettings();
        static int getAndConvertVconfValue(const char *key);
-       static bool updateVconfValue(const char *key, bool *bvalue, int *ivalue, double *dvalue);
        static bool getVconfValue(const char *key, bool *bvalue, int *ivalue, double *dvalue);
        static void updateSwitchesCount(void *data);
        static void feedbackVoiceCb(void *data, Evas_Object *obj, void *event_info);