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