Fix PackageParser for bug
[platform/framework/native/appfw.git] / src / system / FSys_RuntimeInfoImpl.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                FSysRuntimeInfo.cpp
19  * @brief               This is the implementation file for _RuntimeInfoImpl class.
20  *
21  *
22  * This file contains the implementation of _RuntimeInfoImpl class.
23  */
24
25 #include <unique_ptr.h>
26 #include <pthread.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <unistd.h>
31 #include <sys/vfs.h>
32 #include <app_storage.h>
33 #include <devman.h>
34 #include <runtime_info.h>
35 #include <vconf.h>
36
37 #include <FIo.h>
38 #include <FAppApp.h>
39 #include <FBaseRtEvent.h>
40 #include <FBaseRtIEventArg.h>
41 #include <FBaseRtIEventListener.h>
42 #include <FBaseRtThread.h>
43 #include <FBaseSysLog.h>
44 #include <FApp_AppInfo.h>
45 #include <FBase_StringConverter.h>
46
47 #include "FSys_EnvironmentImpl.h"
48 #include "FSys_RuntimeInfoImpl.h"
49 #include "FSys_RuntimeClient.h"
50
51 using namespace Tizen::App;
52 using namespace Tizen::Base;
53 using namespace Tizen::Base::Runtime;
54
55 using namespace std;
56
57 namespace Tizen { namespace System
58 {
59
60 #ifndef VCONFKEY_SERVICE_READY
61 #define VCONFKEY_SERVICE_READY  "memory/deviced/boot_power_on"
62 #endif
63
64 static const wchar_t* _ALLOCATED_MEMORY = L"AllocatedMemory";
65 static const wchar_t* _MEMORY_ALLOCATED = L"http://tizen.org/runtime/memory.allocated";
66 static const wchar_t* _MEMORY_ALLOCATED_SELF = L"http://tizen.org/runtime/memory.allocated.self";
67
68 static const wchar_t* _AVAILABLE_EXTERNAL_STORAGE = L"AvailableExternalStorage";
69 static const wchar_t* _STORAGE_AVAILABLE_EXTERNAL = L"http://tizen.org/runtime/storage.available.external";
70
71 static const wchar_t* _AVAILABLE_INTERNAL_STORAGE = L"AvailableInternalStorage";
72 static const wchar_t* _STORAGE_AVAILABLE_INTERNAL = L"http://tizen.org/runtime/storage.available.internal";
73
74 static const wchar_t* _AVAILABLE_MEDIA_STORAGE = L"AvailableMediaStorage";
75 static const wchar_t* _STORAGE_AVAILABLE_INTERNAL_MEDIA = L"http://tizen.org/runtime/storage.available.internal.media";
76
77 static const wchar_t* _BATTERY_LEVEL = L"BatteryLevel";
78 static const wchar_t* _CHARGING = L"IsCharging";
79
80 static const wchar_t* _CPU_CORE_ALL_USAGE = L"http://tizen.org/runtime/cpu.core.all.usage";
81
82 static const wchar_t* _MAX_ALLOCATABLE_MEMORY = L"MaxAllocatableMemory";
83 static const wchar_t* _AVAILABLE_VIDEO_MEMORY = L"AvailableVideoMemory";
84 static const wchar_t* _ALLOCATED_VIDEO_MEMORY = L"AllocatedVideoMemory";
85 static const wchar_t* _AVAILABLE_MEMORY = L"AvailableMemory";
86 static const wchar_t* _MEMORY_AVAILABLE = L"http://tizen.org/runtime/memory.available";
87 static const wchar_t* _MEMORY_AVAILABLE_VIDEO = L"http://tizen.org/runtime/memory.available.video";
88 static const wchar_t* _MEMORY_ALLOCATED_VIDEO = L"http://tizen.org/runtime/memory.allocated.video";
89
90 static const wchar_t* _STORAGE_ALLOCATED_INTERNAL_APPLICATION = L"http://tizen.org/runtime/storage.allocated.internal.application";
91 static const wchar_t* _STORAGE_ALLOCATED_INTERNAL_AUDIO = L"http://tizen.org/runtime/storage.allocated.internal.audio";
92 static const wchar_t* _STORAGE_ALLOCATED_INTERNAL_VIDEO = L"http://tizen.org/runtime/storage.allocated.internal.video";
93 static const wchar_t* _STORAGE_ALLOCATED_INTERNAL_IMAGE = L"http://tizen.org/runtime/storage.allocated.internal.image";
94 static const wchar_t* _STORAGE_ALLOCATED_INTERNAL_DOWNLOAD = L"http://tizen.org/runtime/storage.allocated.internal.download";
95 static const wchar_t* _STORAGE_ALLOCATED_EXTERNAL_APPLICATION = L"http://tizen.org/runtime/storage.allocated.external.application";
96 static const wchar_t* _STORAGE_ALLOCATED_EXTERNAL_AUDIO = L"http://tizen.org/runtime/storage.allocated.external.audio";
97 static const wchar_t* _STORAGE_ALLOCATED_EXTERNAL_VIDEO = L"http://tizen.org/runtime/storage.allocated.external.video";
98 static const wchar_t* _STORAGE_ALLOCATED_EXTERNAL_IMAGE = L"http://tizen.org/runtime/storage.allocated.external.image";
99 static const wchar_t* _STORAGE_ALLOCATED_EXTERNAL_DOWNLOAD = L"http://tizen.org/runtime/storage.allocated.external.download";
100
101 static const wchar_t _BOOT_STATUS_KEY[] = L"http://tizen.org/runtime/system.status";
102 static const wchar_t _BOOT_STATUS_INITIALIZING[] = L"initializing";
103 static const wchar_t _BOOT_STATUS_READY[]  = L"ready";
104
105
106 static const int _RUNTIME_INFO_EVENT_TYPE_INT = 101;
107 static const int _RUNTIME_INFO_EVENT_TYPE_LONGLONG = 102;
108
109
110 static const char* const _PROC_SYSTEM_MEMORY_INFO = "/proc/meminfo";
111 static const char* const _PROC_PROCESS_MEMORY_INFO = "/proc/self/status";
112 static const char* const _PROC_STAT = "/proc/stat";
113
114 static const char* const _PROC_KEY_SYSTEM_MEMORY_TOTAL = "MemTotal";
115 static const char* const _PROC_KEY_SYSTEM_MEMORY_FREE = "MemFree";
116 static const char* const _PROC_KEY_PROCESS_MEMORY = "VmSize";
117
118 static const char* const _ROOT_PATH = "/";
119
120 static const int _MAX_BUFFER_LENGTH = 1024;
121
122 static const int _CPU_USAGE_EVALUATION_INTERVAL = 1000000; //1 sec
123
124 typedef struct {
125     char cpu[20];
126     unsigned long long user;
127     unsigned long long system;
128     unsigned long long nice;
129     unsigned long long idle;
130     unsigned long long wait;
131     unsigned long long hi;
132     unsigned long long si;
133     unsigned long long zero;
134 } procstat_t;
135
136 bool read_proc_stat(procstat_t *p)
137 {
138         FILE *fp = null;
139         int ret = 0;
140
141         fp = fopen(_PROC_STAT, "r");
142         if(fp == null)
143         {
144                 return false;
145         }
146
147         ret = fscanf(fp, "%s %llu %llu %llu %llu %llu %llu %llu %llu",
148         p->cpu,
149         &p->user,
150         &p->system,
151         &p->nice,
152         &p->idle,
153         &p->wait,
154         &p->hi,
155         &p->si,
156         &p->zero);
157
158         if(ret < 1)
159         {
160                 if(fp != null)
161                 {
162                         fclose(fp);
163                 }
164                 return false;
165         }
166
167         if(fp != null)
168         {
169                 fclose(fp);
170         }
171
172         return true;
173 }
174  
175 void diff_proc_stat(procstat_t *a, procstat_t *b, procstat_t *d)
176 {
177         d->user     = a->user   - b->user;
178         d->system   = a->system - b->system;
179         d->nice     = a->nice   - b->nice;
180         d->idle     = a->idle   - b->idle;
181         d->wait     = a->wait   - b->wait;
182         d->hi       = a->hi     - b->hi;
183         d->si       = a->si     - b->si;
184         d->zero     = a->zero   - b->zero;
185 }
186
187 class _RuntimeInfoEventArg : public IEventArg
188 {
189 public:
190         _RuntimeInfoEventArg()
191         : Type(0)
192         , intValue(0)
193         , longLongValue(0)
194         , errorCode(E_SUCCESS)
195         , DirectoryPath(null)
196         , pListener(null)
197         {
198         }
199
200         ~_RuntimeInfoEventArg()
201         {
202                 if(DirectoryPath != null)
203                 {
204                         delete [] DirectoryPath;
205                 }
206         }
207
208         int Type;
209         int intValue;
210         long long longLongValue;
211         result errorCode;
212         char* DirectoryPath;
213         IEventListener* pListener;
214 };
215
216 class _RuntimeInfoEvent : public Event
217 {
218 protected:
219         void FireImpl(IEventListener& listener, const IEventArg& arg)
220         {
221                 const _RuntimeInfoEventArg* runtimeArg = dynamic_cast<const _RuntimeInfoEventArg*> (&arg);
222
223                 if(runtimeArg == null)
224                 {
225                         SysLogException(NID_SYS, E_SYSTEM, "Argument is null.");
226                         return;
227                 }
228
229                 switch(runtimeArg->Type)
230                 {
231                 case _RUNTIME_INFO_EVENT_TYPE_INT:
232                 {
233                         IRuntimeInfoGetIntAsyncResultListener* pIntListener = dynamic_cast<IRuntimeInfoGetIntAsyncResultListener*>(&listener);
234
235                         if(pIntListener == runtimeArg->pListener)
236                         {                               
237                                 pIntListener->OnResultReceivedForGetValueAsync(runtimeArg->intValue, runtimeArg->errorCode);
238                                 RemoveListener(listener);
239                         }
240                 }
241                 break;
242                 case _RUNTIME_INFO_EVENT_TYPE_LONGLONG:
243                 {
244                         IRuntimeInfoGetLonglongAsyncResultListener* pLonglongListener = dynamic_cast<IRuntimeInfoGetLonglongAsyncResultListener*>(&listener);
245                         if(pLonglongListener == runtimeArg->pListener)
246                         {
247                                 pLonglongListener->OnResultReceivedForGetValueAsync(runtimeArg->longLongValue, runtimeArg->errorCode);
248                                 RemoveListener(listener);
249                         }
250                 }
251                 break;
252                 }
253         }
254 };
255
256 _RuntimeInfoEvent runtimeInfoEvent;
257
258 _RuntimeInfoImpl::_RuntimeInfoImpl(void)
259 {
260 }
261
262 _RuntimeInfoImpl::~_RuntimeInfoImpl(void)
263 {
264 }
265
266 result
267 _RuntimeInfoImpl::GetValue(const String& key, String& value)
268 {
269         if (key == _BOOT_STATUS_KEY)
270         {
271                 int bootReady = -1;
272                 const int errorCode = vconf_get_int(VCONFKEY_SERVICE_READY, &bootReady);
273                 if (errorCode != 0)
274                 {
275                         value = (bootReady == 1 ) ? _BOOT_STATUS_READY : _BOOT_STATUS_INITIALIZING;
276
277                         return E_SUCCESS;
278                 }
279
280                 return E_SYSTEM;
281         }
282         else
283         {
284                 return E_OBJ_NOT_FOUND;
285         }
286 }
287
288 result
289 _RuntimeInfoImpl::GetValue(const String& key, int& value)
290 {
291         int total_size = 0;
292         int free_size =0;
293         result r = E_OBJ_NOT_FOUND;
294
295         if (key == _BATTERY_LEVEL)
296         {
297                 return GetBatteryLevel(value);
298         }
299         else if (key == _ALLOCATED_MEMORY || key == _ALLOCATED_VIDEO_MEMORY)
300         {
301                 r = GetFromProc(_PROC_PROCESS_MEMORY_INFO, _PROC_KEY_PROCESS_MEMORY, free_size);
302                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get memory size.");
303                 value = free_size * 1024;
304         }
305         else if (key == _AVAILABLE_MEMORY || key == _AVAILABLE_VIDEO_MEMORY || key == _MAX_ALLOCATABLE_MEMORY)
306         {
307                 r = GetFromProc(_PROC_SYSTEM_MEMORY_INFO, _PROC_KEY_SYSTEM_MEMORY_FREE, free_size);
308                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get memory size.");
309                 value = free_size * 1024;
310         }
311         return r;
312 }
313
314 result
315 _RuntimeInfoImpl::GetValue(const String& key, long long& value)
316 {
317
318         long long total_size = 0;
319         long long free_size =0;
320         result r = E_OBJ_NOT_FOUND;
321
322         if (key == _MEMORY_AVAILABLE || key == _MEMORY_AVAILABLE_VIDEO)
323         {
324                 r = GetFromProcLonglong(_PROC_SYSTEM_MEMORY_INFO, _PROC_KEY_SYSTEM_MEMORY_FREE, free_size);
325                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get memory size.");
326                 value = free_size * 1024;
327         }
328         else if (key == _MEMORY_ALLOCATED || key == _MEMORY_ALLOCATED_VIDEO)
329         {
330                 r = GetFromProcLonglong(_PROC_SYSTEM_MEMORY_INFO, _PROC_KEY_SYSTEM_MEMORY_TOTAL, total_size);
331                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get memory size.");
332                 r = GetFromProcLonglong(_PROC_SYSTEM_MEMORY_INFO, _PROC_KEY_SYSTEM_MEMORY_FREE, free_size);
333                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get memory size.");
334                 value = (total_size - free_size) * 1024;
335         }
336         else if (key == _MEMORY_ALLOCATED_SELF)
337         {   
338                 r = GetFromProcLonglong(_PROC_PROCESS_MEMORY_INFO, _PROC_KEY_PROCESS_MEMORY, free_size);
339                 SysTryReturnResult(NID_SYS, r == E_SUCCESS, E_SYSTEM, "It is failed to get memory size.");
340                 value = free_size * 1024;
341         } 
342         else if (key == _AVAILABLE_INTERNAL_STORAGE)
343         {
344                 return GetAvailableInternalStorage(value);
345         }
346         else if (key == _AVAILABLE_EXTERNAL_STORAGE)
347         {
348                 return GetAvailableExternalStorage(value);
349         }
350         else if (key == _AVAILABLE_MEDIA_STORAGE)
351         {
352                 return GetAvailableMediaStorage(value);
353         }
354         else if(key == _STORAGE_AVAILABLE_INTERNAL)
355         {
356                 return GetAvailableInternalStorage(value);
357         }
358         else if(key == _STORAGE_AVAILABLE_EXTERNAL)
359         {
360                 return GetAvailableExternalStorage(value);
361         }
362         else if(key == _STORAGE_AVAILABLE_INTERNAL_MEDIA)
363         {
364                 return GetAvailableMediaStorage(value);
365         }
366         else
367         {
368                 SysLogException(NID_SYS, r, "Key[%ls] is not valid.", key.GetPointer());
369         }
370         return r;
371 }
372
373 long long
374 _RuntimeInfoImpl::GetDirectorySize(const char* path)
375 {
376         if(path == null)
377         {
378                 return 0;
379         }
380
381         char command[512] = {0,};
382         char fileName[512] = {0,};
383         long long size = 0;
384         int ret = 0;
385
386         Tizen::App::App* pApp = Tizen::App::App::GetInstance();
387         if(pApp == null)
388         {
389                 return 0;
390         }
391
392         String appId(pApp->GetAppId());
393         unique_ptr <char> appIdPath(_StringConverter::CopyToCharArrayN(appId));
394
395         ret = sprintf(fileName, "/tmp/size_of_directory_%s.tmp", appIdPath.get());
396         if(ret < 1)
397         {
398                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to write file path.");
399                 return 0;
400         }
401
402         ret = sprintf(command, "rm -rf %s", fileName);
403         if(ret < 1)
404         {
405                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to write remove command.");
406                 return 0;
407         }
408
409         ret = system(command);
410
411         if(ret == -1)
412         {
413                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to execute command[%s].", command);
414         }
415
416         ret = sprintf(command, "du -skb -P %s >> %s", path, fileName);
417         if(ret < 1)
418         {
419                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to write du command.");
420                 return 0;
421         }
422
423         ret = system(command);
424         if(ret == -1)
425         {
426                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to execute command[%s].", command);
427                 return 0;
428         }
429
430         FILE* pFile = null;
431         pFile = fopen(fileName, "r");
432         if(pFile == null)
433         {
434                 return 0;
435         }
436
437         ret = fscanf(pFile, "%lld", &size);
438         if(ret < 1)
439         {
440                 if(pFile != null)
441                 {
442                         fclose(pFile);
443                 }
444
445                 return 0;
446         }
447
448         if(pFile != null)
449         {
450                 fclose(pFile);
451         }
452
453         ret = sprintf(command, "rm -rf %s", fileName);
454         if(ret < 1)
455         {
456                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to write remove command.");
457                 return 0;
458         }
459
460         ret = system(command);
461         if(ret == -1)
462         {
463                 SysLogException(NID_SYS, E_SYSTEM, "It is failed to execute command[%s].", command);
464         }
465
466
467         return size;
468 }
469
470 result
471 _RuntimeInfoImpl::GetValue(const String& key, double& value)
472 {
473         return E_OBJ_NOT_FOUND;
474 }
475
476 result
477 _RuntimeInfoImpl::GetValue(const String& key, bool& value)
478 {
479         if (key == _CHARGING)
480         {
481                 return IsChargingMode(value);
482         }
483         else
484         {
485                 return E_OBJ_NOT_FOUND;
486         }
487 }
488
489 result
490 _RuntimeInfoImpl::GetValue(const String& key, UuId& value)
491 {
492         return E_OBJ_NOT_FOUND;
493 }
494
495 result
496 _RuntimeInfoImpl::GetBatteryLevel(int& value)
497 {
498         int batteryValue = -1;
499         batteryValue = device_get_battery_pct();
500         SysTryReturnResult(NID_SYS, !(batteryValue < 0 || value > 100), E_SYSTEM, "[E_SYSTEM] device_get_battery_pct return %d", batteryValue);
501         value = batteryValue;
502
503         return E_SUCCESS;
504 }
505
506 result
507 _RuntimeInfoImpl::IsChargingMode(bool& value)
508 {
509         bool chargeState = false;
510         int ret = 0;
511         ret = runtime_info_get_value_bool(RUNTIME_INFO_KEY_BATTERY_IS_CHARGING, &chargeState);
512         SysTryReturnResult(NID_SYS, ret == 0, E_SYSTEM, "[E_SYSTEM] runtime_info_get_value_bool returns %d.", ret);
513         value = chargeState;
514         return E_SUCCESS;
515
516 }
517
518 result
519 _RuntimeInfoImpl::GetAvailableInternalStorage(long long& value)
520 {
521         long long total = 0;
522         result r = E_SUCCESS;
523
524         r = GetCapacity(_ROOT_PATH, total, value);
525         SysTryReturn(NID_SYS, !IsFailed(r), E_SYSTEM, r, "[E_SYSTEM] system error has occurred. ");
526
527         return E_SUCCESS;
528 }
529 result
530 _RuntimeInfoImpl::GetAvailableExternalStorage(long long& value)
531 {
532         int sdCardStatus = 0;
533         int ret = -1;
534         long long total = 0;
535
536         ret = vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &sdCardStatus);
537         SysTryReturn(NID_SYS, !(ret < 0), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] vconf_get_int VCONFKEY_SYSMAN_MMC_STATUS failed");
538
539         if(sdCardStatus == 0)
540         {
541                 value = 0;
542                 return E_SUCCESS;
543         }
544         char* directoryPath = _StringConverter::CopyToCharArrayN(_EnvironmentImpl::GetExternalStoragePath());
545         SysTryReturnResult(NID_SYS, directoryPath != null, E_SYSTEM, "It is failed to get external directory path.");
546         result r = GetCapacity(directoryPath, total, value);
547         delete [] directoryPath;
548         return r ;
549 }
550
551 result
552 _RuntimeInfoImpl::GetAvailableMediaStorage(long long& value)
553 {
554         long long total = 0;
555
556         char* directoryPath = _StringConverter::CopyToCharArrayN(_EnvironmentImpl::GetMediaPath());
557         SysTryReturnResult(NID_SYS, directoryPath != null, E_SYSTEM, "It is failed to get media directory path.");
558         result r = GetCapacity(directoryPath, total, value);
559         delete [] directoryPath;
560         return r;
561 }
562
563 result
564 _RuntimeInfoImpl::GetCapacity(const char* path, long long& totalSize, long long& availableSize)
565 {
566         struct statfs fs;
567         if (statfs(path, &fs) < 0)
568         {
569                 SysLogException(NID_SYS, E_SYSTEM, "[E_SYSTEM] statfs() failed");
570                 return E_SYSTEM;
571         }
572
573         totalSize = static_cast< long long >(fs.f_bsize) * static_cast< long long >(fs.f_blocks);
574         availableSize = static_cast< long long >(fs.f_bsize) * static_cast< long long >(fs.f_bavail);
575
576         return E_SUCCESS;
577 }
578
579 result
580 _RuntimeInfoImpl::GetFromProcLonglong(const char* path, const char* key, long long& value)
581 {
582         FILE* pStream = null;
583         char line[_MAX_BUFFER_LENGTH] = {0, };
584         char fieldName[_MAX_BUFFER_LENGTH] = {0, };
585         long long keyValue = 0;
586         pStream = fopen(path, "r");
587         SysTryReturnResult(NID_SYS, pStream != null, E_SYSTEM, "%s open is failed.", path);
588
589         while (fgets(line, sizeof(line), pStream))
590         {
591                 if (sscanf(line, "%s %lld %*s", fieldName, &keyValue) == 2)
592                 {
593                         if (strncmp(fieldName, key, static_cast< int >(strlen(key))) == 0)
594                         {
595                                 value = keyValue;
596                                 fclose(pStream);
597                                 return E_SUCCESS;
598                         }
599                 }
600         }
601         fclose(pStream);
602
603         SysLogException(NID_SYS, E_OBJ_NOT_FOUND, "it can't find %s field", key);
604         return E_OBJ_NOT_FOUND;
605 }
606
607 result
608 _RuntimeInfoImpl::GetFromProc(const char* path, const char* key, int& value)
609 {
610         FILE* pStream = null;
611         char line[_MAX_BUFFER_LENGTH] = {0, };
612         char fieldName[_MAX_BUFFER_LENGTH] = {0, };
613         int keyValue = 0;
614         pStream = fopen(path, "r");
615         SysTryReturnResult(NID_SYS, pStream != null, E_SYSTEM, "%s open is failed.", path);
616
617         while (fgets(line, sizeof(line), pStream))
618         {
619                 if (sscanf(line, "%s %d %*s", fieldName, &keyValue) == 2)
620                 {
621                         if (strncmp(fieldName, key, static_cast< int >(strlen(key))) == 0)
622                         {
623                                 value = keyValue;
624                                 fclose(pStream);
625                                 return E_SUCCESS;
626                         }
627                 }
628         }
629         fclose(pStream);
630
631         SysLogException(NID_SYS, E_OBJ_NOT_FOUND, "it can't find %s field", key);
632         return E_OBJ_NOT_FOUND;
633 }
634
635 void*
636 _RuntimeInfoImpl::GetDirectorySizeAsync(void* data)
637 {       
638         if(data == null)
639         {               
640                 return null;
641         }
642         _RuntimeInfoEventArg* pEventArg = (_RuntimeInfoEventArg*)data;
643         long long size = _RuntimeInfoImpl::GetDirectorySize(pEventArg->DirectoryPath);
644
645         if(pEventArg == null)
646         {
647                 SysLogException(NID_SYS, E_OUT_OF_MEMORY, "It is failed to create instance of _RuntimeInfoEventArg");
648                 return null;
649         }
650         pEventArg->Type = _RUNTIME_INFO_EVENT_TYPE_LONGLONG;
651         pEventArg->longLongValue = size;
652         SysLog(NID_SYS, "Fire event %x %s %lld", pEventArg, pEventArg->DirectoryPath, size);
653         runtimeInfoEvent.Fire(*pEventArg);
654         
655         return null;
656 }
657
658 void*
659 _RuntimeInfoImpl::GetCpuUsageAsync(void* data)
660 {
661         result r = E_SUCCESS;
662
663         int value = 0;
664         procstat_t first, second, diffrence;
665         unsigned long long total, usage;
666
667         if(read_proc_stat(&first) != false)
668         {
669                 usleep(_CPU_USAGE_EVALUATION_INTERVAL);
670                 if(read_proc_stat(&second) != false)
671                 {
672                         diff_proc_stat(&second, &first, &diffrence);
673                         total = diffrence.user + diffrence.system 
674                                 + diffrence.nice + diffrence.idle 
675                                 + diffrence.wait + diffrence.hi 
676                                 + diffrence.si;
677                         usage = 10000 - (diffrence.idle * 10000 / total);
678                         value = usage/100;
679                         r = E_SUCCESS;
680                 }
681                 else
682                 {
683                         r = E_SYSTEM;
684                 }
685         }
686         else
687         {
688                 r = E_SYSTEM;
689         }
690
691         _RuntimeInfoEventArg* pEventArg = (_RuntimeInfoEventArg*) data;
692         if(pEventArg == null)
693         {
694                 SysLogException(NID_SYS, E_OUT_OF_MEMORY, "It is failed to create instance of _RuntimeInfoEventArg");
695                 return null;
696         }
697         pEventArg->errorCode = r;
698         pEventArg->Type = _RUNTIME_INFO_EVENT_TYPE_INT;
699         pEventArg->intValue = value;
700
701         runtimeInfoEvent.Fire(*pEventArg);
702
703         return null;
704 }
705
706 result
707 _RuntimeInfoImpl::GetValueAsync(const String& key, IRuntimeInfoGetIntAsyncResultListener* listener)
708 {
709         result r = E_SUCCESS;
710
711         SysTryReturnResult(NID_SYS, listener != null, E_INVALID_ARG, "listener is null");
712
713         if (key == _CPU_CORE_ALL_USAGE)
714         {
715                 if(listener != null)
716                 {
717                         runtimeInfoEvent.AddListener(*listener);
718                 }
719
720                 int thr_id = 0;
721                 pthread_t p_thread;
722                 _RuntimeInfoEventArg* pEventArg = new (std::nothrow) _RuntimeInfoEventArg();
723                 pEventArg->pListener = listener;
724                 thr_id = pthread_create(&p_thread, null, GetCpuUsageAsync, pEventArg);
725                 pthread_detach(p_thread);
726         }
727         else
728         {
729                 SysLogException(NID_SYS, E_INVALID_ARG, "Required key[%ls] is not valid", key.GetPointer());
730                 r = E_INVALID_ARG;
731         }
732         return r;
733 }
734
735 result
736 _RuntimeInfoImpl::GetValueAsync(const String& key, IRuntimeInfoGetLonglongAsyncResultListener* listener)
737 {
738         int thr_id = 0;
739         pthread_t p_thread;
740         result r = E_SUCCESS;
741         String directoryPath;
742
743         SysTryReturnResult(NID_SYS, listener != null, E_INVALID_ARG, "listener is null");
744
745         if(key == _STORAGE_ALLOCATED_INTERNAL_APPLICATION)
746         {
747                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_APPLICATIONS));
748         }       
749         else if (key == _STORAGE_ALLOCATED_INTERNAL_AUDIO)
750         {
751                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_SOUNDS));
752         }
753         else if (key == _STORAGE_ALLOCATED_INTERNAL_VIDEO)
754         {
755                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_VIDEOS));
756         }
757         else if (key == _STORAGE_ALLOCATED_INTERNAL_IMAGE)
758         {
759                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_IMAGES));
760         }
761         else if (key == _STORAGE_ALLOCATED_INTERNAL_DOWNLOAD)
762         {
763                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_DOWNLOADS));
764         }
765         else if (key == _STORAGE_ALLOCATED_EXTERNAL_APPLICATION)
766         {
767                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_EXTERNAL_APPLICATIONS));
768         }
769         else if (key == _STORAGE_ALLOCATED_EXTERNAL_AUDIO)
770         {
771                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_EXTERNAL_SOUNDS));
772         }
773         else if (key == _STORAGE_ALLOCATED_EXTERNAL_VIDEO)
774         {
775                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_EXTERNAL_VIDEOS));
776         }
777         else if (key == _STORAGE_ALLOCATED_EXTERNAL_IMAGE)
778         {
779                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_EXTERNAL_IMAGES));
780         }
781         else if (key == _STORAGE_ALLOCATED_EXTERNAL_DOWNLOAD)
782         {
783                 directoryPath.Append(_EnvironmentImpl::GetPredefinedPath(PREDEFINED_DIRECTORY_EXTERNAL_DOWNLOADS));
784         }
785         else
786         {
787                 SysLogException(NID_SYS, E_INVALID_ARG, "Required key[%ls] is not valid", key.GetPointer());
788                 r = E_INVALID_ARG;
789         }
790
791         SysLog(NID_SYS, "%s", GetErrorMessage(r));
792         SysLog(NID_SYS, "%ls", directoryPath.GetPointer());
793         if(r == E_SUCCESS)
794         {
795                 _RuntimeClient* pRuntimeClient = _RuntimeClient::GetInstance();
796                 pRuntimeClient->GetDirectorySizeValueAsync(directoryPath, listener);
797         }
798
799         return r;
800 }
801
802 _RuntimeInfoImpl*
803 _RuntimeInfoImpl::GetInstance(RuntimeInfo& runtimeinfo)
804 {
805         return runtimeinfo.__pRuntimeInfoImpl;
806 }
807
808 const _RuntimeInfoImpl*
809 _RuntimeInfoImpl::GetInstance(const RuntimeInfo& runtimeinfo)
810 {
811         return runtimeinfo.__pRuntimeInfoImpl;
812 }
813
814 } } //Tizen::System
815