src/app/package/FAppPkg_PackageInfoImpl.cpp

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