dc94f8add86942b907e87bc656e2ec25fbf63cf9
[platform/framework/native/appfw.git] / 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