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