src/app/package/FAppPkg_PackageInfoImpl.cpp

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