src/app/package/FAppPkg_PackageInfoImpl.cpp

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