Merge "update media-capability for emulator" into tizen_2.1
[platform/framework/native/appfw.git] / src / app / package / FAppPkg_PackageInfoImpl.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  * @file        FAppPkg_PackageInfoImpl.cpp
18  * @brief       This is the implementation for the _PackageInfoImpl class.
19  */
20 #include <new>
21 #include <cstdio>
22 #include <cstdlib>
23 #include <unistd.h>
24 #include <unique_ptr.h>
25
26 #include <FAppPkgPackageManager.h>
27 #include <FAppPkgPackageAppInfo.h>
28 #include <FAppPkgPackageInfo.h>
29 #include <FIoDatabase.h>
30 #include <FIoDbEnumerator.h>
31 #include <FIoDbStatement.h>
32 #include <FBaseSysLog.h>
33 #include <FBaseUtilStringTokenizer.h>
34 #include <FSecPrivilegeInfo.h>
35
36 #include <FBase_StringConverter.h>
37 #include <FSec_PrivilegeManager.h>
38
39 #include "FApp_PackageManagerProxy.h"
40 #include "FAppPkg_PackageManagerImpl.h"
41 #include "FAppPkg_PackageInfoImpl.h"
42 #include "FAppPkg_PackageAppInfoImpl.h"
43
44 using namespace Tizen::Base;
45 using namespace Tizen::Base::Collection;
46 using namespace Tizen::Base::Utility;
47 using namespace Tizen::Io;
48 using namespace Tizen::Security;
49
50 namespace Tizen { namespace App { namespace Package
51 {
52
53 const PackageId&
54 _PackageInfoImpl::GetId(void) const
55 {
56         return __id;
57 }
58
59 result
60 _PackageInfoImpl::SetId(const PackageId& id)
61 {
62         __id = id;
63         return E_SUCCESS;
64 }
65
66 const String&
67 _PackageInfoImpl::GetVersion(void) const
68 {
69         return __version;
70 }
71
72 result
73 _PackageInfoImpl::SetVersion(const String& version)
74 {
75         __version = version;
76         return E_SUCCESS;
77 }
78
79 PackageType
80 _PackageInfoImpl::GetType(void) const
81 {
82         SysTryReturn(NID_APP, __id.IsEmpty() == false, PACKAGE_TYPE_TPK, E_SYSTEM, "[E_SYSTEM] id.IsEmpty() is empty.");
83
84         result r = E_SUCCESS;
85         PackageType type = PACKAGE_TYPE_TPK;
86
87         _PackageManagerProxy packageManagerProxy;
88         r = packageManagerProxy.Construct();
89         SysTryReturn(NID_APP, r == E_SUCCESS, PACKAGE_TYPE_TPK, E_SYSTEM, "packageManagerProxy.Construct() failed.");
90
91         type = packageManagerProxy.GetType(__id);
92         SysTryReturn(NID_APP, r == E_SUCCESS, PACKAGE_TYPE_TPK, r, "packageManagerProxy.GetType(%ls) failed.", __id.GetPointer());
93
94         return type;
95 }
96
97 result
98 _PackageInfoImpl::SetType(PackageType packageType)
99 {
100         __packageType = packageType;
101         return E_SUCCESS;
102 }
103
104 const String&
105 _PackageInfoImpl::GetDisplayName(void) const
106 {
107         return __displayName;
108 }
109
110 result
111 _PackageInfoImpl::SetDisplayName(const String& displayName)
112 {
113         __displayName = displayName;
114         return E_SUCCESS;
115 }
116
117 const String&
118 _PackageInfoImpl::GetDescription(void) const
119 {
120         return __description;
121 }
122
123 result
124 _PackageInfoImpl::SetDescription(const String& description)
125 {
126         __description = description;
127         return E_SUCCESS;
128 }
129
130 const String&
131 _PackageInfoImpl::GetAuthor(void) const
132 {
133         return __author;
134 }
135
136 result
137 _PackageInfoImpl::SetAuthor(const String& author)
138 {
139         __author = author;
140         return E_SUCCESS;
141 }
142
143 const String&
144 _PackageInfoImpl::GetUrl(void) const
145 {
146         return __url;
147 }
148
149 result
150 _PackageInfoImpl::SetUrl(const String& url)
151 {
152         __url = url;
153         return E_SUCCESS;
154 }
155
156 const DateTime&
157 _PackageInfoImpl::GetInstallationTime(void) const
158 {
159         return __dateTime;
160 }
161
162 result
163 _PackageInfoImpl::SetInstallationTime(const DateTime& installationTime)
164 {
165         __dateTime = installationTime;
166         return E_SUCCESS;
167 }
168
169 bool
170 _PackageInfoImpl::IsInstalledInExternalStorage(void) const
171 {
172         return __externalStorage;
173 }
174
175 result
176 _PackageInfoImpl::SetInstalledInExternalStorage(bool externalStorage)
177 {
178         __externalStorage = externalStorage;
179         return E_SUCCESS;
180 }
181
182 bool
183 _PackageInfoImpl::IsUninstallable(void) const
184 {
185         return __uninstallable;
186 }
187
188 result
189 _PackageInfoImpl::SetUninstallable(bool uninstallable)
190 {
191         __uninstallable = uninstallable;
192         return E_SUCCESS;
193 }
194
195 bool
196 _PackageInfoImpl::IsMovable(void) const
197 {
198         return __movable;
199 }
200
201 result
202 _PackageInfoImpl::SetMovable(bool movable)
203 {
204         __movable = movable;
205         return E_SUCCESS;
206 }
207
208 bool
209 _PackageInfoImpl::IsDownloaded(void) const
210 {
211         return __downloaded;
212 }
213
214 result
215 _PackageInfoImpl::SetDownloaded(bool downloaded)
216 {
217         __downloaded = downloaded;
218         return E_SUCCESS;
219 }
220
221 long long
222 _PackageInfoImpl::GetSize(void) const
223 {
224         int size = 0;
225
226         if (__fromDatabase)
227         {
228                 SysTryReturn(NID_APP, __id.IsEmpty() == false, 0, E_SYSTEM, "id is IsEmpty.");
229
230                 std::unique_ptr<char[]> pPackage(_StringConverter::CopyToCharArrayN(__id));
231                 SysTryReturn(NID_APP, pPackage, 0, E_OUT_OF_MEMORY, "pPackage is null.");
232
233                 void* pClient = pkgmgr_client_new(PC_REQUEST);
234                 SysTryReturn(NID_APP, pClient, 0, E_SYSTEM, "pkgmgr_client_new() failed.");
235
236                 SysLog(NID_APP, "pkgmgr_client_request_service(PM_REQUEST_GET_SIZE, %s)", pPackage.get());
237                 size = pkgmgr_client_request_service(PM_REQUEST_GET_SIZE, 0, pClient, null, pPackage.get(), null, null, null);
238
239           pkgmgr_client_free(pClient);
240         }
241         else
242         {
243                 SysLog(NID_APP, "GetSize() is not available.");
244         }
245
246         SysLog(NID_APP, "size = [%d]", size);
247
248         return (long long) size;
249 }
250
251 long long
252 _PackageInfoImpl::GetDataSize(void) const
253 {
254         int dataSize = 0;
255
256         if (__fromDatabase)
257         {
258                 SysTryReturn(NID_APP, __id.IsEmpty() == false, 0, E_SYSTEM, "id is IsEmpty.");
259
260                 std::unique_ptr<char[]> pPackage(_StringConverter::CopyToCharArrayN(__id));
261                 SysTryReturn(NID_APP, pPackage, 0, E_OUT_OF_MEMORY, "pPackage is null.");
262
263                 void* pClient = pkgmgr_client_new(PC_REQUEST);
264                 SysTryReturn(NID_APP, pClient, 0, E_SYSTEM, "pkgmgr_client_new() failed.");
265
266                 SysLog(NID_APP, "pkgmgr_client_request_service(PM_REQUEST_GET_SIZE, %s)", pPackage.get());
267                 dataSize = pkgmgr_client_request_service(PM_REQUEST_GET_SIZE, 1, pClient, null, pPackage.get(), null, null, null);
268
269           pkgmgr_client_free(pClient);
270         }
271         else
272         {
273                 SysLog(NID_APP, "GetDataSize() is not available.");
274         }
275
276         SysLog(NID_APP, "dataSize = [%d]", dataSize);
277
278         return (long long) dataSize;
279 }
280
281 const AppId&
282 _PackageInfoImpl::GetMainAppId(void) const
283 {
284         return __mainAppId;
285 }
286
287 result
288 _PackageInfoImpl::SetMainAppId(const AppId& appId)
289 {
290         __mainAppId = appId;
291         return E_SUCCESS;
292 }
293
294 const PackageId&
295 _PackageInfoImpl::GetStoreClientId(void) const
296 {
297         return __storeClientId;
298 }
299
300 result
301 _PackageInfoImpl::SetStoreClientId(const PackageId& packageId)
302 {
303         __storeClientId = packageId;
304         return E_SUCCESS;
305 }
306
307 ArrayList*
308 _PackageInfoImpl::GetPackageAppInfoListN(void)
309 {
310         ArrayList* pList = null;
311
312         if (__fromDatabase)
313         {
314                 SysTryReturn(NID_APP, __packageInfoHandle, null, E_SYSTEM, "[E_SYSTEM] __packageInfoHandle is null.");
315
316                 int res = 0;
317
318                 pList = new (std::nothrow) ArrayList;
319                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
320                 pList->Construct();
321
322                 res = pkgmgrinfo_appinfo_get_list(__packageInfoHandle, PMINFO_UI_APP, PackageAppInfoListHandler, (void *)pList);
323                 res = pkgmgrinfo_appinfo_get_list(__packageInfoHandle, PMINFO_SVC_APP, PackageAppInfoListHandler, (void *)pList);
324         }
325         else
326         {
327                 SysTryReturn(NID_APP, __pPackageAppInfoList, null, E_SYSTEM, "__pPackageAppInfoList must not be null.");
328
329                 result r = E_SUCCESS;
330
331                 pList = new (std::nothrow) ArrayList;
332                 SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList must not be null.");
333                 pList->Construct();
334
335                 for (int i = 0; i < __pPackageAppInfoList->GetCount(); i++)
336                 {
337                         PackageAppInfo* pPackageAppInfo = dynamic_cast <PackageAppInfo*>(__pPackageAppInfoList->GetAt(i));
338                         if (pPackageAppInfo)
339                         {
340                                 std::unique_ptr< PackageAppInfo > pInfo(new (std::nothrow) PackageAppInfo);
341                                 SysTryReturn(NID_APP, pInfo, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
342
343                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pInfo.get());
344                                 SysTryReturn(NID_APP, pPackageAppInfoImpl, null, E_SYSTEM, "pPackageAppInfoImpl is null.");
345
346                                 AppId appId = pPackageAppInfo->GetAppId();
347                                 String appName = pPackageAppInfo->GetAppName();
348                                 String appDisplayName = pPackageAppInfo->GetAppDisplayName();
349                                 bool menuIconVisible = pPackageAppInfo->IsMenuIconVisible();
350                                 bool mainApp = pPackageAppInfo->IsMainApp();
351
352                                 pPackageAppInfoImpl->SetAppId(appId);
353                                 pPackageAppInfoImpl->SetAppName(appName);
354                                 pPackageAppInfoImpl->SetAppDisplayName(appDisplayName);
355                                 pPackageAppInfoImpl->SetMenuIconVisible(menuIconVisible);
356                                 pPackageAppInfoImpl->SetMainApp(mainApp);
357
358                                 r = pList->Add(*pInfo.release());
359                         }
360                  }
361         }
362
363         return pList;
364 }
365
366 PackageAppInfo*
367 _PackageInfoImpl::GetPackageAppInfoN(const AppId& appId) const
368 {
369         if (__fromDatabase)
370         {
371                 SysTryReturn(NID_APP, __packageInfoHandle, null, E_SYSTEM, "[E_SYSTEM] __packageInfoHandle is null.");
372
373                 int res = 0;
374                 pkgmgrinfo_appinfo_h appInfoHandle = null;
375
376                 std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
377                 SysTryReturn(NID_APP, pAppId, null, E_OUT_OF_MEMORY, "pAppId is null");
378
379                 res = pkgmgrinfo_appinfo_get_appinfo(pAppId.get(), &appInfoHandle);
380                 if (res == 0)
381                 {
382                         SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appinfo(): app = [%s]", pAppId.get());
383
384                         PackageAppInfo* pPackageAppInfo = new (std::nothrow) PackageAppInfo;
385                         SysTryReturn(NID_APP, pPackageAppInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
386
387                         GetPackageAppInfo(appInfoHandle, pPackageAppInfo);
388
389                         return pPackageAppInfo;
390                 }
391                 else
392                 {
393                         SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appinfo() is failed. result = [%d]", res);
394                 }
395         }
396         else
397         {
398                 SysTryReturn(NID_APP, __pPackageAppInfoList, null, E_SYSTEM, "__pPackageAppInfoList must not be null.");
399
400                 for (int i = 0; i < __pPackageAppInfoList->GetCount(); i++)
401                 {
402                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(__pPackageAppInfoList->GetAt(i));
403                         if (pPackageAppInfo)
404                         {
405                                 if (appId != pPackageAppInfo->GetAppId())
406                                 {
407                                         continue;
408                                 }
409
410                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
411                                 SysTryReturn(NID_APP, pPackageAppInfoImpl, null, E_SYSTEM, "pPackageAppInfoImpl is null.");
412
413                                 std::unique_ptr< PackageAppInfo > pInfo(new (std::nothrow) PackageAppInfo);
414                                 SysTryReturn(NID_APP, pInfo, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
415
416                                 _PackageAppInfoImpl* pImpl = _PackageAppInfoImpl::GetInstance(pInfo.get());
417                                 SysTryReturn(NID_APP, pImpl, null, E_SYSTEM, "pImpl is null.");
418
419                                 String appName = pPackageAppInfo->GetAppName();
420                                 String appDisplayName = pPackageAppInfo->GetAppDisplayName();
421                                 bool menuIconVisible = pPackageAppInfo->IsMenuIconVisible();
422                                 bool mainApp = pPackageAppInfo->IsMainApp();
423                                 String tempIconPath = pPackageAppInfoImpl->GetAppTempIconPath();
424
425                                 pImpl->SetAppId(appId);
426                                 pImpl->SetAppName(appName);
427                                 pImpl->SetAppDisplayName(appDisplayName);
428                                 pImpl->SetMenuIconVisible(menuIconVisible);
429                                 pImpl->SetMainApp(mainApp);
430                                 pImpl->SetAppTempIconPath(tempIconPath);
431
432                                 return pInfo.release();
433                         }
434                  }
435         }
436
437         return null;
438 }
439
440 int
441 _PackageInfoImpl::PackageAppInfoListHandler(const pkgmgrinfo_appinfo_h handle, void* pUser_data)
442 {
443         ArrayList* pList = (ArrayList*) pUser_data;
444
445         PackageAppInfo* pPackageAppInfo = new (std::nothrow) PackageAppInfo;
446         SysTryReturn(NID_APP, pPackageAppInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
447
448         GetPackageAppInfo(handle, pPackageAppInfo);
449
450         pList->Add(*pPackageAppInfo);
451
452         return 0;
453 }
454
455 bool
456 _PackageInfoImpl::GetPackageAppInfo(const pkgmgrinfo_appinfo_h handle, PackageAppInfo* pPackageAppInfo)
457 {
458         SysTryReturn(NID_APP, pPackageAppInfo, false, E_INVALID_ARG, "[E_INVALID_ARG] pPackageAppInfo is null.");
459
460         int res = 0;
461         char* pAppId = null;
462
463         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
464
465         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
466         if (res == 0)
467         {
468                 SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appid(): app = [%s]", pAppId);
469                 pPackageAppInfoImpl->Construct(pAppId);
470         }
471         else
472         {
473                 SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appid() is failed. result = [%d]", res);
474         }
475
476         return true;
477 }
478
479 IList*
480 _PackageInfoImpl::GetPrivilegeListN(void) const
481 {
482         result r = E_SUCCESS;
483
484         std::unique_ptr< ArrayList > pPrivilegeList(new (std::nothrow) ArrayList);
485         SysTryReturn(NID_APP, pPrivilegeList, null, E_OUT_OF_MEMORY, "pPrivilegeList must not be null.");
486         pPrivilegeList->Construct();
487
488         if (__fromDatabase)
489         {
490                 SysTryReturn(NID_APP, __id.IsEmpty() == false, null, E_SYSTEM, "__id is empty.");
491
492                 std::unique_ptr< IList > pList(_PrivilegeManager::GetPrivilegeListN(__id));
493                 if (pList == null)
494                 {
495                         SysLog(NID_APP, "_PrivilegeManager::GetPrivilegeListN() is null.");
496                         return null;
497                 }
498
499                 for (int i = 0; i < pList->GetCount(); i++)
500                 {
501                         String* pPrivilege = dynamic_cast < String* >(pList->GetAt(i));
502                         if (pPrivilege)
503                         {
504                                 std::unique_ptr< PrivilegeInfo > pPrivilegeInfo(new (std::nothrow) PrivilegeInfo);
505                                 SysTryReturn(NID_APP, pPrivilegeInfo, null, E_OUT_OF_MEMORY, "pPrivilegeInfo must not be null.");
506
507                                 r = pPrivilegeInfo->Construct(*pPrivilege);
508                                 SysTryReturn(NID_APP, !IsFailed(r), null, E_SYSTEM, "pPrivilegeInfo->Construct() failed.");
509
510                                 r = pPrivilegeList->Add(*pPrivilegeInfo.release());
511                                 SysTryReturn(NID_APP, !IsFailed(r), null, E_SYSTEM, "pPrivilegeList->Add() failed.");
512                         }
513                  }
514         }
515         else
516         {
517                 if (__pPrivilegeList)
518                 {
519                         for (int i = 0; i < __pPrivilegeList->GetCount(); i++)
520                         {
521                                 String* pPrivilege = dynamic_cast < String* >(__pPrivilegeList->GetAt(i));
522                                 if (pPrivilege)
523                                 {
524                                         std::unique_ptr< PrivilegeInfo > pPrivilegeInfo(new (std::nothrow) PrivilegeInfo);
525                                         SysTryReturn(NID_APP, pPrivilegeInfo, null, E_OUT_OF_MEMORY, "pPrivilegeInfo must not be null.");
526
527                                         r = pPrivilegeInfo->Construct(*pPrivilege);
528                                         SysTryReturn(NID_APP, !IsFailed(r), null, E_SYSTEM, "pPrivilegeInfo->Construct() failed.");
529
530                                         r = pPrivilegeList->Add(*pPrivilegeInfo.release());
531                                         SysTryReturn(NID_APP, !IsFailed(r), null, E_SYSTEM, "pPrivilegeList->Add() failed.");
532                                 }
533                          }
534                 }
535         }
536
537         if (pPrivilegeList->GetCount() <= 0)
538         {
539                 SysLog(NID_APP, "pPrivilegeList->GetCount() is invalid.");
540                 return null;
541         }
542
543         return pPrivilegeList.release();
544 }
545
546 result
547 _PackageInfoImpl::AddPrivilege(const String& privilege)
548 {
549         result r = E_SUCCESS;
550
551         r = __pPrivilegeList->Add(privilege);
552         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pPrivilegeList->Add() is failed.");
553
554         return r;
555 }
556
557 result
558 _PackageInfoImpl::AddPackageAppInfo(const PackageAppInfo& packageAppInfo)
559 {
560         result r = E_SUCCESS;
561         r = __pPackageAppInfoList->Add(packageAppInfo);
562         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pPackageAppInfoList->Add() is failed.");
563
564         return r;
565 }
566
567 // to be reviewed
568 _PackageInfoImpl::_PackageInfoImpl(void)
569         : __appReadOnlySize(0)
570         , __appDataSize(0)
571         , __appStorageType(0)
572         , __appState(0)
573         , __certType(0)
574         , __pPrivilegeList(null)
575         , __pAppInfoImplList(null)
576         , __pPackageAppInfoList(null)
577         , __packageInfoHandle(null)
578         , __uninstallable(true)
579         , __movable(false)
580         , __downloaded(false)
581         , __iconAvailable(false)
582         , __externalStorage(false)
583         , __fromDatabase(false)
584         , __packageType(PACKAGE_TYPE_TPK)
585         , __pPackageInfo(null)
586 {
587         __pAppInfoImplList = new (std::nothrow) ArrayList;
588         SysTryReturnVoidResult(NID_APP, __pAppInfoImplList != null, E_OUT_OF_MEMORY, "__pAppInfoImplList instance must not be null.");
589         __pAppInfoImplList->Construct();
590
591         __pPackageAppInfoList = new (std::nothrow) ArrayList;
592         SysTryReturnVoidResult(NID_APP, __pPackageAppInfoList != null, E_OUT_OF_MEMORY, "__pPackageAppInfoList instance must not be null.");
593         __pPackageAppInfoList->Construct();
594
595         __pPrivilegeList = new (std::nothrow) ArrayList;
596         SysTryReturnVoidResult(NID_APP, __pPrivilegeList != null, E_OUT_OF_MEMORY, "__pPrivilegeList must not be null.");
597         __pPrivilegeList->Construct();
598 }
599
600 _PackageInfoImpl::~_PackageInfoImpl(void)
601 {
602         __pAppInfoImplList->RemoveAll(true);
603         delete __pAppInfoImplList;
604
605         __pPackageAppInfoList->RemoveAll(true);
606         delete __pPackageAppInfoList;
607
608         __pPrivilegeList->RemoveAll(true);
609         delete __pPrivilegeList;
610
611         if (__packageInfoHandle)
612         {
613                 pkgmgrinfo_pkginfo_destroy_pkginfo(__packageInfoHandle);
614         }
615 }
616
617 const String&
618 _PackageInfoImpl::GetAppId(void) const
619 {
620         return __id;
621 }
622
623 result
624 _PackageInfoImpl::SetAppId(const String& id)
625 {
626         __id = id;
627         return E_SUCCESS;
628 }
629
630 const String&
631 _PackageInfoImpl::GetAppVersion(void) const
632 {
633         return __version;
634 }
635
636 result
637 _PackageInfoImpl::SetAppVersion(const String& appVersion)
638 {
639         __version = appVersion;
640         return E_SUCCESS;
641 }
642
643 const String&
644 _PackageInfoImpl::GetAppType(void) const
645 {
646         return __type;
647 }
648
649 result
650 _PackageInfoImpl::SetAppType(const String& appType)
651 {
652         __type = appType;
653         return E_SUCCESS;
654 }
655
656 const String&
657 _PackageInfoImpl::GetAppMimeType(void) const
658 {
659         return __appMimeType;
660 }
661
662 result
663 _PackageInfoImpl::SetAppMimeType(const String& appMimeType)
664 {
665         __appMimeType = appMimeType;
666         return E_SUCCESS;
667 }
668
669 const String&
670 _PackageInfoImpl::GetAppApiVersion(void) const
671 {
672         return __appApiVersion;
673 }
674
675 result
676 _PackageInfoImpl::SetAppApiVersion(const String& appApiVersion)
677 {
678         __appApiVersion = appApiVersion;
679         return E_SUCCESS;
680 }
681
682 const String&
683 _PackageInfoImpl::GetAppName(void) const
684 {
685         return __displayName;
686 }
687
688 result
689 _PackageInfoImpl::SetAppName(const String& appName)
690 {
691         __displayName = appName;
692         return E_SUCCESS;
693 }
694
695 const String&
696 _PackageInfoImpl::GetAppDescription(void) const
697 {
698         return __description;
699 }
700
701 result
702 _PackageInfoImpl::SetAppDescription(const String& appDescription)
703 {
704         __description = appDescription;
705         return E_SUCCESS;
706 }
707
708 const String&
709 _PackageInfoImpl::GetAppVendor(void) const
710 {
711         return __author;
712 }
713
714 result
715 _PackageInfoImpl::SetAppVendor(const String& appVendor)
716 {
717         __author = appVendor;
718         return E_SUCCESS;
719 }
720
721 const String&
722 _PackageInfoImpl::GetAppUrl(void) const
723 {
724         return __url;
725 }
726
727 result
728 _PackageInfoImpl::SetAppUrl(const String& appUrl)
729 {
730         __url = appUrl;
731         return E_SUCCESS;
732 }
733
734 const String&
735 _PackageInfoImpl::GetAppCid(void) const
736 {
737         return __appCid;
738 }
739
740 result
741 _PackageInfoImpl::SetAppCid(const String& appCid)
742 {
743         __appCid = appCid;
744         return E_SUCCESS;
745 }
746
747 const String&
748 _PackageInfoImpl::GetAppRootPath(void) const
749 {
750         return __appRootPath;
751 }
752
753 result
754 _PackageInfoImpl::SetAppRootPath(const String& appRootPath)
755 {
756         __appRootPath = appRootPath;
757         return E_SUCCESS;
758 }
759
760 int
761 _PackageInfoImpl::GetAppStorageType(void) const
762 {
763         return __appStorageType;
764 }
765
766 result
767 _PackageInfoImpl::SetAppStorageType(int appStorageType)
768 {
769         __appStorageType = appStorageType;
770         return E_SUCCESS;
771 }
772
773 int
774 _PackageInfoImpl::GetCertType(void) const
775 {
776         return __certType;
777 }
778
779 result
780 _PackageInfoImpl::SetCertType(int certType)
781 {
782         __certType = certType;
783         return E_SUCCESS;
784 }
785
786 ArrayList*
787 _PackageInfoImpl::GetAppInfoListN(void) const
788 {
789         result r = E_SUCCESS;
790         Database db;
791         DbStatement* pStmt = null;
792         DbEnumerator* pEnum = null;
793         String query;
794         //int id = 0;
795         ArrayList* pList = null;
796
797         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", GetUniqueId());
798
799         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
800         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
801
802         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
803         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
804
805         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
806         if (pEnum != null)
807         {
808                 pList = new (std::nothrow) ArrayList;
809                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
810                 pList->Construct();
811
812                 while (pEnum->MoveNext() == E_SUCCESS)
813                 {
814                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
815                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
816
817                         int uniqueId = 0;
818                         int pkgId = 0;
819                         String name;
820                         String type;
821                         String defaultapp;
822                         String mainmenuIcon;
823                         String settingIcon;
824                         //String tickerIcon;
825                         String quickpanelIcon;
826                         //String launchImageIcon;
827                         int appFeature = 0;
828                         String packageName;
829
830                         pEnum->GetIntAt(0, uniqueId);
831                         pEnum->GetIntAt(1, pkgId);
832                         pEnum->GetStringAt(2, name);
833                         pEnum->GetStringAt(3, type);
834                         pEnum->GetStringAt(4, defaultapp);
835                         pEnum->GetStringAt(5, mainmenuIcon);
836                         pEnum->GetStringAt(6, settingIcon);
837                         //pEnum->GetStringAt(7, tickerIcon);
838                         pEnum->GetStringAt(8, quickpanelIcon);
839                         //pEnum->GetStringAt(9, launchImageIcon);
840                         pEnum->GetIntAt(10, appFeature);
841                         pEnum->GetStringAt(11, packageName);
842
843                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
844                         pPackageAppInfoImpl->SetPkgId(pkgId);
845                         pPackageAppInfoImpl->SetName(name);
846                         pPackageAppInfoImpl->SetType(type);
847                         pPackageAppInfoImpl->SetDefault(defaultapp);
848                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
849                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
850                         //pPackageAppInfoImpl->SetTickerIcon(tickerIcon);
851                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
852                         //pPackageAppInfoImpl->SetLaunchImageIcon(launchImageIcon);
853                         pPackageAppInfoImpl->SetAppFeature(appFeature);
854                         pPackageAppInfoImpl->SetPackageName(packageName);
855
856                         pList->Add(*pPackageAppInfoImpl);
857                 }
858
859                 delete pEnum;
860         }
861
862 CATCH:
863         delete pStmt;
864         return pList;
865 }
866
867 ArrayList*
868 _PackageInfoImpl::GetAppInfoList(void)
869 {
870         if (__pAppInfoImplList == null)
871         {
872                 __pAppInfoImplList = GetAppInfoListN();
873         }
874
875         return __pAppInfoImplList;
876 }
877
878 result
879 _PackageInfoImpl::AddAppInfo(const _PackageAppInfoImpl& appInfoImpl)
880 {
881         result r = E_SUCCESS;
882         r = __pAppInfoImplList->Add(appInfoImpl);
883         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pAppInfoImplList->Add() is failed.");
884
885         return r;
886 }
887
888 result
889 _PackageInfoImpl::GetPrivileges(String& privileges, String& hmacPrivileges, ArrayList& privilegeList)
890 {
891         result r = E_SUCCESS;
892         Database db;
893         DbStatement* pStmt = null;
894         DbEnumerator* pEnum = null;
895         String query;
896
897         String privilegeListString;
898         String delim("#");
899         String privilegeToken;
900
901
902         query.Format(1024, L"SELECT * FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
903
904         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
905         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
906
907         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
908         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
909
910         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
911         if (pEnum != null)
912         {
913                 if (pEnum->MoveNext() == E_SUCCESS)
914                 {
915                         pEnum->GetStringAt(1, privileges);
916                         pEnum->GetStringAt(2, hmacPrivileges);
917                         pEnum->GetStringAt(4, privilegeListString);
918                 }
919
920                 StringTokenizer strTok(privilegeListString, delim);
921
922                 while (strTok.HasMoreTokens())
923                 {
924                         strTok.GetNextToken(privilegeToken);
925                         privilegeList.Add(new String(privilegeToken));
926                 }
927
928                 delete pEnum;
929                 pEnum = null;
930         }
931
932 CATCH:
933         delete pStmt;
934         pStmt = null;
935         return r;
936 }
937
938 result
939 _PackageInfoImpl::GetPrivilegesValue(String& privileges, String& hmacPrivileges) const
940 {
941         privileges = __privileges;
942         hmacPrivileges = __hmacPrivileges;
943
944         return E_SUCCESS;
945 }
946
947 result
948 _PackageInfoImpl::SetPrivilegesValue(const String& privileges, const String& hmacPrivileges)
949 {
950         __privileges = privileges;
951         __hmacPrivileges = hmacPrivileges;
952
953         return E_SUCCESS;
954 }
955
956 int
957 _PackageInfoImpl::GetApiVisibility() const
958 {
959         result r = E_SUCCESS;
960         int apiVisibility = 0;
961         Database db;
962         DbStatement* pStmt = null;
963         DbEnumerator* pEnum = null;
964         String query;
965
966         query.Format(1024, L"SELECT CERTIFICATE_TYPE FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
967
968         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
969         SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
970
971         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
972         SysTryCatch(NID_APP, pStmt != null, apiVisibility = -1, GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
973
974         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
975         if (pEnum != null)
976         {
977                 if (pEnum->MoveNext() == E_SUCCESS)
978                 {
979                         if (pEnum->GetColumnType(0) != DB_COLUMNTYPE_NULL)
980                         {
981                                 r = pEnum->GetIntAt(0, apiVisibility);
982                                 SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] GetIntAt() is failed.", GetErrorMessage(r));
983                         }
984                 }
985
986                 delete pEnum;
987                 pEnum = null;
988         }
989
990 CATCH:
991         delete pStmt;
992         pStmt = null;
993         return apiVisibility;
994 }
995
996 const String&
997 _PackageInfoImpl::GetAppIconPath(void) const
998 {
999         return __appIconPath;
1000 }
1001
1002 result
1003 _PackageInfoImpl::SetAppIconPath(const Tizen::Base::String& appIconPath)
1004 {
1005         __appIconPath = appIconPath;
1006
1007         return E_SUCCESS;
1008 }
1009
1010 const DateTime&
1011 _PackageInfoImpl::GetAppInstallationTime(void) const
1012 {
1013         return __dateTime;
1014 }
1015
1016 result
1017 _PackageInfoImpl::SetAppInstallationTime(const DateTime& installationTime)
1018 {
1019         __dateTime = installationTime;
1020
1021         return E_SUCCESS;
1022 }
1023
1024 result
1025 _PackageInfoImpl::Construct(const PackageId& packageId)
1026 {
1027         result r = E_SUCCESS;
1028         int result = 0;
1029         char* pPackage = null;
1030         char* pVersion = null;
1031         char* pName = null;
1032         char* pIconPath = null;
1033         char* pType = null;
1034         char* pDescription = null;
1035         char* pAuthor = null;
1036         char* pUrl = null;
1037         char* pMainAppId = null;
1038         char* pStoreClientId = null;
1039         char* pRootPath = null;
1040         int installedTime = 0;
1041         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
1042         bool removable = true;
1043         bool preloaded = true;
1044
1045         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
1046         SysTryReturnResult(NID_APP, pPackageId, E_OUT_OF_MEMORY, "pPackageId is null");
1047
1048         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &__packageInfoHandle);
1049         SysTryReturnResult(NID_APP, result == PMINFO_R_OK, E_PKG_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() is failed. result=[%d], package=[%s]", result, pPackageId.get());
1050
1051         __fromDatabase = true;
1052
1053         result = pkgmgrinfo_pkginfo_get_pkgname(__packageInfoHandle, &pPackage);
1054         if (result == PMINFO_R_OK)
1055         {
1056                 String package(pPackage);
1057                 __id = package;
1058         }
1059         else
1060         {
1061                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1062         }
1063
1064         result = pkgmgrinfo_pkginfo_get_version(__packageInfoHandle, &pVersion);
1065         if (result == PMINFO_R_OK)
1066         {
1067                 String version(pVersion);
1068                 __version = version;
1069         }
1070         else
1071         {
1072                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_version() is failed. result = [%d]", result);
1073         }
1074
1075         result = pkgmgrinfo_pkginfo_get_type(__packageInfoHandle, &pType);
1076         if (result == PMINFO_R_OK)
1077         {
1078                 String type(pType);
1079                 __type = type;
1080         }
1081         else
1082         {
1083                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_type() is failed. result = [%d]", result);
1084         }
1085
1086         result = pkgmgrinfo_pkginfo_get_label(__packageInfoHandle, &pName);
1087         if (result == PMINFO_R_OK)
1088         {
1089                 String Name(pName);
1090                 __displayName = Name;
1091         }
1092         else
1093         {
1094                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_label() is failed. result = [%d]", result);
1095         }
1096
1097         result = pkgmgrinfo_pkginfo_get_icon(__packageInfoHandle, &pIconPath);
1098         if (result == PMINFO_R_OK)
1099         {
1100                 String path(pIconPath);
1101                 __appIconPath = path;
1102         }
1103         else
1104         {
1105                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_icon() is failed. result = [%d]", result);
1106         }
1107
1108         result = pkgmgrinfo_pkginfo_is_removable(__packageInfoHandle, &removable);
1109         if (result == PMINFO_R_OK)
1110         {
1111                 if (removable == false)
1112                 {
1113                         __uninstallable = false;
1114                 }
1115         }
1116         else
1117         {
1118                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_removable() is failed. result = [%d]", result);
1119         }
1120
1121         result = pkgmgrinfo_pkginfo_is_preload(__packageInfoHandle, &preloaded);
1122         if (result == PMINFO_R_OK)
1123         {
1124                 if (preloaded == false)
1125                 {
1126                         __downloaded = true;
1127                 }
1128         }
1129         else
1130         {
1131                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_preload() is failed. result = [%d]", result);
1132         }
1133
1134         result = pkgmgrinfo_pkginfo_get_description(__packageInfoHandle, &pDescription);
1135         if (result == PMINFO_R_OK)
1136         {
1137                 String description(pDescription);
1138                 __description = description;
1139         }
1140         else
1141         {
1142                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_description() is failed. result = [%d]", result);
1143         }
1144
1145         result = pkgmgrinfo_pkginfo_get_author_name(__packageInfoHandle, &pAuthor);
1146         if (result == PMINFO_R_OK)
1147         {
1148                 String author(pAuthor);
1149                 __author = author;
1150         }
1151         else
1152         {
1153                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_author_name() is failed. result = [%d]", result);
1154         }
1155
1156         result = pkgmgrinfo_pkginfo_get_installed_time(__packageInfoHandle, &installedTime);
1157         if (result == PMINFO_R_OK)
1158         {
1159                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_time(): installedTime = [%d]", installedTime);
1160
1161                 time_t dateTime = (time_t) installedTime;
1162                 struct tm* pGmTime = null;
1163
1164                 pGmTime = gmtime(&dateTime);
1165                 if (pGmTime)
1166                 {
1167                         DateTime tempTime;
1168                         tempTime.SetValue(pGmTime->tm_year + 1900, pGmTime->tm_mon + 1, pGmTime->tm_mday, pGmTime->tm_hour, pGmTime->tm_min, pGmTime->tm_sec);
1169                         __dateTime = tempTime;
1170                         SysLog(NID_APP, "Time %d %d/%d, %d:%d:%d", tempTime.GetYear(), tempTime.GetMonth(), tempTime.GetDay(), tempTime.GetHour(), tempTime.GetMinute(), tempTime.GetSecond());
1171                 }
1172         }
1173         else
1174         {
1175                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_time() is failed. result = [%d]", result);
1176         }
1177
1178         result = pkgmgrinfo_pkginfo_get_installed_storage(__packageInfoHandle, &storage);
1179         if (result == PMINFO_R_OK)
1180         {
1181                 if (storage == PMINFO_EXTERNAL_STORAGE)
1182                 {
1183                         __externalStorage = true;
1184                 }
1185         }
1186         else
1187         {
1188                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage() is failed. result = [%d]", result);
1189         }
1190
1191         result = pkgmgrinfo_pkginfo_get_url(__packageInfoHandle, &pUrl);
1192         if (result == PMINFO_R_OK)
1193         {
1194                 String url(pUrl);
1195                 __url = url;
1196         }
1197         else
1198         {
1199                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_url() is failed. result = [%d]", result);
1200         }
1201
1202         result = pkgmgrinfo_pkginfo_get_mainappid(__packageInfoHandle, &pMainAppId);
1203         if (result == PMINFO_R_OK)
1204         {
1205                 AppId mainAppId(pMainAppId);
1206                 __mainAppId = mainAppId;
1207         }
1208         else
1209         {
1210                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_mainappid() is failed. result = [%d]", result);
1211         }
1212
1213         result = pkgmgrinfo_pkginfo_get_storeclientid(__packageInfoHandle, &pStoreClientId);
1214         if (result == PMINFO_R_OK)
1215         {
1216                 String storeClientId(pStoreClientId);
1217                 __storeClientId = storeClientId;
1218         }
1219         else
1220         {
1221                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_storeclientid() is failed. result = [%d]", result);
1222         }
1223
1224         result = pkgmgrinfo_pkginfo_get_root_path(__packageInfoHandle, &pRootPath);
1225         if (result == PMINFO_R_OK)
1226         {
1227                 String rootPath(pRootPath);
1228                 __appRootPath = rootPath;
1229         }
1230         else
1231         {
1232                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_root_path() is failed. result = [%d]", result);
1233         }
1234
1235         SysLog(NID_APP, "package(%ls), version(%ls), type(%ls), displayName(%ls), uninstallable(%d), downloaded(%d), "
1236                                                                         "externalStorage(%d), mainApp(%ls), storeClient(%ls), appRootPath(%ls)",
1237                         __id.GetPointer(), __version.GetPointer(), __type.GetPointer(), __displayName.GetPointer(), __uninstallable, __downloaded,
1238                         __externalStorage, __mainAppId.GetPointer(), __storeClientId.GetPointer(), __appRootPath.GetPointer());
1239
1240         return r;
1241 }
1242
1243 int
1244 _PackageInfoImpl::GetUniqueId(void) const
1245 {
1246         result r = E_SUCCESS;
1247         Database db;
1248         DbStatement* pStmt = null;
1249         DbEnumerator* pEnum = null;
1250         String query;
1251         int uniqueId = 0;
1252
1253         query.Format(1024, L"SELECT UNIQUE_ID FROM PkgInfo WHERE PKG_ID = '%ls'", __id.GetPointer());
1254
1255         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1256         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1257
1258         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1259         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1260
1261         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1262         if (pEnum != null)
1263         {
1264                 if (pEnum->MoveNext() == E_SUCCESS)
1265                 {
1266                         pEnum->GetIntAt(0, uniqueId);
1267                 }
1268
1269                 delete pEnum;
1270         }
1271         else
1272         {
1273                 r = E_OBJ_NOT_FOUND;
1274         }
1275
1276 CATCH:
1277         delete pStmt;
1278
1279         return uniqueId;
1280 }
1281
1282 result
1283 _PackageInfoImpl::GetUiScalabilityInfo(String& baseScreenSize, String& coordinateSystem, String& logicalCoordinate) const
1284 {
1285         result r = E_SUCCESS;
1286         Database db;
1287         DbStatement* pStmt = null;
1288         DbEnumerator* pEnum = null;
1289         String query;
1290
1291         query.Format(1024,
1292                 L"SELECT AppFeature.NAME, AppFeature.VALUE FROM AppFeature, AppInfo WHERE AppFeature.ID = AppInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = 'True' and AppInfo.ID = %d", GetUniqueId());
1293
1294         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1295         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1296
1297         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1298         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1299                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1300
1301         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1302         if (pEnum != null)
1303         {
1304                 while (pEnum->MoveNext() == E_SUCCESS)
1305                 {
1306                         String name;
1307                         String value;
1308
1309                         pEnum->GetStringAt(0, name);
1310                         pEnum->GetStringAt(1, value);
1311
1312                         if (name == L"CoordinateSystem")
1313                         {
1314                                 coordinateSystem = value;
1315                         }
1316                         else if (name == L"BaseScreenSize")
1317                         {
1318                                 baseScreenSize = value;
1319                         }
1320                         else if (name == L"LogicalCoordinate")
1321                         {
1322                                 logicalCoordinate = value;
1323                         }
1324                 }
1325                 delete pEnum;
1326         }
1327         else
1328         {
1329                 r = E_OBJ_NOT_FOUND;
1330                 SetLastResult(r);
1331         }
1332
1333 CATCH:
1334         delete pStmt;
1335
1336         return r;
1337 }
1338
1339 // to be removed
1340 const String&
1341 _PackageInfoImpl::GetAppPackageName(void)
1342 {
1343         if (__appPackageName.IsEmpty() == false)
1344         {
1345                 return __appPackageName;
1346         }
1347
1348         result r = E_SUCCESS;
1349         Database db;
1350         DbStatement* pStmt = null;
1351         DbEnumerator* pEnum = null;
1352         String query;
1353
1354         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo WHERE AppInfo.APP_DEFAULT = 'True' and ID = %d", GetUniqueId());
1355
1356         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1357         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1358
1359         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1360         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1361
1362         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1363         if (pEnum != null)
1364         {
1365                 if (pEnum->MoveNext() == E_SUCCESS)
1366                 {
1367                         pEnum->GetStringAt(0, __appPackageName);
1368                 }
1369
1370                 delete pEnum;
1371                 pEnum = null;
1372         }
1373
1374 CATCH:
1375         delete pStmt;
1376         pStmt = null;
1377
1378         return __appPackageName;
1379 }
1380
1381 const String&
1382 _PackageInfoImpl::GetApiVersion(void) const
1383 {
1384         return __appApiVersion;
1385 }
1386
1387 const String&
1388 _PackageInfoImpl::GetName(void) const
1389 {
1390         return __displayName;
1391 }
1392
1393 _PackageInfoImpl*
1394 _PackageInfoImpl::GetInstance(PackageInfo* pPackageInfo)
1395 {
1396         if (pPackageInfo)
1397         {
1398                 return pPackageInfo->__pPackageInfoImpl;
1399         }
1400
1401         return null;
1402 }
1403
1404 const _PackageInfoImpl*
1405 _PackageInfoImpl::GetInstance(const PackageInfo* pPackageInfo)
1406 {
1407         if (pPackageInfo)
1408         {
1409                 return pPackageInfo->__pPackageInfoImpl;
1410         }
1411
1412         return null;
1413 }
1414
1415 } } } // Tizen::App::Package