From 60926fe51235e3d27389e48d62d47b826b0e0602 Mon Sep 17 00:00:00 2001 From: Joohyun Kim Date: Wed, 26 Jun 2013 13:21:13 +0900 Subject: [PATCH] Add Setting feature on system-server lib Change-Id: Ia786799796f099599fb51c6ba8107a3e2fd55591 Signed-off-by: Joohyun Kim --- packaging/osp-appfw.spec | 14 + src/system-server/CMakeLists.txt | 27 +- src/system-server/inc/FSys_SettingInfo.h | 83 ++ src/system-server/setting/FSys_SettingInfo.cpp | 371 ++++++ .../setting/providers/FSys_ISettingProvider.h | 101 ++ src/system-server/setting/providers/FSys_Icu.cpp | 111 ++ src/system-server/setting/providers/FSys_Icu.h | 45 + .../providers/FSys_SettingApplicationProvider.cpp | 198 +++ .../providers/FSys_SettingApplicationProvider.h | 53 + .../setting/providers/FSys_SettingFontProvider.cpp | 257 ++++ .../setting/providers/FSys_SettingFontProvider.h | 51 + .../providers/FSys_SettingGeneralProvider.cpp | 430 +++++++ .../providers/FSys_SettingGeneralProvider.h | 59 + .../providers/FSys_SettingLocaleProvider.cpp | 733 +++++++++++ .../setting/providers/FSys_SettingLocaleProvider.h | 64 + .../providers/FSys_SettingLocationProvider.cpp | 228 ++++ .../providers/FSys_SettingLocationProvider.h | 53 + .../providers/FSys_SettingNetworkProvider.cpp | 1342 ++++++++++++++++++++ .../providers/FSys_SettingNetworkProvider.h | 106 ++ .../providers/FSys_SettingScreenProvider.cpp | 466 +++++++ .../setting/providers/FSys_SettingScreenProvider.h | 60 + .../providers/FSys_SettingSoundProvider.cpp | 623 +++++++++ .../setting/providers/FSys_SettingSoundProvider.h | 65 + .../providers/FSys_SettingSpeechProvider.cpp | 197 +++ .../setting/providers/FSys_SettingSpeechProvider.h | 57 + .../providers/FSys_SettingStorageProvider.cpp | 455 +++++++ .../providers/FSys_SettingStorageProvider.h | 53 + .../providers/FSys_SettingVibrationProvider.cpp | 227 ++++ .../providers/FSys_SettingVibrationProvider.h | 57 + 29 files changed, 6585 insertions(+), 1 deletion(-) create mode 100644 src/system-server/inc/FSys_SettingInfo.h create mode 100644 src/system-server/setting/FSys_SettingInfo.cpp create mode 100644 src/system-server/setting/providers/FSys_ISettingProvider.h create mode 100644 src/system-server/setting/providers/FSys_Icu.cpp create mode 100644 src/system-server/setting/providers/FSys_Icu.h create mode 100644 src/system-server/setting/providers/FSys_SettingApplicationProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingApplicationProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingFontProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingFontProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingGeneralProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingGeneralProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingLocaleProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingLocaleProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingLocationProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingLocationProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingNetworkProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingNetworkProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingScreenProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingScreenProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingSoundProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingSoundProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingSpeechProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingSpeechProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingStorageProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingStorageProvider.h create mode 100644 src/system-server/setting/providers/FSys_SettingVibrationProvider.cpp create mode 100644 src/system-server/setting/providers/FSys_SettingVibrationProvider.h diff --git a/packaging/osp-appfw.spec b/packaging/osp-appfw.spec index 88e0636..9f35ebd 100755 --- a/packaging/osp-appfw.spec +++ b/packaging/osp-appfw.spec @@ -21,6 +21,12 @@ BuildRequires: pkgconfig(capi-system-runtime-info) BuildRequires: pkgconfig(capi-system-system-settings) BuildRequires: pkgconfig(capi-system-media-key) BuildRequires: pkgconfig(capi-network-bluetooth) +BuildRequires: pkgconfig(capi-telephony-sim) +BuildRequires: pkgconfig(capi-network-tethering) +BuildRequires: pkgconfig(capi-network-wifi) +BuildRequires: pkgconfig(capi-network-wifi-direct) +BuildRequires: pkgconfig(capi-media-sound-manager) +BuildRequires: pkgconfig(sysman) BuildRequires: pkgconfig(tapi) BuildRequires: pkgconfig(alarm-service) BuildRequires: pkgconfig(appsvc) @@ -35,6 +41,14 @@ BuildRequires: pkgconfig(dukgenerator) BuildRequires: pkgconfig(ecore) BuildRequires: pkgconfig(glib-2.0) BuildRequires: pkgconfig(heynoti) +BuildRequires: pkgconfig(elementary) +BuildRequires: pkgconfig(eina) +BuildRequires: pkgconfig(evas) +BuildRequires: pkgconfig(edje) +BuildRequires: pkgconfig(eet) +BuildRequires: pkgconfig(edbus) +BuildRequires: pkgconfig(efreet) +BuildRequires: pkgconfig(ethumb) BuildRequires: pkgconfig(icu-i18n) BuildRequires: pkgconfig(libcurl) BuildRequires: pkgconfig(libpcre) diff --git a/src/system-server/CMakeLists.txt b/src/system-server/CMakeLists.txt index c9cae01..6e19e2c 100644 --- a/src/system-server/CMakeLists.txt +++ b/src/system-server/CMakeLists.txt @@ -1,9 +1,22 @@ SET (this_target osp-system-server) INCLUDE_DIRECTORIES ( + /usr/include/sysman + /usr/include/elementary-1 + /usr/include/eet-1 + /usr/include/ecore-1 + /usr/include/evas-1 + /usr/include/edje-1 + /usr/include/e_dbus-1 + /usr/include/efreet-1 + /usr/include/ethumb-1 + /usr/include/libxml + /usr/include/telephony ${SLP_INCLUDE_DIRS} ${CMAKE_SOURCE_DIR} ${CMAKE_SOURCE_DIR}/inc + ${CMAKE_SOURCE_DIR}/src/app/inc + ${CMAKE_SOURCE_DIR}/src/base/inc ${CMAKE_SOURCE_DIR}/src/system-server/inc ${CMAKE_SOURCE_DIR}/src/io/inc ${CMAKE_SOURCE_DIR}/src/server/inc @@ -12,7 +25,18 @@ INCLUDE_DIRECTORIES ( SET (${this_target}_SOURCE_FILES system/FSys_SystemInfo.cpp - dev/FSys_DeviceManager.cpp + setting/FSys_SettingInfo.cpp + setting/providers/FSys_SettingApplicationProvider.cpp + setting/providers/FSys_SettingFontProvider.cpp + setting/providers/FSys_SettingGeneralProvider.cpp + setting/providers/FSys_SettingLocaleProvider.cpp + setting/providers/FSys_SettingLocationProvider.cpp + setting/providers/FSys_SettingNetworkProvider.cpp + setting/providers/FSys_SettingScreenProvider.cpp + setting/providers/FSys_SettingSoundProvider.cpp + setting/providers/FSys_SettingSpeechProvider.cpp + setting/providers/FSys_SettingStorageProvider.cpp + setting/providers/FSys_SettingVibrationProvider.cpp ) INCLUDE(FindPkgConfig) @@ -52,6 +76,7 @@ SET_TARGET_PROPERTIES(${this_target} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1 ) + ADD_CUSTOM_COMMAND(TARGET ${this_target} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${LIBRARY_OUTPUT_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}${this_target}${CMAKE_SHARED_LIBRARY_SUFFIX} ${LIBRARY_OUTPUT_PATH}/debug/${CMAKE_SHARED_LIBRARY_PREFIX}${this_target}${CMAKE_SHARED_LIBRARY_SUFFIX}.${FULLVER} diff --git a/src/system-server/inc/FSys_SettingInfo.h b/src/system-server/inc/FSys_SettingInfo.h new file mode 100644 index 0000000..3538e0e --- /dev/null +++ b/src/system-server/inc/FSys_SettingInfo.h @@ -0,0 +1,83 @@ +#ifndef _FSYS_SETTING_INFO_INTERNAL_H_ +#define _FSYS_SETTING_INFO_INTERNAL_H_ + +#include + +#include +#include +#include +#include +#include +#include + +namespace Tizen { namespace System +{ + +class _ISettingProvider; + +class _OSP_EXPORT_ _SettingInfo +{ +private: + _SettingInfo(); + ~_SettingInfo(); + + static void InitSingleton(void); + static void DestroySingleton(void); + +public: + static _SettingInfo* GetInstance(void); + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result GetValue(const Tizen::Base::String& key, int& value); + result GetValue(const Tizen::Base::String& key, bool& value); + bool HasKey(const Tizen::Base::String& key); + result SetValue(const Tizen::Base::String& key, bool value); + result SetValue(const Tizen::Base::String& key, int value); + result SetValue(const Tizen::Base::String& key, Tizen::Base::String value); + result AddSettingEventListener(ISettingEventListener& listener); + result RemoveSettingEventListener(ISettingEventListener& listener); + result GetValueForPrivilegedKey(const Tizen::Base::String& key, bool& value); + result SetValueForPrivilegedKey(const Tizen::Base::String& key, bool value); + result SetValueAsyncForPrivilegedKey(const Tizen::Base::String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener); + result SetValueAsync(const Tizen::Base::String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener); + result SetValueForPrivilegedKey(const Tizen::Base::String& key, Tizen::Base::String value); + result ResetToFactoryDefault(void); + + result AnnounceSettingEvent(const Tizen::Base::String& key); + +private: + result RegisterProvider(const Tizen::Base::String& key, _ISettingProvider* provider); + result UnregisterProvider(const Tizen::Base::String& key); + _ISettingProvider* GetProvider(const Tizen::Base::String& key); + result RemoveProvider(const Tizen::Base::String key); + +private: + static _SettingInfo* __pSettingInfo; + +private: + Tizen::Base::Collection::HashMapT __settingProviderList; + Tizen::Base::Collection::ArrayListT< ISettingEventListener* > __settingEventList; + + class _StringHashProvider + : public Tizen::Base::Collection::IHashCodeProviderT + { + public: + virtual int GetHashCode(const Tizen::Base::String& value) const + { + return value.GetHashCode(); + } + }; + + class _StringComparer + : public Tizen::Base::Collection::IComparerT + { + public: + virtual result Compare(const Tizen::Base::String& string1, const Tizen::Base::String& string2, int& cmp) const + { + cmp = string1.CompareTo(string2); + return E_SUCCESS; + } + }; +}; + +}} +#endif diff --git a/src/system-server/setting/FSys_SettingInfo.cpp b/src/system-server/setting/FSys_SettingInfo.cpp new file mode 100644 index 0000000..968c303 --- /dev/null +++ b/src/system-server/setting/FSys_SettingInfo.cpp @@ -0,0 +1,371 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingInfo.cpp + * @brief This is the implementation file for _SettingInfo class. + */ + +#include +#include +#include +#include +#include + +#include +#include + +#include "providers/FSys_ISettingProvider.h" +#include "FSys_SettingInfo.h" + +//providers +#include "providers/FSys_SettingApplicationProvider.h" +#include "providers/FSys_SettingFontProvider.h" +#include "providers/FSys_SettingGeneralProvider.h" +#include "providers/FSys_SettingLocaleProvider.h" +#include "providers/FSys_SettingLocationProvider.h" +#include "providers/FSys_SettingNetworkProvider.h" +#include "providers/FSys_SettingScreenProvider.h" +#include "providers/FSys_SettingSoundProvider.h" +#include "providers/FSys_SettingSpeechProvider.h" +#include "providers/FSys_SettingStorageProvider.h" +#include "providers/FSys_SettingVibrationProvider.h" + +using namespace std; + +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Io; + +namespace Tizen { namespace System +{ + +static const String _SETTING_APPLICATION_PROVIDER(L"application"); +static const String _SETTING_FONT_PROVIDER(L"font"); +static const String _SETTING_DEVICE_NAME_PROVIDER(L"device_name"); +static const String _SETTING_MOTION_PROVIDER(L"motion"); +static const String _SETTING_CONTACTS_PROVIDER(L"contacts"); +static const String _SETTING_DEVELOPER_PROVIDER(L"developer"); +static const String _SETTING_BATTERY_PROVIDER(L"battery"); +static const String _SETTING_GRAPHICS_PROVIDER(L"graphics"); +static const String _SETTING_LOCALE_PROVIDER(L"locale"); +static const String _SETTING_LOCATION_PROVIDER(L"location"); +static const String _SETTING_NETWORK_PROVIDER(L"network"); +static const String _SETTING_SCREEN_PROVIDER(L"screen"); +static const String _SETTING_SOUND_PROVIDER(L"sound"); +static const String _SETTING_SPEECH_PROVIDER(L"speech"); +static const String _SETTING_STORAGE_PROVIDER(L"storage"); +static const String _SETTING_VIBRATION_PROVIDER(L"vibration"); + +static const wchar_t* _SETTING_PREFIX = L"http://tizen.org/setting/"; + +_SettingInfo* _SettingInfo::__pSettingInfo = null; +static const char* _BIN_FACTORY_RESET = "/usr/bin/factory-reset"; + +_SettingInfo::_SettingInfo() +{ + static _StringHashProvider hashProvider; + static _StringComparer stringComparer; + __settingProviderList.Construct(0, 0, hashProvider, stringComparer); + + _SettingApplicationProvider* applicationProvider = new (std::nothrow) _SettingApplicationProvider(); + RegisterProvider(_SETTING_APPLICATION_PROVIDER, (_ISettingProvider*)applicationProvider); + + _SettingFontProvider* fontProvider = new (std::nothrow) _SettingFontProvider(); + RegisterProvider(_SETTING_FONT_PROVIDER, (_ISettingProvider*)fontProvider); + + _SettingGeneralProvider* generalProvider = new (std::nothrow) _SettingGeneralProvider(); + RegisterProvider(_SETTING_DEVICE_NAME_PROVIDER, (_ISettingProvider*)generalProvider); + RegisterProvider(_SETTING_MOTION_PROVIDER, (_ISettingProvider*)generalProvider); + RegisterProvider(_SETTING_CONTACTS_PROVIDER, (_ISettingProvider*)generalProvider); + RegisterProvider(_SETTING_DEVELOPER_PROVIDER, (_ISettingProvider*)generalProvider); + RegisterProvider(_SETTING_BATTERY_PROVIDER, (_ISettingProvider*)generalProvider); + RegisterProvider(_SETTING_GRAPHICS_PROVIDER, (_ISettingProvider*)generalProvider); + + _SettingLocaleProvider* localeProvider = new (std::nothrow) _SettingLocaleProvider(); + RegisterProvider(_SETTING_LOCALE_PROVIDER, (_ISettingProvider*)localeProvider); + + _SettingLocationProvider* locationProvider = new (std::nothrow) _SettingLocationProvider(); + RegisterProvider(_SETTING_LOCATION_PROVIDER, (_ISettingProvider*)locationProvider); + + _SettingNetworkProvider* networkProvider = new (std::nothrow) _SettingNetworkProvider(); + RegisterProvider(_SETTING_NETWORK_PROVIDER, (_ISettingProvider*)networkProvider); + + _SettingScreenProvider* screenProvider = new (std::nothrow) _SettingScreenProvider(); + RegisterProvider(_SETTING_SCREEN_PROVIDER, (_ISettingProvider*)screenProvider); + + _SettingSoundProvider* soundProvider = new (std::nothrow) _SettingSoundProvider(); + RegisterProvider(_SETTING_SOUND_PROVIDER, (_ISettingProvider*)soundProvider); + + _SettingSpeechProvider* speechProvider = new (std::nothrow) _SettingSpeechProvider(); + RegisterProvider(_SETTING_SPEECH_PROVIDER, (_ISettingProvider*)speechProvider); + + _SettingStorageProvider* storageProvider = new (std::nothrow) _SettingStorageProvider(); + RegisterProvider(_SETTING_STORAGE_PROVIDER, (_ISettingProvider*)storageProvider); + + _SettingVibrationProvider* vibrationProvider = new (std::nothrow) _SettingVibrationProvider(); + RegisterProvider(_SETTING_VIBRATION_PROVIDER, (_ISettingProvider*)vibrationProvider); + + __settingEventList.Construct(); +} + +_SettingInfo::~_SettingInfo() +{ + RemoveProvider(_SETTING_APPLICATION_PROVIDER); + RemoveProvider(_SETTING_FONT_PROVIDER); + UnregisterProvider(_SETTING_MOTION_PROVIDER); + UnregisterProvider(_SETTING_CONTACTS_PROVIDER); + UnregisterProvider(_SETTING_DEVELOPER_PROVIDER); + UnregisterProvider(_SETTING_BATTERY_PROVIDER); + UnregisterProvider(_SETTING_GRAPHICS_PROVIDER); + RemoveProvider(_SETTING_LOCALE_PROVIDER); + RemoveProvider(_SETTING_LOCATION_PROVIDER); + RemoveProvider(_SETTING_NETWORK_PROVIDER); + RemoveProvider(_SETTING_SCREEN_PROVIDER); + RemoveProvider(_SETTING_SOUND_PROVIDER); + RemoveProvider(_SETTING_SPEECH_PROVIDER); + RemoveProvider(_SETTING_STORAGE_PROVIDER); + RemoveProvider(_SETTING_VIBRATION_PROVIDER); + __settingProviderList.RemoveAll(); +} + +result +_SettingInfo::RemoveProvider(const String key) +{ + _ISettingProvider* pProvider = null; + + pProvider = GetProvider(key); + if(pProvider != null) + { + UnregisterProvider(key); + delete pProvider; + return E_SUCCESS; + } + return E_SYSTEM; +} + +_SettingInfo* +_SettingInfo::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + if(__pSettingInfo == null) + { + pthread_once(&onceBlock, InitSingleton); + } + return __pSettingInfo; +} + +void +_SettingInfo::InitSingleton(void) +{ + _SettingInfo* pSettingInfo = new (std::nothrow) _SettingInfo(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", + GetErrorMessage(E_OUT_OF_MEMORY)); + + __pSettingInfo = pSettingInfo; + atexit(DestroySingleton); +} + +void +_SettingInfo::DestroySingleton(void) +{ + delete __pSettingInfo; +} + +_ISettingProvider* +_SettingInfo::GetProvider(const String& key) +{ + int index = 0; + String requiredKey; + String prefix(_SETTING_PREFIX); + _ISettingProvider* provider = null; + + key.SubString(prefix.GetLength(), requiredKey); + key.IndexOf(L".", 0, index); + requiredKey.SubString(index, requiredKey); + result r = __settingProviderList.GetValue(requiredKey, provider); + + if(r != E_SUCCESS || provider == null) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to find proper provider for required key(%ls).", key.GetPointer()); + return null; + } + + return provider; +} + +result +_SettingInfo::GetValue(const String& key, String& value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->GetValue(key, value); +} + +result +_SettingInfo::GetValue(const String& key, int& value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->GetValue(key, value); +} + +result +_SettingInfo::GetValue(const String& key, bool& value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->GetValue(key, value); +} + +bool HasKey(const String& key) +{ + return false; +} + +result +_SettingInfo::SetValue(const String& key, bool value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->SetValue(key, value); +} + +result +_SettingInfo::SetValue(const String& key, int value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->SetValue(key, value); +} + +result +_SettingInfo::SetValue(const String& key, String value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->SetValue(key, value); +} + +result +_SettingInfo::AddSettingEventListener(ISettingEventListener& listener) +{ + return __settingEventList.Add(&listener); +} + +result +_SettingInfo::RemoveSettingEventListener(ISettingEventListener& listener) +{ + return __settingEventList.Remove(&listener); +} + +result +_SettingInfo::AnnounceSettingEvent(const String& key) +{ + IEnumeratorT< ISettingEventListener*>* pEnum = __settingEventList.GetEnumeratorN(); + SysTryReturnResult(NID_SYS, pEnum != null, E_SYSTEM, "It is failed to get event listener list."); + + while(pEnum->MoveNext() == E_SUCCESS) + { + ISettingEventListener* pEventListener = null; + pEnum->GetCurrent(pEventListener); + + if(pEventListener != null) + { + String eventKey = key; + pEventListener->OnSettingChanged(eventKey); + } + } + + delete pEnum; + return E_SUCCESS; +} + +result +_SettingInfo::GetValueForPrivilegedKey(const String& key, bool& value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->GetValueForPrivilegedKey(key, value); +} + +result +_SettingInfo::SetValueForPrivilegedKey(const String& key, bool value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->SetValueForPrivilegedKey(key, value); +} + +result +_SettingInfo::SetValueAsyncForPrivilegedKey(const String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->SetValueAsyncForPrivilegedKey(key, value, listener); +} + +result +_SettingInfo::SetValueAsync(const String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->SetValueAsyncForPrivilegedKey(key, value, listener); +} + +result +_SettingInfo::SetValueForPrivilegedKey(const String& key, String value) +{ + _ISettingProvider* provider = GetProvider(key); + SysTryReturnResult(NID_SYS, provider != null, E_SYSTEM, "It is failed to find provider."); + return provider->SetValueForPrivilegedKey(key, value); +} + +result +_SettingInfo::ResetToFactoryDefault(void) +{ + SysTryReturnResult(NID_SYS, File::IsFileExist(_BIN_FACTORY_RESET) == true, E_UNSUPPORTED_OPERATION, "Current device does not support factory reset."); + SysTryReturnResult(NID_SYS, sysman_call_predef_action("launchfr", 0, NULL) == 0, E_SYSTEM, "It is failed to execute factory reset."); + return E_SUCCESS; +} + +result +_SettingInfo::RegisterProvider(const String& key, _ISettingProvider* provider) +{ + bool exist = false; + result r = __settingProviderList.ContainsKey(key, exist); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to check required key(%ls).", key.GetPointer()); + SysTryReturnResult(NID_SYS, exist == false, E_OBJ_ALREADY_EXIST, "It is already registered key(%ls).", key.GetPointer()); + + r = __settingProviderList.Add(key, provider); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to add required key(%ls).", key.GetPointer()); + return E_SUCCESS; +} + +result +_SettingInfo::UnregisterProvider(const String& key) +{ + bool exist = false; + result r = __settingProviderList.ContainsKey(key, exist); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to check required key(%ls).", key.GetPointer()); + SysTryReturnResult(NID_SYS, exist == true, E_OBJ_NOT_FOUND, "It is already registered key(%ls).", key.GetPointer()); + + r = __settingProviderList.Remove(key); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to remove required key(%ls).", key.GetPointer()); + return E_SUCCESS; +} + +} } diff --git a/src/system-server/setting/providers/FSys_ISettingProvider.h b/src/system-server/setting/providers/FSys_ISettingProvider.h new file mode 100644 index 0000000..737a942 --- /dev/null +++ b/src/system-server/setting/providers/FSys_ISettingProvider.h @@ -0,0 +1,101 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_ISettingProvider.h + * @brief This is the header file for the %_ISettingProvider class. + * + * This header file contains the declarations of the %_ISettingProvider class. + */ + +#ifndef _FSYS_ISETTING_PROVIDER_INTERNAL_H_ +#define _FSYS_ISETTING_PROVIDER_INTERNAL_H_ + +#include +#include +#include + +namespace Tizen { namespace System +{ + +class _ISettingProvider +{ +public: + virtual bool HasKey(const Tizen::Base::String& key) + { + return false; + } + + virtual result GetValue(const Tizen::Base::String& key, int& value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result GetValue(const Tizen::Base::String& key, bool& value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result GetValueForPrivilegedKey(const Tizen::Base::String& key, bool& value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result SetValue(const Tizen::Base::String& key, int value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result SetValue(const Tizen::Base::String& key, bool value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result SetValue(const Tizen::Base::String& key, Tizen::Base::String value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result SetValueAsync(const Tizen::Base::String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener) + { + return E_OBJ_NOT_FOUND; + } + + virtual result SetValueAsyncForPrivilegedKey(const Tizen::Base::String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener) + { + return E_OBJ_NOT_FOUND; + } + + virtual result SetValueForPrivilegedKey(const Tizen::Base::String& key, bool value) + { + return E_OBJ_NOT_FOUND; + } + + virtual result SetValueForPrivilegedKey(const Tizen::Base::String& key, Tizen::Base::String value) + { + return E_OBJ_NOT_FOUND; + } + +}; // _ISettingProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_PROVIDER_LISTENER_H_ diff --git a/src/system-server/setting/providers/FSys_Icu.cpp b/src/system-server/setting/providers/FSys_Icu.cpp new file mode 100644 index 0000000..63a7c8d --- /dev/null +++ b/src/system-server/setting/providers/FSys_Icu.cpp @@ -0,0 +1,111 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_Icu.cpp + * @brief This is the implementation file for _Icu class. + */ + +#include +#include + +#include +#include +#include "FSys_Icu.h" + +namespace Tizen { namespace System +{ + +static const int _MAX_COUNTRY_LENTH = 2; +static const int _LANGUAGE_START_INDEX = 0; +static const int _MAX_LANGUAGE_LENTH = 2; + +_Icu::_Icu() +{ +} + +_Icu::~_Icu() +{ +} + +char* +_Icu::GetIcuPatternN(const char* pLocale, UChar* pCustomSkeleton) +{ + UErrorCode status = U_ZERO_ERROR; + UDateTimePatternGenerator* pGenerator = null; + UChar bestPattern[64] = {0,}; + + if(pLocale == null || pCustomSkeleton == null) + { + return null; + } + + char* pBestPatternString = null; + int32_t bestPatternCapacity = 0; + int32_t bestPatternLength = 0; + + pGenerator = udatpg_open(pLocale, &status); + + if (U_FAILURE(status) == true) + { + return null; + } + + status = U_ZERO_ERROR; + + bestPatternCapacity = (int32_t)(sizeof(bestPattern)/sizeof((bestPattern)[0])); + bestPatternLength = udatpg_getBestPattern(pGenerator, pCustomSkeleton, u_strlen(pCustomSkeleton), bestPattern, bestPatternCapacity, &status); + if (U_FAILURE(status) == true) + { + return null; + } + + status = U_ZERO_ERROR; + pBestPatternString = (char*)malloc(128); + if (pBestPatternString == null) + { + return null; + } + memset(pBestPatternString, 0, 128); + u_austrncpy(pBestPatternString, bestPattern, 128); + udatpg_close(pGenerator); + SysLog(NID_SYS, "Format is [%s] \n", pBestPatternString); + return pBestPatternString; +} + +char* +_Icu::GetDateTimeFormatN(const char* pIcuFormat) +{ + char* pFormatString = null; + char* pDateTimeFormat = null; + + if (pIcuFormat == null) + { + return null; + } + + UChar customSkeleton[256] = {0, }; + const char* pLocaleDefault = uloc_getDefault(); + + pDateTimeFormat = const_cast< char* > (pLocaleDefault); + + u_uastrncpy(customSkeleton, pIcuFormat, sizeof(customSkeleton)); + pFormatString = GetIcuPatternN(pDateTimeFormat, customSkeleton); + + return pFormatString; +} + +} } // Tizen::System diff --git a/src/system-server/setting/providers/FSys_Icu.h b/src/system-server/setting/providers/FSys_Icu.h new file mode 100644 index 0000000..49bb7b2 --- /dev/null +++ b/src/system-server/setting/providers/FSys_Icu.h @@ -0,0 +1,45 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_Icu.h + * @brief This is the header file for _Icu class. + */ + + +#include +#include +#include +#include +#include +#include + +namespace Tizen { namespace System +{ +// ICU +static const char* _ICU_DATE_FORMAT = "yMMMMEEEEd"; +static const char* _ICU_TIME_24_FORMAT = "Hms"; +static const char* _ICU_TIME_12_FORMAT = "hms"; + +class _Icu +{ +public: + _Icu(); + virtual ~_Icu(); + char* GetIcuPatternN(const char* pLocale, UChar* pCustomSkeleton); + char* GetDateTimeFormatN(const char* pIcuFormat); +}; +} } // Tizen::System diff --git a/src/system-server/setting/providers/FSys_SettingApplicationProvider.cpp b/src/system-server/setting/providers/FSys_SettingApplicationProvider.cpp new file mode 100644 index 0000000..b2f7b15 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingApplicationProvider.cpp @@ -0,0 +1,198 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingApplicationProvider.cpp + * @brief This is the implementation for the _SettingApplicationProvider class. + */ +#include + +#include +#include +#include + +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingApplicationProvider.h" + +using namespace std; + +using namespace Tizen::App; +using namespace Tizen::Base; + +namespace Tizen { namespace System +{ + +static const wchar_t* _APPLICATION_HOME = L"http://tizen.org/setting/application.home"; +static const wchar_t* _APPLICATION_LOCK = L"http://tizen.org/setting/application.lock"; + +struct charDeleter +{ + void operator()(char* pValue) + { + if(pValue != null) + { + free(pValue); + pValue = null; + } + } +}; + +_SettingApplicationProvider::_SettingApplicationProvider() +{ + int errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register event listen for home application change."); + } + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register event listen for lock application change."); + } +} + +_SettingApplicationProvider::~_SettingApplicationProvider() +{ + int errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister event listen for home application change."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister event listen for lock application change."); + } +} + +bool +_SettingApplicationProvider::HasKey(const String& key) +{ + if(key == _APPLICATION_HOME) + { + unique_ptr pPackageName(vconf_get_str(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME)); + + if(pPackageName.get() != null) + { + return true; + } + } + else if(key == _APPLICATION_LOCK) + { + unique_ptr pPackageName(vconf_get_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR)); + + if(pPackageName.get() != null) + { + return true; + } + } + return false; +} + +result +_SettingApplicationProvider::GetValue(const String& key, String& value) +{ + result r = E_OBJ_NOT_FOUND; + + SysLog(NID_SYS, "Key[%ls] is required.", key.GetPointer()); + if(key == _APPLICATION_HOME) + { + unique_ptr pPackageName(vconf_get_str(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME)); + SysLog(NID_SYS, "Value for Key[%ls] is %s.", key.GetPointer(), pPackageName.get()); + SysTryReturnResult(NID_SYS, pPackageName != null, E_UNSUPPORTED_OPERATION, "It is failed to get package name of home application."); + value.Clear(); + value.Append(pPackageName.get()); + r = E_SUCCESS; + } + else if(key == _APPLICATION_LOCK) + { + unique_ptr pPackageName(vconf_get_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR)); + SysLog(NID_SYS, "Value for Key[%ls] is %s.", key.GetPointer(), pPackageName.get()); + SysTryReturnResult(NID_SYS, pPackageName != null, E_UNSUPPORTED_OPERATION, "It is failed to get package name of lock application."); + value.Clear(); + value.Append(pPackageName.get()); + r = E_SUCCESS; + } + + return r; +} + +result +_SettingApplicationProvider::SetValueForPrivilegedKey(const String& key, String value) +{ + result r = E_OBJ_NOT_FOUND; + + int errorCode = 0; + + if(key == _APPLICATION_HOME) + { + bool installed = _Aul::IsInstalled(value); + SysTryReturnResult(NID_SYS, installed == true, E_INVALID_ARG, "Specified application[%ls] is not installed.", value.GetPointer()); + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support home application."); + r = E_SUCCESS; + + unique_ptr pPackageName(_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, pPackageName.get() != null, E_SYSTEM, "It is failed to get string of specified value[%ls].", value.GetPointer()); + SysLog(NID_SYS, "Value for Key[%ls] is %s.", key.GetPointer(), pPackageName.get()); + errorCode = vconf_set_str(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, pPackageName.get()); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set home application."); + } + else if(key == _APPLICATION_LOCK) + { + bool installed = _Aul::IsInstalled(value); + SysTryReturnResult(NID_SYS, installed == true, E_INVALID_ARG, "Specified application[%ls] is not installed.", value.GetPointer()); + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support lock application."); + r = E_SUCCESS; + + unique_ptr pPackageName(_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, pPackageName.get() != null, E_SYSTEM, "It is failed to get string of specified value[%ls].", value.GetPointer()); + SysLog(NID_SYS, "Value for Key[%ls] is %s.", key.GetPointer(), pPackageName.get()); + errorCode = vconf_set_str(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, pPackageName.get()); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set lock application."); + } + return r; +} + +void +_SettingApplicationProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + String settingKey; + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + if(strcmp(VCONFKEY_SETAPPL_SELECTED_PACKAGE_NAME, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_APPLICATION_HOME); + } + else if(strcmp(VCONFKEY_SETAPPL_3RD_LOCK_PKG_NAME_STR, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_APPLICATION_LOCK); + } + else + { + SysLogException(NID_SYS, E_SYSTEM, "There is no reserved key [%s].", vconf_keynode_get_name(node)); + return; + } + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingApplicationProvider.h b/src/system-server/setting/providers/FSys_SettingApplicationProvider.h new file mode 100644 index 0000000..fed3407 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingApplicationProvider.h @@ -0,0 +1,53 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingApplicationProvider.h + * @brief This is the header file for the %_SettingApplicationProvider class. + * + * This header file contains the declarations of the %_SettingApplicationProvider class. + */ + +#ifndef _FSYS_SETTING_APPLICATION_PROVIDER_INTERNAL_H_ +#define _FSYS_SETTING_APPLICATION_PROVIDER_INTERNAL_H_ + +#include + +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingApplicationProvider + : _ISettingProvider +{ +public: + _SettingApplicationProvider(); + virtual ~_SettingApplicationProvider(); + +public: + bool HasKey(const Tizen::Base::String& key); + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValueForPrivilegedKey(const Tizen::Base::String& key, Tizen::Base::String value); + +private: + static void SettingEventVConf(keynode_t* node, void* userData); + +}; // _SettingApplicationProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_APPLICATION_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingFontProvider.cpp b/src/system-server/setting/providers/FSys_SettingFontProvider.cpp new file mode 100644 index 0000000..a6185ed --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingFontProvider.cpp @@ -0,0 +1,257 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingFontProvider.cpp + * @brief This is the implementation for the _SettingFontProvider class. + */ + +#include + +#include +#include +#include + +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingFontProvider.h" + +using namespace std; + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Utility; + +namespace Tizen { namespace System +{ + +static const wchar_t* _FONT_SIZE = L"http://tizen.org/setting/font.size"; +static const wchar_t* _FONT_TYPE = L"http://tizen.org/setting/font.type"; + +static const wchar_t* _FONT_SIZE_GIANT = L"giant"; +static const wchar_t* _FONT_SIZE_HUGE = L"huge"; +static const wchar_t* _FONT_SIZE_LARGE = L"large"; +static const wchar_t* _FONT_SIZE_MEDIUM = L"medium"; +static const wchar_t* _FONT_SIZE_SMALL = L"small"; + +static const int _FONT_SIZE_GIANT_VCONF = 4; +static const int _FONT_SIZE_HUGE_VCONF = 3; +static const int _FONT_SIZE_LARGE_VCONF = 2; +static const int _FONT_SIZE_MEDIUM_VCONF = 1; +static const int _FONT_SIZE_SMALL_VCONF = 0; + +struct charDeleter +{ + void operator()(char* pValue) + { + if(pValue != null) + { + free(pValue); + pValue = null; + } + } +}; + +bool +_SettingFontProvider::HasKey(const Tizen::Base::String& key) +{ + if(key == _FONT_SIZE || key == _FONT_TYPE) + { + return true; + } + + return false; +} + +_SettingFontProvider::_SettingFontProvider() +{ + int errorCode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE, SettingEventSettingInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register font type event listener"); + } + + errorCode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_SIZE, SettingEventSettingInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register font size event listener"); + } +} + + +_SettingFontProvider::~_SettingFontProvider() +{ + int errorCode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_FONT_SIZE); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister font size event listener"); + } + + errorCode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister font type event listener"); + } +} + +result +_SettingFontProvider::GetValue(const String& key, String& value) +{ + SysTryReturnResult(NID_SYS, 0, E_SYSTEM, "[E_SYSTEM] It is not working."); + result r = E_OBJ_NOT_FOUND; + + if(key == _FONT_SIZE) + { + int fontSize = 0; + int res = 0; + res = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &fontSize); + SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to get font size."); + SysLog(NID_SYS, "current font size is %d.", fontSize); + + r = E_SUCCESS; + switch (fontSize) + { + case _FONT_SIZE_GIANT_VCONF: + value.Append(_FONT_SIZE_GIANT); + break; + case _FONT_SIZE_HUGE_VCONF: + value.Append(_FONT_SIZE_HUGE); + break; + case _FONT_SIZE_LARGE_VCONF: + value.Append(_FONT_SIZE_LARGE); + break; + case _FONT_SIZE_MEDIUM_VCONF: + value.Append(_FONT_SIZE_MEDIUM); + break; + case _FONT_SIZE_SMALL_VCONF: + value.Append(_FONT_SIZE_SMALL); + break; + default: + r = E_SYSTEM; + break; + } + + } + else if(key == _FONT_TYPE) + { + r = E_SUCCESS; + char* pTemp = null; + int res = 0; + res = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &pTemp); + SysTryReturnResult(NID_SYS, pTemp != null, E_SYSTEM, "It is failed to get font type."); + + unique_ptr pFontType(pTemp); + SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to get font type."); + SysLog(NID_SYS, "current font type is %s.", pTemp); + r = StringUtil::Utf8ToString(pFontType.get(), value); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to convert font type to Utf8."); + } + + return r; +} + +result +_SettingFontProvider::SetValue(const String& key, const String value) +{ + SysTryReturnResult(NID_SYS, 0, E_SYSTEM, "[E_SYSTEM] It is not working."); + result r = E_OBJ_NOT_FOUND; + + if(key == _FONT_SIZE) + { + int fontSize = 0; + int res = 0; + String lowerValue = value; + lowerValue.ToLowerCase(); + r = E_SUCCESS; + + if (lowerValue == _FONT_SIZE_GIANT) + { + fontSize = _FONT_SIZE_GIANT_VCONF; + } + else if (lowerValue == _FONT_SIZE_HUGE) + { + fontSize = _FONT_SIZE_HUGE_VCONF; + } + else if (lowerValue == _FONT_SIZE_LARGE) + { + fontSize = _FONT_SIZE_LARGE_VCONF; + } + else if (lowerValue == _FONT_SIZE_MEDIUM) + { + fontSize = _FONT_SIZE_MEDIUM_VCONF; + } + else if (lowerValue == _FONT_SIZE_SMALL) + { + fontSize = _FONT_SIZE_SMALL_VCONF; + } + else + { + return E_INVALID_ARG; + } + res = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, fontSize); + SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to set font size."); + } + else if(key == _FONT_TYPE) + { + int res = 0; + r = E_SUCCESS; + + unique_ptr pFontType(_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, pFontType.get() != null, E_SYSTEM, "It is failed to convert String to string."); + SysLog(NID_SYS, "Requested font type is %s.", pFontType.get()); + res = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, pFontType.get()); + if(res == SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER) + { + return E_INVALID_ARG; + } + SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to set font type."); + } + return r; +} + +void +_SettingFontProvider::SettingEventSettingInfo(system_settings_key_e key, void* userData) +{ + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + String settingKey; + + switch (key) + { + case SYSTEM_SETTINGS_KEY_FONT_SIZE: + { + settingKey.Append(_FONT_SIZE); + break; + } + case SYSTEM_SETTINGS_KEY_FONT_TYPE: + { + settingKey.Append(_FONT_TYPE); + break; + } + default: + { + SysLogException(NID_SYS, E_SYSTEM, "No required key[%d] is delivered", key); + return; + } + } + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingFontProvider.h b/src/system-server/setting/providers/FSys_SettingFontProvider.h new file mode 100644 index 0000000..57c6bdc --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingFontProvider.h @@ -0,0 +1,51 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingFontProvider.h + * @brief This is the header file for the %_SettingFontProvider class. + * + * This header file contains the declarations of the %_SettingFontProvider class. + */ + +#ifndef _FSYS_SETTING_FONT_PROVIDER_INTERNAL_H_ +#define _FSYS_SETTING_FONT_PROVIDER_INTERNAL_H_ + +#include +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingFontProvider + : _ISettingProvider +{ +public: + _SettingFontProvider(); + ~_SettingFontProvider(); + +public: + bool HasKey(const Tizen::Base::String& key); + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValue(const Tizen::Base::String& key, Tizen::Base::String value); + +private: + static void SettingEventSettingInfo(system_settings_key_e key, void* userData); +}; // _SettingFontProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_FONT_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingGeneralProvider.cpp b/src/system-server/setting/providers/FSys_SettingGeneralProvider.cpp new file mode 100644 index 0000000..3465688 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingGeneralProvider.cpp @@ -0,0 +1,430 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingGeneralProvider.cpp + * @brief This is the implementation for the _SettingGeneralProvider class. + */ +#include + +#include +#include + +#include + +#include + +#include +#include +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingGeneralProvider.h" + +using namespace std; + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Utility; + +namespace Tizen { namespace System +{ + +static const int _NUM_OF_GENERAL_PROVIDER = 6; + +static const wchar_t* _DEVICE_NAME = L"device_name"; + +static const wchar_t* _MOTION_UI = L"motion.ui"; + +static const wchar_t* _CONTACT_ORDER_FIRSTNAME = L"contacts.order.firstname"; +static const int _CONTACT_ORDER_FIRSTNAME_FIRSTLAST = 0; +static const int _CONTACT_ORDER_FIRSTNAME_LASTFIRST = 1; + +static const wchar_t* _DEVELOPER_USBDEBUGGING = L"developer.usb_debugging"; + +static const wchar_t* _BATTERY_FORMAT_PERCENTAGE = L"battery.format.percentage"; + +static const wchar_t* _GRAPHICS_GPU_RENDERING = L"graphics.gpu.rendering"; +static const char* _GRAPHICS_GPU_RENDERING_HW = "opengl_x11"; +static const char* _GRAPHICS_GPU_RENDERING_SW = "software_x11"; + +struct charDeleter +{ + void operator()(char* pValue) + { + if(pValue != null) + { + free(pValue); + pValue = null; + } + } +}; + +_SettingGeneralProvider::_SettingGeneralProvider() + : currentMode(0) +{ + int errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEVICE_NAME_STR event listener."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER event listener."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL event listener."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL event listener."); + } + + errorCode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, SettingEventSettingInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION event listener."); + } + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT event listener."); + } +} + + +_SettingGeneralProvider::~_SettingGeneralProvider() +{ + int errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEVICE_NAME_STR event listener."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER event listener."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL event listener."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL event listener."); + } + + errorCode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION event listener."); + } + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT event listener."); + } +} + +result +_SettingGeneralProvider::GetValue(const String& key, bool& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + SysLog(NID_SYS, "Key: %ls", key.GetPointer()); + if (key == _MOTION_UI) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + int motion = 0; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_MOTION_ACTIVATION, &motion); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_SETAPPL_MOTION_ACTIVATION."); + value = motion; + return r; + } + else if (key == _CONTACT_ORDER_FIRSTNAME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Contact ordering feature."); + r = E_SUCCESS; + + int contactOrder = 0; + errorCode = vconf_get_int(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, &contactOrder); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER."); + + if (contactOrder == _CONTACT_ORDER_FIRSTNAME_FIRSTLAST) + { + value = true; + } + else if (contactOrder == _CONTACT_ORDER_FIRSTNAME_LASTFIRST) + { + value = false; + } + else + { + return E_SYSTEM; + } + } + else if (key == _DEVELOPER_USBDEBUGGING) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support USB debugging feature."); + r = E_SUCCESS; + + int usbMode = 0; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, &usbMode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL."); + value = usbMode; + } + else if(key == _BATTERY_FORMAT_PERCENTAGE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support battery format feature."); + r = E_SUCCESS; + + int batteryFormat = 0; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, &batteryFormat); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL."); + value = batteryFormat; + } + else if(key == _GRAPHICS_GPU_RENDERING) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support GPU rendering feature."); + r = E_SUCCESS; + + int gpu_rendering = 0; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT, &gpu_rendering); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT."); + value = (gpu_rendering == SETTING_RENDERING_ENGINE_HW); + } + return r; +} + +result +_SettingGeneralProvider::SetValue(const String& key, const bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + SysLog(NID_SYS, "Key: %ls, %d", key.GetPointer(), value); + if(key == _MOTION_UI) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_MOTION_ACTIVATION, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set the VCONFKEY_SETAPPL_MOTION_ACTIVATION."); + } + else if (key == _CONTACT_ORDER_FIRSTNAME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + int contactOrder = 0; + + if (value) + { + contactOrder = _CONTACT_ORDER_FIRSTNAME_FIRSTLAST; + } + else + { + contactOrder = _CONTACT_ORDER_FIRSTNAME_LASTFIRST; + } + errorCode = vconf_set_int(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, contactOrder); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER vconf"); + } + else if(key == _BATTERY_FORMAT_PERCENTAGE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support battery format feature."); + r = E_SUCCESS; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set the VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL."); + } + else if(key == _GRAPHICS_GPU_RENDERING) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support GPU rendering feature."); + r = E_SUCCESS; + + if(value == true) + { + elm_config_preferred_engine_set(_GRAPHICS_GPU_RENDERING_HW); + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT, SETTING_RENDERING_ENGINE_HW); + } + else + { + elm_config_preferred_engine_set(_GRAPHICS_GPU_RENDERING_SW); + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT, SETTING_RENDERING_ENGINE_SW); + } + + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT."); + } + return r; +} + +result +_SettingGeneralProvider::SetValueForPrivilegedKey(const String& key, bool value) +{ + result r = E_OBJ_NOT_FOUND; + if(key == _DEVELOPER_USBDEBUGGING) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + int errorCode = vconf_set_bool(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL vconf"); + } + return r; +} + +result +_SettingGeneralProvider::GetValue(const String& key, String& value) +{ + result r = E_OBJ_NOT_FOUND; + if (key == _DEVICE_NAME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + unique_ptr pDeviceName(vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR)); + SysTryReturnResult(NID_SYS, pDeviceName.get() != null, E_SYSTEM, "It is failed to get device name."); + + r = StringUtil::Utf8ToString(pDeviceName.get(), value); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "[%s] StringUtil::Utf8ToString is failed", GetErrorMessage(r)); + } + return r; +} + +result +_SettingGeneralProvider::SetValue(const String& key, const String value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _DEVICE_NAME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + SysTryReturnResult(NID_SYS, value.GetLength() > 0 && value.GetLength() <= 128, E_INVALID_ARG, "Device name is too long") + unique_ptr deviceName(_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, deviceName.get() != null, E_SYSTEM, "It is failed to convert String to string"); + + errorCode = vconf_set_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR, deviceName.get()); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_DEVICE_NAME_STR vconf"); + } + return r; +} + +bool +_SettingGeneralProvider::HasKey(const Tizen::Base::String& key) +{ + if(key == _DEVICE_NAME) + { + return true; + } + else if(key == _MOTION_UI) + { + return true; + } + else if(key == _CONTACT_ORDER_FIRSTNAME) + { + return true; + } + else if(key == _DEVELOPER_USBDEBUGGING) + { +#ifndef _OSP_EMUL_ + return true; +#else + return false; +#endif + } + else if(key == _GRAPHICS_GPU_RENDERING) + { + return true; + } + else if(key == _BATTERY_FORMAT_PERCENTAGE) + { + return true; + } + return false; +} + +void +_SettingGeneralProvider::SettingEventSettingInfo(system_settings_key_e key, void* userData) +{ + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + String settingKey; + + if(key == SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION) + { + settingKey.Append(_MOTION_UI); + } + else + { + return; + } + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingGeneralProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + String settingKey; + + if (strcmp(VCONFKEY_SETAPPL_DEVICE_NAME_STR, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_DEVICE_NAME); + } + else if (strcmp(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_CONTACT_ORDER_FIRSTNAME); + } + else if (strcmp(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_DEVELOPER_USBDEBUGGING); + } + else if (strcmp(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_BATTERY_FORMAT_PERCENTAGE); + } + else if (strcmp(VCONFKEY_SETAPPL_DEFAULT_RENDERING_ENGINE_TYPE_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_GRAPHICS_GPU_RENDERING); + } + else + { + return; + } + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingGeneralProvider.h b/src/system-server/setting/providers/FSys_SettingGeneralProvider.h new file mode 100644 index 0000000..3efa30d --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingGeneralProvider.h @@ -0,0 +1,59 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingGeneralProvider.h + * @brief This is the header file for the %_SettingGeneralProvider class. + * + * This header file contains the declarations of the %_SettingGeneralProvider class. + */ + +#ifndef _FSYS_SETTING_GENERAL_PROVIDER_H_ +#define _FSYS_SETTING_GENERAL_PROVIDER_H_ + +#include +#include + +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingGeneralProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingGeneralProvider(); + virtual ~_SettingGeneralProvider(); + +public: + bool HasKey(const Tizen::Base::String& key); + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValue(const Tizen::Base::String& key, const bool value); + result SetValueForPrivilegedKey(const Tizen::Base::String& key, bool value); + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValue(const Tizen::Base::String& key, const Tizen::Base::String value); +private: + int currentMode; + +private: + static void SettingEventSettingInfo(system_settings_key_e key, void* userData); + static void SettingEventVConf(keynode_t* node, void* userData); +}; // _SettingGeneralProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_GENERAL_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingLocaleProvider.cpp b/src/system-server/setting/providers/FSys_SettingLocaleProvider.cpp new file mode 100644 index 0000000..bfd633e --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingLocaleProvider.cpp @@ -0,0 +1,733 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingLocaleProvider.cpp + * @brief This is the implementation for the _SettingLocaleProvider class. + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingLocaleProvider.h" + +using namespace std; + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Base::Utility; +using namespace Tizen::Locales; + +namespace Tizen { namespace System +{ + +//Language and Region +static const wchar_t* _LOCALE_COUNTRY = L"http://tizen.org/setting/locale.country"; +static const wchar_t* _LOCALE_LANGUAGE = L"http://tizen.org/setting/locale.language"; +static const char* _LANGUAGE_LIST_FILE_PATH = "/opt/usr/data/setting/langlist.xml"; + +//Format +static const wchar_t* _LOCALE_DATE_FORMAT = L"http://tizen.org/setting/locale.date.format"; +static const wchar_t* _LOCALE_DATETIME_FORMAT = L"http://tizen.org/setting/locale.date_time.format"; +static const wchar_t* _LOCALE_TIME_FORMAT = L"http://tizen.org/setting/locale.time.format"; +static const wchar_t* _LOCALE_TIME_FORMAT_24HOUR = L"http://tizen.org/setting/locale.time.format.24hour"; + +static const wchar_t* _LOCALE_WEEK_FORMAT_FIRSTDAY = L"http://tizen.org/setting/locale.week.format.firstday"; +static const wchar_t* _LOCALE_WEEK_FORMAT_FIRSTDAY_MONDAY = L"Monday"; +static const wchar_t* _LOCALE_WEEK_FORMAT_FIRSTDAY_SUNDAY = L"Sunday"; + +static const int _LOCALE_WEEK_FORMAT_VCONF_SUNDAY = 0; +static const int _LOCALE_WEEK_FORMAT_VCONF_MONDAY = 1; + +//Timezone +static const wchar_t* _LOCALE_TIMEZONE = L"locale.time_zone"; +static const wchar_t* _LOCALE_UPDATE_AUTO= L"locale.update.auto"; + +static const char* _LOCALE_TIMEZONE_ROOT_PATH = "/usr/share/zoneinfo/"; +static const char* _LOCALE_TIMEZONE_LINK = "/opt/etc/localtime"; +static const int _LOCALE_TIMEZONE_ROOT_PATH_LENGTH = 20; + +//Date time +static const wchar_t* _LOCALE_DATE = L"locale.date"; +static const wchar_t* _LOCALE_TIME = L"locale.time"; +static const wchar_t* _LOCALE_DATETIME = L"locale.date_time"; + +struct charDeleter +{ + void operator()(char* pValue) + { + if(pValue != null) + { + free(pValue); + pValue = null; + } + } +}; + +_SettingLocaleProvider::_SettingLocaleProvider() +{ + int errorCode = 0; + errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_REGION, SettingEventRuntimeInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register region event listener"); + } + + errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LANGUAGE, SettingEventRuntimeInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register language event listener"); + } + + errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED, SettingEventRuntimeInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register 24hour format event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_TIMEZONE_ID, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL event listener"); + } +} + +_SettingLocaleProvider::~_SettingLocaleProvider() +{ + int errorCode = 0; + errorCode = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_REGION); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister region event listener"); + } + + errorCode = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_LANGUAGE); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register language event listener"); + } + + errorCode = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register 24hour format event listener"); + } + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_TIMEZONE_ID, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_TIMEZONE_ID event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL event listener"); + } +} + +result +_SettingLocaleProvider::GetValue(const String& key, bool& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _LOCALE_TIME_FORMAT_24HOUR) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support 24hour format feature."); + r = E_SUCCESS; + bool is24HoueEnabled = false; + errorCode = runtime_info_get_value_bool(RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED, &is24HoueEnabled); + SysTryReturnResult(NID_SYS, errorCode == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "It is failed to get the SYSTEM_INFO_KEY__WIFI_SUPPORTED"); + value = is24HoueEnabled; + } + else if (key == _LOCALE_UPDATE_AUTO) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support locale auto update feature."); + r = E_SUCCESS; + int isAutomaticUpdate = 0; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &isAutomaticUpdate); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL vconf"); + if(isAutomaticUpdate == 1) + { + value = true; + } + else + { + value = false; + } + } + return r; +} + +result +_SettingLocaleProvider::SetValue(const String& key, const bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _LOCALE_TIME_FORMAT_24HOUR) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support 24hour format feature."); + r = E_SUCCESS; + errorCode = vconf_set_int(VCONFKEY_REGIONFORMAT_TIME1224, value ? VCONFKEY_TIME_FORMAT_24 : VCONFKEY_TIME_FORMAT_12); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_REGIONFORMAT_TIME1224 vconf"); + } + else if(key == _LOCALE_UPDATE_AUTO) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support locale auto update feature."); + r = E_SUCCESS; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL vconf"); + } + return r; +} + +result +_SettingLocaleProvider::GetValue(const String& key, String& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if (key == _LOCALE_COUNTRY || key == _LOCALE_LANGUAGE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support %ls feature.", key.GetPointer()); + r = E_SUCCESS; + + unique_ptr pLocale(null); + char* pTemp = null; + runtime_info_key_e vconfKey = (key == _LOCALE_COUNTRY) + ? RUNTIME_INFO_KEY_REGION // Region locale + : RUNTIME_INFO_KEY_LANGUAGE; // Display language locale + + errorCode = runtime_info_get_value_string(vconfKey, &pTemp); + SysTryReturnResult(NID_SYS, errorCode == RUNTIME_INFO_ERROR_NONE && pTemp != null, E_SYSTEM, "[E_SYSTEM] runtime_info_get_value_string [%ls] failed", key.GetPointer()); + pLocale.reset(pTemp); + icu::Locale icuLocale(pLocale.get()); + String localeString(icuLocale.getISO3Language()); + String languageScriptTmp(icuLocale.getScript()); + + if (!languageScriptTmp.IsEmpty()) + { + String languageScript; + languageScriptTmp.ToLowerCase(languageScript); + localeString.Append(L"-"); + localeString.Append(languageScript); + } + localeString.Append("_"); + + localeString.Append(icuLocale.getCountry()); + + value = localeString; + } + else if ( key == _LOCALE_TIME_FORMAT) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support date format feature."); + r = E_SUCCESS; + + unique_ptr pTimeFormat(null); + char* pTemp = null; + bool selected24Format = false; + + r = GetValue(_LOCALE_TIME_FORMAT_24HOUR, selected24Format); + + if (selected24Format == true) + { + pTemp = __icu.GetDateTimeFormatN(_ICU_TIME_24_FORMAT); + } + else + { + pTemp = __icu.GetDateTimeFormatN(_ICU_TIME_12_FORMAT); + } + SysTryReturnResult(NID_SYS, pTemp != null, E_SYSTEM, "Failed to get time format"); + pTimeFormat.reset(pTemp); + r = StringUtil::Utf8ToString(pTimeFormat.get(), value); + } + else if ( key == _LOCALE_DATE_FORMAT) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support date format feature."); + r = E_SUCCESS; + + unique_ptr pDateFormat(__icu.GetDateTimeFormatN(_ICU_DATE_FORMAT)); + SysTryReturnResult(NID_SYS, pDateFormat.get() != null, E_SYSTEM, "It is failed to get date format"); + + r = StringUtil::Utf8ToString(pDateFormat.get(), value); + } + else if (key == _LOCALE_DATETIME_FORMAT) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support date time format feature."); + r = E_SUCCESS; + + unique_ptr pDateFormat(__icu.GetDateTimeFormatN(_ICU_DATE_FORMAT)); + unique_ptr pTimeFormat(null); + char* pTemp = null; + String timeFormat; + bool selected24Format = false; + + SysLog(NID_SYS, "Date Time format is %s.", pDateFormat.get()); + SysTryReturnResult(NID_SYS, pDateFormat.get() != null, E_SYSTEM, "It is failed to get date format."); + + r = GetValue(_LOCALE_TIME_FORMAT_24HOUR, selected24Format); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get time format."); + + SysLog(NID_SYS, "24hour format, %d", selected24Format); + + if (selected24Format == true) + { + pTemp = __icu.GetDateTimeFormatN(_ICU_TIME_24_FORMAT); + } + else + { + pTemp = __icu.GetDateTimeFormatN(_ICU_TIME_12_FORMAT); + } + + SysTryReturnResult(NID_SYS, pTemp != null, E_SYSTEM, "It is failed to get time format."); + pTimeFormat.reset(pTemp); + r = StringUtil::Utf8ToString(pDateFormat.get(), value); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to convert string to UTF8."); + r = StringUtil::Utf8ToString(pTimeFormat.get(), timeFormat); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to convert string to UTF8."); + + value.Append(" "); + value.Append(timeFormat); + } + else if (key == _LOCALE_WEEK_FORMAT_FIRSTDAY) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support week format feature."); + r = E_SUCCESS; + + int firstDay = 0; + int errorCode = 0; + + errorCode = vconf_get_int(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, &firstDay); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT vconf"); + + if (firstDay == _LOCALE_WEEK_FORMAT_VCONF_SUNDAY) + { + value = _LOCALE_WEEK_FORMAT_FIRSTDAY_SUNDAY; + } + else if (firstDay == _LOCALE_WEEK_FORMAT_VCONF_MONDAY) + { + value = _LOCALE_WEEK_FORMAT_FIRSTDAY_MONDAY; + } + else + { + r = E_SYSTEM; + } + } + else if (key == _LOCALE_TIMEZONE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support time zone feature."); + r = E_SUCCESS; + + char pTZPath[256] = {0,}; + ssize_t nLen = readlink(_LOCALE_TIMEZONE_LINK, pTZPath, sizeof(pTZPath)-1); + if (nLen != -1) + { + pTZPath[nLen] = '\0'; + } + else + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to get timezone"); + } + value.Clear(); + value.Append(&pTZPath[_LOCALE_TIMEZONE_ROOT_PATH_LENGTH]); + } + else if (key == _LOCALE_DATE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support date feature."); + r = E_SUCCESS; + + DateTime currentTime; + SystemTime::GetCurrentTime(TIME_MODE_WALL, currentTime); + String currentFormat; + GetValue(_LOCALE_DATE_FORMAT, currentFormat); + + unique_ptr pFormatter(DateTimeFormatter::CreateTimeFormatterN()); + SysTryReturnResult(NID_SYS, pFormatter != null, E_OUT_OF_MEMORY, "It is failed to create DateTimeFomatter"); + pFormatter->ApplyPattern(currentFormat); + value.Clear(); + pFormatter->Format(currentTime, value); + } + else if (key == _LOCALE_DATETIME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support date time feature."); + r = E_SUCCESS; + + DateTime currentTime; + SystemTime::GetCurrentTime(TIME_MODE_WALL, currentTime); + String currentFormat; + GetValue(_LOCALE_DATETIME_FORMAT, currentFormat); + + unique_ptr pFormatter(DateTimeFormatter::CreateTimeFormatterN()); + pFormatter->ApplyPattern(currentFormat); + value.Clear(); + pFormatter->Format(currentTime, value); + } + else if (key == _LOCALE_TIME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support time feature."); + r = E_SUCCESS; + + DateTime currentTime; + SystemTime::GetCurrentTime(TIME_MODE_WALL, currentTime); + String currentFormat; + GetValue(_LOCALE_TIME_FORMAT, currentFormat); + + unique_ptr pFormatter(DateTimeFormatter::CreateTimeFormatterN()); + pFormatter->ApplyPattern(currentFormat); + value.Clear(); + pFormatter->Format(currentTime, value); + } + return r; +} + +result +_SettingLocaleProvider::SetValue(const String& key, const String value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _LOCALE_COUNTRY || key == _LOCALE_LANGUAGE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support locale country selection feature."); + + r = E_SUCCESS; + + unique_ptr lang (_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, lang != null, E_SYSTEM, "It is failed to convert String to string"); + + icu::Locale locale(lang.get()); + errorCode = locale.isBogus(); + SysTryReturnResult(NID_SYS, errorCode == 0 && IsValidLocaleString(value, locale) == true, E_INVALID_ARG, "Unknown language format"); + + std::string localeCode(locale.getLanguage()); + localeCode.append("_"); + localeCode.append(locale.getCountry()); + + const char* vconfKey = null; + + if (key == _LOCALE_LANGUAGE) + { + SysTryReturnResult(NID_SYS, IsSupportedDisplayLanguageLocale(localeCode.c_str()), + E_INVALID_ARG, "It is not the supported display language locale [%s].", localeCode.c_str()); + vconfKey = VCONFKEY_LANGSET; + localeCode.append(".utf8"); + } + else if (key == _LOCALE_COUNTRY) + { + localeCode.append(".utf8"); + SysTryReturnResult(NID_SYS, IsSupportedRegionLocale(localeCode.c_str()), + E_INVALID_ARG, "It is not the supported region locale [%s].", localeCode.c_str()); + vconfKey = VCONFKEY_REGIONFORMAT; + } + errorCode = vconf_set_str(vconfKey, localeCode.c_str()); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on %ls vconf",key.GetPointer()); + r = E_SUCCESS; + } + else if(key == _LOCALE_WEEK_FORMAT_FIRSTDAY) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support week format selection feature."); + r = E_SUCCESS; + + int firstDay = 0; + + String sunday(_LOCALE_WEEK_FORMAT_FIRSTDAY_SUNDAY); + String monday(_LOCALE_WEEK_FORMAT_FIRSTDAY_MONDAY); + + String requiredValue(value); + requiredValue.ToLowerCase(); + sunday.ToLowerCase(); + monday.ToLowerCase(); + + if (requiredValue == sunday) + { + firstDay = _LOCALE_WEEK_FORMAT_VCONF_SUNDAY; + } + else if (requiredValue == monday) + { + firstDay = _LOCALE_WEEK_FORMAT_VCONF_MONDAY; + } + else + { + return E_INVALID_ARG; + } + + errorCode = vconf_set_int(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, firstDay); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT vconf"); + } + else if(key == _LOCALE_TIMEZONE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support time zone feature."); + r = E_SUCCESS; + + LocaleManager localeManager; + localeManager.Construct(); + unique_ptr pSupportedTimeZoneList(localeManager.GetAvailableTimeZonesN()); + + SysTryReturnResult(NID_SYS, pSupportedTimeZoneList != null, E_SYSTEM, "It is failed to get supported timezone list."); + SysTryReturnResult(NID_SYS, pSupportedTimeZoneList->Contains(value) == true, E_INVALID_ARG, "Specified timezone id[%S] is not valid", value.GetPointer()); + + unique_ptr tzpath (_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, tzpath != null, E_SYSTEM, "It is failed to convert String to string"); + std::string tzStr(_LOCALE_TIMEZONE_ROOT_PATH); + tzStr.append(tzpath.get()); + unique_ptr cstrTzpath (strdup(tzStr.c_str())); + int errorCode = sysman_set_timezone(cstrTzpath.get()); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set timezone"); + + errorCode = vconf_set_str(VCONFKEY_SETAPPL_TIMEZONE_ID, cstrTzpath.get()+_LOCALE_TIMEZONE_ROOT_PATH_LENGTH); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set VCONFKEY_SETAPPL_TIMEZONE_ID vconf"); + + errorCode = vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED, -1); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to notify to system about time changing"); + } + return r; +} + +bool +_SettingLocaleProvider::HasKey(const Tizen::Base::String& key) +{ + if(key == _LOCALE_COUNTRY || key == _LOCALE_LANGUAGE) + { + return true; + } + else if(key == _LOCALE_DATE_FORMAT || key == _LOCALE_DATETIME_FORMAT || key == _LOCALE_TIME_FORMAT || key == _LOCALE_TIME_FORMAT_24HOUR || key == _LOCALE_WEEK_FORMAT_FIRSTDAY) + { + return true; + } + else if(key == _LOCALE_TIMEZONE || key == _LOCALE_UPDATE_AUTO) + { + return true; + } + else if(key == _LOCALE_DATE || key == _LOCALE_TIME || _LOCALE_DATETIME) + { + return true; + } + return false; +} + +void +_SettingLocaleProvider::SettingEventRuntimeInfo(runtime_info_key_e key, void* userData) +{ + result r = E_SUCCESS; + String settingKey; + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + if(key == RUNTIME_INFO_KEY_REGION) + { + settingKey = _LOCALE_DATE_FORMAT; + pSettingInfo->AnnounceSettingEvent(settingKey); + settingKey = _LOCALE_DATETIME_FORMAT; + pSettingInfo->AnnounceSettingEvent(settingKey); + settingKey = _LOCALE_TIME_FORMAT; + pSettingInfo->AnnounceSettingEvent(settingKey); + settingKey = _LOCALE_COUNTRY; + pSettingInfo->AnnounceSettingEvent(settingKey); + } + else if(key == RUNTIME_INFO_KEY_LANGUAGE) + { + settingKey.Append(_LOCALE_LANGUAGE); + pSettingInfo->AnnounceSettingEvent(settingKey); + } + else if(key == RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED) + { + settingKey = _LOCALE_DATETIME_FORMAT; + pSettingInfo->AnnounceSettingEvent(settingKey); + settingKey = _LOCALE_TIME_FORMAT; + pSettingInfo->AnnounceSettingEvent(settingKey); + settingKey = _LOCALE_TIME_FORMAT_24HOUR; + } + r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingLocaleProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + result r = E_SUCCESS; + String settingKey; + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + if (strcmp(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_LOCALE_WEEK_FORMAT_FIRSTDAY); + } + else if (strcmp(VCONFKEY_SYSTEM_TIME_CHANGED, vconf_keynode_get_name(node)) == 0) + { + settingKey = _LOCALE_DATETIME; + pSettingInfo->AnnounceSettingEvent(settingKey); + settingKey = _LOCALE_DATE; + pSettingInfo->AnnounceSettingEvent(settingKey); + settingKey = _LOCALE_TIME; + } + else if (strcmp(VCONFKEY_SETAPPL_TIMEZONE_ID, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_LOCALE_TIMEZONE); + } + else if (strcmp(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_LOCALE_UPDATE_AUTO); + } + else + { + return; + } + + r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +bool +_SettingLocaleProvider::IsValidLocaleString(const Tizen::Base::String& localeString, const icu::Locale& icuLocale) +{ + int indexOfScript = -1; + int indexOfCountryCode = -1; + + localeString.IndexOf(L"-", 0, indexOfScript); + localeString.IndexOf(L"_", 0, indexOfCountryCode); + + SysTryReturnResult(NID_SYS, indexOfCountryCode == 3 || (indexOfScript == 3 && indexOfCountryCode == 8) + , E_INVALID_ARG, "localeString %ls is invalid.", localeString.GetPointer()); + + // Tizen locale format languageCode-scriptCode_countryCode (ex: aze-latn_AZ) + String languageCode; + String scriptCode; + String countryCode; + + localeString.SubString(0, 3, languageCode); + + if (indexOfScript == 3) + { + localeString.SubString(4, 4, scriptCode); + } + + int countryCodeLength = (localeString.Contains(L"419") == true) ? 3 : 2; + int countryCodeIndex = (indexOfCountryCode == 3) ? 4 : 9; + + localeString.SubString(countryCodeIndex, countryCodeLength, countryCode); + + // icu locale format languageCode_ScriptCode_countryCode (ex: az_Latn_AZ) + String icuLanguageCode(icuLocale.getISO3Language()); + String icuScriptCode(icuLocale.getScript()); + String icuCountryCode(icuLocale.getCountry()); + + if (!icuScriptCode.IsEmpty()) + { + icuScriptCode.ToLowerCase(); + } + + if (languageCode == icuLanguageCode && scriptCode == icuScriptCode && countryCode == icuCountryCode) + { + return true; + } + + return false; +} + +bool +_SettingLocaleProvider::IsSupportedDisplayLanguageLocale(const char* localeId) +{ + xmlDocPtr doc = null; + xmlNodePtr cur = null; + + doc = xmlParseFile(_LANGUAGE_LIST_FILE_PATH); + SysTryCatch(NID_SYS, doc != null, , E_FILE_NOT_FOUND, "[E_FILE_NOT_FOUND] It is failed to get the langlist from the resource."); + + cur = xmlDocGetRootElement(doc); + SysTryCatch(NID_SYS, cur != null, , E_EMPTY_BODY, "[E_EMPTY_BODY] It is empty document."); + SysTryCatch(NID_SYS, xmlStrcmp(cur->name, (const xmlChar *) "langlist") == 0, , E_INVALID_CONTENT, "[E_INVALID_CONTENT] The document is wrong type"); + + cur = cur->xmlChildrenNode; + + for (xmlNodePtr cur_node = cur; cur_node; cur_node = cur_node->next) + { + if (cur_node->type == XML_ELEMENT_NODE) + { + char* pLocId = (char*)xmlGetProp(cur_node, (const xmlChar *)"id"); + if (!strcmp(localeId, pLocId)) + { + xmlFreeDoc(doc); + return true; + } + } + } + +CATCH: + if (doc) + { + xmlFreeDoc(doc); + } + return false; +} + +bool +_SettingLocaleProvider::IsSupportedRegionLocale(const char* localeId) +{ + locale_t cLoc = newlocale(LC_ALL_MASK, localeId, null); + if (cLoc == (locale_t)null) + { + return false; + } + freelocale(cLoc); + return true; +} + +} } diff --git a/src/system-server/setting/providers/FSys_SettingLocaleProvider.h b/src/system-server/setting/providers/FSys_SettingLocaleProvider.h new file mode 100644 index 0000000..d7b3cf3 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingLocaleProvider.h @@ -0,0 +1,64 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingLocaleProvider.h + * @brief This is the header file for the %_SettingLocaleProvider class. + * + * This header file contains the declarations of the %_SettingLocaleProvider class. + */ + +#ifndef _FSYS_SETTING_LOCALE_PROVIDER_H_ +#define _FSYS_SETTING_LOCALE_PROVIDER_H_ + +#include +#include + +#include "FSys_ISettingProvider.h" +#include "FSys_Icu.h" + +namespace Tizen { namespace System +{ + +class _SettingLocaleProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingLocaleProvider(); + virtual ~_SettingLocaleProvider(); + +public: + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValue(const Tizen::Base::String& key, const bool value); + + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValue(const Tizen::Base::String& key, const Tizen::Base::String value); + + bool HasKey(const Tizen::Base::String& key); + + bool IsValidLocaleString(const Tizen::Base::String& localeString, const icu::Locale& icuLocale); + bool IsSupportedDisplayLanguageLocale(const char* localeId); + bool IsSupportedRegionLocale(const char* localeId); +private: + _Icu __icu; +private: + static void SettingEventRuntimeInfo(runtime_info_key_e key, void* userData); + static void SettingEventVConf(keynode_t* node, void* userData); +}; // _SettingLocaleProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_LOCALE_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingLocationProvider.cpp b/src/system-server/setting/providers/FSys_SettingLocationProvider.cpp new file mode 100644 index 0000000..bb669f7 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingLocationProvider.cpp @@ -0,0 +1,228 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingLocationProvider.cpp + * @brief This is the implementation for the _SettingLocationProvider class. + */ + +#include +#include +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingLocationProvider.h" + +using namespace Tizen::App; +using namespace Tizen::Base; + +namespace Tizen { namespace System +{ + +static const wchar_t* _LOCATION_GPS = L"http://tizen.org/setting/location.gps"; +static const wchar_t* _LOCATION_GPS_ADVANCED = L"http://tizen.org/setting/location.gps.advanced"; +static const wchar_t* _LOCATION_WPS = L"http://tizen.org/setting/location.wps"; + +_SettingLocationProvider::_SettingLocationProvider() +{ + int errorCode = vconf_notify_key_changed(VCONFKEY_LOCATION_ENABLED, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_LOCATION_ENABLED event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_LOCATION_NETWORK_ENABLED, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_LOCATION_NETWORK_ENABLED event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_LOCATION_AGPS_ENABLED, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_LOCATION_AGPS_ENABLED event listener"); + } +} + + +_SettingLocationProvider::~_SettingLocationProvider() +{ + int errorCode = vconf_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_LOCATION_ENABLED event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_LOCATION_NETWORK_ENABLED, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_LOCATION_NETWORK_ENABLED event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_LOCATION_AGPS_ENABLED, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_LOCATION_AGPS_ENABLED event listener"); + } +} + +result +_SettingLocationProvider::GetValue(const String& key, bool& value) +{ + result r = E_OBJ_NOT_FOUND; + int errorCode = 0; + + if (key == _LOCATION_GPS) + { + int gps_value = 0; + errorCode = vconf_get_int(VCONFKEY_LOCATION_ENABLED, &gps_value); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_LOCATION_ENABLED vconf."); + if(gps_value == 0) + { + value = false; + } + else + { + value = true; + } + } + else if (key == _LOCATION_GPS_ADVANCED) + { + int agps = 0; + errorCode = vconf_get_int(VCONFKEY_LOCATION_AGPS_ENABLED, &agps); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL vconf."); + + if(agps == 0) + { + value = false; + } + else + { + value = true; + } + + return r; + } + else if (key == _LOCATION_WPS) + { + int wps_value = 0; + errorCode = vconf_get_int(VCONFKEY_LOCATION_NETWORK_ENABLED, &wps_value); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get the VCONFKEY_LOCATION_NETWORK_ENABLED"); + if(wps_value == 0) + { + value = false; + } + else + { + value = true; + } + + } + return r; +} + +result +_SettingLocationProvider::SetValueForPrivilegedKey(const String& key, bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _LOCATION_GPS) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support GPS feature."); + r = E_SUCCESS; + if(value == true) + { + errorCode = vconf_set_int(VCONFKEY_LOCATION_ENABLED, 1); + } + else + { + errorCode = vconf_set_int(VCONFKEY_LOCATION_ENABLED, 0); + } + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_LOCATION_ENABLED vconf"); + } + else if(key == _LOCATION_WPS) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support WPS feature."); + r = E_SUCCESS; + if(value == true) + { + errorCode = vconf_set_int(VCONFKEY_LOCATION_NETWORK_ENABLED, 1); + } + else + { + errorCode = vconf_set_int(VCONFKEY_LOCATION_NETWORK_ENABLED, 0); + } + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_LOCATION_NETWORK_ENABLED vconf"); + } + else if(key == _LOCATION_GPS_ADVANCED) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Advanced GPS feature."); + r = E_SUCCESS; + if(value == true) + { + errorCode = vconf_set_int(VCONFKEY_LOCATION_AGPS_ENABLED, 1); + } + else + { + errorCode = vconf_set_int(VCONFKEY_LOCATION_AGPS_ENABLED, 0); + } + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_LOCATION_AGPS_ENABLED vconf"); + } + return r; +} + +bool +_SettingLocationProvider::HasKey(const Tizen::Base::String& key) +{ + if(key == _LOCATION_GPS || key == _LOCATION_WPS || key == _LOCATION_GPS_ADVANCED) + { + return true; + } + return false; +} + +void +_SettingLocationProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + String settingKey; + + if (strcmp(VCONFKEY_LOCATION_ENABLED, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_LOCATION_GPS); + } + else if (strcmp(VCONFKEY_LOCATION_NETWORK_ENABLED, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_LOCATION_WPS); + } + else if (strcmp(VCONFKEY_LOCATION_AGPS_ENABLED, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_LOCATION_GPS_ADVANCED); + } + else + { + return; + } + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +} } diff --git a/src/system-server/setting/providers/FSys_SettingLocationProvider.h b/src/system-server/setting/providers/FSys_SettingLocationProvider.h new file mode 100644 index 0000000..7027159 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingLocationProvider.h @@ -0,0 +1,53 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingLocationProvider.h + * @brief This is the header file for the %_SettingLocationProvider class. + * + * This header file contains the declarations of the %_SettingLocationProvider class. + */ + +#ifndef _FSYS_SETTING_LOCATION_PROVIDER_H_ +#define _FSYS_SETTING_LOCATION_PROVIDER_H_ + +#include + +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingLocationProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingLocationProvider(); + virtual ~_SettingLocationProvider(); + +public: + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValueForPrivilegedKey(const Tizen::Base::String& key, bool value); + + bool HasKey(const Tizen::Base::String& key); + +private: + static void SettingEventVConf(keynode_t* node, void* userData); +}; // _SettingLocationProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_LOCATION_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingNetworkProvider.cpp b/src/system-server/setting/providers/FSys_SettingNetworkProvider.cpp new file mode 100644 index 0000000..2bd5817 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingNetworkProvider.cpp @@ -0,0 +1,1342 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingNetworkProvider.cpp + * @brief This is the implementation for the _SettingNetworkProvider class. + */ + +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include + +#include "FSys_SystemInfo.h" +#include "FSys_SettingNetworkProvider.h" + +using namespace std; + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base; +using namespace Utility; + +namespace Tizen { namespace System +{ +//Network Telephony +static const wchar_t* _NETWORK_FLIGHTMODE = L"http://tizen.org/setting/network.flight_mode"; +static const wchar_t* _NETWORK_TELEPHONY_PACKETSERVICE = L"http://tizen.org/setting/network.telephony.packet_service"; +static const wchar_t* _NETWORK_TELEPHONY_ROAMING = L"http://tizen.org/setting/network.telephony.roaming"; +static const wchar_t* _SYSTEM_TELEPHONY = L"http://tizen.org/feature/network.telephony"; + +//Network Wi-Fi +static const wchar_t* _NETWORK_WIFI = L"http://tizen.org/setting/network.wifi"; +static const wchar_t* _NETWORK_WIFI_NOTIFICATION = L"http://tizen.org/setting/network.wifi.notification"; +static const wchar_t* _NETWORK_WIFI_TETHERING = L"http://tizen.org/setting/network.wifi.tethering"; +static const wchar_t* _NETWORK_WIFI_TETHERING_HIDE = L"http://tizen.org/setting/network.wifi.tethering.hide"; +static const wchar_t* _NETWORK_WIFI_TETHERING_SECURITY = L"http://tizen.org/setting/network.wifi.tethering.security"; +static const wchar_t* _NETWORK_WIFI_TETHERING_SECURITY_PASSWORD = L"http://tizen.org/setting/network.wifi.tethering.security.password"; +static const wchar_t* _USB_TETHERING = L"http://tizen.org/setting/usb.tethering"; //Especially, USB tethering is covered by this provider. +static const wchar_t* _NETWORK_WIFI_DIRECT = L"http://tizen.org/setting/network.wifi.direct"; + +static const wchar_t* _SYSTEM_NETWORK_WIFI_DIRECT = L"http://tizen.org/feature/network.wifi.direct"; +static const wchar_t* _SYSTEM_NETWORK_WIFI = L"http://tizen.org/feature/network.wifi"; + +//Network Bluetooth +static const wchar_t* _NETWORK_BLUETOOTH = L"http://tizen.org/setting/network.bluetooth"; +static const wchar_t* _NETWORK_BLUETOOTH_TETHERING = L"http://tizen.org/setting/network.bluetooth.tethering"; + +static const wchar_t* _SYSTEM_NETWORK_BLUETOOTH = L"http://tizen.org/feature/network.bluetooth"; + +static const wchar_t* _NETWORK_RESULT_SUCCESS = L"osp.system.result.success"; +static const wchar_t* _NETWORK_RESULT_SYSTEM = L"osp.system.result.system"; + +struct charDeleter +{ + void operator()(char* pValue) + { + if(pValue != null) + { + free(pValue); + pValue = null; + } + } +}; + +_SettingNetworkProvider::_SettingNetworkProvider() + : __tapiHandle(null) + , __pWifiDllHandle(null) + , __pBluetoothDllHandle(null) + , __stateOfFlightMode(0) + , __stateOfWifi(0) + , __stateOfWifiDirect(0) + , __stateOfBluetooth(0) + , __flightModeEnabled(false) + , __networkBluetoothEnabled(false) + , __wifiInit(false) + , __wifiDirectInit(false) + , __pWifiListener(null) + , __pWifiDirectListener(null) + , __pFlightModeListener(null) + , __pBluetoothListener(null) +{ + int errorCode = bt_initialize(); + if(errorCode != 0) + { + //For multiple usage, deinitialize should not be called when it terminated. + SysLogException(NID_SYS, E_SYSTEM, "It is failed to initialize bluetooth."); + } + + errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED, SettingEventRuntimeInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register flight mode event listener"); + } + + errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_PACKET_DATA_ENABLED, SettingEventRuntimeInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register packet data event listener"); + } + + errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED, SettingEventRuntimeInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register roaming event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_WIFI_STATE, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_WIFI_STATE listener"); + } + + errorCode = tethering_create(&__tetheringHandle); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to create tethering handle"); + } + + errorCode = tethering_set_enabled_cb(__tetheringHandle, TETHERING_TYPE_USB, SettingEventTetheringEnabled, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register TETHERING_TYPE_USB listener"); + } + + errorCode = tethering_set_enabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI, SettingEventTetheringEnabled, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register TETHERING_TYPE_WIFI listener"); + } + + errorCode = tethering_set_enabled_cb(__tetheringHandle, TETHERING_TYPE_BT, SettingEventTetheringEnabled, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register TETHERING_TYPE_BT listener"); + } + + errorCode = tethering_set_disabled_cb(__tetheringHandle, TETHERING_TYPE_USB, SettingEventTetheringDisabled, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register TETHERING_TYPE_USB listener"); + } + + errorCode = tethering_set_disabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI, SettingEventTetheringDisabled, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register TETHERING_TYPE_WIFI listener"); + } + + errorCode = tethering_set_disabled_cb(__tetheringHandle, TETHERING_TYPE_BT, SettingEventTetheringDisabled, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register TETHERING_TYPE_BT listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_WIFI_DIRECT_STATE, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_WIFI_DIRECT_STATE listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_BT_STATUS, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_BT_STATUS listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_MOBILE_HOTSPOT_SECURITY, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_MOBILE_HOTSPOT_SECURITY listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_MOBILE_HOTSPOT_HIDE, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_MOBILE_HOTSPOT_HIDE listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_WIFI_ENABLE_QS, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_WIFI_ENABLE_QS listener"); + } + + errorCode = bt_adapter_set_state_changed_cb(SettingEventBluetooth, (void*)this); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register bluetooth listener"); + } + + if(__wifiInit == false) + { + SysLog(NID_SYS, "wifi init is started"); + errorCode = wifi_initialize(); + SysLog(NID_SYS, "wifi init result is %d", errorCode); + __wifiInit = true; + } +} + + +_SettingNetworkProvider::~_SettingNetworkProvider() +{ + int errorCode = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister flight mode event listener"); + } + + errorCode = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_PACKET_DATA_ENABLED); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister packet data event listener"); + } + + errorCode = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister roaming event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_WIFI_STATE listener"); + } + + errorCode = tethering_unset_enabled_cb(__tetheringHandle, TETHERING_TYPE_USB); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister TETHERING_TYPE_USB listener"); + } + + errorCode = tethering_unset_enabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister TETHERING_TYPE_WIFI listener"); + } + + errorCode = tethering_unset_enabled_cb(__tetheringHandle, TETHERING_TYPE_BT); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister TETHERING_TYPE_BT listener"); + } + + errorCode = tethering_unset_disabled_cb(__tetheringHandle, TETHERING_TYPE_USB); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister TETHERING_TYPE_USB listener"); + } + + errorCode = tethering_unset_disabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister TETHERING_TYPE_WIFI listener"); + } + + errorCode = tethering_unset_disabled_cb(__tetheringHandle, TETHERING_TYPE_BT); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister TETHERING_TYPE_BT listener"); + } + + tethering_destroy(__tetheringHandle); + __tetheringHandle = null; + + errorCode = vconf_ignore_key_changed(VCONFKEY_WIFI_DIRECT_STATE, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_WIFI_DIRECT_STATE listener"); + } + errorCode = vconf_ignore_key_changed(VCONFKEY_BT_STATUS, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_BT_STATUS listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_MOBILE_HOTSPOT_SECURITY, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_MOBILE_HOTSPOT_SECURITY listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_MOBILE_HOTSPOT_HIDE, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_MOBILE_HOTSPOT_HIDE listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_WIFI_ENABLE_QS, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_WIFI_ENABLE_QS listener"); + } + + errorCode = bt_adapter_unset_state_changed_cb(); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister bluetooth listener"); + } + + errorCode = bt_deinitialize(); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to deinitialize bluetooth."); + } + + if(__wifiDirectInit == true) + { + errorCode = wifi_direct_unset_device_state_changed_cb(); + if(errorCode == WIFI_DIRECT_ERROR_NONE) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister Wi-Fi direct callback."); + } + + errorCode = wifi_direct_deinitialize(); + if(errorCode == WIFI_DIRECT_ERROR_NONE) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to deinitialize Wi-Fi direct."); + } + SysLog(NID_SYS, "Wifi direct de-init result is %d.", errorCode); + __wifiDirectInit = false; + } + + if(__wifiInit == true) + { + errorCode = wifi_deinitialize(); + if(errorCode == WIFI_ERROR_NONE) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to deinitialize Wi-Fi."); + } + SysLog(NID_SYS, "Wifi de-init result is %d.", errorCode); + __wifiInit = false; + } + SysLog(NID_SYS, "Network Provider is terminated properly."); +} + +result +_SettingNetworkProvider::GetValue(const String& key, bool& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _NETWORK_FLIGHTMODE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support flightmode feature."); + bool flightModeEnabled = false; + r = E_SUCCESS; + errorCode = runtime_info_get_value_bool(RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED, &flightModeEnabled); + SysTryReturnResult(NID_SYS, errorCode == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "It is failed to get the RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED"); + value = flightModeEnabled; + } + else if(key == _NETWORK_TELEPHONY_PACKETSERVICE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Telephony packet service feature."); + bool packetServiceAllowed = false; + r = E_SUCCESS; + errorCode = runtime_info_get_value_bool(RUNTIME_INFO_KEY_PACKET_DATA_ENABLED, &packetServiceAllowed); + SysTryReturnResult(NID_SYS, errorCode == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "It is failed to get the RUNTIME_INFO_KEY_PACKET_DATA_ENABLED"); + value = packetServiceAllowed; + } + else if(key == _NETWORK_TELEPHONY_ROAMING) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Telephony roaming feature."); + bool dataRoamingEnabled = false; + r = E_SUCCESS; + errorCode = runtime_info_get_value_bool(RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED, &dataRoamingEnabled); + SysTryReturnResult(NID_SYS, errorCode == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "It is failed to get the RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED"); + value = dataRoamingEnabled; + } + else if (key == _NETWORK_WIFI) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + + bool wifiState = false; + errorCode = wifi_is_activated(&wifiState); + SysTryReturnResult(NID_SYS, errorCode == WIFI_ERROR_NONE, E_SYSTEM, "It is failed to get from wifi_is_activated."); + value = wifiState; + } + else if (key == _NETWORK_WIFI_NOTIFICATION) + { + int wifiQSState = 0; + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + + errorCode = vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &wifiQSState); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_WIFI_ENABLE_QS vconf."); + + if(wifiQSState == VCONFKEY_WIFI_QS_DISABLE) + { + value = false; + } + else + { + value = true; + } + } + else if (key == _NETWORK_WIFI_TETHERING) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi tethering feature."); + value = tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_WIFI); + } + else if (key == _NETWORK_WIFI_TETHERING_HIDE) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi tethering feature."); + errorCode = tethering_wifi_get_ssid_visibility(__tetheringHandle, &value); + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to get wifi tethering visibility state"); + } + else if (key == _NETWORK_WIFI_TETHERING_SECURITY) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi tethering feature."); + r = E_SUCCESS; + tethering_wifi_security_type_e securityType; + errorCode = tethering_wifi_get_security_type(__tetheringHandle, &securityType); + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to get wifi tethering securiy state"); + if(securityType == TETHERING_WIFI_SECURITY_TYPE_NONE) + { + value = false; + } + else + { + value = true; + } + } + else if (key == _USB_TETHERING) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support USB tethering feature."); + value = tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_USB); + } + else if (key == _NETWORK_WIFI_DIRECT) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi direct feature."); + r = E_SUCCESS; + + int isActivated = 0; + errorCode = vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &isActivated); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_WIFI_ENABLE_QS vconf."); + + if(isActivated == 1) + { + value = true; + } + else + { + value = false; + } + } + else if (key == _NETWORK_BLUETOOTH) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Bluetooth feature."); + r = E_SUCCESS; + int bluetoothStatus = VCONFKEY_BT_STATUS_OFF; + errorCode = vconf_get_int(VCONFKEY_BT_STATUS, &bluetoothStatus); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to read bluetooth status."); + + if(bluetoothStatus == VCONFKEY_BT_STATUS_OFF) + { + value = false; + } + else + { + value = true; + } + } + else if (key == _NETWORK_BLUETOOTH_TETHERING) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Bluetooth tethering feature."); + r = E_SUCCESS; + value = tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_BT); + } + return r; +} + +result +_SettingNetworkProvider::SetValue(const String& key, const bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _NETWORK_WIFI_NOTIFICATION) + { + int currentValue = 0; + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + errorCode = vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, ¤tValue); + SysTryReturnResult(NID_SYS, errorCode != -1, E_UNSUPPORTED_OPERATION, "This device does not support %ls key.", key.GetPointer()); + + if(value == true) + { + errorCode = vconf_set_int(VCONFKEY_WIFI_ENABLE_QS, VCONFKEY_WIFI_QS_ENABLE); + } + else + { + errorCode = vconf_set_int(VCONFKEY_WIFI_ENABLE_QS, VCONFKEY_WIFI_QS_DISABLE); + } + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_WIFI_ENABLE_QS vconf."); + } + else if(key == _NETWORK_WIFI_TETHERING) + { + bool state = false; + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature."); + r = GetValue(_NETWORK_WIFI, state); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the WIFI state"); + SysTryReturnResult(NID_SYS, state == true, E_INVALID_STATE, "WIFI is not activated"); + + if(value == true) + { + errorCode = tethering_enable(__tetheringHandle, TETHERING_TYPE_WIFI); + } + else + { + errorCode = tethering_disable(__tetheringHandle, TETHERING_TYPE_WIFI); + } + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to change tethering option."); + } + else if(key == _NETWORK_WIFI_TETHERING_HIDE) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + + bool currentState = false; + SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature."); + errorCode = tethering_wifi_get_ssid_visibility(__tetheringHandle, ¤tState); + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to current wifi tethering visibility setting"); + + if(value == true && currentState == false) + { + errorCode = tethering_wifi_set_ssid_visibility(__tetheringHandle, true); + } + else if(value == false && currentState == true) + { + errorCode = tethering_wifi_set_ssid_visibility(__tetheringHandle, false); + } + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to change wifi tethering visibility setting"); + } + else if(key == _NETWORK_WIFI_TETHERING_SECURITY) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + + tethering_wifi_security_type_e securityType; + SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature."); + + errorCode = tethering_wifi_get_security_type(__tetheringHandle, &securityType); + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to get wifi tethering securiy state"); + + if(value == true && securityType == TETHERING_WIFI_SECURITY_TYPE_NONE) + { + errorCode = tethering_wifi_set_security_type(__tetheringHandle, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK); + } + else if(value == false && securityType == TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK) + { + errorCode = tethering_wifi_set_security_type(__tetheringHandle, TETHERING_WIFI_SECURITY_TYPE_NONE); + } + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to change wifi tethering visibility setting"); + } + else if(key == _USB_TETHERING) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature."); + + if(value == true) + { + errorCode = tethering_enable(__tetheringHandle, TETHERING_TYPE_USB); + } + else + { + errorCode = tethering_disable(__tetheringHandle, TETHERING_TYPE_USB); + } + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to change tethering option"); + } + else if(key == _NETWORK_BLUETOOTH_TETHERING) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature."); + + bool state = false; + r = GetValue(_NETWORK_BLUETOOTH, state); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the Bluetooth state"); + SysTryReturnResult(NID_SYS, state == true, E_INVALID_STATE, "Bluetooth is not activated"); + + if(value == true) + { + errorCode = tethering_enable(__tetheringHandle, TETHERING_TYPE_BT); + } + else + { + errorCode = tethering_disable(__tetheringHandle, TETHERING_TYPE_BT); + } + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to change tethering option"); + } + return r; +} + +result +_SettingNetworkProvider::SetValueAsync(const String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener) +{ + int ret = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _NETWORK_BLUETOOTH) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Bluetooth feature."); + SysTryReturnResult(NID_SYS, __stateOfBluetooth == 0, E_IN_PROGRESS, "Bluetooth is under changing procedure."); + r = E_SUCCESS; + __stateOfBluetooth = 1; + __pBluetoothListener = listener; + + if(value == true) + { + ret = bt_adapter_enable(); + } + else + { + ret = bt_adapter_disable(); + } + + SysLog(NID_SYS, "bt_adapter returns %d.", ret); + + switch(ret) + { + case BT_ERROR_NONE: + SysLog(NID_SYS, "It is OK to change the bluetooth mode."); + break; + + case BT_ERROR_ALREADY_DONE: + case BT_ERROR_NOT_ENABLED: + SysLog(NID_SYS, "Bluetooth is already enabled."); + SettingEventBluetooth(BT_ERROR_NONE, BT_ADAPTER_ENABLED, (void*)this); + break; + + case BT_ERROR_NOW_IN_PROGRESS: + SysLog(NID_SYS, "Currently, Bluetooth change is in progress."); + __stateOfBluetooth = 0; + r = E_IN_PROGRESS; + break; + + case BT_ERROR_NOT_INITIALIZED: + default: + SysLog(NID_SYS, "There is an unknown error when changing the bluetooth mode."); + __stateOfBluetooth = 0; + r = E_SYSTEM; + break; + } + } + return r; +} + +result +_SettingNetworkProvider::SetValueForPrivilegedKey(const String& key, bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _NETWORK_TELEPHONY_PACKETSERVICE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support telephony packet service feature."); + r = E_SUCCESS; + errorCode = vconf_set_bool(VCONFKEY_3G_ENABLE, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_3G_ENABLE vconf."); + } + else if(key == _NETWORK_TELEPHONY_ROAMING) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support telephony roaming feature."); + r = E_SUCCESS; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL vconf."); + } + return r; +} + +result +_SettingNetworkProvider::SetValueAsyncForPrivilegedKey(const String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _NETWORK_FLIGHTMODE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support flightmode feature."); + r = E_SUCCESS; + + SysTryReturnResult(NID_SYS, __stateOfFlightMode == 0, E_IN_PROGRESS, "Flightmode is under changing procedure."); + __stateOfFlightMode = 1; + + bool supported = false; + int ret = system_info_get_platform_bool("tizen.org/feature/network.telephony", &supported); + SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to get system information from configration file."); + + __pFlightModeListener = listener; + if(supported == true) + { + if(__tapiHandle == null) + { + __tapiHandle = tel_init(null); + if(__tapiHandle == null) + { + __stateOfFlightMode = 0; + } + SysTryReturnResult(NID_SYS, __tapiHandle != null, E_SYSTEM, "Tapi is not ready."); + } + errorCode = tel_set_flight_mode(__tapiHandle, + value ? TAPI_POWER_FLIGHT_MODE_ENTER : TAPI_POWER_FLIGHT_MODE_LEAVE, + SettingEventFlightMode, (void*)this); + + if(errorCode != 0) + { + __stateOfFlightMode = 0; + } + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on Network Flight mode(%d).", errorCode); + } + else + { + FlightModeEnabler((void*)this); + } + } + else if(key == _NETWORK_WIFI) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + SysTryReturnResult(NID_SYS, __stateOfWifi == 0 && __stateOfWifiDirect == 0, E_IN_PROGRESS, "Wifi processing is under way."); + r = E_SUCCESS; + + __stateOfWifi = 1; + SysLog(NID_SYS, "It creates thread for wifi enable[%d].", value); + + bool wifiEnabled = false; + __pWifiListener = listener; + errorCode = wifi_is_activated(&wifiEnabled); + if(errorCode != WIFI_ERROR_NONE) + { + __stateOfWifi = 0; + SysLogException(NID_SYS, E_SYSTEM, "It is failed to get current status of WIFI."); + return E_SYSTEM; + } + + if(value == wifiEnabled) //Wi-Fi is already changed. + { + SysLog(NID_SYS, "It is try to use dummy thread"); + r = WifiDummy((void*)this); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to set Wi-Fi state."); + return r; + } + + if(value == true) + { + errorCode = wifi_activate(SettingWifiActivateCallBack, (void*) this); + } + else + { + errorCode = wifi_deactivate(SettingWifiActivateCallBack, (void*) this); + } + + if(errorCode != WIFI_ERROR_NONE) + { + __stateOfWifi = 0; + return E_SYSTEM; + } + } + else if(key == _NETWORK_WIFI_DIRECT) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature."); + SysTryReturnResult(NID_SYS, __stateOfWifi == 0 && __stateOfWifiDirect == 0, E_IN_PROGRESS, "Wifi processing is under way."); + r = E_SUCCESS; + + __stateOfWifiDirect = 1; + SysLog(NID_SYS, "It creates thread for wifi direct enable[%d].", value); + + + __pWifiDirectListener = listener; + if(__wifiDirectInit == false) + { + SysLog(NID_SYS, "wifi direct init is started"); + errorCode = wifi_direct_initialize(); + SysLog(NID_SYS, "wifi direct init result is %d", errorCode); + SysTryReturnResult(NID_SYS, errorCode == WIFI_DIRECT_ERROR_NONE, E_SYSTEM, "It is failed to init wifi direct."); + errorCode = wifi_direct_set_device_state_changed_cb(SettingWifiDirectStateChangedCallBack, (void*) this); + SysTryReturnResult(NID_SYS, errorCode == WIFI_DIRECT_ERROR_NONE, E_SYSTEM, "It is failed to register wifi direct result callback."); + __wifiDirectInit = true; + } + + + wifi_direct_state_e wifi_direct_state; + errorCode = wifi_direct_get_state(&wifi_direct_state); + if(errorCode != WIFI_DIRECT_ERROR_NONE) + { + __stateOfWifiDirect = 0; + SysLogException(NID_SYS, E_SYSTEM, "It is failed to get current status of WIFI direct."); + return E_SYSTEM; + } + + if((value == false && wifi_direct_state == WIFI_DIRECT_STATE_DEACTIVATED) + || (value == true && wifi_direct_state != WIFI_DIRECT_STATE_DEACTIVATED)) + { + SysLog(NID_SYS, "Required state is already applied."); + WifiDirectDummy((void*)this); + return E_SUCCESS; + } + + if(value == true) + { + errorCode = wifi_direct_activate(); + } + else + { + errorCode = wifi_direct_deactivate(); + } + SysLog(NID_SYS, "wifi_direct_activate result is %d. value is %d.", errorCode, value); + + if(errorCode < 0) + { + return E_SYSTEM; + } + } + return r; +} + +result +_SettingNetworkProvider::WifiDummy(void* data) +{ + result r = E_SUCCESS; + String settingKey(_NETWORK_WIFI); + _SettingNetworkProvider* pProvider = (_SettingNetworkProvider*)data; + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnResult(NID_SYS, (pSettingInfo != null && pProvider != null), E_SYSTEM, "There is no values of args."); + + SysTryCatch(NID_SYS, pProvider->__stateOfWifi == 1, r = E_SYSTEM, E_SYSTEM, "There is invalid state."); + + if(pProvider->__pWifiListener != null) + { + pProvider->__pWifiListener->OnResultReceivedForSetValueAsync(settingKey, E_SUCCESS); + } + r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryCatch(NID_SYS, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); + +CATCH: + pProvider->__stateOfWifi = 0; + return r; +} + +result +_SettingNetworkProvider::WifiDirectDummy(void* data) +{ + result r = E_SUCCESS; + String settingKey(_NETWORK_WIFI_DIRECT); + _SettingNetworkProvider* pProvider = (_SettingNetworkProvider*)data; + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnResult(NID_SYS, (pSettingInfo != null && pProvider != null), E_SYSTEM, "There is no values of args."); + SysTryCatch(NID_SYS, pProvider->__stateOfWifiDirect == 1, E_SYSTEM, E_SYSTEM, "There is invalid state."); + + if(pProvider->__pWifiDirectListener != null) + { + pProvider->__pWifiDirectListener->OnResultReceivedForSetValueAsync(settingKey, E_SUCCESS); + } + r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryCatch(NID_SYS, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); + +CATCH: + pProvider->__stateOfWifiDirect = 0; + return r; +} + +void +_SettingNetworkProvider::SettingWifiActivateCallBack(wifi_error_e errorCode, void* data) +{ + String settingKey(_NETWORK_WIFI); + + _SettingNetworkProvider* pProvider = (_SettingNetworkProvider*)data; + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, (pSettingInfo != null && pProvider != null), E_SYSTEM, "There is no values of args."); + SysTryCatch(NID_SYS, pProvider->__stateOfWifi == 1, E_SYSTEM, E_SYSTEM, "Wi-Fi processing is under way."); + + if(errorCode != WIFI_ERROR_NONE) + { + switch(errorCode) + { + case WIFI_ERROR_INVALID_PARAMETER: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by invalid param."); + break; + case WIFI_ERROR_OUT_OF_MEMORY: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by out of memory."); + break; + case WIFI_ERROR_INVALID_OPERATION: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by invalid operation."); + break; + case WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by family not supported."); + break; + case WIFI_ERROR_OPERATION_FAILED: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by operation failed."); + break; + case WIFI_ERROR_NO_CONNECTION: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by no connection."); + break; + case WIFI_ERROR_ALREADY_EXISTS: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by already exist."); + break; + case WIFI_ERROR_OPERATION_ABORTED: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by operation aborted."); + break; + case WIFI_ERROR_DHCP_FAILED: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by DHCP fail."); + break; + case WIFI_ERROR_INVALID_KEY: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by invalid key."); + break; + case WIFI_ERROR_NO_REPLY: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by no reply."); + break; + case WIFI_ERROR_SECURITY_RESTRICTED: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is failed by security restricted."); + break; + case WIFI_ERROR_NOW_IN_PROGRESS: + SysLogException(NID_SYS, E_SYSTEM, "Wifi change request is under way."); + break; + } + } + + if(pProvider->__pWifiDirectListener != null) + { + pProvider->__pWifiDirectListener->OnResultReceivedForSetValueAsync(settingKey, E_SUCCESS); + } +CATCH: + pProvider->__stateOfWifi = 0; +} + +void +_SettingNetworkProvider::SettingWifiDirectStateChangedCallBack(wifi_direct_error_e errorCode, wifi_direct_device_state_e deviceState, void* data) +{ + result r = E_SUCCESS; + String settingKey(_NETWORK_WIFI_DIRECT); + String returnValue = _NETWORK_RESULT_SUCCESS; + + _SettingNetworkProvider* pProvider = (_SettingNetworkProvider*)data; + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, (pSettingInfo != null && pProvider != null), E_SYSTEM, "There is no values of args."); + + SysTryCatch(NID_SYS, pProvider->__stateOfWifiDirect == 1 , E_SYSTEM, E_SYSTEM, "There is invalid state."); + + if(errorCode != WIFI_DIRECT_ERROR_NONE) + { + r = E_SYSTEM; + } + + if(pProvider->__pWifiDirectListener != null) + { + pProvider->__pWifiDirectListener->OnResultReceivedForSetValueAsync(settingKey, r); + } + +CATCH: + pProvider->__stateOfWifiDirect = 0; +} + +result +_SettingNetworkProvider::GetValue(const String& key, String& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if (key == _NETWORK_WIFI_TETHERING_SECURITY_PASSWORD) + { + r = E_SUCCESS; + unique_ptr password(null); + char* pTemp = null; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi tethering feature."); + + SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature."); + errorCode = tethering_wifi_get_passphrase(__tetheringHandle, &pTemp); + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE && pTemp != null, E_SYSTEM, "It is failed to get password"); + + password.reset(pTemp); + + value.Clear(); + value.Append(password.get()); + } + return r; +} + +result +_SettingNetworkProvider::SetValue(const String& key, const String value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key ==_NETWORK_WIFI_TETHERING_SECURITY_PASSWORD) + { + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi tethering feature."); + + SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature."); + unique_ptr password(_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, password != null, E_SYSTEM, "It is failed to convert String to string"); + errorCode = tethering_wifi_set_passphrase(__tetheringHandle, password.get()); + SysTryReturnResult(NID_SYS, errorCode == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to set password"); + } + return r; +} + +bool +_SettingNetworkProvider::HasKey(const String& key) +{ + bool wifi_supported = false; + bool wifi_direct_supported = false; + bool bluetooth_supported = false; + bool telephony_supported = false; + + int ret = system_info_get_platform_bool("tizen.org/feature/network.wifi", &wifi_supported); + SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to get system information from configration file."); + + ret = system_info_get_platform_bool("tizen.org/feature/network.wifi.direct", &wifi_direct_supported); + SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to get system information from configration file."); + + ret = system_info_get_platform_bool("tizen.org/feature/network.bluetooth", &bluetooth_supported); + SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to get system information from configration file."); + + ret = system_info_get_platform_bool("tizen.org/feature/network.telephony", &telephony_supported); + SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to get system information from configration file."); + + if(key == _NETWORK_FLIGHTMODE) + { + return true; + } + else if(key == _NETWORK_TELEPHONY_PACKETSERVICE || key == _NETWORK_TELEPHONY_ROAMING) + { + if(telephony_supported == true) + { + return true; + } + } + else if(key == _NETWORK_WIFI || key == _NETWORK_WIFI_NOTIFICATION) + { + if(wifi_supported == true) + { + return true; + } + } + else if(key == _NETWORK_WIFI_DIRECT) + { + if(wifi_direct_supported == true) + { + return true; + } + } + else if(key == _NETWORK_WIFI_TETHERING || key == _NETWORK_WIFI_TETHERING_HIDE + || key == _NETWORK_WIFI_TETHERING_SECURITY || key == _NETWORK_WIFI_TETHERING_SECURITY_PASSWORD || key == _USB_TETHERING) + { + bool isSupported = false; + int errorCode = system_info_get_value_bool(SYSTEM_INFO_KEY_TETHERING_SUPPORTED, &isSupported); + if(errorCode == SYSTEM_INFO_ERROR_NONE && isSupported == true) + { + return true; + } + } + else if(key == _NETWORK_BLUETOOTH) + { + if(bluetooth_supported == true) + { + return true; + } + } + else if(key == _NETWORK_BLUETOOTH_TETHERING) + { + if(__tetheringHandle != null && bluetooth_supported == true) + { + return true; + } + } + return false; +} + +void +_SettingNetworkProvider::SettingEventRuntimeInfo(runtime_info_key_e key, void* userData) +{ + String settingKey; + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "SettingInfo is not ready."); + + if(key == RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED) + { + settingKey.Append(_NETWORK_FLIGHTMODE); + } + else if(key == RUNTIME_INFO_KEY_PACKET_DATA_ENABLED) + { + settingKey.Append(_NETWORK_TELEPHONY_PACKETSERVICE); + } + else if(key == RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED) + { + settingKey.Append(_NETWORK_TELEPHONY_ROAMING); + } + else + { + SysLogException(NID_SYS, E_SYSTEM, "It is not supported key."); + return; + } + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingNetworkProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + result r = E_SUCCESS; + String settingKey; + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + if (strcmp(VCONFKEY_WIFI_STATE, vconf_keynode_get_name(node)) == 0) + { + int state = VCONFKEY_WIFI_OFF; + int errorCode = 0; + errorCode = vconf_get_int(VCONFKEY_WIFI_STATE, &state); + + if(errorCode == 0 && (state == VCONFKEY_WIFI_OFF || state == VCONFKEY_WIFI_UNCONNECTED)) + { + settingKey.Append(_NETWORK_WIFI); + r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); + } + return; + } + else if (strcmp(VCONFKEY_WIFI_ENABLE_QS, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_NETWORK_WIFI_NOTIFICATION); + } + else if (strcmp(VCONFKEY_WIFI_DIRECT_STATE, vconf_keynode_get_name(node)) == 0) + { + int state = VCONFKEY_WIFI_DIRECT_DEACTIVATED; + int errorCode = 0; + errorCode = vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &state); + SysLog(NID_SYS, "Wi-Fi Direct state is changed. %d", state); + if(errorCode == 0 && (state == VCONFKEY_WIFI_DIRECT_DEACTIVATED || state == VCONFKEY_WIFI_DIRECT_ACTIVATED)) + { + settingKey.Append(_NETWORK_WIFI_DIRECT); + r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); + } + return; + } + else if (strcmp(VCONFKEY_BT_STATUS, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_NETWORK_BLUETOOTH); + } + else if (strcmp(VCONFKEY_MOBILE_HOTSPOT_SECURITY, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_NETWORK_WIFI_TETHERING_SECURITY); + } + else if (strcmp(VCONFKEY_MOBILE_HOTSPOT_HIDE, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_NETWORK_WIFI_TETHERING_HIDE); + } + else + { + SysLogException(NID_SYS, E_SYSTEM, "It is not supported key."); + return; + } + + r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingNetworkProvider::SettingEventTetheringEnabled(tethering_error_e err, tethering_type_e type, bool is_requested, void* data) +{ + String settingKey; + SysLog(NID_SYS, "Tethering Endabled Event is occured."); + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + switch(type) + { + case TETHERING_TYPE_USB: + settingKey.Append(_USB_TETHERING); + break; + case TETHERING_TYPE_WIFI: + settingKey.Append(_NETWORK_WIFI_TETHERING); + break; + case TETHERING_TYPE_BT: + settingKey.Append(_NETWORK_BLUETOOTH_TETHERING); + break; + default: + return; + } + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingNetworkProvider::SettingEventTetheringDisabled(tethering_error_e err, tethering_type_e type, tethering_disabled_cause_e cause,void* data) +{ + SysLog(NID_SYS, "Tethering Disabled Event is occured."); + SettingEventTetheringEnabled(err, type, false, null); +} + +void +_SettingNetworkProvider::SettingEventFlightMode(TapiHandle* handle, int res, void* data, void* user_data) +{ + String settingKey(_NETWORK_FLIGHTMODE); + int errorCode = 0; + result r = E_SUCCESS; + SysLog(NID_SYS, "Flightmode response is handle:%x, res:%d, date:%x, user_data:%x", handle, res, data, user_data); + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "SettingInfo is not ready."); + _SettingNetworkProvider* pProvider = (_SettingNetworkProvider*)user_data; + SysTryReturnVoidResult(NID_SYS, pProvider != null, E_SYSTEM, "There is invalid provider."); + SysTryCatch(NID_SYS, pProvider->__stateOfFlightMode == 1, E_SYSTEM, E_SYSTEM, "Current state of flight mode is not valid."); + + switch (res) + { + case TAPI_POWER_FLIGHT_MODE_RESP_ON: + SysLog(NID_SYS, "It successes to change flight mode on"); + + errorCode = vconf_set_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, true); + if (errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to set on VCONFKEY_TELEPHONY_FLIGHT_MODE vconf."); + r = E_SYSTEM; + } + break; + case TAPI_POWER_FLIGHT_MODE_RESP_OFF: + SysLog(NID_SYS, "It successes to change flight mode off"); + + errorCode = vconf_set_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, false); + if (errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to set on VCONFKEY_TELEPHONY_FLIGHT_MODE vconf."); + r = E_SYSTEM; + } + break; + case TAPI_POWER_FLIGHT_MODE_RESP_FAIL: + default: + SysLogException(NID_SYS, E_SYSTEM, "It is failed to change flight mode"); + r = E_SYSTEM; + } + + if(pProvider->__pFlightModeListener != null) + { + pProvider->__pFlightModeListener->OnResultReceivedForSetValueAsync(settingKey, r); + } + +CATCH: + pProvider->__stateOfFlightMode = 0; +} + +result +_SettingNetworkProvider::FlightModeEnabler(void* data) +{ + result r = E_SUCCESS; + int errorCode = 0; + String settingKey(_NETWORK_FLIGHTMODE); + + _SettingNetworkProvider* pProvider = (_SettingNetworkProvider*)data; + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnResult(NID_SYS, pProvider != null && pSettingInfo != null, E_SYSTEM, "Provider or SettingInfo is not ready."); + SysTryCatch(NID_SYS, pProvider->__stateOfFlightMode == 1, E_SYSTEM, E_SYSTEM, "Current state of flight mode is not valid."); + + errorCode = vconf_set_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, pProvider->__flightModeEnabled); + if (errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to set on VCONFKEY_TELEPHONY_FLIGHT_MODE vconf."); + r = E_SYSTEM; + } + + + if(pProvider->__pFlightModeListener != null) + { + pProvider->__pFlightModeListener->OnResultReceivedForSetValueAsync(settingKey, r); + } + +CATCH: + pProvider->__stateOfFlightMode = 0; + return r; +} + +void +_SettingNetworkProvider::SettingEventBluetooth(int res, bt_adapter_state_e adapter_state, void* user_data) +{ + String settingKey(_NETWORK_BLUETOOTH); + result r = E_SUCCESS; + SysLog(NID_SYS, "Bluetooth callback is invoked. result:%d, adapter_state:%d, user_data:%x", res, adapter_state, user_data); + + _SettingNetworkProvider* pProvider = (_SettingNetworkProvider*)user_data; + SysTryReturnVoidResult(NID_SYS, pProvider != null, E_SYSTEM, "There is no values of args."); + SysTryCatch(NID_SYS, pProvider->__stateOfBluetooth == 1, E_SYSTEM, E_SYSTEM, "Bluetooth processing is under way."); + + if(res == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + else + { + r = E_SYSTEM; + } + + if(pProvider->__pBluetoothListener != null && pProvider->__stateOfBluetooth == 1) + { + pProvider->__pBluetoothListener->OnResultReceivedForSetValueAsync(settingKey, r); + } + + if(r == E_SUCCESS) + { + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryCatch(NID_SYS, pSettingInfo != null, E_SYSTEM, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryCatch(NID_SYS, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); + } + +CATCH: + pProvider->__stateOfBluetooth = 0; +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingNetworkProvider.h b/src/system-server/setting/providers/FSys_SettingNetworkProvider.h new file mode 100644 index 0000000..3c7dacd --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingNetworkProvider.h @@ -0,0 +1,106 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingNetworkProvider.h + * @brief This is the header file for the %_SettingNetworkProvider class. + * + * This header file contains the declarations of the %_SettingNetworkProvider class. + */ + +#ifndef _FSYS_SETTING_NETWORK_PROVIDER_H_ +#define _FSYS_SETTING_NETWORK_PROVIDER_H_ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "FSys_SettingInfo.h" +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingNetworkProvider + : _ISettingProvider +{ +public: + _SettingNetworkProvider(); + virtual ~_SettingNetworkProvider(); + +public: + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValue(const Tizen::Base::String& key, const bool value); + result SetValueAsync(const Tizen::Base::String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener); + result SetValueForPrivilegedKey(const Tizen::Base::String& key, bool value); + result SetValueAsyncForPrivilegedKey(const Tizen::Base::String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener); + + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValue(const Tizen::Base::String& key, const Tizen::Base::String value); + + bool HasKey(const Tizen::Base::String& key); + +private: + result FlightModeEnabler(void* data); + result WifiDummy(void* data); + result WifiDirectDummy(void* data); + + static void SettingEventFlightMode(TapiHandle* handle, int res, void* data, void* user_data); + static void SettingEventRuntimeInfo(runtime_info_key_e key, void* userData); + static void SettingEventVConf(keynode_t* node, void* userData); + static void SettingEventTetheringEnabled(tethering_error_e tetheringErr, tethering_type_e deviceType, bool isRequested, void* data); + static void SettingEventTetheringDisabled(tethering_error_e tetheringErr, tethering_type_e deviceType, tethering_disabled_cause_e tetheringCause, void* data); + static void SettingEventBluetooth(int result, bt_adapter_state_e adapter_state, void* user_data); + + static void SettingWifiActivateCallBack(wifi_error_e errorCode, void* data); + static void SettingWifiDirectStateChangedCallBack(wifi_direct_error_e errorCode, wifi_direct_device_state_e deviceState, void* data); + +private: + TapiHandle* __tapiHandle; + void* __pWifiDllHandle; + void* __pBluetoothDllHandle; + tethering_h __tetheringHandle; + + int __stateOfFlightMode; + int __stateOfWifi; + int __stateOfWifiDirect; + int __stateOfBluetooth; + + bool __flightModeEnabled; + bool __networkBluetoothEnabled; + + bool __wifiInit; + bool __wifiDirectInit; + + ISettingInfoSetValueAsyncResultListener* __pWifiListener; + ISettingInfoSetValueAsyncResultListener* __pWifiDirectListener; + ISettingInfoSetValueAsyncResultListener* __pFlightModeListener; + ISettingInfoSetValueAsyncResultListener* __pBluetoothListener; +}; // _SettingNetworkProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_NETWORK_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingScreenProvider.cpp b/src/system-server/setting/providers/FSys_SettingScreenProvider.cpp new file mode 100644 index 0000000..e1c81a4 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingScreenProvider.cpp @@ -0,0 +1,466 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingScreenProvider.cpp + * @brief This is the implementation for the _SettingScreenProvider class. + */ + +#include +#include + +#include +#include +#include +#include + +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingScreenProvider.h" + +using namespace std; + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Utility; +using namespace Tizen::Io; + +namespace Tizen { namespace System +{ + +static const wchar_t* _SCREEN_WALLPAPER = L"http://tizen.org/setting/screen.wallpaper"; +static const wchar_t* _SCREEN_WALLPAPER_LOCK = L"http://tizen.org/setting/screen.wallpaper.lock"; +static const wchar_t* _SCREEN_BRIGHTNESS = L"http://tizen.org/setting/screen.brightness"; +static const wchar_t* _SCREEN_BRIGHTNESS_AUTO = L"http://tizen.org/setting/screen.brightness.auto"; +static const wchar_t* _SCREEN_BACKLIGHT_TIME = L"http://tizen.org/setting/screen.backlight.time"; +static const wchar_t* _SCREEN_ROTATION_AUTO = L"http://tizen.org/setting/screen.rotation.auto"; +static const wchar_t* _SCREEN_MODE = L"http://tizen.org/setting/screen.mode"; + +static const wchar_t* _SCREEN_MODE_DYNAMIC = L"Dynamic"; +static const wchar_t* _SCREEN_MODE_STANDARD = L"Standard"; +static const wchar_t* _SCREEN_MODE_NATURAL = L"Natural"; +static const wchar_t* _SCREEN_MODE_MOVIE = L"Movie"; +static const char* _SCREEN_MODE_VCONFKEY = VCONFKEY_SETAPPL_PREFIX"/screenmode/selected_name"; + +struct charDeleter +{ + void operator()(char* pValue) + { + if(pValue != null) + { + free(pValue); + pValue = null; + } + } +}; + +_SettingScreenProvider::_SettingScreenProvider() +{ + int errorCode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, SettingEventSettingInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register wallpaper event listener"); + } + + errorCode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, SettingEventSettingInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register lock wallpaper event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_LCD_BRIGHTNESS event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL event listener"); + } + + errorCode = vconf_notify_key_changed(_SCREEN_MODE_VCONFKEY, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register _SCREEN_MODE_VCONFKEY event listener"); + } +} + + +_SettingScreenProvider::~_SettingScreenProvider() +{ + int errorCode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister wallpaper event listener"); + } + + errorCode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister lock wallpaper event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_LCD_BRIGHTNESS event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL event listener"); + } + + errorCode = vconf_ignore_key_changed(_SCREEN_MODE_VCONFKEY, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister _SCREEN_MODE_VCONFKEY event listener"); + } +} + +result +_SettingScreenProvider::GetValue(const String& key, bool& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if (key == _SCREEN_BRIGHTNESS_AUTO) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support brightness auto control feature."); + r = E_SUCCESS; + int brightnessAuto = 0; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &brightnessAuto); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on SETAPPL_BRIGHTNESS_AUTOMATIC_INT vconf"); + + if(brightnessAuto == 0) + { + value = false; + } + else + { + value = true; + } + } + else if (key == _SCREEN_ROTATION_AUTO) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support auto ratation feature."); + r = E_SUCCESS; + int autoRotate = false; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, &autoRotate); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL vconf"); + if(autoRotate == 1) + { + value = true; + } + else + { + value = false; + } + } + return r; +} + +result +_SettingScreenProvider::SetValue(const String& key, const bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _SCREEN_BRIGHTNESS_AUTO) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support brightness auto control feature."); + r = E_SUCCESS; + if(value == true) + { + errorCode = vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_ON); + } + else + { + errorCode = vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_OFF); + } + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on SETAPPL_BRIGHTNESS_AUTOMATIC_INT vconf"); + } + else if(key == _SCREEN_ROTATION_AUTO) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support auto ratation feature."); + r = E_SUCCESS; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL vconf"); + } + return r; +} + +result +_SettingScreenProvider::GetValue(const String& key, int& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if (key == _SCREEN_BRIGHTNESS) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support brightness feature."); + r = E_SUCCESS; + int brightness = 0; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_LCD_BRIGHTNESS vconf"); + value = brightness; + } + else if (key == _SCREEN_BACKLIGHT_TIME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen backlight time feature."); + r = E_SUCCESS; + int timeout = 0; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, &timeout); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_TIMEOUT_NORMAL vconf"); + value = timeout; + } + return r; +} + +result +_SettingScreenProvider::SetValue(const String& key, const int value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _SCREEN_BRIGHTNESS) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support brightness feature."); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, value > 0 && value <= 100, E_INVALID_ARG, "Out of range"); + + errorCode = vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_LCD_BRIGHTNESS vconf"); + + errorCode = device_set_brightness_from_settings(0); + if(errorCode != 0) + { + SysLog(NID_SYS, "It is failed to update screen brightness."); + } + } + else if(key == _SCREEN_BACKLIGHT_TIME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen backlight time feature."); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, value == 15 || value == 30 || value == 60 || value == 120 || value == 300 || value == 600, E_INVALID_ARG, "Out of range"); + + errorCode = vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL vconf"); + } + return r; +} + +result +_SettingScreenProvider::GetValue(const String& key, String& value) +{ + int errorCode = 0; + result r = E_SUCCESS; + + if(key == _SCREEN_WALLPAPER) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support wallpaper feature."); + r = E_SUCCESS; + char* pWallpaper = null; + errorCode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &pWallpaper); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get wallpaper of home screen"); + + r = StringUtil::Utf8ToString(pWallpaper, value); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r)); + + free(pWallpaper); + } + else if (key == _SCREEN_WALLPAPER_LOCK) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support wallpaper feature."); + r = E_SUCCESS; + unique_ptr pWallpaper(null); + char* pTemp = null; + + errorCode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, &pTemp); + SysTryReturnResult(NID_SYS, errorCode == 0 && pTemp != null, E_SYSTEM, "It is failed to get wallpaper of lock screen"); + + pWallpaper.reset(pTemp); + + r = StringUtil::Utf8ToString(pWallpaper.get(), value); + SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r)); + } + else if (key == _SCREEN_MODE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen mode feature."); + r = E_SUCCESS; + unique_ptr curmode(vconf_get_str(_SCREEN_MODE_VCONFKEY)); + value.Clear(); + value.Append(curmode.get()); + } + return r; +} + +result +_SettingScreenProvider::SetValue(const String& key, const String value) +{ + int errorCode = 0; + result r = E_SUCCESS; + + if(key == _SCREEN_WALLPAPER) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support wallpaper feature."); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, File::IsFileExist(value) == true, E_INVALID_ARG, "The entry for the specified wallpaper file or the file path cannot be found"); + unique_ptr pFilePath(_StringConverter::CopyToCharArrayN(value)); + + SysTryReturnResult(NID_SYS, pFilePath.get() != null, E_SYSTEM, "It is failed to convert type of filePath"); + + errorCode = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, pFilePath.get()); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set wallpaper of home screen"); + } + else if(key == _SCREEN_WALLPAPER_LOCK) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support wallpaper feature."); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, File::IsFileExist(value) == true, E_INVALID_ARG, "The entry for the specified wallpaper lock file or the file path cannot be found"); + unique_ptr pFilePath(_StringConverter::CopyToCharArrayN(value)); + SysTryReturnResult(NID_SYS, pFilePath.get() != null, E_SYSTEM, "It is failed to convert type of filePath"); + + errorCode = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, pFilePath.get()); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set wallpaper of home screen"); + } + else if(key == _SCREEN_MODE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen mode feature."); + r = E_SUCCESS; + SysTryReturnResult(NID_SYS, value == _SCREEN_MODE_DYNAMIC || value == _SCREEN_MODE_STANDARD || value == _SCREEN_MODE_NATURAL || value == _SCREEN_MODE_MOVIE, E_INVALID_ARG, "designated value(%ls) is invalid", value.GetPointer()); + unique_ptr screenMode(_StringConverter::CopyToCharArrayN(value)); + errorCode = vconf_set_str(_SCREEN_MODE_VCONFKEY, screenMode.get()); + + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to change screen mode."); + } + return r; +} + +bool +_SettingScreenProvider::HasKey(const Tizen::Base::String& key) +{ + + if(key == _SCREEN_WALLPAPER || key == _SCREEN_WALLPAPER_LOCK) + { + return true; + } + else if(key == _SCREEN_BRIGHTNESS || key ==_SCREEN_BRIGHTNESS_AUTO) + { + return true; + } + else if(key == _SCREEN_BACKLIGHT_TIME) + { + return true; + } + else if(key == _SCREEN_ROTATION_AUTO) + { + return true; + } + else if(key == _SCREEN_MODE) + { + return true; + } + return false; +} + +void +_SettingScreenProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + String settingKey; + + if (strcmp(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SCREEN_BRIGHTNESS); + } + else if (strcmp(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SCREEN_BRIGHTNESS_AUTO); + } + else if (strcmp(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SCREEN_BACKLIGHT_TIME); + } + else if (strcmp(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SCREEN_ROTATION_AUTO); + } + else if (strcmp(_SCREEN_MODE_VCONFKEY, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SCREEN_MODE); + } + else + { + return; + } + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingScreenProvider::SettingEventSettingInfo(system_settings_key_e key, void* userData) +{ + String settingKey; + + if(key == SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN) + { + settingKey.Append(_SCREEN_WALLPAPER); + } + else if(key == SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN) + { + settingKey.Append(_SCREEN_WALLPAPER_LOCK); + } + else + { + return; + } + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingScreenProvider.h b/src/system-server/setting/providers/FSys_SettingScreenProvider.h new file mode 100644 index 0000000..16353c5 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingScreenProvider.h @@ -0,0 +1,60 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingScreenProvider.h + * @brief This is the header file for the %_SettingScreenProvider class. + * + * This header file contains the declarations of the %_SettingScreenProvider class. + */ + +#ifndef _FSYS_SETTING_SCREEN_PROVIDER_H_ +#define _FSYS_SETTING_SCREEN_PROVIDER_H_ + +#include +#include + +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingScreenProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingScreenProvider(); + virtual ~_SettingScreenProvider(); + +public: + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValue(const Tizen::Base::String& key, const bool value); + + result GetValue(const Tizen::Base::String& key, int& value); + result SetValue(const Tizen::Base::String& key, const int value); + + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValue(const Tizen::Base::String& key, const Tizen::Base::String value); + + bool HasKey(const Tizen::Base::String& key); +private: + static void SettingEventVConf(keynode_t* node, void* userData); + static void SettingEventSettingInfo(system_settings_key_e key, void* userData); +}; // _SettingScreenProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_SCREEN_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingSoundProvider.cpp b/src/system-server/setting/providers/FSys_SettingSoundProvider.cpp new file mode 100644 index 0000000..1d5df81 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingSoundProvider.cpp @@ -0,0 +1,623 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingSoundProvider.cpp + * @brief This is the implementation for the _SettingSoundProvider class. + */ + +#include + +#include +#include +#include +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingSoundProvider.h" + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Utility; +using namespace Tizen::Io; + +namespace Tizen { namespace System +{ +static const wchar_t* _SOUND_MEDIA_VOLUME = L"http://tizen.org/setting/sound.media.volume"; +static const wchar_t* _SOUND_NOTIFICATION = L"http://tizen.org/setting/sound.notification"; +static const wchar_t* _SOUND_NOTIFICATION_REPEAT_PERIOD = L"http://tizen.org/setting/sound.notification.repetition_period"; +static const wchar_t* _SOUND_NOTIFICATION_REPEAT_PERIOD_ONCE = L"once"; +static const wchar_t* _SOUND_NOTIFICATION_REPEAT_PERIOD_2MIN = L"2min"; +static const wchar_t* _SOUND_NOTIFICATION_REPEAT_PERIOD_5MIN = L"5min"; +static const wchar_t* _SOUND_NOTIFICATION_REPEAT_PERIOD_10MIN = L"10min"; +static const wchar_t* _SOUND_NOTIFICATION_VOLUME = L"http://tizen.org/setting/sound.notification.volume"; +static const wchar_t* _SOUND_RINGTONE_VOLUME = L"http://tizen.org/setting/sound.ringtone.volume"; +static const wchar_t* _SOUND_SYSTEM_VOLUME = L"http://tizen.org/setting/sound.system.volume"; + +static const wchar_t* _SOUND_RINGTONE = L"http://tizen.org/setting/sound.ringtone"; +static const wchar_t* _SOUND_SILENTMODE = L"http://tizen.org/setting/sound.silent_mode"; +static const wchar_t* _SOUND_TOUCH = L"http://tizen.org/setting/sound.touch"; +static const wchar_t* _SOUND_LOCK = L"http://tizen.org/setting/sound.lock"; + +_SettingSoundProvider::_SettingSoundProvider() +{ + int errorCode = sound_manager_set_volume_changed_cb(SettingEventSoundManager, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register volume event listener."); + } + + errorCode = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, SettingEventSettingInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register ringtone event listener."); + } + + errorCode = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_SILENT_MODE_ENABLED, SettingEventRuntimeInfo, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register silent mode event listener."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL event listener."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT event listener."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_SOUND_LOCK_BOOL event listener."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT event listener."); + } +} + + +_SettingSoundProvider::~_SettingSoundProvider() +{ + sound_manager_unset_volume_changed_cb(); + + int errorCode = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister ringtone event listener."); + } + + errorCode = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_SILENT_MODE_ENABLED); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister silent mode event listener."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL event listener."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_SOUND_LOCK_BOOL event listener."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_SOUND_LOCK_BOOL event listener."); + } +} + +result +_SettingSoundProvider::GetValue(const String& key, bool& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if (key == _SOUND_SILENTMODE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + r = E_SUCCESS; + bool silentModeEnabled = false; + errorCode = runtime_info_get_value_bool(RUNTIME_INFO_KEY_SILENT_MODE_ENABLED, &silentModeEnabled); + SysTryReturnResult(NID_SYS, errorCode == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "It is failed to get the RUNTIME_INFO_KEY_SILENT_MODE_ENABLED"); + value = !silentModeEnabled; + } + else if (key == _SOUND_TOUCH) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound touch effect feature."); + r = E_SUCCESS; + int soundTouch = 0; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, &soundTouch); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL vconf"); + if(soundTouch == 0) + { + value = false; + } + else + { + value = true; + } + return r; + } + else if (key == _SOUND_LOCK) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound touch effect feature."); + r = E_SUCCESS; + + int soundLock = 0; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, &soundLock); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_SOUND_LOCK_BOO vconf"); + if(soundLock == 0) + { + value = false; + } + else + { + value = true; + } + return r; + } + return r; +} + +result +_SettingSoundProvider::SetValue(const String& key, const bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _SOUND_SILENTMODE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + r = E_SUCCESS; + bool silentMode = !value; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, silentMode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_SOUND_STATUS_BOOL vconf"); + } + else if(key == _SOUND_TOUCH) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound touch effect feature."); + r = E_SUCCESS; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL vconf"); + } + else if(key == _SOUND_LOCK) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound lock effect feature."); + r = E_SUCCESS; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_SOUND_LOCK_BOOL vconf"); + } + return r; +} + +result +_SettingSoundProvider::GetValue(const String& key, int& value) +{ + int volume = 0; + int maxVolume = 0; + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if (key == _SOUND_MEDIA_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + r = E_SUCCESS; + + errorCode = sound_manager_get_max_volume(SOUND_TYPE_MEDIA, &maxVolume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume It is failed"); + + errorCode = sound_manager_get_volume(SOUND_TYPE_MEDIA, &volume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume It is failed"); + + value = volume; + } + else if (key == _SOUND_NOTIFICATION_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + r = E_SUCCESS; + + errorCode = sound_manager_get_max_volume(SOUND_TYPE_NOTIFICATION, &maxVolume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume It is failed"); + + errorCode = sound_manager_get_volume(SOUND_TYPE_NOTIFICATION, &volume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume It is failed"); + + value = volume; + } + else if (key == _SOUND_RINGTONE_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + r = E_SUCCESS; + + errorCode = sound_manager_get_max_volume(SOUND_TYPE_RINGTONE, &maxVolume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume It is failed"); + + errorCode = sound_manager_get_volume(SOUND_TYPE_RINGTONE, &volume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume It is failed"); + + value = volume; + } + else if (key == _SOUND_SYSTEM_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + r = E_SUCCESS; + + errorCode = sound_manager_get_max_volume(SOUND_TYPE_SYSTEM, &maxVolume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume It is failed"); + + errorCode = sound_manager_get_volume(SOUND_TYPE_SYSTEM, &volume); + SysTryReturnResult(NID_SYS, errorCode == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume It is failed"); + + value = volume; + } + return r; +} + +result +_SettingSoundProvider::SetValue(const String& key, const int value) +{ + int errorCode = 0; + int maxVolume = 0; + result r = E_SUCCESS; + sound_type_e soundType; + + if (key == _SOUND_MEDIA_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + soundType = SOUND_TYPE_MEDIA; + } + else if (key == _SOUND_NOTIFICATION_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + soundType = SOUND_TYPE_NOTIFICATION; + } + else if (key == _SOUND_RINGTONE_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + soundType = SOUND_TYPE_RINGTONE; + } + else if (key == _SOUND_SYSTEM_VOLUME) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support sound feature."); + soundType = SOUND_TYPE_SYSTEM; + } + else + { + return E_OBJ_NOT_FOUND; + } + + errorCode = sound_manager_get_max_volume(soundType, &maxVolume); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get max volume."); + SysTryReturnResult(NID_SYS, maxVolume >= value && value >= 0, E_INVALID_ARG, "The specified value[%d] is outside the bounds of soundCategory.", value); + + SysLog(NID_SYS, "Required Volume is %d, Value is %d", soundType, value); + errorCode = sound_manager_set_volume(soundType, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "A system error has occured."); + + return r; +} + +result +_SettingSoundProvider::GetValue(const String& key, String& value) +{ + int errorCode = 0; + result r =E_OBJ_NOT_FOUND; + + if(key == _SOUND_RINGTONE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support ringtone feature."); + r = E_SUCCESS; + char* pRingtone = null; + errorCode = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &pRingtone); + SysTryReturnResult(NID_SYS, errorCode == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to get ringtone"); + + value.Clear(); + value.Append(pRingtone); + free(pRingtone); + if(File::IsFileExist(value) == false) + { + if(File::IsFileExist(L"/opt/share/settings/Ringtones/ringtone_sdk.mp3") == true) + { + value = L"/opt/share/settings/Ringtones/ringtone_sdk.mp3"; + system_settings_set_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, "/opt/share/settings/Ringtones/ringtone_sdk.mp3"); + } + else + { + return E_SYSTEM; + } + } + } + if(key == _SOUND_NOTIFICATION) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support ringtone feature."); + r = E_SUCCESS; + char* pNotification = null; + pNotification = vconf_get_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR); + SysTryReturnResult(NID_SYS, pNotification != null, E_SYSTEM, "It is failed to get ringtone"); + value.Clear(); + value.Append(pNotification); + free(pNotification); + + if(File::IsFileExist(value) == false) + { + if(File::IsFileExist( L"/opt/share/settings/Alerts/General notification_sdk.wav") == true) + { + value = L"/opt/share/settings/Alerts/General notification_sdk.wav"; + errorCode = vconf_set_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, "/opt/share/settings/Alerts/General notification_sdk.wav"); + } + else + { + return E_SYSTEM; + } + } + } + else if(key == _SOUND_NOTIFICATION_REPEAT_PERIOD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support notificaito sound feature."); + r = E_SUCCESS; + + int current_value = 0; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, ¤t_value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get notification repeat count."); + + switch (current_value) + { + case SETTING_SOUND_REP_ONCE: + value = _SOUND_NOTIFICATION_REPEAT_PERIOD_ONCE; + break; + case SETTING_SOUND_REP_EVERY_2_MIN: + value = _SOUND_NOTIFICATION_REPEAT_PERIOD_2MIN; + break; + case SETTING_SOUND_REP_EVERY_5_MIN: + value = _SOUND_NOTIFICATION_REPEAT_PERIOD_5MIN; + break; + case SETTING_SOUND_REP_EVERY_10_MIN: + value = _SOUND_NOTIFICATION_REPEAT_PERIOD_10MIN; + break; + default: + SysLogException(NID_SYS, E_SYSTEM, "Unsupported value[%d] is provided.", current_value); + return E_SYSTEM; + } + } + + return r; +} + +result +_SettingSoundProvider::SetValue(const String& key, const String value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _SOUND_RINGTONE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support ringtone sound feature."); + r = E_SUCCESS; + + char* pFilePath = null; + SysTryReturn(NID_SYS, File::IsFileExist(value) == true, E_INVALID_ARG, E_INVALID_ARG, "The entry for the specified ringtone file or the file path cannot be found"); + pFilePath = _StringConverter::CopyToCharArrayN(value); + + SysTryReturn(NID_SYS, pFilePath != null, E_SYSTEM, E_SYSTEM, "It is failed to convert type of filePath"); + + errorCode = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, const_cast(pFilePath)); + SysTryReturn(NID_SYS, errorCode == 0, E_SYSTEM, E_SYSTEM, "It is failed to set ringtone"); + + delete [] pFilePath; + } + else if(key == _SOUND_NOTIFICATION) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support notification sound feature."); + r = E_SUCCESS; + + char* pFilePath = null; + SysTryReturn(NID_SYS, File::IsFileExist(value) == true, E_INVALID_ARG, E_INVALID_ARG, "The entry for the specified notification file or the file path cannot be found"); + pFilePath = _StringConverter::CopyToCharArrayN(value); + + SysTryReturn(NID_SYS, pFilePath != null, E_SYSTEM, E_SYSTEM, "It is failed to convert type of filePath"); + + errorCode = vconf_set_str(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, const_cast(pFilePath)); + SysTryReturn(NID_SYS, errorCode == 0, E_SYSTEM, E_SYSTEM, "It is failed to set ringtone"); + + delete [] pFilePath; + } + else if(key == _SOUND_NOTIFICATION_REPEAT_PERIOD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support notificaito sound feature."); + r = E_SUCCESS; + + String requestValue(value); + + requestValue.ToLowerCase(); + + int current_value = 0; + + if(requestValue == _SOUND_NOTIFICATION_REPEAT_PERIOD_ONCE) + { + current_value = (int) SETTING_SOUND_REP_ONCE; + } + else if(requestValue == _SOUND_NOTIFICATION_REPEAT_PERIOD_2MIN) + { + current_value = (int) SETTING_SOUND_REP_EVERY_2_MIN; + } + else if(requestValue == _SOUND_NOTIFICATION_REPEAT_PERIOD_5MIN) + { + current_value = (int) SETTING_SOUND_REP_EVERY_5_MIN; + } + else if(requestValue == _SOUND_NOTIFICATION_REPEAT_PERIOD_10MIN) + { + current_value = (int) SETTING_SOUND_REP_EVERY_10_MIN; + } + else + { + SysLogException(NID_SYS, E_INVALID_ARG, "Requested value[%ls] is not supported.", value.GetPointer()); + return E_INVALID_ARG; + } + + errorCode = vconf_set_int(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, current_value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get notification repeat count."); + } + + + return r; +} + +bool +_SettingSoundProvider::HasKey(const Tizen::Base::String& key) +{ + + if(key == _SOUND_MEDIA_VOLUME || key == _SOUND_NOTIFICATION_VOLUME + || key == _SOUND_RINGTONE_VOLUME || key == _SOUND_SYSTEM_VOLUME) + { + return true; + } + else if(key == _SOUND_RINGTONE) + { + return true; + } + else if(key == _SOUND_SILENTMODE) + { + return true; + } + else if(key == _SOUND_TOUCH || key == _SOUND_LOCK) + { + return true; + } + else if(key == _SOUND_NOTIFICATION || key == _SOUND_NOTIFICATION_REPEAT_PERIOD) + { + return true; + } + + return false; +} + +void +_SettingSoundProvider::SettingEventSoundManager(sound_type_e type, unsigned int volume, void* userData) +{ + String settingKey; + + switch (type) + { + case SOUND_TYPE_SYSTEM: + settingKey.Append(_SOUND_SYSTEM_VOLUME); + break; + case SOUND_TYPE_MEDIA: + settingKey.Append(_SOUND_MEDIA_VOLUME); + break; + case SOUND_TYPE_RINGTONE: + settingKey.Append(_SOUND_RINGTONE_VOLUME); + break; + case SOUND_TYPE_NOTIFICATION: + settingKey.Append(_SOUND_NOTIFICATION_VOLUME); + break; + default: + SysLog(NID_SYS, "NOT IMPLEMENTED"); + return; + } + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingSoundProvider::SettingEventSettingInfo(system_settings_key_e key, void* userData) +{ + String settingKey; + + if(key == SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE) + { + settingKey.Append(_SOUND_RINGTONE); + } + else + { + return; + } + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +void +_SettingSoundProvider::SettingEventRuntimeInfo(runtime_info_key_e key, void* userData) +{ + String settingKey; + + if(key == RUNTIME_INFO_KEY_SILENT_MODE_ENABLED) + { + settingKey.Append(_SOUND_SILENTMODE); + } + else + { + return; + } + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} +void +_SettingSoundProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + String settingKey; + + if (strcmp(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SOUND_TOUCH); + } + else if(strcmp(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SOUND_LOCK); + } + else if(strcmp(VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SOUND_NOTIFICATION_REPEAT_PERIOD); + } + else if(strcmp(VCONFKEY_SETAPPL_NOTI_MSG_RINGTONE_PATH_STR, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SOUND_NOTIFICATION); + } + else + { + return; + } + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingSoundProvider.h b/src/system-server/setting/providers/FSys_SettingSoundProvider.h new file mode 100644 index 0000000..4b4ab3a --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingSoundProvider.h @@ -0,0 +1,65 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingSoundProvider.h + * @brief This is the header file for the %_SettingSoundProvider class. + * + * This header file contains the declarations of the %_SettingSoundProvider class. + */ + +#ifndef _FSYS_SETTING_SOUND_PROVIDER_H_ +#define _FSYS_SETTING_SOUND_PROVIDER_H_ + +#include +#include +#include +#include + +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingSoundProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingSoundProvider(); + virtual ~_SettingSoundProvider(); + +public: + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValue(const Tizen::Base::String& key, const bool value); + + result GetValue(const Tizen::Base::String& key, int& value); + result SetValue(const Tizen::Base::String& key, const int value); + + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValue(const Tizen::Base::String& key, const Tizen::Base::String value); + + bool HasKey(const Tizen::Base::String& key); + +private: + static void SettingEventSoundManager(sound_type_e type, unsigned int volume, void* userData); + static void SettingEventSettingInfo(system_settings_key_e key, void* userData); + static void SettingEventRuntimeInfo(runtime_info_key_e key, void* userData); + static void SettingEventVConf(keynode_t* node, void* userData); +}; // _SettingSoundProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_SOUND_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingSpeechProvider.cpp b/src/system-server/setting/providers/FSys_SettingSpeechProvider.cpp new file mode 100644 index 0000000..1ad139d --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingSpeechProvider.cpp @@ -0,0 +1,197 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingSpeechProvider.cpp + * @brief This is the implementation for the _SettingSpeechProvider class. + */ +#include + +#include +#include +#include + +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingSpeechProvider.h" + +using namespace std; + +using namespace Tizen::App; +using namespace Tizen::App::Package; +using namespace Tizen::Base; + +namespace Tizen { namespace System +{ + +static const wchar_t* _SPEECH_TTS_SCREEN = L"http://tizen.org/setting/speech.tts.screen"; +static const wchar_t* _SPEECH_TTS_SCREEN_RATE = L"http://tizen.org/setting/speech.tts.screen.rate"; + +struct charDeleter +{ + void operator()(char* pValue) + { + if(pValue != null) + { + free(pValue); + pValue = null; + } + } +}; + +_SettingSpeechProvider::_SettingSpeechProvider() +{ + int errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register event listen for screen reader speech rate change."); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register event listen for screen reader change."); + } +} + +_SettingSpeechProvider::~_SettingSpeechProvider() +{ + int errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register event listen for screen reader speech rate change."); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register event listen for screen reader change."); + } + +} + +result +_SettingSpeechProvider::GetValue(const String& key, bool& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _SPEECH_TTS_SCREEN) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen reader."); + r = E_SUCCESS; + int current_value = 0; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, ¤t_value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get VCONFKEY_SETAPPL_ACCESSIBILITY_TTS key."); + if(current_value == 0) + { + value = false; + } + else + { + value = true; + } + } + return r; +} + +result +_SettingSpeechProvider::SetValueForPrivilegedKey(const String& key, bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _SPEECH_TTS_SCREEN) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen reader."); + r = E_SUCCESS; + + int current_value = (int)value; + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, current_value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get VCONFKEY_SETAPPL_ACCESSIBILITY_TTS key."); + } + return r; +} + +result +_SettingSpeechProvider::GetValue(const String& key, int& value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _SPEECH_TTS_SCREEN_RATE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen reader."); + r = E_SUCCESS; + + errorCode = vconf_get_int(VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, &value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE key."); + } + return r; +} + +result +_SettingSpeechProvider::SetValue(const String& key, const int value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _SPEECH_TTS_SCREEN_RATE) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support screen reader."); + r = E_SUCCESS; + + SysTryReturnResult(NID_SYS, value > -1 && value < 5, E_INVALID_ARG, "Required value[%d] is not valid.", value); + + errorCode = vconf_set_int(VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE key."); + } + return r; +} + +bool +_SettingSpeechProvider::HasKey(const String& key) +{ + if(key == _SPEECH_TTS_SCREEN_RATE || key == _SPEECH_TTS_SCREEN) + { + return true; + } + return false; +} + +void +_SettingSpeechProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + String settingKey; + + if(strcmp(VCONFKEY_SETAPPL_ACCESSIBILITY_SPEECH_RATE, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SPEECH_TTS_SCREEN_RATE); + } + else if(strcmp(VCONFKEY_SETAPPL_ACCESSIBILITY_TTS, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_SPEECH_TTS_SCREEN); + } + else + { + return; + } + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingSpeechProvider.h b/src/system-server/setting/providers/FSys_SettingSpeechProvider.h new file mode 100644 index 0000000..1c686b4 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingSpeechProvider.h @@ -0,0 +1,57 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingSpeechProvider.h + * @brief This is the header file for the %_SettingSpeechProvider class. + * + * This header file contains the declarations of the %_SettingSpeechProvider class. + */ + +#ifndef _FSYS_SETTING_SPEECH_PROVIDER_H_ +#define _FSYS_SETTING_SPEECH_PROVIDER_H_ + +#include + +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingSpeechProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingSpeechProvider(); + virtual ~_SettingSpeechProvider(); + +public: + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValue(const Tizen::Base::String& key, const bool value); + result SetValueForPrivilegedKey(const Tizen::Base::String& key, bool value); + + result GetValue(const Tizen::Base::String& key, int& value); + result SetValue(const Tizen::Base::String& key, const int value); + + bool HasKey(const Tizen::Base::String& key); + +private: + static void SettingEventVConf(keynode_t* node, void* userData); +}; // _SettingSpeechProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_SPEECH_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingStorageProvider.cpp b/src/system-server/setting/providers/FSys_SettingStorageProvider.cpp new file mode 100644 index 0000000..36a5f72 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingStorageProvider.cpp @@ -0,0 +1,455 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingStorageProvider.cpp + * @brief This is the implementation for the _SettingStorageProvider class. + */ + +#include +#include +#include +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingStorageProvider.h" + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Utility; +using namespace Tizen::Io; + +namespace Tizen { namespace System +{ + +static const wchar_t* _STORAGE_DIRECTORY_WAP_DOWNLOAD = L"http://tizen.org/setting/storage.directory.wap.download"; +static const wchar_t* _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD = L"http://tizen.org/setting/storage.directory.bluetooth.download"; +static const wchar_t* _STORAGE_DIRECTORY_CAMERA_RECORD = L"http://tizen.org/setting/storage.directory.camera.record"; +static const wchar_t* _STORAGE_DIRECTORY_VOICE_RECORD = L"http://tizen.org/setting/storage.directory.voice.record"; +static const wchar_t* _STORAGE_DIRECTORY_RADIO_BROADCAST = L"http://tizen.org/setting/storage.directory.radio.broadcast"; +static const wchar_t* _STORAGE_DIRECTORY_VIDEO_BROADCAST = L"http://tizen.org/setting/storage.directory.video.broadcast"; +static const wchar_t* _STORAGE_DIRECTORY_INTERNAL_MODE = L"internal"; +static const wchar_t* _STORAGE_DIRECTORY_EXTERNAL_MODE = L"external"; + +_SettingStorageProvider::_SettingStorageProvider() +{ + int errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT event listener"); + } +} + + +_SettingStorageProvider::~_SettingStorageProvider() +{ + int errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT event listener"); + } +} + +result +_SettingStorageProvider::GetValue(const String& key, String& value) +{ + result r = E_OBJ_NOT_FOUND; + int errorCode = 0; + int storage_mode = 0; + + if (key == _STORAGE_DIRECTORY_WAP_DOWNLOAD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, &storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT vconf"); + SysLog(NID_SYS, "storage wap download -> %d", storage_mode); + + switch(storage_mode) + { + case 0: + value = _STORAGE_DIRECTORY_INTERNAL_MODE; + break; + case 1: + value = _STORAGE_DIRECTORY_EXTERNAL_MODE; + break; + default: + r = E_SYSTEM; + } + SysLog(NID_SYS, "storage wap download -> %s", value.GetPointer()); + } + else if (key == _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, &storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT vconf"); + + switch(storage_mode) + { + case 0: + value = _STORAGE_DIRECTORY_INTERNAL_MODE; + break; + case 1: + value = _STORAGE_DIRECTORY_EXTERNAL_MODE; + break; + default: + r = E_SYSTEM; + } + } + else if (key == _STORAGE_DIRECTORY_CAMERA_RECORD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, &storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT vconf"); + + switch(storage_mode) + { + case 0: + value = _STORAGE_DIRECTORY_INTERNAL_MODE; + break; + case 1: + value = _STORAGE_DIRECTORY_EXTERNAL_MODE; + break; + default: + r = E_SYSTEM; + } + } + else if (key == _STORAGE_DIRECTORY_VOICE_RECORD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, &storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT vconf"); + + switch(storage_mode) + { + case 0: + value = _STORAGE_DIRECTORY_INTERNAL_MODE; + break; + case 1: + value = _STORAGE_DIRECTORY_EXTERNAL_MODE; + break; + default: + r = E_SYSTEM; + } + } + else if (key == _STORAGE_DIRECTORY_RADIO_BROADCAST) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, &storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT vconf"); + + switch(storage_mode) + { + case 0: + value = _STORAGE_DIRECTORY_INTERNAL_MODE; + break; + case 1: + value = _STORAGE_DIRECTORY_EXTERNAL_MODE; + break; + default: + r = E_SYSTEM; + } + } + else if (key == _STORAGE_DIRECTORY_VIDEO_BROADCAST) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + errorCode = vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, &storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT vconf"); + + switch(storage_mode) + { + case 0: + value = _STORAGE_DIRECTORY_INTERNAL_MODE; + break; + case 1: + value = _STORAGE_DIRECTORY_EXTERNAL_MODE; + break; + default: + r = E_SYSTEM; + } + } + return r; +} + +result +_SettingStorageProvider::SetValue(const String& key, const String value) +{ + result r = E_OBJ_NOT_FOUND; + int storage_mode = 0; + int errorCode = 0; + if(key == _STORAGE_DIRECTORY_WAP_DOWNLOAD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + + String lowerValue; + value.ToLowerCase(lowerValue); + + if(lowerValue == _STORAGE_DIRECTORY_INTERNAL_MODE) + { + storage_mode = 0; + } + else if(lowerValue == _STORAGE_DIRECTORY_EXTERNAL_MODE) + { + storage_mode = 1; + } + else + { + return E_UNSUPPORTED_OPERATION; + } + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT vconf"); + } + else if(key == _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + + String lowerValue; + value.ToLowerCase(lowerValue); + + if(lowerValue == _STORAGE_DIRECTORY_INTERNAL_MODE) + { + storage_mode = 0; + } + else if(lowerValue == _STORAGE_DIRECTORY_EXTERNAL_MODE) + { + storage_mode = 1; + } + else + { + return E_UNSUPPORTED_OPERATION; + } + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT vconf"); + } + else if(key == _STORAGE_DIRECTORY_CAMERA_RECORD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + + String lowerValue; + value.ToLowerCase(lowerValue); + + if(lowerValue == _STORAGE_DIRECTORY_INTERNAL_MODE) + { + storage_mode = 0; + } + else if(lowerValue == _STORAGE_DIRECTORY_EXTERNAL_MODE) + { + storage_mode = 1; + } + else + { + return E_UNSUPPORTED_OPERATION; + } + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT vconf"); + } + else if(key == _STORAGE_DIRECTORY_VOICE_RECORD) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + + String lowerValue; + value.ToLowerCase(lowerValue); + + if(lowerValue == _STORAGE_DIRECTORY_INTERNAL_MODE) + { + storage_mode = 0; + } + else if(lowerValue == _STORAGE_DIRECTORY_EXTERNAL_MODE) + { + storage_mode = 1; + } + else + { + return E_UNSUPPORTED_OPERATION; + } + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT vconf"); + } + else if(key == _STORAGE_DIRECTORY_RADIO_BROADCAST) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + + String lowerValue; + value.ToLowerCase(lowerValue); + + if(lowerValue == _STORAGE_DIRECTORY_INTERNAL_MODE) + { + storage_mode = 0; + } + else if(lowerValue == _STORAGE_DIRECTORY_EXTERNAL_MODE) + { + storage_mode = 1; + } + else + { + return E_UNSUPPORTED_OPERATION; + } + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT vconf"); + } + else if(key == _STORAGE_DIRECTORY_VIDEO_BROADCAST) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support storage feature."); + r = E_SUCCESS; + + String lowerValue; + value.ToLowerCase(lowerValue); + + if(lowerValue == _STORAGE_DIRECTORY_INTERNAL_MODE) + { + storage_mode = 0; + } + else if(lowerValue == _STORAGE_DIRECTORY_EXTERNAL_MODE) + { + storage_mode = 1; + } + else + { + return E_UNSUPPORTED_OPERATION; + } + errorCode = vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, storage_mode); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT vconf"); + } + return r; +} + +bool +_SettingStorageProvider::HasKey(const Tizen::Base::String& key) +{ + if(key == _STORAGE_DIRECTORY_WAP_DOWNLOAD + || key == _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD + || key == _STORAGE_DIRECTORY_CAMERA_RECORD + || key == _STORAGE_DIRECTORY_VOICE_RECORD + || key == _STORAGE_DIRECTORY_RADIO_BROADCAST + || key == _STORAGE_DIRECTORY_VIDEO_BROADCAST) + { + return true; + } + return false; +} + +void +_SettingStorageProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + String settingKey; + + if (strcmp(VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_STORAGE_DIRECTORY_WAP_DOWNLOAD); + } + else if (strcmp(VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD); + } + else if (strcmp(VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_STORAGE_DIRECTORY_CAMERA_RECORD); + } + else if (strcmp(VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_STORAGE_DIRECTORY_VOICE_RECORD); + } + else if (strcmp(VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_STORAGE_DIRECTORY_RADIO_BROADCAST); + } + else if (strcmp(VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_STORAGE_DIRECTORY_VIDEO_BROADCAST); + } + else + { + return; + } + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingStorageProvider.h b/src/system-server/setting/providers/FSys_SettingStorageProvider.h new file mode 100644 index 0000000..e8020ba --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingStorageProvider.h @@ -0,0 +1,53 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingStorageProvider.h + * @brief This is the header file for the %_SettingStorageProvider class. + * + * This header file contains the declarations of the %_SettingStorageProvider class. + */ + +#ifndef _FSYS_SETTING_STORAGE_PROVIDER_H_ +#define _FSYS_SETTING_STORAGE_PROVIDER_H_ + +#include +#include + +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingStorageProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingStorageProvider(); + virtual ~_SettingStorageProvider(); + +public: + result GetValue(const Tizen::Base::String& key, Tizen::Base::String& value); + result SetValue(const Tizen::Base::String& key, const Tizen::Base::String value); + + bool HasKey(const Tizen::Base::String& key); +private: + static void SettingEventVConf(keynode_t* node, void* userData); +}; // _SettingStorageProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_STORAGE_PROVIDER_H_ diff --git a/src/system-server/setting/providers/FSys_SettingVibrationProvider.cpp b/src/system-server/setting/providers/FSys_SettingVibrationProvider.cpp new file mode 100644 index 0000000..bfce27a --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingVibrationProvider.cpp @@ -0,0 +1,227 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingVibrationProvider.cpp + * @brief This is the implementation for the _SettingVibrationProvider class. + */ + +#include +#include + +#include +#include +#include +#include + +#include "FSys_SettingInfo.h" +#include "FSys_SettingVibrationProvider.h" + +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Utility; +using namespace Tizen::Io; + +namespace Tizen { namespace System +{ +static const wchar_t* _VIBRATOR = L"http://tizen.org/setting/vibrator"; +static const wchar_t* _VIBRATOR_LEVEL = L"http://tizen.org/setting/vibrator.level"; +static const wchar_t* _VIBRATOR_LEVEL_NOTIFICATION = L"http://tizen.org/setting/vibrator.level.notification"; + +_SettingVibrationProvider::_SettingVibrationProvider() +{ + int errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT event listener"); + } + + errorCode = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, SettingEventVConf, null); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to register VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT event listener"); + } +} + + +_SettingVibrationProvider::~_SettingVibrationProvider() +{ + int errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT event listener"); + } + + errorCode = vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, SettingEventVConf); + if(errorCode != 0) + { + SysLogException(NID_SYS, E_SYSTEM, "It is failed to unregister VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT event listener"); + } +} + +result +_SettingVibrationProvider::GetValue(const String& key, bool& value) +{ + int enabled = false; + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _VIBRATOR) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + errorCode = vconf_get_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, &enabled); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL vconf."); + value = enabled ? true : false; + } + return r; +} + +result +_SettingVibrationProvider::SetValue(const String& key, const bool value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + haptic_device_h __hapticHandle; + + if(key == _VIBRATOR) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + if(!value) + { + errorCode = haptic_open(HAPTIC_DEVICE_0, &__hapticHandle); + SysTryReturnResult(NID_SYS, errorCode == HAPTIC_ERROR_NONE, E_SYSTEM, "It is failed to open haptic library."); + haptic_stop_all_effects(__hapticHandle); + errorCode = haptic_close(__hapticHandle); + SysTryReturnResult(NID_SYS, errorCode == HAPTIC_ERROR_NONE, E_SYSTEM, "It is failed to close haptic library."); + __hapticHandle = null; + } + errorCode = vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL vconf."); + } + return r; +} + +result +_SettingVibrationProvider::GetValue(const String& key, int& value) +{ + int level = 0; + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + + if(key == _VIBRATOR_LEVEL) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + errorCode = vconf_get_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, &level); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT vconf"); + value = level; + } + else if (key == _VIBRATOR_LEVEL_NOTIFICATION) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + int errorCode = vconf_get_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, &level); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to get on VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT vconf"); + value = level; + } + return r; +} + +result +_SettingVibrationProvider::SetValue(const String& key, const int value) +{ + int errorCode = 0; + result r = E_OBJ_NOT_FOUND; + if(key == _VIBRATOR_LEVEL) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + SysTryReturnResult(NID_SYS, value >= 0 && value <= 5, E_INVALID_ARG, "Speicified value is not valid"); + errorCode = vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT vconf"); + } + else if(key == _VIBRATOR_LEVEL_NOTIFICATION) + { + SysTryReturnResult(NID_SYS, HasKey(key) == true, E_UNSUPPORTED_OPERATION, "Current device does not support vibrator feature."); + r = E_SUCCESS; + + SysTryReturnResult(NID_SYS, value >= 0 && value <= 5, E_INVALID_ARG, "Speicified value is not valid"); + errorCode = vconf_set_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, value); + SysTryReturnResult(NID_SYS, errorCode == 0, E_SYSTEM, "It is failed to set on VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT vconf"); + } + return r; +} + +bool +_SettingVibrationProvider::HasKey(const Tizen::Base::String& key) +{ + + if(key == _VIBRATOR_LEVEL_NOTIFICATION + || key == _VIBRATOR_LEVEL + || key == _VIBRATOR) + { + return true; + } + return false; +} + +void +_SettingVibrationProvider::SettingEventVConf(keynode_t* node, void* userData) +{ + String settingKey; + + if (strcmp(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_VIBRATOR); + } + else if (strcmp(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_VIBRATOR_LEVEL); + } + else if (strcmp(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, vconf_keynode_get_name(node)) == 0) + { + settingKey.Append(_VIBRATOR_LEVEL_NOTIFICATION); + } + else + { + return; + } + + _SettingInfo* pSettingInfo = _SettingInfo::GetInstance(); + SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_SYSTEM, "_SettingInfo is not ready."); + + result r = pSettingInfo->AnnounceSettingEvent(settingKey); + SysTryReturnVoidResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to send the event[%ls].", settingKey.GetPointer()); +} + +}} diff --git a/src/system-server/setting/providers/FSys_SettingVibrationProvider.h b/src/system-server/setting/providers/FSys_SettingVibrationProvider.h new file mode 100644 index 0000000..b3cd886 --- /dev/null +++ b/src/system-server/setting/providers/FSys_SettingVibrationProvider.h @@ -0,0 +1,57 @@ +// +// Copyright (c) 2012 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FSys_SettingVibrationProvider.h + * @brief This is the header file for the %_SettingVibrationProvider class. + * + * This header file contains the declarations of the %_SettingVibrationProvider class. + */ + +#ifndef _FSYS_SETTING_VIBRATION_PROVIDER_H_ +#define _FSYS_SETTING_VIBRATION_PROVIDER_H_ + +#include +#include "FSys_ISettingProvider.h" + +namespace Tizen { namespace System +{ + +class _SettingVibrationProvider + : virtual public Tizen::System::_ISettingProvider +{ +public: + _SettingVibrationProvider(); + virtual ~_SettingVibrationProvider(); + +public: + Tizen::Base::String GetId(void); + + result GetValue(const Tizen::Base::String& key, bool& value); + result SetValue(const Tizen::Base::String& key, const bool value); + + result GetValue(const Tizen::Base::String& key, int& value); + result SetValue(const Tizen::Base::String& key, const int value); + + bool HasKey(const Tizen::Base::String& key); + +private: + static void SettingEventVConf(keynode_t* node, void* userData); +}; // _SettingVibrationProvider + +}} // Tizen::System + +#endif // _FSYS_ISETTING_VIBRATION_PROVIDER_H_ -- 2.7.4