src/app/package/FAppPkg_PackageInfoImpl.cpp

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