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 || value == L"ERROR")
 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                         if (ret != SYSTEM_INFO_ERROR_NONE)
 506                         {
 507                                 ret = system_info_get_custom_string(systemKey.get(), &pStringValue);
 508                                 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());
 509                         }
 510                         r = StringUtil::Utf8ToString(pStringValue, value);
 511                         free(pStringValue);
 512                         r = E_SUCCESS;
 513                 }
 514         }
 515         if( r == E_SUCCESS)
 516         {
 517                 stringList.Add(new String(tizenKey), new String(value));
 518         }
 519         return r;
 520 }
 521
 522 result
 523 _SystemInfoImpl::GetSysInfo(const String& key, int& value)
 524 {
 525         result r = E_SUCCESS;
 526         String tizenKey = ConvertToTizen(key);
 527
 528         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
 529
 530         if (firstRequest == false)
 531         {
 532                 PrepareCache();
 533         }
 534
 535         Integer* pValue = (Integer*)integerList.GetValue(tizenKey);
 536
 537         if(pValue != null)
 538         {
 539                 value = pValue->value;
 540                 return E_SUCCESS;
 541         }
 542
 543         if (key == _CAMERA_COUNT)
 544         {
 545                 bool supported = false;
 546                 int cameraCount = 0;
 547
 548                 GetSysInfo(_CAMERA_FRONT, supported);
 549                 if(supported == true)
 550                         cameraCount++;
 551
 552                 GetSysInfo(_CAMERA_BACK, supported);
 553                 if(supported == true)
 554                         cameraCount++;
 555
 556                 value = cameraCount;
 557         }
 558         else
 559         {
 560                 r = GetFromRegistry(tizenKey, value);
 561                 if(r != E_SUCCESS || tizenKey == _SCREEN_WIDTH || tizenKey == _SCREEN_HEIGHT || tizenKey == _SCREEN_DPI)
 562                 {
 563                         int ret = 0;
 564                         String tKey;
 565
 566                         tizenKey.SubString(7, tKey);
 567                         SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_OBJ_NOT_FOUND, "Required key should be longer than 0.");
 568
 569                         ClearLastResult();
 570                         unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 571                         r = GetLastResult();
 572                         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 573
 574                         ret = system_info_get_platform_int(systemKey.get(), &value);
 575                         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());
 576                         r = E_SUCCESS;
 577                 }
 578         }
 579
 580         if(r == E_SUCCESS)
 581         {
 582                 integerList.Add(new String(tizenKey), new Integer(value));
 583         }
 584
 585         return r;
 586 }
 587
 588 result
 589 _SystemInfoImpl::GetSysInfo(const String& key, long long& value)
 590 {
 591         return E_OBJ_NOT_FOUND;
 592 }
 593
 594 result
 595 _SystemInfoImpl::GetSysInfo(const String& key, double& value)
 596 {
 597         return E_OBJ_NOT_FOUND;
 598 }
 599
 600 result
 601 _SystemInfoImpl::GetSysInfo(const String& key, bool& value)
 602 {
 603         result r = E_SUCCESS;
 604         String tizenKey = ConvertToTizen(key);
 605
 606         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
 607
 608         if (firstRequest == false)
 609         {
 610                 PrepareCache();
 611         }
 612
 613         Boolean* pValue = (Boolean*)boolList.GetValue(tizenKey);
 614
 615         if(pValue != null)
 616         {
 617                 value = pValue->value;
 618                 return E_SUCCESS;
 619         }
 620
 621         r = GetFromRegistry(tizenKey, value);
 622         if(r != E_SUCCESS)
 623         {
 624                 String tKey;
 625                 tizenKey.SubString(7, tKey);
 626                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_OBJ_NOT_FOUND, "Required key should be longer than 0.");
 627
 628                 ClearLastResult();
 629                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 630                 r = GetLastResult();
 631                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 632
 633                 bool supported = false;
 634                 int ret = system_info_get_platform_bool(systemKey.get(), &supported);
 635                 if(ret != SYSTEM_INFO_ERROR_NONE)
 636                 {
 637                         String screenKey(L"http://tizen.org/feature/screen.size");
 638                         String requiredKey;
 639                         tizenKey.SubString(0, screenKey.GetLength(), requiredKey);
 640
 641                         if(requiredKey == screenKey)
 642                         {
 643                                 value = false;
 644                         }
 645                 }
 646
 647                 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());
 648                 value = supported;
 649                 r = E_SUCCESS;
 650         }
 651
 652         if(r == E_SUCCESS)
 653         {
 654                 boolList.Add(new String(tizenKey), new Boolean(value));
 655         }
 656
 657         return r;
 658 }
 659
 660 result
 661 _SystemInfoImpl::GetSysInfo(const String& key, UuId& value)
 662 {
 663         return E_OBJ_NOT_FOUND;
 664 }
 665
 666 Collection::IList*
 667 _SystemInfoImpl::GetSysInfoValuesN(const String& key, SystemInfoValueType type)
 668 {
 669         SetLastResult(E_OBJ_NOT_FOUND);
 670         return null;
 671 }
 672
 673 result
 674 _SystemInfoImpl::GetPlatformVersion(String& platformVersion)
 675 {
 676         result r = E_SUCCESS;
 677         String tizenKey(_PLATFORM_VERSION);
 678
 679         r = GetFromRegistry(tizenKey, platformVersion);
 680
 681         if(r != E_SUCCESS)
 682         {
 683                 char* pStringValue = null;
 684                 String tKey;
 685                 tizenKey.SubString(7, tKey);
 686                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 687
 688                 ClearLastResult();
 689                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 690                 r = GetLastResult();
 691                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 692
 693                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 694                 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());
 695
 696                 r = StringUtil::Utf8ToString(pStringValue, platformVersion);
 697                 free(pStringValue);
 698                 r = E_SUCCESS;
 699         }
 700         return r;
 701 }
 702
 703 result
 704 _SystemInfoImpl::GetBuildInfo(String& buildInfo)
 705 {
 706         result r = E_SUCCESS;
 707         String tizenKey(_BUILD_STRING);
 708
 709         r = GetFromRegistry(tizenKey, buildInfo);
 710
 711         if(r != E_SUCCESS)
 712         {
 713                 char* pStringValue = null;
 714                 String tKey;
 715                 tizenKey.SubString(7, tKey);
 716                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 717
 718                 ClearLastResult();
 719                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 720                 r = GetLastResult();
 721                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 722
 723                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 724                 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());
 725
 726                 r = StringUtil::Utf8ToString(pStringValue, buildInfo);
 727                 free(pStringValue);
 728                 r = E_SUCCESS;
 729         }
 730         return r;
 731 }
 732
 733 result
 734 _SystemInfoImpl::GetNativeApiVersion(String& nativeApiVersion)
 735 {
 736         result r = E_SUCCESS;
 737         String tizenKey(_PLATFORM_NATIVE_API_VERSION);
 738
 739         r = GetFromRegistry(tizenKey, nativeApiVersion);
 740
 741         if(r != E_SUCCESS)
 742         {
 743                 char* pStringValue = null;
 744                 String tKey;
 745                 tizenKey.SubString(7, tKey);
 746                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 747
 748                 ClearLastResult();
 749                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 750                 r = GetLastResult();
 751                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 752
 753                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 754                 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());
 755
 756                 r = StringUtil::Utf8ToString(pStringValue, nativeApiVersion);
 757                 free(pStringValue);
 758                 r = E_SUCCESS;
 759         }
 760         return r;
 761 }
 762
 763 result
 764 _SystemInfoImpl::GetWebApiVersion(String& webApiVersion)
 765 {
 766         result r = E_SUCCESS;
 767         String tizenKey(_PLATFORM_WEB_API_VERSION);
 768
 769         r = GetFromRegistry(tizenKey, webApiVersion);
 770
 771         if(r != E_SUCCESS)
 772         {
 773                 char* pStringValue = null;
 774                 String tKey;
 775                 tizenKey.SubString(7, tKey);
 776                 SysTryReturnResult(NID_SYS, tKey.GetLength() > 0, E_SYSTEM, "Required key should be longer than 0.");
 777
 778                 ClearLastResult();
 779                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tKey));
 780                 r = GetLastResult();
 781                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
 782
 783                 int ret = system_info_get_platform_string(systemKey.get(), &pStringValue);
 784                 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());
 785
 786                 r = StringUtil::Utf8ToString(pStringValue, webApiVersion);
 787                 free(pStringValue);
 788                 r = E_SUCCESS;
 789         }
 790         return r;
 791 }
 792
 793 result
 794 _SystemInfoImpl::GetImei(String& imei)
 795 {
 796         result r = E_SUCCESS;
 797
 798         int ret = 0;
 799         TapiHandle* handle = null;
 800         int time_count = 0;
 801         int status = 0;
 802
 803         handle = tel_init(null);
 804         SysTryReturnResult(NID_SYS, handle != null, E_SYSTEM, "It is failed to get handle of telephony.");
 805         while(time_count < 30) //Wait 30 second.
 806         {
 807                 ret = tel_check_modem_power_status(handle, &status);
 808                 SysLog(NID_SYS, "Modem check result is %d, status is %d.", handle, status);
 809                 if(ret != TAPI_API_SUCCESS)
 810                 {
 811                         SysLogException(NID_SYS, E_SYSTEM, "It is failed to get Modem status.");
 812                         tel_deinit(handle);
 813                         return E_SYSTEM;
 814                 }
 815
 816                 if(status == 0)
 817                 {
 818                         break;
 819                 }
 820
 821                 usleep(1000000);
 822                 time_count++;
 823         }
 824         tel_deinit(handle);
 825
 826         ArrayList requestMessage;
 827         ArrayList responseMessage;
 828
 829         _CommunicationDispatcherClient* pCommunicationDispatcherClient = _CommunicationDispatcherClient::GetInstance();
 830
 831         _IpcClient* pIpcClient = pCommunicationDispatcherClient->GetIpcClient();
 832         SysTryReturn(NID_SYS, pIpcClient != null, E_OUT_OF_MEMORY, r, "It is failed to create IPC instance.");
 833
 834         requestMessage.Construct();
 835         responseMessage.Construct();
 836
 837         String serviceId(_SYSTEM_SERVICE_ID);
 838         String commandId(L"osp.system.command.get.imei.internal");
 839
 840         requestMessage.Add(serviceId);
 841         requestMessage.Add(commandId);
 842
 843         unique_ptr<IoService_Request> pMsg(new (std::nothrow) IoService_Request(requestMessage, &responseMessage));
 844         SysTryReturnResult(NID_SYS, pMsg != null, E_OUT_OF_MEMORY, "It is failed to create Ipc message");
 845
 846         r = pIpcClient->SendRequest(pMsg.get());
 847         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "It is failed to send ipc message. [%s]", GetErrorMessage(r));
 848
 849         String* pResult = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA);
 850         String* pImei = (String*)responseMessage.GetAt(_SYSTEM_RESPONSE_DATA+1);
 851
 852         SysTryReturn(NID_SYS, pResult != null, r = E_SYSTEM, r, "It is failed to receive result on IPC response message.");
 853         SysTryReturn(NID_SYS, pImei != null, r = E_SYSTEM, r, "It is failed to receive IMEI value on IPC response message.");
 854
 855         SysTryReturn(NID_SYS, *pResult != _SYSTEM_RESULT_PRIVILEGED, r = E_PRIVILEGE_DENIED, r, "It is failed to get privilege.");
 856         SysTryReturn(NID_SYS, *pResult == _SYSTEM_RESULT_OK, r = E_SYSTEM, r, "It is failed to get IMEI value.");
 857
 858         imei = *pImei;
 859         responseMessage.RemoveAll(true);
 860
 861         return r;
 862 }
 863
 864 result
 865 _SystemInfoImpl::GetFromRegistry(const String& key, String& value)
 866 {
 867         result r = E_SUCCESS;
 868         _RegistryImpl _reg;
 869         String valStr;
 870
 871         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 872         SysTryReturnResult(NID_SYS, r == E_SUCCESS , r, " RegistryImpl construct is failed");
 873
 874         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 875         SysTryReturnResult(NID_SYS, r == E_SUCCESS , r, " Registry GetValue is failed, %ls", key.GetPointer());
 876
 877         if(valStr == L"true" || valStr == L"false")
 878         {
 879                 return E_OBJ_NOT_FOUND;
 880         }
 881         else
 882         {
 883                 value = valStr;
 884         }
 885
 886         return E_SUCCESS;
 887 }
 888
 889 result
 890 _SystemInfoImpl::GetFromRegistry(const String& key, int& value)
 891 {
 892         result r = E_SUCCESS;
 893         _RegistryImpl _reg;
 894         String valStr;
 895
 896         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 897         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " RegistryImpl construct is failed");
 898
 899         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 900         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " Registry GetValue is failed, %ls", key.GetPointer());
 901         r = Integer::Parse(valStr, value);
 902         SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_OBJ_NOT_FOUND, " Integer::Parse() is failed");
 903         return E_SUCCESS;
 904 }
 905
 906 result
 907 _SystemInfoImpl::GetFromRegistry(const String& key, bool& value)
 908 {
 909         result r = E_SUCCESS;
 910         _RegistryImpl _reg;
 911         String valStr;
 912
 913         r = _reg.Construct(_REGISTRY_PATH, REG_OPEN_READ_ONLY, null);
 914         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " RegistryImpl construct is failed");
 915
 916         r = _reg.GetValue(_SYSTEM_INFO_SESSION, key, valStr);
 917         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, " Registry GetValue is failed, [%ls]", key.GetPointer());
 918         if(valStr == L"true")
 919         {
 920                 value = true;
 921         }
 922         else if(valStr == L"false")
 923         {
 924                 value = false;
 925         }
 926         else
 927         {
 928                 return E_OBJ_NOT_FOUND;
 929         }
 930         return E_SUCCESS;
 931 }
 932
 933 _SystemInfoImpl*
 934 _SystemInfoImpl::GetInstance(SystemInfo& systeminfo)
 935 {
 936         return systeminfo.__pSystemInfoImpl;
 937 }
 938 const _SystemInfoImpl*
 939 _SystemInfoImpl::GetInstance(const SystemInfo& systeminfo)
 940 {
 941         return systeminfo.__pSystemInfoImpl;
 942 }
 943 } } // Tizen::System