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