src/app/package/FAppPkg_PackageInfoImpl.cpp

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