src/system/FSys_SettingManager.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /**
  19  * @file                FSys_SettingManager.cpp
  20  * @brief               This is the implementation file for _SettingManager class.
  21  */
  22
  23 #include <pthread.h>
  24 #include <unique_ptr.h>
  25 #include <string>
  26 #include <stdlib.h>
  27 #include <unicode/ustring.h>
  28 #include <unicode/uloc.h>
  29 #include <unicode/utypes.h>
  30 #include <unicode/udat.h>
  31 #include <unicode/udatpg.h>
  32 #include <unicode/locid.h>
  33 #include <device.h>
  34 #include <telephony_network.h>
  35 #include <sysman.h>
  36 #include <tethering.h>
  37 #include <sim.h>
  38 #include <dlfcn.h>
  39
  40 #include <FBaseColIMapEnumerator.h>
  41 #include <FBaseInteger.h>
  42 #include <FBaseRtIEventArg.h>
  43 #include <FBaseSysLog.h>
  44 #include <FBaseUtilStringUtil.h>
  45 #include <FLclLocale.h>
  46 #include <FLclDateTimeFormatter.h>
  47 #include <FIoFile.h>
  48 #include <FSysIBatteryEventListener.h>
  49 #include <FSysIChargingEventListener.h>
  50 #include <FSysIDeviceEventListener.h>
  51 #include <FSysIScreenEventListener.h>
  52 #include <FSysSystemInfo.h>
  53
  54 #include <FApp_AppInfo.h>
  55 #include <FBase_NativeError.h>
  56 #include <FBase_StringConverter.h>
  57 #include <FBaseColAllElementsDeleter.h>
  58 #include <FIo_AppServiceIpcMessages.h>
  59 #include <FIo_RegistryImpl.h>
  60 #include <FLcl_LocaleImpl.h>
  61 #include <FLcl_LocaleManagerImpl.h>
  62 #include <FSys_SettingManager.h>
  63 #include <FSys_SystemInfoImpl.h>
  64
  65 using namespace Tizen::App;
  66 using namespace Tizen::Base;
  67 using namespace Tizen::Base::Collection;
  68 using namespace Tizen::Base::Runtime;
  69 using namespace Tizen::Base::Utility;
  70 using namespace Tizen::Io;
  71 using namespace Tizen::Locales;
  72
  73 namespace Tizen { namespace System
  74 {
  75
  76 //Battery
  77 static const wchar_t* _BATTERY_FORMAT_PERCENTAGE = L"http://tizen.org/setting/battery.format.percentage";
  78
  79 static const wchar_t* _ENABLE_MOTION = L"EnableMotion";
  80
  81 //Font
  82 static const wchar_t* _FONT_SIZE = L"http://tizen.org/setting/font.size";
  83 static const wchar_t* _FONT_SIZE_GIANT = L"Giant";
  84 static const wchar_t* _FONT_SIZE_HUGE = L"Huge";
  85 static const wchar_t* _FONT_SIZE_LARGE = L"Large";
  86 static const wchar_t* _FONT_SIZE_MEDIUM = L"Medium";
  87 static const wchar_t* _FONT_SIZE_SMALL = L"Small";
  88 static const wchar_t* _FONT_SIZE_GIANT_LOWERCASE = L"giant";
  89 static const wchar_t* _FONT_SIZE_HUGE_LOWERCASE = L"huge";
  90 static const wchar_t* _FONT_SIZE_LARGE_LOWERCASE = L"large";
  91 static const wchar_t* _FONT_SIZE_MEDIUM_LOWERCASE = L"medium";
  92 static const wchar_t* _FONT_SIZE_SMALL_LOWERCASE = L"small";
  93 static const int _FONT_SIZE_GIANT_VCONF = 4;
  94 static const int _FONT_SIZE_HUGE_VCONF = 3;
  95 static const int _FONT_SIZE_LARGE_VCONF = 2;
  96 static const int _FONT_SIZE_MEDIUM_VCONF = 1;
  97 static const int _FONT_SIZE_SMALL_VCONF = 0;
  98 static const wchar_t* _FONTSIZE = L"FontSize";
  99 static const wchar_t* _FONTTYPE = L"FontType";
 100 static const wchar_t* _FONT_TYPE = L"http://tizen.org/setting/font.type";
 101 static const wchar_t* _GPS_ENABLED = L"GPSEnabled";
 102 static const wchar_t* _HOUR_FORMAT_SELECTED = L"24HourFormatSelected";
 103
 104 //Locale
 105 //Locale Country
 106 static const wchar_t* _LOCALE_COUNTRY = L"http://tizen.org/setting/locale.country";
 107 static const wchar_t* _LOCALE_COUNTRY_LATIN_AMERICA = L"419";
 108 static const wchar_t* _COUNTRY = L"Country";
 109
 110 //Locale Format
 111 static const wchar_t* _LOCALE_DATE_FORMAT = L"http://tizen.org/setting/locale.date.format";
 112 static const wchar_t* _LOCALE_DATETIME_FORMAT = L"http://tizen.org/setting/locale.date_time.format";
 113 static const wchar_t* _LOCALE_TIME_FORMAT = L"http://tizen.org/setting/locale.time.format";
 114 static const wchar_t* _LOCALE_TIME_FORMAT_24HOUR = L"http://tizen.org/setting/locale.time.format.24hour";
 115 static const wchar_t* _DATE_FORMAT = L"DateFormat";
 116 static const wchar_t* _TIME_FORMAT = L"TimeFormat";
 117
 118 //Locale Language
 119 static const wchar_t* _LOCALE_LANGUAGE = L"http://tizen.org/setting/locale.language";
 120 static const wchar_t* _LANGUAGE = L"Language";
 121
 122 //Locale Time
 123 static const wchar_t* _LOCALE_TIMEZONE = L"http://tizen.org/setting/locale.time_zone";
 124 static const wchar_t* _LOCALE_UPDATE_AUTO= L"http://tizen.org/setting/locale.update.auto";
 125 static const char* _LOCALE_TIMEZONE_ROOT_PATH = "/usr/share/zoneinfo/";
 126 static const char* _LOCALE_TIMEZONE_LINK = "/opt/etc/localtime";
 127 static const int _LOCALE_TIMEZONE_ROOT_PATH_LENGTH = 20;
 128 static const wchar_t* _LOCALE_WEEK_FORMAT_FIRSTDAY = L"http://tizen.org/setting/locale.week.format.firstday";
 129 static const wchar_t* _LOCALE_WEEK_FORMAT_FIRSTDAY_MONDAY = L"Monday";
 130 static const wchar_t* _LOCALE_WEEK_FORMAT_FIRSTDAY_SUNDAY = L"Sunday";
 131 static const int _LOCALE_WEEK_FORMAT_VCONF_SUNDAY = 0;
 132 static const int _LOCALE_WEEK_FORMAT_VCONF_MONDAY = 1;
 133 static const wchar_t* _DATE_TIME_FORMAT = L"DateTimeFormat";
 134
 135 static const wchar_t* _LOCALE_DATE = L"http://tizen.org/setting/locale.date";
 136 static const wchar_t* _LOCALE_TIME = L"http://tizen.org/setting/locale.time";
 137 static const wchar_t* _LOCALE_DATETIME = L"http://tizen.org/setting/locale.date_time";
 138
 139 //Location
 140 static const wchar_t* _LOCATION_GPS = L"http://tizen.org/setting/location.gps";
 141 static const wchar_t* _LOCATION_GPS_ADVANCED = L"http://tizen.org/setting/location.gps.advanced";
 142 static const wchar_t* _LOCATION_WPS = L"http://tizen.org/setting/location.wps";
 143 static const wchar_t* _MEDIA_SOUND_VOLUME = L"MediaSoundVolume";
 144 static const wchar_t* _WPS_ENABLED = L"WPSEnabled";
 145
 146 //Network
 147 static const wchar_t* _NETWORK_FLIGHTMODE = L"http://tizen.org/setting/network.flight_mode";
 148 static const wchar_t* _FLIGHT_MODE_ENABLED = L"FlightModeEnabled";
 149
 150 //Network Telephony
 151 static const wchar_t* _NETWORK_TELEPHONY_MODE = L"http://tizen.org/setting/network.telephony.mode";
 152 String _tmpNetworkTelephonyMode = L"UMTS";
 153 static const wchar_t* _NETWORK_TELEPHONY_PACKETSERVICE = L"http://tizen.org/setting/network.telephony.packet_service";
 154 static const wchar_t* _NETWORK_TELEPHONY_PROVIDER = L"http://tizen.org/setting/network.telephony.provider";
 155 String _tmpNetworkTelephonyProvider = L"Tizen";
 156 static const wchar_t* _NETWORK_TELEPHONY_ROAMING = L"http://tizen.org/setting/network.telephony.roaming";
 157 static const wchar_t* _DATA_ROAMING_ENABLED = L"DataRoamingEnabled";
 158 static const wchar_t* _SYSTEM_NETWORK_TELEPHONY = L"http://tizen.org/feature/network.telephony";
 159
 160 //Network Wifi
 161 static const wchar_t* _NETWORK_WIFI = L"http://tizen.org/setting/network.wifi";
 162 static const wchar_t* _NETWORK_WIFI_NOTIFICATION = L"http://tizen.org/setting/network.wifi.notification";
 163 static const wchar_t* _NETWORK_WIFI_TETHERING = L"http://tizen.org/setting/network.wifi.tethering";
 164 static const wchar_t* _NETWORK_WIFI_TETHERING_HIDE = L"http://tizen.org/setting/network.wifi.tethering.hide";
 165 static const wchar_t* _NETWORK_WIFI_TETHERING_SECURITY = L"http://tizen.org/setting/network.wifi.tethering.security";
 166 static const wchar_t* _NETWORK_WIFI_TETHERING_SECURITY_PASSWORD = L"http://tizen.org/setting/network.wifi.tethering.security.password";
 167 static const wchar_t* _NETWORK_WIFI_DIRECT = L"http://tizen.org/setting/network.wifi.direct";
 168 static const wchar_t* _SYSTEM_NETWORK_WIFI_DIRECT = L"http://tizen.org/feature/network.wifi.direct";
 169 static const wchar_t* _SYSTEM_NETWORK_WIFI = L"http://tizen.org/feature/network.wifi";
 170
 171 //Network Bluetooth
 172 static const wchar_t* _NETWORK_BLUETOOTH = L"http://tizen.org/setting/network.bluetooth";
 173 static const wchar_t* _NETWORK_BLUETOOTH_TETHERING = L"http://tizen.org/setting/network.bluetooth.tethering";
 174 static const wchar_t* _SYSTEM_NETWORK_BLUETOOTH = L"http://tizen.org/feature/network.bluetooth";
 175
 176 //Sound
 177 static const wchar_t* _NOTIFICATION_SOUND_VOLUME = L"NotificationSoundVolume";
 178 static const wchar_t* _PACKET_SERVICE_ALLOWED = L"PacketServiceAllowed";
 179 static const wchar_t* _RINGTONE = L"Ringtone";
 180 static const wchar_t* _RINGTONE_SOUND_VOLUME = L"RingtoneSoundVolume";
 181 static const wchar_t* _SILENT_MODE = L"SilentMode";
 182 static const wchar_t* _SOUND_MEDIA_VOLUME = L"http://tizen.org/setting/sound.media.volume";
 183 static const wchar_t* _SOUND_NOTIFICATION_VOLUME = L"http://tizen.org/setting/sound.notification.volume";
 184 static const wchar_t* _SOUND_RINGTONE = L"http://tizen.org/setting/sound.ringtone";
 185 static const wchar_t* _SOUND_RINGTONE_VOLUME = L"http://tizen.org/setting/sound.ringtone.volume";
 186 static const wchar_t* _SOUND_SILENTMODE = L"http://tizen.org/setting/sound.silent_mode";
 187 static const wchar_t* _SOUND_SYSTEM_VOLUME = L"http://tizen.org/setting/sound.system.volume";
 188 static const wchar_t* _SOUND_TOUCH = L"http://tizen.org/setting/sound.touch";
 189 static const wchar_t* _SOUND_LOCK = L"http://tizen.org/setting/sound.lock";
 190
 191 //Screen
 192 static const wchar_t* _SCREEN_WALLPAPER = L"http://tizen.org/setting/screen.wallpaper";
 193 static const wchar_t* _SCREEN_WALLPAPER_LOCK = L"http://tizen.org/setting/screen.wallpaper.lock";
 194 static const wchar_t* _WALLPAPER = L"Wallpaper";
 195 static const wchar_t* _SCREEN_BRIGHTNESS = L"http://tizen.org/setting/screen.brightness";
 196 static const wchar_t* _SCREEN_BRIGHTNESS_AUTO = L"http://tizen.org/setting/screen.brightness.auto";
 197 static const wchar_t* _SCREEN_BACKLIGHT_TIME = L"http://tizen.org/setting/screen.backlight.time";
 198 static const wchar_t* _SCREEN_ROTATION_AUTO = L"http://tizen.org/setting/screen.rotation.auto";
 199 static const wchar_t* _SCREEN_MODE = L"http://tizen.org/setting/screen.mode";
 200 static const wchar_t* _SCREEN_MODE_DYNAMIC = L"Dynamic";
 201 static const wchar_t* _SCREEN_MODE_STANDARD = L"Standard";
 202 static const wchar_t* _SCREEN_MODE_NATURAL = L"Natural";
 203 static const wchar_t* _SCREEN_MODE_MOVIE = L"Movie";
 204 static const char* _SCREEN_MODE_VCONFKEY = VCONFKEY_SETAPPL_PREFIX"/screenmode/selected_name";
 205
 206 //Directory
 207 static const wchar_t* _STORAGE_DIRECTORY_WAP_DOWNLOAD = L"http://tizen.org/setting/storage.directory.wap.download";
 208 String _tmpStorageDirectoryWapDownload = L"";
 209 static const wchar_t* _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD = L"http://tizen.org/setting/storage.directory.bluetooth.download";
 210 String _tmpStorageDirectoryBluetoothDownload = L"";
 211 static const wchar_t* _STORAGE_DIRECTORY_CAMERA_RECORD = L"http://tizen.org/setting/storage.directory.camera.record";
 212 String _tmpStorageDirectoryCameraRecord = L"";
 213 static const wchar_t* _STORAGE_DIRECTORY_VOICE_RECORD = L"http://tizen.org/setting/storage.directory.voice.record";
 214 String _tmpStorageDirectoryVoiceRecord = L"";
 215 static const wchar_t* _STORAGE_DIRECTORY_RADIO_BROADCAST = L"http://tizen.org/setting/storage.directory.radio.broadcast";
 216 String _tmpStorageDirectoryRadioBroadcast = L"";
 217 static const wchar_t* _STORAGE_DIRECTORY_VIDEO_BROADCAST = L"http://tizen.org/setting/storage.directory.video.broadcast";
 218 String _tmpStorageDirectoryVideoBroadcast = L"";
 219 static const wchar_t* _SYSTEM_SOUND_VOLUME = L"SystemSoundVolume";
 220
 221 //Device Name
 222 static const wchar_t* _DEVICE_NAME = L"http://tizen.org/setting/device_name";
 223
 224 //Vibration
 225 static const wchar_t* _TOUCH_VIBRATION_LEVEL = L"TouchVibrationLevel";
 226 static const wchar_t* _VIBRATOR = L"http://tizen.org/setting/vibrator";
 227 static const wchar_t* _VIBRATOR_LEVEL = L"http://tizen.org/setting/vibrator.level";
 228
 229 static const wchar_t* _VIBRATOR_LEVEL_NOTIFICATION = L"http://tizen.org/setting/vibrator.level.notification";
 230
 231 //USB
 232 static const wchar_t* _USBMODE = L"UsbMode";
 233 static const wchar_t* _USBMODE_MTP = L"MTP";
 234 static const wchar_t* _USB_TETHERING = L"http://tizen.org/setting/usb.tethering";
 235
 236 //WEB
 237 static const wchar_t* _WEB_APPLICATION_COOKIE_SHARE = L"http://tizen.org/setting/web.application.cookie.share";
 238 bool _tmpWebApplicationCookieShare = false;
 239
 240 //Motion UI
 241 static const wchar_t* _MOTION_UI = L"http://tizen.org/setting/motion.ui";
 242
 243 //Contact Order
 244 static const wchar_t* _CONTACT_ORDER_FIRSTNAME = L"http://tizen.org/setting/contacts.order.firstname";
 245 static const int _CONTACT_ORDER_FIRSTNAME_FIRSTLAST = 0;
 246 static const int _CONTACT_ORDER_FIRSTNAME_LASTFIRST = 1;
 247
 248 //Privileged key
 249 static const wchar_t* _DEVELOPER_USBDEBUGGING = L"http://tizen.org/setting/developer.usb_debugging";
 250
 251 static const int _MAX_COUNTRY_LENTH = 2;
 252 static const int _LANGUAGE_START_INDEX = 0;
 253 static const int _MAX_LANGUAGE_LENTH = 2;
 254 static const int _TOUCH_FEEDBACK_RESOLUTION = 20;
 255
 256 static const int _OSP_USB_DEFAULT_MODE = 0;
 257
 258 // ICU
 259 static const char* _ICU_DATE_FORMAT = "yMMMMEEEEd";
 260 static const char* _ICU_TIME_24_FORMAT = "Hms";
 261 static const char* _ICU_TIME_12_FORMAT = "hms";
 262
 263 static const int _DEVELOPER_USBDEBUGGING_ON = 1;
 264 static const int _DEVELOPER_USBDEBUGGING_OFF = 0;
 265
 266 // wifi direct
 267 static const char* _WIFI_DIRECT_LIBRARY_NAME = "libosp-wifi.so";
 268 static const char* _BLUETOOTH_LIBRARY_NAME = "libosp-bluetooth.so";
 269
 270 static result (*pWifiDirectDeviceImpl_Activate)(void) = null;
 271 static result (*pWifiDirectDeviceImpl_Deactivate)(void) = null;
 272 static bool (*pWifiDirectDeviceImpl_IsActivated)(void) = null;
 273 static result (*pWifiManagerImpl_Activate)(void) = null;
 274 static result (*pWifiManagerImpl_Deactivate)(void) = null;
 275 static result (*pBluetoothManagerImpl_Activate)(void) = null;
 276 static result (*pBluetoothManagerImpl_Deactivate)(void) = null;
 277
 278 _SettingManager* _SettingManager::__pSettingManager = null;
 279
 280 class _SettingEventArg : public IEventArg
 281 {
 282 public:
 283         String KeyName;
 284 };
 285
 286 class _SettingEvent : public Event
 287 {
 288 protected:
 289         virtual void FireImpl(IEventListener& listener, const IEventArg& arg)
 290         {
 291                 ISettingEventListener* pListener = dynamic_cast<ISettingEventListener*> (&listener);
 292                 const _SettingEventArg* pArg = dynamic_cast<const _SettingEventArg*>(&arg);
 293
 294                 if(pListener == null || pArg == null)
 295                 {
 296                         SysLogException(NID_SYS, E_SYSTEM, "It is failed to get listner or arguemnt");
 297                         return;
 298                 }
 299
 300                 String value =pArg->KeyName;
 301                 pListener->OnSettingChanged(value);
 302         }
 303 };
 304
 305 class _SettingAsyncEventArg : public IEventArg
 306 {
 307 public:
 308         String Key;
 309         result errorCode;
 310 };
 311
 312 class _SettingAsyncEvent : public Event
 313 {
 314 protected:
 315         virtual void FireImpl(IEventListener& listener, const IEventArg& arg)
 316         {
 317                 ISettingInfoSetValueAsyncResultListener* pListener = dynamic_cast<ISettingInfoSetValueAsyncResultListener*> (&listener);
 318                 const _SettingAsyncEventArg* pArg = dynamic_cast<const _SettingAsyncEventArg*>(&arg);
 319
 320                 if(pListener == null || pArg == null)
 321                 {
 322                         SysLogException(NID_SYS, E_SYSTEM, "It is failed to get listner or arguemnt");
 323                         return;
 324                 }
 325
 326                 result r = pArg->errorCode;
 327                 pListener->OnResultReceivedForSetValueAsync(pArg->Key, r);
 328                 RemoveListener(listener);
 329                 delete pListener;
 330         }
 331 };
 332
 333 void
 334 _SettingManager::InitSettingManager(void)
 335 {
 336         static _SettingManager settingManager;
 337         __pSettingManager = &settingManager;
 338 }
 339
 340 _SettingManager*
 341 _SettingManager::GetInstance(void)
 342 {
 343         static pthread_once_t once_block = PTHREAD_ONCE_INIT;
 344         if(__pSettingManager == null)
 345         {
 346                 pthread_once(&once_block, InitSettingManager);
 347         }
 348         return __pSettingManager;
 349 }
 350
 351 _SettingManager::_SettingManager()
 352         : __pSettingEventListener(null)
 353         , __pSettingEvent(null)
 354         , __listenerCount(0)
 355         , __registeredSettingEvents(false)
 356         , __tapiHandle(null)
 357         , __pSettingAsyncEvent(null)
 358         , __pSettingEventForInternal(null)
 359         , __listenerInternalCount(0)
 360         , __registeredSettingEventsForInternal(false)
 361         , __pWifiDllHandle(null)
 362 {
 363         __pSettingEvent = new (std::nothrow) _SettingEvent();
 364         __pSettingEventForInternal = new (std::nothrow) _SettingEvent();
 365
 366         tethering_create(&__tetheringHandle);
 367 }
 368
 369 _SettingManager::~_SettingManager()
 370 {
 371
 372         if(__registeredSettingEvents == true)
 373         {
 374                 __listenerCount = 0;
 375                 StopSettingEventListen();
 376         }
 377
 378         delete __pSettingEvent;
 379
 380         if(__tetheringHandle != null)
 381         {
 382                 tethering_destroy(__tetheringHandle);
 383         }
 384
 385         if(__pSettingAsyncEvent != null)
 386         {
 387                 delete __pSettingAsyncEvent;
 388         }
 389         __pSettingManager = null;
 390 }
 391
 392 result
 393 _SettingManager::GetValue(const String& key, String& value)
 394 {
 395         result r = E_SUCCESS;
 396
 397         if (key == _COUNTRY)
 398         {
 399                 int ret = 0;
 400                 char* pCountry = null;
 401                 String countryValue;
 402
 403                 ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_REGION, &pCountry);
 404                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE && pCountry != null, E_SYSTEM, "[E_SYSTEM] runtime_info_get_value_string RUNTIME_INFO_KEY_LANGUAGE failed");
 405
 406                 Tizen::Locales::Locale ospLoc = _LocaleImpl(pCountry).GetOspLocale();
 407                 value = ospLoc.GetCountryCodeString();
 408                 free (pCountry);
 409         }
 410         else if (key == _LOCALE_COUNTRY)
 411         {
 412                 int ret = 0;
 413                 char* pCountry = null;
 414                 String countryValue;
 415
 416                 ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_REGION, &pCountry);
 417                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE && pCountry != null, E_SYSTEM, "[E_SYSTEM] runtime_info_get_value_string RUNTIME_INFO_KEY_LANGUAGE failed");
 418
 419                 Tizen::Locales::Locale ospLoc = _LocaleImpl(pCountry).GetOspLocale();
 420                 value = ospLoc.GetLocaleCodeString();
 421                 free (pCountry);
 422         }
 423         else if (key == _DEVICE_NAME)
 424         {
 425                 std::unique_ptr<char> pDeviceName (vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR));
 426                 String deviceName;
 427                 r = StringUtil::Utf8ToString(pDeviceName.get(), deviceName);
 428                 SysTryReturn(NID_SYS, !IsFailed(r), E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 429
 430                 value = deviceName;
 431         }
 432         else if (key == _LOCALE_DATE)
 433         {
 434                 DateTime currentTime;
 435                 SystemTime::GetCurrentTime(TIME_MODE_WALL, currentTime);
 436                 String currentFormat;
 437                 GetValue(_LOCALE_DATE_FORMAT, currentFormat);
 438
 439                 std::unique_ptr<DateTimeFormatter> pFormatter(DateTimeFormatter::CreateTimeFormatterN());
 440                 SysTryReturnResult(NID_SYS, pFormatter != null, E_OUT_OF_MEMORY, "Failed to create DateTimeFomatter");
 441                 pFormatter->ApplyPattern(currentFormat);
 442                 value.Clear();
 443                 pFormatter->Format(currentTime, value);
 444         }
 445         else if (key == _LANGUAGE)
 446         {
 447                 int ret = 0;
 448                 char* pLanguage = null;
 449                 String langValue;
 450                 LanguageCode langCode = LANGUAGE_ENG;
 451
 452                 ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &pLanguage);
 453
 454                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE && pLanguage != null, E_SYSTEM, "[E_SYSTEM] runtime_info_get_value_string RUNTIME_INFO_KEY_LANGUAGE failed");
 455
 456                 r = StringUtil::Utf8ToString(pLanguage, langValue);
 457                 free(pLanguage);
 458                 SysTryReturn(NID_SYS, !IsFailed(r), E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 459
 460                 if (langValue.GetLength() > 2)
 461                 {
 462                         langValue.SubString(0, 2, langValue);
 463                 }
 464
 465                 langCode = Tizen::Locales::Locale::TwoLetterLanguageCodeStringToLanguageCode(langValue);
 466                 langValue = Tizen::Locales::Locale::LanguageCodeToString(langCode);
 467                 SysTryReturnResult(NID_SYS, langValue.GetLength() == 3, E_SYSTEM, "[E_SYSTEM] _LANGUAGEcode transform failed. value is \"%ls\"", langValue.GetPointer());
 468
 469                 value = langValue;
 470         }
 471         else if (key == _LOCALE_LANGUAGE)
 472         {
 473                 int ret = 0;
 474                 char* pCountry = null;
 475                 String countryValue;
 476                 String langValue;
 477                 LanguageCode langCode = LANGUAGE_ENG;
 478
 479                 ret = runtime_info_get_value_string(RUNTIME_INFO_KEY_LANGUAGE, &pCountry);
 480                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE && pCountry != null, E_SYSTEM, "[E_SYSTEM] runtime_info_get_value_string RUNTIME_INFO_KEY_LANGUAGE failed");
 481
 482                 r = StringUtil::Utf8ToString(pCountry, countryValue);
 483                 SysTryReturn(NID_SYS, !IsFailed(r), E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 484
 485                 free(pCountry);
 486
 487                 countryValue.SubString(0, 2, langValue);
 488                 countryValue.SubString(3, 2, countryValue);
 489
 490                 langCode = Tizen::Locales::Locale::TwoLetterLanguageCodeStringToLanguageCode(langValue);
 491                 langValue = Tizen::Locales::Locale::LanguageCodeToString(langCode);
 492                 SysTryReturnResult(NID_SYS, langValue.GetLength() == 3, E_SYSTEM, "[E_SYSTEM] _LANGUAGEcode transform failed. value is \"%ls\"", langValue.GetPointer());
 493                 value.Clear();
 494                 value.Append(langValue);
 495                 value.Append("_");
 496                 value.Append(countryValue);
 497         }
 498         else if (key == _DATE_FORMAT || key == _LOCALE_DATE_FORMAT)
 499         {
 500                 char* pDateFormat = __settingIcu.GetDateTimeFormatN(_ICU_DATE_FORMAT);
 501                 SysTryReturnResult(NID_SYS, pDateFormat != null, E_SYSTEM, "Failed to get date format");
 502                 r = StringUtil::Utf8ToString(pDateFormat, value);
 503                 free(pDateFormat);
 504         }
 505         else if (key == _LOCALE_DATETIME)
 506         {
 507                 DateTime currentTime;
 508                 SystemTime::GetCurrentTime(TIME_MODE_WALL, currentTime);
 509                 String currentFormat;
 510                 GetValue(_LOCALE_DATETIME_FORMAT, currentFormat);
 511
 512                 std::unique_ptr<DateTimeFormatter> pFormatter(DateTimeFormatter::CreateTimeFormatterN());
 513                 pFormatter->ApplyPattern(currentFormat);
 514                 value.Clear();
 515                 pFormatter->Format(currentTime, value);
 516         }
 517         else if (key == _DATE_TIME_FORMAT || key == _LOCALE_DATETIME_FORMAT)
 518         {
 519                 char* pDateFormat = __settingIcu.GetDateTimeFormatN(_ICU_DATE_FORMAT);
 520                 char* pTimeFormat = null;
 521                 String timeFormat;
 522                 bool selected24Format = false;
 523
 524                 SysLog(NID_SYS, "Date Time format");
 525                 SysTryReturnResult(NID_SYS, pDateFormat != null, E_SYSTEM, "Failed to get date format");
 526
 527                 r = GetValue(_HOUR_FORMAT_SELECTED, selected24Format);
 528                 if(r != E_SUCCESS)
 529                 {
 530                         free(pDateFormat);
 531                         SysLogException(NID_SYS, E_SYSTEM, "Failed to get 24 hour select state");
 532                         return E_SYSTEM;
 533                 }
 534                 SysLog(NID_SYS, "24hour format, %d", selected24Format);
 535                 SysLog(NID_SYS, "%s", pDateFormat);
 536
 537                 if (selected24Format == true)
 538                 {
 539                         pTimeFormat = __settingIcu.GetDateTimeFormatN(_ICU_TIME_24_FORMAT);
 540                 }
 541                 else
 542                 {
 543                         pTimeFormat = __settingIcu.GetDateTimeFormatN(_ICU_TIME_12_FORMAT);
 544                 }
 545
 546                 if(pTimeFormat == null)
 547                 {
 548                         free(pDateFormat);
 549                         SysLogException(NID_SYS, E_SYSTEM, "Failed to get date time format");
 550                         return E_SYSTEM;
 551                 }
 552
 553                 r = StringUtil::Utf8ToString(pDateFormat, value);
 554                 r = StringUtil::Utf8ToString(pTimeFormat, timeFormat);
 555
 556                 value.Append(" ");
 557                 value.Append(timeFormat);
 558                 free(pDateFormat);
 559                 free(pTimeFormat);
 560         }
 561         else if (key == _LOCALE_TIME)
 562         {
 563                 DateTime currentTime;
 564                 SystemTime::GetCurrentTime(TIME_MODE_WALL, currentTime);
 565                 String currentFormat;
 566                 GetValue(_LOCALE_TIME_FORMAT, currentFormat);
 567
 568                 std::unique_ptr<DateTimeFormatter> pFormatter(DateTimeFormatter::CreateTimeFormatterN());
 569                 pFormatter->ApplyPattern(currentFormat);
 570                 value.Clear();
 571                 pFormatter->Format(currentTime, value);
 572         }
 573         else if (key == _LOCALE_TIMEZONE)
 574         {
 575                 char pTZPath[256] = {0,};
 576                 ssize_t nLen = readlink(_LOCALE_TIMEZONE_LINK, pTZPath, sizeof(pTZPath)-1);
 577                 if (nLen != -1)
 578                 {
 579                         pTZPath[nLen] = '\0';
 580                 }
 581                 else
 582                 {
 583                         SysLogException(NID_SYS, E_SYSTEM, "Failed to get timezone");
 584                 }
 585                 value.Clear();
 586                 value.Append(&pTZPath[_LOCALE_TIMEZONE_ROOT_PATH_LENGTH]);
 587         }
 588         else if (key == _LOCALE_WEEK_FORMAT_FIRSTDAY)
 589         {
 590                 int firstDay = 0;
 591                 int ret = -1;
 592
 593                 ret = vconf_get_int(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, &firstDay);
 594                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT vconf");
 595
 596                 if (firstDay == _LOCALE_WEEK_FORMAT_VCONF_SUNDAY)
 597                 {
 598                         value = _LOCALE_WEEK_FORMAT_FIRSTDAY_SUNDAY;
 599                 }
 600                 else if (firstDay == _LOCALE_WEEK_FORMAT_VCONF_MONDAY)
 601                 {
 602                         value = _LOCALE_WEEK_FORMAT_FIRSTDAY_MONDAY;
 603                 }
 604                 else
 605                 {
 606                         r = E_SYSTEM;
 607                 }
 608         }
 609         else if (key == _NETWORK_TELEPHONY_MODE)
 610         {
 611                 value = _tmpNetworkTelephonyMode;
 612         }
 613         else if (key == _NETWORK_TELEPHONY_PROVIDER)
 614         {
 615                 value = _tmpNetworkTelephonyProvider;
 616         }
 617         else if (key == _NETWORK_WIFI_TETHERING_SECURITY_PASSWORD)
 618         {
 619                 int ret = 0;
 620                 char* password = null;
 621                 bool supported = false;
 622                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
 623                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
 624
 625                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
 626                 ret = tethering_wifi_get_passphrase(__tetheringHandle, &password);
 627                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "It is failed to get password");
 628
 629                 value.Clear();
 630                 value.Append(password);
 631                 free(password);
 632         }
 633         else if (key == _SCREEN_MODE)
 634         {
 635                 std::unique_ptr<char> curmode(vconf_get_str(_SCREEN_MODE_VCONFKEY));
 636                 value.Clear();
 637                 value.Append(curmode.get());
 638         }
 639         else if (key == _STORAGE_DIRECTORY_WAP_DOWNLOAD)
 640         {
 641                 value = _tmpStorageDirectoryWapDownload;
 642         }
 643         else if (key == _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD)
 644         {
 645                 value = _tmpStorageDirectoryBluetoothDownload;
 646         }
 647         else if (key == _STORAGE_DIRECTORY_CAMERA_RECORD)
 648         {
 649                 value = _tmpStorageDirectoryCameraRecord;
 650         }
 651         else if (key == _STORAGE_DIRECTORY_VOICE_RECORD)
 652         {
 653                 value = _tmpStorageDirectoryVoiceRecord;
 654         }
 655         else if (key == _STORAGE_DIRECTORY_RADIO_BROADCAST)
 656         {
 657                 value = _tmpStorageDirectoryRadioBroadcast;
 658         }
 659         else if (key == _STORAGE_DIRECTORY_VIDEO_BROADCAST)
 660         {
 661                 value = _tmpStorageDirectoryVideoBroadcast;
 662         }
 663         else if (key == _FONTTYPE || key == _FONT_TYPE)
 664         {
 665                 char* pFontType = null;
 666                 int res = 0;
 667                 res = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &pFontType);
 668                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "Failed to get font type");
 669                 r = StringUtil::Utf8ToString(pFontType, value);
 670                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 671                 free(pFontType);
 672         }
 673         else if (key == _FONT_SIZE || key == _FONTSIZE)
 674         {
 675                 int fontSize = 0;
 676                 int res = 0;
 677                 res = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &fontSize);
 678                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "Failed to get font size");
 679                 value.Clear();
 680                 switch (fontSize)
 681                 {
 682                 case _FONT_SIZE_GIANT_VCONF:
 683                         if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
 684                         {
 685                                 value.Append(_FONT_SIZE_GIANT);
 686                                 break;
 687                         }
 688                 case _FONT_SIZE_HUGE_VCONF:
 689                         if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
 690                         {
 691                                 value.Append(_FONT_SIZE_HUGE);
 692                                 break;
 693                         }
 694                 case _FONT_SIZE_LARGE_VCONF:
 695                         value.Append(_FONT_SIZE_LARGE);
 696                         break;
 697                 case _FONT_SIZE_MEDIUM_VCONF:
 698                         value.Append(_FONT_SIZE_MEDIUM);
 699                         break;
 700                 case _FONT_SIZE_SMALL_VCONF:
 701                         value.Append(_FONT_SIZE_SMALL);
 702                         break;
 703                 default:
 704                         r = E_SYSTEM;
 705                         break;
 706                 }
 707                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
 708                 {
 709                         value.ToLowerCase();
 710                 }
 711         }
 712         else if (key == _RINGTONE || key == _SOUND_RINGTONE)
 713         {
 714                 char* pRingtone = null;
 715                 int res = 0;
 716                 res = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, &pRingtone);
 717                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "Failed to get ringtone");
 718
 719                 r = StringUtil::Utf8ToString(pRingtone, value);
 720                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 721
 722                 free(pRingtone);
 723
 724         }
 725         else if (key == _TIME_FORMAT || key == _LOCALE_TIME_FORMAT)
 726         {
 727                 char* pTimeFormat = null;
 728                 bool selected24Format = false;
 729
 730                 r = GetValue(_HOUR_FORMAT_SELECTED, selected24Format);
 731
 732                 if (selected24Format == true)
 733                 {
 734                         pTimeFormat = __settingIcu.GetDateTimeFormatN(_ICU_TIME_24_FORMAT);
 735                 }
 736                 else
 737                 {
 738                         pTimeFormat = __settingIcu.GetDateTimeFormatN(_ICU_TIME_12_FORMAT);
 739                 }
 740                 SysTryReturnResult(NID_SYS, pTimeFormat != null, E_SYSTEM, "Failed to get time format");
 741                 r = StringUtil::Utf8ToString(pTimeFormat, value);
 742                 free(pTimeFormat);
 743         }
 744         else if (key == _WALLPAPER || key == _SCREEN_WALLPAPER)
 745         {
 746                 int ret = 0;
 747                 char* pWallpaper = null;
 748
 749                 ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, &pWallpaper);
 750                 SysTryReturn(NID_SYS, ret == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to get wallpaper of home screen");
 751
 752                 r = StringUtil::Utf8ToString(pWallpaper, value);
 753                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 754
 755                 free(pWallpaper);
 756         }
 757         else if (key == _SCREEN_WALLPAPER_LOCK)
 758         {
 759                 int ret = 0;
 760                 char* pWallpaper = null;
 761
 762                 ret = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, &pWallpaper);
 763                 SysTryReturn(NID_SYS, ret == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to get wallpaper of lock screen");
 764
 765                 r = StringUtil::Utf8ToString(pWallpaper, value);
 766                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 767
 768                 free(pWallpaper);
 769         }
 770         else if (key == _USBMODE)
 771         {
 772                 value = _USBMODE_MTP;
 773         }
 774         else
 775         {
 776                 r = E_OBJ_NOT_FOUND;
 777         }
 778         return r;
 779 }
 780
 781 result
 782 _SettingManager::GetValue(const String& key, int& value)
 783 {
 784         result r = E_SUCCESS;
 785         if (key == _TOUCH_VIBRATION_LEVEL || key == _VIBRATOR_LEVEL)
 786         {
 787                 int vibLevel = -1;
 788                 int ret = 0;
 789                 ret = runtime_info_get_value_int(RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK, &vibLevel);
 790                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "runtime_info_get_value_int(RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK) is Failed");
 791
 792                 value = vibLevel * _TOUCH_FEEDBACK_RESOLUTION;
 793         }
 794         else if (key == _MEDIA_SOUND_VOLUME || key == _SOUND_MEDIA_VOLUME)
 795         {
 796                 int volume = 0;
 797                 int maxVolume = 0;
 798
 799                 int ret = sound_manager_get_max_volume(SOUND_TYPE_MEDIA, &maxVolume);
 800                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume Failed");
 801
 802                 ret = sound_manager_get_volume(SOUND_TYPE_MEDIA, &volume);
 803                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume Failed");
 804
 805                 value = volume;
 806         }
 807         else if (key == _NOTIFICATION_SOUND_VOLUME || key == _SOUND_NOTIFICATION_VOLUME)
 808         {
 809                 int volume = 0;
 810                 int maxVolume = 0;
 811
 812                 int ret = sound_manager_get_max_volume(SOUND_TYPE_NOTIFICATION, &maxVolume);
 813                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume Failed");
 814
 815                 ret = sound_manager_get_volume(SOUND_TYPE_NOTIFICATION, &volume);
 816                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume Failed");
 817
 818                 value = volume;
 819         }
 820         else if (key == _RINGTONE_SOUND_VOLUME || key == _SOUND_RINGTONE_VOLUME)
 821         {
 822                 int volume = 0;
 823                 int maxVolume = 0;
 824
 825                 int ret = sound_manager_get_max_volume(SOUND_TYPE_RINGTONE, &maxVolume);
 826                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume Failed");
 827
 828                 ret = sound_manager_get_volume(SOUND_TYPE_RINGTONE, &volume);
 829                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume Failed");
 830
 831                 value = volume;
 832         }
 833         else if (key == _SYSTEM_SOUND_VOLUME || key == _SOUND_SYSTEM_VOLUME)
 834         {
 835                 int volume = 0;
 836                 int maxVolume = 0;
 837
 838                 int ret = sound_manager_get_max_volume(SOUND_TYPE_SYSTEM, &maxVolume);
 839                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_max_volume Failed");
 840
 841                 ret = sound_manager_get_volume(SOUND_TYPE_SYSTEM, &volume);
 842                 SysTryReturnResult(NID_SYS, ret == SOUND_MANAGER_ERROR_NONE, E_SYSTEM, "sound_manager_get_volume Failed");
 843
 844                 value = volume;
 845         }
 846         else if (key == _SCREEN_BRIGHTNESS)
 847         {
 848                 int brightness = 0;
 849                 int ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness);
 850                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_LCD_BRIGHTNESS vconf");
 851                 value = brightness;
 852         }
 853         else if (key == _SCREEN_BACKLIGHT_TIME)
 854         {
 855                 int timeout = 0;
 856                 int ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, &timeout);
 857                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_TIMEOUT_NORMAL vconf");
 858                 value = timeout;
 859         }
 860         else if (key == _VIBRATOR_LEVEL_NOTIFICATION)
 861         {
 862                 int level = 0;
 863                 int ret = vconf_get_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, &level);
 864                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT vconf");
 865                 value = level;
 866         }
 867         else
 868         {
 869                 r = E_OBJ_NOT_FOUND;
 870         }
 871         return r;
 872 }
 873
 874 result
 875 _SettingManager::GetValue(const String& originalKey, long long& value)
 876 {
 877         return E_OBJ_NOT_FOUND;
 878 }
 879
 880 result
 881 _SettingManager::GetValue(const String& originalKey, double& value)
 882 {
 883         return E_OBJ_NOT_FOUND;
 884 }
 885
 886 result
 887 _SettingManager::GetValue(const String& key, bool& value)
 888 {
 889         result r = E_SUCCESS;
 890         int vconf_bool = 0;
 891         int ret = -1;
 892
 893         if (key == _BATTERY_FORMAT_PERCENTAGE)
 894         {
 895                 ret = vconf_get_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, &vconf_bool);
 896                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL vconf");
 897
 898                 if(vconf_bool == 0)
 899                 {
 900                         value = false;
 901                 }
 902                 else
 903                 {
 904                         value = true;
 905                 }
 906         }
 907         else if (key == _LOCALE_UPDATE_AUTO)
 908         {
 909                 ret = vconf_get_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, &vconf_bool);
 910                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL vconf");
 911                 value = vconf_bool ? true : false;
 912         }
 913         else if (key == _NETWORK_WIFI)
 914         {
 915                 bool supported = false;
 916                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
 917                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
 918
 919                 int wifiState = 0;
 920                 ret = vconf_get_int(VCONFKEY_WIFI_STATE, &wifiState);
 921                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_WIFI_STATE vconf");
 922                 if(wifiState== VCONFKEY_WIFI_OFF)
 923                 {
 924                         value = false;
 925                 }
 926                 else
 927                 {
 928                         value = true;
 929                 }
 930                 return r;
 931         }
 932         else if (key == _NETWORK_WIFI_NOTIFICATION)
 933         {
 934                 int wifiQSState = 0;
 935                 bool supported = false;
 936                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
 937                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
 938
 939                 ret = vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &wifiQSState);
 940                 SysTryReturnResult(NID_SYS, ret != -1, E_UNSUPPORTED_OPERATION, "Current device does not support %ls key.", key.GetPointer());
 941                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_WIFI_ENABLE_QS vconf");
 942
 943                 if(wifiQSState == VCONFKEY_WIFI_QS_DISABLE)
 944                 {
 945                         value = false;
 946                 }
 947                 else
 948                 {
 949                         value = true;
 950                 }
 951                 return r;
 952         }
 953         else if (key == _NETWORK_WIFI_TETHERING)
 954         {
 955                 bool supported = false;
 956                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
 957                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
 958
 959                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
 960                 value = tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_WIFI);
 961                 return r;
 962         }
 963         else if (key == _NETWORK_WIFI_TETHERING_HIDE)
 964         {
 965                 bool supported = false;
 966                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
 967                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
 968
 969                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
 970                 ret = tethering_wifi_get_ssid_visibility(__tetheringHandle, &value);
 971                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to get wifi tethering visibility state");
 972                 return r;
 973         }
 974         else if (key == _NETWORK_WIFI_TETHERING_SECURITY)
 975         {
 976                 bool supported = false;
 977                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
 978                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
 979
 980                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
 981                 tethering_wifi_security_type_e securityType;
 982                 ret = tethering_wifi_get_security_type(__tetheringHandle, &securityType);
 983                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to get wifi tethering securiy state");
 984                 if(securityType == TETHERING_WIFI_SECURITY_TYPE_NONE)
 985                 {
 986                         value = false;
 987                 }
 988                 else
 989                 {
 990                         value = true;
 991                 }
 992                 return r;
 993         }
 994         else if (key == _NETWORK_WIFI_DIRECT)
 995         {
 996                 bool supported = false;
 997                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI_DIRECT, supported);
 998                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support WiFi direct feature");
 999                 SysTryReturnResult(NID_SYS, LoadWifiDll() == E_SUCCESS, E_SYSTEM, "Failed to open wifi so");
1000
1001                 bool isActivated = false;
1002                 isActivated = pWifiDirectDeviceImpl_IsActivated();
1003
1004                 UnloadWifiDll();
1005                 SysTryReturnResult(NID_SYS, GetLastResult() == E_SUCCESS, E_SYSTEM, "Failed to get wifi direct state");
1006                 value = isActivated;
1007                 return r;
1008         }
1009         else if (key == _NETWORK_BLUETOOTH)
1010         {
1011                 int bluetoothStatus = VCONFKEY_BT_STATUS_OFF;
1012                 ret = vconf_get_int(VCONFKEY_BT_STATUS, &bluetoothStatus);
1013                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to read bluetooth status.");
1014
1015                 if(bluetoothStatus == VCONFKEY_BT_STATUS_OFF)
1016                 {
1017                         value = false;
1018                 }
1019                 else
1020                 {
1021                         value = true;
1022                 }
1023
1024                 return r;
1025         }
1026         else if (key == _NETWORK_BLUETOOTH_TETHERING)
1027         {
1028                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1029                 value  = tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_BT);
1030                 return r;
1031         }
1032         else if (key == _SCREEN_BRIGHTNESS_AUTO)
1033         {
1034                 int brightnessAuto = 0;
1035                 int ret = vconf_get_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, &brightnessAuto);
1036                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL vconf");
1037
1038                 if(brightnessAuto == 0)
1039                 {
1040                         value = false;
1041                 }
1042                 else
1043                 {
1044                         value = true;
1045                 }
1046                 return r;
1047         }
1048         else if (key == _SOUND_LOCK)
1049         {
1050                 int soundLock = 0;
1051                 int ret = vconf_get_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, &soundLock);
1052                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_SOUND_LOCK_BOO vconf");
1053                 if(soundLock == 0)
1054                 {
1055                         value = false;
1056                 }
1057                 else
1058                 {
1059                         value = true;
1060                 }
1061                 return r;
1062         }
1063         else if (key == _SOUND_TOUCH)
1064         {
1065                 int soundTouch = 0;
1066                 int ret = vconf_get_bool(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, &soundTouch);
1067                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL vconf");
1068                 if(soundTouch == 0)
1069                 {
1070                         value = false;
1071                 }
1072                 else
1073                 {
1074                         value = true;
1075                 }
1076                 return r;
1077         }
1078         else if (key == _VIBRATOR)
1079         {
1080                 ret = vconf_get_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, &vconf_bool);
1081                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL vconf");
1082                 value = vconf_bool ? true : false;
1083                 return r;
1084         }
1085         else if (key == _USB_TETHERING)
1086         {
1087                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1088                 value = tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_USB);
1089                 return r;
1090         }
1091         else if (key == _WEB_APPLICATION_COOKIE_SHARE)
1092         {
1093                 value = _tmpWebApplicationCookieShare;
1094                 return r;
1095         }
1096         else if (key == _LOCATION_GPS_ADVANCED)
1097         {
1098                 int agps = 0;
1099                 ret = vconf_get_int(VCONFKEY_LOCATION_AGPS_ENABLED, &agps);
1100                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL vconf");
1101
1102                 if(agps == 0)
1103                 {
1104                         value = false;
1105                 }
1106                 else
1107                 {
1108                         value = true;
1109                 }
1110
1111                 return r;
1112         }
1113         else if (key == _SCREEN_ROTATION_AUTO)
1114         {
1115                 ret = vconf_get_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, &vconf_bool);
1116                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL vconf");
1117                 value = vconf_bool;
1118         }
1119         else if (key == _HOUR_FORMAT_SELECTED || key == _LOCALE_TIME_FORMAT_24HOUR)
1120         {
1121                 bool is24HoueEnabled = false;
1122                 ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED, &is24HoueEnabled);
1123                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the SYSTEM_INFO_KEY__WIFI_SUPPORTED");
1124                 value = is24HoueEnabled;
1125
1126                 return r;
1127         }
1128         else if (key == _ENABLE_MOTION || key == _MOTION_UI)
1129         {
1130                 bool enableMotion = false;
1131                 ret = system_settings_get_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, &enableMotion);
1132                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get the SYSTEM_SETTINGS_KEY_MOTION_ACTIVIATION");
1133                 value = enableMotion;
1134
1135                 return r;
1136         }
1137         else if (key == _DATA_ROAMING_ENABLED || key == _NETWORK_TELEPHONY_ROAMING)
1138         {
1139                 bool dataRoamingEnabled = false;
1140                 ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED, &dataRoamingEnabled);
1141                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED");
1142                 value = dataRoamingEnabled;
1143
1144                 return r;
1145         }
1146         else if (key == _GPS_ENABLED || key == _LOCATION_GPS)
1147         {
1148                 int gps_value = 0;
1149                 ret = vconf_get_int(VCONFKEY_LOCATION_ENABLED, &gps_value);
1150                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get the VCONFKEY_LOCATION_ENABLED");
1151                 if(gps_value == 0)
1152                 {
1153                         value = false;
1154                 }
1155                 else
1156                 {
1157                         value = true;
1158                 }
1159         }
1160         else if (key == _PACKET_SERVICE_ALLOWED || key == _NETWORK_TELEPHONY_PACKETSERVICE)
1161         {
1162                 bool packetServiceAllowed = false;
1163                 ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_PACKET_DATA_ENABLED, &packetServiceAllowed);
1164                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the RUNTIME_INFO_KEY_PACKET_DATA_ENABLED");
1165                 value = packetServiceAllowed;
1166
1167                 return r;
1168         }
1169         else if (key == _SILENT_MODE || key == _SOUND_SILENTMODE)
1170         {
1171                 bool silentModeEnabled = false;
1172                 ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_SILENT_MODE_ENABLED, &silentModeEnabled);
1173                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the RUNTIME_INFO_KEY_SILENT_MODE_ENABLED");
1174                 value = !silentModeEnabled;
1175
1176                 return r;
1177         }
1178         else if (key == _WPS_ENABLED || key == _LOCATION_WPS)
1179         {
1180                 int wps_value = 0;
1181                 ret = vconf_get_int(VCONFKEY_LOCATION_NETWORK_ENABLED, &wps_value);
1182                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get the VCONFKEY_LOCATION_NETWORK_ENABLED");
1183                 if(wps_value == 0)
1184                 {
1185                         value = false;
1186                 }
1187                 else
1188                 {
1189                         value = true;
1190                 }
1191
1192         }
1193         else if (key == _FLIGHT_MODE_ENABLED || key == _NETWORK_FLIGHTMODE)
1194         {
1195                 bool flightModeEnabled = false;
1196                 ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED, &flightModeEnabled);
1197                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED");
1198                 value = flightModeEnabled;
1199
1200                 return r;
1201         }
1202         else if (key == _DEVELOPER_USBDEBUGGING)
1203         {
1204                 int usbMode = 0;
1205                 ret = vconf_get_bool(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, &usbMode);
1206                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL");
1207                 value = usbMode == _DEVELOPER_USBDEBUGGING_ON;
1208         }
1209         else if (key == _NETWORK_TELEPHONY_ROAMING)
1210         {
1211                 ret = vconf_get_bool(VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, &vconf_bool);
1212                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL");
1213                 value = vconf_bool ? true : false;
1214         }
1215         else if (key == _CONTACT_ORDER_FIRSTNAME)
1216         {
1217                 int contactOrder = 0;
1218                 ret = vconf_get_int(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, &contactOrder);
1219                 SysTryReturnResult(NID_SYS, ret == RUNTIME_INFO_ERROR_NONE, E_SYSTEM, "Failed to get the VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER");
1220
1221                 if (contactOrder == _CONTACT_ORDER_FIRSTNAME_FIRSTLAST)
1222                 {
1223                         value = true;
1224                 }
1225                 else if (contactOrder == _CONTACT_ORDER_FIRSTNAME_LASTFIRST)
1226                 {
1227                         value = false;
1228                 }
1229                 else
1230                 {
1231                         return E_SYSTEM;
1232                 }
1233         }
1234         else
1235         {
1236                 r = E_OBJ_NOT_FOUND;
1237         }
1238
1239         return r;
1240 }
1241
1242 result
1243 _SettingManager::GetValue(const String& originalKey, UuId& value)
1244 {
1245         return E_OBJ_NOT_FOUND;
1246 }
1247
1248 result
1249 _SettingManager::GetValueForPrivilegedKey(const String& originalKey, bool& value)
1250 {
1251         return E_OBJ_NOT_FOUND;
1252 }
1253
1254 result
1255 _SettingManager::SetValue(const String& key, const bool& value)
1256 {
1257         int ret = -1;
1258
1259         if(key == _LOCALE_TIME_FORMAT_24HOUR)
1260         {
1261                 ret = vconf_set_int(VCONFKEY_REGIONFORMAT_TIME1224, value ? VCONFKEY_TIME_FORMAT_24 : VCONFKEY_TIME_FORMAT_12);
1262                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_REGIONFORMAT_TIME1224 vconf");
1263         }
1264         else if(key == _BATTERY_FORMAT_PERCENTAGE)
1265         {
1266                 ret = vconf_set_bool(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, value);
1267                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL vconf");
1268         }
1269         else if(key == _LOCALE_UPDATE_AUTO)
1270         {
1271                 ret = vconf_set_bool(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, value);
1272                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL vconf");
1273         }
1274         else if(key == _NETWORK_WIFI_NOTIFICATION)
1275         {
1276                 bool supported = false;
1277                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
1278                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
1279
1280                 int currentValue = 0;
1281                 ret = vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &currentValue);
1282                 SysTryReturnResult(NID_SYS, ret != -1, E_UNSUPPORTED_OPERATION, "This device does not support %ls key.", key.GetPointer());
1283
1284                 if(value == true)
1285                 {
1286                         ret = vconf_set_int(VCONFKEY_WIFI_ENABLE_QS, VCONFKEY_WIFI_QS_ENABLE);
1287                 }
1288                 else
1289                 {
1290                         ret = vconf_set_int(VCONFKEY_WIFI_ENABLE_QS, VCONFKEY_WIFI_QS_DISABLE);
1291                 }
1292                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_WIFI_ENABLE_QS vconf");
1293         }
1294         else if(key == _NETWORK_WIFI_TETHERING)
1295         {
1296                 result r = E_SUCCESS;
1297
1298                 bool supported = false;
1299                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
1300                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
1301
1302                 sim_state_e simState;
1303                 ret = sim_get_state(&simState);
1304
1305                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get the SIM state");
1306                 SysTryReturnResult(NID_SYS, simState != SIM_STATE_UNAVAILABLE, E_INVALID_STATE, "SIM is not available");
1307                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1308
1309                 bool state = false;
1310                 r = GetValue(_NETWORK_WIFI, state);
1311                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "Failed to get the WIFI state");
1312                 SysTryReturnResult(NID_SYS, state == true, E_INVALID_STATE, "WIFI is not activated");
1313
1314                 if(value == true)
1315                 {
1316                         if(tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_WIFI) == false)
1317                         {
1318                                 ret = tethering_enable(__tetheringHandle, TETHERING_TYPE_WIFI);
1319                         }
1320                 }
1321                 else
1322                 {
1323                         if(tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_WIFI) == true)
1324                         {
1325                                 ret = tethering_disable(__tetheringHandle, TETHERING_TYPE_WIFI);
1326                         }
1327                 }
1328                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to change tethering option");
1329         }
1330         else if(key == _NETWORK_WIFI_TETHERING_HIDE)
1331         {
1332                 bool supported = false;
1333                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
1334                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
1335
1336                 bool currentState = false;
1337                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1338                 ret = tethering_wifi_get_ssid_visibility(__tetheringHandle, &currentState);
1339                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to current wifi tethering visibility setting");
1340
1341                 if(value == true && currentState == false)
1342                 {
1343                         ret = tethering_wifi_set_ssid_visibility(__tetheringHandle, true);
1344                 }
1345                 else if(value == false && currentState == true)
1346                 {
1347                         ret = tethering_wifi_set_ssid_visibility(__tetheringHandle, false);
1348                 }
1349
1350                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to change wifi tethering visibility setting");
1351         }
1352         else if(key == _NETWORK_WIFI_TETHERING_SECURITY)
1353         {
1354                 bool supported = false;
1355                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
1356                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
1357
1358                 tethering_wifi_security_type_e securityType;
1359                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1360                 ret = tethering_wifi_get_security_type(__tetheringHandle, &securityType);
1361                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to get wifi tethering securiy state");
1362
1363                 if(value == true && securityType == TETHERING_WIFI_SECURITY_TYPE_NONE)
1364                 {
1365                         ret = tethering_wifi_set_security_type(__tetheringHandle, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK);
1366                 }
1367                 else if(value == false && securityType == TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK)
1368                 {
1369                         ret = tethering_wifi_set_security_type(__tetheringHandle, TETHERING_WIFI_SECURITY_TYPE_NONE);
1370                 }
1371                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to change wifi tethering visibility setting");
1372         }
1373         else if(key == _NETWORK_BLUETOOTH)
1374         {
1375                 bool supported = false;
1376                 int bluetoothStatus = VCONFKEY_BT_STATUS_OFF;
1377                 result r = E_SUCCESS;
1378                 r = _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_BLUETOOTH, supported);
1379                 SysTryReturnResult(NID_SYS, supported == true && r == E_SUCCESS, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
1380                 SysTryReturnResult(NID_SYS, LoadBluetoothDll() == E_SUCCESS, E_SYSTEM, "It is failed to load bluetooth library.");
1381
1382                 ret = vconf_get_int(VCONFKEY_BT_STATUS, &bluetoothStatus);
1383                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to read bluetooth status.");
1384
1385                 if(value == true)
1386                 {
1387                         if(bluetoothStatus == VCONFKEY_BT_STATUS_OFF)
1388                         {
1389                                 r = pBluetoothManagerImpl_Activate();
1390                         }
1391                 }
1392                 else
1393                 {
1394                         if(bluetoothStatus != VCONFKEY_BT_STATUS_OFF)
1395                         {
1396                                 r = pBluetoothManagerImpl_Deactivate();
1397                         }
1398                 }
1399
1400                 UnloadBluetoothDll();
1401                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to change bluetooth state.");
1402         }
1403         else if(key == _NETWORK_BLUETOOTH_TETHERING)
1404         {
1405                 result r = E_SUCCESS;
1406                 sim_state_e simState;
1407                 ret = sim_get_state(&simState);
1408
1409                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get the SIM state");
1410                 SysTryReturnResult(NID_SYS, simState != SIM_STATE_UNAVAILABLE, E_INVALID_STATE, "SIM is not available");
1411                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1412
1413                 bool state = false;
1414                 r = GetValue(_NETWORK_BLUETOOTH, state);
1415                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "Failed to get the Bluetooth state");
1416                 SysTryReturnResult(NID_SYS, state == true, E_INVALID_STATE, "Bluetooth is not activated");
1417
1418                 if(value == true)
1419                 {
1420                         if(tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_BT) == false)
1421                         {
1422                                 ret = tethering_enable(__tetheringHandle, TETHERING_TYPE_BT);
1423                         }
1424                 }
1425                 else
1426                 {
1427                         if(tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_BT) == true)
1428                         {
1429                                 ret = tethering_disable(__tetheringHandle, TETHERING_TYPE_BT);
1430                         }
1431                 }
1432                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to change tethering option");
1433         }
1434         else if(key == _SCREEN_BRIGHTNESS_AUTO)
1435         {
1436                 if(value == true)
1437                 {
1438                         ret = vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_ON);
1439                 }
1440                 else
1441                 {
1442                         ret = vconf_set_int(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SETTING_BRIGHTNESS_AUTOMATIC_OFF);
1443                 }
1444                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL vconf");
1445         }
1446         else if(key == _SOUND_LOCK)
1447         {
1448                 ret = vconf_set_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, value);
1449                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_SOUND_LOCK_BOOL vconf");
1450         }
1451         else if(key == _SOUND_TOUCH)
1452         {
1453                 ret = vconf_set_bool(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, value);
1454                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL vconf");
1455         }
1456         else if(key == _USB_TETHERING)
1457         {
1458                 sim_state_e simState;
1459                 ret = sim_get_state(&simState);
1460
1461                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get the SIM state");
1462                 SysTryReturnResult(NID_SYS, simState != SIM_STATE_UNAVAILABLE, E_INVALID_STATE, "SIM is not available");
1463                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1464
1465                 if(value == true)
1466                 {
1467                         if(tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_USB) == false)
1468                         {
1469                                 ret = tethering_enable(__tetheringHandle, TETHERING_TYPE_USB);
1470                         }
1471                 }
1472                 else
1473                 {
1474                         if(tethering_is_enabled(__tetheringHandle, TETHERING_TYPE_USB) == true)
1475                         {
1476                                 ret = tethering_disable(__tetheringHandle, TETHERING_TYPE_USB);
1477                         }
1478                 }
1479                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to change tethering option");
1480         }
1481         else if(key == _WEB_APPLICATION_COOKIE_SHARE)
1482         {
1483                 _tmpWebApplicationCookieShare = value;
1484         }
1485         else if(key == _VIBRATOR)
1486         {
1487                 if(!value)
1488                 {
1489                         ret = haptic_open(HAPTIC_DEVICE_0, &__hapticHandle);
1490                         SysTryReturnResult(NID_SYS, ret == HAPTIC_ERROR_NONE, E_SYSTEM, "It is failed to open haptic library");
1491                         haptic_stop_all_effects(__hapticHandle);
1492                         ret = haptic_close(__hapticHandle);
1493                         SysTryReturnResult(NID_SYS, ret == HAPTIC_ERROR_NONE, E_SYSTEM, "It is failed to close haptic library");
1494                         __hapticHandle = null;
1495                 }
1496                 ret = vconf_set_bool(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, value);
1497                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL vconf");
1498         }
1499         else if(key == _SCREEN_ROTATION_AUTO)
1500         {
1501                 ret = vconf_set_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, value);
1502                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL vconf");
1503         }
1504         else if(key == _SOUND_SILENTMODE)
1505         {
1506                 bool silentMode = !value;
1507                 ret = vconf_set_bool(VCONFKEY_SETAPPL_SOUND_STATUS_BOOL, silentMode);
1508                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_SOUND_STATUS_BOOL vconf");
1509         }
1510         else if (key == _CONTACT_ORDER_FIRSTNAME)
1511         {
1512                 int contactOrder = 0;
1513
1514                 if (value)
1515                 {
1516                         contactOrder = _CONTACT_ORDER_FIRSTNAME_FIRSTLAST;
1517                 }
1518                 else
1519                 {
1520                         contactOrder = _CONTACT_ORDER_FIRSTNAME_LASTFIRST;
1521                 }
1522                 ret = vconf_set_int(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, contactOrder);
1523                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER vconf");
1524         }
1525         else if(key == _MOTION_UI)
1526         {
1527                 ret = system_settings_set_value_bool(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, value);
1528                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set the SYSTEM_SETTINGS_KEY_MOTION_ACTIVIATION");
1529         }
1530         else
1531         {
1532                 return E_OBJ_NOT_FOUND;
1533         }
1534         return E_SUCCESS;
1535 }
1536
1537 result
1538 _SettingManager::SetValue(const String& key, const int& value)
1539 {
1540         if(key == _VIBRATOR_LEVEL)
1541         {
1542                 SysTryReturnResult(NID_SYS, value >= 0 && value <= 100, E_INVALID_ARG, "Speicified value is not valid");
1543                 int ret = vconf_set_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, value);
1544                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT vconf");
1545         }
1546         else if(key == _VIBRATOR_LEVEL_NOTIFICATION)
1547         {
1548                 SysTryReturnResult(NID_SYS, value >= 0 && value <= 100, E_INVALID_ARG, "Speicified value is not valid");
1549                 int ret = vconf_set_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, value);
1550                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT vconf");
1551         }
1552         else if(key == _SCREEN_BRIGHTNESS)
1553         {
1554                 SysTryReturnResult(NID_SYS, value > 0 && value <= 100, E_INVALID_ARG, "Out of range");
1555
1556                 int ret = vconf_set_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, value);
1557                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_TIMEOUT_NORMAL vconf");
1558                 ret = device_set_brightness(0, value);
1559                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to update on Screen Brightness vconf");
1560         }
1561         else if(key == _SCREEN_BACKLIGHT_TIME)
1562         {
1563                 SysTryReturnResult(NID_SYS, value == 15 || value == 30 || value == 60 || value == 120 || value == 300 || value == 600, E_INVALID_ARG, "Out of range");
1564
1565                 int ret = vconf_set_int(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, value);
1566                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL vconf");
1567         }
1568         else if (key == _SOUND_SYSTEM_VOLUME)
1569         {
1570                 return SetVolume(_SYSTEM_SOUND_VOLUME, value);
1571         }
1572         else if (key == _SOUND_MEDIA_VOLUME)
1573         {
1574                 return SetVolume(_MEDIA_SOUND_VOLUME, value);
1575         }
1576         else if (key ==_SOUND_RINGTONE_VOLUME)
1577         {
1578                 return SetVolume(_RINGTONE_SOUND_VOLUME, value);
1579         }
1580         else if (key == _SOUND_NOTIFICATION_VOLUME)
1581         {
1582                 return SetVolume(_NOTIFICATION_SOUND_VOLUME, value);
1583         }
1584         else
1585         {
1586                 return E_OBJ_NOT_FOUND;
1587         }
1588         return E_SUCCESS;
1589 }
1590
1591 result
1592 _SettingManager::SetValue(const String& key, const String& value)
1593 {
1594         result r = E_SUCCESS;
1595
1596         if (key == _LOCALE_DATE_FORMAT
1597                 || key == _LOCALE_DATETIME_FORMAT
1598                 || key == _LOCALE_TIME_FORMAT )
1599         {
1600         }
1601         else if(key == _DEVICE_NAME)
1602         {
1603                 char* deviceName = _StringConverter::CopyToCharArrayN(value);
1604                 SysTryReturnResult(NID_SYS, deviceName != null, E_SYSTEM, "Failed to convert String to string");
1605
1606                 int err = vconf_set_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR, deviceName);
1607                 delete [] deviceName;
1608                 SysTryReturnResult(NID_SYS, err == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_DEVICE_NAME_STR vconf");
1609         }
1610         else if(key == _LOCALE_COUNTRY)
1611         {
1612                 int err = 0;
1613                 std::unique_ptr<char> lang (_StringConverter::CopyToCharArrayN(value));
1614                 SysTryReturnResult(NID_SYS, lang != null, E_SYSTEM, "Failed to convert String to string");
1615
1616                 icu::Locale locale(lang.get());
1617                 err = locale.isBogus();
1618                 SysTryReturnResult(NID_SYS, err == 0, E_INVALID_ARG, "Unknown language format");
1619
1620                 std::string localeCode(locale.getLanguage());
1621                 localeCode.append("_");
1622                 localeCode.append(locale.getCountry());
1623                 localeCode.append(".utf8");
1624
1625                 err = vconf_set_str(VCONFKEY_REGIONFORMAT, localeCode.c_str());
1626                 SysTryReturnResult(NID_SYS, err == 0, E_SYSTEM, "Failed to set on VCONFKEY_REGIONFORMAT vconf");
1627         }
1628         else if(key == _LOCALE_LANGUAGE)
1629         {
1630                 int err = 0;
1631                 std::unique_ptr<char> lang (_StringConverter::CopyToCharArrayN(value));
1632                 SysTryReturnResult(NID_SYS, lang != null, E_SYSTEM, "Failed to convert String to string");
1633
1634                 icu::Locale locale(lang.get());
1635                 err = locale.isBogus();
1636                 SysTryReturnResult(NID_SYS, err == 0, E_INVALID_ARG, "Unknown language format");
1637
1638                 std::string localeCode(locale.getLanguage());
1639                 localeCode.append("_");
1640                 localeCode.append(locale.getCountry());
1641                 localeCode.append(".utf8");
1642
1643                 err = vconf_set_str(VCONFKEY_LANGSET, localeCode.c_str());
1644                 SysTryReturnResult(NID_SYS, err == 0, E_SYSTEM, "Failed to set on VCONFKEY_LANGSET vconf");
1645         }
1646         else if(key == _LOCALE_WEEK_FORMAT_FIRSTDAY)
1647         {
1648                 int firstDay = 0;
1649                 int ret = -1;
1650
1651                 if (value == _LOCALE_WEEK_FORMAT_FIRSTDAY_SUNDAY)
1652                 {
1653                         firstDay = _LOCALE_WEEK_FORMAT_VCONF_SUNDAY;
1654                 }
1655                 else if (value == _LOCALE_WEEK_FORMAT_FIRSTDAY_MONDAY)
1656                 {
1657                         firstDay = _LOCALE_WEEK_FORMAT_VCONF_MONDAY;
1658                 }
1659                 else
1660                 {
1661                         return E_INVALID_ARG;
1662                 }
1663
1664                 ret = vconf_set_int(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, firstDay);
1665                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT vconf");
1666         }
1667         else if (key == _FONT_SIZE)
1668         {
1669                 int fontSize = 0;
1670                 int res = 0;
1671
1672                 if (value == _FONT_SIZE_GIANT_LOWERCASE)
1673                 {
1674                         fontSize = _FONT_SIZE_GIANT_VCONF;
1675                 }
1676                 else if (value == _FONT_SIZE_HUGE_LOWERCASE)
1677                 {
1678                         fontSize = _FONT_SIZE_HUGE_VCONF;
1679                 }
1680                 else if (value == _FONT_SIZE_LARGE_LOWERCASE)
1681                 {
1682                         fontSize = _FONT_SIZE_LARGE_VCONF;
1683                 }
1684                 else if (value == _FONT_SIZE_MEDIUM_LOWERCASE)
1685                 {
1686                         fontSize = _FONT_SIZE_MEDIUM_VCONF;
1687                 }
1688                 else if (value == _FONT_SIZE_SMALL_LOWERCASE)
1689                 {
1690                         fontSize = _FONT_SIZE_SMALL_VCONF;
1691                 }
1692                 else
1693                 {
1694                         return E_UNSUPPORTED_OPERATION;
1695                 }
1696                 res = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, fontSize);
1697                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "Failed to set font size");
1698         }
1699         else if(key == _LOCALE_TIMEZONE)
1700         {
1701                 r = E_SUCCESS;
1702                 std::unique_ptr<IMap, AllElementsDeleter> pSupportedTimeZoneList(_LocaleManagerImpl::GetAvailableTimeZonesN());
1703
1704                 SysTryReturnResult(NID_SYS, pSupportedTimeZoneList != null, E_SYSTEM, "It is failed to get supported timezone list.");
1705                 SysTryReturnResult(NID_SYS, pSupportedTimeZoneList->ContainsKey(value) == true, E_INVALID_ARG, "Specified timezone id[%S] is not valid", value.GetPointer());
1706
1707                 std::unique_ptr<char> tzpath (_StringConverter::CopyToCharArrayN(value));
1708                 SysTryReturnResult(NID_SYS, tzpath != null, E_SYSTEM, "It is failed to convert String to string");
1709                 std::string tzStr(_LOCALE_TIMEZONE_ROOT_PATH);
1710                 tzStr.append(tzpath.get());
1711                 std::unique_ptr<char> cstrTzpath (strdup(tzStr.c_str()));
1712                 int ret = sysman_set_timezone(cstrTzpath.get());
1713                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to set timezone");
1714
1715                 ret = vconf_set_str(VCONFKEY_SETAPPL_TIMEZONE_ID, cstrTzpath.get()+_LOCALE_TIMEZONE_ROOT_PATH_LENGTH);
1716                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to set VCONFKEY_SETAPPL_TIMEZONE_ID vconf");
1717
1718                 ret = vconf_set_int(VCONFKEY_SYSTEM_TIME_CHANGED, -1);
1719                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to notify to system about time changing");
1720         }
1721         else if(key == _FONT_TYPE)
1722         {
1723                 char* pFontType = null;
1724                 int res = 0;
1725
1726                 pFontType = _StringConverter::CopyToCharArrayN(value);
1727                 SysTryReturnResult(NID_SYS, pFontType != null, E_SYSTEM, "Failed to convert String to string");
1728                 SysLog(NID_SYS, "Requested font type is %s.", pFontType);
1729                 res = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, pFontType);
1730                 delete [] pFontType;
1731                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "Failed to set font type");
1732         }
1733         else if(key == _NETWORK_TELEPHONY_MODE)
1734         {
1735                 _tmpNetworkTelephonyMode = value;
1736         }
1737         else if(key ==_NETWORK_WIFI_TETHERING_SECURITY_PASSWORD)
1738         {
1739                 int ret = 0;
1740                 bool supported = false;
1741                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
1742                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
1743
1744                 SysTryReturnResult(NID_SYS, __tetheringHandle != null, E_UNSUPPORTED_OPERATION, "Current device does not support tethering feature");
1745                 std::unique_ptr<char> password(_StringConverter::CopyToCharArrayN(value));
1746                 SysTryReturnResult(NID_SYS, password != null, E_SYSTEM, "Failed to convert String to string");
1747                 ret = tethering_wifi_set_passphrase(__tetheringHandle, password.get());
1748                 SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to set password");
1749         }
1750         else if(key == _SCREEN_MODE)
1751         {
1752                 int ret = 0;
1753
1754
1755                 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());
1756                 char* screenMode = _StringConverter::CopyToCharArrayN(value);
1757                 ret  = vconf_set_str(_SCREEN_MODE_VCONFKEY, screenMode);
1758
1759                 if(ret == 0)
1760                 {
1761                         r = E_SYSTEM;
1762                         SysLog(NID_SYS, "Failed to change screen mode");
1763                 }
1764                 if(screenMode != null)
1765                 {
1766                         delete [] screenMode;
1767                 }
1768         }
1769         else if(key == _SCREEN_WALLPAPER)
1770         {
1771                 int ret = 0;
1772                 SysTryReturn(NID_SYS, File::IsFileExist(value) == true, E_FILE_NOT_FOUND, E_FILE_NOT_FOUND, "The entry for the specified wallpaper file or the file path cannot be found");
1773                 std::unique_ptr<char> pFilePath(_StringConverter::CopyToCharArrayN(value));
1774
1775                 SysTryReturn(NID_SYS, pFilePath != null, E_SYSTEM, E_SYSTEM, "Failed to convert type of filePath");
1776
1777                 ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, pFilePath.get());
1778                 SysTryReturn(NID_SYS, ret == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to set wallpaper of home screen");
1779         }
1780         else if(key == _SCREEN_WALLPAPER_LOCK)
1781         {
1782                 int ret = 0;
1783                 char* pFilePath = null;
1784
1785                 SysTryReturn(NID_SYS, File::IsFileExist(value) == true, E_FILE_NOT_FOUND, E_FILE_NOT_FOUND, "[E_FILE_NOT_FOUND] The entry for the specified wallpaper file or the file path cannot be found");
1786                 pFilePath = _StringConverter::CopyToCharArrayN(value);
1787
1788                 SysTryReturn(NID_SYS, pFilePath != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to convert type of filePath");
1789
1790                 ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, const_cast<char*>(pFilePath));
1791                 delete [] pFilePath;
1792                 SysTryReturn(NID_SYS, ret == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to set wallpaper of home screen");
1793         }
1794         else if(key == _SOUND_RINGTONE)
1795         {
1796                 int ret = 0;
1797                 char* pFilePath = null;
1798
1799                 SysTryReturn(NID_SYS, File::IsFileExist(value) == true, E_FILE_NOT_FOUND, E_FILE_NOT_FOUND, "[E_FILE_NOT_FOUND] The entry for the specified ringtone file or the file path cannot be found");
1800                 pFilePath = _StringConverter::CopyToCharArrayN(value);
1801
1802                 SysTryReturn(NID_SYS, pFilePath != null, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to convert type of filePath");
1803
1804                 ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, const_cast<char*>(pFilePath));
1805                 SysTryReturn(NID_SYS, ret == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to set ringtone");
1806
1807                 delete [] pFilePath;
1808         }
1809         else if(key == _STORAGE_DIRECTORY_WAP_DOWNLOAD)
1810         {
1811                 _tmpStorageDirectoryWapDownload = value;
1812         }
1813         else if(key == _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD)
1814         {
1815                 _tmpStorageDirectoryWapDownload = value;
1816         }
1817         else if(key == _STORAGE_DIRECTORY_CAMERA_RECORD)
1818         {
1819                 _tmpStorageDirectoryWapDownload = value;
1820         }
1821         else if(key == _STORAGE_DIRECTORY_VOICE_RECORD)
1822         {
1823                 _tmpStorageDirectoryVoiceRecord = value;
1824         }
1825         else if(key == _STORAGE_DIRECTORY_RADIO_BROADCAST)
1826         {
1827                 _tmpStorageDirectoryRadioBroadcast = value;
1828         }
1829         else if(key == _STORAGE_DIRECTORY_VIDEO_BROADCAST)
1830         {
1831                 _tmpStorageDirectoryVideoBroadcast = value;
1832         }
1833         else
1834         {
1835                 SysLog(NID_SYS, "required key(%ls) is not existed", key.GetPointer());
1836                 r = E_OBJ_NOT_FOUND;
1837         }
1838         return r;
1839 }
1840
1841 result
1842 _SettingManager::SetValueForPrivilegedKey(const String& key, String value)
1843 {
1844         result r = E_SUCCESS;
1845         if(key == _NETWORK_TELEPHONY_PROVIDER)
1846         {
1847                 _tmpNetworkTelephonyProvider = value;
1848         }
1849         else if(key == _NETWORK_TELEPHONY_MODE)
1850         {
1851                 _tmpNetworkTelephonyMode= value;
1852         }
1853         else
1854         {
1855                 r = E_OBJ_NOT_FOUND;
1856         }
1857         return r;
1858 }
1859
1860 result
1861 _SettingManager::SetValueAsyncForPrivilegedKey(const String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener)
1862 {
1863         int ret = -1;
1864
1865         if(key == _NETWORK_FLIGHTMODE)
1866         {
1867                 SysTryReturnResult(NID_SYS, __tapiHandle == null, E_SYSTEM, "Tapi is already ready");
1868                 __tapiHandle = tel_init(null);
1869                 SysTryReturnResult(NID_SYS, __tapiHandle != null, E_SYSTEM, "Tapi is not ready.");
1870
1871                 if(__pSettingAsyncEvent == null)
1872                 {
1873                         _SettingAsyncEvent* pEvent = new (std::nothrow) _SettingAsyncEvent();
1874                         SysTryReturnResult(NID_SYS, pEvent != null, E_OUT_OF_MEMORY, "It is failed to create instance of Event");
1875                         __pSettingAsyncEvent = pEvent;
1876                 }
1877                 __pSettingAsyncEvent->AddListener(*listener);
1878
1879                 ret = tel_set_flight_mode(__tapiHandle,
1880                                 value ? TAPI_POWER_FLIGHT_MODE_ENTER : TAPI_POWER_FLIGHT_MODE_LEAVE,
1881                                 SettingEventFlightMode, (void*)__pSettingAsyncEvent);
1882                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "It is failed to set on Network Flight mode");
1883         }
1884
1885         return E_SUCCESS;
1886 }
1887
1888 result
1889 _SettingManager::SetValueForPrivilegedKey(const String& key, bool value)
1890 {
1891         int ret = -1;
1892         result r = E_SUCCESS;
1893         if(key == _LOCATION_GPS)
1894         {
1895                 if(value == true)
1896                 {
1897                         ret = vconf_set_int(VCONFKEY_LOCATION_ENABLED, 1);
1898                 }
1899                 else
1900                 {
1901                         ret = vconf_set_int(VCONFKEY_LOCATION_ENABLED, 0);
1902                 }
1903                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_LOCATION_ENABLED vconf");
1904         }
1905         else if(key == _LOCATION_WPS)
1906         {
1907                 if(value == true)
1908                 {
1909                         ret = vconf_set_int(VCONFKEY_LOCATION_NETWORK_ENABLED, 1);
1910                 }
1911                 else
1912                 {
1913                         ret = vconf_set_int(VCONFKEY_LOCATION_NETWORK_ENABLED, 0);
1914                 }
1915                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_LOCATION_NETWORK_ENABLED vconf");
1916         }
1917         else if(key == _LOCATION_GPS_ADVANCED)
1918         {
1919                 if(value == true)
1920                 {
1921                         ret = vconf_set_int(VCONFKEY_LOCATION_AGPS_ENABLED, 1);
1922                 }
1923                 else
1924                 {
1925                         ret = vconf_set_int(VCONFKEY_LOCATION_AGPS_ENABLED, 0);
1926                 }
1927                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to get on VCONFKEY_LOCATION_AGPS_ENABLED vconf");
1928         }
1929         else if(key == _NETWORK_TELEPHONY_ROAMING)
1930         {
1931                 ret = vconf_set_bool(VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, value);
1932                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL vconf");
1933         }
1934         else if(key == _NETWORK_TELEPHONY_PACKETSERVICE)
1935         {
1936                 ret = vconf_set_bool(VCONFKEY_3G_ENABLE, value);
1937                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_3G_ENABLE vconf");
1938         }
1939         else if(key == _NETWORK_WIFI)
1940         {
1941                 int wifiState = 0;
1942                 bool supported = false;
1943                 r = _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
1944                 SysTryReturnResult(NID_SYS, supported == true && r == E_SUCCESS, E_UNSUPPORTED_OPERATION, "Current device does not support Wi-Fi feature.");
1945
1946                 ret = vconf_get_int(VCONFKEY_WIFI_STATE, &wifiState);
1947                 SysTryReturnResult(NID_SYS, ret == 0, E_UNSUPPORTED_OPERATION, "Failed to set on VCONFKEY_WIFI_STATE vconf");
1948                 SysTryReturnResult(NID_SYS, LoadWifiDll() == E_SUCCESS , E_SYSTEM,"Failed to get wifi so");
1949
1950                 if(value == true)
1951                 {
1952                         if(wifiState == VCONFKEY_WIFI_OFF)
1953                         {
1954                                 r = pWifiManagerImpl_Activate();
1955                         }
1956                 }
1957                 else
1958                 {
1959                         if(wifiState != VCONFKEY_WIFI_OFF)
1960                         {
1961                                 r = pWifiManagerImpl_Deactivate();
1962                         }
1963
1964                 }
1965                 UnloadWifiDll();
1966                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to change wifi state.");
1967         }
1968         else if(key == _NETWORK_WIFI_DIRECT)
1969         {
1970                 bool supported = false;
1971                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI_DIRECT, supported);
1972                 SysTryReturnResult(NID_SYS, supported == true, E_UNSUPPORTED_OPERATION, "Current device does not support WiFi direct feature");
1973                 SysTryReturnResult(NID_SYS, LoadWifiDll() == E_SUCCESS , E_SYSTEM,"Failed to get wifi so");
1974
1975                 bool isActivated = pWifiDirectDeviceImpl_IsActivated();
1976
1977                 if (isActivated == false && value == true)
1978                 {
1979                         ret = pWifiDirectDeviceImpl_Activate();
1980                 }
1981                 else if (isActivated == true && value == false)
1982                 {
1983                         ret = pWifiDirectDeviceImpl_Deactivate();
1984                 }
1985                 UnloadWifiDll();
1986                 SysTryReturnResult(NID_SYS, ret == E_SUCCESS, E_SYSTEM, "Failed to change Wi-Fi direct state");
1987         }
1988         else if(key == _DEVELOPER_USBDEBUGGING)
1989         {
1990 #ifndef _OSP_EMUL_
1991                 ret = vconf_set_bool(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL,
1992                                 value ? _DEVELOPER_USBDEBUGGING_ON : _DEVELOPER_USBDEBUGGING_OFF);
1993                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to set on VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL vconf");
1994 #else
1995                 r = E_UNSUPPORTED_OPERATION;
1996 #endif
1997         }
1998         else
1999         {
2000                 r = E_OBJ_NOT_FOUND;
2001         }
2002         return r;
2003 }
2004
2005 bool
2006 _SettingManager::HasKey(const String& key)
2007 {
2008         if(key == _BATTERY_FORMAT_PERCENTAGE)
2009         {
2010                 return true;
2011         }
2012         else if(key == _FONT_SIZE)
2013         {
2014                 return true;
2015         }
2016         else if(key == _FONT_TYPE)
2017         {
2018                 return true;
2019         }
2020         else if(key == _LOCALE_COUNTRY)
2021         {
2022                 return true;
2023         }
2024         else if(key == _LOCALE_DATE)
2025         {
2026                 return true;
2027         }
2028         else if(key == _LOCALE_DATE_FORMAT)
2029         {
2030                 return true;
2031         }
2032         else if(key == _LOCALE_DATETIME)
2033         {
2034                 return true;
2035         }
2036         else if(key == _LOCALE_DATETIME_FORMAT)
2037         {
2038                 return true;
2039         }
2040         else if(key == _LOCALE_LANGUAGE)
2041         {
2042                 return true;
2043         }
2044         else if(key == _LOCALE_TIME)
2045         {
2046                 return true;
2047         }
2048         else if(key == _LOCALE_TIME_FORMAT)
2049         {
2050                 return true;
2051         }
2052         else if(key == _LOCALE_TIME_FORMAT_24HOUR)
2053         {
2054                 return true;
2055         }
2056         else if(key == _LOCALE_TIMEZONE)
2057         {
2058                 return true;
2059         }
2060         else if(key == _LOCALE_UPDATE_AUTO)
2061         {
2062                 return true;
2063         }
2064         else if(key == _LOCALE_WEEK_FORMAT_FIRSTDAY)
2065         {
2066                 return true;
2067         }
2068         else if(key == _LOCATION_GPS)
2069         {
2070                 return true;
2071         }
2072         else if(key == _LOCATION_GPS_ADVANCED)
2073         {
2074                 return true;
2075         }
2076         else if(key == _LOCATION_WPS)
2077         {
2078                 return true;
2079         }
2080         else if(key == _MOTION_UI)
2081         {
2082                 return true;
2083         }
2084         else if(key == _NETWORK_FLIGHTMODE)
2085         {
2086                 return true;
2087         }
2088         else if(key == _NETWORK_TELEPHONY_MODE || key == _NETWORK_TELEPHONY_PACKETSERVICE || key == _NETWORK_TELEPHONY_PROVIDER || key == _NETWORK_TELEPHONY_ROAMING)
2089         {
2090                 bool supported = false;
2091                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
2092
2093                 return supported;
2094         }
2095         else if(key == _NETWORK_WIFI)
2096         {
2097                 bool supported = false;
2098                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
2099
2100                 return supported;
2101         }
2102         else if(key == _NETWORK_WIFI_NOTIFICATION)
2103         {
2104                 int ret = 0;
2105                 int currentValue = 0;
2106                 bool supported = false;
2107                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
2108                 if(supported == false)
2109                 {
2110                         return false;
2111                 }
2112                 ret = vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &currentValue);
2113
2114                 if(ret == -1)
2115                 {
2116                         return false;
2117                 }
2118
2119                 return true;
2120         }
2121         else if(key == _NETWORK_WIFI_TETHERING)
2122         {
2123                 bool supported = false;
2124                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
2125                 if(supported == false)
2126                 {
2127                         return false;
2128                 }
2129                 if(__tetheringHandle == null)
2130                 {
2131                         return false;
2132                 }
2133                 return true;
2134         }
2135         else if(key == _NETWORK_WIFI_TETHERING_HIDE)
2136         {
2137                 bool supported = false;
2138                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
2139                 if(supported == false)
2140                 {
2141                         return false;
2142                 }
2143                 if(__tetheringHandle == null)
2144                 {
2145                         return false;
2146                 }
2147                 return true;
2148         }
2149         else if(key == _NETWORK_WIFI_TETHERING_SECURITY)
2150         {
2151                 bool supported = false;
2152                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
2153                 if(supported == false)
2154                 {
2155                         return false;
2156                 }
2157                 if(__tetheringHandle == null)
2158                 {
2159                         return false;
2160                 }
2161                 return true;
2162         }
2163         else if(key == _NETWORK_WIFI_TETHERING_SECURITY_PASSWORD)
2164         {
2165                 bool supported = false;
2166                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI, supported);
2167                 if(supported == false)
2168                 {
2169                         return false;
2170                 }
2171                 if(__tetheringHandle == null)
2172                 {
2173                         return false;
2174                 }
2175                 return true;
2176         }
2177         else if(key == _NETWORK_WIFI_DIRECT)
2178         {
2179                 bool supported = false;
2180                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI_DIRECT, supported);
2181                 return supported;
2182         }
2183         else if(key == _NETWORK_BLUETOOTH)
2184         {
2185                 bool supported = false;
2186                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_BLUETOOTH, supported);
2187                 return supported;
2188         }
2189         else if(key == _NETWORK_BLUETOOTH_TETHERING)
2190         {
2191                 bool supported = false;
2192                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI_DIRECT, supported);
2193
2194                 if(__tetheringHandle == null || supported == false)
2195                 {
2196                         return false;
2197                 }
2198                 return true;
2199         }
2200         else if(key == _SCREEN_WALLPAPER)
2201         {
2202                 return true;
2203         }
2204         else if(key == _SCREEN_WALLPAPER_LOCK)
2205         {
2206                 return true;
2207         }
2208         else if(key == _SCREEN_BRIGHTNESS)
2209         {
2210                 return true;
2211         }
2212         else if(key == _SCREEN_BRIGHTNESS_AUTO)
2213         {
2214                 return true;
2215         }
2216         else if(key == _SCREEN_MODE)
2217         {
2218                 return true;
2219         }
2220         else if(key == _SCREEN_BACKLIGHT_TIME)
2221         {
2222                 return true;
2223         }
2224         else if(key == _SOUND_LOCK)
2225         {
2226                 return true;
2227         }
2228         else if(key == _SOUND_MEDIA_VOLUME)
2229         {
2230                 return true;
2231         }
2232         else if(key == _SOUND_NOTIFICATION_VOLUME)
2233         {
2234                 return true;
2235         }
2236         else if(key == _SOUND_RINGTONE)
2237         {
2238                 return true;
2239         }
2240         else if(key == _SOUND_RINGTONE_VOLUME)
2241         {
2242                 return true;
2243         }
2244         else if(key == _SOUND_SILENTMODE)
2245         {
2246                 return true;
2247         }
2248         else if(key == _SOUND_SYSTEM_VOLUME)
2249         {
2250                 return true;
2251         }
2252         else if(key == _SOUND_TOUCH)
2253         {
2254                 return true;
2255         }
2256         else if(key == _STORAGE_DIRECTORY_WAP_DOWNLOAD)
2257         {
2258                 return true;
2259         }
2260         else if(key == _STORAGE_DIRECTORY_BLUETOOTH_DOWNLOAD)
2261         {
2262                 return true;
2263         }
2264         else if(key == _STORAGE_DIRECTORY_CAMERA_RECORD)
2265         {
2266                 return true;
2267         }
2268         else if(key == _STORAGE_DIRECTORY_VOICE_RECORD)
2269         {
2270                 return true;
2271         }
2272         else if(key == _STORAGE_DIRECTORY_RADIO_BROADCAST)
2273         {
2274                 return true;
2275         }
2276         else if(key == _STORAGE_DIRECTORY_VIDEO_BROADCAST)
2277         {
2278                 return true;
2279         }
2280         else if(key == _VIBRATOR)
2281         {
2282                 return true;
2283         }
2284         else if(key == _VIBRATOR_LEVEL)
2285         {
2286                 return true;
2287         }
2288         else if(key == _VIBRATOR_LEVEL_NOTIFICATION)
2289         {
2290                 return true;
2291         }
2292         else if(key == _USB_TETHERING)
2293         {
2294                 if(__tetheringHandle == null)
2295                 {
2296                         return false;
2297                 }
2298                 return true;
2299         }
2300         else if(key == _WEB_APPLICATION_COOKIE_SHARE)
2301         {
2302                 return true;
2303         }
2304         else if(key == _SCREEN_ROTATION_AUTO)
2305         {
2306                 return true;
2307         }
2308         else if(key == _CONTACT_ORDER_FIRSTNAME)
2309         {
2310                 return true;
2311         }
2312         else if(key == _DEVELOPER_USBDEBUGGING)
2313         {
2314                 return true;
2315         }
2316         return false;
2317 }
2318
2319 result
2320 _SettingManager::ResetToFactoryDefault(void)
2321 {
2322         return E_SUCCESS;
2323 }
2324
2325 result
2326 _SettingManager::SetVolume(const String& soundCategory, int level)
2327 {
2328         int res = 0;
2329         int maxVolume = 0;
2330
2331         sound_type_e soundType;
2332
2333         if (soundCategory == _SYSTEM_SOUND_VOLUME)
2334         {
2335                 soundType = SOUND_TYPE_SYSTEM;
2336         }
2337         else if (soundCategory == _MEDIA_SOUND_VOLUME)
2338         {
2339                 soundType = SOUND_TYPE_MEDIA;
2340         }
2341         else if (soundCategory == _RINGTONE_SOUND_VOLUME)
2342         {
2343                 soundType = SOUND_TYPE_RINGTONE;
2344         }
2345         else if (soundCategory == _NOTIFICATION_SOUND_VOLUME)
2346         {
2347                 soundType = SOUND_TYPE_NOTIFICATION;
2348         }
2349         else
2350         {
2351                 SysLogException(NID_SYS, E_INVALID_ARG, "The specified soundCategory is invalid");
2352                 return E_INVALID_ARG;
2353         }
2354
2355         res = sound_manager_get_max_volume(soundType, &maxVolume);
2356         SysTryReturn(NID_SYS, res == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to get max volume");
2357
2358         SysTryReturn(NID_SYS, maxVolume >= level, E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The specified level is outside the bounds of soundCategory");
2359
2360         res = sound_manager_set_volume(soundType, level);
2361         SysTryReturn(NID_SYS, res == 0, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] A sy8stem error has occured.");
2362
2363         return E_SUCCESS;
2364 }
2365
2366 //Event Management
2367 result
2368 _SettingManager::AddSettingEventListener(ISettingEventListener& listener)
2369 {
2370         result r = E_SUCCESS;
2371         SysTryReturnResult(NID_SYS, __pSettingEvent != null, E_SYSTEM, "Event system is not ready.");
2372         r = __pSettingEvent->AddListener(listener);
2373         SysTryReturnResult(NID_SYS, r != E_OBJ_ALREADY_EXIST, r, "listener is already registered.");
2374         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to add listener");
2375         __listenerCount++;
2376         return StartSettingEventListen();
2377 }
2378
2379 result
2380 _SettingManager::RemoveSettingEventListener(ISettingEventListener& listener)
2381 {
2382         result r = E_SUCCESS;
2383         SysTryReturnResult(NID_SYS, __pSettingEvent != null, E_SYSTEM, "Event system is not ready.");
2384         r = __pSettingEvent->RemoveListener(listener);
2385         SysTryReturnResult(NID_SYS, r != E_OBJ_NOT_FOUND, r, "listener is not registered.");
2386         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to remove listener");
2387         __listenerCount--;
2388         return StopSettingEventListen();
2389 }
2390
2391 // Event for internal
2392 result
2393 _SettingManager::AddSettingEventListenerForInternal(ISettingEventListener& listener)
2394 {
2395         result r = E_SUCCESS;
2396         SysTryReturnResult(NID_SYS, __pSettingEventForInternal != null, E_SYSTEM, "Event system is not ready.");
2397         __pSettingEventForInternal->AddListener(listener);
2398         SysTryReturnResult(NID_SYS, r != E_OBJ_ALREADY_EXIST, r, "listener is already registered.");
2399         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "The memory is insufficient.");
2400         if(__listenerInternalCount == 0)
2401         {
2402                 r = StartSettingEventListenForInternal();
2403                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to start internal event.");
2404         }
2405         __listenerInternalCount++;
2406         return r;
2407 }
2408
2409 result
2410 _SettingManager::RemoveSettingEventListenerForInternal(ISettingEventListener& listener)
2411 {
2412         result r = E_SUCCESS;
2413         SysTryReturnResult(NID_SYS, __pSettingEventForInternal != null, E_SYSTEM, "Event system is not ready.");
2414         r = __pSettingEventForInternal->RemoveListener(listener);
2415         SysTryReturnResult(NID_SYS, r != E_OBJ_NOT_FOUND, r, "listener is not registered.");
2416         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "The listener is not added.");
2417         __listenerInternalCount--;
2418
2419         if(__listenerInternalCount == 0 && __listenerCount == 0)
2420         {
2421                 r = StopSettingEventListenForInternal();
2422                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to stop internal event.");
2423         }
2424         return r;
2425 }
2426
2427 result
2428 _SettingManager::StartSettingEventListenForInternal(void)
2429 {
2430         if(__registeredSettingEventsForInternal == false)
2431         {
2432                 int ret = 0;
2433                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_REGION, SettingEventRuntimeInfo, null);
2434                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register region event listener");
2435
2436                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LANGUAGE, SettingEventRuntimeInfo, null);
2437                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register language event listener");
2438
2439                 ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE, SettingEventSettingInfo, null);
2440                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register font type event listener");
2441
2442                 ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_FONT_SIZE, SettingEventSettingInfo, null);
2443                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register font size event listener");
2444
2445                 __registeredSettingEventsForInternal = true;
2446         }
2447         return E_SUCCESS;
2448 }
2449
2450 result
2451 _SettingManager::StopSettingEventListenForInternal(void)
2452 {
2453         if(__registeredSettingEventsForInternal == true)
2454         {
2455                 int ret = 0;
2456                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_REGION);
2457                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2458
2459                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_LANGUAGE);
2460                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2461
2462                 ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_FONT_SIZE);
2463                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2464
2465                 ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_FONT_TYPE);
2466                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2467
2468                 __registeredSettingEventsForInternal = false;
2469         }
2470         return E_SUCCESS;
2471 }
2472
2473 result
2474 _SettingManager::StartSettingEventListen(void)
2475 {
2476         if (__listenerCount > 0 && __registeredSettingEvents == false)
2477         {
2478                 int ret = 0;
2479                 result r = E_SUCCESS;
2480                 int currentIntValue = 0;
2481                 bool currentBoolValue = false;
2482                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED, SettingEventRuntimeInfo, null);
2483                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register 24 hour event listener");
2484                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED, SettingEventRuntimeInfo, null);
2485                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register roaming event listener");
2486                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED, SettingEventRuntimeInfo, null);
2487                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register flight mode event listener");
2488                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED, SettingEventRuntimeInfo, null);
2489                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register location service event listener");
2490                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED, SettingEventRuntimeInfo, null);
2491                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register network position event listener");
2492                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_PACKET_DATA_ENABLED, SettingEventRuntimeInfo, null);
2493                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register packet data event listener");
2494                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_SILENT_MODE_ENABLED, SettingEventRuntimeInfo, null);
2495                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register silent mode event listener");
2496                 ret = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK, SettingEventRuntimeInfo, null);
2497                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register vibration event listener");
2498                 ret = sound_manager_set_volume_changed_cb(SettingEventSoundManager, null);
2499                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register sound volume event listener");
2500
2501                 ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE, SettingEventSettingInfo, null);
2502                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register rington event listener");
2503                 ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN, SettingEventSettingInfo, null);
2504                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register wallpaper event listener");
2505                 ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN, SettingEventSettingInfo, null);
2506                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register wallpaper event listener");
2507                 ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION, SettingEventSettingInfo, null);
2508                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register wallpaper event listener");
2509
2510                 if(__tetheringHandle != null)
2511                 {
2512                         ret = tethering_set_enabled_cb(__tetheringHandle, TETHERING_TYPE_USB, SettingEventTetheringEnabled, null);
2513                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to register USB Tethering event listener");
2514
2515                         ret = tethering_set_enabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI, SettingEventTetheringEnabled, null);
2516                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to register WIFI Tethering event listener");
2517
2518                         ret = tethering_set_enabled_cb(__tetheringHandle, TETHERING_TYPE_BT, SettingEventTetheringEnabled, null);
2519                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to register BT Tethering event listener");
2520
2521                         ret = tethering_set_disabled_cb(__tetheringHandle, TETHERING_TYPE_USB, SettingEventTetheringDisabled, null);
2522                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to register USB Tethering event listener");
2523
2524                         ret = tethering_set_disabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI, SettingEventTetheringDisabled, null);
2525                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to register WIFI Tethering event listener");
2526
2527                         ret = tethering_set_disabled_cb(__tetheringHandle, TETHERING_TYPE_BT, SettingEventTetheringDisabled, null);
2528                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to register BT Tethering event listener");
2529                 }
2530
2531                 ret = vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &currentIntValue);
2532                 if(ret != -1)
2533                 {
2534                         ret = vconf_notify_key_changed(VCONFKEY_WIFI_ENABLE_QS, SettingEventVConf, null);
2535                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register WIFI QS event listener");
2536                 }
2537
2538                 ret = vconf_notify_key_changed(VCONFKEY_BT_STATUS, SettingEventVConf, null);
2539                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register BT event listener");
2540
2541                 ret = vconf_notify_key_changed(VCONFKEY_WIFI_STATE, SettingEventVConf, null);
2542                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register WIFI event listener");
2543
2544                 ret = vconf_notify_key_changed(VCONFKEY_LOCATION_AGPS_ENABLED, SettingEventVConf, null);
2545                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register event listener");
2546
2547                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, SettingEventVConf, null);
2548                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register event listener");
2549
2550                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, SettingEventVConf, null);
2551                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register vibration enable event listener");
2552
2553                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, SettingEventVConf, null);
2554                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register rotate lock event listener");
2555
2556                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, SettingEventVConf, null);
2557                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register usb mode selection event listener");
2558
2559                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, SettingEventVConf, null);
2560                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register automatic time update enable event");
2561
2562                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, SettingEventVConf, null);
2563                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register first day of week event listener");
2564
2565                 ret = vconf_notify_key_changed(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, SettingEventVConf, null);
2566                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register contact display order event listener");
2567
2568                 ret = vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, SettingEventVConf, null);
2569                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register time event");
2570
2571                 ret = vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, &currentIntValue);
2572                 if(ret != -1)
2573                 {
2574                         ret = vconf_notify_key_changed(VCONFKEY_MOBILE_HOTSPOT_SECURITY, SettingEventVConf, null);
2575                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register mobile hotspot security event");
2576                 }
2577
2578                 ret = vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &currentIntValue);
2579                 if(ret != -1)
2580                 {
2581                         ret = vconf_notify_key_changed(VCONFKEY_MOBILE_HOTSPOT_HIDE, SettingEventVConf, null);
2582                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register mobile hotspot hide event");
2583                 }
2584
2585                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, SettingEventVConf, null);
2586                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL changed event");
2587
2588                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SettingEventVConf, null);
2589                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register VCONFKEY_SETAPPL_LCD_BRIGHTNESS changed event");
2590
2591                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SettingEventVConf, null);
2592                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT changed event");
2593
2594                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_TIMEZONE_ID, SettingEventVConf, null);
2595                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register VCONFKEY_SETAPPL_TIMEZONE_ID changed event");
2596
2597                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, SettingEventVConf, null);
2598                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT changed event");
2599
2600                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, SettingEventVConf, null);
2601                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register TOUCH_SOUNDS changed event");
2602
2603                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, SettingEventVConf, null);
2604                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register SOUND_LOCK changed event");
2605
2606                 ret = vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR, SettingEventVConf, null);
2607                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register device name changed event");
2608
2609                 ret = vconf_notify_key_changed(_SCREEN_MODE_VCONFKEY, SettingEventVConf, null);
2610                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register screen mode changed event");
2611
2612                 _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI_DIRECT, currentBoolValue);
2613
2614                 if(currentBoolValue == true)
2615                 {
2616                         ret = vconf_notify_key_changed(VCONFKEY_WIFI_DIRECT_STATE, SettingEventVConf, null);
2617                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register wifi direct changed event");
2618                 }
2619
2620                 r = StartSettingEventListenForInternal();
2621                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "Failed to register internal events");
2622
2623                 __registeredSettingEvents = true;
2624         }
2625
2626         return E_SUCCESS;
2627 }
2628
2629 result
2630 _SettingManager::StopSettingEventListen(void)
2631 {
2632         if (__listenerCount == 0 && __registeredSettingEvents == true)
2633         {
2634                 int ret = 0;
2635                 int currentIntValue = 0;
2636                 bool currentBoolValue =false;
2637                 result r = E_SUCCESS;
2638
2639                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED);
2640                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2641                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED);
2642                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2643                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED);
2644                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2645                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED);
2646                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2647                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED);
2648                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2649                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_PACKET_DATA_ENABLED);
2650                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2651                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_SILENT_MODE_ENABLED);
2652                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2653                 ret = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK);
2654                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2655                 sound_manager_unset_volume_changed_cb();
2656
2657                 ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE);
2658                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2659                 ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN);
2660                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2661                 ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN);
2662                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2663                 ret = system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION);
2664                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2665
2666                 //3.0 extensions
2667                 if(__tetheringHandle != null)
2668                 {
2669                         ret = tethering_unset_enabled_cb(__tetheringHandle, TETHERING_TYPE_USB);
2670                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to unregister USB Tethering event listener");
2671
2672                         ret = tethering_unset_enabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI);
2673                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to unregister WIFI Tethering event listener");
2674
2675                         ret = tethering_unset_enabled_cb(__tetheringHandle, TETHERING_TYPE_BT);
2676                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to unregister Bluetooth Tethering event listener");
2677
2678                         ret = tethering_unset_disabled_cb(__tetheringHandle, TETHERING_TYPE_USB);
2679                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to unregister USB Tethering event listener");
2680
2681                         ret = tethering_unset_disabled_cb(__tetheringHandle, TETHERING_TYPE_WIFI);
2682                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to unregister WIFI Tethering event listener");
2683
2684                         ret = tethering_unset_disabled_cb(__tetheringHandle, TETHERING_TYPE_BT);
2685                         SysTryReturnResult(NID_SYS, ret == TETHERING_ERROR_NONE, E_SYSTEM, "Failed to unregister Bluetooth Tethering event listener");
2686                 }
2687
2688                 ret = vconf_get_int(VCONFKEY_WIFI_ENABLE_QS, &currentIntValue);
2689                 if(ret != -1)
2690                 {
2691                         ret = vconf_ignore_key_changed(VCONFKEY_WIFI_ENABLE_QS, SettingEventVConf);
2692                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister WIFI QS event listener");
2693                 }
2694
2695                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_TIMEZONE_ID, SettingEventVConf);
2696                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister VCONFKEY_SETAPPL_TIMEZONE_ID changed event");
2697
2698                 ret = vconf_ignore_key_changed(VCONFKEY_BT_STATUS, SettingEventVConf);
2699                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister BT event listener");
2700
2701                 ret = vconf_ignore_key_changed(VCONFKEY_WIFI_STATE, SettingEventVConf);
2702                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister WIFI event listener");
2703
2704                 ret = vconf_ignore_key_changed(VCONFKEY_LOCATION_AGPS_ENABLED, SettingEventVConf);
2705                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2706
2707                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, SettingEventVConf);
2708                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister event listener");
2709
2710                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, SettingEventVConf);
2711                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister vibration enable event listener");
2712
2713                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, SettingEventVConf);
2714                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister rotate lock event listener");
2715
2716                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, SettingEventVConf);
2717                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister usb mode selection event listener");
2718
2719                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, SettingEventVConf);
2720                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister automatic time update enable event");
2721
2722                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, SettingEventVConf);
2723                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister first day of week event listener");
2724
2725                 ret = vconf_ignore_key_changed(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, SettingEventVConf);
2726                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister contact display order event listener");
2727
2728                 ret = vconf_ignore_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, SettingEventVConf);
2729                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister time event");
2730
2731                 ret = vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, &currentIntValue);
2732                 if(ret != -1)
2733                 {
2734                         ret = vconf_ignore_key_changed(VCONFKEY_MOBILE_HOTSPOT_SECURITY, SettingEventVConf);
2735                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister mobile hotspot security event");
2736                 }
2737
2738                 ret = vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &currentIntValue);
2739                 if(ret != -1)
2740                 {
2741                         ret = vconf_ignore_key_changed(VCONFKEY_MOBILE_HOTSPOT_HIDE, SettingEventVConf);
2742                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister mobile hotspot hide event");
2743                 }
2744
2745                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, SettingEventVConf);
2746                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL changed event");
2747
2748                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, SettingEventVConf);
2749                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister VCONFKEY_SETAPPL_LCD_BRIGHTNESS changed event");
2750
2751                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, SettingEventVConf);
2752                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT changed event");
2753
2754                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, SettingEventVConf);
2755                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT changed event");
2756
2757                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, SettingEventVConf);
2758                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister TOUCH_SOUNDS changed event");
2759
2760                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, SettingEventVConf);
2761                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister SOUND_LOCK changed event");
2762
2763                 ret = vconf_ignore_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR, SettingEventVConf);
2764                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister device name changed event");
2765
2766                 ret = vconf_ignore_key_changed(_SCREEN_MODE_VCONFKEY, SettingEventVConf);
2767                 SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to unregister screen mode changed event");
2768
2769                 r = _SystemInfoImpl::GetSysInfo(_SYSTEM_NETWORK_WIFI_DIRECT, currentBoolValue);
2770
2771                 if(r == E_SUCCESS && currentBoolValue == true)
2772                 {
2773                         ret = vconf_ignore_key_changed(VCONFKEY_WIFI_DIRECT_STATE, SettingEventVConf);
2774                         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "Failed to register wifi direct changed event");
2775                 }
2776
2777                 if(__listenerInternalCount == 0)
2778                 {
2779                         r = StopSettingEventListenForInternal();
2780                         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "Failed to register internal events");
2781                 }
2782
2783                 __registeredSettingEvents = false;
2784         }
2785         return E_SUCCESS;
2786 }
2787
2788 result
2789 _SettingManager::SetSettingEventListener(ISettingEventListener* pListener)
2790 {
2791         result r = E_SUCCESS;
2792         if (pListener != null)
2793         {
2794                 __pSettingEventListener = pListener;
2795                 r = AddSettingEventListener(*pListener);
2796                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to add event listener");
2797         }
2798         else
2799         {
2800                 if (__pSettingEventListener == null)
2801                 {
2802                         SysLog(NID_SYS, "listener is not registered");
2803                         return E_SUCCESS;
2804                 }
2805                 r = RemoveSettingEventListener(*__pSettingEventListener);
2806                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to remove event listener");
2807                 __pSettingEventListener = null;
2808         }
2809         return E_SUCCESS;
2810 }
2811
2812 //Event
2813 void
2814 _SettingManager::SettingEventRuntimeInfo(runtime_info_key_e key, void* userData)
2815 {
2816         SysLog(NID_SYS, "SettingEventListener called [%d]", key);
2817
2818         if(__pSettingManager == null)
2819         {
2820                 SysLogException(NID_SYS, E_SYSTEM, "SettingManager is not initialized");
2821                 return;
2822         }
2823
2824         String settingKey;
2825         switch (key)
2826         {
2827         case RUNTIME_INFO_KEY_FLIGHT_MODE_ENABLED:
2828                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2829                 {
2830                         settingKey = _NETWORK_FLIGHTMODE;
2831                 }
2832                 else
2833                 {
2834                         settingKey = _FLIGHT_MODE_ENABLED;
2835                 }
2836                 break;
2837         case RUNTIME_INFO_KEY_LANGUAGE:
2838                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2839                 {
2840                         settingKey = _LOCALE_LANGUAGE;
2841                 }
2842                 else
2843                 {
2844                         settingKey = _LANGUAGE;
2845                 }
2846                 break;
2847         case RUNTIME_INFO_KEY_24HOUR_CLOCK_FORMAT_ENABLED:
2848                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2849                 {
2850                         __pSettingManager->DeliverSettingEvent(_LOCALE_TIME_FORMAT);
2851                         __pSettingManager->DeliverSettingEvent(_LOCALE_DATETIME_FORMAT);
2852                         settingKey = _LOCALE_TIME_FORMAT_24HOUR;
2853                 }
2854                 else
2855                 {
2856                         __pSettingManager->DeliverSettingEvent(_DATE_TIME_FORMAT);
2857                         __pSettingManager->DeliverSettingEvent(_TIME_FORMAT);
2858                         settingKey = _HOUR_FORMAT_SELECTED;
2859                 }
2860                 break;
2861         case RUNTIME_INFO_KEY_REGION:
2862                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2863                 {
2864                         settingKey = _LOCALE_DATE_FORMAT;
2865                 }
2866                 else
2867                 {
2868                         settingKey = _DATE_FORMAT;
2869                 }
2870                 __pSettingManager->DeliverSettingEvent(settingKey);
2871
2872                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2873                 {
2874                         settingKey = _LOCALE_DATETIME_FORMAT;
2875                 }
2876                 else
2877                 {
2878                         settingKey = _DATE_TIME_FORMAT;
2879                 }
2880                 __pSettingManager->DeliverSettingEvent(settingKey);
2881
2882                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2883                 {
2884                         settingKey = _LOCALE_TIME_FORMAT;
2885                 }
2886                 else
2887                 {
2888                         settingKey = _TIME_FORMAT;
2889                 }
2890                 __pSettingManager->DeliverSettingEvent(settingKey);
2891
2892                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2893                 {
2894                         settingKey = _LOCALE_COUNTRY;
2895                 }
2896                 else
2897                 {
2898                         settingKey = _COUNTRY;
2899                 }
2900
2901                 break;
2902
2903         case RUNTIME_INFO_KEY_DATA_ROAMING_ENABLED:
2904                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2905                 {
2906                         settingKey = _NETWORK_TELEPHONY_ROAMING;
2907                 }
2908                 else
2909                 {
2910                         settingKey = _DATA_ROAMING_ENABLED;
2911                 }
2912                 break;
2913         case RUNTIME_INFO_KEY_LOCATION_SERVICE_ENABLED:
2914                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2915                 {
2916                         settingKey = _LOCATION_GPS;
2917                 }
2918                 else
2919                 {
2920                         settingKey = _GPS_ENABLED;
2921                 }
2922                 break;
2923         case RUNTIME_INFO_KEY_LOCATION_NETWORK_POSITION_ENABLED:
2924                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2925                 {
2926                         settingKey = _LOCATION_WPS;
2927                 }
2928                 else
2929                 {
2930                         settingKey = _WPS_ENABLED;
2931                 }
2932                 break;
2933         case RUNTIME_INFO_KEY_PACKET_DATA_ENABLED:
2934                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2935                 {
2936                         settingKey = _NETWORK_TELEPHONY_PACKETSERVICE;
2937                 }
2938                 else
2939                 {
2940                         settingKey = _PACKET_SERVICE_ALLOWED;
2941                 }
2942                 break;
2943         case RUNTIME_INFO_KEY_SILENT_MODE_ENABLED:
2944                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2945                 {
2946                         settingKey = _SOUND_SILENTMODE;
2947                 }
2948                 else
2949                 {
2950                         settingKey = _SILENT_MODE;
2951                 }
2952                 break;
2953         case RUNTIME_INFO_KEY_VIBRATION_LEVEL_HAPTIC_FEEDBACK:
2954                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2955                 {
2956                         settingKey =  _VIBRATOR_LEVEL;
2957                 }
2958                 else
2959                 {
2960                         settingKey = _TOUCH_VIBRATION_LEVEL;
2961                 }
2962                 break;
2963         default:
2964                 SysLog(NID_SYS, "NOT IMPLEMENTED");
2965                 return;
2966         }
2967
2968         SysLog(NID_SYS, "Event(%ls) is deliverted.", settingKey.GetPointer());
2969         __pSettingManager->DeliverSettingEvent(settingKey);
2970 }
2971
2972 void
2973 _SettingManager::SettingEventSettingInfo(system_settings_key_e key, void* userData)
2974 {
2975         SysLog(NID_SYS, "System setting is changed[%d]", key);
2976
2977         if(__pSettingManager == null)
2978         {
2979                 SysLogException(NID_SYS, E_SYSTEM, "SettingManager is not initialized");
2980                 return;
2981         }
2982
2983         String settingKey;
2984         switch (key)
2985         {
2986         case SYSTEM_SETTINGS_KEY_MOTION_ACTIVATION:
2987         {
2988                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
2989                 {
2990                         settingKey = _MOTION_UI;
2991                 }
2992                 else
2993                 {
2994                         settingKey = _ENABLE_MOTION;
2995                 }
2996                 break;
2997         }
2998         case SYSTEM_SETTINGS_KEY_INCOMING_CALL_RINGTONE:
2999         {
3000                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3001                 {
3002                         settingKey = _SOUND_RINGTONE;
3003                 }
3004                 else
3005                 {
3006                         settingKey = _RINGTONE;
3007                 }
3008                 break;
3009         }
3010         case SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN:
3011         {
3012                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3013                 {
3014                         settingKey = _SCREEN_WALLPAPER;
3015                 }
3016                 else
3017                 {
3018                         settingKey = _WALLPAPER;
3019                 }
3020                 break;
3021         }
3022         case SYSTEM_SETTINGS_KEY_WALLPAPER_LOCK_SCREEN:
3023         {
3024                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3025                 {
3026                         settingKey = _SCREEN_WALLPAPER_LOCK;
3027                 }
3028                 else
3029                 {
3030                         return;
3031                 }
3032                 break;
3033         }
3034
3035         case SYSTEM_SETTINGS_KEY_FONT_SIZE:
3036         {
3037                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3038                 {
3039                         settingKey = _FONT_SIZE;
3040                 }
3041                 else
3042                 {
3043                         settingKey = _FONTSIZE;
3044                 }
3045                 break;
3046         }
3047         case SYSTEM_SETTINGS_KEY_FONT_TYPE:
3048         {
3049                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3050                 {
3051                         settingKey = _FONT_TYPE;
3052                 }
3053                 else
3054                 {
3055                         settingKey = _FONTTYPE;
3056                 }
3057                 break;
3058         }
3059         default:
3060                 SysLog(NID_SYS, "NOT IMPLEMENTED");
3061                 return;
3062         }
3063
3064         __pSettingManager->DeliverSettingEvent(settingKey);
3065 }
3066
3067 void
3068 _SettingManager::SettingEventSoundManager(sound_type_e type, unsigned int volume, void* userData)
3069 {
3070         SysLog(NID_SYS, "Sound Volume is changed [%d]", type);
3071
3072         if(__pSettingManager == null)
3073         {
3074                 SysLogException(NID_SYS, E_SYSTEM, "SettingManager is not initialized");
3075                 return;
3076         }
3077
3078         String settingKey;
3079         switch (type)
3080         {
3081         case SOUND_TYPE_SYSTEM:
3082                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3083                 {
3084                         settingKey = _SOUND_SYSTEM_VOLUME;
3085                 }
3086                 else
3087                 {
3088                         settingKey = _SYSTEM_SOUND_VOLUME;
3089                 }
3090                 break;
3091         case SOUND_TYPE_MEDIA:
3092                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3093                 {
3094                         settingKey = _SOUND_MEDIA_VOLUME;
3095                 }
3096                 else
3097                 {
3098                         settingKey = _MEDIA_SOUND_VOLUME;
3099                 }
3100                 break;
3101         case SOUND_TYPE_RINGTONE:
3102                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3103                 {
3104                         settingKey = _SOUND_RINGTONE_VOLUME;
3105                 }
3106                 else
3107                 {
3108                         settingKey = _RINGTONE_SOUND_VOLUME;
3109                 }
3110                 break;
3111         case SOUND_TYPE_NOTIFICATION:
3112                 if(!(_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()))
3113                 {
3114                         settingKey = _SOUND_NOTIFICATION_VOLUME;
3115                 }
3116                 else
3117                 {
3118                         settingKey = _NOTIFICATION_SOUND_VOLUME;
3119                 }
3120                 break;
3121         default:
3122                 SysLog(NID_SYS, "NOT IMPLEMENTED");
3123                 return;
3124         }
3125
3126         __pSettingManager->DeliverSettingEvent(settingKey);
3127 }
3128
3129 void
3130 _SettingManager::SettingEventVConf(keynode_t* node, void* userData)
3131 {
3132         SysLog(NID_SYS, "VConf change event is occured");
3133
3134         if(__pSettingManager == null)
3135         {
3136                 SysLogException(NID_SYS, E_SYSTEM, "SettingManager is not initialized");
3137                 return;
3138         }
3139         SysLog(NID_SYS, "Vconf is changed [%s]", vconf_keynode_get_name(node));
3140
3141         String settingKey;
3142
3143         if (strcmp(VCONFKEY_SETAPPL_BATTERY_PERCENTAGE_BOOL, vconf_keynode_get_name(node)) == 0)
3144         {
3145                 settingKey = _BATTERY_FORMAT_PERCENTAGE;
3146         }
3147         else if (strcmp(VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL, vconf_keynode_get_name(node)) == 0)
3148         {
3149                 settingKey = _VIBRATOR;
3150         }
3151         else if (strcmp(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, vconf_keynode_get_name(node)) == 0)
3152         {
3153                 settingKey = _SCREEN_ROTATION_AUTO;
3154         }
3155         else if (strcmp(VCONFKEY_SETAPPL_USB_DEBUG_MODE_BOOL, vconf_keynode_get_name(node)) == 0)
3156         {
3157                 settingKey = _DEVELOPER_USBDEBUGGING;
3158         }
3159         else if (strcmp(VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, vconf_keynode_get_name(node)) == 0)
3160         {
3161                 settingKey = _LOCALE_UPDATE_AUTO;
3162         }
3163         else if (strcmp(VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, vconf_keynode_get_name(node)) == 0)
3164         {
3165                 settingKey = _LOCALE_WEEK_FORMAT_FIRSTDAY;
3166         }
3167         else if (strcmp(VCONFKEY_CONTACTS_SVC_NAME_DISPLAY_ORDER, vconf_keynode_get_name(node)) == 0)
3168         {
3169                 settingKey = _CONTACT_ORDER_FIRSTNAME;
3170         }
3171         else if (strcmp(VCONFKEY_SYSTEM_TIME_CHANGED, vconf_keynode_get_name(node)) == 0)
3172         {
3173                 __pSettingManager->DeliverSettingEvent(_LOCALE_DATETIME);
3174                 __pSettingManager->DeliverSettingEvent(_LOCALE_DATE);
3175                 settingKey = _LOCALE_TIME;
3176         }
3177         else if (strcmp(VCONFKEY_SETAPPL_TIMEZONE_ID, vconf_keynode_get_name(node)) == 0)
3178         {
3179                 settingKey = _LOCALE_TIMEZONE;
3180         }
3181         else if (strcmp(VCONFKEY_SETAPPL_DEVICE_NAME_STR, vconf_keynode_get_name(node)) == 0)
3182         {
3183                 settingKey = _DEVICE_NAME;
3184         }
3185         else if (strcmp(VCONFKEY_LOCATION_AGPS_ENABLED, vconf_keynode_get_name(node)) == 0)
3186         {
3187                 settingKey = _LOCATION_GPS_ADVANCED;
3188         }
3189         else if (strcmp(VCONFKEY_WIFI_STATE, vconf_keynode_get_name(node)) == 0)
3190         {
3191                 int state = VCONFKEY_WIFI_OFF;
3192                 int ret = 0;
3193                 ret = vconf_get_int(VCONFKEY_WIFI_STATE, &state);
3194
3195                 if(ret == 0 && (state == VCONFKEY_WIFI_OFF || state == VCONFKEY_WIFI_UNCONNECTED))
3196                 {
3197                         settingKey = _NETWORK_WIFI;
3198                 }
3199                 else
3200                 {
3201                         SysLog(NID_SYS, "It is not Wi-Fi on/off event.");
3202                         return;
3203                 }
3204         }
3205         else if (strcmp(VCONFKEY_BT_STATUS, vconf_keynode_get_name(node)) == 0)
3206         {
3207                 settingKey = _NETWORK_BLUETOOTH;
3208         }
3209         else if (strcmp(VCONFKEY_MOBILE_HOTSPOT_SECURITY, vconf_keynode_get_name(node)) == 0)
3210         {
3211                 settingKey = _NETWORK_WIFI_TETHERING_SECURITY;
3212         }
3213         else if (strcmp(VCONFKEY_MOBILE_HOTSPOT_HIDE, vconf_keynode_get_name(node)) == 0)
3214         {
3215                 settingKey = _NETWORK_WIFI_TETHERING_HIDE;
3216         }
3217         else if (strcmp(VCONFKEY_WIFI_ENABLE_QS, vconf_keynode_get_name(node)) == 0)
3218         {
3219                 settingKey = _NETWORK_WIFI_NOTIFICATION;
3220         }
3221         else if (strcmp(_SCREEN_MODE_VCONFKEY, vconf_keynode_get_name(node)) == 0)
3222         {
3223                 settingKey = _SCREEN_MODE;
3224         }
3225         else if (strcmp(VCONFKEY_SETAPPL_TOUCH_SOUNDS_BOOL, vconf_keynode_get_name(node)) == 0)
3226         {
3227                 settingKey = _SOUND_TOUCH;
3228         }
3229         else if (strcmp(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, vconf_keynode_get_name(node)) == 0)
3230         {
3231                 settingKey = _SOUND_LOCK;
3232         }
3233         else if (strcmp(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, vconf_keynode_get_name(node)) == 0)
3234         {
3235                 settingKey = _VIBRATOR_LEVEL_NOTIFICATION;
3236         }
3237         else if (strcmp(VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, vconf_keynode_get_name(node)) == 0)
3238         {
3239                 settingKey = _SCREEN_BACKLIGHT_TIME;
3240         }
3241         else if (strcmp(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, vconf_keynode_get_name(node)) == 0)
3242         {
3243                 settingKey = _SCREEN_BRIGHTNESS;
3244         }
3245         else if (strcmp(VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, vconf_keynode_get_name(node)) == 0)
3246         {
3247                 settingKey = _SCREEN_BRIGHTNESS_AUTO;
3248         }
3249         else if (strcmp(VCONFKEY_WIFI_DIRECT_STATE, vconf_keynode_get_name(node)) == 0)
3250         {
3251                 int state = VCONFKEY_WIFI_DIRECT_DEACTIVATED;
3252                 int ret = 0;
3253                 ret = vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &state);
3254                 SysLog(NID_SYS, "Wi-Fi Direct state is changed. %d", state);
3255                 if(ret == 0 && (state == VCONFKEY_WIFI_DIRECT_DEACTIVATED || state == VCONFKEY_WIFI_DIRECT_ACTIVATED))
3256                 {
3257                         settingKey = _NETWORK_WIFI_DIRECT;
3258                 }
3259                 else
3260                 {
3261                         SysLog(NID_SYS, "It is not Wi-Fi direct on/off event. %d", state);
3262                         return;
3263                 }
3264         }
3265         else
3266         {
3267                 return;
3268         }
3269
3270         __pSettingManager->DeliverSettingEvent(settingKey);
3271 }
3272
3273 void
3274 _SettingManager::SettingEventTetheringEnabled(tethering_error_e err, tethering_type_e type, bool is_requested, void* data)
3275 {
3276         if(__pSettingManager == null)
3277         {
3278                 SysLogException(NID_SYS, E_SYSTEM, "SettingManager is not initialized");
3279                 return;
3280         }
3281
3282         String settingKey;
3283         switch(type)
3284         {
3285         case TETHERING_TYPE_USB:
3286                 settingKey = _USB_TETHERING;
3287         break;
3288         case TETHERING_TYPE_WIFI:
3289                 settingKey = _NETWORK_WIFI_TETHERING;
3290         break;
3291         case TETHERING_TYPE_BT:
3292                 settingKey = _NETWORK_BLUETOOTH_TETHERING;
3293         break;
3294         default:
3295                 return;
3296         }
3297         __pSettingManager->DeliverSettingEvent(settingKey);
3298 }
3299
3300 void
3301 _SettingManager::SettingEventTetheringDisabled(tethering_error_e err, tethering_type_e type, tethering_disabled_cause_e cause,void* data)
3302 {
3303         SettingEventTetheringEnabled(err, type, false, null);
3304 }
3305
3306 void
3307 _SettingManager::DeliverSettingEvent(String keyName)
3308 {
3309         if(__pSettingEvent != null)
3310         {
3311                 _SettingEventArg* settingEventArg = new (std::nothrow) _SettingEventArg();
3312                 if(settingEventArg == null)
3313                 {
3314                         SysLogException(NID_SYS, E_OUT_OF_MEMORY, "It is failed to create instance of _SettingEventArg");
3315                 }
3316                 settingEventArg->KeyName = keyName;
3317                 __pSettingEvent->Fire(*settingEventArg);
3318         }
3319
3320         if(__listenerInternalCount > 0)
3321         {
3322                 if(__pSettingEventForInternal != null)
3323                 {
3324                         _SettingEventArg* settingEventArgForInternal = new (std::nothrow) _SettingEventArg();
3325                         if(settingEventArgForInternal == null)
3326                         {
3327                                 SysLogException(NID_SYS, E_OUT_OF_MEMORY, "It is failed to create instance of _SettingEventArg");
3328                         }
3329                         settingEventArgForInternal->KeyName = keyName;
3330
3331                         __pSettingEventForInternal->Fire(*settingEventArgForInternal);
3332                 }
3333         }
3334 }
3335
3336 void
3337 _SettingManager::SettingEventFlightMode(TapiHandle* handle, int res, void* data, void* user_data)
3338 {
3339         SysLog(NID_SYS, "TAPI change event is occured");
3340         result r = E_SUCCESS;
3341         int ret = 0;
3342
3343         if(__pSettingManager == null)
3344         {
3345                 SysLogException(NID_SYS, E_SYSTEM, "SettingManager is not initialized");
3346                 return;
3347         }
3348
3349         if(__pSettingManager->__tapiHandle != handle)
3350         {
3351                 SysLogException(NID_SYS, E_SYSTEM, "SettingManager is not initialized");
3352                 return;
3353         }
3354
3355         SysLog(NID_SYS, "Flight mode changed");
3356
3357         switch (res)
3358         {
3359         case TAPI_POWER_FLIGHT_MODE_RESP_ON:
3360                 SysLog(NID_SYS, "success change flight mode on");
3361
3362                 ret = vconf_set_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, true);
3363                 if (ret != 0)
3364                 {
3365                         SysLogException(NID_SYS, E_SYSTEM, "Failed to set on VCONFKEY_TELEPHONY_FLIGHT_MODE vconf");
3366                 }
3367                 break;
3368         case TAPI_POWER_FLIGHT_MODE_RESP_OFF:
3369                 SysLog(NID_SYS, "success change flight mode off");
3370
3371                 ret = vconf_set_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, false);
3372                 if (ret != 0)
3373                 {
3374                         SysLogException(NID_SYS, E_SYSTEM, "Failed to set on VCONFKEY_TELEPHONY_FLIGHT_MODE vconf");
3375                 }
3376                 break;
3377         case TAPI_POWER_FLIGHT_MODE_RESP_FAIL:
3378         default:
3379                 SysLogException(NID_SYS, E_SYSTEM, "Failed to change flight mode");
3380                 r = E_SYSTEM;
3381         }
3382
3383         _SettingAsyncEvent* pEvent = (_SettingAsyncEvent*)user_data;
3384
3385         if(pEvent != null)
3386         {
3387                 _SettingAsyncEventArg* pSettingAsyncEventArg = new (std::nothrow) _SettingAsyncEventArg;
3388                 pSettingAsyncEventArg->Key = _NETWORK_FLIGHTMODE;
3389                 pSettingAsyncEventArg->errorCode = r;
3390                 pEvent->Fire(*pSettingAsyncEventArg);
3391         }
3392
3393         if(__pSettingManager->__tapiHandle != null)
3394         {
3395                 tel_deinit(__pSettingManager->__tapiHandle);
3396                 __pSettingManager->__tapiHandle = null;
3397         }
3398         else
3399         {
3400                 SysLogException(NID_SYS, E_SYSTEM, "TAPI is not ready");
3401                 return;
3402         }
3403 }
3404
3405 result
3406 _SettingManager::LoadBluetoothDll()
3407 {
3408         result r = E_SUCCESS;
3409         if(__pBluetoothDllHandle == null)
3410         {
3411                 __pBluetoothDllHandle = dlopen(_BLUETOOTH_LIBRARY_NAME, RTLD_LAZY);
3412                 SysTryReturnResult(NID_SYS, __pBluetoothDllHandle, E_SYSTEM, "It is failed to open bluetooth library.");
3413
3414                 pBluetoothManagerImpl_Activate = reinterpret_cast< result(*)(void)> (dlsym(__pBluetoothDllHandle, "_BluetoothManagerImpl_Activate"));
3415                 pBluetoothManagerImpl_Deactivate = reinterpret_cast< result(*)(void)> (dlsym(__pBluetoothDllHandle, "_BluetoothManagerImpl_Deactivate"));
3416
3417                 SysTryCatch(NID_SYS, pBluetoothManagerImpl_Activate != null, r = E_SYSTEM, E_SYSTEM, "It is failed to find _BluetoothManagerImpl_Activate method");
3418                 SysTryCatch(NID_SYS, pBluetoothManagerImpl_Deactivate != null, r = E_SYSTEM, E_SYSTEM, "It is failed to find _BluetoothManagerImpl_Deactivate method");
3419         }
3420 CATCH:
3421         if(r != E_SUCCESS)
3422         {
3423                 UnloadBluetoothDll();
3424         }
3425
3426         return E_SUCCESS;
3427 }
3428
3429 void
3430 _SettingManager::UnloadBluetoothDll()
3431 {
3432         if (__pBluetoothDllHandle != null)
3433         {
3434                 pBluetoothManagerImpl_Activate = null;
3435                 pBluetoothManagerImpl_Deactivate = null;
3436
3437                 dlclose(__pBluetoothDllHandle);
3438                 __pBluetoothDllHandle = null;
3439         }
3440 }
3441
3442 result
3443 _SettingManager::LoadWifiDll()
3444 {
3445         result r = E_SUCCESS;
3446         if (__pWifiDllHandle == null)
3447         {
3448                 __pWifiDllHandle = dlopen(_WIFI_DIRECT_LIBRARY_NAME, RTLD_LAZY);
3449                 SysTryReturnResult(NID_SYS, __pWifiDllHandle, E_SYSTEM, "It is failed to open wifi library.");
3450
3451                 pWifiDirectDeviceImpl_Activate = reinterpret_cast< result(*)(void)> (dlsym(__pWifiDllHandle, "_WifiDirectDeviceImpl_Activate"));
3452                 pWifiDirectDeviceImpl_Deactivate = reinterpret_cast< result(*)(void)> (dlsym(__pWifiDllHandle, "_WifiDirectDeviceImpl_Deactivate"));
3453                 pWifiDirectDeviceImpl_IsActivated = reinterpret_cast< bool(*)(void)> (dlsym(__pWifiDllHandle, "_WifiDirectDeviceImpl_IsActivated"));
3454                 pWifiManagerImpl_Activate = reinterpret_cast< result(*)(void)> (dlsym(__pWifiDllHandle, "_WifiManagerImpl_Activate"));
3455                 pWifiManagerImpl_Deactivate = reinterpret_cast< result(*)(void)> (dlsym(__pWifiDllHandle, "_WifiManagerImpl_Deactivate"));
3456
3457                 SysTryCatch(NID_SYS, pWifiDirectDeviceImpl_Activate != null, r = E_SYSTEM, E_SYSTEM, "It is failed to find _WifiDirectDeviceImpl_Activate method");
3458                 SysTryCatch(NID_SYS, pWifiDirectDeviceImpl_Deactivate != null, r = E_SYSTEM, E_SYSTEM, "It is failed to find _WifiDirectDeviceImpl_Deactivate method");
3459                 SysTryCatch(NID_SYS, pWifiDirectDeviceImpl_IsActivated != null, r = E_SYSTEM, E_SYSTEM, "It is failed to find _WifiDirectDeviceImpl_IsActivated method");
3460                 SysTryCatch(NID_SYS, pWifiManagerImpl_Activate != null, r = E_SYSTEM, E_SYSTEM, "It is failed to find _WifiManagerImpl_Activate method");
3461                 SysTryCatch(NID_SYS, pWifiManagerImpl_Deactivate != null, r = E_SYSTEM, E_SYSTEM, "It is failed to find _WifiManagerImpl_Deactivate method");
3462         }
3463 CATCH:
3464         if(r != E_SUCCESS)
3465         {
3466                 UnloadWifiDll();
3467         }
3468
3469         return E_SUCCESS;
3470 }
3471
3472 void
3473 _SettingManager::UnloadWifiDll()
3474 {
3475         if (__pWifiDllHandle != null)
3476         {
3477                 pWifiDirectDeviceImpl_Activate = null;
3478                 pWifiDirectDeviceImpl_Deactivate = null;
3479                 pWifiDirectDeviceImpl_IsActivated = null;
3480                 pWifiManagerImpl_Activate = null;
3481                 pWifiManagerImpl_Deactivate = null;
3482
3483                 dlclose(__pWifiDllHandle);
3484                 __pWifiDllHandle = null;
3485         }
3486 }
3487
3488 } } // Tizen::System