src/app/package/FAppPkg_PackageInfoImpl.cpp

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