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