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