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