src/app/package/FAppPkg_PackageInfoImpl.cpp

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