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 bool
 565 _PackageInfoImpl::IsPreloaded(void) const
 566 {
 567         return __preloaded;
 568 }
 569
 570 bool
 571 _PackageInfoImpl::IsUpdated(void) const
 572 {
 573         return __updated;
 574 }
 575
 576 result
 577 _PackageInfoImpl::AddPackageAppInfo(const PackageAppInfo& packageAppInfo)
 578 {
 579         result r = E_SUCCESS;
 580         r = __pPackageAppInfoList->Add(packageAppInfo);
 581         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pPackageAppInfoList->Add() is failed.");
 582
 583         return r;
 584 }
 585
 586 // to be reviewed
 587 _PackageInfoImpl::_PackageInfoImpl(void)
 588         : __appReadOnlySize(0)
 589         , __appDataSize(0)
 590         , __appStorageType(0)
 591         , __appState(0)
 592         , __certType(0)
 593         , __pPrivilegeList(null)
 594         , __pAppInfoImplList(null)
 595         , __pPackageAppInfoList(null)
 596         , __packageInfoHandle(null)
 597         , __uninstallable(true)
 598         , __movable(false)
 599         , __downloaded(false)
 600         , __preloaded(false)
 601         , __updated(false)
 602         , __iconAvailable(false)
 603         , __externalStorage(false)
 604         , __fromDatabase(false)
 605         , __packageType(PACKAGE_TYPE_TPK)
 606         , __pPackageInfo(null)
 607 {
 608         __pAppInfoImplList = new (std::nothrow) ArrayList;
 609         SysTryReturnVoidResult(NID_APP, __pAppInfoImplList != null, E_OUT_OF_MEMORY, "__pAppInfoImplList instance must not be null.");
 610         __pAppInfoImplList->Construct();
 611
 612         __pPackageAppInfoList = new (std::nothrow) ArrayList;
 613         SysTryReturnVoidResult(NID_APP, __pPackageAppInfoList != null, E_OUT_OF_MEMORY, "__pPackageAppInfoList instance must not be null.");
 614         __pPackageAppInfoList->Construct();
 615
 616         __pPrivilegeList = new (std::nothrow) ArrayList;
 617         SysTryReturnVoidResult(NID_APP, __pPrivilegeList != null, E_OUT_OF_MEMORY, "__pPrivilegeList must not be null.");
 618         __pPrivilegeList->Construct();
 619 }
 620
 621 _PackageInfoImpl::~_PackageInfoImpl(void)
 622 {
 623         __pAppInfoImplList->RemoveAll(true);
 624         delete __pAppInfoImplList;
 625
 626         __pPackageAppInfoList->RemoveAll(true);
 627         delete __pPackageAppInfoList;
 628
 629         __pPrivilegeList->RemoveAll(true);
 630         delete __pPrivilegeList;
 631
 632         if (__packageInfoHandle)
 633         {
 634                 pkgmgrinfo_pkginfo_destroy_pkginfo(__packageInfoHandle);
 635         }
 636 }
 637
 638 const String&
 639 _PackageInfoImpl::GetAppId(void) const
 640 {
 641         return __id;
 642 }
 643
 644 result
 645 _PackageInfoImpl::SetAppId(const String& id)
 646 {
 647         __id = id;
 648         return E_SUCCESS;
 649 }
 650
 651 const String&
 652 _PackageInfoImpl::GetAppVersion(void) const
 653 {
 654         return __version;
 655 }
 656
 657 result
 658 _PackageInfoImpl::SetAppVersion(const String& appVersion)
 659 {
 660         __version = appVersion;
 661         return E_SUCCESS;
 662 }
 663
 664 const String&
 665 _PackageInfoImpl::GetAppType(void) const
 666 {
 667         return __type;
 668 }
 669
 670 result
 671 _PackageInfoImpl::SetAppType(const String& appType)
 672 {
 673         __type = appType;
 674         return E_SUCCESS;
 675 }
 676
 677 const String&
 678 _PackageInfoImpl::GetAppMimeType(void) const
 679 {
 680         return __appMimeType;
 681 }
 682
 683 result
 684 _PackageInfoImpl::SetAppMimeType(const String& appMimeType)
 685 {
 686         __appMimeType = appMimeType;
 687         return E_SUCCESS;
 688 }
 689
 690 const String&
 691 _PackageInfoImpl::GetAppApiVersion(void) const
 692 {
 693         return __appApiVersion;
 694 }
 695
 696 result
 697 _PackageInfoImpl::SetAppApiVersion(const String& appApiVersion)
 698 {
 699         __appApiVersion = appApiVersion;
 700         return E_SUCCESS;
 701 }
 702
 703 const String&
 704 _PackageInfoImpl::GetAppName(void) const
 705 {
 706         return __displayName;
 707 }
 708
 709 result
 710 _PackageInfoImpl::SetAppName(const String& appName)
 711 {
 712         __displayName = appName;
 713         return E_SUCCESS;
 714 }
 715
 716 const String&
 717 _PackageInfoImpl::GetAppDescription(void) const
 718 {
 719         return __description;
 720 }
 721
 722 result
 723 _PackageInfoImpl::SetAppDescription(const String& appDescription)
 724 {
 725         __description = appDescription;
 726         return E_SUCCESS;
 727 }
 728
 729 const String&
 730 _PackageInfoImpl::GetAppVendor(void) const
 731 {
 732         return __author;
 733 }
 734
 735 result
 736 _PackageInfoImpl::SetAppVendor(const String& appVendor)
 737 {
 738         __author = appVendor;
 739         return E_SUCCESS;
 740 }
 741
 742 const String&
 743 _PackageInfoImpl::GetAppUrl(void) const
 744 {
 745         return __url;
 746 }
 747
 748 result
 749 _PackageInfoImpl::SetAppUrl(const String& appUrl)
 750 {
 751         __url = appUrl;
 752         return E_SUCCESS;
 753 }
 754
 755 const String&
 756 _PackageInfoImpl::GetAppCid(void) const
 757 {
 758         return __appCid;
 759 }
 760
 761 result
 762 _PackageInfoImpl::SetAppCid(const String& appCid)
 763 {
 764         __appCid = appCid;
 765         return E_SUCCESS;
 766 }
 767
 768 const String&
 769 _PackageInfoImpl::GetAppRootPath(void) const
 770 {
 771         return __appRootPath;
 772 }
 773
 774 result
 775 _PackageInfoImpl::SetAppRootPath(const String& appRootPath)
 776 {
 777         __appRootPath = appRootPath;
 778         return E_SUCCESS;
 779 }
 780
 781 int
 782 _PackageInfoImpl::GetAppStorageType(void) const
 783 {
 784         return __appStorageType;
 785 }
 786
 787 result
 788 _PackageInfoImpl::SetAppStorageType(int appStorageType)
 789 {
 790         __appStorageType = appStorageType;
 791         return E_SUCCESS;
 792 }
 793
 794 int
 795 _PackageInfoImpl::GetCertType(void) const
 796 {
 797         return __certType;
 798 }
 799
 800 result
 801 _PackageInfoImpl::SetCertType(int certType)
 802 {
 803         __certType = certType;
 804         return E_SUCCESS;
 805 }
 806
 807 ArrayList*
 808 _PackageInfoImpl::GetAppInfoListN(void) const
 809 {
 810         result r = E_SUCCESS;
 811         Database db;
 812         DbStatement* pStmt = null;
 813         DbEnumerator* pEnum = null;
 814         String query;
 815         //int id = 0;
 816         ArrayList* pList = null;
 817
 818         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", GetUniqueId());
 819
 820         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 821         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 822
 823         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 824         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 825
 826         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 827         if (pEnum != null)
 828         {
 829                 pList = new (std::nothrow) ArrayList;
 830                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 831                 pList->Construct();
 832
 833                 while (pEnum->MoveNext() == E_SUCCESS)
 834                 {
 835                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
 836                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 837
 838                         int uniqueId = 0;
 839                         int pkgId = 0;
 840                         String name;
 841                         String type;
 842                         String defaultapp;
 843                         String mainmenuIcon;
 844                         String settingIcon;
 845                         //String tickerIcon;
 846                         String quickpanelIcon;
 847                         //String launchImageIcon;
 848                         int appFeature = 0;
 849                         String packageName;
 850
 851                         pEnum->GetIntAt(0, uniqueId);
 852                         pEnum->GetIntAt(1, pkgId);
 853                         pEnum->GetStringAt(2, name);
 854                         pEnum->GetStringAt(3, type);
 855                         pEnum->GetStringAt(4, defaultapp);
 856                         pEnum->GetStringAt(5, mainmenuIcon);
 857                         pEnum->GetStringAt(6, settingIcon);
 858                         //pEnum->GetStringAt(7, tickerIcon);
 859                         pEnum->GetStringAt(8, quickpanelIcon);
 860                         //pEnum->GetStringAt(9, launchImageIcon);
 861                         pEnum->GetIntAt(10, appFeature);
 862                         pEnum->GetStringAt(11, packageName);
 863
 864                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
 865                         pPackageAppInfoImpl->SetPkgId(pkgId);
 866                         pPackageAppInfoImpl->SetName(name);
 867                         pPackageAppInfoImpl->SetType(type);
 868                         pPackageAppInfoImpl->SetDefault(defaultapp);
 869                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
 870                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
 871                         //pPackageAppInfoImpl->SetTickerIcon(tickerIcon);
 872                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
 873                         //pPackageAppInfoImpl->SetLaunchImageIcon(launchImageIcon);
 874                         pPackageAppInfoImpl->SetAppFeature(appFeature);
 875                         pPackageAppInfoImpl->SetPackageName(packageName);
 876
 877                         pList->Add(*pPackageAppInfoImpl);
 878                 }
 879
 880                 delete pEnum;
 881         }
 882
 883 CATCH:
 884         delete pStmt;
 885         return pList;
 886 }
 887
 888 ArrayList*
 889 _PackageInfoImpl::GetAppInfoList(void)
 890 {
 891         if (__pAppInfoImplList == null)
 892         {
 893                 __pAppInfoImplList = GetAppInfoListN();
 894         }
 895
 896         return __pAppInfoImplList;
 897 }
 898
 899 result
 900 _PackageInfoImpl::AddAppInfo(const _PackageAppInfoImpl& appInfoImpl)
 901 {
 902         result r = E_SUCCESS;
 903         r = __pAppInfoImplList->Add(appInfoImpl);
 904         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pAppInfoImplList->Add() is failed.");
 905
 906         return r;
 907 }
 908
 909 result
 910 _PackageInfoImpl::GetPrivileges(String& privileges, String& hmacPrivileges, ArrayList& privilegeList)
 911 {
 912         result r = E_SUCCESS;
 913         Database db;
 914         DbStatement* pStmt = null;
 915         DbEnumerator* pEnum = null;
 916         String query;
 917
 918         String privilegeListString;
 919         String delim("#");
 920         String privilegeToken;
 921
 922
 923         query.Format(1024, L"SELECT * FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
 924
 925         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 926         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 927
 928         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 929         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 930
 931         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 932         if (pEnum != null)
 933         {
 934                 if (pEnum->MoveNext() == E_SUCCESS)
 935                 {
 936                         pEnum->GetStringAt(1, privileges);
 937                         pEnum->GetStringAt(2, hmacPrivileges);
 938                         pEnum->GetStringAt(4, privilegeListString);
 939                 }
 940
 941                 StringTokenizer strTok(privilegeListString, delim);
 942
 943                 while (strTok.HasMoreTokens())
 944                 {
 945                         strTok.GetNextToken(privilegeToken);
 946                         privilegeList.Add(new String(privilegeToken));
 947                 }
 948
 949                 delete pEnum;
 950                 pEnum = null;
 951         }
 952
 953 CATCH:
 954         delete pStmt;
 955         pStmt = null;
 956         return r;
 957 }
 958
 959 result
 960 _PackageInfoImpl::GetPrivilegesValue(String& privileges, String& hmacPrivileges) const
 961 {
 962         privileges = __privileges;
 963         hmacPrivileges = __hmacPrivileges;
 964
 965         return E_SUCCESS;
 966 }
 967
 968 result
 969 _PackageInfoImpl::SetPrivilegesValue(const String& privileges, const String& hmacPrivileges)
 970 {
 971         __privileges = privileges;
 972         __hmacPrivileges = hmacPrivileges;
 973
 974         return E_SUCCESS;
 975 }
 976
 977 int
 978 _PackageInfoImpl::GetApiVisibility() const
 979 {
 980         result r = E_SUCCESS;
 981         int apiVisibility = 0;
 982         Database db;
 983         DbStatement* pStmt = null;
 984         DbEnumerator* pEnum = null;
 985         String query;
 986
 987         query.Format(1024, L"SELECT CERTIFICATE_TYPE FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
 988
 989         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 990         SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 991
 992         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 993         SysTryCatch(NID_APP, pStmt != null, apiVisibility = -1, GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 994
 995         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 996         if (pEnum != null)
 997         {
 998                 if (pEnum->MoveNext() == E_SUCCESS)
 999                 {
1000                         if (pEnum->GetColumnType(0) != DB_COLUMNTYPE_NULL)
1001                         {
1002                                 r = pEnum->GetIntAt(0, apiVisibility);
1003                                 SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] GetIntAt() is failed.", GetErrorMessage(r));
1004                         }
1005                 }
1006
1007                 delete pEnum;
1008                 pEnum = null;
1009         }
1010
1011 CATCH:
1012         delete pStmt;
1013         pStmt = null;
1014         return apiVisibility;
1015 }
1016
1017 const String&
1018 _PackageInfoImpl::GetAppIconPath(void) const
1019 {
1020         return __appIconPath;
1021 }
1022
1023 result
1024 _PackageInfoImpl::SetAppIconPath(const Tizen::Base::String& appIconPath)
1025 {
1026         __appIconPath = appIconPath;
1027
1028         return E_SUCCESS;
1029 }
1030
1031 const DateTime&
1032 _PackageInfoImpl::GetAppInstallationTime(void) const
1033 {
1034         return __dateTime;
1035 }
1036
1037 result
1038 _PackageInfoImpl::SetAppInstallationTime(const DateTime& installationTime)
1039 {
1040         __dateTime = installationTime;
1041
1042         return E_SUCCESS;
1043 }
1044
1045 result
1046 _PackageInfoImpl::Construct(const PackageId& packageId)
1047 {
1048         result r = E_SUCCESS;
1049         int result = 0;
1050         char* pPackage = null;
1051         char* pVersion = null;
1052         char* pName = null;
1053         char* pIconPath = null;
1054         char* pType = null;
1055         char* pDescription = null;
1056         char* pAuthor = null;
1057         char* pUrl = null;
1058         char* pMainAppId = null;
1059         char* pStoreClientId = null;
1060         char* pRootPath = null;
1061         int installedTime = 0;
1062         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
1063         bool removable = true;
1064         bool movable = true;
1065         bool preloaded = false;
1066         bool updated = false;
1067
1068         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
1069         SysTryReturnResult(NID_APP, pPackageId, E_OUT_OF_MEMORY, "pPackageId is null");
1070
1071         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &__packageInfoHandle);
1072         SysTryReturnResult(NID_APP, result == PMINFO_R_OK, E_PKG_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() is failed. result=[%d], package=[%s]", result, pPackageId.get());
1073
1074         __fromDatabase = true;
1075
1076         result = pkgmgrinfo_pkginfo_get_pkgname(__packageInfoHandle, &pPackage);
1077         if (result == PMINFO_R_OK)
1078         {
1079                 String package(pPackage);
1080                 __id = package;
1081         }
1082         else
1083         {
1084                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1085         }
1086
1087         result = pkgmgrinfo_pkginfo_get_version(__packageInfoHandle, &pVersion);
1088         if (result == PMINFO_R_OK)
1089         {
1090                 String version(pVersion);
1091                 __version = version;
1092         }
1093         else
1094         {
1095                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_version() is failed. result = [%d]", result);
1096         }
1097
1098         result = pkgmgrinfo_pkginfo_get_type(__packageInfoHandle, &pType);
1099         if (result == PMINFO_R_OK)
1100         {
1101                 String type(pType);
1102                 __type = type;
1103         }
1104         else
1105         {
1106                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_type() is failed. result = [%d]", result);
1107         }
1108
1109         result = pkgmgrinfo_pkginfo_get_label(__packageInfoHandle, &pName);
1110         if (result == PMINFO_R_OK)
1111         {
1112                 String Name(pName);
1113                 __displayName = Name;
1114         }
1115         else
1116         {
1117                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_label() is failed. result = [%d]", result);
1118         }
1119
1120         result = pkgmgrinfo_pkginfo_get_icon(__packageInfoHandle, &pIconPath);
1121         if (result == PMINFO_R_OK)
1122         {
1123                 String path(pIconPath);
1124                 __appIconPath = path;
1125         }
1126         else
1127         {
1128                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_icon() is failed. result = [%d]", result);
1129         }
1130
1131         result = pkgmgrinfo_pkginfo_is_removable(__packageInfoHandle, &removable);
1132         if (result == PMINFO_R_OK)
1133         {
1134                 if (removable == false)
1135                 {
1136                         __uninstallable = false;
1137                 }
1138         }
1139         else
1140         {
1141                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_removable() is failed. result = [%d]", result);
1142         }
1143
1144         result = pkgmgrinfo_pkginfo_is_movable(__packageInfoHandle, &movable);
1145         if (result == PMINFO_R_OK)
1146         {
1147                 __movable = movable;
1148         }
1149         else
1150         {
1151                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_movable() is failed. result = [%d]", result);
1152         }
1153
1154         result = pkgmgrinfo_pkginfo_is_preload(__packageInfoHandle, &preloaded);
1155         if (result == PMINFO_R_OK)
1156         {
1157                 __preloaded = preloaded;
1158         }
1159         else
1160         {
1161                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_preload() is failed. result = [%d]", result);
1162         }
1163
1164         result = pkgmgrinfo_pkginfo_is_update(__packageInfoHandle, &updated);
1165         if (result == PMINFO_R_OK)
1166         {
1167                 __updated = updated;
1168         }
1169         else
1170         {
1171                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_update() is failed. result = [%d]", result);
1172         }
1173
1174         if (updated == true)
1175         {
1176                 __downloaded = true;
1177         }
1178         else
1179         {
1180                 if (preloaded == true)
1181                 {
1182                         __downloaded = false;
1183                 }
1184                 else
1185                 {
1186                         __downloaded = true;
1187                 }
1188         }
1189
1190         result = pkgmgrinfo_pkginfo_get_description(__packageInfoHandle, &pDescription);
1191         if (result == PMINFO_R_OK)
1192         {
1193                 String description(pDescription);
1194                 __description = description;
1195         }
1196         else
1197         {
1198                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_description() is failed. result = [%d]", result);
1199         }
1200
1201         result = pkgmgrinfo_pkginfo_get_author_name(__packageInfoHandle, &pAuthor);
1202         if (result == PMINFO_R_OK)
1203         {
1204                 String author(pAuthor);
1205                 __author = author;
1206         }
1207         else
1208         {
1209                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_author_name() is failed. result = [%d]", result);
1210         }
1211
1212         result = pkgmgrinfo_pkginfo_get_installed_time(__packageInfoHandle, &installedTime);
1213         if (result == PMINFO_R_OK)
1214         {
1215                 time_t dateTime = (time_t) installedTime;
1216                 struct tm* pGmTime = null;
1217
1218                 pGmTime = gmtime(&dateTime);
1219                 if (pGmTime)
1220                 {
1221                         DateTime tempTime;
1222                         tempTime.SetValue(pGmTime->tm_year + 1900, pGmTime->tm_mon + 1, pGmTime->tm_mday, pGmTime->tm_hour, pGmTime->tm_min, pGmTime->tm_sec);
1223                         __dateTime = tempTime;
1224                 }
1225         }
1226         else
1227         {
1228                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_time() is failed. result = [%d]", result);
1229         }
1230
1231         result = pkgmgrinfo_pkginfo_get_installed_storage(__packageInfoHandle, &storage);
1232         if (result == PMINFO_R_OK)
1233         {
1234                 if (storage == PMINFO_EXTERNAL_STORAGE)
1235                 {
1236                         __externalStorage = true;
1237                 }
1238         }
1239         else
1240         {
1241                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage() is failed. result = [%d]", result);
1242         }
1243
1244         result = pkgmgrinfo_pkginfo_get_url(__packageInfoHandle, &pUrl);
1245         if (result == PMINFO_R_OK)
1246         {
1247                 String url(pUrl);
1248                 __url = url;
1249         }
1250         else
1251         {
1252                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_url() is failed. result = [%d]", result);
1253         }
1254
1255         result = pkgmgrinfo_pkginfo_get_mainappid(__packageInfoHandle, &pMainAppId);
1256         if (result == PMINFO_R_OK)
1257         {
1258                 AppId mainAppId(pMainAppId);
1259                 __mainAppId = mainAppId;
1260         }
1261         else
1262         {
1263                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_mainappid() is failed. result = [%d]", result);
1264         }
1265
1266         result = pkgmgrinfo_pkginfo_get_storeclientid(__packageInfoHandle, &pStoreClientId);
1267         if (result == PMINFO_R_OK)
1268         {
1269                 String storeClientId(pStoreClientId);
1270                 __storeClientId = storeClientId;
1271         }
1272         else
1273         {
1274                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_storeclientid() is failed. result = [%d]", result);
1275         }
1276
1277         result = pkgmgrinfo_pkginfo_get_root_path(__packageInfoHandle, &pRootPath);
1278         if (result == PMINFO_R_OK)
1279         {
1280                 String rootPath(pRootPath);
1281                 __appRootPath = rootPath;
1282         }
1283         else
1284         {
1285                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_root_path() is failed. result = [%d]", result);
1286         }
1287
1288         SysLog(NID_APP, "package(%ls), version(%ls), type(%ls), displayName(%ls), uninstallable(%d), downloaded(%d), updated(%d), preloaded(%d)"
1289                                                                         "movable(%d), externalStorage(%d), mainApp(%ls), storeClient(%ls), appRootPath(%ls)",
1290                         __id.GetPointer(), __version.GetPointer(), __type.GetPointer(), __displayName.GetPointer(), __uninstallable, __downloaded, updated, preloaded,
1291                         __movable, __externalStorage, __mainAppId.GetPointer(), __storeClientId.GetPointer(), __appRootPath.GetPointer());
1292
1293         return r;
1294 }
1295
1296 int
1297 _PackageInfoImpl::GetUniqueId(void) const
1298 {
1299         result r = E_SUCCESS;
1300         Database db;
1301         DbStatement* pStmt = null;
1302         DbEnumerator* pEnum = null;
1303         String query;
1304         int uniqueId = 0;
1305
1306         query.Format(1024, L"SELECT UNIQUE_ID FROM PkgInfo WHERE PKG_ID = '%ls'", __id.GetPointer());
1307
1308         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1309         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1310
1311         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1312         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1313
1314         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1315         if (pEnum != null)
1316         {
1317                 if (pEnum->MoveNext() == E_SUCCESS)
1318                 {
1319                         pEnum->GetIntAt(0, uniqueId);
1320                 }
1321
1322                 delete pEnum;
1323         }
1324         else
1325         {
1326                 r = E_OBJ_NOT_FOUND;
1327         }
1328
1329 CATCH:
1330         delete pStmt;
1331
1332         return uniqueId;
1333 }
1334
1335 result
1336 _PackageInfoImpl::GetUiScalabilityInfo(String& baseScreenSize, String& coordinateSystem, String& logicalCoordinate) const
1337 {
1338         result r = E_SUCCESS;
1339         Database db;
1340         DbStatement* pStmt = null;
1341         DbEnumerator* pEnum = null;
1342         String query;
1343
1344         query.Format(1024,
1345                 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());
1346
1347         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1348         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1349
1350         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1351         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1352                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1353
1354         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1355         if (pEnum != null)
1356         {
1357                 while (pEnum->MoveNext() == E_SUCCESS)
1358                 {
1359                         String name;
1360                         String value;
1361
1362                         pEnum->GetStringAt(0, name);
1363                         pEnum->GetStringAt(1, value);
1364
1365                         if (name == L"CoordinateSystem")
1366                         {
1367                                 coordinateSystem = value;
1368                         }
1369                         else if (name == L"BaseScreenSize")
1370                         {
1371                                 baseScreenSize = value;
1372                         }
1373                         else if (name == L"LogicalCoordinate")
1374                         {
1375                                 logicalCoordinate = value;
1376                         }
1377                 }
1378                 delete pEnum;
1379         }
1380         else
1381         {
1382                 r = E_OBJ_NOT_FOUND;
1383                 SetLastResult(r);
1384         }
1385
1386 CATCH:
1387         delete pStmt;
1388
1389         return r;
1390 }
1391
1392 // to be removed
1393 const String&
1394 _PackageInfoImpl::GetAppPackageName(void)
1395 {
1396         if (__appPackageName.IsEmpty() == false)
1397         {
1398                 return __appPackageName;
1399         }
1400
1401         result r = E_SUCCESS;
1402         Database db;
1403         DbStatement* pStmt = null;
1404         DbEnumerator* pEnum = null;
1405         String query;
1406
1407         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo WHERE AppInfo.APP_DEFAULT = 'True' and ID = %d", GetUniqueId());
1408
1409         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1410         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1411
1412         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1413         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1414
1415         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1416         if (pEnum != null)
1417         {
1418                 if (pEnum->MoveNext() == E_SUCCESS)
1419                 {
1420                         pEnum->GetStringAt(0, __appPackageName);
1421                 }
1422
1423                 delete pEnum;
1424                 pEnum = null;
1425         }
1426
1427 CATCH:
1428         delete pStmt;
1429         pStmt = null;
1430
1431         return __appPackageName;
1432 }
1433
1434 const String&
1435 _PackageInfoImpl::GetApiVersion(void) const
1436 {
1437         return __appApiVersion;
1438 }
1439
1440 const String&
1441 _PackageInfoImpl::GetName(void) const
1442 {
1443         return __displayName;
1444 }
1445
1446 _PackageInfoImpl*
1447 _PackageInfoImpl::GetInstance(PackageInfo* pPackageInfo)
1448 {
1449         if (pPackageInfo)
1450         {
1451                 return pPackageInfo->__pPackageInfoImpl;
1452         }
1453
1454         return null;
1455 }
1456
1457 const _PackageInfoImpl*
1458 _PackageInfoImpl::GetInstance(const PackageInfo* pPackageInfo)
1459 {
1460         if (pPackageInfo)
1461         {
1462                 return pPackageInfo->__pPackageInfoImpl;
1463         }
1464
1465         return null;
1466 }
1467
1468 } } } // Tizen::App::Package