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