From ade536d511db833a8fb4797b3f5fc84789272df3 Mon Sep 17 00:00:00 2001
From: Oskar Chodowicz <o.chodowicz@samsung.com>
Date: Thu, 28 Mar 2019 16:08:29 +0100
Subject: [PATCH] Use vconf class instead of vconf in c style

Change-Id: I92999da9e560b3f617886747ec02904ee1fa6d3c
---
 src/AccessibilityLauncherPage.cpp   |  72 ++-----
 src/MainPage.cpp                    |  44 ++---
 src/MainPage.hpp                    |   4 +-
 src/RemoveSwitchPage.cpp            |  19 +-
 src/ScreenReaderPage.cpp            |  43 ++---
 src/ScreenReaderPage.hpp            |   4 +-
 src/ScreenReaderSettingsPage.cpp    |  24 +--
 src/UniversalSwitchPage.cpp         |  76 +++-----
 src/UniversalSwitchPage.hpp         |   2 +
 src/UniversalSwitchSettingsPage.cpp | 363 +++++++++++++++---------------------
 src/UniversalSwitchSettingsPage.hpp |   1 -
 11 files changed, 248 insertions(+), 404 deletions(-)

diff --git a/src/AccessibilityLauncherPage.cpp b/src/AccessibilityLauncherPage.cpp
index 8ab35f5..2addab1 100644
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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);
-- 
2.7.4