src/system/FSys_SystemInfoImpl.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_SystemInfoImpl.cpp
  19  * @brief               This is the implementation file for _SystemInfoImpl class.
  20  */
  21 #include <unique_ptr.h>
  22 #include <unistd.h>
  23
  24 #include <system_info.h>
  25 #include <ITapiModem.h>
  26
  27 #include <FBaseBoolean.h>
  28 #include <FBaseInteger.h>
  29 #include <FBaseColHashMap.h>
  30 #include <FBaseUtilStringUtil.h>
  31 #include <FIoRegistry.h>
  32
  33 #include <FBase_NativeError.h>
  34 #include <FBase_StringConverter.h>
  35 #include <FIo_RegistryImpl.h>
  36 #include <FSys_SystemInfoImpl.h>
  37 #include <FIo_AppServiceIpcMessages.h>
  38 #include <FIo_IpcClient.h>
  39
  40 #include "FSys_Types.h"
  41 #include "FSys_SystemClient.h"
  42 #include "FSys_CommunicationDispatcherClient.h"
  43
  44 using namespace std;
  45
  46 using namespace Tizen::Base;
  47 using namespace Tizen::Base::Collection;
  48 using namespace Tizen::Io;
  49 using namespace Tizen::Base::Utility;
  50
  51 namespace Tizen { namespace System
  52 {
  53
  54 static const wchar_t* _REGISTRY_PATH = L"/opt/usr/etc/system_info_cache.ini";
  55 static const wchar_t* _SYSTEM_INFO_SESSION = L"SystemInformation";
  56
  57 //Bluetooth
  58 static const wchar_t* _BLUETOOTH = L"http://tizen.org/feature/network.bluetooth";
  59 static const wchar_t* _BLUETOOTH_SUPPORTED = L"BluetoothSupported";
  60
  61 //Camera
  62
  63 static const wchar_t* _CAMERA_FRONT = L"http://tizen.org/feature/camera.front";
  64
  65 static const wchar_t* _CAMERA_BACK = L"http://tizen.org/feature/camera.back";
  66
  67 static const wchar_t* _CAMERA_COUNT = L"CameraCount";
  68
  69 //DUID
  70 static const wchar_t* _DUID = L"http://tizen.org/system/duid";
  71 static const wchar_t* _DEVICE_ID = L"DUID";
  72
  73 //FM Radio
  74 static const wchar_t* _FMRADIO = L"http://tizen.org/feature/fmradio";
  75 static const wchar_t* _FM_RADIO_SUPPORTED = L"FmRadioSupported";
  76
  77 //Keyboard
  78 static const wchar_t* _KEYBOARD_TYPE = L"KeyboardType";
  79 static const wchar_t* _INPUT_KEYBOARD_LAYOUT = L"http://tizen.org/feature/input.keyboard.layout";
  80
  81 //Location
  82 static const wchar_t* _GPS_SUPPORTED = L"GPSSupported";
  83 static const wchar_t* _LOCATION_GPS = L"http://tizen.org/feature/location.gps";
  84 static const wchar_t* _WPS_SUPPORTED = L"WPSSupported";
  85 static const wchar_t* _LOCATION_WPS = L"http://tizen.org/feature/location.wps";
  86
  87 //Model name
  88 static const wchar_t* _MODELNAME = L"http://tizen.org/system/model_name";
  89 static const wchar_t* _MODEL_NAME = L"ModelName";
  90
  91 //Multi point
  92 static const wchar_t* _MULTIPOINTTOUCH_POINTCOUNT = L"http://tizen.org/feature/multi_point_touch.point_count";
  93 static const wchar_t* _MULTIPOINT_TOUCH_COUNT = L"MultiPointTouchCount";
  94
  95 //NFC
  96 static const wchar_t* _NETWORK_NFC = L"http://tizen.org/feature/network.nfc";
  97 static const wchar_t* _NFC_SUPPORTED = L"NFCSupported";
  98
  99 //Opengles
 100 static const wchar_t* _OPENGLES_VERSION_1_1 = L"http://tizen.org/feature/opengles.version.1_1";
 101 static const wchar_t* _OPENGLES_VERSION_2_0 = L"http://tizen.org/feature/opengles.version.2_0";
 102 static const wchar_t* _OPENGL_ES_VERSION = L"OpenGLESVersion";
 103
 104 // Screen
 105 static const wchar_t* _SCREEN_BPP = L"http://tizen.org/feature/screen.bpp";
 106 static const wchar_t* _SCREEN_BITS_PER_PIXEL = L"ScreenBitsPerPixel";
 107 static const wchar_t* _SCREEN_DPI = L"http://tizen.org/feature/screen.dpi";
 108 static const wchar_t* _SCREEN_HEIGHT = L"http://tizen.org/feature/screen.height";
 109 static const wchar_t* _SCREENHEIGHT = L"ScreenHeight";
 110 static const wchar_t* _SCREEN_WIDTH = L"http://tizen.org/feature/screen.width";
 111 static const wchar_t* _SCREENWIDTH = L"ScreenWidth";
 112 static const wchar_t* _SCREENDPI = L"ScreenDPI";
 113
 114 //HDMI RCA
 115 static const wchar_t* _SCREEN_OUTPUT_RCA = L"http://tizen.org/feature/screen.output.rca";
 116 static const wchar_t* _TV_OUT_SUPPORTED = L"TvOutSupported";
 117
 118 //Sound
 119 static const wchar_t* _SOUND_MEDIA_VOLUME_MAX = L"http://tizen.org/system/sound.media.volume.resolution.max";
 120 static const wchar_t* _MAX_MEDIA_SOUND_VOLUME = L"MaxMediaSoundVolume";
 121 static const wchar_t* _SOUND_NOTIFICATION_VOLUME_MAX = L"http://tizen.org/system/sound.notification.volume.resolution.max";
 122 static const wchar_t* _MAX_NOTIFICATION_SOUND_VOLUME = L"MaxNotificationSoundVolume";
 123 static const wchar_t* _SOUND_RINGTONE_VOLUME_MAX = L"http://tizen.org/system/sound.ringtone.volume.resolution.max";
 124 static const wchar_t* _MAX_RINGTONE_SOUND_VOLUME = L"MaxRingtoneSoundVolume";
 125 static const wchar_t* _SOUND_SYSTEM_VOLUME_MAX = L"http://tizen.org/system/sound.system.volume.resolution.max";
 126 static const wchar_t* _MAX_SYSTEM_SOUND_VOLUME = L"MaxSystemSoundVolume";
 127
 128 //Telephony
 129 static const wchar_t* _TELEPHONY = L"http://tizen.org/feature/network.telephony";
 130 static const wchar_t* _TELEPHONY_SERVICE_GSM = L"http://tizen.org/feature/network.telephony.service.gsm";
 131 static const wchar_t* _TELEPHONY_SERVICE_GPRS = L"http://tizen.org/feature/network.telephony.service.gprs";
 132 static const wchar_t* _TELEPHONY_SERVICE_EDGE = L"http://tizen.org/feature/network.telephony.service.edge";
 133 static const wchar_t* _TELEPHONY_SERVICE_UMTS = L"http://tizen.org/feature/network.telephony.service.umts";
 134 static const wchar_t* _TELEPHONY_SERVICE_HSDPA = L"http://tizen.org/feature/network.telephony.service.hsdpa";
 135 static const wchar_t* _TELEPHONY_SERVICE_HSUPA = L"http://tizen.org/feature/network.telephony.service.hsupa";
 136 static const wchar_t* _TELEPHONY_SERVICE_HSPA = L"http://tizen.org/feature/network.telephony.service.hspa";
 137 static const wchar_t* _TELEPHONY_SERVICE_LTE = L"http://tizen.org/feature/network.telephony.service.lte";
 138 static const wchar_t* _TELEPHONY_SERVICE_CDMA = L"http://tizen.org/feature/network.telephony.service.cdma";
 139 static const wchar_t* _NETWORK_TYPE = L"NetworkType";
 140 static const wchar_t* _NETWORK_EMERGENCY = L"Emergency";
 141 static const wchar_t* _NETWORK_NO_SERVICE = L"NoService";
 142
 143 //WIFI
 144 static const wchar_t* _WIFI = L"http://tizen.org/feature/network.wifi";
 145 static const wchar_t* _WIFI_SUPPORTED = L"WiFiSupported";
 146 static const wchar_t* _WIFI_DIRECT = L"http://tizen.org/feature/network.wifi.direct";
 147 static const wchar_t* _WIFI_DIRECT_SUPPORTED = L"WiFiDirectSupported";
 148
 149 //Version
 150 static const wchar_t* _PLATFORM_VERSION = L"http://tizen.org/feature/platform.version";
 151 static const wchar_t* _PLATFORM_NATIVE_API_VERSION = L"http://tizen.org/feature/platform.native.api.version";
 152 static const wchar_t* _PLATFORM_WEB_API_VERSION = L"http://tizen.org/feature/platform.web.api.version";
 153 static const wchar_t* _BUILD_STRING = L"http://tizen.org/system/build.string";
 154
 155 static const wchar_t* _WAC_VERSION = L"WACVersion";
 156 static const wchar_t* _SUPPORTED = L"Supported";
 157 static const wchar_t* _UNSUPPORTED = L"Unsupported";
 158
 159 static bool firstRequest = false;
 160 static HashMap integerList(SingleObjectDeleter);
 161 static HashMap boolList(SingleObjectDeleter);
 162 static HashMap stringList(SingleObjectDeleter);
 163
 164 void
 165 PrepareCache(void)
 166 {
 167         if(firstRequest == false)
 168         {
 169                 integerList.Construct();
 170                 boolList.Construct();
 171                 stringList.Construct();
 172                 firstRequest = true;
 173         }
 174 }
 175
 176 String
 177 _SystemInfoImpl::ConvertToTizen(const String& key)
 178 {
 179         String code(key);
 180
 181         if(code == _DEVICE_ID)
 182         {
 183                 code = _DUID;
 184         }
 185         else if(code == _MODEL_NAME)
 186         {
 187                 code = _MODELNAME;
 188         }
 189         else if(code == _KEYBOARD_TYPE)
 190         {
 191                 code = _INPUT_KEYBOARD_LAYOUT;
 192         }
 193         else if(code == _SCREEN_BITS_PER_PIXEL)
 194         {
 195                 code = _SCREEN_BPP;
 196         }
 197         else if(code == _SCREENHEIGHT)
 198         {
 199                 code = _SCREEN_HEIGHT;
 200         }
 201         else if(code == _SCREENWIDTH)
 202         {
 203                 code = _SCREEN_WIDTH;
 204         }
 205         else if(code == _SCREENDPI)
 206         {
 207                 code = _SCREEN_DPI;
 208         }
 209         else if(code == _MAX_SYSTEM_SOUND_VOLUME)
 210         {
 211                 code = _SOUND_SYSTEM_VOLUME_MAX;
 212         }
 213         else if(code == _MAX_MEDIA_SOUND_VOLUME)
 214         {
 215                 code = _SOUND_MEDIA_VOLUME_MAX;
 216         }
 217         else if(code == _MAX_RINGTONE_SOUND_VOLUME)
 218         {
 219                 code = _SOUND_RINGTONE_VOLUME_MAX;
 220         }
 221         else if(code == _MAX_NOTIFICATION_SOUND_VOLUME)
 222         {
 223                 code = _SOUND_NOTIFICATION_VOLUME_MAX;
 224         }
 225         else if(code == _MULTIPOINT_TOUCH_COUNT)
 226         {
 227                 code = _MULTIPOINTTOUCH_POINTCOUNT;
 228         }
 229         else if(code == _BLUETOOTH_SUPPORTED)
 230         {
 231                 code = _BLUETOOTH;
 232         }
 233         else if(code == _GPS_SUPPORTED)
 234         {
 235                 code = _LOCATION_GPS;
 236         }
 237         else if(code == _WPS_SUPPORTED)
 238         {
 239                 code = _LOCATION_WPS;
 240         }
 241         else if(code == _WIFI_SUPPORTED)
 242         {
 243                 code = _WIFI;
 244         }
 245         else if(code == _WIFI_DIRECT_SUPPORTED)
 246         {
 247                 code = _WIFI_DIRECT;
 248         }
 249         else if(code == _FM_RADIO_SUPPORTED)
 250         {
 251                 code = _FMRADIO;
 252         }
 253         else if(code == _TV_OUT_SUPPORTED)
 254         {
 255                 code = _SCREEN_OUTPUT_RCA;
 256         }
 257         else if(code == _NFC_SUPPORTED)
 258         {
 259                 code = _NETWORK_NFC;
 260         }
 261         return code;
 262 }
 263
 264 result
 265 _SystemInfoImpl::GetSysInfo(const String& key, String& value)
 266 {
 267         result r = E_OBJ_NOT_FOUND;
 268         String tizenKey = ConvertToTizen(key);
 269
 270         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
 271
 272         if (firstRequest == false)
 273         {
 274                 PrepareCache();
 275         }
 276
 277         String* pValue = (String*)stringList.GetValue(tizenKey);
 278
 279         if(pValue != null)
 280         {
 281                 value = *pValue;
 282                 return E_SUCCESS;
 283         }
 284
 285         if (key == _NETWORK_TYPE) //Compatibility
 286         {
 287                 bool supported = false;
 288                 GetSysInfo(_TELEPHONY, supported);
 289                 if(supported == false)
 290                 {
 291                         value = _NETWORK_EMERGENCY;
 292                 }
 293
 294                 bool supportedGsm = false;
 295                 bool supportedGprs = false;
 296                 bool supportedEdge = false;
 297                 bool supportedUmts = false;
 298                 bool supportedHsdpa = false;
 299                 bool supportedHsupa = false;
 300                 bool supportedHspa = false;
 301                 bool supportedLte = false;
 302                 bool supportedCdma = false;
 303
 304                 GetSysInfo(_TELEPHONY_SERVICE_GSM, supportedGsm);
 305                 GetSysInfo(_TELEPHONY_SERVICE_GPRS, supportedGprs);
 306                 GetSysInfo(_TELEPHONY_SERVICE_EDGE, supportedEdge);
 307                 GetSysInfo(_TELEPHONY_SERVICE_UMTS, supportedUmts);
 308                 GetSysInfo(_TELEPHONY_SERVICE_HSDPA, supportedHsdpa);
 309                 GetSysInfo(_TELEPHONY_SERVICE_HSUPA, supportedHsupa);
 310                 GetSysInfo(_TELEPHONY_SERVICE_HSPA, supportedHspa);
 311                 GetSysInfo(_TELEPHONY_SERVICE_LTE, supportedLte);
 312                 GetSysInfo(_TELEPHONY_SERVICE_CDMA, supportedCdma);
 313
 314                 value.Clear();
 315                 if(supportedGsm == false && supportedGprs == false
 316                         && supportedEdge == false && supportedUmts == false
 317                         && supportedHsdpa == false && supportedHsupa == false
 318                         && supportedHspa == false && supportedLte == false
 319                         && supportedCdma == false)
 320                 {
 321                         value = _NETWORK_NO_SERVICE;
 322                 }
 323                 else if(supportedGsm == true)
 324                 {
 325                         value.Append(L"GSM");
 326                 }
 327                 else if(supportedGprs == true)
 328                 {
 329                         if(value.GetLength() > 0)
 330                                 value.Append(L" | ");
 331
 332                         value.Append(L"GPRS");
 333                 }
 334                 else if(supportedEdge == true)
 335                 {
 336                         if(value.GetLength() > 0)
 337                                 value.Append(L" | ");
 338
 339                         value.Append(L"EDGE");
 340                 }
 341                 else if(supportedUmts == true)
 342                 {
 343                         if(value.GetLength() > 0)
 344                                 value.Append(L" | ");
 345
 346                         value.Append(L"UMTS");
 347                 }
 348                 else if(supportedHsdpa == true)
 349                 {
 350                         if(value.GetLength() > 0)
 351                                 value.Append(L" | ");
 352
 353                         value.Append(L"HSDPA");
 354                 }
 355                 else if(supportedHsupa == true)
 356                 {
 357                         if(value.GetLength() > 0)
 358                                 value.Append(L" | ");
 359
 360                         value.Append(L"HSUPA");
 361                 }
 362                 else if(supportedHspa == true)
 363                 {
 364                         if(value.GetLength() > 0)
 365                                 value.Append(L" | ");
 366
 367                         value.Append(L"HSPA");
 368                 }
 369                 else if(supportedLte == true)
 370                 {
 371                         if(value.GetLength() > 0)
 372                                 value.Append(L" | ");
 373
 374                         value.Append(L"LTE");
 375                 }
 376                 else if(supportedCdma == true)
 377                 {
 378                         if(value.GetLength() > 0)
 379                                 value.Append(L" | ");
 380
 381                         value.Append(L"CDMA");
 382                 }
 383                 r = E_SUCCESS;
 384         }
 385         else if (key == _OPENGL_ES_VERSION)
 386         {
 387                 bool opengles_11 = false;
 388                 bool opengles_20 = false;
 389
 390                 GetSysInfo(_OPENGLES_VERSION_1_1, opengles_11);
 391                 GetSysInfo(_OPENGLES_VERSION_2_0, opengles_20);
 392
 393                 if(opengles_11 == true)
 394                 {
 395                         value.Append(L"1.1");
 396                 }
 397                 else if(opengles_20 == true)
 398                 {
 399                         if(value.GetLength() > 0)
 400                                 value.Append(L" | ");
 401
 402                         value.Append(L"2.0");
 403                 }
 404                 r = E_SUCCESS;
 405         }
 406         else if(key == _BLUETOOTH_SUPPORTED)
 407         {
 408                 bool supported = false;
 409                 GetSysInfo(_BLUETOOTH, supported);
 410                 if(supported == false)
 411                         value = _SUPPORTED;
 412                 else
 413                         value = _UNSUPPORTED;
 414                 r = E_SUCCESS;
 415         }
 416         else if (key == _GPS_SUPPORTED)
 417         {
 418                 bool supported = false;
 419                 GetSysInfo(_LOCATION_GPS, supported);
 420                 if(supported == false)
 421                         value = _SUPPORTED;
 422                 else
 423                         value = _UNSUPPORTED;
 424                 r = E_SUCCESS;
 425         }
 426         else if (key == _WIFI_SUPPORTED)
 427         {
 428                 bool supported = false;
 429                 GetSysInfo(_WIFI, supported);
 430                 if(supported == false)
 431                         value = _SUPPORTED;
 432                 else
 433                         value = _UNSUPPORTED;
 434                 r = E_SUCCESS;
 435         }
 436         else if (key == _WAC_VERSION)
 437         {
 438                 value.Clear();
 439                 r = E_SUCCESS;
 440         }
 441         else if (key == _PLATFORM_NATIVE_API_VERSION || key == _PLATFORM_WEB_API_VERSION || key == _PLATFORM_VERSION || key == _BUILD_STRING)
 442         {
 443                 r = E_OBJ_NOT_FOUND;
 444         }
 445         else if (tizenKey == _DUID)
 446         {
 447                 r = GetFromRegistry(tizenKey, value);
 448
 449                 if(r != E_SUCCESS)
 450                 {
 451                         ArrayList requestMessage;
 452                         ArrayList responseMessage;
 453
 454                         _CommunicationDispatcherClient* pCommunicationDispatcherClient = _CommunicationDispatcherClient::GetInstance();
 455
 456                         _IpcClient* pIpcClient = pCommunicationDispatcherClient->GetIpcClient();
 457                         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 458
 459                         requestMessage.Construct();
 460                         responseMessage.Construct();
 461
 462                         String serviceId(_SYSTEM_SERVICE_ID);
 463                         String commandId(L"osp.system.command.get.duid.internal");
 464
 465                         requestMessage.Add(serviceId);
 466                         requestMessage.Add(commandId);
 467
 468                         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 469                         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 470
 471                         r = pIpcClient->SendRequest(pMsg.get());
 472                         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "It is failed to send ipc message. [%s]", GetErrorMessage(r));
 473
 474                         String* pResult = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA);
 475                         String* pDuid = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA+1);
 476
 477                         SysTryReturn(NID_SYS, pResult != null, r = E_SYSTEM, r, "It is failed to receive result on IPC response message.");
 478                         SysTryReturn(NID_SYS, pDuid != null, r = E_SYSTEM, r, "It is failed to receive IMEI value on IPC response message.");
 479
 480                         SysTryReturn(NID_SYS, *pResult != _SYSTEM_RESULT_PRIVILEGED, r = E_PRIVILEGE_DENIED, r, "It is failed to get privilege.");
 481                         SysTryReturn(NID_SYS, *pResult == _SYSTEM_RESULT_OK, r = E_SYSTEM, r, "It is failed to get DUID value.");
 482
 483                         value = *pDuid;
 484
 485                         responseMessage.RemoveAll(true);
 486                 }
 487         }
 488         else
 489         {
 490                 r = GetFromRegistry(tizenKey, value);
 491
 492                 if(r != E_SUCCESS)
 493                 {
 494                         char* pStringValue = null;
 495                         String tKey;
 496                         tizenKey.SubString(7, tKey);
 497                         SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_OBJ_NOT_FOUND, "Required key should be longer than 0.");
 498
 499                         ClearLastResult();
 500                         unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 501                         r = GetLastResult();
 502                         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 503
 504                         int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 505                         SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", tizenKey.GetPointer());
 506
 507                         r = StringUtil::Utf8ToString(pStringValue, value);
 508                         free(pStringValue);
 509                         r = E_SUCCESS;
 510                 }
 511         }
 512         if( r == E_SUCCESS)
 513         {
 514                 stringList.Add(new String(tizenKey), new String(value));
 515         }
 516         return r;
 517 }
 518
 519 result
 520 _SystemInfoImpl::GetSysInfo(const String& key, int& value)
 521 {
 522         result r = E_SUCCESS;
 523         String tizenKey = ConvertToTizen(key);
 524
 525         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
 526
 527         if (firstRequest == false)
 528         {
 529                 PrepareCache();
 530         }
 531
 532         Integer* pValue = (Integer*)integerList.GetValue(tizenKey);
 533
 534         if(pValue != null)
 535         {
 536                 value = pValue->value;
 537                 return E_SUCCESS;
 538         }
 539
 540         if (key == _CAMERA_COUNT)
 541         {
 542                 bool supported = false;
 543                 int cameraCount = 0;
 544
 545                 GetSysInfo(_CAMERA_FRONT, supported);
 546                 if(supported == true)
 547                         cameraCount++;
 548
 549                 GetSysInfo(_CAMERA_BACK, supported);
 550                 if(supported == true)
 551                         cameraCount++;
 552
 553                 value = cameraCount;
 554         }
 555         else
 556         {
 557                 r = GetFromRegistry(tizenKey, value);
 558                 if(r != E_SUCCESS || tizenKey == _SCREEN_WIDTH || tizenKey == _SCREEN_HEIGHT || tizenKey == _SCREEN_DPI)
 559                 {
 560                         int ret = 0;
 561                         String tKey;
 562
 563                         tizenKey.SubString(7, tKey);
 564                         SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_OBJ_NOT_FOUND, "Required key should be longer than 0.");
 565
 566                         ClearLastResult();
 567                         unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 568                         r = GetLastResult();
 569                         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 570
 571                         ret = system_info_get_platform_int(systemKey.get(), &value);
 572                         SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", tizenKey.GetPointer());
 573                         r = E_SUCCESS;
 574                 }
 575         }
 576
 577         if(r == E_SUCCESS)
 578         {
 579                 integerList.Add(new String(tizenKey), new Integer(value));
 580         }
 581
 582         return r;
 583 }
 584
 585 result
 586 _SystemInfoImpl::GetSysInfo(const String& key, long long& value)
 587 {
 588         return E_OBJ_NOT_FOUND;
 589 }
 590
 591 result
 592 _SystemInfoImpl::GetSysInfo(const String& key, double& value)
 593 {
 594         return E_OBJ_NOT_FOUND;
 595 }
 596
 597 result
 598 _SystemInfoImpl::GetSysInfo(const String& key, bool& value)
 599 {
 600         result r = E_SUCCESS;
 601         String tizenKey = ConvertToTizen(key);
 602
 603         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
 604
 605         if (firstRequest == false)
 606         {
 607                 PrepareCache();
 608         }
 609
 610         Boolean* pValue = (Boolean*)boolList.GetValue(tizenKey);
 611
 612         if(pValue != null)
 613         {
 614                 value = pValue->value;
 615                 return E_SUCCESS;
 616         }
 617
 618         r = GetFromRegistry(tizenKey, value);
 619         if(r != E_SUCCESS)
 620         {
 621                 String tKey;
 622                 tizenKey.SubString(7, tKey);
 623                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_OBJ_NOT_FOUND, "Required key should be longer than 0.");
 624
 625                 ClearLastResult();
 626                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 627                 r = GetLastResult();
 628                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 629
 630                 bool supported = false;
 631                 int ret = system_info_get_platform_bool(systemKey.get(), &supported);
 632                 if(ret != SYSTEM_INFO_ERROR_NONE)
 633                 {
 634                         String screenKey(L"http://tizen.org/feature/screen.size");
 635                         String requiredKey;
 636                         tizenKey.SubString(0, screenKey.GetLength(), requiredKey);
 637
 638                         if(requiredKey == screenKey)
 639                         {
 640                                 value = false;
 641                         }
 642                 }
 643
 644                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", tizenKey.GetPointer());
 645                 value = supported;
 646                 r = E_SUCCESS;
 647         }
 648
 649         if(r == E_SUCCESS)
 650         {
 651                 boolList.Add(new String(tizenKey), new Boolean(value));
 652         }
 653
 654         return r;
 655 }
 656
 657 result
 658 _SystemInfoImpl::GetSysInfo(const String& key, UuId& value)
 659 {
 660         return E_OBJ_NOT_FOUND;
 661 }
 662
 663 Collection::IList*
 664 _SystemInfoImpl::GetSysInfoValuesN(const String& key, SystemInfoValueType type)
 665 {
 666         SetLastResult(E_OBJ_NOT_FOUND);
 667         return null;
 668 }
 669
 670 result
 671 _SystemInfoImpl::GetPlatformVersion(String& platformVersion)
 672 {
 673         result r = E_SUCCESS;
 674         String tizenKey(_PLATFORM_VERSION);
 675
 676         r = GetFromRegistry(tizenKey, platformVersion);
 677
 678         if(r != E_SUCCESS)
 679         {
 680                 char* pStringValue = null;
 681                 String tKey;
 682                 tizenKey.SubString(7, tKey);
 683                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 684
 685                 ClearLastResult();
 686                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 687                 r = GetLastResult();
 688                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 689
 690                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 691                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", tizenKey.GetPointer());
 692
 693                 r = StringUtil::Utf8ToString(pStringValue, platformVersion);
 694                 free(pStringValue);
 695                 r = E_SUCCESS;
 696         }
 697         return r;
 698 }
 699
 700 result
 701 _SystemInfoImpl::GetBuildInfo(String& buildInfo)
 702 {
 703         result r = E_SUCCESS;
 704         String tizenKey(_BUILD_STRING);
 705
 706         r = GetFromRegistry(tizenKey, buildInfo);
 707
 708         if(r != E_SUCCESS)
 709         {
 710                 char* pStringValue = null;
 711                 String tKey;
 712                 tizenKey.SubString(7, tKey);
 713                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 714
 715                 ClearLastResult();
 716                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 717                 r = GetLastResult();
 718                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 719
 720                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 721                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", tizenKey.GetPointer());
 722
 723                 r = StringUtil::Utf8ToString(pStringValue, buildInfo);
 724                 free(pStringValue);
 725                 r = E_SUCCESS;
 726         }
 727         return r;
 728 }
 729
 730 result
 731 _SystemInfoImpl::GetNativeApiVersion(String& nativeApiVersion)
 732 {
 733         result r = E_SUCCESS;
 734         String tizenKey(_PLATFORM_NATIVE_API_VERSION);
 735
 736         r = GetFromRegistry(tizenKey, nativeApiVersion);
 737
 738         if(r != E_SUCCESS)
 739         {
 740                 char* pStringValue = null;
 741                 String tKey;
 742                 tizenKey.SubString(7, tKey);
 743                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 744
 745                 ClearLastResult();
 746                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 747                 r = GetLastResult();
 748                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 749
 750                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 751                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", tizenKey.GetPointer());
 752
 753                 r = StringUtil::Utf8ToString(pStringValue, nativeApiVersion);
 754                 free(pStringValue);
 755                 r = E_SUCCESS;
 756         }
 757         return r;
 758 }
 759
 760 result
 761 _SystemInfoImpl::GetWebApiVersion(String& webApiVersion)
 762 {
 763         result r = E_SUCCESS;
 764         String tizenKey(_PLATFORM_WEB_API_VERSION);
 765
 766         r = GetFromRegistry(tizenKey, webApiVersion);
 767
 768         if(r != E_SUCCESS)
 769         {
 770                 char* pStringValue = null;
 771                 String tKey;
 772                 tizenKey.SubString(7, tKey);
 773                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 774
 775                 ClearLastResult();
 776                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 777                 r = GetLastResult();
 778                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 779
 780                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 781                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", tizenKey.GetPointer());
 782
 783                 r = StringUtil::Utf8ToString(pStringValue, webApiVersion);
 784                 free(pStringValue);
 785                 r = E_SUCCESS;
 786         }
 787         return r;
 788 }
 789
 790 result
 791 _SystemInfoImpl::GetImei(String& imei)
 792 {
 793         result r = E_SUCCESS;
 794
 795         int ret = 0;
 796         TapiHandle* handle = null;
 797         int time_count = 0;
 798         int status = 0;
 799
 800         handle = tel_init(null);
 801         SysTryReturnResult(NID_SYS, handle != null, E_SYSTEM, "It is failed to get handle of telephony.");
 802         while(time_count < 30) //Wait 30 second.
 803         {
 804                 ret = tel_check_modem_power_status(handle, &status);
 805                 SysLog(NID_SYS, "Modem check result is %d, status is %d.", handle, status);
 806                 if(ret != TAPI_API_SUCCESS)
 807                 {
 808                         SysLogException(NID_SYS, E_SYSTEM, "It is failed to get Modem status.");
 809                         tel_deinit(handle);
 810                         return E_SYSTEM;
 811                 }
 812
 813                 if(status == 0)
 814                 {
 815                         break;
 816                 }
 817
 818                 usleep(1000000);
 819                 time_count++;
 820         }
 821         tel_deinit(handle);
 822
 823         ArrayList requestMessage;
 824         ArrayList responseMessage;
 825
 826         _CommunicationDispatcherClient* pCommunicationDispatcherClient = _CommunicationDispatcherClient::GetInstance();
 827
 828         _IpcClient* pIpcClient = pCommunicationDispatcherClient->GetIpcClient();
 829         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 830
 831         requestMessage.Construct();
 832         responseMessage.Construct();
 833
 834         String serviceId(_SYSTEM_SERVICE_ID);
 835         String commandId(L"osp.system.command.get.imei.internal");
 836
 837         requestMessage.Add(serviceId);
 838         requestMessage.Add(commandId);
 839
 840         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 841         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 842
 843         r = pIpcClient->SendRequest(pMsg.get());
 844         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "It is failed to send ipc message. [%s]", GetErrorMessage(r));
 845
 846         String* pResult = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA);
 847         String* pImei = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA+1);
 848
 849         SysTryReturn(NID_SYS, pResult != null, r = E_SYSTEM, r, "It is failed to receive result on IPC response message.");
 850         SysTryReturn(NID_SYS, pImei != null, r = E_SYSTEM, r, "It is failed to receive IMEI value on IPC response message.");
 851
 852         SysTryReturn(NID_SYS, *pResult != _SYSTEM_RESULT_PRIVILEGED, r = E_PRIVILEGE_DENIED, r, "It is failed to get privilege.");
 853         SysTryReturn(NID_SYS, *pResult == _SYSTEM_RESULT_OK, r = E_SYSTEM, r, "It is failed to get IMEI value.");
 854
 855         imei = *pImei;
 856         responseMessage.RemoveAll(true);
 857
 858         return r;
 859 }
 860
 861 result
 862 _SystemInfoImpl::GetFromRegistry(const String& key, String& value)
 863 {
 864         result r = E_SUCCESS;
 865         _RegistryImpl _reg;
 866         String valStr;
 867
 868         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 869         SysTryReturnResult(NID_SYS, r == E_SUCCESS , r, " RegistryImpl construct is failed");
 870
 871         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 872         SysTryReturnResult(NID_SYS, r == E_SUCCESS , r, " Registry GetValue is failed, %ls", key.GetPointer());
 873
 874         if(valStr == L"true" || valStr == L"false")
 875         {
 876                 return E_OBJ_NOT_FOUND;
 877         }
 878         else
 879         {
 880                 value = valStr;
 881         }
 882
 883         return E_SUCCESS;
 884 }
 885
 886 result
 887 _SystemInfoImpl::GetFromRegistry(const String& key, int& value)
 888 {
 889         result r = E_SUCCESS;
 890         _RegistryImpl _reg;
 891         String valStr;
 892
 893         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 894         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " RegistryImpl construct is failed");
 895
 896         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 897         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " Registry GetValue is failed, %ls", key.GetPointer());
 898         r = Integer::Parse(valStr, value);
 899         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_OBJ_NOT_FOUND, " Integer::Parse() is failed");
 900         return E_SUCCESS;
 901 }
 902
 903 result
 904 _SystemInfoImpl::GetFromRegistry(const String& key, bool& value)
 905 {
 906         result r = E_SUCCESS;
 907         _RegistryImpl _reg;
 908         String valStr;
 909
 910         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 911         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " RegistryImpl construct is failed");
 912
 913         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 914         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " Registry GetValue is failed, [%ls]", key.GetPointer());
 915         if(valStr == L"true")
 916         {
 917                 value = true;
 918         }
 919         else if(valStr == L"false")
 920         {
 921                 value = false;
 922         }
 923         else
 924         {
 925                 return E_OBJ_NOT_FOUND;
 926         }
 927         return E_SUCCESS;
 928 }
 929
 930 _SystemInfoImpl*
 931 _SystemInfoImpl::GetInstance(SystemInfo& systeminfo)
 932 {
 933         return systeminfo.__pSystemInfoImpl;
 934 }
 935 const _SystemInfoImpl*
 936 _SystemInfoImpl::GetInstance(const SystemInfo& systeminfo)
 937 {
 938         return systeminfo.__pSystemInfoImpl;
 939 }
 940 } } // Tizen::System