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                                 std::unique_ptr< 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.get());
 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.release());
 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(): app = [%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                 SysTryReturn(NID_APP, __pPackageAppInfoList, null, E_SYSTEM, "__pPackageAppInfoList must not be null.");
 384
 385                 for (int i = 0; i < __pPackageAppInfoList->GetCount(); i++)
 386                 {
 387                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(__pPackageAppInfoList->GetAt(i));
 388                         if (pPackageAppInfo)
 389                         {
 390                                 if (appId != pPackageAppInfo->GetAppId())
 391                                 {
 392                                         continue;
 393                                 }
 394
 395                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 396                                 SysTryReturn(NID_APP, pPackageAppInfoImpl, null, E_SYSTEM, "pPackageAppInfoImpl is null.");
 397
 398                                 std::unique_ptr< PackageAppInfo > pInfo(new (std::nothrow) PackageAppInfo);
 399                                 SysTryReturn(NID_APP, pInfo, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 400
 401                                 _PackageAppInfoImpl* pImpl = _PackageAppInfoImpl::GetInstance(pInfo.get());
 402                                 SysTryReturn(NID_APP, pImpl, null, E_SYSTEM, "pImpl is null.");
 403
 404                                 String appName = pPackageAppInfo->GetAppName();
 405                                 String appDisplayName = pPackageAppInfo->GetAppDisplayName();
 406                                 bool menuIconVisible = pPackageAppInfo->IsMenuIconVisible();
 407                                 bool mainApp = pPackageAppInfo->IsMainApp();
 408                                 String tempIconPath = pPackageAppInfoImpl->GetAppTempIconPath();
 409
 410                                 pImpl->SetAppId(appId);
 411                                 pImpl->SetAppName(appName);
 412                                 pImpl->SetAppDisplayName(appDisplayName);
 413                                 pImpl->SetMenuIconVisible(menuIconVisible);
 414                                 pImpl->SetMainApp(mainApp);
 415                                 pImpl->SetAppTempIconPath(tempIconPath);
 416
 417                                 return pInfo.release();
 418                         }
 419                  }
 420         }
 421
 422         return null;
 423 }
 424
 425 int
 426 _PackageInfoImpl::PackageAppInfoListHandler(const pkgmgrinfo_appinfo_h handle, void* pUser_data)
 427 {
 428         ArrayList* pList = (ArrayList*) pUser_data;
 429
 430         PackageAppInfo* pPackageAppInfo = new (std::nothrow) PackageAppInfo;
 431         SysTryReturn(NID_APP, pPackageAppInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 432
 433         GetPackageAppInfo(handle, pPackageAppInfo);
 434
 435         pList->Add(*pPackageAppInfo);
 436
 437         return 0;
 438 }
 439
 440 bool
 441 _PackageInfoImpl::GetPackageAppInfo(const pkgmgrinfo_appinfo_h handle, PackageAppInfo* pPackageAppInfo)
 442 {
 443         SysTryReturn(NID_APP, pPackageAppInfo, false, E_INVALID_ARG, "[E_INVALID_ARG] pPackageAppInfo is null.");
 444
 445         int res = 0;
 446         char* pAppId = null;
 447
 448         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 449
 450         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
 451         if (res == 0)
 452         {
 453                 SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appid(): app = [%s]", pAppId);
 454                 pPackageAppInfoImpl->Construct(pAppId);
 455         }
 456         else
 457         {
 458                 SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appid() is failed. result = [%d]", res);
 459         }
 460
 461         return true;
 462 }
 463
 464 ArrayList*
 465 _PackageInfoImpl::GetPrivilegeListN(void) const
 466 {
 467         SysTryReturn(NID_APP, __pPrivilegeList, null, E_SYSTEM, "__pPrivilegeList must not be null.");
 468
 469         result r = E_SUCCESS;
 470
 471         ArrayList* pPrivilegeList = new (std::nothrow) ArrayList;
 472         SysTryReturn(NID_APP, pPrivilegeList, null, E_OUT_OF_MEMORY, "pPrivilegeList must not be null.");
 473         pPrivilegeList->Construct();
 474
 475         for (int i = 0; i < __pPrivilegeList->GetCount(); i++)
 476         {
 477                 String* pPrivilege = dynamic_cast <String*>(__pPrivilegeList->GetAt(i));
 478                 if (pPrivilege)
 479                 {
 480                         PrivilegeInfo* pPrivilegeInfo = new (std::nothrow) PrivilegeInfo;
 481                         SysTryReturn(NID_APP, pPrivilegeInfo, null, E_OUT_OF_MEMORY, "pPrivilegeInfo must not be null.");
 482
 483                         pPrivilegeInfo->Construct(*pPrivilege);
 484
 485                         r = pPrivilegeList->Add(*pPrivilegeInfo);
 486                 }
 487          }
 488
 489         return pPrivilegeList;
 490 }
 491
 492 result
 493 _PackageInfoImpl::AddPrivilege(const String& privilege)
 494 {
 495         result r = E_SUCCESS;
 496
 497         r = __pPrivilegeList->Add(privilege);
 498         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pPrivilegeList->Add() is failed.");
 499
 500         return r;
 501 }
 502
 503 result
 504 _PackageInfoImpl::AddPackageAppInfo(const PackageAppInfo& packageAppInfo)
 505 {
 506         result r = E_SUCCESS;
 507         r = __pPackageAppInfoList->Add(packageAppInfo);
 508         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pPackageAppInfoList->Add() is failed.");
 509
 510         return r;
 511 }
 512
 513 // to be reviewed
 514 _PackageInfoImpl::_PackageInfoImpl(void)
 515         : __appReadOnlySize(0)
 516         , __appDataSize(0)
 517         , __appStorageType(0)
 518         , __appState(0)
 519         , __certType(0)
 520         , __pPrivilegeList(null)
 521         , __pAppInfoImplList(null)
 522         , __pPackageAppInfoList(null)
 523         , __packageInfoHandle(null)
 524         , __uninstallable(true)
 525         , __movable(false)
 526         , __downloaded(false)
 527         , __iconAvailable(false)
 528         , __externalStorage(false)
 529         , __fromDatabase(false)
 530         , __packageType(PACKAGE_TYPE_TPK)
 531         , __pPackageInfo(null)
 532 {
 533         __pAppInfoImplList = new (std::nothrow) ArrayList;
 534         SysTryReturnVoidResult(NID_APP, __pAppInfoImplList != null, E_OUT_OF_MEMORY, "__pAppInfoImplList instance must not be null.");
 535         __pAppInfoImplList->Construct();
 536
 537         __pPackageAppInfoList = new (std::nothrow) ArrayList;
 538         SysTryReturnVoidResult(NID_APP, __pPackageAppInfoList != null, E_OUT_OF_MEMORY, "__pPackageAppInfoList instance must not be null.");
 539         __pPackageAppInfoList->Construct();
 540
 541         __pPrivilegeList = new (std::nothrow) ArrayList;
 542         SysTryReturnVoidResult(NID_APP, __pPrivilegeList != null, E_OUT_OF_MEMORY, "__pPrivilegeList must not be null.");
 543         __pPrivilegeList->Construct();
 544 }
 545
 546 _PackageInfoImpl::~_PackageInfoImpl(void)
 547 {
 548         __pAppInfoImplList->RemoveAll(true);
 549         delete __pAppInfoImplList;
 550
 551         __pPackageAppInfoList->RemoveAll(true);
 552         delete __pPackageAppInfoList;
 553
 554         __pPrivilegeList->RemoveAll(true);
 555         delete __pPrivilegeList;
 556
 557         if (__packageInfoHandle)
 558         {
 559                 pkgmgrinfo_pkginfo_destroy_pkginfo(__packageInfoHandle);
 560         }
 561 }
 562
 563 const String&
 564 _PackageInfoImpl::GetAppId(void) const
 565 {
 566         return __id;
 567 }
 568
 569 result
 570 _PackageInfoImpl::SetAppId(const String& id)
 571 {
 572         __id = id;
 573         return E_SUCCESS;
 574 }
 575
 576 const String&
 577 _PackageInfoImpl::GetAppVersion(void) const
 578 {
 579         return __version;
 580 }
 581
 582 result
 583 _PackageInfoImpl::SetAppVersion(const String& appVersion)
 584 {
 585         __version = appVersion;
 586         return E_SUCCESS;
 587 }
 588
 589 const String&
 590 _PackageInfoImpl::GetAppType(void) const
 591 {
 592         return __type;
 593 }
 594
 595 result
 596 _PackageInfoImpl::SetAppType(const String& appType)
 597 {
 598         __type = appType;
 599         return E_SUCCESS;
 600 }
 601
 602 const String&
 603 _PackageInfoImpl::GetAppMimeType(void) const
 604 {
 605         return __appMimeType;
 606 }
 607
 608 result
 609 _PackageInfoImpl::SetAppMimeType(const String& appMimeType)
 610 {
 611         __appMimeType = appMimeType;
 612         return E_SUCCESS;
 613 }
 614
 615 const String&
 616 _PackageInfoImpl::GetAppApiVersion(void) const
 617 {
 618         return __appApiVersion;
 619 }
 620
 621 result
 622 _PackageInfoImpl::SetAppApiVersion(const String& appApiVersion)
 623 {
 624         __appApiVersion = appApiVersion;
 625         return E_SUCCESS;
 626 }
 627
 628 const String&
 629 _PackageInfoImpl::GetAppName(void) const
 630 {
 631         return __displayName;
 632 }
 633
 634 result
 635 _PackageInfoImpl::SetAppName(const String& appName)
 636 {
 637         __displayName = appName;
 638         return E_SUCCESS;
 639 }
 640
 641 const String&
 642 _PackageInfoImpl::GetAppDescription(void) const
 643 {
 644         return __description;
 645 }
 646
 647 result
 648 _PackageInfoImpl::SetAppDescription(const String& appDescription)
 649 {
 650         __description = appDescription;
 651         return E_SUCCESS;
 652 }
 653
 654 const String&
 655 _PackageInfoImpl::GetAppVendor(void) const
 656 {
 657         return __author;
 658 }
 659
 660 result
 661 _PackageInfoImpl::SetAppVendor(const String& appVendor)
 662 {
 663         __author = appVendor;
 664         return E_SUCCESS;
 665 }
 666
 667 const String&
 668 _PackageInfoImpl::GetAppUrl(void) const
 669 {
 670         return __url;
 671 }
 672
 673 result
 674 _PackageInfoImpl::SetAppUrl(const String& appUrl)
 675 {
 676         __url = appUrl;
 677         return E_SUCCESS;
 678 }
 679
 680 const String&
 681 _PackageInfoImpl::GetAppCid(void) const
 682 {
 683         return __appCid;
 684 }
 685
 686 result
 687 _PackageInfoImpl::SetAppCid(const String& appCid)
 688 {
 689         __appCid = appCid;
 690         return E_SUCCESS;
 691 }
 692
 693 const String&
 694 _PackageInfoImpl::GetAppRootPath(void) const
 695 {
 696         return __appRootPath;
 697 }
 698
 699 result
 700 _PackageInfoImpl::SetAppRootPath(const String& appRootPath)
 701 {
 702         __appRootPath = appRootPath;
 703         return E_SUCCESS;
 704 }
 705
 706 int
 707 _PackageInfoImpl::GetAppStorageType(void) const
 708 {
 709         return __appStorageType;
 710 }
 711
 712 result
 713 _PackageInfoImpl::SetAppStorageType(int appStorageType)
 714 {
 715         __appStorageType = appStorageType;
 716         return E_SUCCESS;
 717 }
 718
 719 int
 720 _PackageInfoImpl::GetCertType(void) const
 721 {
 722         return __certType;
 723 }
 724
 725 result
 726 _PackageInfoImpl::SetCertType(int certType)
 727 {
 728         __certType = certType;
 729         return E_SUCCESS;
 730 }
 731
 732 ArrayList*
 733 _PackageInfoImpl::GetAppInfoListN(void) const
 734 {
 735         result r = E_SUCCESS;
 736         Database db;
 737         DbStatement* pStmt = null;
 738         DbEnumerator* pEnum = null;
 739         String query;
 740         //int id = 0;
 741         ArrayList* pList = null;
 742
 743         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", GetUniqueId());
 744
 745         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 746         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 747
 748         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 749         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 750
 751         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 752         if (pEnum != null)
 753         {
 754                 pList = new (std::nothrow) ArrayList;
 755                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 756                 pList->Construct();
 757
 758                 while (pEnum->MoveNext() == E_SUCCESS)
 759                 {
 760                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
 761                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 762
 763                         int uniqueId = 0;
 764                         int pkgId = 0;
 765                         String name;
 766                         String type;
 767                         String defaultapp;
 768                         String mainmenuIcon;
 769                         String settingIcon;
 770                         //String tickerIcon;
 771                         String quickpanelIcon;
 772                         //String launchImageIcon;
 773                         int appFeature = 0;
 774                         String packageName;
 775
 776                         pEnum->GetIntAt(0, uniqueId);
 777                         pEnum->GetIntAt(1, pkgId);
 778                         pEnum->GetStringAt(2, name);
 779                         pEnum->GetStringAt(3, type);
 780                         pEnum->GetStringAt(4, defaultapp);
 781                         pEnum->GetStringAt(5, mainmenuIcon);
 782                         pEnum->GetStringAt(6, settingIcon);
 783                         //pEnum->GetStringAt(7, tickerIcon);
 784                         pEnum->GetStringAt(8, quickpanelIcon);
 785                         //pEnum->GetStringAt(9, launchImageIcon);
 786                         pEnum->GetIntAt(10, appFeature);
 787                         pEnum->GetStringAt(11, packageName);
 788
 789                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
 790                         pPackageAppInfoImpl->SetPkgId(pkgId);
 791                         pPackageAppInfoImpl->SetName(name);
 792                         pPackageAppInfoImpl->SetType(type);
 793                         pPackageAppInfoImpl->SetDefault(defaultapp);
 794                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
 795                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
 796                         //pPackageAppInfoImpl->SetTickerIcon(tickerIcon);
 797                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
 798                         //pPackageAppInfoImpl->SetLaunchImageIcon(launchImageIcon);
 799                         pPackageAppInfoImpl->SetAppFeature(appFeature);
 800                         pPackageAppInfoImpl->SetPackageName(packageName);
 801
 802                         pList->Add(*pPackageAppInfoImpl);
 803                 }
 804
 805                 delete pEnum;
 806         }
 807
 808 CATCH:
 809         delete pStmt;
 810         return pList;
 811 }
 812
 813 ArrayList*
 814 _PackageInfoImpl::GetAppInfoList(void)
 815 {
 816         if (__pAppInfoImplList == null)
 817         {
 818                 __pAppInfoImplList = GetAppInfoListN();
 819         }
 820
 821         return __pAppInfoImplList;
 822 }
 823
 824 result
 825 _PackageInfoImpl::AddAppInfo(const _PackageAppInfoImpl& appInfoImpl)
 826 {
 827         result r = E_SUCCESS;
 828         r = __pAppInfoImplList->Add(appInfoImpl);
 829         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pAppInfoImplList->Add() is failed.");
 830
 831         return r;
 832 }
 833
 834 result
 835 _PackageInfoImpl::GetPrivileges(String& privileges, String& hmacPrivileges, ArrayList& privilegeList)
 836 {
 837         result r = E_SUCCESS;
 838         Database db;
 839         DbStatement* pStmt = null;
 840         DbEnumerator* pEnum = null;
 841         String query;
 842
 843         String privilegeListString;
 844         String delim("#");
 845         String privilegeToken;
 846
 847
 848         query.Format(1024, L"SELECT * FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
 849
 850         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 851         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 852
 853         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 854         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 855
 856         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 857         if (pEnum != null)
 858         {
 859                 if (pEnum->MoveNext() == E_SUCCESS)
 860                 {
 861                         pEnum->GetStringAt(1, privileges);
 862                         pEnum->GetStringAt(2, hmacPrivileges);
 863                         pEnum->GetStringAt(4, privilegeListString);
 864                 }
 865
 866                 StringTokenizer strTok(privilegeListString, delim);
 867
 868                 while (strTok.HasMoreTokens())
 869                 {
 870                         strTok.GetNextToken(privilegeToken);
 871                         privilegeList.Add(new String(privilegeToken));
 872                 }
 873
 874                 delete pEnum;
 875                 pEnum = null;
 876         }
 877
 878 CATCH:
 879         delete pStmt;
 880         pStmt = null;
 881         return r;
 882 }
 883
 884 result
 885 _PackageInfoImpl::GetPrivilegesValue(String& privileges, String& hmacPrivileges) const
 886 {
 887         privileges = __privileges;
 888         hmacPrivileges = __hmacPrivileges;
 889
 890         return E_SUCCESS;
 891 }
 892
 893 result
 894 _PackageInfoImpl::SetPrivilegesValue(const String& privileges, const String& hmacPrivileges)
 895 {
 896         __privileges = privileges;
 897         __hmacPrivileges = hmacPrivileges;
 898
 899         return E_SUCCESS;
 900 }
 901
 902 int
 903 _PackageInfoImpl::GetApiVisibility() const
 904 {
 905         result r = E_SUCCESS;
 906         int apiVisibility = 0;
 907         Database db;
 908         DbStatement* pStmt = null;
 909         DbEnumerator* pEnum = null;
 910         String query;
 911
 912         query.Format(1024, L"SELECT CERTIFICATE_TYPE FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
 913
 914         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 915         SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 916
 917         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 918         SysTryCatch(NID_APP, pStmt != null, apiVisibility = -1, GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 919
 920         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 921         if (pEnum != null)
 922         {
 923                 if (pEnum->MoveNext() == E_SUCCESS)
 924                 {
 925                         if (pEnum->GetColumnType(0) != DB_COLUMNTYPE_NULL)
 926                         {
 927                                 r = pEnum->GetIntAt(0, apiVisibility);
 928                                 SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] GetIntAt() is failed.", GetErrorMessage(r));
 929                         }
 930                 }
 931
 932                 delete pEnum;
 933                 pEnum = null;
 934         }
 935
 936 CATCH:
 937         delete pStmt;
 938         pStmt = null;
 939         return apiVisibility;
 940 }
 941
 942 const String&
 943 _PackageInfoImpl::GetAppIconPath(void) const
 944 {
 945         return __appIconPath;
 946 }
 947
 948 result
 949 _PackageInfoImpl::SetAppIconPath(const Tizen::Base::String& appIconPath)
 950 {
 951         __appIconPath = appIconPath;
 952
 953         return E_SUCCESS;
 954 }
 955
 956 const DateTime&
 957 _PackageInfoImpl::GetAppInstallationTime(void) const
 958 {
 959         return __dateTime;
 960 }
 961
 962 result
 963 _PackageInfoImpl::SetAppInstallationTime(const DateTime& installationTime)
 964 {
 965         __dateTime = installationTime;
 966
 967         return E_SUCCESS;
 968 }
 969
 970 result
 971 _PackageInfoImpl::Construct(const PackageId& packageId)
 972 {
 973         result r = E_SUCCESS;
 974         int result = 0;
 975         char* pPackage = null;
 976         char* pVersion = null;
 977         char* pName = null;
 978         char* pIconPath = null;
 979         char* pType = null;
 980         char* pDescription = null;
 981         char* pAuthor = null;
 982         char* pUrl = null;
 983         char* pMainAppId = null;
 984         char* pStoreClientId = null;
 985         char* pRootPath = null;
 986         int installedTime = 0;
 987         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 988         bool removable = true;
 989
 990         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 991         SysTryReturnResult(NID_APP, pPackageId, E_OUT_OF_MEMORY, "pPackageId is null");
 992
 993         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &__packageInfoHandle);
 994         SysTryReturnResult(NID_APP, result == PMINFO_R_OK, E_PKG_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() is failed. result=[%d], package=[%s]", result, pPackageId.get());
 995
 996         __fromDatabase = true;
 997
 998         result = pkgmgrinfo_pkginfo_get_pkgname(__packageInfoHandle, &pPackage);
 999         if (result == PMINFO_R_OK)
1000         {
1001                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1002                 String package(pPackage);
1003                 __id = package;
1004         }
1005         else
1006         {
1007                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1008         }
1009
1010         result = pkgmgrinfo_pkginfo_get_version(__packageInfoHandle, &pVersion);
1011         if (result == PMINFO_R_OK)
1012         {
1013                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_version(): version = [%s]", pVersion);
1014                 String version(pVersion);
1015                 __version = version;
1016         }
1017         else
1018         {
1019                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_version() is failed. result = [%d]", result);
1020         }
1021
1022         result = pkgmgrinfo_pkginfo_get_type(__packageInfoHandle, &pType);
1023         if (result == PMINFO_R_OK)
1024         {
1025                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_type(): type = [%s]", pType);
1026                 String type(pType);
1027                 __type = type;
1028         }
1029         else
1030         {
1031                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_type() is failed. result = [%d]", result);
1032         }
1033
1034         result = pkgmgrinfo_pkginfo_get_label(__packageInfoHandle, &pName);
1035         if (result == PMINFO_R_OK)
1036         {
1037                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_label(): name = [%s]", pName);
1038                 String Name(pName);
1039                 __displayName = Name;
1040         }
1041         else
1042         {
1043                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_label() is failed. result = [%d]", result);
1044         }
1045
1046         result = pkgmgrinfo_pkginfo_get_icon(__packageInfoHandle, &pIconPath);
1047         if (result == PMINFO_R_OK)
1048         {
1049                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_icon(): iconpath = [%s]", pIconPath);
1050                 String path(pIconPath);
1051                 __appIconPath = path;
1052         }
1053         else
1054         {
1055                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_icon() is failed. result = [%d]", result);
1056         }
1057
1058         result = pkgmgrinfo_pkginfo_is_removable(__packageInfoHandle, &removable);
1059         if (result == PMINFO_R_OK)
1060         {
1061                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_removable(): removable = [%d]", removable);
1062
1063                 if (removable == false)
1064                 {
1065                         __uninstallable = false;
1066                 }
1067         }
1068         else
1069         {
1070                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_removable() is failed. result = [%d]", result);
1071         }
1072
1073         result = pkgmgrinfo_pkginfo_get_description(__packageInfoHandle, &pDescription);
1074         if (result == PMINFO_R_OK)
1075         {
1076                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_description(): description = [%s]", pDescription);
1077                 String description(pDescription);
1078                 __description = description;
1079         }
1080         else
1081         {
1082                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_description() is failed. result = [%d]", result);
1083         }
1084
1085         result = pkgmgrinfo_pkginfo_get_author_name(__packageInfoHandle, &pAuthor);
1086         if (result == PMINFO_R_OK)
1087         {
1088                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_author_name(): author = [%s]", pAuthor);
1089                 String author(pAuthor);
1090                 __author = author;
1091         }
1092         else
1093         {
1094                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_author_name() is failed. result = [%d]", result);
1095         }
1096
1097         result = pkgmgrinfo_pkginfo_get_installed_time(__packageInfoHandle, &installedTime);
1098         if (result == PMINFO_R_OK)
1099         {
1100                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_time(): installedTime = [%d]", installedTime);
1101
1102                 time_t dateTime = (time_t) installedTime;
1103                 struct tm* pGmTime = null;
1104
1105                 pGmTime = gmtime(&dateTime);
1106                 if (pGmTime)
1107                 {
1108                         DateTime tempTime;
1109                         tempTime.SetValue(pGmTime->tm_year + 1900, pGmTime->tm_mon + 1, pGmTime->tm_mday, pGmTime->tm_hour, pGmTime->tm_min, pGmTime->tm_sec);
1110                         __dateTime = tempTime;
1111                         SysLog(NID_APP, "Time %d %d/%d, %d:%d:%d", tempTime.GetYear(), tempTime.GetMonth(), tempTime.GetDay(), tempTime.GetHour(), tempTime.GetMinute(), tempTime.GetSecond());
1112                 }
1113         }
1114         else
1115         {
1116                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_time() is failed. result = [%d]", result);
1117         }
1118
1119         result = pkgmgrinfo_pkginfo_get_installed_storage(__packageInfoHandle, &storage);
1120         if (result == PMINFO_R_OK)
1121         {
1122                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d]", storage);
1123                 if (storage == PMINFO_EXTERNAL_STORAGE)
1124                 {
1125                         __externalStorage = true;
1126                 }
1127         }
1128         else
1129         {
1130                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage() is failed. result = [%d]", result);
1131         }
1132
1133         result = pkgmgrinfo_pkginfo_get_url(__packageInfoHandle, &pUrl);
1134         if (result == PMINFO_R_OK)
1135         {
1136                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_url(): url = [%s]", pUrl);
1137                 String url(pUrl);
1138                 __url = url;
1139         }
1140         else
1141         {
1142                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_url() is failed. result = [%d]", result);
1143         }
1144
1145         result = pkgmgrinfo_pkginfo_get_mainappid(__packageInfoHandle, &pMainAppId);
1146         if (result == PMINFO_R_OK)
1147         {
1148                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_mainappid(): mainApp = [%s]", pMainAppId);
1149                 AppId mainAppId(pMainAppId);
1150                 __mainAppId = mainAppId;
1151         }
1152         else
1153         {
1154                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_mainappid() is failed. result = [%d]", result);
1155         }
1156
1157         result = pkgmgrinfo_pkginfo_get_storeclientid(__packageInfoHandle, &pStoreClientId);
1158         if (result == PMINFO_R_OK)
1159         {
1160                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_storeclientid(): storeClientId = [%s]", pStoreClientId);
1161                 String storeClientId(pStoreClientId);
1162                 __storeClientId = storeClientId;
1163         }
1164         else
1165         {
1166                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_storeclientid() is failed. result = [%d]", result);
1167         }
1168
1169         result = pkgmgrinfo_pkginfo_get_root_path(__packageInfoHandle, &pRootPath);
1170         if (result == PMINFO_R_OK)
1171         {
1172                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_root_path(): rootPath = [%s]", pRootPath);
1173                 String rootPath(pRootPath);
1174                 __appRootPath = rootPath;
1175         }
1176         else
1177         {
1178                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_root_path() is failed. result = [%d]", result);
1179         }
1180
1181         return r;
1182 }
1183
1184 int
1185 _PackageInfoImpl::GetUniqueId(void) const
1186 {
1187         result r = E_SUCCESS;
1188         Database db;
1189         DbStatement* pStmt = null;
1190         DbEnumerator* pEnum = null;
1191         String query;
1192         int uniqueId = 0;
1193
1194         query.Format(1024, L"SELECT UNIQUE_ID FROM PkgInfo WHERE PKG_ID = '%ls'", __id.GetPointer());
1195
1196         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1197         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1198
1199         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1200         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1201
1202         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1203         if (pEnum != null)
1204         {
1205                 if (pEnum->MoveNext() == E_SUCCESS)
1206                 {
1207                         pEnum->GetIntAt(0, uniqueId);
1208                 }
1209
1210                 delete pEnum;
1211         }
1212         else
1213         {
1214                 r = E_OBJ_NOT_FOUND;
1215         }
1216
1217 CATCH:
1218         delete pStmt;
1219
1220         return uniqueId;
1221 }
1222
1223 result
1224 _PackageInfoImpl::GetUiScalabilityInfo(String& baseScreenSize, String& coordinateSystem, String& logicalCoordinate) const
1225 {
1226         result r = E_SUCCESS;
1227         Database db;
1228         DbStatement* pStmt = null;
1229         DbEnumerator* pEnum = null;
1230         String query;
1231
1232         query.Format(1024,
1233                 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());
1234
1235         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1236         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1237
1238         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1239         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1240                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1241
1242         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1243         if (pEnum != null)
1244         {
1245                 while (pEnum->MoveNext() == E_SUCCESS)
1246                 {
1247                         String name;
1248                         String value;
1249
1250                         pEnum->GetStringAt(0, name);
1251                         pEnum->GetStringAt(1, value);
1252
1253                         if (name == L"CoordinateSystem")
1254                         {
1255                                 coordinateSystem = value;
1256                         }
1257                         else if (name == L"BaseScreenSize")
1258                         {
1259                                 baseScreenSize = value;
1260                         }
1261                         else if (name == L"LogicalCoordinate")
1262                         {
1263                                 logicalCoordinate = value;
1264                         }
1265                 }
1266                 delete pEnum;
1267         }
1268         else
1269         {
1270                 r = E_OBJ_NOT_FOUND;
1271                 SetLastResult(r);
1272         }
1273
1274 CATCH:
1275         delete pStmt;
1276
1277         return r;
1278 }
1279
1280 // to be removed
1281 const String&
1282 _PackageInfoImpl::GetAppPackageName(void)
1283 {
1284         if (__appPackageName.IsEmpty() == false)
1285         {
1286                 return __appPackageName;
1287         }
1288
1289         result r = E_SUCCESS;
1290         Database db;
1291         DbStatement* pStmt = null;
1292         DbEnumerator* pEnum = null;
1293         String query;
1294
1295         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo WHERE AppInfo.APP_DEFAULT = 'True' and ID = %d", GetUniqueId());
1296
1297         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1298         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1299
1300         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1301         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1302
1303         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1304         if (pEnum != null)
1305         {
1306                 if (pEnum->MoveNext() == E_SUCCESS)
1307                 {
1308                         pEnum->GetStringAt(0, __appPackageName);
1309                 }
1310
1311                 delete pEnum;
1312                 pEnum = null;
1313         }
1314
1315 CATCH:
1316         delete pStmt;
1317         pStmt = null;
1318
1319         return __appPackageName;
1320 }
1321
1322 const String&
1323 _PackageInfoImpl::GetApiVersion(void) const
1324 {
1325         return __appApiVersion;
1326 }
1327
1328 const String&
1329 _PackageInfoImpl::GetName(void) const
1330 {
1331         return __displayName;
1332 }
1333
1334 _PackageInfoImpl*
1335 _PackageInfoImpl::GetInstance(PackageInfo* pPackageInfo)
1336 {
1337         if (pPackageInfo)
1338         {
1339                 return pPackageInfo->__pPackageInfoImpl;
1340         }
1341
1342         return null;
1343 }
1344
1345 const _PackageInfoImpl*
1346 _PackageInfoImpl::GetInstance(const PackageInfo* pPackageInfo)
1347 {
1348         if (pPackageInfo)
1349         {
1350                 return pPackageInfo->__pPackageInfoImpl;
1351         }
1352
1353         return null;
1354 }
1355
1356 } } } // Tizen::App::Package