src/system/FSys_SystemInfoImpl.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_SystemInfoImpl.cpp
  20  * @brief               This is the implementation file for _SystemInfoImpl class.
  21  */
  22 #include <unique_ptr.h>
  23
  24 #include <FBaseBoolean.h>
  25 #include <FBaseInteger.h>
  26 #include <FBaseColHashMap.h>
  27
  28 #include <FBase_NativeError.h>
  29 #include <FIo_RegistryImpl.h>
  30 #include <FSys_SystemInfoImpl.h>
  31 #include <FIo_AppServiceIpcMessages.h>
  32 #include <FIo_IpcClient.h>
  33
  34 #include "FSys_Types.h"
  35 #include "FSys_SystemClient.h"
  36 #include "FSys_CommunicationDispatcherClient.h"
  37
  38 using namespace std;
  39
  40 using namespace Tizen::Base;
  41 using namespace Tizen::Base::Collection;
  42 using namespace Tizen::Io;
  43
  44 namespace Tizen { namespace System
  45 {
  46
  47 static const wchar_t* _REGISTRY_PATH = L"/opt/usr/etc/system_info_cache.ini";
  48 static const wchar_t* _SYSTEM_INFO_SESSION = L"SystemInformation";
  49
  50 //Bluetooth
  51 static const wchar_t* _BLUETOOTH = L"http://tizen.org/feature/network.bluetooth";
  52 static const wchar_t* _BLUETOOTH_SUPPORTED = L"BluetoothSupported";
  53
  54 //Camera
  55
  56 static const wchar_t* _CAMERA_FRONT = L"http://tizen.org/feature/camera.front";
  57
  58 static const wchar_t* _CAMERA_BACK = L"http://tizen.org/feature/camera.back";
  59
  60 static const wchar_t* _CAMERA_COUNT = L"CameraCount";
  61
  62 //DUID
  63 static const wchar_t* _DUID = L"http://tizen.org/system/duid";
  64 static const wchar_t* _DEVICE_ID = L"DUID";
  65
  66 //FM Radio
  67 static const wchar_t* _FMRADIO = L"http://tizen.org/feature/fmradio";
  68 static const wchar_t* _FM_RADIO_SUPPORTED = L"FmRadioSupported";
  69
  70 //Keyboard
  71 static const wchar_t* _KEYBOARD_TYPE = L"KeyboardType";
  72 static const wchar_t* _INPUT_KEYBOARD_LAYOUT = L"http://tizen.org/feature/input.keyboard.layout";
  73
  74 //Location
  75 static const wchar_t* _GPS_SUPPORTED = L"GPSSupported";
  76 static const wchar_t* _LOCATION_GPS = L"http://tizen.org/feature/location.gps";
  77 static const wchar_t* _WPS_SUPPORTED = L"WPSSupported";
  78 static const wchar_t* _LOCATION_WPS = L"http://tizen.org/feature/location.wps";
  79
  80 //Model name
  81 static const wchar_t* _MODELNAME = L"http://tizen.org/system/model_name";
  82 static const wchar_t* _MODEL_NAME = L"ModelName";
  83
  84 //Multi point
  85 static const wchar_t* _MULTIPOINTTOUCH_POINTCOUNT = L"http://tizen.org/feature/multi_point_touch.point_count";
  86 static const wchar_t* _MULTIPOINT_TOUCH_COUNT = L"MultiPointTouchCount";
  87
  88 //NFC
  89 static const wchar_t* _NETWORK_NFC = L"http://tizen.org/feature/network.nfc";
  90 static const wchar_t* _NFC_SUPPORTED = L"NFCSupported";
  91
  92 //Opengles
  93 static const wchar_t* _OPENGLES_VERSION_1_1 = L"http://tizen.org/feature/opengles.version.1_1";
  94 static const wchar_t* _OPENGLES_VERSION_2_0 = L"http://tizen.org/feature/opengles.version.2_0";
  95 static const wchar_t* _OPENGL_ES_VERSION = L"OpenGLESVersion";
  96
  97 // Screen
  98 static const wchar_t* _SCREEN_BPP = L"http://tizen.org/feature/screen.bpp";
  99 static const wchar_t* _SCREEN_BITS_PER_PIXEL = L"ScreenBitsPerPixel";
 100 static const wchar_t* _SCREEN_DPI = L"http://tizen.org/feature/screen.dpi";
 101 static const wchar_t* _SCREEN_HEIGHT = L"http://tizen.org/feature/screen.height";
 102 static const wchar_t* _SCREENHEIGHT = L"ScreenHeight";
 103 static const wchar_t* _SCREEN_WIDTH = L"http://tizen.org/feature/screen.width";
 104 static const wchar_t* _SCREENWIDTH = L"ScreenWidth";
 105 static const wchar_t* _SCREENDPI = L"ScreenDPI";
 106
 107 //HDMI RCA
 108 static const wchar_t* _SCREEN_OUTPUT_RCA = L"http://tizen.org/feature/screen.output.rca";
 109 static const wchar_t* _TV_OUT_SUPPORTED = L"TvOutSupported";
 110
 111 //Sound
 112 static const wchar_t* _SOUND_MEDIA_VOLUME_MAX = L"http://tizen.org/system/sound.media.volume.resolution.max";
 113 static const wchar_t* _MAX_MEDIA_SOUND_VOLUME = L"MaxMediaSoundVolume";
 114 static const wchar_t* _SOUND_NOTIFICATION_VOLUME_MAX = L"http://tizen.org/system/sound.notification.volume.resolution.max";
 115 static const wchar_t* _MAX_NOTIFICATION_SOUND_VOLUME = L"MaxNotificationSoundVolume";
 116 static const wchar_t* _SOUND_RINGTONE_VOLUME_MAX = L"http://tizen.org/system/sound.ringtone.volume.resolution.max";
 117 static const wchar_t* _MAX_RINGTONE_SOUND_VOLUME = L"MaxRingtoneSoundVolume";
 118 static const wchar_t* _SOUND_SYSTEM_VOLUME_MAX = L"http://tizen.org/system/sound.system.volume.resolution.max";
 119 static const wchar_t* _MAX_SYSTEM_SOUND_VOLUME = L"MaxSystemSoundVolume";
 120
 121 //Telephony
 122 static const wchar_t* _TELEPHONY = L"http://tizen.org/feature/network.telephony";
 123 static const wchar_t* _TELEPHONY_SERVICE_GSM = L"http://tizen.org/feature/network.telephony.service.gsm";
 124 static const wchar_t* _TELEPHONY_SERVICE_GPRS = L"http://tizen.org/feature/network.telephony.service.gprs";
 125 static const wchar_t* _TELEPHONY_SERVICE_EDGE = L"http://tizen.org/feature/network.telephony.service.edge";
 126 static const wchar_t* _TELEPHONY_SERVICE_UMTS = L"http://tizen.org/feature/network.telephony.service.umts";
 127 static const wchar_t* _TELEPHONY_SERVICE_HSDPA = L"http://tizen.org/feature/network.telephony.service.hsdpa";
 128 static const wchar_t* _TELEPHONY_SERVICE_HSUPA = L"http://tizen.org/feature/network.telephony.service.hsupa";
 129 static const wchar_t* _TELEPHONY_SERVICE_HSPA = L"http://tizen.org/feature/network.telephony.service.hspa";
 130 static const wchar_t* _TELEPHONY_SERVICE_LTE = L"http://tizen.org/feature/network.telephony.service.lte";
 131 static const wchar_t* _TELEPHONY_SERVICE_CDMA = L"http://tizen.org/feature/network.telephony.service.cdma";
 132 static const wchar_t* _NETWORK_TYPE = L"NetworkType";
 133 static const wchar_t* _NETWORK_EMERGENCY = L"Emergency";
 134 static const wchar_t* _NETWORK_NO_SERVICE = L"NoService";
 135
 136 //WIFI
 137 static const wchar_t* _WIFI = L"http://tizen.org/feature/network.wifi";
 138 static const wchar_t* _WIFI_SUPPORTED = L"WiFiSupported";
 139 static const wchar_t* _WIFI_DIRECT = L"http://tizen.org/feature/network.wifi.direct";
 140 static const wchar_t* _WIFI_DIRECT_SUPPORTED = L"WiFiDirectSupported";
 141
 142 //Version
 143 static const wchar_t* _PLATFORM_VERSION = L"http://tizen.org/feature/platform.version";
 144 static const wchar_t* _PLATFORM_NATIVE_API_VERSION = L"http://tizen.org/feature/platform.native.api.version";
 145 static const wchar_t* _PLATFORM_WEB_API_VERSION = L"http://tizen.org/feature/platform.web.api.version";
 146 static const wchar_t* _BUILD_STRING = L"http://tizen.org/system/build.string";
 147
 148 static const wchar_t* _WAC_VERSION = L"WACVersion";
 149 static const wchar_t* _SUPPORTED = L"Supported";
 150 static const wchar_t* _UNSUPPORTED = L"Unsupported";
 151
 152 static bool firstRequest = false;
 153 static HashMap integerList;
 154 static HashMap boolList;
 155 static HashMap stringList;
 156
 157 void
 158 PrepareCache(void)
 159 {
 160         if(firstRequest == false)
 161         {
 162                 integerList.Construct();
 163                 boolList.Construct();
 164                 stringList.Construct();
 165                 firstRequest = true;
 166         }
 167 }
 168
 169 String
 170 _SystemInfoImpl::ConvertToTizen(const String& key)
 171 {
 172         String code(key);
 173
 174         if(code == _DEVICE_ID)
 175         {
 176                 code = _DUID;
 177         }
 178         else if(code == _MODEL_NAME)
 179         {
 180                 code = _MODELNAME;
 181         }
 182         else if(code == _KEYBOARD_TYPE)
 183         {
 184                 code = _INPUT_KEYBOARD_LAYOUT;
 185         }
 186         else if(code == _SCREEN_BITS_PER_PIXEL)
 187         {
 188                 code = _SCREEN_BPP;
 189         }
 190         else if(code == _SCREENHEIGHT)
 191         {
 192                 code = _SCREEN_HEIGHT;
 193         }
 194         else if(code == _SCREENWIDTH)
 195         {
 196                 code = _SCREEN_WIDTH;
 197         }
 198         else if(code == _SCREENDPI)
 199         {
 200                 code = _SCREEN_DPI;
 201         }
 202         else if(code == _MAX_SYSTEM_SOUND_VOLUME)
 203         {
 204                 code = _SOUND_SYSTEM_VOLUME_MAX;
 205         }
 206         else if(code == _MAX_MEDIA_SOUND_VOLUME)
 207         {
 208                 code = _SOUND_MEDIA_VOLUME_MAX;
 209         }
 210         else if(code == _MAX_RINGTONE_SOUND_VOLUME)
 211         {
 212                 code = _SOUND_RINGTONE_VOLUME_MAX;
 213         }
 214         else if(code == _MAX_NOTIFICATION_SOUND_VOLUME)
 215         {
 216                 code = _SOUND_NOTIFICATION_VOLUME_MAX;
 217         }
 218         else if(code == _MULTIPOINT_TOUCH_COUNT)
 219         {
 220                 code = _MULTIPOINTTOUCH_POINTCOUNT;
 221         }
 222         else if(code == _BLUETOOTH_SUPPORTED)
 223         {
 224                 code = _BLUETOOTH;
 225         }
 226         else if(code == _GPS_SUPPORTED)
 227         {
 228                 code = _LOCATION_GPS;
 229         }
 230         else if(code == _WPS_SUPPORTED)
 231         {
 232                 code = _LOCATION_WPS;
 233         }
 234         else if(code == _WIFI_SUPPORTED)
 235         {
 236                 code = _WIFI;
 237         }
 238         else if(code == _WIFI_DIRECT_SUPPORTED)
 239         {
 240                 code = _WIFI_DIRECT;
 241         }
 242         else if(code == _FM_RADIO_SUPPORTED)
 243         {
 244                 code = _FMRADIO;
 245         }
 246         else if(code == _TV_OUT_SUPPORTED)
 247         {
 248                 code = _SCREEN_OUTPUT_RCA;
 249         }
 250         else if(code == _NFC_SUPPORTED)
 251         {
 252                 code = _NETWORK_NFC;
 253         }
 254         return code;
 255 }
 256
 257 result
 258 _SystemInfoImpl::GetSysInfo(const String& key, String& value)
 259 {
 260         result r = E_OBJ_NOT_FOUND;
 261         String tizenKey = ConvertToTizen(key);
 262
 263         if (firstRequest == false)
 264         {
 265                 PrepareCache();
 266         }
 267
 268         String* pValue = (String*)stringList.GetValue(key);
 269
 270         if(pValue != null)
 271         {
 272                 value = *pValue;
 273                 r = E_SUCCESS;
 274         }
 275
 276         if (key == _NETWORK_TYPE) //Compatibility
 277         {
 278                 bool supported = false;
 279                 GetSysInfo(_TELEPHONY, supported);
 280                 if(supported == false)
 281                 {
 282                         value = _NETWORK_EMERGENCY;
 283                 }
 284
 285                 bool supportedGsm = false;
 286                 bool supportedGprs = false;
 287                 bool supportedEdge = false;
 288                 bool supportedUmts = false;
 289                 bool supportedHsdpa = false;
 290                 bool supportedHsupa = false;
 291                 bool supportedHspa = false;
 292                 bool supportedLte = false;
 293                 bool supportedCdma = false;
 294
 295                 GetSysInfo(_TELEPHONY_SERVICE_GSM, supportedGsm);
 296                 GetSysInfo(_TELEPHONY_SERVICE_GPRS, supportedGprs);
 297                 GetSysInfo(_TELEPHONY_SERVICE_EDGE, supportedEdge);
 298                 GetSysInfo(_TELEPHONY_SERVICE_UMTS, supportedUmts);
 299                 GetSysInfo(_TELEPHONY_SERVICE_HSDPA, supportedHsdpa);
 300                 GetSysInfo(_TELEPHONY_SERVICE_HSUPA, supportedHsupa);
 301                 GetSysInfo(_TELEPHONY_SERVICE_HSPA, supportedHspa);
 302                 GetSysInfo(_TELEPHONY_SERVICE_LTE, supportedLte);
 303                 GetSysInfo(_TELEPHONY_SERVICE_CDMA, supportedCdma);
 304
 305                 value.Clear();
 306                 if(supportedGsm == false && supportedGprs == false
 307                         && supportedEdge == false && supportedUmts == false
 308                         && supportedHsdpa == false && supportedHsupa == false
 309                         && supportedHspa == false && supportedLte == false
 310                         && supportedCdma == false)
 311                 {
 312                         value = _NETWORK_NO_SERVICE;
 313                 }
 314                 else if(supportedGsm == true)
 315                 {
 316                         value.Append(L"GSM");
 317                 }
 318                 else if(supportedGprs == true)
 319                 {
 320                         if(value.GetLength() > 0)
 321                                 value.Append(L" | ");
 322
 323                         value.Append(L"GPRS");
 324                 }
 325                 else if(supportedEdge == true)
 326                 {
 327                         if(value.GetLength() > 0)
 328                                 value.Append(L" | ");
 329
 330                         value.Append(L"EDGE");
 331                 }
 332                 else if(supportedUmts == true)
 333                 {
 334                         if(value.GetLength() > 0)
 335                                 value.Append(L" | ");
 336
 337                         value.Append(L"UMTS");
 338                 }
 339                 else if(supportedHsdpa == true)
 340                 {
 341                         if(value.GetLength() > 0)
 342                                 value.Append(L" | ");
 343
 344                         value.Append(L"HSDPA");
 345                 }
 346                 else if(supportedHsupa == true)
 347                 {
 348                         if(value.GetLength() > 0)
 349                                 value.Append(L" | ");
 350
 351                         value.Append(L"HSUPA");
 352                 }
 353                 else if(supportedHspa == true)
 354                 {
 355                         if(value.GetLength() > 0)
 356                                 value.Append(L" | ");
 357
 358                         value.Append(L"HSPA");
 359                 }
 360                 else if(supportedLte == true)
 361                 {
 362                         if(value.GetLength() > 0)
 363                                 value.Append(L" | ");
 364
 365                         value.Append(L"LTE");
 366                 }
 367                 else if(supportedCdma == true)
 368                 {
 369                         if(value.GetLength() > 0)
 370                                 value.Append(L" | ");
 371
 372                         value.Append(L"CDMA");
 373                 }
 374                 r = E_SUCCESS;
 375         }
 376         else if (key == _OPENGL_ES_VERSION)
 377         {
 378                 bool opengles_11 = false;
 379                 bool opengles_20 = false;
 380
 381                 GetSysInfo(_OPENGLES_VERSION_1_1, opengles_11);
 382                 GetSysInfo(_OPENGLES_VERSION_2_0, opengles_20);
 383
 384                 if(opengles_11 == true)
 385                 {
 386                         value.Append(L"1.1");
 387                 }
 388                 else if(opengles_20 == true)
 389                 {
 390                         if(value.GetLength() > 0)
 391                                 value.Append(L" | ");
 392
 393                         value.Append(L"2.0");
 394                 }
 395                 r = E_SUCCESS;
 396         }
 397         else if(key == _BLUETOOTH_SUPPORTED)
 398         {
 399                 bool supported = false;
 400                 GetSysInfo(_BLUETOOTH, supported);
 401                 if(supported == false)
 402                         value = _SUPPORTED;
 403                 else
 404                         value = _UNSUPPORTED;
 405                 r = E_SUCCESS;
 406         }
 407         else if (key == _GPS_SUPPORTED)
 408         {
 409                 bool supported = false;
 410                 GetSysInfo(_LOCATION_GPS, supported);
 411                 if(supported == false)
 412                         value = _SUPPORTED;
 413                 else
 414                         value = _UNSUPPORTED;
 415                 r = E_SUCCESS;
 416         }
 417         else if (key == _WIFI_SUPPORTED)
 418         {
 419                 bool supported = false;
 420                 GetSysInfo(_WIFI, supported);
 421                 if(supported == false)
 422                         value = _SUPPORTED;
 423                 else
 424                         value = _UNSUPPORTED;
 425                 r = E_SUCCESS;
 426         }
 427         else if (key == _WAC_VERSION)
 428         {
 429                 value.Clear();
 430                 r = E_SUCCESS;
 431         }
 432         else if (key == _PLATFORM_NATIVE_API_VERSION || key == _PLATFORM_WEB_API_VERSION || key == _PLATFORM_VERSION || key == _BUILD_STRING)
 433         {
 434                 r = E_OBJ_NOT_FOUND;
 435         }
 436         else
 437         {
 438                 r = GetFromRegistry(tizenKey, value);
 439                 if(r != E_SUCCESS)
 440                 {
 441                         _SystemClient* pSystemClient = _SystemClient::GetInstance();
 442                         r = pSystemClient->GetValue(key, value);
 443                 }
 444         }
 445         if( r == E_SUCCESS)
 446         {
 447                 stringList.Add(new String(key), new String(value));
 448         }
 449         return r;
 450 }
 451
 452 result
 453 _SystemInfoImpl::GetSysInfo(const String& key, int& value)
 454 {
 455         result r = E_SUCCESS;
 456         String tizenKey = ConvertToTizen(key);
 457
 458         if (firstRequest == false)
 459         {
 460                 PrepareCache();
 461         }
 462
 463         Integer* pValue = (Integer*)integerList.GetValue(key);
 464
 465         if(pValue != null)
 466         {
 467                 value = pValue->value;
 468                 return E_SUCCESS;
 469         }
 470
 471         if (key == _CAMERA_COUNT)
 472         {
 473                 bool supported = false;
 474                 int cameraCount = 0;
 475
 476                 GetSysInfo(_CAMERA_FRONT, supported);
 477                 if(supported == true)
 478                         cameraCount++;
 479
 480                 GetSysInfo(_CAMERA_BACK, supported);
 481                 if(supported == true)
 482                         cameraCount++;
 483
 484                 value = cameraCount;
 485         }
 486         else
 487         {
 488                 r = GetFromRegistry(tizenKey, value);
 489                 if(r != E_SUCCESS)
 490                 {
 491                         _SystemClient* pSystemClient = _SystemClient::GetInstance();
 492                         r = pSystemClient->GetValue(key, value);
 493                 }
 494         }
 495
 496         if(r == E_SUCCESS)
 497         {
 498                 integerList.Add(new String(key), new Integer(value));
 499         }
 500
 501         return r;
 502 }
 503
 504 result
 505 _SystemInfoImpl::GetSysInfo(const String& key, long long& value)
 506 {
 507         return E_OBJ_NOT_FOUND;
 508 }
 509
 510 result
 511 _SystemInfoImpl::GetSysInfo(const String& key, double& value)
 512 {
 513         return E_OBJ_NOT_FOUND;
 514 }
 515
 516 result
 517 _SystemInfoImpl::GetSysInfo(const String& key, bool& value)
 518 {
 519         result r = E_SUCCESS;
 520         String tizenKey = ConvertToTizen(key);
 521
 522         if (firstRequest == false)
 523         {
 524                 PrepareCache();
 525         }
 526
 527         Boolean* pValue = (Boolean*)boolList.GetValue(key);
 528
 529         if(pValue != null)
 530         {
 531                 value = pValue->value;
 532                 return E_SUCCESS;
 533         }
 534
 535         r = GetFromRegistry(tizenKey, value);
 536         if(r != E_SUCCESS)
 537         {
 538                 _SystemClient* pSystemClient = _SystemClient::GetInstance();
 539                 r = pSystemClient->GetValue(key, value);
 540         }
 541         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_OBJ_NOT_FOUND, "It is failed to get the key[%ls]", tizenKey.GetPointer());
 542
 543         if(r == E_SUCCESS)
 544         {
 545                 boolList.Add(new String(key), new Boolean(value));
 546         }
 547
 548         return r;
 549 }
 550
 551 result
 552 _SystemInfoImpl::GetSysInfo(const String& key, UuId& value)
 553 {
 554         return E_OBJ_NOT_FOUND;
 555 }
 556
 557 Collection::IList*
 558 _SystemInfoImpl::GetSysInfoValuesN(const String& key, SystemInfoValueType type)
 559 {
 560         SetLastResult(E_OBJ_NOT_FOUND);
 561         return null;
 562 }
 563
 564 result
 565 _SystemInfoImpl::GetPlatformVersion(String& platformVersion)
 566 {
 567         result r = E_SUCCESS;
 568         String tizenKey(_PLATFORM_VERSION);
 569
 570         r = GetFromRegistry(tizenKey, platformVersion);
 571         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the key[%ls]", tizenKey.GetPointer());
 572         return r;
 573 }
 574
 575 result
 576 _SystemInfoImpl::GetBuildInfo(String& buildInfo)
 577 {
 578         result r = E_SUCCESS;
 579         String tizenKey(_BUILD_STRING);
 580
 581         r = GetFromRegistry(tizenKey, buildInfo);
 582         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the key[%ls]", tizenKey.GetPointer());
 583         return r;
 584 }
 585
 586 result
 587 _SystemInfoImpl::GetNativeApiVersion(String& nativeApiVersion)
 588 {
 589         result r = E_SUCCESS;
 590         String tizenKey(_PLATFORM_NATIVE_API_VERSION);
 591
 592         r = GetFromRegistry(tizenKey, nativeApiVersion);
 593         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the key[%ls]", tizenKey.GetPointer());
 594         return r;
 595 }
 596
 597 result
 598 _SystemInfoImpl::GetWebApiVersion(String& webApiVersion)
 599 {
 600         result r = E_SUCCESS;
 601         String tizenKey(_PLATFORM_WEB_API_VERSION);
 602
 603         r = GetFromRegistry(tizenKey, webApiVersion);
 604         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the key[%ls]", tizenKey.GetPointer());
 605         return r;
 606 }
 607
 608 result
 609 _SystemInfoImpl::GetImei(String& imei)
 610 {
 611         result r = E_SUCCESS;
 612
 613         ArrayList requestMessage;
 614         ArrayList responseMessage;
 615
 616         _CommunicationDispatcherClient* pCommunicationDispatcherClient = _CommunicationDispatcherClient::GetInstance();
 617
 618         _IpcClient* pIpcClient = pCommunicationDispatcherClient->GetIpcClient();
 619         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 620
 621         requestMessage.Construct();
 622         responseMessage.Construct();
 623
 624         String serviceId(_SYSTEM_SERVICE_ID);
 625         String commandId(L"osp.system.command.get.imei.internal");
 626
 627         requestMessage.Add(serviceId);
 628         requestMessage.Add(commandId);
 629
 630         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 631         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 632
 633         r = pIpcClient->SendRequest(pMsg.get());
 634         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "It is failed to send ipc message. [%s]", GetErrorMessage(r));
 635
 636         unique_ptr<String> pResult((String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA));
 637         unique_ptr<String> pImei((String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA+1));
 638
 639         SysTryReturnResult(NID_SYS, pResult != null, E_SYSTEM, "It is failed to receive result on IPC response message.");
 640         SysTryReturnResult(NID_SYS, pImei != null, E_SYSTEM, "It is failed to receive IMEI value on IPC response message.");
 641
 642         SysTryReturnResult(NID_SYS, *pResult != _SYSTEM_RESULT_PRIVILEGED, E_PRIVILEGE_DENIED, "It is failed to get privilege.");
 643         SysTryReturnResult(NID_SYS, *pResult == _SYSTEM_RESULT_OK, E_SYSTEM, "It is failed to get IMEI value.");
 644
 645         imei = *pImei;
 646         return r;
 647 }
 648
 649 result
 650 _SystemInfoImpl::GetFromRegistry(const String& key, String& value)
 651 {
 652         result r = E_SUCCESS;
 653         _RegistryImpl _reg;
 654         String valStr;
 655
 656         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 657         SysTryReturnResult(NID_SYS, r == E_SUCCESS , r, " RegistryImpl construct It is failed");
 658
 659         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 660         SysTryReturnResult(NID_SYS, r == E_SUCCESS , r, " Registry GetValue  It is failed");
 661
 662         if(valStr == L"true" || valStr == L"false")
 663         {
 664                 return E_OBJ_NOT_FOUND;
 665         }
 666         else
 667         {
 668                 value = valStr;
 669         }
 670
 671         return E_SUCCESS;
 672 }
 673
 674 result
 675 _SystemInfoImpl::GetFromRegistry(const String& key, int& value)
 676 {
 677         result r = E_SUCCESS;
 678         _RegistryImpl _reg;
 679         String valStr;
 680         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 681         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " RegistryImpl construct It is failed");
 682
 683         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 684         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " Registry GetValue  It is failed");
 685         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, " Registry GetValue  It is failed");
 686         r = Integer::Parse(valStr, value);
 687         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_OBJ_NOT_FOUND, " Integer::Parse()  It is failed");
 688         return E_SUCCESS;
 689 }
 690
 691 result
 692 _SystemInfoImpl::GetFromRegistry(const String& key, bool& value)
 693 {
 694         result r = E_SUCCESS;
 695         _RegistryImpl _reg;
 696         String valStr;
 697         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 698         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " RegistryImpl construct It is failed");
 699
 700         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 701         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " Registry GetValue It is failed");
 702         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, " Registry GetValue  It is failed");
 703         if(valStr == L"true")
 704         {
 705                 value = true;
 706         }
 707         else if(valStr == L"false")
 708         {
 709                 value = false;
 710         }
 711         else
 712         {
 713                 return E_OBJ_NOT_FOUND;
 714         }
 715         return E_SUCCESS;
 716 }
 717
 718 _SystemInfoImpl*
 719 _SystemInfoImpl::GetInstance(SystemInfo& systeminfo)
 720 {
 721         return systeminfo.__pSystemInfoImpl;
 722 }
 723 const _SystemInfoImpl*
 724 _SystemInfoImpl::GetInstance(const SystemInfo& systeminfo)
 725 {
 726         return systeminfo.__pSystemInfoImpl;
 727 }
 728 } } // Tizen::System