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