src/server/system/setting/FSys_SettingInfo.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                FSys_SettingInfo.cpp
  19  * @brief               This is the implementation file for _SettingInfo class.
  20  */
  21
  22 #include <new>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <unique_ptr.h>
  26 #include <sysman.h>
  27
  28 #include <FBaseColIEnumeratorT.h>
  29 #include <FIoFile.h>
  30
  31 #include "providers/FSys_ISettingProvider.h"
  32 #include "FSys_SettingInfo.h"
  33
  34 //providers
  35 #include "providers/FSys_SettingApplicationProvider.h"
  36 #include "providers/FSys_SettingFontProvider.h"
  37 #include "providers/FSys_SettingGeneralProvider.h"
  38 #include "providers/FSys_SettingLocaleProvider.h"
  39 #include "providers/FSys_SettingLocationProvider.h"
  40 #include "providers/FSys_SettingNetworkProvider.h"
  41 #include "providers/FSys_SettingScreenProvider.h"
  42 #include "providers/FSys_SettingSoundProvider.h"
  43 #include "providers/FSys_SettingSpeechProvider.h"
  44 #include "providers/FSys_SettingStorageProvider.h"
  45 #include "providers/FSys_SettingVibrationProvider.h"
  46
  47 using namespace std;
  48
  49 using namespace Tizen::Base;
  50 using namespace Tizen::Base::Collection;
  51 using namespace Tizen::Io;
  52
  53 namespace Tizen { namespace System
  54 {
  55
  56 static const String _SETTING_APPLICATION_PROVIDER(L"application");
  57 static const String _SETTING_FONT_PROVIDER(L"font");
  58 static const String _SETTING_DEVICE_NAME_PROVIDER(L"device_name");
  59 static const String _SETTING_MOTION_PROVIDER(L"motion");
  60 static const String _SETTING_CONTACTS_PROVIDER(L"contacts");
  61 static const String _SETTING_DEVELOPER_PROVIDER(L"developer");
  62 static const String _SETTING_BATTERY_PROVIDER(L"battery");
  63 static const String _SETTING_GRAPHICS_PROVIDER(L"graphics");
  64 static const String _SETTING_LOCALE_PROVIDER(L"locale");
  65 static const String _SETTING_LOCATION_PROVIDER(L"location");
  66 static const String _SETTING_NETWORK_PROVIDER(L"network");
  67 static const String _SETTING_SCREEN_PROVIDER(L"screen");
  68 static const String _SETTING_SOUND_PROVIDER(L"sound");
  69 static const String _SETTING_SPEECH_PROVIDER(L"speech");
  70 static const String _SETTING_STORAGE_PROVIDER(L"storage");
  71 static const String _SETTING_USB_PROVIDER(L"usb");
  72 static const String _SETTING_VIBRATION_PROVIDER(L"vibrator");
  73
  74 static const wchar_t* _SETTING_PREFIX = L"http://tizen.org/setting/";
  75
  76 _SettingInfo* _SettingInfo::__pSettingInfo = null;
  77 static const char* _BIN_FACTORY_RESET = "/usr/bin/factory-reset";
  78
  79 _SettingInfo::_SettingInfo()
  80 {
  81         static _StringHashProvider hashProvider;
  82         static _StringComparer stringComparer;
  83         __settingProviderList.Construct(0, 0, hashProvider, stringComparer);
  84
  85         _SettingApplicationProvider* applicationProvider = new (std::nothrow) _SettingApplicationProvider();
  86         RegisterProvider(_SETTING_APPLICATION_PROVIDER, (_ISettingProvider*)applicationProvider);
  87
  88         _SettingFontProvider* fontProvider = new (std::nothrow) _SettingFontProvider();
  89         RegisterProvider(_SETTING_FONT_PROVIDER, (_ISettingProvider*)fontProvider);
  90
  91         _SettingGeneralProvider* generalProvider = new (std::nothrow) _SettingGeneralProvider();
  92         RegisterProvider(_SETTING_DEVICE_NAME_PROVIDER, (_ISettingProvider*)generalProvider);
  93         RegisterProvider(_SETTING_MOTION_PROVIDER, (_ISettingProvider*)generalProvider);
  94         RegisterProvider(_SETTING_CONTACTS_PROVIDER, (_ISettingProvider*)generalProvider);
  95         RegisterProvider(_SETTING_DEVELOPER_PROVIDER, (_ISettingProvider*)generalProvider);
  96         RegisterProvider(_SETTING_BATTERY_PROVIDER, (_ISettingProvider*)generalProvider);
  97         RegisterProvider(_SETTING_GRAPHICS_PROVIDER, (_ISettingProvider*)generalProvider);
  98
  99         _SettingLocaleProvider* localeProvider = new (std::nothrow) _SettingLocaleProvider();
 100         RegisterProvider(_SETTING_LOCALE_PROVIDER, (_ISettingProvider*)localeProvider);
 101
 102         _SettingLocationProvider* locationProvider = new (std::nothrow) _SettingLocationProvider();
 103         RegisterProvider(_SETTING_LOCATION_PROVIDER, (_ISettingProvider*)locationProvider);
 104
 105         _SettingNetworkProvider* networkProvider = new (std::nothrow) _SettingNetworkProvider();
 106         RegisterProvider(_SETTING_NETWORK_PROVIDER, (_ISettingProvider*)networkProvider);
 107         RegisterProvider(_SETTING_USB_PROVIDER, (_ISettingProvider*)networkProvider);
 108
 109         _SettingScreenProvider* screenProvider = new (std::nothrow) _SettingScreenProvider();
 110         RegisterProvider(_SETTING_SCREEN_PROVIDER, (_ISettingProvider*)screenProvider);
 111
 112         _SettingSoundProvider* soundProvider = new (std::nothrow) _SettingSoundProvider();
 113         RegisterProvider(_SETTING_SOUND_PROVIDER, (_ISettingProvider*)soundProvider);
 114
 115         _SettingSpeechProvider* speechProvider = new (std::nothrow) _SettingSpeechProvider();
 116         RegisterProvider(_SETTING_SPEECH_PROVIDER, (_ISettingProvider*)speechProvider);
 117
 118         _SettingStorageProvider* storageProvider = new (std::nothrow) _SettingStorageProvider();
 119         RegisterProvider(_SETTING_STORAGE_PROVIDER, (_ISettingProvider*)storageProvider);
 120
 121         _SettingVibrationProvider* vibrationProvider = new (std::nothrow) _SettingVibrationProvider();
 122         RegisterProvider(_SETTING_VIBRATION_PROVIDER, (_ISettingProvider*)vibrationProvider);
 123
 124         __settingEventList.Construct();
 125 }
 126
 127 _SettingInfo::~_SettingInfo()
 128 {
 129         RemoveProvider(_SETTING_APPLICATION_PROVIDER);
 130         RemoveProvider(_SETTING_FONT_PROVIDER);
 131         UnregisterProvider(_SETTING_MOTION_PROVIDER);
 132         UnregisterProvider(_SETTING_CONTACTS_PROVIDER);
 133         UnregisterProvider(_SETTING_DEVELOPER_PROVIDER);
 134         UnregisterProvider(_SETTING_BATTERY_PROVIDER);
 135         UnregisterProvider(_SETTING_GRAPHICS_PROVIDER);
 136         RemoveProvider(_SETTING_DEVICE_NAME_PROVIDER);
 137         RemoveProvider(_SETTING_LOCALE_PROVIDER);
 138         RemoveProvider(_SETTING_LOCATION_PROVIDER);
 139         UnregisterProvider(_SETTING_USB_PROVIDER);
 140         RemoveProvider(_SETTING_NETWORK_PROVIDER);
 141         RemoveProvider(_SETTING_SCREEN_PROVIDER);
 142         RemoveProvider(_SETTING_SOUND_PROVIDER);
 143         RemoveProvider(_SETTING_SPEECH_PROVIDER);
 144         RemoveProvider(_SETTING_STORAGE_PROVIDER);
 145         RemoveProvider(_SETTING_VIBRATION_PROVIDER);
 146         __settingProviderList.RemoveAll();
 147 }
 148
 149 result
 150 _SettingInfo::RemoveProvider(const String key)
 151 {
 152         _ISettingProvider* pProvider = null;
 153
 154         pProvider = GetProvider(key);
 155         if(pProvider != null)
 156         {
 157                 UnregisterProvider(key);
 158                 delete pProvider;
 159                 return E_SUCCESS;
 160         }
 161         return E_SYSTEM;
 162 }
 163
 164 _SettingInfo*
 165 _SettingInfo::GetInstance(void)
 166 {
 167         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 168         if(__pSettingInfo == null)
 169         {
 170                 pthread_once(&onceBlock, InitSingleton);
 171         }
 172         return __pSettingInfo;
 173 }
 174
 175 void
 176 _SettingInfo::InitSingleton(void)
 177 {
 178         _SettingInfo* pSettingInfo = new (std::nothrow) _SettingInfo();
 179         SysTryReturnVoidResult(NID_SYS, pSettingInfo != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.",
 180                                                    GetErrorMessage(E_OUT_OF_MEMORY));
 181
 182         __pSettingInfo = pSettingInfo;
 183         atexit(DestroySingleton);
 184 }
 185
 186 void
 187 _SettingInfo::DestroySingleton(void)
 188 {
 189         delete __pSettingInfo;
 190 }
 191
 192 _ISettingProvider*
 193 _SettingInfo::GetProvider(const String& key)
 194 {
 195         int index = 0;
 196         String requiredKey;
 197         String prefix(_SETTING_PREFIX);
 198         _ISettingProvider* provider = null;
 199
 200         key.SubString(prefix.GetLength(), requiredKey);
 201         requiredKey.IndexOf(L".", 0, index);
 202         requiredKey.SubString(0, index, requiredKey);
 203
 204         result r = __settingProviderList.GetValue(requiredKey, provider);
 205
 206         if(r != E_SUCCESS || provider == null)
 207         {
 208                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to find proper provider for required key(%ls).", key.GetPointer());
 209                 return null;
 210         }
 211
 212         return provider;
 213 }
 214
 215 result
 216 _SettingInfo::GetValue(const String& key, String& value)
 217 {
 218         _ISettingProvider* provider = GetProvider(key);
 219         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 220         return provider->GetValue(key, value);
 221 }
 222
 223 result
 224 _SettingInfo::GetValue(const String& key, int& value)
 225 {
 226         _ISettingProvider* provider = GetProvider(key);
 227         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 228         return provider->GetValue(key, value);
 229 }
 230
 231 result
 232 _SettingInfo::GetValue(const String& key, bool& value)
 233 {
 234         _ISettingProvider* provider = GetProvider(key);
 235         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 236         return provider->GetValue(key, value);
 237 }
 238
 239 bool
 240 _SettingInfo::HasKey(const String& key)
 241 {
 242         _ISettingProvider* provider = GetProvider(key);
 243         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 244         return provider->HasKey(key);
 245 }
 246
 247 result
 248 _SettingInfo::SetValue(const String& key, bool value)
 249 {
 250         _ISettingProvider* provider = GetProvider(key);
 251         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 252         return provider->SetValue(key, value);
 253 }
 254
 255 result
 256 _SettingInfo::SetValue(const String& key, int value)
 257 {
 258         _ISettingProvider* provider = GetProvider(key);
 259         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 260         return provider->SetValue(key, value);
 261 }
 262
 263 result
 264 _SettingInfo::SetValue(const String& key, String value)
 265 {
 266         _ISettingProvider* provider = GetProvider(key);
 267         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 268         return provider->SetValue(key, value);
 269 }
 270
 271 result
 272 _SettingInfo::AddSettingEventListener(ISettingEventListener& listener)
 273 {
 274         return __settingEventList.Add(&listener);
 275 }
 276
 277 result
 278 _SettingInfo::RemoveSettingEventListener(ISettingEventListener& listener)
 279 {
 280         return __settingEventList.Remove(&listener);
 281 }
 282
 283 result
 284 _SettingInfo::AnnounceSettingEvent(const String& key)
 285 {
 286         IEnumeratorT< ISettingEventListener*>* pEnum = __settingEventList.GetEnumeratorN();
 287         SysTryReturnResult(NID_SYS, pEnum != null, E_SYSTEM, "It is failed to get event listener list.");
 288
 289         SysLog(NID_SYS, "Setting event[%ls] is occured.", key.GetPointer());
 290         while(pEnum->MoveNext() == E_SUCCESS)
 291         {
 292                 ISettingEventListener* pEventListener = null;
 293                 pEnum->GetCurrent(pEventListener);
 294
 295                 if(pEventListener != null)
 296                 {
 297                         String eventKey = key;
 298                         pEventListener->OnSettingChanged(eventKey);
 299                         SysLog(NID_SYS, "Event is delivered to %x.", pEventListener);
 300                 }
 301         }
 302
 303         delete pEnum;
 304         return E_SUCCESS;
 305 }
 306
 307 result
 308 _SettingInfo::GetValueForPrivilegedKey(const String& key, bool& value)
 309 {
 310         _ISettingProvider* provider = GetProvider(key);
 311         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 312         return provider->GetValueForPrivilegedKey(key, value);
 313 }
 314
 315 result
 316 _SettingInfo::SetValueForPrivilegedKey(const String& key, bool value)
 317 {
 318         _ISettingProvider* provider = GetProvider(key);
 319         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 320         return provider->SetValueForPrivilegedKey(key, value);
 321 }
 322
 323 result
 324 _SettingInfo::SetValueAsyncForPrivilegedKey(const String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener)
 325 {
 326         _ISettingProvider* provider = GetProvider(key);
 327         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 328         return provider->SetValueAsyncForPrivilegedKey(key, value, listener);
 329 }
 330
 331 result
 332 _SettingInfo::SetValueAsync(const String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener)
 333 {
 334         _ISettingProvider* provider = GetProvider(key);
 335         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 336         return provider->SetValueAsync(key, value, listener);
 337 }
 338
 339 result
 340 _SettingInfo::SetValueForPrivilegedKey(const String& key, String value)
 341 {
 342         _ISettingProvider* provider = GetProvider(key);
 343         SysTryReturnResult(NID_SYS, provider != null, E_OBJ_NOT_FOUND, "It is failed to find provider.");
 344         return provider->SetValueForPrivilegedKey(key, value);
 345 }
 346
 347 result
 348 _SettingInfo::ResetToFactoryDefault(void)
 349 {
 350         SysTryReturnResult(NID_SYS, File::IsFileExist(_BIN_FACTORY_RESET) == true, E_UNSUPPORTED_OPERATION, "Current device does not support factory reset.");
 351         SysTryReturnResult(NID_SYS, sysman_call_predef_action("launchfr", 0, NULL) == 0, E_SYSTEM, "It is failed to execute factory reset.");
 352         return E_SUCCESS;
 353 }
 354
 355 result
 356 _SettingInfo::RegisterProvider(const String& key, _ISettingProvider* provider)
 357 {
 358         bool exist = false;
 359         result r = __settingProviderList.ContainsKey(key, exist);
 360         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to check required key(%ls).", key.GetPointer());
 361         SysTryReturnResult(NID_SYS, exist == false, E_OBJ_ALREADY_EXIST, "It is already registered key(%ls).", key.GetPointer());
 362
 363         r = __settingProviderList.Add(key, provider);
 364         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to add required key(%ls).", key.GetPointer());
 365         return E_SUCCESS;
 366 }
 367
 368 result
 369 _SettingInfo::UnregisterProvider(const String& key)
 370 {
 371         bool exist = false;
 372         result r = __settingProviderList.ContainsKey(key, exist);
 373         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to check required key(%ls).", key.GetPointer());
 374         SysTryReturnResult(NID_SYS, exist == true, E_OBJ_NOT_FOUND, "It is already registered key(%ls).", key.GetPointer());
 375
 376         r = __settingProviderList.Remove(key);
 377         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to remove required key(%ls).", key.GetPointer());
 378         return E_SUCCESS;
 379 }
 380
 381 } }