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