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