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