src/system/FSys_SettingInfoImpl.cpp

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