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         this->GetValue(_SCREEN_DPI, nValue);
 265         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DPI, nValue);
 266         reg.Flush();
 267
 268         this->GetValue(_SCREEN_HEIGHT, nValue);
 269         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_HEIGHT, nValue);
 270         reg.Flush();
 271
 272         this->GetValue(_SCREEN_WIDTH, nValue);
 273         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_WIDTH, nValue);
 274         reg.Flush();
 275
 276         this->GetValue(_CAMERA, bValue);
 277         if(bValue == true)
 278                 systemValue = _SYSTEM_CACHING_TRUE;
 279         else
 280                 systemValue = _SYSTEM_CACHING_FALSE;
 281         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA, systemValue);
 282         reg.Flush();
 283
 284         this->GetValue(_CAMERA_BACK, bValue);
 285         if(bValue == true)
 286                 systemValue = _SYSTEM_CACHING_TRUE;
 287         else
 288                 systemValue = _SYSTEM_CACHING_FALSE;
 289         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK, systemValue);
 290         reg.Flush();
 291
 292         this->GetValue(_CAMERA_BACK_FLASH, bValue);
 293         if(bValue == true)
 294                 systemValue = _SYSTEM_CACHING_TRUE;
 295         else
 296                 systemValue = _SYSTEM_CACHING_FALSE;
 297         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK_FLASH, systemValue);
 298         reg.Flush();
 299
 300         this->GetValue(_CAMERA_FRONT, bValue);
 301         if(bValue == true)
 302                 systemValue = _SYSTEM_CACHING_TRUE;
 303         else
 304                 systemValue = _SYSTEM_CACHING_FALSE;
 305         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT, systemValue);
 306         reg.Flush();
 307
 308         this->GetValue(_CAMERA_FRONT_FLASH, bValue);
 309         if(bValue == true)
 310                 systemValue = _SYSTEM_CACHING_TRUE;
 311         else
 312                 systemValue = _SYSTEM_CACHING_FALSE;
 313         reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT_FLASH, systemValue);
 314         reg.Flush();
 315
 316         this->GetValue(_DATABASE_ENCRYPTION, bValue);
 317         if(bValue == true)
 318                 systemValue = _SYSTEM_CACHING_TRUE;
 319         else
 320                 systemValue = _SYSTEM_CACHING_FALSE;
 321         reg.AddValue(_SYSTEM_CACHING_SECTION, _DATABASE_ENCRYPTION, systemValue);
 322         reg.Flush();
 323
 324         this->GetValue(_FMRADIO, bValue);
 325         if(bValue == true)
 326                 systemValue = _SYSTEM_CACHING_TRUE;
 327         else
 328                 systemValue = _SYSTEM_CACHING_FALSE;
 329         reg.AddValue(_SYSTEM_CACHING_SECTION, _FMRADIO, systemValue);
 330         reg.Flush();
 331
 332         this->GetValue(_GRAPHIC_ACCELERATION, bValue);
 333         if(bValue == true)
 334                 systemValue = _SYSTEM_CACHING_TRUE;
 335         else
 336                 systemValue = _SYSTEM_CACHING_FALSE;
 337         reg.AddValue(_SYSTEM_CACHING_SECTION, _GRAPHIC_ACCELERATION, systemValue);
 338         reg.Flush();
 339
 340         this->GetValue(_INPUT_KEYBOARD, bValue);
 341         if(bValue == true)
 342                 systemValue = _SYSTEM_CACHING_TRUE;
 343         else
 344                 systemValue = _SYSTEM_CACHING_FALSE;
 345         reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD, systemValue);
 346         reg.Flush();
 347
 348         this->GetValue(_INPUT_KEYBOARD_LAYOUT, sValue);
 349         reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD_LAYOUT, sValue);
 350         reg.Flush();
 351
 352         this->GetValue(_LOCATION, bValue);
 353         if(bValue == true)
 354                 systemValue = _SYSTEM_CACHING_TRUE;
 355         else
 356                 systemValue = _SYSTEM_CACHING_FALSE;
 357         reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION, systemValue);
 358         reg.Flush();
 359
 360         this->GetValue(_LOCATION_GPS, bValue);
 361         if(bValue == true)
 362                 systemValue = _SYSTEM_CACHING_TRUE;
 363         else
 364                 systemValue = _SYSTEM_CACHING_FALSE;
 365         reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_GPS, systemValue);
 366         reg.Flush();
 367
 368         this->GetValue(_LOCATION_WPS, bValue);
 369         if(bValue == true)
 370                 systemValue = _SYSTEM_CACHING_TRUE;
 371         else
 372                 systemValue = _SYSTEM_CACHING_FALSE;
 373         reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_WPS, systemValue);
 374         reg.Flush();
 375
 376         this->GetValue(_MICROPHONE, bValue);
 377         if(bValue == true)
 378                 systemValue = _SYSTEM_CACHING_TRUE;
 379         else
 380                 systemValue = _SYSTEM_CACHING_FALSE;
 381         reg.AddValue(_SYSTEM_CACHING_SECTION, _MICROPHONE, systemValue);
 382         reg.Flush();
 383
 384         this->GetValue(_MULTIPOINTTOUCH_PINCHZOOM, bValue);
 385         if(bValue == true)
 386                 systemValue = _SYSTEM_CACHING_TRUE;
 387         else
 388                 systemValue = _SYSTEM_CACHING_FALSE;
 389         reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_PINCHZOOM, systemValue);
 390         reg.Flush();
 391
 392         this->GetValue(_MULTIPOINTTOUCH_POINTCOUNT, nValue);
 393         reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
 394         reg.Flush();
 395
 396         this->GetValue(_NETWORK_BLUETOOTH, bValue);
 397         if(bValue == true)
 398                 systemValue = _SYSTEM_CACHING_TRUE;
 399         else
 400                 systemValue = _SYSTEM_CACHING_FALSE;
 401         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_BLUETOOTH, systemValue);
 402         reg.Flush();
 403
 404         this->GetValue(_NETWORK_NFC, bValue);
 405         if(bValue == true)
 406                 systemValue = _SYSTEM_CACHING_TRUE;
 407         else
 408                 systemValue = _SYSTEM_CACHING_FALSE;
 409         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC, systemValue);
 410         reg.Flush();
 411
 412         this->GetValue(_NETWORK_NFC_RESERVED_PUSH, bValue);
 413         if(bValue == true)
 414                 systemValue = _SYSTEM_CACHING_TRUE;
 415         else
 416                 systemValue = _SYSTEM_CACHING_FALSE;
 417         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC_RESERVED_PUSH, systemValue);
 418         reg.Flush();
 419
 420         this->GetValue(_NETWORK_PUSH, bValue);
 421         if(bValue == true)
 422                 systemValue = _SYSTEM_CACHING_TRUE;
 423         else
 424                 systemValue = _SYSTEM_CACHING_FALSE;
 425         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_PUSH, systemValue);
 426         reg.Flush();
 427
 428         this->GetValue(_NETWORK_SECURE_ELEMENT, bValue);
 429         if(bValue == true)
 430                 systemValue = _SYSTEM_CACHING_TRUE;
 431         else
 432                 systemValue = _SYSTEM_CACHING_FALSE;
 433         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_SECURE_ELEMENT, systemValue);
 434         reg.Flush();
 435
 436         this->GetValue(_NETWORK_TELEPHONY, bValue);
 437         if(bValue == true)
 438                 systemValue = _SYSTEM_CACHING_TRUE;
 439         else
 440                 systemValue = _SYSTEM_CACHING_FALSE;
 441         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY, systemValue);
 442         reg.Flush();
 443
 444         this->GetValue(_NETWORK_TELEPHONY_MMS, bValue);
 445         if(bValue == true)
 446                 systemValue = _SYSTEM_CACHING_TRUE;
 447         else
 448                 systemValue = _SYSTEM_CACHING_FALSE;
 449         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_MMS, systemValue);
 450         reg.Flush();
 451
 452         this->GetValue(_NETWORK_TELEPHONY_SMS, bValue);
 453         if(bValue == true)
 454                 systemValue = _SYSTEM_CACHING_TRUE;
 455         else
 456                 systemValue = _SYSTEM_CACHING_FALSE;
 457         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS, systemValue);
 458         reg.Flush();
 459
 460         this->GetValue(_NETWORK_TELEPHONY_SMS_CBS, bValue);
 461         if(bValue == true)
 462                 systemValue = _SYSTEM_CACHING_TRUE;
 463         else
 464                 systemValue = _SYSTEM_CACHING_FALSE;
 465         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS_CBS, systemValue);
 466         reg.Flush();
 467
 468         this->GetValue(_NETWORK_TELEPHONY_SERVICE_CDMA, bValue);
 469         if(bValue == true)
 470                 systemValue = _SYSTEM_CACHING_TRUE;
 471         else
 472                 systemValue = _SYSTEM_CACHING_FALSE;
 473         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_CDMA, systemValue);
 474         reg.Flush();
 475
 476         this->GetValue(_NETWORK_TELEPHONY_SERVICE_EDGE, 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_SERVICE_EDGE, systemValue);
 482         reg.Flush();
 483
 484         this->GetValue(_NETWORK_TELEPHONY_SERVICE_GPRS, bValue);
 485         if(bValue == true)
 486                 systemValue = _SYSTEM_CACHING_TRUE;
 487         else
 488                 systemValue = _SYSTEM_CACHING_FALSE;
 489         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GPRS, systemValue);
 490         reg.Flush();
 491
 492         this->GetValue(_NETWORK_TELEPHONY_SERVICE_GSM, bValue);
 493         if(bValue == true)
 494                 systemValue = _SYSTEM_CACHING_TRUE;
 495         else
 496                 systemValue = _SYSTEM_CACHING_FALSE;
 497         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GSM, systemValue);
 498         reg.Flush();
 499
 500         this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSDPA, bValue);
 501         if(bValue == true)
 502                 systemValue = _SYSTEM_CACHING_TRUE;
 503         else
 504                 systemValue = _SYSTEM_CACHING_FALSE;
 505         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSDPA, systemValue);
 506         reg.Flush();
 507
 508         this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSPA, bValue);
 509         if(bValue == true)
 510                 systemValue = _SYSTEM_CACHING_TRUE;
 511         else
 512                 systemValue = _SYSTEM_CACHING_FALSE;
 513         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSPA, systemValue);
 514         reg.Flush();
 515
 516         this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSUPA, bValue);
 517         if(bValue == true)
 518                 systemValue = _SYSTEM_CACHING_TRUE;
 519         else
 520                 systemValue = _SYSTEM_CACHING_FALSE;
 521         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSUPA, systemValue);
 522         reg.Flush();
 523
 524         this->GetValue(_NETWORK_TELEPHONY_SERVICE_LTE, bValue);
 525         if(bValue == true)
 526                 systemValue = _SYSTEM_CACHING_TRUE;
 527         else
 528                 systemValue = _SYSTEM_CACHING_FALSE;
 529         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_LTE, systemValue);
 530         reg.Flush();
 531
 532         this->GetValue(_NETWORK_TELEPHONY_SERVICE_UMTS, bValue);
 533         if(bValue == true)
 534                 systemValue = _SYSTEM_CACHING_TRUE;
 535         else
 536                 systemValue = _SYSTEM_CACHING_FALSE;
 537         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_UMTS, systemValue);
 538         reg.Flush();
 539
 540         this->GetValue(_NETWORK_WIFI, bValue);
 541         if(bValue == true)
 542                 systemValue = _SYSTEM_CACHING_TRUE;
 543         else
 544                 systemValue = _SYSTEM_CACHING_FALSE;
 545         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI, systemValue);
 546         reg.Flush();
 547
 548         this->GetValue(_NETWORK_WIFI_DIRECT, bValue);
 549         if(bValue == true)
 550                 systemValue = _SYSTEM_CACHING_TRUE;
 551         else
 552                 systemValue = _SYSTEM_CACHING_FALSE;
 553         reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI_DIRECT, systemValue);
 554         reg.Flush();
 555
 556         this->GetValue(_OPENGLES, bValue);
 557         if(bValue == true)
 558                 systemValue = _SYSTEM_CACHING_TRUE;
 559         else
 560                 systemValue = _SYSTEM_CACHING_FALSE;
 561         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES, systemValue);
 562         reg.Flush();
 563
 564         this->GetValue(_OPENGLES_TEXTUREFORMAT_3DC, bValue);
 565         if(bValue == true)
 566                 systemValue = _SYSTEM_CACHING_TRUE;
 567         else
 568                 systemValue = _SYSTEM_CACHING_FALSE;
 569         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_3DC, systemValue);
 570         reg.Flush();
 571
 572         this->GetValue(_OPENGLES_TEXTUREFORMAT_ATC, bValue);
 573         if(bValue == true)
 574                 systemValue = _SYSTEM_CACHING_TRUE;
 575         else
 576                 systemValue = _SYSTEM_CACHING_FALSE;
 577         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ATC, systemValue);
 578         reg.Flush();
 579
 580         this->GetValue(_OPENGLES_TEXTUREFORMAT_ETC, bValue);
 581         if(bValue == true)
 582                 systemValue = _SYSTEM_CACHING_TRUE;
 583         else
 584                 systemValue = _SYSTEM_CACHING_FALSE;
 585         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ETC, systemValue);
 586         reg.Flush();
 587
 588         this->GetValue(_OPENGLES_TEXTUREFORMAT_PTC, bValue);
 589         if(bValue == true)
 590                 systemValue = _SYSTEM_CACHING_TRUE;
 591         else
 592                 systemValue = _SYSTEM_CACHING_FALSE;
 593         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PTC, systemValue);
 594         reg.Flush();
 595
 596         this->GetValue(_OPENGLES_TEXTUREFORMAT_PVRTC, bValue);
 597         if(bValue == true)
 598                 systemValue = _SYSTEM_CACHING_TRUE;
 599         else
 600                 systemValue = _SYSTEM_CACHING_FALSE;
 601         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PVRTC, systemValue);
 602         reg.Flush();
 603
 604         this->GetValue(_OPENGLES_TEXTUREFORMAT_UTC, bValue);
 605         if(bValue == true)
 606                 systemValue = _SYSTEM_CACHING_TRUE;
 607         else
 608                 systemValue = _SYSTEM_CACHING_FALSE;
 609         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_UTC, systemValue);
 610         reg.Flush();
 611
 612         this->GetValue(_OPENGLES_VERSION_1_1, bValue);
 613         if(bValue == true)
 614                 systemValue = _SYSTEM_CACHING_TRUE;
 615         else
 616                 systemValue = _SYSTEM_CACHING_FALSE;
 617         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_1_1, systemValue);
 618         reg.Flush();
 619
 620         this->GetValue(_OPENGLES_VERSION_2_0, bValue);
 621         if(bValue == true)
 622                 systemValue = _SYSTEM_CACHING_TRUE;
 623         else
 624                 systemValue = _SYSTEM_CACHING_FALSE;
 625         reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_2_0, systemValue);
 626         reg.Flush();
 627
 628         this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV6, bValue);
 629         if(bValue == true)
 630                 systemValue = _SYSTEM_CACHING_TRUE;
 631         else
 632                 systemValue = _SYSTEM_CACHING_FALSE;
 633         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV6, systemValue);
 634         reg.Flush();
 635
 636         this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV7, bValue);
 637         if(bValue == true)
 638                 systemValue = _SYSTEM_CACHING_TRUE;
 639         else
 640                 systemValue = _SYSTEM_CACHING_FALSE;
 641         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV7, systemValue);
 642         reg.Flush();
 643
 644         this->GetValue(_PLATFORM_CORE_CPU_ARCH_X86, bValue);
 645         if(bValue == true)
 646                 systemValue = _SYSTEM_CACHING_TRUE;
 647         else
 648                 systemValue = _SYSTEM_CACHING_FALSE;
 649         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_X86, systemValue);
 650         reg.Flush();
 651
 652         this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE2, bValue);
 653         if(bValue == true)
 654                 systemValue = _SYSTEM_CACHING_TRUE;
 655         else
 656                 systemValue = _SYSTEM_CACHING_FALSE;
 657         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE2, systemValue);
 658         reg.Flush();
 659
 660         this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE3, bValue);
 661         if(bValue == true)
 662                 systemValue = _SYSTEM_CACHING_TRUE;
 663         else
 664                 systemValue = _SYSTEM_CACHING_FALSE;
 665         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE3, systemValue);
 666         reg.Flush();
 667
 668         this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSSE3, bValue);
 669         if(bValue == true)
 670                 systemValue = _SYSTEM_CACHING_TRUE;
 671         else
 672                 systemValue = _SYSTEM_CACHING_FALSE;
 673         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSSE3, systemValue);
 674         reg.Flush();
 675
 676         this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV2, bValue);
 677         if(bValue == true)
 678                 systemValue = _SYSTEM_CACHING_TRUE;
 679         else
 680                 systemValue = _SYSTEM_CACHING_FALSE;
 681         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV2, systemValue);
 682         reg.Flush();
 683
 684         this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV3, bValue);
 685         if(bValue == true)
 686                 systemValue = _SYSTEM_CACHING_TRUE;
 687         else
 688                 systemValue = _SYSTEM_CACHING_FALSE;
 689         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV3, systemValue);
 690         reg.Flush();
 691
 692         this->GetValue(_PLATFORM_NATIVE_API_VERSION, sValue);
 693         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_API_VERSION, sValue);
 694         reg.Flush();
 695
 696         this->GetValue(_PLATFORM_NATIVE_OSP_COMPATIBLE, bValue);
 697         if(bValue == true)
 698                 systemValue = _SYSTEM_CACHING_TRUE;
 699         else
 700                 systemValue = _SYSTEM_CACHING_FALSE;
 701         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_OSP_COMPATIBLE, systemValue);
 702         reg.Flush();
 703
 704         this->GetValue(_PLATFORM_VERSION, sValue);
 705         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_VERSION, sValue);
 706         reg.Flush();
 707
 708         this->GetValue(_PLATFORM_WEB_API_VERSION, sValue);
 709         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_WEB_API_VERSION, sValue);
 710         reg.Flush();
 711
 712         this->GetValue(_SCREEN_AUTO_ROTATION, bValue);
 713         if(bValue == true)
 714                 systemValue = _SYSTEM_CACHING_TRUE;
 715         else
 716                 systemValue = _SYSTEM_CACHING_FALSE;
 717         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_AUTO_ROTATION, systemValue);
 718         reg.Flush();
 719
 720         this->GetValue(_SCREEN_BPP, nValue);
 721         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_BPP, nValue);
 722         reg.Flush();
 723
 724         this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, bValue);
 725         if(bValue == true)
 726                 systemValue = _SYSTEM_CACHING_TRUE;
 727         else
 728                 systemValue = _SYSTEM_CACHING_FALSE;
 729         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, systemValue);
 730         reg.Flush();
 731
 732         this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, bValue);
 733         if(bValue == true)
 734                 systemValue = _SYSTEM_CACHING_TRUE;
 735         else
 736                 systemValue = _SYSTEM_CACHING_FALSE;
 737         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, systemValue);
 738         reg.Flush();
 739
 740         this->GetValue(_SCREEN_DESKTOPMODE, bValue);
 741         if(bValue == true)
 742                 systemValue = _SYSTEM_CACHING_TRUE;
 743         else
 744                 systemValue = _SYSTEM_CACHING_FALSE;
 745         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DESKTOPMODE, systemValue);
 746         reg.Flush();
 747
 748         this->GetValue(_SCREEN_SIZE_LARGE, bValue);
 749         if(bValue == true)
 750                 systemValue = _SYSTEM_CACHING_TRUE;
 751         else
 752                 systemValue = _SYSTEM_CACHING_FALSE;
 753         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_LARGE, systemValue);
 754         reg.Flush();
 755
 756         this->GetValue(_SCREEN_SIZE_NORMAL, bValue);
 757         if(bValue == true)
 758                 systemValue = _SYSTEM_CACHING_TRUE;
 759         else
 760                 systemValue = _SYSTEM_CACHING_FALSE;
 761         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL, systemValue);
 762         reg.Flush();
 763
 764
 765         this->GetValue(_SCREEN_SIZE_NORMAL_240_400, bValue);
 766         if(bValue == true)
 767                 systemValue = _SYSTEM_CACHING_TRUE;
 768         else
 769                 systemValue = _SYSTEM_CACHING_FALSE;
 770
 771         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_240_400, systemValue);
 772         reg.Flush();
 773
 774         this->GetValue(_SCREEN_SIZE_NORMAL_320_480, bValue);
 775         if(bValue == true)
 776                 systemValue = _SYSTEM_CACHING_TRUE;
 777         else
 778                 systemValue = _SYSTEM_CACHING_FALSE;
 779
 780         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_320_480, systemValue);
 781         reg.Flush();
 782
 783         this->GetValue(_SCREEN_SIZE_NORMAL_480_800, bValue);
 784         if(bValue == true)
 785                 systemValue = _SYSTEM_CACHING_TRUE;
 786         else
 787                 systemValue = _SYSTEM_CACHING_FALSE;
 788
 789         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_480_800, systemValue);
 790         reg.Flush();
 791
 792         this->GetValue(_SCREEN_SIZE_NORMAL_540_960, bValue);
 793         if(bValue == true)
 794                 systemValue = _SYSTEM_CACHING_TRUE;
 795         else
 796                 systemValue = _SYSTEM_CACHING_FALSE;
 797
 798         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_540_960, systemValue);
 799         reg.Flush();
 800
 801         this->GetValue(_SCREEN_SIZE_NORMAL_600_1024, bValue);
 802         if(bValue == true)
 803                 systemValue = _SYSTEM_CACHING_TRUE;
 804         else
 805                 systemValue = _SYSTEM_CACHING_FALSE;
 806
 807         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_600_1024, systemValue);
 808         reg.Flush();
 809
 810         this->GetValue(_SCREEN_SIZE_NORMAL_720_1280, bValue);
 811         if(bValue == true)
 812                 systemValue = _SYSTEM_CACHING_TRUE;
 813         else
 814                 systemValue = _SYSTEM_CACHING_FALSE;
 815
 816         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_720_1280, systemValue);
 817         reg.Flush();
 818
 819         this->GetValue(_SCREEN_SIZE_NORMAL_1080_1920, bValue);
 820         if(bValue == true)
 821                 systemValue = _SYSTEM_CACHING_TRUE;
 822         else
 823                 systemValue = _SYSTEM_CACHING_FALSE;
 824
 825         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_1080_1920, systemValue);
 826         reg.Flush();
 827
 828         this->GetValue(_SCREEN_OUTPUT_HDMI, bValue);
 829         if(bValue == true)
 830                 systemValue = _SYSTEM_CACHING_TRUE;
 831         else
 832                 systemValue = _SYSTEM_CACHING_FALSE;
 833         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_HDMI, systemValue);
 834         reg.Flush();
 835
 836         this->GetValue(_SCREEN_OUTPUT_RCA, bValue);
 837         if(bValue == true)
 838                 systemValue = _SYSTEM_CACHING_TRUE;
 839         else
 840                 systemValue = _SYSTEM_CACHING_FALSE;
 841         reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_RCA, systemValue);
 842         reg.Flush();
 843
 844         this->GetValue(_SHELL_APPWIDGET, bValue);
 845         if(bValue == true)
 846                 systemValue = _SYSTEM_CACHING_TRUE;
 847         else
 848                 systemValue = _SYSTEM_CACHING_FALSE;
 849         reg.AddValue(_SYSTEM_CACHING_SECTION, _SHELL_APPWIDGET, systemValue);
 850         reg.Flush();
 851
 852         this->GetValue(_SENSOR_ACCELEROMETER, bValue);
 853         if(bValue == true)
 854                 systemValue = _SYSTEM_CACHING_TRUE;
 855         else
 856                 systemValue = _SYSTEM_CACHING_FALSE;
 857         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER, systemValue);
 858         reg.Flush();
 859
 860         this->GetValue(_SENSOR_ACCELEROMETER_WAKEUP, bValue);
 861         if(bValue == true)
 862                 systemValue = _SYSTEM_CACHING_TRUE;
 863         else
 864                 systemValue = _SYSTEM_CACHING_FALSE;
 865         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER_WAKEUP, systemValue);
 866         reg.Flush();
 867
 868         this->GetValue(_SENSOR_BAROMETER, bValue);
 869         if(bValue == true)
 870                 systemValue = _SYSTEM_CACHING_TRUE;
 871         else
 872                 systemValue = _SYSTEM_CACHING_FALSE;
 873         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER, systemValue);
 874         reg.Flush();
 875
 876         this->GetValue(_SENSOR_BAROMETER_WAKEUP, bValue);
 877         if(bValue == true)
 878                 systemValue = _SYSTEM_CACHING_TRUE;
 879         else
 880                 systemValue = _SYSTEM_CACHING_FALSE;
 881         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER_WAKEUP, systemValue);
 882         reg.Flush();
 883
 884         this->GetValue(_SENSOR_GYROSCOPE, bValue);
 885         if(bValue == true)
 886                 systemValue = _SYSTEM_CACHING_TRUE;
 887         else
 888                 systemValue = _SYSTEM_CACHING_FALSE;
 889         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE, systemValue);
 890         reg.Flush();
 891
 892         this->GetValue(_SENSOR_GYROSCOPE_WAKEUP, bValue);
 893         if(bValue == true)
 894                 systemValue = _SYSTEM_CACHING_TRUE;
 895         else
 896                 systemValue = _SYSTEM_CACHING_FALSE;
 897         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE_WAKEUP, systemValue);
 898         reg.Flush();
 899
 900         this->GetValue(_SENSOR_MAGNETOMETER, bValue);
 901         if(bValue == true)
 902                 systemValue = _SYSTEM_CACHING_TRUE;
 903         else
 904                 systemValue = _SYSTEM_CACHING_FALSE;
 905         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER, systemValue);
 906         reg.Flush();
 907
 908         this->GetValue(_SENSOR_MAGNETOMETER_WAKEUP, bValue);
 909         if(bValue == true)
 910                 systemValue = _SYSTEM_CACHING_TRUE;
 911         else
 912                 systemValue = _SYSTEM_CACHING_FALSE;
 913         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER_WAKEUP, systemValue);
 914         reg.Flush();
 915
 916         this->GetValue(_SENSOR_PHOTOMETER, bValue);
 917         if(bValue == true)
 918                 systemValue = _SYSTEM_CACHING_TRUE;
 919         else
 920                 systemValue = _SYSTEM_CACHING_FALSE;
 921         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER, systemValue);
 922         reg.Flush();
 923
 924         this->GetValue(_SENSOR_PHOTOMETER_WAKEUP, bValue);
 925         if(bValue == true)
 926                 systemValue = _SYSTEM_CACHING_TRUE;
 927         else
 928                 systemValue = _SYSTEM_CACHING_FALSE;
 929         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER_WAKEUP, systemValue);
 930         reg.Flush();
 931
 932         this->GetValue(_SENSOR_PROXIMITY, bValue);
 933         if(bValue == true)
 934                 systemValue = _SYSTEM_CACHING_TRUE;
 935         else
 936                 systemValue = _SYSTEM_CACHING_FALSE;
 937         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY, systemValue);
 938         reg.Flush();
 939
 940         this->GetValue(_SENSOR_PROXIMITY_WAKEUP, bValue);
 941         if(bValue == true)
 942                 systemValue = _SYSTEM_CACHING_TRUE;
 943         else
 944                 systemValue = _SYSTEM_CACHING_FALSE;
 945         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY_WAKEUP, systemValue);
 946         reg.Flush();
 947
 948         this->GetValue(_SENSOR_TILTMETER, bValue);
 949         if(bValue == true)
 950                 systemValue = _SYSTEM_CACHING_TRUE;
 951         else
 952                 systemValue = _SYSTEM_CACHING_FALSE;
 953         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER, systemValue);
 954         reg.Flush();
 955
 956         this->GetValue(_SENSOR_TILTMETER_WAKEUP, bValue);
 957         if(bValue == true)
 958                 systemValue = _SYSTEM_CACHING_TRUE;
 959         else
 960                 systemValue = _SYSTEM_CACHING_FALSE;
 961         reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER_WAKEUP, systemValue);
 962         reg.Flush();
 963
 964         this->GetValue(_SIP_VOIP, bValue);
 965         if(bValue == true)
 966                 systemValue = _SYSTEM_CACHING_TRUE;
 967         else
 968                 systemValue = _SYSTEM_CACHING_FALSE;
 969         reg.AddValue(_SYSTEM_CACHING_SECTION, _SIP_VOIP, systemValue);
 970         reg.Flush();
 971
 972         this->GetValue(_SPEECH_RECOGNITION, bValue);
 973         if(bValue == true)
 974                 systemValue = _SYSTEM_CACHING_TRUE;
 975         else
 976                 systemValue = _SYSTEM_CACHING_FALSE;
 977         reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_RECOGNITION, systemValue);
 978         reg.Flush();
 979
 980         this->GetValue(_SPEECH_SYNTHESIS, bValue);
 981         if(bValue == true)
 982                 systemValue = _SYSTEM_CACHING_TRUE;
 983         else
 984                 systemValue = _SYSTEM_CACHING_FALSE;
 985         reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_SYNTHESIS, systemValue);
 986         reg.Flush();
 987
 988         this->GetValue(_USB_ACCESSORY, bValue);
 989         if(bValue == true)
 990                 systemValue = _SYSTEM_CACHING_TRUE;
 991         else
 992                 systemValue = _SYSTEM_CACHING_FALSE;
 993         reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_ACCESSORY, systemValue);
 994         reg.Flush();
 995
 996         this->GetValue(_USB_CLIENT, bValue);
 997         if(bValue == true)
 998                 systemValue = _SYSTEM_CACHING_TRUE;
 999         else
1000                 systemValue = _SYSTEM_CACHING_FALSE;
1001         reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_CLIENT, systemValue);
1002         reg.Flush();
1003
1004         this->GetValue(_USB_HOST, bValue);
1005         if(bValue == true)
1006                 systemValue = _SYSTEM_CACHING_TRUE;
1007         else
1008                 systemValue = _SYSTEM_CACHING_FALSE;
1009         reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_HOST, systemValue);
1010         reg.Flush();
1011
1012         this->GetValue(_VISION_FACE_RECOGNITION, bValue);
1013         if(bValue == true)
1014                 systemValue = _SYSTEM_CACHING_TRUE;
1015         else
1016                 systemValue = _SYSTEM_CACHING_FALSE;
1017         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_FACE_RECOGNITION, systemValue);
1018         reg.Flush();
1019
1020         this->GetValue(_VISION_IMAGE_RECOGNITION, bValue);
1021         if(bValue == true)
1022                 systemValue = _SYSTEM_CACHING_TRUE;
1023         else
1024                 systemValue = _SYSTEM_CACHING_FALSE;
1025         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_IMAGE_RECOGNITION, systemValue);
1026         reg.Flush();
1027
1028         this->GetValue(_VISION_QRCODE_GENERATION, bValue);
1029         if(bValue == true)
1030                 systemValue = _SYSTEM_CACHING_TRUE;
1031         else
1032                 systemValue = _SYSTEM_CACHING_FALSE;
1033         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_GENERATION, systemValue);
1034         reg.Flush();
1035
1036         this->GetValue(_VISION_QRCODE_RECOGNITION, bValue);
1037         if(bValue == true)
1038                 systemValue = _SYSTEM_CACHING_TRUE;
1039         else
1040                 systemValue = _SYSTEM_CACHING_FALSE;
1041         reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_RECOGNITION, systemValue);
1042         reg.Flush();
1043
1044         this->GetValue(_BUILD_STRING, systemValue);
1045         reg.Flush();
1046         reg.AddValue(_SYSTEM_CACHING_SECTION, _BUILD_STRING, systemValue);
1047         reg.Flush();
1048
1049         r = this->GetValue(_DUID, sValue);
1050         if(r != E_SUCCESS)
1051         {
1052                 sValue.Append(L"ERROR");
1053         }
1054         reg.AddValue(_SYSTEM_CACHING_SECTION, _DUID, sValue);
1055         reg.Flush();
1056
1057         this->GetValue(_MODELNAME, sValue);
1058         reg.AddValue(_SYSTEM_CACHING_SECTION, _MODELNAME, sValue);
1059         reg.Flush();
1060
1061         this->GetValue(_PLATFORM_NAME, sValue);
1062         reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NAME, sValue);
1063         reg.Flush();
1064
1065         this->GetValue(_SOUND_MEDIA_VOLUME_MAX, nValue);
1066         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_MEDIA_VOLUME_MAX, nValue);
1067         reg.Flush();
1068
1069         this->GetValue(_SOUND_NOTIFICATION_VOLUME_MAX, nValue);
1070         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_NOTIFICATION_VOLUME_MAX, nValue);
1071         reg.Flush();
1072
1073         this->GetValue(_SOUND_RINGTONE_VOLUME_MAX, nValue);
1074         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_RINGTONE_VOLUME_MAX, nValue);
1075         reg.Flush();
1076
1077         this->GetValue(_SOUND_SYSTEM_VOLUME_MAX, nValue);
1078         reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_SYSTEM_VOLUME_MAX, nValue);
1079         reg.Flush();
1080
1081         return E_SUCCESS;
1082 }
1083
1084 result
1085 _SystemInfoService::UpdateCacheFile(void)
1086 {
1087         Registry reg;
1088         result r = E_SUCCESS;
1089         String systemValue;
1090
1091         r = reg.Construct(_SYSTEM_CACHING_FILE, "r+");
1092         SysTryReturnResult(NID_SYS, r == E_SUCCESS, r, "It is failed to create the cache file.");
1093
1094         bool bValue = false;
1095         int nValue = 0;
1096         String sValue;
1097
1098         //For improve launch performance
1099         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_DPI, nValue);
1100         if(r != E_SUCCESS)
1101         {
1102                 this->GetValue(_SCREEN_DPI, nValue);
1103                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DPI, nValue);
1104                 reg.Flush();
1105         }
1106
1107         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_HEIGHT, nValue);
1108         if(r != E_SUCCESS)
1109         {
1110                 this->GetValue(_SCREEN_HEIGHT, nValue);
1111                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_HEIGHT, nValue);
1112                 reg.Flush();
1113         }
1114
1115         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_WIDTH, nValue);
1116         if(r != E_SUCCESS)
1117         {
1118                 this->GetValue(_SCREEN_WIDTH, nValue);
1119                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_WIDTH, nValue);
1120                 reg.Flush();
1121         }
1122
1123         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA, systemValue);
1124         if(r != E_SUCCESS)
1125         {
1126                 this->GetValue(_CAMERA, systemValue);
1127                 if(bValue == true)
1128                         systemValue = _SYSTEM_CACHING_TRUE;
1129                 else
1130                         systemValue = _SYSTEM_CACHING_FALSE;
1131
1132                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA, systemValue);
1133                 reg.Flush();
1134         }
1135
1136         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK, systemValue);
1137         if(r != E_SUCCESS)
1138         {
1139                 this->GetValue(_CAMERA_BACK, systemValue);
1140                 if(bValue == true)
1141                         systemValue = _SYSTEM_CACHING_TRUE;
1142                 else
1143                         systemValue = _SYSTEM_CACHING_FALSE;
1144
1145                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK, systemValue);
1146                 reg.Flush();
1147         }
1148
1149         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK_FLASH, systemValue);
1150         if(r != E_SUCCESS)
1151         {
1152                 this->GetValue(_CAMERA_BACK_FLASH, systemValue);
1153                 if(bValue == true)
1154                         systemValue = _SYSTEM_CACHING_TRUE;
1155                 else
1156                         systemValue = _SYSTEM_CACHING_FALSE;
1157
1158                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_BACK_FLASH, systemValue);
1159                 reg.Flush();
1160         }
1161
1162         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT, systemValue);
1163         if(r != E_SUCCESS)
1164         {
1165                 this->GetValue(_CAMERA_FRONT, systemValue);
1166                 if(bValue == true)
1167                         systemValue = _SYSTEM_CACHING_TRUE;
1168                 else
1169                         systemValue = _SYSTEM_CACHING_FALSE;
1170
1171                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT, systemValue);
1172                 reg.Flush();
1173         }
1174
1175         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT_FLASH, systemValue);
1176         if(r != E_SUCCESS)
1177         {
1178                 this->GetValue(_CAMERA_FRONT_FLASH, systemValue);
1179                 if(bValue == true)
1180                         systemValue = _SYSTEM_CACHING_TRUE;
1181                 else
1182                         systemValue = _SYSTEM_CACHING_FALSE;
1183
1184                 reg.AddValue(_SYSTEM_CACHING_SECTION, _CAMERA_FRONT_FLASH, systemValue);
1185                 reg.Flush();
1186         }
1187
1188         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _DATABASE_ENCRYPTION, systemValue);
1189         if(r != E_SUCCESS)
1190         {
1191                 this->GetValue(_DATABASE_ENCRYPTION, systemValue);
1192                 if(bValue == true)
1193                         systemValue = _SYSTEM_CACHING_TRUE;
1194                 else
1195                         systemValue = _SYSTEM_CACHING_FALSE;
1196
1197                 reg.AddValue(_SYSTEM_CACHING_SECTION, _DATABASE_ENCRYPTION, systemValue);
1198                 reg.Flush();
1199         }
1200
1201         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _FMRADIO, systemValue);
1202         if(r != E_SUCCESS)
1203         {
1204                 this->GetValue(_FMRADIO, systemValue);
1205                 if(bValue == true)
1206                         systemValue = _SYSTEM_CACHING_TRUE;
1207                 else
1208                         systemValue = _SYSTEM_CACHING_FALSE;
1209
1210                 reg.AddValue(_SYSTEM_CACHING_SECTION, _FMRADIO, systemValue);
1211                 reg.Flush();
1212         }
1213
1214         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _GRAPHIC_ACCELERATION, systemValue);
1215         if(r != E_SUCCESS)
1216         {
1217                 this->GetValue(_GRAPHIC_ACCELERATION, systemValue);
1218                 if(bValue == true)
1219                         systemValue = _SYSTEM_CACHING_TRUE;
1220                 else
1221                         systemValue = _SYSTEM_CACHING_FALSE;
1222
1223                 reg.AddValue(_SYSTEM_CACHING_SECTION, _GRAPHIC_ACCELERATION, systemValue);
1224                 reg.Flush();
1225         }
1226
1227         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD, systemValue);
1228         if(r != E_SUCCESS)
1229         {
1230                 this->GetValue(_INPUT_KEYBOARD, systemValue);
1231                 if(bValue == true)
1232                         systemValue = _SYSTEM_CACHING_TRUE;
1233                 else
1234                         systemValue = _SYSTEM_CACHING_FALSE;
1235
1236                 reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD, systemValue);
1237                 reg.Flush();
1238         }
1239
1240         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD_LAYOUT, sValue);
1241         if(r != E_SUCCESS)
1242         {
1243                 this->GetValue(_INPUT_KEYBOARD_LAYOUT, sValue);
1244                 reg.AddValue(_SYSTEM_CACHING_SECTION, _INPUT_KEYBOARD_LAYOUT, sValue);
1245                 reg.Flush();
1246         }
1247
1248         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _LOCATION, systemValue);
1249         if(r != E_SUCCESS)
1250         {
1251                 this->GetValue(_LOCATION, systemValue);
1252                 if(bValue == true)
1253                         systemValue = _SYSTEM_CACHING_TRUE;
1254                 else
1255                         systemValue = _SYSTEM_CACHING_FALSE;
1256
1257                 reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION, systemValue);
1258                 reg.Flush();
1259         }
1260
1261         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _LOCATION_GPS, systemValue);
1262         if(r != E_SUCCESS)
1263         {
1264                 this->GetValue(_LOCATION_GPS, systemValue);
1265                 if(bValue == true)
1266                         systemValue = _SYSTEM_CACHING_TRUE;
1267                 else
1268                         systemValue = _SYSTEM_CACHING_FALSE;
1269
1270                 reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_GPS, systemValue);
1271                 reg.Flush();
1272         }
1273
1274         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _LOCATION_WPS, systemValue);
1275         if(r != E_SUCCESS)
1276         {
1277                 this->GetValue(_LOCATION_WPS, systemValue);
1278                 if(bValue == true)
1279                         systemValue = _SYSTEM_CACHING_TRUE;
1280                 else
1281                         systemValue = _SYSTEM_CACHING_FALSE;
1282
1283                 reg.AddValue(_SYSTEM_CACHING_SECTION, _LOCATION_WPS, systemValue);
1284                 reg.Flush();
1285         }
1286
1287         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MICROPHONE, systemValue);
1288         if(r != E_SUCCESS)
1289         {
1290                 this->GetValue(_MICROPHONE, systemValue);
1291                 if(bValue == true)
1292                         systemValue = _SYSTEM_CACHING_TRUE;
1293                 else
1294                         systemValue = _SYSTEM_CACHING_FALSE;
1295
1296                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MICROPHONE, systemValue);
1297                 reg.Flush();
1298         }
1299
1300         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_PINCHZOOM, systemValue);
1301         if(r != E_SUCCESS)
1302         {
1303                 this->GetValue(_MULTIPOINTTOUCH_PINCHZOOM, systemValue);
1304                 if(bValue == true)
1305                         systemValue = _SYSTEM_CACHING_TRUE;
1306                 else
1307                         systemValue = _SYSTEM_CACHING_FALSE;
1308
1309                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_PINCHZOOM, systemValue);
1310                 reg.Flush();
1311         }
1312
1313         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
1314         if(r != E_SUCCESS)
1315         {
1316                 r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
1317                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MULTIPOINTTOUCH_POINTCOUNT, nValue);
1318                 reg.Flush();
1319         }
1320
1321         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_BLUETOOTH, systemValue);
1322         if(r != E_SUCCESS)
1323         {
1324                 this->GetValue(_NETWORK_BLUETOOTH, systemValue);
1325                 if(bValue == true)
1326                         systemValue = _SYSTEM_CACHING_TRUE;
1327                 else
1328                         systemValue = _SYSTEM_CACHING_FALSE;
1329
1330                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_BLUETOOTH, systemValue);
1331                 reg.Flush();
1332         }
1333
1334         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC, systemValue);
1335         if(r != E_SUCCESS)
1336         {
1337                 this->GetValue(_NETWORK_NFC, systemValue);
1338                 if(bValue == true)
1339                         systemValue = _SYSTEM_CACHING_TRUE;
1340                 else
1341                         systemValue = _SYSTEM_CACHING_FALSE;
1342
1343                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC, systemValue);
1344                 reg.Flush();
1345         }
1346
1347         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC_RESERVED_PUSH, systemValue);
1348         if(r != E_SUCCESS)
1349         {
1350                 this->GetValue(_NETWORK_NFC_RESERVED_PUSH, systemValue);
1351                 if(bValue == true)
1352                         systemValue = _SYSTEM_CACHING_TRUE;
1353                 else
1354                         systemValue = _SYSTEM_CACHING_FALSE;
1355
1356                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_NFC_RESERVED_PUSH, systemValue);
1357                 reg.Flush();
1358         }
1359
1360         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_PUSH, systemValue);
1361         if(r != E_SUCCESS)
1362         {
1363                 this->GetValue(_NETWORK_PUSH, systemValue);
1364                 if(bValue == true)
1365                         systemValue = _SYSTEM_CACHING_TRUE;
1366                 else
1367                         systemValue = _SYSTEM_CACHING_FALSE;
1368
1369                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_PUSH, systemValue);
1370                 reg.Flush();
1371         }
1372
1373         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_SECURE_ELEMENT, systemValue);
1374         if(r != E_SUCCESS)
1375         {
1376                 this->GetValue(_NETWORK_SECURE_ELEMENT, systemValue);
1377                 if(bValue == true)
1378                         systemValue = _SYSTEM_CACHING_TRUE;
1379                 else
1380                         systemValue = _SYSTEM_CACHING_FALSE;
1381
1382                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_SECURE_ELEMENT, systemValue);
1383                 reg.Flush();
1384         }
1385
1386         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY, systemValue);
1387         if(r != E_SUCCESS)
1388         {
1389                 this->GetValue(_NETWORK_TELEPHONY, systemValue);
1390                 if(bValue == true)
1391                         systemValue = _SYSTEM_CACHING_TRUE;
1392                 else
1393                         systemValue = _SYSTEM_CACHING_FALSE;
1394
1395                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY, systemValue);
1396                 reg.Flush();
1397         }
1398
1399         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_MMS, systemValue);
1400         if(r != E_SUCCESS)
1401         {
1402                 this->GetValue(_NETWORK_TELEPHONY_MMS, systemValue);
1403                 if(bValue == true)
1404                         systemValue = _SYSTEM_CACHING_TRUE;
1405                 else
1406                         systemValue = _SYSTEM_CACHING_FALSE;
1407
1408                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_MMS, systemValue);
1409                 reg.Flush();
1410         }
1411
1412         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS, systemValue);
1413         if(r != E_SUCCESS)
1414         {
1415                 this->GetValue(_NETWORK_TELEPHONY_SMS, systemValue);
1416                 if(bValue == true)
1417                         systemValue = _SYSTEM_CACHING_TRUE;
1418                 else
1419                         systemValue = _SYSTEM_CACHING_FALSE;
1420
1421                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS, systemValue);
1422                 reg.Flush();
1423         }
1424
1425         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS_CBS, systemValue);
1426         if(r != E_SUCCESS)
1427         {
1428                 this->GetValue(_NETWORK_TELEPHONY_SMS_CBS, systemValue);
1429                 if(bValue == true)
1430                         systemValue = _SYSTEM_CACHING_TRUE;
1431                 else
1432                         systemValue = _SYSTEM_CACHING_FALSE;
1433
1434                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SMS_CBS, systemValue);
1435                 reg.Flush();
1436         }
1437
1438         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_CDMA, systemValue);
1439         if(r != E_SUCCESS)
1440         {
1441                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_CDMA, systemValue);
1442                 if(bValue == true)
1443                         systemValue = _SYSTEM_CACHING_TRUE;
1444                 else
1445                         systemValue = _SYSTEM_CACHING_FALSE;
1446
1447                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_CDMA, systemValue);
1448                 reg.Flush();
1449         }
1450
1451         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_EDGE, systemValue);
1452         if(r != E_SUCCESS)
1453         {
1454                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_EDGE, systemValue);
1455                 if(bValue == true)
1456                         systemValue = _SYSTEM_CACHING_TRUE;
1457                 else
1458                         systemValue = _SYSTEM_CACHING_FALSE;
1459
1460                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_EDGE, systemValue);
1461                 reg.Flush();
1462         }
1463
1464         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GPRS, systemValue);
1465         if(r != E_SUCCESS)
1466         {
1467                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_GPRS, systemValue);
1468                 if(bValue == true)
1469                         systemValue = _SYSTEM_CACHING_TRUE;
1470                 else
1471                         systemValue = _SYSTEM_CACHING_FALSE;
1472
1473                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GPRS, systemValue);
1474                 reg.Flush();
1475         }
1476
1477         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GSM, systemValue);
1478         if(r != E_SUCCESS)
1479         {
1480                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_GSM, systemValue);
1481                 if(bValue == true)
1482                         systemValue = _SYSTEM_CACHING_TRUE;
1483                 else
1484                         systemValue = _SYSTEM_CACHING_FALSE;
1485
1486                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_GSM, systemValue);
1487                 reg.Flush();
1488         }
1489
1490         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSDPA, systemValue);
1491         if(r != E_SUCCESS)
1492         {
1493                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSDPA, systemValue);
1494                 if(bValue == true)
1495                         systemValue = _SYSTEM_CACHING_TRUE;
1496                 else
1497                         systemValue = _SYSTEM_CACHING_FALSE;
1498
1499                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSDPA, systemValue);
1500                 reg.Flush();
1501         }
1502
1503         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSPA, systemValue);
1504         if(r != E_SUCCESS)
1505         {
1506                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSPA, systemValue);
1507                 if(bValue == true)
1508                         systemValue = _SYSTEM_CACHING_TRUE;
1509                 else
1510                         systemValue = _SYSTEM_CACHING_FALSE;
1511
1512                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSPA, systemValue);
1513                 reg.Flush();
1514         }
1515
1516         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSUPA, systemValue);
1517         if(r != E_SUCCESS)
1518         {
1519                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_HSUPA, systemValue);
1520                 if(bValue == true)
1521                         systemValue = _SYSTEM_CACHING_TRUE;
1522                 else
1523                         systemValue = _SYSTEM_CACHING_FALSE;
1524
1525                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_HSUPA, systemValue);
1526                 reg.Flush();
1527         }
1528
1529         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_LTE, systemValue);
1530         if(r != E_SUCCESS)
1531         {
1532                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_LTE, systemValue);
1533                 if(bValue == true)
1534                         systemValue = _SYSTEM_CACHING_TRUE;
1535                 else
1536                         systemValue = _SYSTEM_CACHING_FALSE;
1537
1538                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_LTE, systemValue);
1539                 reg.Flush();
1540         }
1541
1542         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_UMTS, systemValue);
1543         if(r != E_SUCCESS)
1544         {
1545                 this->GetValue(_NETWORK_TELEPHONY_SERVICE_UMTS, systemValue);
1546                 if(bValue == true)
1547                         systemValue = _SYSTEM_CACHING_TRUE;
1548                 else
1549                         systemValue = _SYSTEM_CACHING_FALSE;
1550
1551                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_TELEPHONY_SERVICE_UMTS, systemValue);
1552                 reg.Flush();
1553         }
1554
1555         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI, systemValue);
1556         if(r != E_SUCCESS)
1557         {
1558                 this->GetValue(_NETWORK_WIFI, systemValue);
1559                 if(bValue == true)
1560                         systemValue = _SYSTEM_CACHING_TRUE;
1561                 else
1562                         systemValue = _SYSTEM_CACHING_FALSE;
1563
1564                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI, systemValue);
1565                 reg.Flush();
1566         }
1567
1568         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI_DIRECT, systemValue);
1569         if(r != E_SUCCESS)
1570         {
1571                 this->GetValue(_NETWORK_WIFI_DIRECT, systemValue);
1572                 if(bValue == true)
1573                         systemValue = _SYSTEM_CACHING_TRUE;
1574                 else
1575                         systemValue = _SYSTEM_CACHING_FALSE;
1576
1577                 reg.AddValue(_SYSTEM_CACHING_SECTION, _NETWORK_WIFI_DIRECT, systemValue);
1578                 reg.Flush();
1579         }
1580
1581         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES, systemValue);
1582         if(r != E_SUCCESS)
1583         {
1584                 this->GetValue(_OPENGLES, systemValue);
1585                 if(bValue == true)
1586                         systemValue = _SYSTEM_CACHING_TRUE;
1587                 else
1588                         systemValue = _SYSTEM_CACHING_FALSE;
1589
1590                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES, systemValue);
1591                 reg.Flush();
1592         }
1593
1594         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_3DC, systemValue);
1595         if(r != E_SUCCESS)
1596         {
1597                 this->GetValue(_OPENGLES_TEXTUREFORMAT_3DC, systemValue);
1598                 if(bValue == true)
1599                         systemValue = _SYSTEM_CACHING_TRUE;
1600                 else
1601                         systemValue = _SYSTEM_CACHING_FALSE;
1602
1603                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_3DC, systemValue);
1604                 reg.Flush();
1605         }
1606
1607         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ATC, systemValue);
1608         if(r != E_SUCCESS)
1609         {
1610                 this->GetValue(_OPENGLES_TEXTUREFORMAT_ATC, systemValue);
1611                 if(bValue == true)
1612                         systemValue = _SYSTEM_CACHING_TRUE;
1613                 else
1614                         systemValue = _SYSTEM_CACHING_FALSE;
1615
1616                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ATC, systemValue);
1617                 reg.Flush();
1618         }
1619
1620         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ETC, systemValue);
1621         if(r != E_SUCCESS)
1622         {
1623                 this->GetValue(_OPENGLES_TEXTUREFORMAT_ETC, systemValue);
1624                 if(bValue == true)
1625                         systemValue = _SYSTEM_CACHING_TRUE;
1626                 else
1627                         systemValue = _SYSTEM_CACHING_FALSE;
1628
1629                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_ETC, systemValue);
1630                 reg.Flush();
1631         }
1632
1633         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PTC, systemValue);
1634         if(r != E_SUCCESS)
1635         {
1636                 this->GetValue(_OPENGLES_TEXTUREFORMAT_PTC, systemValue);
1637                 if(bValue == true)
1638                         systemValue = _SYSTEM_CACHING_TRUE;
1639                 else
1640                         systemValue = _SYSTEM_CACHING_FALSE;
1641
1642                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PTC, systemValue);
1643                 reg.Flush();
1644         }
1645
1646         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PVRTC, systemValue);
1647         if(r != E_SUCCESS)
1648         {
1649                 this->GetValue(_OPENGLES_TEXTUREFORMAT_PVRTC, systemValue);
1650                 if(bValue == true)
1651                         systemValue = _SYSTEM_CACHING_TRUE;
1652                 else
1653                         systemValue = _SYSTEM_CACHING_FALSE;
1654
1655                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_PVRTC, systemValue);
1656                 reg.Flush();
1657         }
1658
1659         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_UTC, systemValue);
1660         if(r != E_SUCCESS)
1661         {
1662                 this->GetValue(_OPENGLES_TEXTUREFORMAT_UTC, systemValue);
1663                 if(bValue == true)
1664                         systemValue = _SYSTEM_CACHING_TRUE;
1665                 else
1666                         systemValue = _SYSTEM_CACHING_FALSE;
1667
1668                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_TEXTUREFORMAT_UTC, systemValue);
1669                 reg.Flush();
1670         }
1671
1672         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_1_1, systemValue);
1673         if(r != E_SUCCESS)
1674         {
1675                 this->GetValue(_OPENGLES_VERSION_1_1, systemValue);
1676                 if(bValue == true)
1677                         systemValue = _SYSTEM_CACHING_TRUE;
1678                 else
1679                         systemValue = _SYSTEM_CACHING_FALSE;
1680
1681                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_1_1, systemValue);
1682                 reg.Flush();
1683         }
1684
1685         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_2_0, systemValue);
1686         if(r != E_SUCCESS)
1687         {
1688                 this->GetValue(_OPENGLES_VERSION_2_0, systemValue);
1689                 if(bValue == true)
1690                         systemValue = _SYSTEM_CACHING_TRUE;
1691                 else
1692                         systemValue = _SYSTEM_CACHING_FALSE;
1693
1694                 reg.AddValue(_SYSTEM_CACHING_SECTION, _OPENGLES_VERSION_2_0, systemValue);
1695                 reg.Flush();
1696         }
1697
1698         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV6, systemValue);
1699         if(r != E_SUCCESS)
1700         {
1701                 this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV6, systemValue);
1702                 if(bValue == true)
1703                         systemValue = _SYSTEM_CACHING_TRUE;
1704                 else
1705                         systemValue = _SYSTEM_CACHING_FALSE;
1706
1707                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV6, systemValue);
1708                 reg.Flush();
1709         }
1710
1711         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV7, systemValue);
1712         if(r != E_SUCCESS)
1713         {
1714                 this->GetValue(_PLATFORM_CORE_CPU_ARCH_ARMV7, systemValue);
1715                 if(bValue == true)
1716                         systemValue = _SYSTEM_CACHING_TRUE;
1717                 else
1718                         systemValue = _SYSTEM_CACHING_FALSE;
1719
1720                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_ARMV7, systemValue);
1721                 reg.Flush();
1722         }
1723
1724         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_X86, systemValue);
1725         if(r != E_SUCCESS)
1726         {
1727                 this->GetValue(_PLATFORM_CORE_CPU_ARCH_X86, systemValue);
1728                 if(bValue == true)
1729                         systemValue = _SYSTEM_CACHING_TRUE;
1730                 else
1731                         systemValue = _SYSTEM_CACHING_FALSE;
1732
1733                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_CPU_ARCH_X86, systemValue);
1734                 reg.Flush();
1735         }
1736
1737         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE2, systemValue);
1738         if(r != E_SUCCESS)
1739         {
1740                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE2, systemValue);
1741                 if(bValue == true)
1742                         systemValue = _SYSTEM_CACHING_TRUE;
1743                 else
1744                         systemValue = _SYSTEM_CACHING_FALSE;
1745
1746                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE2, systemValue);
1747                 reg.Flush();
1748         }
1749
1750         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE3, systemValue);
1751         if(r != E_SUCCESS)
1752         {
1753                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSE3, systemValue);
1754                 if(bValue == true)
1755                         systemValue = _SYSTEM_CACHING_TRUE;
1756                 else
1757                         systemValue = _SYSTEM_CACHING_FALSE;
1758
1759                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSE3, systemValue);
1760                 reg.Flush();
1761         }
1762
1763         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSSE3, systemValue);
1764         if(r != E_SUCCESS)
1765         {
1766                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_SSSE3, systemValue);
1767                 if(bValue == true)
1768                         systemValue = _SYSTEM_CACHING_TRUE;
1769                 else
1770                         systemValue = _SYSTEM_CACHING_FALSE;
1771
1772                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_SSSE3, systemValue);
1773                 reg.Flush();
1774         }
1775
1776         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV2, systemValue);
1777         if(r != E_SUCCESS)
1778         {
1779                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV2, systemValue);
1780                 if(bValue == true)
1781                         systemValue = _SYSTEM_CACHING_TRUE;
1782                 else
1783                         systemValue = _SYSTEM_CACHING_FALSE;
1784
1785                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV2, systemValue);
1786                 reg.Flush();
1787         }
1788
1789         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV3, systemValue);
1790         if(r != E_SUCCESS)
1791         {
1792                 this->GetValue(_PLATFORM_CORE_FPU_ARCH_VFPV3, systemValue);
1793                 if(bValue == true)
1794                         systemValue = _SYSTEM_CACHING_TRUE;
1795                 else
1796                         systemValue = _SYSTEM_CACHING_FALSE;
1797
1798                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_CORE_FPU_ARCH_VFPV3, systemValue);
1799                 reg.Flush();
1800         }
1801
1802         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_API_VERSION, sValue);
1803         if(r != E_SUCCESS)
1804         {
1805                 this->GetValue(_PLATFORM_NATIVE_API_VERSION, sValue);
1806                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_API_VERSION, sValue);
1807                 reg.Flush();
1808         }
1809
1810         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_OSP_COMPATIBLE, systemValue);
1811         if(r != E_SUCCESS)
1812         {
1813                 this->GetValue(_PLATFORM_NATIVE_OSP_COMPATIBLE, systemValue);
1814                 if(bValue == true)
1815                         systemValue = _SYSTEM_CACHING_TRUE;
1816                 else
1817                         systemValue = _SYSTEM_CACHING_FALSE;
1818
1819                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NATIVE_OSP_COMPATIBLE, systemValue);
1820                 reg.Flush();
1821         }
1822
1823         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_VERSION, sValue);
1824         if(r != E_SUCCESS)
1825         {
1826                 this->GetValue(_PLATFORM_VERSION, sValue);
1827                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_VERSION, sValue);
1828                 reg.Flush();
1829         }
1830
1831         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_WEB_API_VERSION, sValue);
1832         if(r != E_SUCCESS)
1833         {
1834                 this->GetValue(_PLATFORM_WEB_API_VERSION, sValue);
1835                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_WEB_API_VERSION, sValue);
1836                 reg.Flush();
1837         }
1838
1839         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_AUTO_ROTATION, systemValue);
1840         if(r != E_SUCCESS)
1841         {
1842                 this->GetValue(_SCREEN_AUTO_ROTATION, systemValue);
1843                 if(bValue == true)
1844                         systemValue = _SYSTEM_CACHING_TRUE;
1845                 else
1846                         systemValue = _SYSTEM_CACHING_FALSE;
1847
1848                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_AUTO_ROTATION, systemValue);
1849                 reg.Flush();
1850         }
1851
1852         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_BPP, nValue);
1853         if(r != E_SUCCESS)
1854         {
1855                 this->GetValue(_SCREEN_BPP, nValue);
1856                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_BPP, nValue);
1857                 reg.Flush();
1858         }
1859
1860         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, systemValue);
1861         if(r != E_SUCCESS)
1862         {
1863                 this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, systemValue);
1864                 if(bValue == true)
1865                         systemValue = _SYSTEM_CACHING_TRUE;
1866                 else
1867                         systemValue = _SYSTEM_CACHING_FALSE;
1868
1869                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_LARGE, systemValue);
1870                 reg.Flush();
1871         }
1872
1873         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, systemValue);
1874         if(r != E_SUCCESS)
1875         {
1876                 this->GetValue(_SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, systemValue);
1877                 if(bValue == true)
1878                         systemValue = _SYSTEM_CACHING_TRUE;
1879                 else
1880                         systemValue = _SYSTEM_CACHING_FALSE;
1881
1882                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_COORDINATE_SYSTEM_SIZE_NORMAL, systemValue);
1883                 reg.Flush();
1884         }
1885
1886         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_DESKTOPMODE, systemValue);
1887         if(r != E_SUCCESS)
1888         {
1889                 this->GetValue(_SCREEN_DESKTOPMODE, systemValue);
1890                 if(bValue == true)
1891                         systemValue = _SYSTEM_CACHING_TRUE;
1892                 else
1893                         systemValue = _SYSTEM_CACHING_FALSE;
1894
1895                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_DESKTOPMODE, systemValue);
1896                 reg.Flush();
1897         }
1898
1899         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_LARGE, systemValue);
1900         if(r != E_SUCCESS)
1901         {
1902                 this->GetValue(_SCREEN_SIZE_LARGE, systemValue);
1903                 if(bValue == true)
1904                         systemValue = _SYSTEM_CACHING_TRUE;
1905                 else
1906                         systemValue = _SYSTEM_CACHING_FALSE;
1907
1908                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_LARGE, systemValue);
1909                 reg.Flush();
1910         }
1911
1912         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL, systemValue);
1913         if(r != E_SUCCESS)
1914         {
1915                 this->GetValue(_SCREEN_SIZE_NORMAL, systemValue);
1916                 if(bValue == true)
1917                         systemValue = _SYSTEM_CACHING_TRUE;
1918                 else
1919                         systemValue = _SYSTEM_CACHING_FALSE;
1920
1921                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL, systemValue);
1922                 reg.Flush();
1923         }
1924
1925         this->GetValue(_SCREEN_SIZE_NORMAL_240_400, systemValue);
1926         if(r != E_SUCCESS)
1927         {
1928                 this->GetValue(_SCREEN_SIZE_NORMAL_240_400, systemValue);
1929                 if(bValue == true)
1930                         systemValue = _SYSTEM_CACHING_TRUE;
1931                 else
1932                         systemValue = _SYSTEM_CACHING_FALSE;
1933
1934                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_240_400, systemValue);
1935                 reg.Flush();
1936         }
1937
1938         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_320_480, systemValue);
1939         if(r != E_SUCCESS)
1940         {
1941                 this->GetValue(_SCREEN_SIZE_NORMAL_320_480, systemValue);
1942                 if(bValue == true)
1943                         systemValue = _SYSTEM_CACHING_TRUE;
1944                 else
1945                         systemValue = _SYSTEM_CACHING_FALSE;
1946
1947                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_320_480, systemValue);
1948                 reg.Flush();
1949         }
1950
1951         this->GetValue(_SCREEN_SIZE_NORMAL_480_800, systemValue);
1952         if(r != E_SUCCESS)
1953         {
1954                 this->GetValue(_SCREEN_SIZE_NORMAL_480_800, systemValue);
1955                 if(bValue == true)
1956                         systemValue = _SYSTEM_CACHING_TRUE;
1957                 else
1958                         systemValue = _SYSTEM_CACHING_FALSE;
1959
1960                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_480_800, systemValue);
1961                 reg.Flush();
1962         }
1963
1964         this->GetValue(_SCREEN_SIZE_NORMAL_540_960, systemValue);
1965         if(r != E_SUCCESS)
1966         {
1967                 this->GetValue(_SCREEN_SIZE_NORMAL_540_960, systemValue);
1968                 if(bValue == true)
1969                         systemValue = _SYSTEM_CACHING_TRUE;
1970                 else
1971                         systemValue = _SYSTEM_CACHING_FALSE;
1972
1973                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_540_960, systemValue);
1974                 reg.Flush();
1975         }
1976
1977         this->GetValue(_SCREEN_SIZE_NORMAL_600_1024, systemValue);
1978         if(r != E_SUCCESS)
1979         {
1980                 this->GetValue(_SCREEN_SIZE_NORMAL_600_1024, systemValue);
1981                 if(bValue == true)
1982                         systemValue = _SYSTEM_CACHING_TRUE;
1983                 else
1984                         systemValue = _SYSTEM_CACHING_FALSE;
1985
1986                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_600_1024, systemValue);
1987                 reg.Flush();
1988         }
1989
1990         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_720_1280, systemValue);
1991         if(r != E_SUCCESS)
1992         {
1993                 this->GetValue(_SCREEN_SIZE_NORMAL_720_1280, systemValue);
1994                 if(bValue == true)
1995                         systemValue = _SYSTEM_CACHING_TRUE;
1996                 else
1997                         systemValue = _SYSTEM_CACHING_FALSE;
1998
1999                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_720_1280, systemValue);
2000                 reg.Flush();
2001         }
2002
2003         this->GetValue(_SCREEN_SIZE_NORMAL_1080_1920, systemValue);
2004         if(r != E_SUCCESS)
2005         {
2006                 this->GetValue(_SCREEN_SIZE_NORMAL_1080_1920, systemValue);
2007                 if(bValue == true)
2008                         systemValue = _SYSTEM_CACHING_TRUE;
2009                 else
2010                         systemValue = _SYSTEM_CACHING_FALSE;
2011
2012                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_SIZE_NORMAL_1080_1920, systemValue);
2013                 reg.Flush();
2014         }
2015
2016         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_HDMI, systemValue);
2017         if(r != E_SUCCESS)
2018         {
2019                 this->GetValue(_SCREEN_OUTPUT_HDMI, systemValue);
2020                 if(bValue == true)
2021                         systemValue = _SYSTEM_CACHING_TRUE;
2022                 else
2023                         systemValue = _SYSTEM_CACHING_FALSE;
2024
2025                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_HDMI, systemValue);
2026                 reg.Flush();
2027         }
2028
2029         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_RCA, systemValue);
2030         if(r != E_SUCCESS)
2031         {
2032                 this->GetValue(_SCREEN_OUTPUT_RCA, systemValue);
2033                 if(bValue == true)
2034                         systemValue = _SYSTEM_CACHING_TRUE;
2035                 else
2036                         systemValue = _SYSTEM_CACHING_FALSE;
2037
2038                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SCREEN_OUTPUT_RCA, systemValue);
2039                 reg.Flush();
2040         }
2041
2042         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SHELL_APPWIDGET, systemValue);
2043         if(r != E_SUCCESS)
2044         {
2045                 this->GetValue(_SHELL_APPWIDGET, systemValue);
2046                 if(bValue == true)
2047                         systemValue = _SYSTEM_CACHING_TRUE;
2048                 else
2049                         systemValue = _SYSTEM_CACHING_FALSE;
2050
2051                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SHELL_APPWIDGET, systemValue);
2052                 reg.Flush();
2053         }
2054
2055         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER, systemValue);
2056         if(r != E_SUCCESS)
2057         {
2058                 this->GetValue(_SENSOR_ACCELEROMETER, systemValue);
2059                 if(bValue == true)
2060                         systemValue = _SYSTEM_CACHING_TRUE;
2061                 else
2062                         systemValue = _SYSTEM_CACHING_FALSE;
2063
2064                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER, systemValue);
2065                 reg.Flush();
2066         }
2067
2068         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER_WAKEUP, systemValue);
2069         if(r != E_SUCCESS)
2070         {
2071                 this->GetValue(_SENSOR_ACCELEROMETER_WAKEUP, systemValue);
2072                 if(bValue == true)
2073                         systemValue = _SYSTEM_CACHING_TRUE;
2074                 else
2075                         systemValue = _SYSTEM_CACHING_FALSE;
2076
2077                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_ACCELEROMETER_WAKEUP, systemValue);
2078                 reg.Flush();
2079         }
2080
2081         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER, systemValue);
2082         if(r != E_SUCCESS)
2083         {
2084                 this->GetValue(_SENSOR_BAROMETER, systemValue);
2085                 if(bValue == true)
2086                         systemValue = _SYSTEM_CACHING_TRUE;
2087                 else
2088                         systemValue = _SYSTEM_CACHING_FALSE;
2089
2090                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER, systemValue);
2091                 reg.Flush();
2092         }
2093
2094         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER_WAKEUP, systemValue);
2095         if(r != E_SUCCESS)
2096         {
2097                 this->GetValue(_SENSOR_BAROMETER_WAKEUP, systemValue);
2098                 if(bValue == true)
2099                         systemValue = _SYSTEM_CACHING_TRUE;
2100                 else
2101                         systemValue = _SYSTEM_CACHING_FALSE;
2102
2103                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_BAROMETER_WAKEUP, systemValue);
2104                 reg.Flush();
2105         }
2106
2107         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE, systemValue);
2108         if(r != E_SUCCESS)
2109         {
2110                 this->GetValue(_SENSOR_GYROSCOPE, systemValue);
2111                 if(bValue == true)
2112                         systemValue = _SYSTEM_CACHING_TRUE;
2113                 else
2114                         systemValue = _SYSTEM_CACHING_FALSE;
2115
2116                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE, systemValue);
2117                 reg.Flush();
2118         }
2119
2120         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE_WAKEUP, systemValue);
2121         if(r != E_SUCCESS)
2122         {
2123                 this->GetValue(_SENSOR_GYROSCOPE_WAKEUP, systemValue);
2124                 if(bValue == true)
2125                         systemValue = _SYSTEM_CACHING_TRUE;
2126                 else
2127                         systemValue = _SYSTEM_CACHING_FALSE;
2128
2129                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_GYROSCOPE_WAKEUP, systemValue);
2130                 reg.Flush();
2131         }
2132
2133         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER, systemValue);
2134         if(r != E_SUCCESS)
2135         {
2136                 this->GetValue(_SENSOR_MAGNETOMETER, systemValue);
2137                 if(bValue == true)
2138                         systemValue = _SYSTEM_CACHING_TRUE;
2139                 else
2140                         systemValue = _SYSTEM_CACHING_FALSE;
2141
2142                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER, systemValue);
2143                 reg.Flush();
2144         }
2145
2146         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER_WAKEUP, systemValue);
2147         if(r != E_SUCCESS)
2148         {
2149                 this->GetValue(_SENSOR_MAGNETOMETER_WAKEUP, systemValue);
2150                 if(bValue == true)
2151                         systemValue = _SYSTEM_CACHING_TRUE;
2152                 else
2153                         systemValue = _SYSTEM_CACHING_FALSE;
2154
2155                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_MAGNETOMETER_WAKEUP, systemValue);
2156                 reg.Flush();
2157         }
2158
2159         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER, systemValue);
2160         if(r != E_SUCCESS)
2161         {
2162                 this->GetValue(_SENSOR_PHOTOMETER, systemValue);
2163                 if(bValue == true)
2164                         systemValue = _SYSTEM_CACHING_TRUE;
2165                 else
2166                         systemValue = _SYSTEM_CACHING_FALSE;
2167
2168                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER, systemValue);
2169                 reg.Flush();
2170         }
2171
2172         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER_WAKEUP, systemValue);
2173         if(r != E_SUCCESS)
2174         {
2175                 this->GetValue(_SENSOR_PHOTOMETER_WAKEUP, systemValue);
2176                 if(bValue == true)
2177                         systemValue = _SYSTEM_CACHING_TRUE;
2178                 else
2179                         systemValue = _SYSTEM_CACHING_FALSE;
2180
2181                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PHOTOMETER_WAKEUP, systemValue);
2182                 reg.Flush();
2183         }
2184
2185         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY, systemValue);
2186         if(r != E_SUCCESS)
2187         {
2188                 this->GetValue(_SENSOR_PROXIMITY, systemValue);
2189                 if(bValue == true)
2190                         systemValue = _SYSTEM_CACHING_TRUE;
2191                 else
2192                         systemValue = _SYSTEM_CACHING_FALSE;
2193
2194                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY, systemValue);
2195                 reg.Flush();
2196         }
2197
2198         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY_WAKEUP, systemValue);
2199         if(r != E_SUCCESS)
2200         {
2201                 this->GetValue(_SENSOR_PROXIMITY_WAKEUP, systemValue);
2202                 if(bValue == true)
2203                         systemValue = _SYSTEM_CACHING_TRUE;
2204                 else
2205                         systemValue = _SYSTEM_CACHING_FALSE;
2206
2207                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_PROXIMITY_WAKEUP, systemValue);
2208                 reg.Flush();
2209         }
2210
2211         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER, systemValue);
2212         if(r != E_SUCCESS)
2213         {
2214                 this->GetValue(_SENSOR_TILTMETER, systemValue);
2215                 if(bValue == true)
2216                         systemValue = _SYSTEM_CACHING_TRUE;
2217                 else
2218                         systemValue = _SYSTEM_CACHING_FALSE;
2219
2220                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER, systemValue);
2221                 reg.Flush();
2222         }
2223
2224         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER_WAKEUP, systemValue);
2225         if(r != E_SUCCESS)
2226         {
2227                 this->GetValue(_SENSOR_TILTMETER_WAKEUP, systemValue);
2228                 if(bValue == true)
2229                         systemValue = _SYSTEM_CACHING_TRUE;
2230                 else
2231                         systemValue = _SYSTEM_CACHING_FALSE;
2232
2233                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SENSOR_TILTMETER_WAKEUP, systemValue);
2234                 reg.Flush();
2235         }
2236
2237         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SIP_VOIP, systemValue);
2238         if(r != E_SUCCESS)
2239         {
2240                 this->GetValue(_SIP_VOIP, systemValue);
2241                 if(bValue == true)
2242                         systemValue = _SYSTEM_CACHING_TRUE;
2243                 else
2244                         systemValue = _SYSTEM_CACHING_FALSE;
2245
2246                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SIP_VOIP, systemValue);
2247                 reg.Flush();
2248         }
2249
2250         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SPEECH_RECOGNITION, systemValue);
2251         if(r != E_SUCCESS)
2252         {
2253                 this->GetValue(_SPEECH_RECOGNITION, systemValue);
2254                 if(bValue == true)
2255                         systemValue = _SYSTEM_CACHING_TRUE;
2256                 else
2257                         systemValue = _SYSTEM_CACHING_FALSE;
2258
2259                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_RECOGNITION, systemValue);
2260                 reg.Flush();
2261         }
2262
2263         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SPEECH_SYNTHESIS, systemValue);
2264         if(r != E_SUCCESS)
2265         {
2266                 this->GetValue(_SPEECH_SYNTHESIS, systemValue);
2267                 if(bValue == true)
2268                         systemValue = _SYSTEM_CACHING_TRUE;
2269                 else
2270                         systemValue = _SYSTEM_CACHING_FALSE;
2271
2272                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SPEECH_SYNTHESIS, systemValue);
2273                 reg.Flush();
2274         }
2275
2276         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _USB_ACCESSORY, systemValue);
2277         if(r != E_SUCCESS)
2278         {
2279                 this->GetValue(_USB_ACCESSORY, systemValue);
2280                 if(bValue == true)
2281                         systemValue = _SYSTEM_CACHING_TRUE;
2282                 else
2283                         systemValue = _SYSTEM_CACHING_FALSE;
2284
2285                 reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_ACCESSORY, systemValue);
2286                 reg.Flush();
2287         }
2288
2289         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _USB_CLIENT, systemValue);
2290         if(r != E_SUCCESS)
2291         {
2292                 this->GetValue(_USB_CLIENT, systemValue);
2293                 if(bValue == true)
2294                         systemValue = _SYSTEM_CACHING_TRUE;
2295                 else
2296                         systemValue = _SYSTEM_CACHING_FALSE;
2297
2298                 reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_CLIENT, systemValue);
2299                 reg.Flush();
2300         }
2301
2302         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _USB_HOST, systemValue);
2303         if(r != E_SUCCESS)
2304         {
2305                 this->GetValue(_USB_HOST, systemValue);
2306                 if(bValue == true)
2307                         systemValue = _SYSTEM_CACHING_TRUE;
2308                 else
2309                         systemValue = _SYSTEM_CACHING_FALSE;
2310
2311                 reg.AddValue(_SYSTEM_CACHING_SECTION, _USB_HOST, systemValue);
2312                 reg.Flush();
2313         }
2314
2315         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_FACE_RECOGNITION, systemValue);
2316         if(r != E_SUCCESS)
2317         {
2318                 this->GetValue(_VISION_FACE_RECOGNITION, systemValue);
2319                 if(bValue == true)
2320                         systemValue = _SYSTEM_CACHING_TRUE;
2321                 else
2322                         systemValue = _SYSTEM_CACHING_FALSE;
2323
2324                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_FACE_RECOGNITION, systemValue);
2325                 reg.Flush();
2326         }
2327
2328         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_IMAGE_RECOGNITION, systemValue);
2329         if(r != E_SUCCESS)
2330         {
2331                 this->GetValue(_VISION_IMAGE_RECOGNITION, systemValue);
2332                 if(bValue == true)
2333                         systemValue = _SYSTEM_CACHING_TRUE;
2334                 else
2335                         systemValue = _SYSTEM_CACHING_FALSE;
2336
2337                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_IMAGE_RECOGNITION, systemValue);
2338                 reg.Flush();
2339         }
2340
2341         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_GENERATION, systemValue);
2342         if(r != E_SUCCESS)
2343         {
2344                 this->GetValue(_VISION_QRCODE_GENERATION, systemValue);
2345                 if(bValue == true)
2346                         systemValue = _SYSTEM_CACHING_TRUE;
2347                 else
2348                         systemValue = _SYSTEM_CACHING_FALSE;
2349
2350                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_GENERATION, systemValue);
2351                 reg.Flush();
2352         }
2353
2354         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_RECOGNITION, systemValue);
2355         if(r != E_SUCCESS)
2356         {
2357                 this->GetValue(_VISION_QRCODE_RECOGNITION, systemValue);
2358                 if(bValue == true)
2359                         systemValue = _SYSTEM_CACHING_TRUE;
2360                 else
2361                         systemValue = _SYSTEM_CACHING_FALSE;
2362
2363                 reg.AddValue(_SYSTEM_CACHING_SECTION, _VISION_QRCODE_RECOGNITION, systemValue);
2364                 reg.Flush();
2365         }
2366
2367         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _BUILD_STRING, systemValue);
2368         if(r != E_SUCCESS)
2369         {
2370                 this->GetValue(_BUILD_STRING, systemValue);
2371                 reg.Flush();
2372                 reg.AddValue(_SYSTEM_CACHING_SECTION, _BUILD_STRING, systemValue);
2373                 reg.Flush();
2374
2375         r = this->GetValue(_DUID, sValue);
2376         r = this->GetValue(_DUID, sValue);
2377         if(r != E_SUCCESS)
2378         {
2379                 sValue.Append(L"ERROR");
2380         }
2381         reg.AddValue(_SYSTEM_CACHING_SECTION, _DUID, sValue);
2382                 reg.Flush();
2383         }
2384
2385         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _MODELNAME, sValue);
2386         if(r != E_SUCCESS)
2387         {
2388                 this->GetValue(_MODELNAME, sValue);
2389                 reg.AddValue(_SYSTEM_CACHING_SECTION, _MODELNAME, sValue);
2390                 reg.Flush();
2391         }
2392
2393         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NAME, sValue);
2394         if(r != E_SUCCESS)
2395         {
2396                 this->GetValue(_PLATFORM_NAME, sValue);
2397                 reg.AddValue(_SYSTEM_CACHING_SECTION, _PLATFORM_NAME, sValue);
2398                 reg.Flush();
2399         }
2400
2401         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_MEDIA_VOLUME_MAX, nValue);
2402         if(r != E_SUCCESS)
2403         {
2404                 this->GetValue(_SOUND_MEDIA_VOLUME_MAX, nValue);
2405                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_MEDIA_VOLUME_MAX, nValue);
2406                 reg.Flush();
2407         }
2408
2409         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_NOTIFICATION_VOLUME_MAX, nValue);
2410         if(r != E_SUCCESS)
2411         {
2412                 this->GetValue(_SOUND_NOTIFICATION_VOLUME_MAX, nValue);
2413                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_NOTIFICATION_VOLUME_MAX, nValue);
2414                 reg.Flush();
2415         }
2416
2417         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_RINGTONE_VOLUME_MAX, nValue);
2418         if(r != E_SUCCESS)
2419         {
2420                 this->GetValue(_SOUND_RINGTONE_VOLUME_MAX, nValue);
2421                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_RINGTONE_VOLUME_MAX, nValue);
2422                 reg.Flush();
2423         }
2424
2425         r = reg.GetValue(_SYSTEM_CACHING_SECTION, _SOUND_SYSTEM_VOLUME_MAX, nValue);
2426         if(r != E_SUCCESS)
2427         {
2428                 this->GetValue(_SOUND_SYSTEM_VOLUME_MAX, nValue);
2429                 reg.AddValue(_SYSTEM_CACHING_SECTION, _SOUND_SYSTEM_VOLUME_MAX, nValue);
2430                 reg.Flush();
2431         }
2432
2433         return E_SUCCESS;
2434 }
2435
2436 result
2437 _SystemInfoService::CachingSystemInformation(void)
2438 {
2439         result r = E_SUCCESS;
2440
2441         if(File::IsFileExist(_SYSTEM_CACHING_FILE) == false)
2442         {
2443                 r = CreateCacheFile();
2444         }
2445         else
2446         {
2447                 FileAttributes attr;
2448                 File::GetAttributes(_SYSTEM_CACHING_FILE, attr);
2449                 if(attr.GetFileSize() == 0)
2450                 {
2451                         r = CreateCacheFile();
2452                 }
2453                 else
2454                 {
2455                         r = UpdateCacheFile();
2456                 }
2457         }
2458
2459         return r;
2460 }
2461
2462 result
2463 _SystemInfoService::GetValue(const String& key, String& value)
2464 {
2465         int ret = 0;
2466         result r = E_SUCCESS;
2467         char* pValue = null;
2468
2469         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
2470         if (key == _DUID)
2471         {
2472                 bool supported = false;
2473                 SysLog(NID_SYS, "It trys to get DUID from telephony.");
2474                 this->GetValue(_NETWORK_TELEPHONY, supported);
2475                 if(supported == true)
2476                 {
2477                         r = _DeviceId::GetId(value, 0);
2478                 }
2479                 else
2480                 {
2481                         SysLog(NID_SYS, "It trys to get DUID from wifi.");
2482                         this->GetValue(_NETWORK_WIFI, supported);
2483                         if(supported == true)
2484                         {
2485                                 r = _DeviceId::GetId(value, 1);
2486                         }
2487                         else
2488                         {
2489                                 SysLog(NID_SYS, "It trys to get DUID from bluetooth.");
2490                                 this->GetValue(_NETWORK_BLUETOOTH, supported);
2491                                 if(supported == true)
2492                                 {
2493                                         r = _DeviceId::GetId(value, 2);
2494                                 }
2495                                 else
2496                                 {
2497                                         SysLogException(NID_SYS, E_SYSTEM, "It is failed to get telephony, wifi, bluetooth information.");
2498                                         return E_SYSTEM;
2499                                 }
2500                         }
2501                 }
2502                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get the key[%ls]", key.GetPointer());
2503         }
2504         else if (key == _MODELNAME)
2505         {
2506                 ret = system_info_get_value_string(SYSTEM_INFO_KEY_MODEL, &pValue);
2507                 SysTryReturnResult(NID_SYS, ret == SYSTEM_INFO_ERROR_NONE && pValue, E_SYSTEM, "It is failed to get the SYSTEM_INFO_KEY_MODEL");
2508
2509                 r = StringUtil::Utf8ToString(pValue, value);
2510                 SysTryCatch(NID_SYS, r == E_SUCCESS, r = E_SYSTEM, r, "[%s] StringUtil::Utf8ToString It is failed", GetErrorMessage(r));
2511         }
2512         else if (key == _BUILD_STRING)
2513         {
2514                 ret = system_info_get_value_string(SYSTEM_INFO_KEY_BUILD_STRING, &pValue);
2515                 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");
2516
2517                 r = StringUtil::Utf8ToString(pValue, value);
2518                 SysTryCatch(NID_SYS, r == E_SUCCESS, r = E_SYSTEM, r, "[%s] StringUtil::Utf8ToString It is failed", GetErrorMessage(r));
2519         }
2520         else
2521         {
2522                 String tizenKey;
2523                 key.SubString(7, tizenKey);
2524
2525                 ClearLastResult();
2526                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tizenKey));
2527                 r = GetLastResult();
2528                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
2529                 int ret = system_info_get_platform_string(systemKey.get(), &pValue);
2530
2531                 SysTryReturnResult(NID_SYS, ret == 0, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from the configuration file", key.GetPointer());
2532
2533                 r = StringUtil::Utf8ToString(pValue, value);
2534                 free(pValue);
2535                 pValue = null;
2536
2537                 return r;
2538         }
2539
2540 CATCH:
2541         if(pValue != null)
2542         {
2543                 free(pValue);
2544         }
2545
2546         return r;
2547
2548 }
2549
2550 result
2551 _SystemInfoService::GetValue(const String& key, int& value)
2552 {
2553         int ret = 0;
2554         result r = E_SUCCESS;
2555
2556         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
2557
2558         String tizenKey;
2559         key.SubString(7, tizenKey);
2560
2561         ClearLastResult();
2562         unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tizenKey));
2563         r = GetLastResult();
2564         SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
2565         ret = system_info_get_platform_int(systemKey.get(), &value);
2566
2567         SysTryReturnResult(NID_SYS, ret == 0, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", key.GetPointer());
2568         r = E_SUCCESS;
2569
2570         return r;
2571 }
2572
2573 result
2574 _SystemInfoService::GetValue(const String& key, bool& value)
2575 {
2576         int ret = 0;
2577         result r = E_SUCCESS;
2578
2579         SysLog(NID_SYS, "Request Key is %ls.", key.GetPointer());
2580
2581         if (key == _SCREEN_DESKTOPMODE)
2582         {
2583                 value = false;
2584         }
2585         else if (key == _USB_CLIENT)
2586         {
2587                 value = true;
2588         }
2589         else
2590         {
2591                 String tizenKey;
2592                 key.SubString(7, tizenKey);
2593
2594                 ClearLastResult();
2595                 unique_ptr< char[] > systemKey(_StringConverter::CopyToCharArrayN(tizenKey));
2596                 r = GetLastResult();
2597                 SysTryReturn(NID_SYS, r == E_SUCCESS, E_SYSTEM, r, "[%s] StringUtil::StringToUtf8N It is failed", GetErrorMessage(r));
2598
2599                 bool supported = false;
2600                 ret = system_info_get_platform_bool(systemKey.get(), &supported);
2601                 SysTryReturnResult(NID_SYS, ret == 0, E_OBJ_NOT_FOUND, "It is failed to get system information %ls from configration file.", key.GetPointer());
2602                 value = supported;
2603         }
2604
2605         return E_SUCCESS;
2606 }
2607 } } // Tizen::System