src/system/FSys_SystemInfoService.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_SystemInfoService.cpp
  19  * @brief               This is the implementation file for _SystemInfoService class.
  20  */
  21
  22 #include <unique_ptr.h>
  23 #include <sys/stat.h>
  24 #include <sys/utsname.h>
  25 #include <stdlib.h>
  26 #include <dlfcn.h>
  27 #include <media/sound_manager.h>
  28 #include <system_info.h>
  29
  30 #include <FBaseColIMapEnumerator.h>
  31 #include <FBaseInteger.h>
  32 #include <FBaseSysLog.h>
  33 #include <FBaseUtilStringUtil.h>
  34 #include <FBaseUtilStringTokenizer.h>
  35 #include <FIoFile.h>
  36 #include <FIoRegistry.h>
  37 #include <FIoDirectory.h>
  38 #include <FSysIDeviceEventListener.h>
  39 #include <FSysIScreenEventListener.h>
  40 #include <FSysIChargingEventListener.h>
  41 #include <FSysIBatteryEventListener.h>
  42
  43 #include <FAppPkg_PackageManagerImpl.h>
  44 #include <FBase_NativeError.h>
  45 #include <FBase_StringConverter.h>
  46 #include <FIo_RegistryImpl.h>
  47 #include <FSys_DeviceId.h>
  48 #include <FSys_SystemInfoService.h>
  49
  50 using namespace std;
  51 using namespace Tizen::App;
  52 using namespace Tizen::App::Package;
  53 using namespace Tizen::Base;
  54 using namespace Tizen::Base::Collection;
  55 using namespace Tizen::Base::Utility;
  56 using namespace Tizen::Io;
  57
  58 namespace Tizen { namespace System
  59 {
  60 //Camera
  61 static const wchar_t* _CAMERA = L"http://tizen.org/feature/camera";
  62 static const wchar_t* _CAMERA_BACK = L"http://tizen.org/feature/camera.back";
  63 static const wchar_t* _CAMERA_BACK_FLASH = L"http://tizen.org/feature/camera.back.flash";
  64 static const wchar_t* _CAMERA_FRONT = L"http://tizen.org/feature/camera.front";
  65 static const wchar_t* _CAMERA_FRONT_FLASH = L"http://tizen.org/feature/camera.front.flash";
  66 //Database
  67 static const wchar_t* _DATABASE_ENCRYPTION = L"http://tizen.org/feature/database.encryption";
  68 //FM Radio
  69 static const wchar_t* _FMRADIO = L"http://tizen.org/feature/fmradio";
  70 //Graphic
  71 static const wchar_t* _GRAPHIC_ACCELERATION = L"http://tizen.org/feature/graphics.acceleration";
  72 //Input
  73 static const wchar_t* _INPUT_KEYBOARD = L"http://tizen.org/feature/input.keyboard";
  74 static const wchar_t* _INPUT_KEYBOARD_LAYOUT = L"http://tizen.org/feature/input.keyboard.layout";
  75 //Location
  76 static const wchar_t* _LOCATION = L"http://tizen.org/feature/location";
  77 static const wchar_t* _LOCATION_GPS = L"http://tizen.org/feature/location.gps";
  78 static const wchar_t* _LOCATION_WPS = L"http://tizen.org/feature/location.wps";
  79 //Microphone
  80 static const wchar_t* _MICROPHONE = L"http://tizen.org/feature/microphone";
  81 //Multi point
  82 static const wchar_t* _MULTIPOINTTOUCH_PINCHZOOM = L"http://tizen.org/feature/multi_point_touch.pinch_zoom";
  83 static const wchar_t* _MULTIPOINTTOUCH_POINTCOUNT = L"http://tizen.org/feature/multi_point_touch.point_count";
  84 //Network bluetooth
  85 static const wchar_t* _NETWORK_BLUETOOTH = L"http://tizen.org/feature/network.bluetooth";
  86 //Network NFC
  87 static const wchar_t* _NETWORK_NFC = L"http://tizen.org/feature/network.nfc";
  88 static const wchar_t* _NETWORK_NFC_RESERVED_PUSH = L"http://tizen.org/feature/network.nfc.reserved_push";
  89 //Network push
  90 static const wchar_t* _NETWORK_PUSH = L"http://tizen.org/feature/network.push";
  91 static const wchar_t* _NETWORK_SECURE_ELEMENT = L"http://tizen.org/feature/network.secure_element";
  92 //Network telephony
  93 static const wchar_t* _NETWORK_TELEPHONY = L"http://tizen.org/feature/network.telephony";
  94 static const wchar_t* _NETWORK_TELEPHONY_MMS = L"http://tizen.org/feature/network.telephony.mms";
  95 static const wchar_t* _NETWORK_TELEPHONY_SMS = L"http://tizen.org/feature/network.telephony.sms";
  96 static const wchar_t* _NETWORK_TELEPHONY_SMS_CBS = L"http://tizen.org/feature/network.telephony.sms.cbs";
  97 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_CDMA = L"http://tizen.org/feature/network.telephony.service.cdma";
  98 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_EDGE = L"http://tizen.org/feature/network.telephony.service.edge";
  99 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_GPRS = L"http://tizen.org/feature/network.telephony.service.gprs";
 100 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_GSM = L"http://tizen.org/feature/network.telephony.service.gsm";
 101 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_HSDPA = L"http://tizen.org/feature/network.telephony.service.hsdpa";
 102 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_HSPA = L"http://tizen.org/feature/network.telephony.service.hspa";
 103 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_HSUPA = L"http://tizen.org/feature/network.telephony.service.hsupa";
 104 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_LTE = L"http://tizen.org/feature/network.telephony.service.lte";
 105 static const wchar_t* _NETWORK_TELEPHONY_SERVICE_UMTS = L"http://tizen.org/feature/network.telephony.service.umts";
 106 //Network WIFI
 107 static const wchar_t* _NETWORK_WIFI = L"http://tizen.org/feature/network.wifi";
 108 static const wchar_t* _NETWORK_WIFI_DIRECT = L"http://tizen.org/feature/network.wifi.direct";
 109 //Opengles
 110 static const wchar_t* _OPENGLES = L"http://tizen.org/feature/opengles";
 111 static const wchar_t* _OPENGLES_TEXTUREFORMAT_3DC = L"http://tizen.org/feature/opengles.texture_format.3dc";
 112 static const wchar_t* _OPENGLES_TEXTUREFORMAT_ATC = L"http://tizen.org/feature/opengles.texture_format.atc";
 113 static const wchar_t* _OPENGLES_TEXTUREFORMAT_ETC = L"http://tizen.org/feature/opengles.texture_format.etc";
 114 static const wchar_t* _OPENGLES_TEXTUREFORMAT_PTC = L"http://tizen.org/feature/opengles.texture_format.ptc";
 115 static const wchar_t* _OPENGLES_TEXTUREFORMAT_PVRTC = L"http://tizen.org/feature/opengles.texture_format.pvrtc";
 116 static const wchar_t* _OPENGLES_TEXTUREFORMAT_UTC = L"http://tizen.org/feature/opengles.texture_format.utc";
 117 static const wchar_t* _OPENGLES_VERSION_1_1 = L"http://tizen.org/feature/opengles.version.1_1";
 118 static const wchar_t* _OPENGLES_VERSION_2_0 = L"http://tizen.org/feature/opengles.version.2_0";
 119 //Platform core CPU
 120 static const wchar_t* _PLATFORM_CORE_CPU_ARCH_ARMV6 = L"http://tizen.org/feature/platform.core.cpu.arch.armv6";
 121 static const wchar_t* _PLATFORM_CORE_CPU_ARCH_ARMV7 = L"http://tizen.org/feature/platform.core.cpu.arch.armv7";
 122 static const wchar_t* _PLATFORM_CORE_CPU_ARCH_X86 = L"http://tizen.org/feature/platform.core.cpu.arch.x86";
 123 //Platform core FPU
 124 static const wchar_t* _PLATFORM_CORE_FPU_ARCH_SSE2 = L"http://tizen.org/feature/platform.core.fpu.arch.sse2";
 125 static const wchar_t* _PLATFORM_CORE_FPU_ARCH_SSE3 = L"http://tizen.org/feature/platform.core.fpu.arch.sse3";
 126 static const wchar_t* _PLATFORM_CORE_FPU_ARCH_SSSE3 = L"http://tizen.org/feature/platform.core.fpu.arch.ssse3";
 127 static const wchar_t* _PLATFORM_CORE_FPU_ARCH_VFPV2 = L"http://tizen.org/feature/platform.core.fpu.arch.vfpv2";
 128 static const wchar_t* _PLATFORM_CORE_FPU_ARCH_VFPV3 = L"http://tizen.org/feature/platform.core.fpu.arch.vfpv3";
 129 //Platform Version
 130 static const wchar_t* _PLATFORM_NATIVE_API_VERSION = L"http://tizen.org/feature/platform.native.api.version";
 131 static const wchar_t* _PLATFORM_NATIVE_OSP_COMPATIBLE = L"http://tizen.org/feature/platform.native.osp_compatible";
 132 static const wchar_t* _PLATFORM_VERSION = L"http://tizen.org/feature/platform.version";
 133 static const wchar_t* _PLATFORM_WEB_API_VERSION = L"http://tizen.org/feature/platform.web.api.version";
 134 //Screen
 135 static const wchar_t* _SCREEN_AUTO_ROTATION = L"http://tizen.org/feature/screen.auto_rotation";
 136 static const wchar_t* _SCREEN_BPP = L"http://tizen.org/feature/screen.bpp";
 137 static const wchar_t* _SCREEN_COORDINATE_SYSTEM_SIZE_LARGE = L"http://tizen.org/feature/screen.coordinate_system.size.large";
 138 static const wchar_t* _SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL = L"http://tizen.org/feature/screen.coordinate_system.size.normal";
 139 static const wchar_t* _SCREEN_DESKTOPMODE = L"http://tizen.org/feature/screen.desktop_mode";
 140 static const wchar_t* _SCREEN_DPI = L"http://tizen.org/feature/screen.dpi";
 141 static const wchar_t* _SCREEN_HEIGHT = L"http://tizen.org/feature/screen.height";
 142 static const wchar_t* _SCREEN_SIZE_LARGE = L"http://tizen.org/feature/screen.size.large";
 143 static const wchar_t* _SCREEN_SIZE_NORMAL = L"http://tizen.org/feature/screen.size.normal";
 144 static const wchar_t* _SCREEN_SIZE_NORMAL_240_400 = L"http://tizen.org/feature/screen.size.normal.240.400";
 145 static const wchar_t* _SCREEN_SIZE_NORMAL_320_480 = L"http://tizen.org/feature/screen.size.normal.320.480";
 146 static const wchar_t* _SCREEN_SIZE_NORMAL_480_800 = L"http://tizen.org/feature/screen.size.normal.480.800";
 147 static const wchar_t* _SCREEN_SIZE_NORMAL_540_960 = L"http://tizen.org/feature/screen.size.normal.540.960";
 148 static const wchar_t* _SCREEN_SIZE_NORMAL_600_1024 = L"http://tizen.org/feature/screen.size.normal.600.1024";
 149 static const wchar_t* _SCREEN_SIZE_NORMAL_720_1280 = L"http://tizen.org/feature/screen.size.normal.720.1280";
 150 static const wchar_t* _SCREEN_SIZE_NORMAL_1080_1920 = L"http://tizen.org/feature/screen.size.normal.1080.1920";
 151 static const wchar_t* _SCREEN_WIDTH = L"http://tizen.org/feature/screen.width";
 152 //Screen HDMI RCA
 153 static const wchar_t* _SCREEN_OUTPUT_HDMI = L"http://tizen.org/feature/screen.output.hdmi";
 154 static const wchar_t* _SCREEN_OUTPUT_RCA = L"http://tizen.org/feature/screen.output.rca";
 155 //Shell
 156 static const wchar_t* _SHELL_APPWIDGET = L"http://tizen.org/feature/shell.appwidget";
 157 //Sensor
 158 static const wchar_t* _SENSOR_ACCELEROMETER = L"http://tizen.org/feature/sensor.accelerometer";
 159 static const wchar_t* _SENSOR_ACCELEROMETER_WAKEUP = L"http://tizen.org/feature/sensor.accelerometer.wakeup";
 160 static const wchar_t* _SENSOR_BAROMETER = L"http://tizen.org/feature/sensor.barometer";
 161 static const wchar_t* _SENSOR_BAROMETER_WAKEUP = L"http://tizen.org/feature/sensor.barometer.wakeup";
 162 static const wchar_t* _SENSOR_GYROSCOPE = L"http://tizen.org/feature/sensor.gyroscope";
 163 static const wchar_t* _SENSOR_GYROSCOPE_WAKEUP = L"http://tizen.org/feature/sensor.gyroscope.wakeup";
 164 static const wchar_t* _SENSOR_MAGNETOMETER = L"http://tizen.org/feature/sensor.magnetometer";
 165 static const wchar_t* _SENSOR_MAGNETOMETER_WAKEUP = L"http://tizen.org/feature/sensor.magnetometer.wakeup";
 166 static const wchar_t* _SENSOR_PHOTOMETER = L"http://tizen.org/feature/sensor.photometer";
 167 static const wchar_t* _SENSOR_PHOTOMETER_WAKEUP = L"http://tizen.org/feature/sensor.photometer.wakeup";
 168 static const wchar_t* _SENSOR_PROXIMITY = L"http://tizen.org/feature/sensor.proximity";
 169 static const wchar_t* _SENSOR_PROXIMITY_WAKEUP = L"http://tizen.org/feature/sensor.proximity.wakeup";
 170 static const wchar_t* _SENSOR_TILTMETER = L"http://tizen.org/feature/sensor.tiltmeter";
 171 static const wchar_t* _SENSOR_TILTMETER_WAKEUP = L"http://tizen.org/feature/sensor.tiltmeter.wakeup";
 172 //SIP VOIP
 173 static const wchar_t* _SIP_VOIP = L"http://tizen.org/feature/sip.voip";
 174 //Speech Recognition
 175 static const wchar_t* _SPEECH_RECOGNITION = L"http://tizen.org/feature/speech.recognition";
 176 static const wchar_t* _SPEECH_SYNTHESIS = L"http://tizen.org/feature/speech.synthesis";
 177 //USB
 178 static const wchar_t* _USB_ACCESSORY = L"http://tizen.org/feature/usb.accessory";
 179 static const wchar_t* _USB_CLIENT = L"http://tizen.org/feature/usb.client";
 180 static const wchar_t* _USB_HOST = L"http://tizen.org/feature/usb.host";
 181 //Vision
 182 static const wchar_t* _VISION_FACE_RECOGNITION = L"http://tizen.org/feature/vision.face_recognition";
 183 static const wchar_t* _VISION_IMAGE_RECOGNITION = L"http://tizen.org/feature/vision.image_recognition";
 184 static const wchar_t* _VISION_QRCODE_GENERATION = L"http://tizen.org/feature/vision.qrcode_generation";
 185 static const wchar_t* _VISION_QRCODE_RECOGNITION = L"http://tizen.org/feature/vision.qrcode_recognition";
 186
 187 static const wchar_t* _BUILD_STRING = L"http://tizen.org/system/build.string";
 188 //DUID
 189 static const wchar_t* _DUID = L"http://tizen.org/system/duid";
 190 //Model name
 191 static const wchar_t* _MODELNAME = L"http://tizen.org/system/model_name";
 192 //Platform name
 193 static const wchar_t* _PLATFORM_NAME = L"http://tizen.org/system/platform.name";
 194 //Sound
 195 static const wchar_t* _SOUND_MEDIA_VOLUME_MAX = L"http://tizen.org/system/sound.media.volume.resolution.max";
 196 static const wchar_t* _SOUND_NOTIFICATION_VOLUME_MAX = L"http://tizen.org/system/sound.notification.volume.resolution.max";
 197 static const wchar_t* _SOUND_RINGTONE_VOLUME_MAX = L"http://tizen.org/system/sound.ringtone.volume.resolution.max";
 198 static const wchar_t* _SOUND_SYSTEM_VOLUME_MAX = L"http://tizen.org/system/sound.system.volume.resolution.max";
 199
 200
 201 //Communication
 202
 203 static const wchar_t* _SYSTEM_CACHING_FILE = L"/opt/usr/etc/system_info_cache.ini";
 204 static const wchar_t* _SYSTEM_CACHING_SECTION = L"SystemInformation";
 205
 206 static const wchar_t* _SYSTEM_CACHING_TRUE = L"true";
 207 static const wchar_t* _SYSTEM_CACHING_FALSE = L"false";
 208
 209 _SystemInfoService* _SystemInfoService::__pSystemInfoService = null;
 210
 211 _SystemInfoService::_SystemInfoService()
 212 {
 213 }
 214
 215 _SystemInfoService::~_SystemInfoService()
 216 {
 217 }
 218
 219 _SystemInfoService*
 220 _SystemInfoService::GetInstance(void)
 221 {
 222         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
 223         if(__pSystemInfoService == null)
 224         {
 225                 pthread_once(&onceBlock, InitSingleton);
 226         }
 227         return __pSystemInfoService;
 228 }
 229
 230 void
 231 _SystemInfoService::InitSingleton(void)
 232 {
 233         _SystemInfoService* pSystemInfoService = new (nothrow) _SystemInfoService();
 234         SysTryReturnVoidResult(NID_SYS, pSystemInfoService != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 235
 236         __pSystemInfoService = pSystemInfoService;
 237         atexit(DestroySingleton);
 238 }
 239
 240 void
 241 _SystemInfoService::DestroySingleton(void)
 242 {
 243         delete __pSystemInfoService;
 244 }
 245
 246 result
 247 _SystemInfoService::CreateCacheFile(void)
 248 {
 249         Registry reg;
 250         result r = E_SUCCESS;
 251         String systemValue;
 252
 253         r = reg.Construct(_SYSTEM_CACHING_FILE, "w+");
 254         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, "It is failed to create the cache file.");
 255
 256         r = reg.AddSection(_SYSTEM_CACHING_SECTION);
 257         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, "It is failed to create section on the cache file.");
 258
 259         bool bValue = false;
 260         int nValue = 0;
 261         String sValue;
 262
 263         //For improve launch performance
 264         nValue = 0;
 265         this->GetValue(_SCREEN_DPI, nValue);
 266         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DPI, nValue);
 267         reg.Flush();
 268
 269         nValue = 0;
 270         this->GetValue(_SCREEN_HEIGHT, nValue);
 271         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_HEIGHT, nValue);
 272         reg.Flush();
 273
 274         nValue = 0;
 275         this->GetValue(_SCREEN_WIDTH, nValue);
 276         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_WIDTH, nValue);
 277         reg.Flush();
 278
 279         this->GetValue(_CAMERA, bValue);
 280         if(bValue == true)
 281                 systemValue = _SYSTEM_CACHING_TRUE;
 282         else
 283                 systemValue = _SYSTEM_CACHING_FALSE;
 284         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA, systemValue);
 285         reg.Flush();
 286
 287         bValue = false;
 288         this->GetValue(_CAMERA_BACK, bValue);
 289         if(bValue == true)
 290                 systemValue = _SYSTEM_CACHING_TRUE;
 291         else
 292                 systemValue = _SYSTEM_CACHING_FALSE;
 293         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK, systemValue);
 294         reg.Flush();
 295
 296         bValue = false;
 297         this->GetValue(_CAMERA_BACK_FLASH, bValue);
 298         if(bValue == true)
 299                 systemValue = _SYSTEM_CACHING_TRUE;
 300         else
 301                 systemValue = _SYSTEM_CACHING_FALSE;
 302         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK_FLASH, systemValue);
 303         reg.Flush();
 304
 305         bValue = false;
 306         this->GetValue(_CAMERA_FRONT, bValue);
 307         if(bValue == true)
 308                 systemValue = _SYSTEM_CACHING_TRUE;
 309         else
 310                 systemValue = _SYSTEM_CACHING_FALSE;
 311         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT, systemValue);
 312         reg.Flush();
 313
 314         bValue = false;
 315         this->GetValue(_CAMERA_FRONT_FLASH, bValue);
 316         if(bValue == true)
 317                 systemValue = _SYSTEM_CACHING_TRUE;
 318         else
 319                 systemValue = _SYSTEM_CACHING_FALSE;
 320         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT_FLASH, systemValue);
 321         reg.Flush();
 322
 323         bValue = false;
 324         this->GetValue(_DATABASE_ENCRYPTION, bValue);
 325         if(bValue == true)
 326                 systemValue = _SYSTEM_CACHING_TRUE;
 327         else
 328                 systemValue = _SYSTEM_CACHING_FALSE;
 329         reg.AddValue(_SYSTEM_CACHING_SECTION, _DATABASE_ENCRYPTION, systemValue);
 330         reg.Flush();
 331
 332         bValue = false;
 333         this->GetValue(_FMRADIO, bValue);
 334         if(bValue == true)
 335                 systemValue = _SYSTEM_CACHING_TRUE;
 336         else
 337                 systemValue = _SYSTEM_CACHING_FALSE;
 338         reg.AddValue(_SYSTEM_CACHING_SECTION, _FMRADIO, systemValue);
 339         reg.Flush();
 340
 341         bValue = false;
 342         this->GetValue(_GRAPHIC_ACCELERATION, bValue);
 343         if(bValue == true)
 344                 systemValue = _SYSTEM_CACHING_TRUE;
 345         else
 346                 systemValue = _SYSTEM_CACHING_FALSE;
 347         reg.AddValue(_SYSTEM_CACHING_SECTION, _GRAPHIC_ACCELERATION, systemValue);
 348         reg.Flush();
 349
 350         bValue = false;
 351         this->GetValue(_INPUT_KEYBOARD, bValue);
 352         if(bValue == true)
 353                 systemValue = _SYSTEM_CACHING_TRUE;
 354         else
 355                 systemValue = _SYSTEM_CACHING_FALSE;
 356         reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD, systemValue);
 357         reg.Flush();
 358
 359         sValue.Clear();
 360         this->GetValue(_INPUT_KEYBOARD_LAYOUT, sValue);
 361         reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD_LAYOUT, sValue);
 362         reg.Flush();
 363
 364         this->GetValue(_LOCATION, bValue);
 365         if(bValue == true)
 366                 systemValue = _SYSTEM_CACHING_TRUE;
 367         else
 368                 systemValue = _SYSTEM_CACHING_FALSE;
 369         reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION, systemValue);
 370         reg.Flush();
 371
 372         bValue = false;
 373         this->GetValue(_LOCATION_GPS, bValue);
 374         if(bValue == true)
 375                 systemValue = _SYSTEM_CACHING_TRUE;
 376         else
 377                 systemValue = _SYSTEM_CACHING_FALSE;
 378         reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_GPS, systemValue);
 379         reg.Flush();
 380
 381         bValue = false;
 382         this->GetValue(_LOCATION_WPS, bValue);
 383         if(bValue == true)
 384                 systemValue = _SYSTEM_CACHING_TRUE;
 385         else
 386                 systemValue = _SYSTEM_CACHING_FALSE;
 387         reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_WPS, systemValue);
 388         reg.Flush();
 389
 390         bValue = false;
 391         this->GetValue(_MICROPHONE, bValue);
 392         if(bValue == true)
 393                 systemValue = _SYSTEM_CACHING_TRUE;
 394         else
 395                 systemValue = _SYSTEM_CACHING_FALSE;
 396         reg.AddValue(_SYSTEM_CACHING_SECTION, _MICROPHONE, systemValue);
 397         reg.Flush();
 398
 399         bValue = false;
 400         this->GetValue(_MULTIPOINTTOUCH_PINCHZOOM, bValue);
 401         if(bValue == true)
 402                 systemValue = _SYSTEM_CACHING_TRUE;
 403         else
 404                 systemValue = _SYSTEM_CACHING_FALSE;
 405         reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_PINCHZOOM, systemValue);
 406         reg.Flush();
 407
 408         nValue = 0;
 409         this->GetValue(_MULTIPOINTTOUCH_POINTCOUNT, nValue);
 410         reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
 411         reg.Flush();
 412
 413         this->GetValue(_NETWORK_BLUETOOTH, bValue);
 414         if(bValue == true)
 415                 systemValue = _SYSTEM_CACHING_TRUE;
 416         else
 417                 systemValue = _SYSTEM_CACHING_FALSE;
 418         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_BLUETOOTH, systemValue);
 419         reg.Flush();
 420
 421         bValue = false;
 422         this->GetValue(_NETWORK_NFC, bValue);
 423         if(bValue == true)
 424                 systemValue = _SYSTEM_CACHING_TRUE;
 425         else
 426                 systemValue = _SYSTEM_CACHING_FALSE;
 427         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC, systemValue);
 428         reg.Flush();
 429
 430         bValue = false;
 431         this->GetValue(_NETWORK_NFC_RESERVED_PUSH, bValue);
 432         if(bValue == true)
 433                 systemValue = _SYSTEM_CACHING_TRUE;
 434         else
 435                 systemValue = _SYSTEM_CACHING_FALSE;
 436         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC_RESERVED_PUSH, systemValue);
 437         reg.Flush();
 438
 439         bValue = false;
 440         this->GetValue(_NETWORK_PUSH, bValue);
 441         if(bValue == true)
 442                 systemValue = _SYSTEM_CACHING_TRUE;
 443         else
 444                 systemValue = _SYSTEM_CACHING_FALSE;
 445         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_PUSH, systemValue);
 446         reg.Flush();
 447
 448         bValue = false;
 449         this->GetValue(_NETWORK_SECURE_ELEMENT, bValue);
 450         if(bValue == true)
 451                 systemValue = _SYSTEM_CACHING_TRUE;
 452         else
 453                 systemValue = _SYSTEM_CACHING_FALSE;
 454         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_SECURE_ELEMENT, systemValue);
 455         reg.Flush();
 456
 457         bValue = false;
 458         this->GetValue(_NETWORK_TELEPHONY, bValue);
 459         if(bValue == true)
 460                 systemValue = _SYSTEM_CACHING_TRUE;
 461         else
 462                 systemValue = _SYSTEM_CACHING_FALSE;
 463         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY, systemValue);
 464         reg.Flush();
 465
 466         bValue = false;
 467         this->GetValue(_NETWORK_TELEPHONY_MMS, bValue);
 468         if(bValue == true)
 469                 systemValue = _SYSTEM_CACHING_TRUE;
 470         else
 471                 systemValue = _SYSTEM_CACHING_FALSE;
 472         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_MMS, systemValue);
 473         reg.Flush();
 474
 475         bValue = false;
 476         this->GetValue(_NETWORK_TELEPHONY_SMS, bValue);
 477         if(bValue == true)
 478                 systemValue = _SYSTEM_CACHING_TRUE;
 479         else
 480                 systemValue = _SYSTEM_CACHING_FALSE;
 481         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS, systemValue);
 482         reg.Flush();
 483
 484         bValue = false;
 485         this->GetValue(_NETWORK_TELEPHONY_SMS_CBS, bValue);
 486         if(bValue == true)
 487                 systemValue = _SYSTEM_CACHING_TRUE;
 488         else
 489                 systemValue = _SYSTEM_CACHING_FALSE;
 490         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS_CBS, systemValue);
 491         reg.Flush();
 492
 493         bValue = false;
 494         this->GetValue(_NETWORK_TELEPHONY_SERVICE_CDMA, bValue);
 495         if(bValue == true)
 496                 systemValue = _SYSTEM_CACHING_TRUE;
 497         else
 498                 systemValue = _SYSTEM_CACHING_FALSE;
 499         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_CDMA, systemValue);
 500         reg.Flush();
 501
 502         bValue = false;
 503         this->GetValue(_NETWORK_TELEPHONY_SERVICE_EDGE, bValue);
 504         if(bValue == true)
 505                 systemValue = _SYSTEM_CACHING_TRUE;
 506         else
 507                 systemValue = _SYSTEM_CACHING_FALSE;
 508         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_EDGE, systemValue);
 509         reg.Flush();
 510
 511         bValue = false;
 512         this->GetValue(_NETWORK_TELEPHONY_SERVICE_GPRS, bValue);
 513         if(bValue == true)
 514                 systemValue = _SYSTEM_CACHING_TRUE;
 515         else
 516                 systemValue = _SYSTEM_CACHING_FALSE;
 517         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GPRS, systemValue);
 518         reg.Flush();
 519
 520         bValue = false;
 521         this->GetValue(_NETWORK_TELEPHONY_SERVICE_GSM, bValue);
 522         if(bValue == true)
 523                 systemValue = _SYSTEM_CACHING_TRUE;
 524         else
 525                 systemValue = _SYSTEM_CACHING_FALSE;
 526         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GSM, systemValue);
 527         reg.Flush();
 528
 529         bValue = false;
 530         this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSDPA, bValue);
 531         if(bValue == true)
 532                 systemValue = _SYSTEM_CACHING_TRUE;
 533         else
 534                 systemValue = _SYSTEM_CACHING_FALSE;
 535         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSDPA, systemValue);
 536         reg.Flush();
 537
 538         bValue = false;
 539         this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSPA, bValue);
 540         if(bValue == true)
 541                 systemValue = _SYSTEM_CACHING_TRUE;
 542         else
 543                 systemValue = _SYSTEM_CACHING_FALSE;
 544         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSPA, systemValue);
 545         reg.Flush();
 546
 547         bValue = false;
 548         this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSUPA, bValue);
 549         if(bValue == true)
 550                 systemValue = _SYSTEM_CACHING_TRUE;
 551         else
 552                 systemValue = _SYSTEM_CACHING_FALSE;
 553         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSUPA, systemValue);
 554         reg.Flush();
 555
 556         bValue = false;
 557         this->GetValue(_NETWORK_TELEPHONY_SERVICE_LTE, bValue);
 558         if(bValue == true)
 559                 systemValue = _SYSTEM_CACHING_TRUE;
 560         else
 561                 systemValue = _SYSTEM_CACHING_FALSE;
 562         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_LTE, systemValue);
 563         reg.Flush();
 564
 565         bValue = false;
 566         this->GetValue(_NETWORK_TELEPHONY_SERVICE_UMTS, bValue);
 567         if(bValue == true)
 568                 systemValue = _SYSTEM_CACHING_TRUE;
 569         else
 570                 systemValue = _SYSTEM_CACHING_FALSE;
 571         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_UMTS, systemValue);
 572         reg.Flush();
 573
 574         bValue = false;
 575         this->GetValue(_NETWORK_WIFI, bValue);
 576         if(bValue == true)
 577                 systemValue = _SYSTEM_CACHING_TRUE;
 578         else
 579                 systemValue = _SYSTEM_CACHING_FALSE;
 580         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI, systemValue);
 581         reg.Flush();
 582
 583         bValue = false;
 584         this->GetValue(_NETWORK_WIFI_DIRECT, bValue);
 585         if(bValue == true)
 586                 systemValue = _SYSTEM_CACHING_TRUE;
 587         else
 588                 systemValue = _SYSTEM_CACHING_FALSE;
 589         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI_DIRECT, systemValue);
 590         reg.Flush();
 591
 592         bValue = false;
 593         this->GetValue(_OPENGLES, bValue);
 594         if(bValue == true)
 595                 systemValue = _SYSTEM_CACHING_TRUE;
 596         else
 597                 systemValue = _SYSTEM_CACHING_FALSE;
 598         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES, systemValue);
 599         reg.Flush();
 600
 601         bValue = false;
 602         this->GetValue(_OPENGLES_TEXTUREFORMAT_3DC, bValue);
 603         if(bValue == true)
 604                 systemValue = _SYSTEM_CACHING_TRUE;
 605         else
 606                 systemValue = _SYSTEM_CACHING_FALSE;
 607         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_3DC, systemValue);
 608         reg.Flush();
 609
 610         bValue = false;
 611         this->GetValue(_OPENGLES_TEXTUREFORMAT_ATC, bValue);
 612         if(bValue == true)
 613                 systemValue = _SYSTEM_CACHING_TRUE;
 614         else
 615                 systemValue = _SYSTEM_CACHING_FALSE;
 616         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ATC, systemValue);
 617         reg.Flush();
 618
 619         bValue = false;
 620         this->GetValue(_OPENGLES_TEXTUREFORMAT_ETC, bValue);
 621         if(bValue == true)
 622                 systemValue = _SYSTEM_CACHING_TRUE;
 623         else
 624                 systemValue = _SYSTEM_CACHING_FALSE;
 625         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ETC, systemValue);
 626         reg.Flush();
 627
 628         bValue = false;
 629         this->GetValue(_OPENGLES_TEXTUREFORMAT_PTC, bValue);
 630         if(bValue == true)
 631                 systemValue = _SYSTEM_CACHING_TRUE;
 632         else
 633                 systemValue = _SYSTEM_CACHING_FALSE;
 634         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PTC, systemValue);
 635         reg.Flush();
 636
 637         bValue = false;
 638         this->GetValue(_OPENGLES_TEXTUREFORMAT_PVRTC, bValue);
 639         if(bValue == true)
 640                 systemValue = _SYSTEM_CACHING_TRUE;
 641         else
 642                 systemValue = _SYSTEM_CACHING_FALSE;
 643         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PVRTC, systemValue);
 644         reg.Flush();
 645
 646         bValue = false;
 647         this->GetValue(_OPENGLES_TEXTUREFORMAT_UTC, bValue);
 648         if(bValue == true)
 649                 systemValue = _SYSTEM_CACHING_TRUE;
 650         else
 651                 systemValue = _SYSTEM_CACHING_FALSE;
 652         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_UTC, systemValue);
 653         reg.Flush();
 654
 655         bValue = false;
 656         this->GetValue(_OPENGLES_VERSION_1_1, bValue);
 657         if(bValue == true)
 658                 systemValue = _SYSTEM_CACHING_TRUE;
 659         else
 660                 systemValue = _SYSTEM_CACHING_FALSE;
 661         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_1_1, systemValue);
 662         reg.Flush();
 663
 664         bValue = false;
 665         this->GetValue(_OPENGLES_VERSION_2_0, bValue);
 666         if(bValue == true)
 667                 systemValue = _SYSTEM_CACHING_TRUE;
 668         else
 669                 systemValue = _SYSTEM_CACHING_FALSE;
 670         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_2_0, systemValue);
 671         reg.Flush();
 672
 673         bValue = false;
 674         this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV6, bValue);
 675         if(bValue == true)
 676                 systemValue = _SYSTEM_CACHING_TRUE;
 677         else
 678                 systemValue = _SYSTEM_CACHING_FALSE;
 679         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV6, systemValue);
 680         reg.Flush();
 681
 682         bValue = false;
 683         this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV7, bValue);
 684         if(bValue == true)
 685                 systemValue = _SYSTEM_CACHING_TRUE;
 686         else
 687                 systemValue = _SYSTEM_CACHING_FALSE;
 688         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV7, systemValue);
 689         reg.Flush();
 690
 691         bValue = false;
 692         this->GetValue(_PLATFORM_CORE_CPU_ARCH_X86, bValue);
 693         if(bValue == true)
 694                 systemValue = _SYSTEM_CACHING_TRUE;
 695         else
 696                 systemValue = _SYSTEM_CACHING_FALSE;
 697         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_X86, systemValue);
 698         reg.Flush();
 699
 700         bValue = false;
 701         this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE2, bValue);
 702         if(bValue == true)
 703                 systemValue = _SYSTEM_CACHING_TRUE;
 704         else
 705                 systemValue = _SYSTEM_CACHING_FALSE;
 706         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE2, systemValue);
 707         reg.Flush();
 708
 709         bValue = false;
 710         this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE3, bValue);
 711         if(bValue == true)
 712                 systemValue = _SYSTEM_CACHING_TRUE;
 713         else
 714                 systemValue = _SYSTEM_CACHING_FALSE;
 715         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE3, systemValue);
 716         reg.Flush();
 717
 718         bValue = false;
 719         this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSSE3, bValue);
 720         if(bValue == true)
 721                 systemValue = _SYSTEM_CACHING_TRUE;
 722         else
 723                 systemValue = _SYSTEM_CACHING_FALSE;
 724         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSSE3, systemValue);
 725         reg.Flush();
 726
 727         bValue = false;
 728         this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV2, bValue);
 729         if(bValue == true)
 730                 systemValue = _SYSTEM_CACHING_TRUE;
 731         else
 732                 systemValue = _SYSTEM_CACHING_FALSE;
 733         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV2, systemValue);
 734         reg.Flush();
 735
 736         bValue = false;
 737         this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV3, bValue);
 738         if(bValue == true)
 739                 systemValue = _SYSTEM_CACHING_TRUE;
 740         else
 741                 systemValue = _SYSTEM_CACHING_FALSE;
 742         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV3, systemValue);
 743         reg.Flush();
 744
 745         sValue.Clear();
 746         this->GetValue(_PLATFORM_NATIVE_API_VERSION, sValue);
 747         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_API_VERSION, sValue);
 748         reg.Flush();
 749
 750         this->GetValue(_PLATFORM_NATIVE_OSP_COMPATIBLE, bValue);
 751         if(bValue == true)
 752                 systemValue = _SYSTEM_CACHING_TRUE;
 753         else
 754                 systemValue = _SYSTEM_CACHING_FALSE;
 755         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_OSP_COMPATIBLE, systemValue);
 756         reg.Flush();
 757
 758         sValue.Clear();
 759         this->GetValue(_PLATFORM_VERSION, sValue);
 760         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_VERSION, sValue);
 761         reg.Flush();
 762
 763         this->GetValue(_PLATFORM_WEB_API_VERSION, sValue);
 764         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_WEB_API_VERSION, sValue);
 765         reg.Flush();
 766
 767         this->GetValue(_SCREEN_AUTO_ROTATION, bValue);
 768         if(bValue == true)
 769                 systemValue = _SYSTEM_CACHING_TRUE;
 770         else
 771                 systemValue = _SYSTEM_CACHING_FALSE;
 772         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_AUTO_ROTATION, systemValue);
 773         reg.Flush();
 774
 775         nValue = 0;
 776         this->GetValue(_SCREEN_BPP, nValue);
 777         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_BPP, nValue);
 778         reg.Flush();
 779
 780         this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, bValue);
 781         if(bValue == true)
 782                 systemValue = _SYSTEM_CACHING_TRUE;
 783         else
 784                 systemValue = _SYSTEM_CACHING_FALSE;
 785         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, systemValue);
 786         reg.Flush();
 787
 788         bValue = false;
 789         this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, bValue);
 790         if(bValue == true)
 791                 systemValue = _SYSTEM_CACHING_TRUE;
 792         else
 793                 systemValue = _SYSTEM_CACHING_FALSE;
 794         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, systemValue);
 795         reg.Flush();
 796
 797         bValue = false;
 798         this->GetValue(_SCREEN_DESKTOPMODE, bValue);
 799         if(bValue == true)
 800                 systemValue = _SYSTEM_CACHING_TRUE;
 801         else
 802                 systemValue = _SYSTEM_CACHING_FALSE;
 803         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DESKTOPMODE, systemValue);
 804         reg.Flush();
 805
 806         bValue = false;
 807         this->GetValue(_SCREEN_SIZE_LARGE, bValue);
 808         if(bValue == true)
 809                 systemValue = _SYSTEM_CACHING_TRUE;
 810         else
 811                 systemValue = _SYSTEM_CACHING_FALSE;
 812         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_LARGE, systemValue);
 813         reg.Flush();
 814
 815         bValue = false;
 816         this->GetValue(_SCREEN_SIZE_NORMAL, bValue);
 817         if(bValue == true)
 818                 systemValue = _SYSTEM_CACHING_TRUE;
 819         else
 820                 systemValue = _SYSTEM_CACHING_FALSE;
 821         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL, systemValue);
 822         reg.Flush();
 823
 824         bValue = false;
 825         this->GetValue(_SCREEN_SIZE_NORMAL_240_400, bValue);
 826         if(bValue == true)
 827                 systemValue = _SYSTEM_CACHING_TRUE;
 828         else
 829                 systemValue = _SYSTEM_CACHING_FALSE;
 830
 831         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_240_400, systemValue);
 832         reg.Flush();
 833
 834         bValue = false;
 835         this->GetValue(_SCREEN_SIZE_NORMAL_320_480, bValue);
 836         if(bValue == true)
 837                 systemValue = _SYSTEM_CACHING_TRUE;
 838         else
 839                 systemValue = _SYSTEM_CACHING_FALSE;
 840
 841         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_320_480, systemValue);
 842         reg.Flush();
 843
 844         bValue = false;
 845         this->GetValue(_SCREEN_SIZE_NORMAL_480_800, bValue);
 846         if(bValue == true)
 847                 systemValue = _SYSTEM_CACHING_TRUE;
 848         else
 849                 systemValue = _SYSTEM_CACHING_FALSE;
 850
 851         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_480_800, systemValue);
 852         reg.Flush();
 853
 854         bValue = false;
 855         this->GetValue(_SCREEN_SIZE_NORMAL_540_960, bValue);
 856         if(bValue == true)
 857                 systemValue = _SYSTEM_CACHING_TRUE;
 858         else
 859                 systemValue = _SYSTEM_CACHING_FALSE;
 860
 861         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_540_960, systemValue);
 862         reg.Flush();
 863
 864         bValue = false;
 865         this->GetValue(_SCREEN_SIZE_NORMAL_600_1024, bValue);
 866         if(bValue == true)
 867                 systemValue = _SYSTEM_CACHING_TRUE;
 868         else
 869                 systemValue = _SYSTEM_CACHING_FALSE;
 870
 871         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_600_1024, systemValue);
 872         reg.Flush();
 873
 874         bValue = false;
 875         this->GetValue(_SCREEN_SIZE_NORMAL_720_1280, bValue);
 876         if(bValue == true)
 877                 systemValue = _SYSTEM_CACHING_TRUE;
 878         else
 879                 systemValue = _SYSTEM_CACHING_FALSE;
 880
 881         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_720_1280, systemValue);
 882         reg.Flush();
 883
 884         bValue = false;
 885         this->GetValue(_SCREEN_SIZE_NORMAL_1080_1920, bValue);
 886         if(bValue == true)
 887                 systemValue = _SYSTEM_CACHING_TRUE;
 888         else
 889                 systemValue = _SYSTEM_CACHING_FALSE;
 890
 891         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_1080_1920, systemValue);
 892         reg.Flush();
 893
 894         bValue = false;
 895         this->GetValue(_SCREEN_OUTPUT_HDMI, bValue);
 896         if(bValue == true)
 897                 systemValue = _SYSTEM_CACHING_TRUE;
 898         else
 899                 systemValue = _SYSTEM_CACHING_FALSE;
 900         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_HDMI, systemValue);
 901         reg.Flush();
 902
 903         bValue = false;
 904         this->GetValue(_SCREEN_OUTPUT_RCA, bValue);
 905         if(bValue == true)
 906                 systemValue = _SYSTEM_CACHING_TRUE;
 907         else
 908                 systemValue = _SYSTEM_CACHING_FALSE;
 909         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_RCA, systemValue);
 910         reg.Flush();
 911
 912         bValue = false;
 913         this->GetValue(_SHELL_APPWIDGET, bValue);
 914         if(bValue == true)
 915                 systemValue = _SYSTEM_CACHING_TRUE;
 916         else
 917                 systemValue = _SYSTEM_CACHING_FALSE;
 918         reg.AddValue(_SYSTEM_CACHING_SECTION, _SHELL_APPWIDGET, systemValue);
 919         reg.Flush();
 920
 921         bValue = false;
 922         this->GetValue(_SENSOR_ACCELEROMETER, bValue);
 923         if(bValue == true)
 924                 systemValue = _SYSTEM_CACHING_TRUE;
 925         else
 926                 systemValue = _SYSTEM_CACHING_FALSE;
 927         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER, systemValue);
 928         reg.Flush();
 929
 930         bValue = false;
 931         this->GetValue(_SENSOR_ACCELEROMETER_WAKEUP, bValue);
 932         if(bValue == true)
 933                 systemValue = _SYSTEM_CACHING_TRUE;
 934         else
 935                 systemValue = _SYSTEM_CACHING_FALSE;
 936         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER_WAKEUP, systemValue);
 937         reg.Flush();
 938
 939         bValue = false;
 940         this->GetValue(_SENSOR_BAROMETER, bValue);
 941         if(bValue == true)
 942                 systemValue = _SYSTEM_CACHING_TRUE;
 943         else
 944                 systemValue = _SYSTEM_CACHING_FALSE;
 945         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER, systemValue);
 946         reg.Flush();
 947
 948         bValue = false;
 949         this->GetValue(_SENSOR_BAROMETER_WAKEUP, bValue);
 950         if(bValue == true)
 951                 systemValue = _SYSTEM_CACHING_TRUE;
 952         else
 953                 systemValue = _SYSTEM_CACHING_FALSE;
 954         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER_WAKEUP, systemValue);
 955         reg.Flush();
 956
 957         bValue = false;
 958         this->GetValue(_SENSOR_GYROSCOPE, bValue);
 959         if(bValue == true)
 960                 systemValue = _SYSTEM_CACHING_TRUE;
 961         else
 962                 systemValue = _SYSTEM_CACHING_FALSE;
 963         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE, systemValue);
 964         reg.Flush();
 965
 966         bValue = false;
 967         this->GetValue(_SENSOR_GYROSCOPE_WAKEUP, bValue);
 968         if(bValue == true)
 969                 systemValue = _SYSTEM_CACHING_TRUE;
 970         else
 971                 systemValue = _SYSTEM_CACHING_FALSE;
 972         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE_WAKEUP, systemValue);
 973         reg.Flush();
 974
 975         bValue = false;
 976         this->GetValue(_SENSOR_MAGNETOMETER, bValue);
 977         if(bValue == true)
 978                 systemValue = _SYSTEM_CACHING_TRUE;
 979         else
 980                 systemValue = _SYSTEM_CACHING_FALSE;
 981         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER, systemValue);
 982         reg.Flush();
 983
 984         bValue = false;
 985         this->GetValue(_SENSOR_MAGNETOMETER_WAKEUP, bValue);
 986         if(bValue == true)
 987                 systemValue = _SYSTEM_CACHING_TRUE;
 988         else
 989                 systemValue = _SYSTEM_CACHING_FALSE;
 990         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER_WAKEUP, systemValue);
 991         reg.Flush();
 992
 993         bValue = false;
 994         this->GetValue(_SENSOR_PHOTOMETER, bValue);
 995         if(bValue == true)
 996                 systemValue = _SYSTEM_CACHING_TRUE;
 997         else
 998                 systemValue = _SYSTEM_CACHING_FALSE;
 999         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER, systemValue);
1000         reg.Flush();
1001
1002         bValue = false;
1003         this->GetValue(_SENSOR_PHOTOMETER_WAKEUP, bValue);
1004         if(bValue == true)
1005                 systemValue = _SYSTEM_CACHING_TRUE;
1006         else
1007                 systemValue = _SYSTEM_CACHING_FALSE;
1008         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER_WAKEUP, systemValue);
1009         reg.Flush();
1010
1011         bValue = false;
1012         this->GetValue(_SENSOR_PROXIMITY, bValue);
1013         if(bValue == true)
1014                 systemValue = _SYSTEM_CACHING_TRUE;
1015         else
1016                 systemValue = _SYSTEM_CACHING_FALSE;
1017         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY, systemValue);
1018         reg.Flush();
1019
1020         bValue = false;
1021         this->GetValue(_SENSOR_PROXIMITY_WAKEUP, bValue);
1022         if(bValue == true)
1023                 systemValue = _SYSTEM_CACHING_TRUE;
1024         else
1025                 systemValue = _SYSTEM_CACHING_FALSE;
1026         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY_WAKEUP, systemValue);
1027         reg.Flush();
1028
1029         bValue = false;
1030         this->GetValue(_SENSOR_TILTMETER, bValue);
1031         if(bValue == true)
1032                 systemValue = _SYSTEM_CACHING_TRUE;
1033         else
1034                 systemValue = _SYSTEM_CACHING_FALSE;
1035         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER, systemValue);
1036         reg.Flush();
1037
1038         bValue = false;
1039         this->GetValue(_SENSOR_TILTMETER_WAKEUP, bValue);
1040         if(bValue == true)
1041                 systemValue = _SYSTEM_CACHING_TRUE;
1042         else
1043                 systemValue = _SYSTEM_CACHING_FALSE;
1044         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER_WAKEUP, systemValue);
1045         reg.Flush();
1046
1047         bValue = false;
1048         this->GetValue(_SIP_VOIP, bValue);
1049         if(bValue == true)
1050                 systemValue = _SYSTEM_CACHING_TRUE;
1051         else
1052                 systemValue = _SYSTEM_CACHING_FALSE;
1053         reg.AddValue(_SYSTEM_CACHING_SECTION, _SIP_VOIP, systemValue);
1054         reg.Flush();
1055
1056         bValue = false;
1057         this->GetValue(_SPEECH_RECOGNITION, bValue);
1058         if(bValue == true)
1059                 systemValue = _SYSTEM_CACHING_TRUE;
1060         else
1061                 systemValue = _SYSTEM_CACHING_FALSE;
1062         reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_RECOGNITION, systemValue);
1063         reg.Flush();
1064
1065         bValue = false;
1066         this->GetValue(_SPEECH_SYNTHESIS, bValue);
1067         if(bValue == true)
1068                 systemValue = _SYSTEM_CACHING_TRUE;
1069         else
1070                 systemValue = _SYSTEM_CACHING_FALSE;
1071         reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_SYNTHESIS, systemValue);
1072         reg.Flush();
1073
1074         bValue = false;
1075         this->GetValue(_USB_ACCESSORY, bValue);
1076         if(bValue == true)
1077                 systemValue = _SYSTEM_CACHING_TRUE;
1078         else
1079                 systemValue = _SYSTEM_CACHING_FALSE;
1080         reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_ACCESSORY, systemValue);
1081         reg.Flush();
1082
1083         bValue = false;
1084         this->GetValue(_USB_CLIENT, bValue);
1085         if(bValue == true)
1086                 systemValue = _SYSTEM_CACHING_TRUE;
1087         else
1088                 systemValue = _SYSTEM_CACHING_FALSE;
1089         reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_CLIENT, systemValue);
1090         reg.Flush();
1091
1092         bValue = false;
1093         this->GetValue(_USB_HOST, bValue);
1094         if(bValue == true)
1095                 systemValue = _SYSTEM_CACHING_TRUE;
1096         else
1097                 systemValue = _SYSTEM_CACHING_FALSE;
1098         reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_HOST, systemValue);
1099         reg.Flush();
1100
1101         bValue = false;
1102         this->GetValue(_VISION_FACE_RECOGNITION, bValue);
1103         if(bValue == true)
1104                 systemValue = _SYSTEM_CACHING_TRUE;
1105         else
1106                 systemValue = _SYSTEM_CACHING_FALSE;
1107         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_FACE_RECOGNITION, systemValue);
1108         reg.Flush();
1109
1110         bValue = false;
1111         this->GetValue(_VISION_IMAGE_RECOGNITION, bValue);
1112         if(bValue == true)
1113                 systemValue = _SYSTEM_CACHING_TRUE;
1114         else
1115                 systemValue = _SYSTEM_CACHING_FALSE;
1116         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_IMAGE_RECOGNITION, systemValue);
1117         reg.Flush();
1118
1119         bValue = false;
1120         this->GetValue(_VISION_QRCODE_GENERATION, bValue);
1121         if(bValue == true)
1122                 systemValue = _SYSTEM_CACHING_TRUE;
1123         else
1124                 systemValue = _SYSTEM_CACHING_FALSE;
1125         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_GENERATION, systemValue);
1126         reg.Flush();
1127
1128         bValue = false;
1129         this->GetValue(_VISION_QRCODE_RECOGNITION, bValue);
1130         if(bValue == true)
1131                 systemValue = _SYSTEM_CACHING_TRUE;
1132         else
1133                 systemValue = _SYSTEM_CACHING_FALSE;
1134         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_RECOGNITION, systemValue);
1135         reg.Flush();
1136
1137         sValue.Clear();
1138         this->GetValue(_BUILD_STRING, sValue);
1139         reg.Flush();
1140         reg.AddValue(_SYSTEM_CACHING_SECTION, _BUILD_STRING, sValue);
1141         reg.Flush();
1142
1143         sValue.Clear();
1144         r = this->GetValue(_DUID, sValue);
1145         if(r != E_SUCCESS)
1146         {
1147                 sValue.Append(L"ERROR");
1148         }
1149         reg.AddValue(_SYSTEM_CACHING_SECTION, _DUID, sValue);
1150         reg.Flush();
1151
1152         sValue.Clear();
1153         this->GetValue(_MODELNAME, sValue);
1154         reg.AddValue(_SYSTEM_CACHING_SECTION, _MODELNAME, sValue);
1155         reg.Flush();
1156
1157         sValue.Clear();
1158         this->GetValue(_PLATFORM_NAME, sValue);
1159         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NAME, sValue);
1160         reg.Flush();
1161
1162         nValue = 0;
1163         this->GetValue(_SOUND_MEDIA_VOLUME_MAX, nValue);
1164         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_MEDIA_VOLUME_MAX, nValue);
1165         reg.Flush();
1166
1167         nValue = 0;
1168         this->GetValue(_SOUND_NOTIFICATION_VOLUME_MAX, nValue);
1169         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_NOTIFICATION_VOLUME_MAX, nValue);
1170         reg.Flush();
1171
1172         nValue = 0;
1173         this->GetValue(_SOUND_RINGTONE_VOLUME_MAX, nValue);
1174         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_RINGTONE_VOLUME_MAX, nValue);
1175         reg.Flush();
1176
1177         nValue = 0;
1178         this->GetValue(_SOUND_SYSTEM_VOLUME_MAX, nValue);
1179         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_SYSTEM_VOLUME_MAX, nValue);
1180         reg.Flush();
1181
1182         return E_SUCCESS;
1183 }
1184
1185 result
1186 _SystemInfoService::UpdateCacheFile(void)
1187 {
1188         Registry reg;
1189         result r = E_SUCCESS;
1190         String systemValue;
1191
1192         r = reg.Construct(_SYSTEM_CACHING_FILE, "r+");
1193         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, "It is failed to create the cache file.");
1194
1195         bool bValue = false;
1196         int nValue = 0;
1197         String sValue;
1198
1199         //For improve launch performance
1200         nValue = 0;
1201         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_DPI, nValue);
1202         if(r != E_SUCCESS)
1203         {
1204                 this->GetValue(_SCREEN_DPI, nValue);
1205                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DPI, nValue);
1206                 reg.Flush();
1207         }
1208
1209         nValue = 0;
1210         this->GetValue(_SCREEN_HEIGHT, nValue);
1211         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_HEIGHT, nValue) == E_KEY_ALREADY_EXIST)
1212         {
1213                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_HEIGHT, nValue);
1214         }
1215         reg.Flush();
1216
1217         nValue = 0;
1218         this->GetValue(_SCREEN_WIDTH, nValue);
1219         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_WIDTH, nValue) == E_KEY_ALREADY_EXIST)
1220         {
1221                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_WIDTH, nValue);
1222         }
1223         reg.Flush();
1224
1225         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA, systemValue);
1226         if(r != E_SUCCESS)
1227         {
1228                 bValue = false;
1229                 this->GetValue(_CAMERA, bValue);
1230                 if(bValue == true)
1231                         systemValue = _SYSTEM_CACHING_TRUE;
1232                 else
1233                         systemValue = _SYSTEM_CACHING_FALSE;
1234
1235                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA, systemValue);
1236                 reg.Flush();
1237         }
1238
1239         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK, systemValue);
1240         if(r != E_SUCCESS)
1241         {
1242                 bValue = false;
1243                 this->GetValue(_CAMERA_BACK, bValue);
1244                 if(bValue == true)
1245                         systemValue = _SYSTEM_CACHING_TRUE;
1246                 else
1247                         systemValue = _SYSTEM_CACHING_FALSE;
1248
1249                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK, systemValue);
1250                 reg.Flush();
1251         }
1252
1253         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK_FLASH, systemValue);
1254         if(r != E_SUCCESS)
1255         {
1256                 bValue = false;
1257                 this->GetValue(_CAMERA_BACK_FLASH, bValue);
1258                 if(bValue == true)
1259                         systemValue = _SYSTEM_CACHING_TRUE;
1260                 else
1261                         systemValue = _SYSTEM_CACHING_FALSE;
1262
1263                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK_FLASH, systemValue);
1264                 reg.Flush();
1265         }
1266
1267         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT, systemValue);
1268         if(r != E_SUCCESS)
1269         {
1270                 bValue = false;
1271                 this->GetValue(_CAMERA_FRONT, bValue);
1272                 if(bValue == true)
1273                         systemValue = _SYSTEM_CACHING_TRUE;
1274                 else
1275                         systemValue = _SYSTEM_CACHING_FALSE;
1276
1277                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT, systemValue);
1278                 reg.Flush();
1279         }
1280
1281         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT_FLASH, systemValue);
1282         if(r != E_SUCCESS)
1283         {
1284                 bValue = false;
1285                 this->GetValue(_CAMERA_FRONT_FLASH, bValue);
1286                 if(bValue == true)
1287                         systemValue = _SYSTEM_CACHING_TRUE;
1288                 else
1289                         systemValue = _SYSTEM_CACHING_FALSE;
1290
1291                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT_FLASH, systemValue);
1292                 reg.Flush();
1293         }
1294
1295         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _DATABASE_ENCRYPTION, systemValue);
1296         if(r != E_SUCCESS)
1297         {
1298                 bValue = false;
1299                 this->GetValue(_DATABASE_ENCRYPTION, bValue);
1300                 if(bValue == true)
1301                         systemValue = _SYSTEM_CACHING_TRUE;
1302                 else
1303                         systemValue = _SYSTEM_CACHING_FALSE;
1304
1305                 reg.AddValue(_SYSTEM_CACHING_SECTION, _DATABASE_ENCRYPTION, systemValue);
1306                 reg.Flush();
1307         }
1308
1309         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _FMRADIO, systemValue);
1310         if(r != E_SUCCESS)
1311         {
1312                 bValue = false;
1313                 this->GetValue(_FMRADIO, bValue);
1314                 if(bValue == true)
1315                         systemValue = _SYSTEM_CACHING_TRUE;
1316                 else
1317                         systemValue = _SYSTEM_CACHING_FALSE;
1318
1319                 reg.AddValue(_SYSTEM_CACHING_SECTION, _FMRADIO, systemValue);
1320                 reg.Flush();
1321         }
1322
1323         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _GRAPHIC_ACCELERATION, systemValue);
1324         if(r != E_SUCCESS)
1325         {
1326                 bValue = false;
1327                 this->GetValue(_GRAPHIC_ACCELERATION, bValue);
1328                 if(bValue == true)
1329                         systemValue = _SYSTEM_CACHING_TRUE;
1330                 else
1331                         systemValue = _SYSTEM_CACHING_FALSE;
1332
1333                 reg.AddValue(_SYSTEM_CACHING_SECTION, _GRAPHIC_ACCELERATION, systemValue);
1334                 reg.Flush();
1335         }
1336
1337         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD, systemValue);
1338         if(r != E_SUCCESS)
1339         {
1340                 bValue = false;
1341                 this->GetValue(_INPUT_KEYBOARD, bValue);
1342                 if(bValue == true)
1343                         systemValue = _SYSTEM_CACHING_TRUE;
1344                 else
1345                         systemValue = _SYSTEM_CACHING_FALSE;
1346
1347                 reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD, systemValue);
1348                 reg.Flush();
1349         }
1350
1351         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD_LAYOUT, sValue);
1352         if(r != E_SUCCESS)
1353         {
1354                 sValue.Clear();
1355                 this->GetValue(_INPUT_KEYBOARD_LAYOUT, sValue);
1356                 reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD_LAYOUT, sValue);
1357                 reg.Flush();
1358         }
1359
1360         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _LOCATION, systemValue);
1361         if(r != E_SUCCESS)
1362         {
1363                 bValue = false;
1364                 this->GetValue(_LOCATION, bValue);
1365                 if(bValue == true)
1366                         systemValue = _SYSTEM_CACHING_TRUE;
1367                 else
1368                         systemValue = _SYSTEM_CACHING_FALSE;
1369
1370                 reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION, systemValue);
1371                 reg.Flush();
1372         }
1373
1374         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _LOCATION_GPS, systemValue);
1375         if(r != E_SUCCESS)
1376         {
1377                 bValue = false;
1378                 this->GetValue(_LOCATION_GPS, bValue);
1379                 if(bValue == true)
1380                         systemValue = _SYSTEM_CACHING_TRUE;
1381                 else
1382                         systemValue = _SYSTEM_CACHING_FALSE;
1383
1384                 reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_GPS, systemValue);
1385                 reg.Flush();
1386         }
1387
1388         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _LOCATION_WPS, systemValue);
1389         if(r != E_SUCCESS)
1390         {
1391                 bValue = false;
1392                 this->GetValue(_LOCATION_WPS, bValue);
1393                 if(bValue == true)
1394                         systemValue = _SYSTEM_CACHING_TRUE;
1395                 else
1396                         systemValue = _SYSTEM_CACHING_FALSE;
1397
1398                 reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_WPS, systemValue);
1399                 reg.Flush();
1400         }
1401
1402         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MICROPHONE, systemValue);
1403         if(r != E_SUCCESS)
1404         {
1405                 bValue = false;
1406                 this->GetValue(_MICROPHONE, bValue);
1407                 if(bValue == true)
1408                         systemValue = _SYSTEM_CACHING_TRUE;
1409                 else
1410                         systemValue = _SYSTEM_CACHING_FALSE;
1411
1412                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MICROPHONE, systemValue);
1413                 reg.Flush();
1414         }
1415
1416         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_PINCHZOOM, systemValue);
1417         if(r != E_SUCCESS)
1418         {
1419                 bValue = false;
1420                 this->GetValue(_MULTIPOINTTOUCH_PINCHZOOM, bValue);
1421                 if(bValue == true)
1422                         systemValue = _SYSTEM_CACHING_TRUE;
1423                 else
1424                         systemValue = _SYSTEM_CACHING_FALSE;
1425
1426                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_PINCHZOOM, systemValue);
1427                 reg.Flush();
1428         }
1429
1430         nValue = 0;
1431         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
1432         if(r != E_SUCCESS)
1433         {
1434                 nValue = 0;
1435                 r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
1436                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
1437                 reg.Flush();
1438         }
1439
1440         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_BLUETOOTH, systemValue);
1441         if(r != E_SUCCESS)
1442         {
1443                 bValue = false;
1444                 this->GetValue(_NETWORK_BLUETOOTH, bValue);
1445                 if(bValue == true)
1446                         systemValue = _SYSTEM_CACHING_TRUE;
1447                 else
1448                         systemValue = _SYSTEM_CACHING_FALSE;
1449
1450                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_BLUETOOTH, systemValue);
1451                 reg.Flush();
1452         }
1453
1454         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC, systemValue);
1455         if(r != E_SUCCESS)
1456         {
1457                 bValue = false;
1458                 this->GetValue(_NETWORK_NFC, bValue);
1459                 if(bValue == true)
1460                         systemValue = _SYSTEM_CACHING_TRUE;
1461                 else
1462                         systemValue = _SYSTEM_CACHING_FALSE;
1463
1464                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC, systemValue);
1465                 reg.Flush();
1466         }
1467
1468         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC_RESERVED_PUSH, systemValue);
1469         if(r != E_SUCCESS)
1470         {
1471                 bValue = false;
1472                 this->GetValue(_NETWORK_NFC_RESERVED_PUSH, bValue);
1473                 if(bValue == true)
1474                         systemValue = _SYSTEM_CACHING_TRUE;
1475                 else
1476                         systemValue = _SYSTEM_CACHING_FALSE;
1477
1478                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC_RESERVED_PUSH, systemValue);
1479                 reg.Flush();
1480         }
1481
1482         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_PUSH, systemValue);
1483         if(r != E_SUCCESS)
1484         {
1485                 bValue = false;
1486                 this->GetValue(_NETWORK_PUSH, bValue);
1487                 if(bValue == true)
1488                         systemValue = _SYSTEM_CACHING_TRUE;
1489                 else
1490                         systemValue = _SYSTEM_CACHING_FALSE;
1491
1492                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_PUSH, systemValue);
1493                 reg.Flush();
1494         }
1495
1496         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_SECURE_ELEMENT, systemValue);
1497         if(r != E_SUCCESS)
1498         {
1499                 bValue = false;
1500                 this->GetValue(_NETWORK_SECURE_ELEMENT, bValue);
1501                 if(bValue == true)
1502                         systemValue = _SYSTEM_CACHING_TRUE;
1503                 else
1504                         systemValue = _SYSTEM_CACHING_FALSE;
1505
1506                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_SECURE_ELEMENT, systemValue);
1507                 reg.Flush();
1508         }
1509
1510         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY, systemValue);
1511         if(r != E_SUCCESS)
1512         {
1513                 bValue = false;
1514                 this->GetValue(_NETWORK_TELEPHONY, bValue);
1515                 if(bValue == true)
1516                         systemValue = _SYSTEM_CACHING_TRUE;
1517                 else
1518                         systemValue = _SYSTEM_CACHING_FALSE;
1519
1520                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY, systemValue);
1521                 reg.Flush();
1522         }
1523
1524         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_MMS, systemValue);
1525         if(r != E_SUCCESS)
1526         {
1527                 bValue = false;
1528                 this->GetValue(_NETWORK_TELEPHONY_MMS, bValue);
1529                 if(bValue == true)
1530                         systemValue = _SYSTEM_CACHING_TRUE;
1531                 else
1532                         systemValue = _SYSTEM_CACHING_FALSE;
1533
1534                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_MMS, systemValue);
1535                 reg.Flush();
1536         }
1537
1538         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS, systemValue);
1539         if(r != E_SUCCESS)
1540         {
1541                 bValue = false;
1542                 this->GetValue(_NETWORK_TELEPHONY_SMS, bValue);
1543                 if(bValue == true)
1544                         systemValue = _SYSTEM_CACHING_TRUE;
1545                 else
1546                         systemValue = _SYSTEM_CACHING_FALSE;
1547
1548                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS, systemValue);
1549                 reg.Flush();
1550         }
1551
1552         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS_CBS, systemValue);
1553         if(r != E_SUCCESS)
1554         {
1555                 bValue = false;
1556                 this->GetValue(_NETWORK_TELEPHONY_SMS_CBS, bValue);
1557                 if(bValue == true)
1558                         systemValue = _SYSTEM_CACHING_TRUE;
1559                 else
1560                         systemValue = _SYSTEM_CACHING_FALSE;
1561
1562                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS_CBS, systemValue);
1563                 reg.Flush();
1564         }
1565
1566         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_CDMA, systemValue);
1567         if(r != E_SUCCESS)
1568         {
1569                 bValue = false;
1570                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_CDMA, bValue);
1571                 if(bValue == true)
1572                         systemValue = _SYSTEM_CACHING_TRUE;
1573                 else
1574                         systemValue = _SYSTEM_CACHING_FALSE;
1575
1576                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_CDMA, systemValue);
1577                 reg.Flush();
1578         }
1579
1580         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_EDGE, systemValue);
1581         if(r != E_SUCCESS)
1582         {
1583                 bValue = false;
1584                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_EDGE, bValue);
1585                 if(bValue == true)
1586                         systemValue = _SYSTEM_CACHING_TRUE;
1587                 else
1588                         systemValue = _SYSTEM_CACHING_FALSE;
1589
1590                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_EDGE, systemValue);
1591                 reg.Flush();
1592         }
1593
1594         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GPRS, systemValue);
1595         if(r != E_SUCCESS)
1596         {
1597                 bValue = false;
1598                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_GPRS, bValue);
1599                 if(bValue == true)
1600                         systemValue = _SYSTEM_CACHING_TRUE;
1601                 else
1602                         systemValue = _SYSTEM_CACHING_FALSE;
1603
1604                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GPRS, systemValue);
1605                 reg.Flush();
1606         }
1607
1608         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GSM, systemValue);
1609         if(r != E_SUCCESS)
1610         {
1611                 bValue = false;
1612                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_GSM, bValue);
1613                 if(bValue == true)
1614                         systemValue = _SYSTEM_CACHING_TRUE;
1615                 else
1616                         systemValue = _SYSTEM_CACHING_FALSE;
1617
1618                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GSM, systemValue);
1619                 reg.Flush();
1620         }
1621
1622         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSDPA, systemValue);
1623         if(r != E_SUCCESS)
1624         {
1625                 bValue = false;
1626                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSDPA, bValue);
1627                 if(bValue == true)
1628                         systemValue = _SYSTEM_CACHING_TRUE;
1629                 else
1630                         systemValue = _SYSTEM_CACHING_FALSE;
1631
1632                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSDPA, systemValue);
1633                 reg.Flush();
1634         }
1635
1636         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSPA, systemValue);
1637         if(r != E_SUCCESS)
1638         {
1639                 bValue = false;
1640                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSPA, bValue);
1641                 if(bValue == true)
1642                         systemValue = _SYSTEM_CACHING_TRUE;
1643                 else
1644                         systemValue = _SYSTEM_CACHING_FALSE;
1645
1646                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSPA, systemValue);
1647                 reg.Flush();
1648         }
1649
1650         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSUPA, systemValue);
1651         if(r != E_SUCCESS)
1652         {
1653                 bValue = false;
1654                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSUPA, bValue);
1655                 if(bValue == true)
1656                         systemValue = _SYSTEM_CACHING_TRUE;
1657                 else
1658                         systemValue = _SYSTEM_CACHING_FALSE;
1659
1660                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSUPA, systemValue);
1661                 reg.Flush();
1662         }
1663
1664         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_LTE, systemValue);
1665         if(r != E_SUCCESS)
1666         {
1667                 bValue = false;
1668                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_LTE, bValue);
1669                 if(bValue == true)
1670                         systemValue = _SYSTEM_CACHING_TRUE;
1671                 else
1672                         systemValue = _SYSTEM_CACHING_FALSE;
1673
1674                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_LTE, systemValue);
1675                 reg.Flush();
1676         }
1677
1678         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_UMTS, systemValue);
1679         if(r != E_SUCCESS)
1680         {
1681                 bValue = false;
1682                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_UMTS, bValue);
1683                 if(bValue == true)
1684                         systemValue = _SYSTEM_CACHING_TRUE;
1685                 else
1686                         systemValue = _SYSTEM_CACHING_FALSE;
1687
1688                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_UMTS, systemValue);
1689                 reg.Flush();
1690         }
1691
1692         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI, systemValue);
1693         if(r != E_SUCCESS)
1694         {
1695                 bValue = false;
1696                 this->GetValue(_NETWORK_WIFI, bValue);
1697                 if(bValue == true)
1698                         systemValue = _SYSTEM_CACHING_TRUE;
1699                 else
1700                         systemValue = _SYSTEM_CACHING_FALSE;
1701
1702                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI, systemValue);
1703                 reg.Flush();
1704         }
1705
1706         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI_DIRECT, systemValue);
1707         if(r != E_SUCCESS)
1708         {
1709                 bValue = false;
1710                 this->GetValue(_NETWORK_WIFI_DIRECT, bValue);
1711                 if(bValue == true)
1712                         systemValue = _SYSTEM_CACHING_TRUE;
1713                 else
1714                         systemValue = _SYSTEM_CACHING_FALSE;
1715
1716                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI_DIRECT, systemValue);
1717                 reg.Flush();
1718         }
1719
1720         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES, systemValue);
1721         if(r != E_SUCCESS)
1722         {
1723                 bValue = false;
1724                 this->GetValue(_OPENGLES, bValue);
1725                 if(bValue == true)
1726                         systemValue = _SYSTEM_CACHING_TRUE;
1727                 else
1728                         systemValue = _SYSTEM_CACHING_FALSE;
1729
1730                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES, systemValue);
1731                 reg.Flush();
1732         }
1733
1734         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_3DC, systemValue);
1735         if(r != E_SUCCESS)
1736         {
1737                 bValue = false;
1738                 this->GetValue(_OPENGLES_TEXTUREFORMAT_3DC, bValue);
1739                 if(bValue == true)
1740                         systemValue = _SYSTEM_CACHING_TRUE;
1741                 else
1742                         systemValue = _SYSTEM_CACHING_FALSE;
1743
1744                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_3DC, systemValue);
1745                 reg.Flush();
1746         }
1747
1748         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ATC, systemValue);
1749         if(r != E_SUCCESS)
1750         {
1751                 bValue = false;
1752                 this->GetValue(_OPENGLES_TEXTUREFORMAT_ATC, bValue);
1753                 if(bValue == true)
1754                         systemValue = _SYSTEM_CACHING_TRUE;
1755                 else
1756                         systemValue = _SYSTEM_CACHING_FALSE;
1757
1758                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ATC, systemValue);
1759                 reg.Flush();
1760         }
1761
1762         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ETC, systemValue);
1763         if(r != E_SUCCESS)
1764         {
1765                 bValue = false;
1766                 this->GetValue(_OPENGLES_TEXTUREFORMAT_ETC, bValue);
1767                 if(bValue == true)
1768                         systemValue = _SYSTEM_CACHING_TRUE;
1769                 else
1770                         systemValue = _SYSTEM_CACHING_FALSE;
1771
1772                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ETC, systemValue);
1773                 reg.Flush();
1774         }
1775
1776         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PTC, systemValue);
1777         if(r != E_SUCCESS)
1778         {
1779                 bValue = false;
1780                 this->GetValue(_OPENGLES_TEXTUREFORMAT_PTC, bValue);
1781                 if(bValue == true)
1782                         systemValue = _SYSTEM_CACHING_TRUE;
1783                 else
1784                         systemValue = _SYSTEM_CACHING_FALSE;
1785
1786                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PTC, systemValue);
1787                 reg.Flush();
1788         }
1789
1790         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PVRTC, systemValue);
1791         if(r != E_SUCCESS)
1792         {
1793                 bValue = false;
1794                 this->GetValue(_OPENGLES_TEXTUREFORMAT_PVRTC, bValue);
1795                 if(bValue == true)
1796                         systemValue = _SYSTEM_CACHING_TRUE;
1797                 else
1798                         systemValue = _SYSTEM_CACHING_FALSE;
1799
1800                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PVRTC, systemValue);
1801                 reg.Flush();
1802         }
1803
1804         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_UTC, systemValue);
1805         if(r != E_SUCCESS)
1806         {
1807                 bValue = false;
1808                 this->GetValue(_OPENGLES_TEXTUREFORMAT_UTC, bValue);
1809                 if(bValue == true)
1810                         systemValue = _SYSTEM_CACHING_TRUE;
1811                 else
1812                         systemValue = _SYSTEM_CACHING_FALSE;
1813
1814                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_UTC, systemValue);
1815                 reg.Flush();
1816         }
1817
1818         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_1_1, systemValue);
1819         if(r != E_SUCCESS)
1820         {
1821                 bValue = false;
1822                 this->GetValue(_OPENGLES_VERSION_1_1, bValue);
1823                 if(bValue == true)
1824                         systemValue = _SYSTEM_CACHING_TRUE;
1825                 else
1826                         systemValue = _SYSTEM_CACHING_FALSE;
1827
1828                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_1_1, systemValue);
1829                 reg.Flush();
1830         }
1831
1832         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_2_0, systemValue);
1833         if(r != E_SUCCESS)
1834         {
1835                 bValue = false;
1836                 this->GetValue(_OPENGLES_VERSION_2_0, bValue);
1837                 if(bValue == true)
1838                         systemValue = _SYSTEM_CACHING_TRUE;
1839                 else
1840                         systemValue = _SYSTEM_CACHING_FALSE;
1841
1842                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_2_0, systemValue);
1843                 reg.Flush();
1844         }
1845
1846         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV6, systemValue);
1847         if(r != E_SUCCESS)
1848         {
1849                 bValue = false;
1850                 this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV6, bValue);
1851                 if(bValue == true)
1852                         systemValue = _SYSTEM_CACHING_TRUE;
1853                 else
1854                         systemValue = _SYSTEM_CACHING_FALSE;
1855
1856                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV6, systemValue);
1857                 reg.Flush();
1858         }
1859
1860         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV7, systemValue);
1861         if(r != E_SUCCESS)
1862         {
1863                 bValue = false;
1864                 this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV7, bValue);
1865                 if(bValue == true)
1866                         systemValue = _SYSTEM_CACHING_TRUE;
1867                 else
1868                         systemValue = _SYSTEM_CACHING_FALSE;
1869
1870                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV7, systemValue);
1871                 reg.Flush();
1872         }
1873
1874         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_X86, systemValue);
1875         if(r != E_SUCCESS)
1876         {
1877                 bValue = false;
1878                 this->GetValue(_PLATFORM_CORE_CPU_ARCH_X86, bValue);
1879                 if(bValue == true)
1880                         systemValue = _SYSTEM_CACHING_TRUE;
1881                 else
1882                         systemValue = _SYSTEM_CACHING_FALSE;
1883
1884                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_X86, systemValue);
1885                 reg.Flush();
1886         }
1887
1888         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE2, systemValue);
1889         if(r != E_SUCCESS)
1890         {
1891                 bValue = false;
1892                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE2, bValue);
1893                 if(bValue == true)
1894                         systemValue = _SYSTEM_CACHING_TRUE;
1895                 else
1896                         systemValue = _SYSTEM_CACHING_FALSE;
1897
1898                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE2, systemValue);
1899                 reg.Flush();
1900         }
1901
1902         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE3, systemValue);
1903         if(r != E_SUCCESS)
1904         {
1905                 bValue = false;
1906                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE3, bValue);
1907                 if(bValue == true)
1908                         systemValue = _SYSTEM_CACHING_TRUE;
1909                 else
1910                         systemValue = _SYSTEM_CACHING_FALSE;
1911
1912                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE3, systemValue);
1913                 reg.Flush();
1914         }
1915
1916         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSSE3, systemValue);
1917         if(r != E_SUCCESS)
1918         {
1919                 bValue = false;
1920                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSSE3, bValue);
1921                 if(bValue == true)
1922                         systemValue = _SYSTEM_CACHING_TRUE;
1923                 else
1924                         systemValue = _SYSTEM_CACHING_FALSE;
1925
1926                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSSE3, systemValue);
1927                 reg.Flush();
1928         }
1929
1930         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV2, systemValue);
1931         if(r != E_SUCCESS)
1932         {
1933                 bValue = false;
1934                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV2, bValue);
1935                 if(bValue == true)
1936                         systemValue = _SYSTEM_CACHING_TRUE;
1937                 else
1938                         systemValue = _SYSTEM_CACHING_FALSE;
1939
1940                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV2, systemValue);
1941                 reg.Flush();
1942         }
1943
1944         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV3, systemValue);
1945         if(r != E_SUCCESS)
1946         {
1947                 bValue = false;
1948                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV3, bValue);
1949                 if(bValue == true)
1950                         systemValue = _SYSTEM_CACHING_TRUE;
1951                 else
1952                         systemValue = _SYSTEM_CACHING_FALSE;
1953
1954                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV3, systemValue);
1955                 reg.Flush();
1956         }
1957
1958         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_API_VERSION, sValue);
1959         if(r != E_SUCCESS)
1960         {
1961                 sValue.Clear();
1962                 this->GetValue(_PLATFORM_NATIVE_API_VERSION, sValue);
1963                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_API_VERSION, sValue);
1964                 reg.Flush();
1965         }
1966
1967         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_OSP_COMPATIBLE, systemValue);
1968         if(r != E_SUCCESS)
1969         {
1970                 bValue = false;
1971                 this->GetValue(_PLATFORM_NATIVE_OSP_COMPATIBLE, bValue);
1972                 if(bValue == true)
1973                         systemValue = _SYSTEM_CACHING_TRUE;
1974                 else
1975                         systemValue = _SYSTEM_CACHING_FALSE;
1976
1977                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_OSP_COMPATIBLE, systemValue);
1978                 reg.Flush();
1979         }
1980
1981         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_VERSION, sValue);
1982         if(r != E_SUCCESS)
1983         {
1984                 sValue.Clear();
1985                 this->GetValue(_PLATFORM_VERSION, sValue);
1986                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_VERSION, sValue);
1987                 reg.Flush();
1988         }
1989
1990         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_WEB_API_VERSION, sValue);
1991         if(r != E_SUCCESS)
1992         {
1993                 sValue.Clear();
1994                 this->GetValue(_PLATFORM_WEB_API_VERSION, sValue);
1995                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_WEB_API_VERSION, sValue);
1996                 reg.Flush();
1997         }
1998
1999         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_AUTO_ROTATION, systemValue);
2000         if(r != E_SUCCESS)
2001         {
2002                 bValue = false;
2003                 bValue = false;
2004                 this->GetValue(_SCREEN_AUTO_ROTATION, bValue);
2005                 if(bValue == true)
2006                         systemValue = _SYSTEM_CACHING_TRUE;
2007                 else
2008                         systemValue = _SYSTEM_CACHING_FALSE;
2009
2010                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_AUTO_ROTATION, systemValue);
2011                 reg.Flush();
2012         }
2013
2014         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_BPP, nValue);
2015         if(r != E_SUCCESS)
2016         {
2017                 nValue = 0;
2018                 this->GetValue(_SCREEN_BPP, nValue);
2019                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_BPP, nValue);
2020                 reg.Flush();
2021         }
2022
2023         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, systemValue);
2024         if(r != E_SUCCESS)
2025         {
2026                 bValue = false;
2027                 this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, bValue);
2028                 if(bValue == true)
2029                         systemValue = _SYSTEM_CACHING_TRUE;
2030                 else
2031                         systemValue = _SYSTEM_CACHING_FALSE;
2032
2033                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, systemValue);
2034                 reg.Flush();
2035         }
2036
2037         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, systemValue);
2038         if(r != E_SUCCESS)
2039         {
2040                 bValue = false;
2041                 this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, bValue);
2042                 if(bValue == true)
2043                         systemValue = _SYSTEM_CACHING_TRUE;
2044                 else
2045                         systemValue = _SYSTEM_CACHING_FALSE;
2046
2047                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, systemValue);
2048                 reg.Flush();
2049         }
2050
2051         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_DESKTOPMODE, systemValue);
2052         if(r != E_SUCCESS)
2053         {
2054                 bValue = false;
2055                 this->GetValue(_SCREEN_DESKTOPMODE, bValue);
2056                 if(bValue == true)
2057                         systemValue = _SYSTEM_CACHING_TRUE;
2058                 else
2059                         systemValue = _SYSTEM_CACHING_FALSE;
2060
2061                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DESKTOPMODE, systemValue);
2062                 reg.Flush();
2063         }
2064
2065         bValue = false;
2066         this->GetValue(_SCREEN_SIZE_LARGE, bValue);
2067         if(bValue == true)
2068                 systemValue = _SYSTEM_CACHING_TRUE;
2069         else
2070                 systemValue = _SYSTEM_CACHING_FALSE;
2071
2072         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_LARGE, systemValue) == E_KEY_ALREADY_EXIST)
2073         {
2074                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_LARGE, systemValue);
2075         }
2076         reg.Flush();
2077
2078         bValue = false;
2079         this->GetValue(_SCREEN_SIZE_NORMAL, bValue);
2080         if(bValue == true)
2081                 systemValue = _SYSTEM_CACHING_TRUE;
2082         else
2083                 systemValue = _SYSTEM_CACHING_FALSE;
2084
2085         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL, systemValue) == E_KEY_ALREADY_EXIST)
2086         {
2087                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL, systemValue);
2088         }
2089         reg.Flush();
2090
2091         bValue = false;
2092         this->GetValue(_SCREEN_SIZE_NORMAL_240_400, bValue);
2093         if(bValue == true)
2094                 systemValue = _SYSTEM_CACHING_TRUE;
2095         else
2096                 systemValue = _SYSTEM_CACHING_FALSE;
2097
2098         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_240_400, systemValue) == E_KEY_ALREADY_EXIST)
2099         {
2100                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_240_400, systemValue);
2101         }
2102         reg.Flush();
2103
2104         bValue = false;
2105         this->GetValue(_SCREEN_SIZE_NORMAL_320_480, bValue);
2106         if(bValue == true)
2107                 systemValue = _SYSTEM_CACHING_TRUE;
2108         else
2109                 systemValue = _SYSTEM_CACHING_FALSE;
2110
2111         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_320_480, systemValue) == E_KEY_ALREADY_EXIST)
2112         {
2113                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_320_480, systemValue);
2114         }
2115         reg.Flush();
2116
2117         bValue = false;
2118         this->GetValue(_SCREEN_SIZE_NORMAL_480_800, bValue);
2119         if(bValue == true)
2120                 systemValue = _SYSTEM_CACHING_TRUE;
2121         else
2122                 systemValue = _SYSTEM_CACHING_FALSE;
2123
2124         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_480_800, systemValue) == E_KEY_ALREADY_EXIST)
2125         {
2126                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_480_800, systemValue);
2127         }
2128         reg.Flush();
2129
2130         bValue = false;
2131         this->GetValue(_SCREEN_SIZE_NORMAL_540_960, bValue);
2132         if(bValue == true)
2133                 systemValue = _SYSTEM_CACHING_TRUE;
2134         else
2135                 systemValue = _SYSTEM_CACHING_FALSE;
2136
2137         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_540_960, systemValue) == E_KEY_ALREADY_EXIST)
2138         {
2139                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_540_960, systemValue);
2140         }
2141         reg.Flush();
2142
2143         bValue = false;
2144         this->GetValue(_SCREEN_SIZE_NORMAL_600_1024, bValue);
2145         if(bValue == true)
2146                 systemValue = _SYSTEM_CACHING_TRUE;
2147         else
2148                 systemValue = _SYSTEM_CACHING_FALSE;
2149
2150         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_600_1024, systemValue) == E_KEY_ALREADY_EXIST)
2151         {
2152                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_600_1024, systemValue);
2153         }
2154         reg.Flush();
2155
2156         bValue = false;
2157         this->GetValue(_SCREEN_SIZE_NORMAL_720_1280, bValue);
2158         if(bValue == true)
2159                 systemValue = _SYSTEM_CACHING_TRUE;
2160         else
2161                 systemValue = _SYSTEM_CACHING_FALSE;
2162
2163         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_720_1280, systemValue) == E_KEY_ALREADY_EXIST)
2164         {
2165                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_720_1280, systemValue);
2166         }
2167         reg.Flush();
2168
2169         bValue = false;
2170         this->GetValue(_SCREEN_SIZE_NORMAL_1080_1920, bValue);
2171         if(bValue == true)
2172                 systemValue = _SYSTEM_CACHING_TRUE;
2173         else
2174                 systemValue = _SYSTEM_CACHING_FALSE;
2175
2176         if(reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_1080_1920, systemValue) == E_KEY_ALREADY_EXIST)
2177         {
2178                 reg.SetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_1080_1920, systemValue);
2179         }
2180         reg.Flush();
2181
2182         bValue = false;
2183         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_HDMI, systemValue);
2184         if(r != E_SUCCESS)
2185         {
2186                 bValue = false;
2187                 this->GetValue(_SCREEN_OUTPUT_HDMI, bValue);
2188                 if(bValue == true)
2189                         systemValue = _SYSTEM_CACHING_TRUE;
2190                 else
2191                         systemValue = _SYSTEM_CACHING_FALSE;
2192
2193                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_HDMI, systemValue);
2194                 reg.Flush();
2195         }
2196
2197         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_RCA, systemValue);
2198         if(r != E_SUCCESS)
2199         {
2200                 bValue = false;
2201                 this->GetValue(_SCREEN_OUTPUT_RCA, bValue);
2202                 if(bValue == true)
2203                         systemValue = _SYSTEM_CACHING_TRUE;
2204                 else
2205                         systemValue = _SYSTEM_CACHING_FALSE;
2206
2207                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_RCA, systemValue);
2208                 reg.Flush();
2209         }
2210
2211         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SHELL_APPWIDGET, systemValue);
2212         if(r != E_SUCCESS)
2213         {
2214                 bValue = false;
2215                 this->GetValue(_SHELL_APPWIDGET, bValue);
2216                 if(bValue == true)
2217                         systemValue = _SYSTEM_CACHING_TRUE;
2218                 else
2219                         systemValue = _SYSTEM_CACHING_FALSE;
2220
2221                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SHELL_APPWIDGET, systemValue);
2222                 reg.Flush();
2223         }
2224
2225         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER, systemValue);
2226         if(r != E_SUCCESS)
2227         {
2228                 bValue = false;
2229                 this->GetValue(_SENSOR_ACCELEROMETER, bValue);
2230                 if(bValue == true)
2231                         systemValue = _SYSTEM_CACHING_TRUE;
2232                 else
2233                         systemValue = _SYSTEM_CACHING_FALSE;
2234
2235                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER, systemValue);
2236                 reg.Flush();
2237         }
2238
2239         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER_WAKEUP, systemValue);
2240         if(r != E_SUCCESS)
2241         {
2242                 bValue = false;
2243                 this->GetValue(_SENSOR_ACCELEROMETER_WAKEUP, bValue);
2244                 if(bValue == true)
2245                         systemValue = _SYSTEM_CACHING_TRUE;
2246                 else
2247                         systemValue = _SYSTEM_CACHING_FALSE;
2248
2249                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER_WAKEUP, systemValue);
2250                 reg.Flush();
2251         }
2252
2253         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER, systemValue);
2254         if(r != E_SUCCESS)
2255         {
2256                 bValue = false;
2257                 this->GetValue(_SENSOR_BAROMETER, bValue);
2258                 if(bValue == true)
2259                         systemValue = _SYSTEM_CACHING_TRUE;
2260                 else
2261                         systemValue = _SYSTEM_CACHING_FALSE;
2262
2263                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER, systemValue);
2264                 reg.Flush();
2265         }
2266
2267         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER_WAKEUP, systemValue);
2268         if(r != E_SUCCESS)
2269         {
2270                 bValue = false;
2271                 this->GetValue(_SENSOR_BAROMETER_WAKEUP, bValue);
2272                 if(bValue == true)
2273                         systemValue = _SYSTEM_CACHING_TRUE;
2274                 else
2275                         systemValue = _SYSTEM_CACHING_FALSE;
2276
2277                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER_WAKEUP, systemValue);
2278                 reg.Flush();
2279         }
2280
2281         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE, systemValue);
2282         if(r != E_SUCCESS)
2283         {
2284                 bValue = false;
2285                 this->GetValue(_SENSOR_GYROSCOPE, bValue);
2286                 if(bValue == true)
2287                         systemValue = _SYSTEM_CACHING_TRUE;
2288                 else
2289                         systemValue = _SYSTEM_CACHING_FALSE;
2290
2291                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE, systemValue);
2292                 reg.Flush();
2293         }
2294
2295         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE_WAKEUP, systemValue);
2296         if(r != E_SUCCESS)
2297         {
2298                 bValue = false;
2299                 this->GetValue(_SENSOR_GYROSCOPE_WAKEUP, bValue);
2300                 if(bValue == true)
2301                         systemValue = _SYSTEM_CACHING_TRUE;
2302                 else
2303                         systemValue = _SYSTEM_CACHING_FALSE;
2304
2305                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE_WAKEUP, systemValue);
2306                 reg.Flush();
2307         }
2308
2309         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER, systemValue);
2310         if(r != E_SUCCESS)
2311         {
2312                 bValue = false;
2313                 this->GetValue(_SENSOR_MAGNETOMETER, bValue);
2314                 if(bValue == true)
2315                         systemValue = _SYSTEM_CACHING_TRUE;
2316                 else
2317                         systemValue = _SYSTEM_CACHING_FALSE;
2318
2319                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER, systemValue);
2320                 reg.Flush();
2321         }
2322
2323         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER_WAKEUP, systemValue);
2324         if(r != E_SUCCESS)
2325         {
2326                 bValue = false;
2327                 this->GetValue(_SENSOR_MAGNETOMETER_WAKEUP, bValue);
2328                 if(bValue == true)
2329                         systemValue = _SYSTEM_CACHING_TRUE;
2330                 else
2331                         systemValue = _SYSTEM_CACHING_FALSE;
2332
2333                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER_WAKEUP, systemValue);
2334                 reg.Flush();
2335         }
2336
2337         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER, systemValue);
2338         if(r != E_SUCCESS)
2339         {
2340                 bValue = false;
2341                 this->GetValue(_SENSOR_PHOTOMETER, bValue);
2342                 if(bValue == true)
2343                         systemValue = _SYSTEM_CACHING_TRUE;
2344                 else
2345                         systemValue = _SYSTEM_CACHING_FALSE;
2346
2347                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER, systemValue);
2348                 reg.Flush();
2349         }
2350
2351         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER_WAKEUP, systemValue);
2352         if(r != E_SUCCESS)
2353         {
2354                 bValue = false;
2355                 this->GetValue(_SENSOR_PHOTOMETER_WAKEUP, bValue);
2356                 if(bValue == true)
2357                         systemValue = _SYSTEM_CACHING_TRUE;
2358                 else
2359                         systemValue = _SYSTEM_CACHING_FALSE;
2360
2361                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER_WAKEUP, systemValue);
2362                 reg.Flush();
2363         }
2364
2365         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY, systemValue);
2366         if(r != E_SUCCESS)
2367         {
2368                 bValue = false;
2369                 this->GetValue(_SENSOR_PROXIMITY, bValue);
2370                 if(bValue == true)
2371                         systemValue = _SYSTEM_CACHING_TRUE;
2372                 else
2373                         systemValue = _SYSTEM_CACHING_FALSE;
2374
2375                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY, systemValue);
2376                 reg.Flush();
2377         }
2378
2379         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY_WAKEUP, systemValue);
2380         if(r != E_SUCCESS)
2381         {
2382                 bValue = false;
2383                 this->GetValue(_SENSOR_PROXIMITY_WAKEUP, bValue);
2384                 if(bValue == true)
2385                         systemValue = _SYSTEM_CACHING_TRUE;
2386                 else
2387                         systemValue = _SYSTEM_CACHING_FALSE;
2388
2389                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY_WAKEUP, systemValue);
2390                 reg.Flush();
2391         }
2392
2393         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER, systemValue);
2394         if(r != E_SUCCESS)
2395         {
2396                 bValue = false;
2397                 this->GetValue(_SENSOR_TILTMETER, bValue);
2398                 if(bValue == true)
2399                         systemValue = _SYSTEM_CACHING_TRUE;
2400                 else
2401                         systemValue = _SYSTEM_CACHING_FALSE;
2402
2403                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER, systemValue);
2404                 reg.Flush();
2405         }
2406
2407         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER_WAKEUP, systemValue);
2408         if(r != E_SUCCESS)
2409         {
2410                 bValue = false;
2411                 this->GetValue(_SENSOR_TILTMETER_WAKEUP, bValue);
2412                 if(bValue == true)
2413                         systemValue = _SYSTEM_CACHING_TRUE;
2414                 else
2415                         systemValue = _SYSTEM_CACHING_FALSE;
2416
2417                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER_WAKEUP, systemValue);
2418                 reg.Flush();
2419         }
2420
2421         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SIP_VOIP, systemValue);
2422         if(r != E_SUCCESS)
2423         {
2424                 bValue = false;
2425                 this->GetValue(_SIP_VOIP, bValue);
2426                 if(bValue == true)
2427                         systemValue = _SYSTEM_CACHING_TRUE;
2428                 else
2429                         systemValue = _SYSTEM_CACHING_FALSE;
2430
2431                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SIP_VOIP, systemValue);
2432                 reg.Flush();
2433         }
2434
2435         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SPEECH_RECOGNITION, systemValue);
2436         if(r != E_SUCCESS)
2437         {
2438                 bValue = false;
2439                 this->GetValue(_SPEECH_RECOGNITION, bValue);
2440                 if(bValue == true)
2441                         systemValue = _SYSTEM_CACHING_TRUE;
2442                 else
2443                         systemValue = _SYSTEM_CACHING_FALSE;
2444
2445                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_RECOGNITION, systemValue);
2446                 reg.Flush();
2447         }
2448
2449         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SPEECH_SYNTHESIS, systemValue);
2450         if(r != E_SUCCESS)
2451         {
2452                 bValue = false;
2453                 this->GetValue(_SPEECH_SYNTHESIS, bValue);
2454                 if(bValue == true)
2455                         systemValue = _SYSTEM_CACHING_TRUE;
2456                 else
2457                         systemValue = _SYSTEM_CACHING_FALSE;
2458
2459                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_SYNTHESIS, systemValue);
2460                 reg.Flush();
2461         }
2462
2463         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _USB_ACCESSORY, systemValue);
2464         if(r != E_SUCCESS)
2465         {
2466                 bValue = false;
2467                 this->GetValue(_USB_ACCESSORY, bValue);
2468                 if(bValue == true)
2469                         systemValue = _SYSTEM_CACHING_TRUE;
2470                 else
2471                         systemValue = _SYSTEM_CACHING_FALSE;
2472
2473                 reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_ACCESSORY, systemValue);
2474                 reg.Flush();
2475         }
2476
2477         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _USB_CLIENT, systemValue);
2478         if(r != E_SUCCESS)
2479         {
2480                 bValue = false;
2481                 this->GetValue(_USB_CLIENT, bValue);
2482                 if(bValue == true)
2483                         systemValue = _SYSTEM_CACHING_TRUE;
2484                 else
2485                         systemValue = _SYSTEM_CACHING_FALSE;
2486
2487                 reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_CLIENT, systemValue);
2488                 reg.Flush();
2489         }
2490
2491         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _USB_HOST, systemValue);
2492         if(r != E_SUCCESS)
2493         {
2494                 bValue = false;
2495                 this->GetValue(_USB_HOST, bValue);
2496                 if(bValue == true)
2497                         systemValue = _SYSTEM_CACHING_TRUE;
2498                 else
2499                         systemValue = _SYSTEM_CACHING_FALSE;
2500
2501                 reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_HOST, systemValue);
2502                 reg.Flush();
2503         }
2504
2505         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_FACE_RECOGNITION, systemValue);
2506         if(r != E_SUCCESS)
2507         {
2508                 bValue = false;
2509                 this->GetValue(_VISION_FACE_RECOGNITION, bValue);
2510                 if(bValue == true)
2511                         systemValue = _SYSTEM_CACHING_TRUE;
2512                 else
2513                         systemValue = _SYSTEM_CACHING_FALSE;
2514
2515                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_FACE_RECOGNITION, systemValue);
2516                 reg.Flush();
2517         }
2518
2519         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_IMAGE_RECOGNITION, systemValue);
2520         if(r != E_SUCCESS)
2521         {
2522                 bValue = false;
2523                 this->GetValue(_VISION_IMAGE_RECOGNITION, bValue);
2524                 if(bValue == true)
2525                         systemValue = _SYSTEM_CACHING_TRUE;
2526                 else
2527                         systemValue = _SYSTEM_CACHING_FALSE;
2528
2529                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_IMAGE_RECOGNITION, systemValue);
2530                 reg.Flush();
2531         }
2532
2533         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_GENERATION, systemValue);
2534         if(r != E_SUCCESS)
2535         {
2536                 bValue = false;
2537                 this->GetValue(_VISION_QRCODE_GENERATION, bValue);
2538                 if(bValue == true)
2539                         systemValue = _SYSTEM_CACHING_TRUE;
2540                 else
2541                         systemValue = _SYSTEM_CACHING_FALSE;
2542
2543                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_GENERATION, systemValue);
2544                 reg.Flush();
2545         }
2546
2547         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_RECOGNITION, systemValue);
2548         if(r != E_SUCCESS)
2549         {
2550                 bValue = false;
2551                 this->GetValue(_VISION_QRCODE_RECOGNITION, bValue);
2552                 if(bValue == true)
2553                         systemValue = _SYSTEM_CACHING_TRUE;
2554                 else
2555                         systemValue = _SYSTEM_CACHING_FALSE;
2556
2557                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_RECOGNITION, systemValue);
2558                 reg.Flush();
2559         }
2560
2561         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _BUILD_STRING, sValue);
2562         if(r != E_SUCCESS)
2563         {
2564                 sValue.Clear();
2565                 this->GetValue(_BUILD_STRING, sValue);
2566                 reg.Flush();
2567                 reg.AddValue(_SYSTEM_CACHING_SECTION, _BUILD_STRING, sValue);
2568                 reg.Flush();
2569         }
2570
2571         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _DUID, sValue);
2572         if(r != E_SUCCESS)
2573         {
2574                 sValue.Clear();
2575                 r = this->GetValue(_DUID, sValue);
2576                 if(r != E_SUCCESS)
2577                 {
2578                         sValue.Append(L"ERROR");
2579                 }
2580
2581                 reg.AddValue(_SYSTEM_CACHING_SECTION, _DUID, sValue);
2582                 reg.Flush();
2583         }
2584
2585         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MODELNAME, sValue);
2586         if(r != E_SUCCESS)
2587         {
2588                 sValue.Clear();
2589                 this->GetValue(_MODELNAME, sValue);
2590                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MODELNAME, sValue);
2591                 reg.Flush();
2592         }
2593
2594         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NAME, sValue);
2595         if(r != E_SUCCESS)
2596         {
2597                 sValue.Clear();
2598                 this->GetValue(_PLATFORM_NAME, sValue);
2599                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NAME, sValue);
2600                 reg.Flush();
2601         }
2602
2603         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_MEDIA_VOLUME_MAX, nValue);
2604         if(r != E_SUCCESS)
2605         {
2606                 nValue = 0;
2607                 this->GetValue(_SOUND_MEDIA_VOLUME_MAX, nValue);
2608                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_MEDIA_VOLUME_MAX, nValue);
2609                 reg.Flush();
2610         }
2611
2612         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_NOTIFICATION_VOLUME_MAX, nValue);
2613         if(r != E_SUCCESS)
2614         {
2615                 nValue = 0;
2616                 this->GetValue(_SOUND_NOTIFICATION_VOLUME_MAX, nValue);
2617                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_NOTIFICATION_VOLUME_MAX, nValue);
2618                 reg.Flush();
2619         }
2620
2621         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_RINGTONE_VOLUME_MAX, nValue);
2622         if(r != E_SUCCESS)
2623         {
2624                 nValue = 0;
2625                 this->GetValue(_SOUND_RINGTONE_VOLUME_MAX, nValue);
2626                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_RINGTONE_VOLUME_MAX, nValue);
2627                 reg.Flush();
2628         }
2629
2630         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_SYSTEM_VOLUME_MAX, nValue);
2631         if(r != E_SUCCESS)
2632         {
2633                 nValue = 0;
2634                 this->GetValue(_SOUND_SYSTEM_VOLUME_MAX, nValue);
2635                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_SYSTEM_VOLUME_MAX, nValue);
2636                 reg.Flush();
2637         }
2638
2639         return E_SUCCESS;
2640 }
2641
2642 result
2643 _SystemInfoService::CachingSystemInformation(void)
2644 {
2645         result r = E_SUCCESS;
2646
2647         if(File::IsFileExist(_SYSTEM_CACHING_FILE) == false)
2648         {
2649                 r = CreateCacheFile();
2650         }
2651         else
2652         {
2653                 FileAttributes attr;
2654                 File::GetAttributes(_SYSTEM_CACHING_FILE, attr);
2655                 if(attr.GetFileSize() == 0)
2656                 {
2657                         r = CreateCacheFile();
2658                 }
2659                 else
2660                 {
2661                         r = UpdateCacheFile();
2662                 }
2663         }
2664
2665         return r;
2666 }
2667
2668 result
2669 _SystemInfoService::GetValue(const String& key, String& value)
2670 {
2671         int ret = 0;
2672         result r = E_SUCCESS;
2673         char* pValue = null;
2674
2675         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
2676         if (key == _DUID)
2677         {
2678                 bool supported = false;
2679                 SysLog(NID_SYS, "It trys to get DUID from telephony.");
2680                 this->GetValue(_NETWORK_TELEPHONY, supported);
2681                 if(supported == true)
2682                 {
2683                         r = _DeviceId::GetId(value, 0);
2684                 }
2685                 else
2686                 {
2687                         SysLog(NID_SYS, "It trys to get DUID from wifi.");
2688                         this->GetValue(_NETWORK_WIFI, supported);
2689                         if(supported == true)
2690                         {
2691                                 r = _DeviceId::GetId(value, 1);
2692                         }
2693                         else
2694                         {
2695                                 SysLog(NID_SYS, "It trys to get DUID from bluetooth.");
2696                                 this->GetValue(_NETWORK_BLUETOOTH, supported);
2697                                 if(supported == true)
2698                                 {
2699                                         r = _DeviceId::GetId(value, 2);
2700                                 }
2701                                 else
2702                                 {
2703                                         SysLogException(NID_SYS, E_SYSTEM, "It is failed to get telephony, wifi, bluetooth information.");
2704                                         return E_SYSTEM;
2705                                 }
2706                         }
2707                 }
2708                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the key[%ls]", key.GetPointer());
2709         }
2710         else if (key == _MODELNAME)
2711         {
2712                 ret = system_info_get_value_string(SYSTEM_INFO_KEY_MODEL, &pValue);
2713                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE && pValue, E_SYSTEM, "It is failed to get the SYSTEM_INFO_KEY_MODEL");
2714
2715                 r = StringUtil::Utf8ToString(pValue, value);
2716                 SysTryCatch(NID_SYS, r == E_SUCCESS, r = E_SYSTEM, r, "[%s] StringUtil::Utf8ToString It is failed", GetErrorMessage(r));
2717         }
2718         else if (key == _BUILD_STRING)
2719         {
2720                 ret = system_info_get_value_string(SYSTEM_INFO_KEY_BUILD_STRING, &pValue);
2721                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE, E_SYSTEM, "[E_SYSTEM] system_info_get_value_string : \"SYSTEM_INFO_KEY_TIZEN_VERSION_STRING\"It is failed");
2722
2723                 r = StringUtil::Utf8ToString(pValue, value);
2724                 SysTryCatch(NID_SYS, r == E_SUCCESS, r = E_SYSTEM, r, "[%s] StringUtil::Utf8ToString It is failed", GetErrorMessage(r));
2725         }
2726         else
2727         {
2728                 String tizenKey;
2729                 key.SubString(7, tizenKey);
2730
2731                 ClearLastResult();
2732                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tizenKey));
2733                 r = GetLastResult();
2734                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
2735                 int ret = system_info_get_platform_string(systemKey.get(), &pValue);
2736
2737                 SysTryReturnResult(NID_SYS, ret == 0, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from the configuration file", key.GetPointer());
2738
2739                 r = StringUtil::Utf8ToString(pValue, value);
2740                 free(pValue);
2741                 pValue = null;
2742
2743                 return r;
2744         }
2745
2746 CATCH:
2747         if(pValue != null)
2748         {
2749                 free(pValue);
2750         }
2751
2752         return r;
2753
2754 }
2755
2756 result
2757 _SystemInfoService::GetValue(const String& key, int& value)
2758 {
2759         int ret = 0;
2760         result r = E_SUCCESS;
2761
2762         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
2763
2764         String tizenKey;
2765         key.SubString(7, tizenKey);
2766
2767         ClearLastResult();
2768         unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tizenKey));
2769         r = GetLastResult();
2770         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
2771         ret = system_info_get_platform_int(systemKey.get(), &value);
2772
2773         SysTryReturnResult(NID_SYS, ret == 0, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", key.GetPointer());
2774         r = E_SUCCESS;
2775
2776         return r;
2777 }
2778
2779 result
2780 _SystemInfoService::GetValue(const String& key, bool& value)
2781 {
2782         int ret = 0;
2783         result r = E_SUCCESS;
2784
2785         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
2786
2787         if (key == _SCREEN_DESKTOPMODE)
2788         {
2789                 value = false;
2790         }
2791         else if (key == _USB_CLIENT)
2792         {
2793                 value = true;
2794         }
2795         else
2796         {
2797                 String tizenKey;
2798                 key.SubString(7, tizenKey);
2799
2800                 ClearLastResult();
2801                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tizenKey));
2802                 r = GetLastResult();
2803                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
2804
2805                 bool supported = false;
2806                 ret = system_info_get_platform_bool(systemKey.get(), &supported);
2807                 SysTryReturnResult(NID_SYS, ret == 0, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", key.GetPointer());
2808                 value = supported;
2809         }
2810
2811         return E_SUCCESS;
2812 }
2813 } } // Tizen::System