src/system/FSys_SettingInfoImpl.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_SettingInfoImpl.cpp
  20  * @brief               This is the implementation file for _SysSettingInfoImpl class.
  21  */
  22 #include <system/system_settings.h>
  23 #include <FBase.h>
  24 #include <FBaseColArrayList.h>
  25 #include <FBaseSysLog.h>
  26
  27 #include <FBase_StringConverter.h>
  28 #include <FBase_NativeError.h>
  29 #include <FSys_SettingInfoImpl.h>
  30 #include "FSys_SettingClient.h"
  31
  32 using namespace Tizen::App;
  33 using namespace Tizen::Base;
  34 using namespace Tizen::Base::Collection;
  35 using namespace Tizen::Io;
  36 using namespace Tizen::Base::Utility;
  37
  38 namespace Tizen { namespace System
  39 {
  40 //IDs for IPC
  41 static const int _SYSTEM_RESPONSE_DATA = 2;
  42
  43 //Reserved key
  44 static const wchar_t* _SETTING_SCREEN_WALLPAPER = L"http://tizen.org/setting/screen.wallpaper";
  45 static const wchar_t* _SETTING_SYSTEM_SOUND_VOLUME = L"SystemSoundVolume";
  46 static const wchar_t* _SETTING_SOUND_SYSTEM_VOLUME= L"http://tizen.org/setting/sound.system.volume";
  47 static const wchar_t* _SETTING_MEDIA_SOUND_VOLUME = L"MediaSoundVolume";
  48 static const wchar_t* _SETTING_SOUND_MEDIA_VOLUME = L"http://tizen.org/setting/sound.media.volume";
  49 static const wchar_t* _SETTING_RINGTONE_SOUND_VOLUME = L"RingtoneSoundVolume";
  50 static const wchar_t* _SETTING_SOUND_RINGTONE = L"http://tizen.org/setting/sound.ringtone";
  51 static const wchar_t* _SETTING_SOUND_RINGTONE_VOLUME = L"http://tizen.org/setting/sound.ringtone.volume";
  52 static const wchar_t* _SETTING_NOTIFICATION_SOUND_VOLUME = L"NotificationSoundVolume";
  53 static const wchar_t* _SETTING_SOUND_NOTIFICATION_VOLUME = L"http://tizen.org/setting/sound.notification.volume";
  54
  55 //Font
  56 static const wchar_t* _FONT_SIZE = L"http://tizen.org/setting/font.size";
  57 static const wchar_t* _FONT_TYPE = L"http://tizen.org/setting/font.type";
  58
  59 static const wchar_t* _FONT_SIZE_GIANT = L"giant";
  60 static const wchar_t* _FONT_SIZE_HUGE = L"huge";
  61 static const wchar_t* _FONT_SIZE_LARGE = L"large";
  62 static const wchar_t* _FONT_SIZE_MEDIUM = L"medium";
  63 static const wchar_t* _FONT_SIZE_SMALL = L"small";
  64
  65 static const int _FONT_SIZE_GIANT_VCONF = 4;
  66 static const int _FONT_SIZE_HUGE_VCONF = 3;
  67 static const int _FONT_SIZE_LARGE_VCONF = 2;
  68 static const int _FONT_SIZE_MEDIUM_VCONF = 1;
  69 static const int _FONT_SIZE_SMALL_VCONF = 0;
  70
  71
  72 static _SettingClient* pSettingClient = null;
  73
  74 void
  75 _SettingInfoImpl::InitSettingClient(void)
  76 {
  77         if(pSettingClient == null)
  78         {
  79                 pSettingClient =  _SettingClient::GetInstance();
  80         }
  81 }
  82 result
  83 _SettingInfoImpl::GetValue(const Tizen::Base::String& key, Tizen::Base::String& value)
  84 {
  85         result r = E_SUCCESS;
  86
  87         if (key == _FONT_SIZE || key == _FONT_TYPE)
  88         {
  89                 r = GetValueForFont(key, value);
  90         }
  91         else
  92         {
  93                 InitSettingClient();
  94                 SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
  95                 r = pSettingClient->GetValue(key, value);
  96         }
  97         return r;
  98 }
  99
 100 result
 101 _SettingInfoImpl::GetValue(const Tizen::Base::String& key, int& value)
 102 {
 103         InitSettingClient();
 104         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 105         return pSettingClient->GetValue(key, value);
 106 }
 107
 108 result
 109 _SettingInfoImpl::GetValue(const Tizen::Base::String& key, long long& value)
 110 {
 111         InitSettingClient();
 112         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 113         return pSettingClient->GetValue(key, value);
 114 }
 115
 116 result
 117 _SettingInfoImpl::GetValue(const Tizen::Base::String& key, double& value)
 118 {
 119         InitSettingClient();
 120         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 121         return pSettingClient->GetValue(key, value);
 122 }
 123
 124 result
 125 _SettingInfoImpl::GetValue(const Tizen::Base::String& key, bool& value)
 126 {
 127         InitSettingClient();
 128         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 129         return pSettingClient->GetValue(key, value);
 130 }
 131
 132 result
 133 _SettingInfoImpl::GetValue(const Tizen::Base::String& key, Tizen::Base::UuId& value)
 134 {
 135         InitSettingClient();
 136         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 137         return pSettingClient->GetValue(key, value);
 138 }
 139
 140 result
 141 _SettingInfoImpl::SetWallpaper(const Tizen::Base::String& filePath)
 142 {
 143         InitSettingClient();
 144         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 145         result r = pSettingClient->SetValue(_SETTING_SCREEN_WALLPAPER, filePath);
 146
 147         if(r == E_INVALID_ARG)
 148                 r = E_FILE_NOT_FOUND;
 149         else if(r == E_OBJ_NOT_FOUND)
 150                 r = E_SYSTEM;
 151         else if(r == E_UNSUPPORTED_OPERATION)
 152                 r = E_SYSTEM;
 153
 154         return r;
 155 }
 156
 157 result
 158 _SettingInfoImpl::GetValueForPrivilegedKey(const String& key, bool& value)
 159 {
 160         InitSettingClient();
 161         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 162         return pSettingClient->GetValueForPrivilegedKey(key, value);
 163 }
 164
 165 result
 166 _SettingInfoImpl::SetValue(const String& key, bool value)
 167 {
 168         InitSettingClient();
 169         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 170         return pSettingClient->SetValue(key, value);
 171 }
 172
 173 result
 174 _SettingInfoImpl::SetValue(const String& key, int value)
 175 {
 176         InitSettingClient();
 177         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 178         return pSettingClient->SetValue(key, value);
 179 }
 180
 181
 182 result
 183 _SettingInfoImpl::SetValue(const String& key, String value)
 184 {
 185         result r = E_SUCCESS;
 186         if (key == _FONT_SIZE || key == _FONT_TYPE)
 187         {
 188                 r = SetValueForFont(key, value);
 189         }
 190         else
 191         {
 192                 InitSettingClient();
 193                 SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 194                 r = pSettingClient->SetValue(key, value);
 195         }
 196         return r;
 197 }
 198
 199 result
 200 _SettingInfoImpl::SetValueForPrivilegedKey(const String& key, bool value)
 201 {
 202         InitSettingClient();
 203         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 204         return pSettingClient->SetValueForPrivilegedKey(key, value);
 205 }
 206
 207 result
 208 _SettingInfoImpl::SetValueForPrivilegedKey(const String& key, String value)
 209 {
 210         InitSettingClient();
 211         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 212         return pSettingClient->SetValueForPrivilegedKey(key, value);
 213 }
 214
 215 bool
 216 _SettingInfoImpl::HasKey(const String& key)
 217 {
 218         InitSettingClient();
 219         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 220         return pSettingClient->HasKey(key);
 221 }
 222 result
 223 _SettingInfoImpl::ResetToFactoryDefault(void)
 224 {
 225         InitSettingClient();
 226         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 227         return pSettingClient->ResetToFactoryDefault();
 228 }
 229
 230 result
 231 _SettingInfoImpl::SetRingtone(const Tizen::Base::String& filePath)
 232 {
 233         InitSettingClient();
 234         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 235         result r = pSettingClient->SetValue(_SETTING_SOUND_RINGTONE, filePath);
 236
 237         if(r == E_INVALID_ARG)
 238                 r = E_FILE_NOT_FOUND;
 239         else if(r == E_OBJ_NOT_FOUND)
 240                 r = E_SYSTEM;
 241         else if(r == E_UNSUPPORTED_OPERATION)
 242                 r = E_SYSTEM;
 243
 244         return r;
 245 }
 246
 247 result
 248 _SettingInfoImpl::SetVolume(const Tizen::Base::String& soundCategory, int level)
 249 {
 250         result r = E_SUCCESS;
 251         String key;
 252
 253         InitSettingClient();
 254         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 255
 256         if (soundCategory == _SETTING_SYSTEM_SOUND_VOLUME)
 257         {
 258                 key = _SETTING_SOUND_SYSTEM_VOLUME;
 259         }
 260         else if (soundCategory == _SETTING_MEDIA_SOUND_VOLUME)
 261         {
 262                 key = _SETTING_SOUND_MEDIA_VOLUME;
 263         }
 264         else if (soundCategory == _SETTING_RINGTONE_SOUND_VOLUME)
 265         {
 266                 key = _SETTING_SOUND_RINGTONE_VOLUME;
 267         }
 268         else if (soundCategory == _SETTING_NOTIFICATION_SOUND_VOLUME)
 269         {
 270                 key = _SETTING_SOUND_NOTIFICATION_VOLUME;
 271         }
 272         else
 273         {
 274                 key = soundCategory;
 275         }
 276
 277         r = pSettingClient->SetValue(key, level);
 278
 279         if (r == E_OBJ_NOT_FOUND)
 280         {
 281                 r = E_INVALID_ARG;
 282         }
 283         else if(r == E_INVALID_ARG)
 284         {
 285                 r = E_OUT_OF_RANGE;
 286         }
 287         else if(r == E_UNSUPPORTED_OPERATION)
 288         {
 289                 r = E_SYSTEM;
 290         }
 291         return r;
 292 }
 293
 294 result
 295 _SettingInfoImpl::AddSettingEventListener(ISettingEventListener& listener)
 296 {
 297         InitSettingClient();
 298         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 299         return pSettingClient->AddSettingEventListener(listener);
 300 }
 301
 302 result
 303 _SettingInfoImpl::RemoveSettingEventListener(ISettingEventListener& listener)
 304 {
 305         InitSettingClient();
 306         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 307         return pSettingClient->RemoveSettingEventListener(listener);
 308 }
 309
 310 result
 311 _SettingInfoImpl::AddSettingEventListenerForInternal(ISettingEventListener& listener)
 312 {
 313         InitSettingClient();
 314         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 315         return pSettingClient->AddSettingEventListenerForInternal(listener);
 316 }
 317
 318 result
 319 _SettingInfoImpl::RemoveSettingEventListenerForInternal(ISettingEventListener& listener)
 320 {
 321         InitSettingClient();
 322         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 323         return pSettingClient->RemoveSettingEventListenerForInternal(listener);
 324 }
 325
 326 result
 327 _SettingInfoImpl::SetSettingEventListener(ISettingEventListener* pListener)
 328 {
 329         InitSettingClient();
 330         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 331         return pSettingClient->SetSettingEventListener(pListener);
 332 }
 333
 334 result
 335 _SettingInfoImpl::SetValueAsyncForPrivilegedKey(const Tizen::Base::String& key, bool value, ISettingInfoSetValueAsyncResultListener* listener)
 336 {
 337         InitSettingClient();
 338         SysTryReturnResult(NID_SYS, pSettingClient != null, E_SYSTEM, "It is failed to intialize setting manager");
 339         return pSettingClient->SetValueAsyncForPrivilegedKey(key, value, listener);
 340 }
 341
 342 _SettingInfoImpl*
 343 _SettingInfoImpl::GetInstance(SettingInfo& settinginfo)
 344 {
 345         return settinginfo.__pSettingInfoImpl;
 346 }
 347
 348 const _SettingInfoImpl*
 349 _SettingInfoImpl::GetInstance(const SettingInfo& settinginfo)
 350 {
 351         return settinginfo.__pSettingInfoImpl;
 352 }
 353
 354 result
 355 _SettingInfoImpl::GetValueForFont(const Tizen::Base::String& key, Tizen::Base::String& value)
 356 {
 357         result r = E_OBJ_NOT_FOUND;
 358
 359         if (key == _FONT_SIZE)
 360         {
 361                 int fontSize = 0;
 362                 int res = 0;
 363                 res = system_settings_get_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, &fontSize);
 364
 365                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to get font size.");
 366
 367                 r = E_SUCCESS;
 368                 switch (fontSize)
 369                 {
 370                 case _FONT_SIZE_GIANT_VCONF:
 371                         value.Append(_FONT_SIZE_GIANT);
 372                         break;
 373                 case _FONT_SIZE_HUGE_VCONF:
 374                         value.Append(_FONT_SIZE_HUGE);
 375                         break;
 376                 case _FONT_SIZE_LARGE_VCONF:
 377                         value.Append(_FONT_SIZE_LARGE);
 378                         break;
 379                 case _FONT_SIZE_MEDIUM_VCONF:
 380                         value.Append(_FONT_SIZE_MEDIUM);
 381                         break;
 382                 case _FONT_SIZE_SMALL_VCONF:
 383                         value.Append(_FONT_SIZE_SMALL);
 384                         break;
 385                 default:
 386                         r = E_SYSTEM;
 387                         break;
 388                 }
 389
 390         }
 391         else if (key == _FONT_TYPE)
 392         {
 393                 r = E_SUCCESS;
 394                 char* pFontType = null;
 395                 int res = 0;
 396                 res = system_settings_get_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, &pFontType);
 397                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "Failed to get font type");
 398                 r = StringUtil::Utf8ToString(pFontType, value);
 399                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::Utf8ToString failed", GetErrorMessage(r));
 400                 free(pFontType);
 401         }
 402         return r;
 403 }
 404
 405
 406 result
 407 _SettingInfoImpl::SetValueForFont(const Tizen::Base::String& key, Tizen::Base::String value)
 408 {
 409         result r = E_OBJ_NOT_FOUND;
 410
 411         if(key == _FONT_SIZE)
 412         {
 413                 int fontSize = 0;
 414                 int res = 0;
 415                 String lowerValue = value;
 416                 lowerValue.ToLowerCase();
 417                 r = E_SUCCESS;
 418
 419                 if (lowerValue == _FONT_SIZE_GIANT)
 420                 {
 421                         fontSize = _FONT_SIZE_GIANT_VCONF;
 422                 }
 423                 else if (lowerValue == _FONT_SIZE_HUGE)
 424                 {
 425                         fontSize = _FONT_SIZE_HUGE_VCONF;
 426                 }
 427                 else if (lowerValue == _FONT_SIZE_LARGE)
 428                 {
 429                         fontSize = _FONT_SIZE_LARGE_VCONF;
 430                 }
 431                 else if (lowerValue == _FONT_SIZE_MEDIUM)
 432                 {
 433                         fontSize = _FONT_SIZE_MEDIUM_VCONF;
 434                 }
 435                 else if (lowerValue == _FONT_SIZE_SMALL)
 436                 {
 437                         fontSize = _FONT_SIZE_SMALL_VCONF;
 438                 }
 439                 else
 440                 {
 441                         return E_INVALID_ARG;
 442                 }
 443                 res = system_settings_set_value_int(SYSTEM_SETTINGS_KEY_FONT_SIZE, fontSize);
 444                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to set font size.");
 445         }
 446         else if(key == _FONT_TYPE)
 447         {
 448                 char* pFontType = null;
 449                 int res = 0;
 450                 r = E_SUCCESS;
 451
 452                 pFontType = _StringConverter::CopyToCharArrayN(value);
 453                 SysTryReturnResult(NID_SYS, pFontType != null, E_SYSTEM, "It is failed to convert String to string.");
 454                 SysLog(NID_SYS, "Requested font type is %s.", pFontType);
 455                 res = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_FONT_TYPE, pFontType);
 456                 delete [] pFontType;
 457                 SysTryReturnResult(NID_SYS, res == SYSTEM_SETTINGS_ERROR_NONE, E_SYSTEM, "It is failed to set font type.");
 458         }
 459         return r;
 460 }
 461
 462
 463 } } // Tizen::System