src/app/package/FAppPkg_PackageInfoImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        FAppPkg_PackageInfoImpl.cpp
  19  * @brief       This is the implementation for the _PackageInfoImpl class.
  20  */
  21 #include <new>
  22 #include <cstdio>
  23 #include <cstdlib>
  24 #include <unistd.h>
  25 #include <unique_ptr.h>
  26
  27 #include <FAppPkgPackageManager.h>
  28 #include <FAppPkgPackageAppInfo.h>
  29 #include <FAppPkgPackageInfo.h>
  30 #include <FIoDatabase.h>
  31 #include <FIoDbEnumerator.h>
  32 #include <FIoDbStatement.h>
  33 #include <FBaseSysLog.h>
  34 #include <FSecPrivilegeInfo.h>
  35
  36 #include <FBase_StringConverter.h>
  37 #include <FBaseUtilStringTokenizer.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                                 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);
 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);
 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(): appId = [%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                 result r = E_SUCCESS;
 386
 387                 for (int i = 0; i < __pPackageAppInfoList->GetCount(); i++)
 388                 {
 389                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(__pPackageAppInfoList->GetAt(i));
 390                         if (pPackageAppInfo)
 391                         {
 392                                 if (appId != pPackageAppInfo->GetAppId())
 393                                 {
 394                                         continue;
 395                                 }
 396
 397                                 PackageAppInfo* pInfo = new (std::nothrow) PackageAppInfo;
 398                                 SysTryReturn(NID_APP, pInfo, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 399
 400                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pInfo);
 401                                 SysTryReturn(NID_APP, pPackageAppInfoImpl, null, E_SYSTEM, "pPackageAppInfoImpl is null.");
 402
 403                                 String appName = pPackageAppInfo->GetAppName();
 404                                 String appDisplayName = pPackageAppInfo->GetAppDisplayName();
 405                                 bool menuIconVisible = pPackageAppInfo->IsMenuIconVisible();
 406                                 bool mainApp = pPackageAppInfo->IsMainApp();
 407
 408                                 pPackageAppInfoImpl->SetAppId(appId);
 409                                 pPackageAppInfoImpl->SetAppName(appName);
 410                                 pPackageAppInfoImpl->SetAppDisplayName(appDisplayName);
 411                                 pPackageAppInfoImpl->SetMenuIconVisible(menuIconVisible);
 412                                 pPackageAppInfoImpl->SetMainApp(mainApp);
 413
 414                                 return pInfo;
 415                         }
 416                  }
 417         }
 418
 419         return null;
 420 }
 421
 422 int
 423 _PackageInfoImpl::PackageAppInfoListHandler(const pkgmgrinfo_appinfo_h handle, void* pUser_data)
 424 {
 425         ArrayList* pList = (ArrayList*) pUser_data;
 426
 427         PackageAppInfo* pPackageAppInfo = new (std::nothrow) PackageAppInfo;
 428         SysTryReturn(NID_APP, pPackageAppInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 429
 430         GetPackageAppInfo(handle, pPackageAppInfo);
 431
 432         pList->Add(*pPackageAppInfo);
 433
 434         return 0;
 435 }
 436
 437 bool
 438 _PackageInfoImpl::GetPackageAppInfo(const pkgmgrinfo_appinfo_h handle, PackageAppInfo* pPackageAppInfo)
 439 {
 440         SysTryReturn(NID_APP, pPackageAppInfo, false, E_INVALID_ARG, "[E_INVALID_ARG] pPackageAppInfo is null.");
 441
 442         int res = 0;
 443         char* pAppId = null;
 444
 445         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 446
 447         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
 448         if (res == 0)
 449         {
 450                 SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appid(): appId = [%s]", pAppId);
 451                 pPackageAppInfoImpl->Construct(pAppId);
 452         }
 453         else
 454         {
 455                 SysLog(NID_APP, "pkgmgrinfo_appinfo_get_appid() is failed. result = [%d]", res);
 456         }
 457
 458         return true;
 459 }
 460
 461 ArrayList*
 462 _PackageInfoImpl::GetPrivilegeListN(void) const
 463 {
 464         SysTryReturn(NID_APP, __pPrivilegeList, null, E_SYSTEM, "__pPrivilegeList must not be null.");
 465
 466         result r = E_SUCCESS;
 467
 468         ArrayList* pPrivilegeList = new (std::nothrow) ArrayList;
 469         SysTryReturn(NID_APP, pPrivilegeList, null, E_OUT_OF_MEMORY, "pPrivilegeList must not be null.");
 470         pPrivilegeList->Construct();
 471
 472         for (int i = 0; i < __pPrivilegeList->GetCount(); i++)
 473         {
 474                 String* pPrivilege = dynamic_cast <String*>(__pPrivilegeList->GetAt(i));
 475                 if (pPrivilege)
 476                 {
 477                         PrivilegeInfo* pPrivilegeInfo = new (std::nothrow) PrivilegeInfo;
 478                         SysTryReturn(NID_APP, pPrivilegeInfo, null, E_OUT_OF_MEMORY, "pPrivilegeInfo must not be null.");
 479
 480                         pPrivilegeInfo->Construct(*pPrivilege);
 481
 482                         r = pPrivilegeList->Add(*pPrivilegeInfo);
 483                 }
 484          }
 485
 486         return pPrivilegeList;
 487 }
 488
 489 result
 490 _PackageInfoImpl::AddPrivilege(const String& privilege)
 491 {
 492         result r = E_SUCCESS;
 493
 494         r = __pPrivilegeList->Add(privilege);
 495         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pPrivilegeList->Add() is failed.");
 496
 497         return r;
 498 }
 499
 500 result
 501 _PackageInfoImpl::AddPackageAppInfo(const PackageAppInfo& packageAppInfo)
 502 {
 503         result r = E_SUCCESS;
 504         r = __pPackageAppInfoList->Add(packageAppInfo);
 505         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pPackageAppInfoList->Add() is failed.");
 506
 507         return r;
 508 }
 509
 510 // to be reviewed
 511 _PackageInfoImpl::_PackageInfoImpl(void)
 512         : __appReadOnlySize(0)
 513         , __appDataSize(0)
 514         , __appStorageType(0)
 515         , __appState(0)
 516         , __certType(0)
 517         , __pPrivilegeList(null)
 518         , __pAppInfoImplList(null)
 519         , __pPackageAppInfoList(null)
 520         , __packageInfoHandle(null)
 521         , __uninstallable(true)
 522         , __movable(false)
 523         , __downloaded(false)
 524         , __iconAvailable(false)
 525         , __externalStorage(false)
 526         , __fromDatabase(false)
 527         , __packageType(PACKAGE_TYPE_TPK)
 528         , __pPackageInfo(null)
 529 {
 530         __pAppInfoImplList = new (std::nothrow) ArrayList;
 531         SysTryReturnVoidResult(NID_APP, __pAppInfoImplList != null, E_OUT_OF_MEMORY, "__pAppInfoImplList instance must not be null.");
 532         __pAppInfoImplList->Construct();
 533
 534         __pPackageAppInfoList = new (std::nothrow) ArrayList;
 535         SysTryReturnVoidResult(NID_APP, __pPackageAppInfoList != null, E_OUT_OF_MEMORY, "__pPackageAppInfoList instance must not be null.");
 536         __pPackageAppInfoList->Construct();
 537
 538         __pPrivilegeList = new (std::nothrow) ArrayList;
 539         SysTryReturnVoidResult(NID_APP, __pPrivilegeList != null, E_OUT_OF_MEMORY, "__pPrivilegeList must not be null.");
 540         __pPrivilegeList->Construct();
 541 }
 542
 543 _PackageInfoImpl::~_PackageInfoImpl(void)
 544 {
 545         __pAppInfoImplList->RemoveAll(true);
 546         delete __pAppInfoImplList;
 547
 548         __pPackageAppInfoList->RemoveAll(true);
 549         delete __pPackageAppInfoList;
 550
 551         __pPrivilegeList->RemoveAll(true);
 552         delete __pPrivilegeList;
 553
 554         if (__packageInfoHandle)
 555         {
 556                 pkgmgrinfo_pkginfo_destroy_pkginfo(__packageInfoHandle);
 557         }
 558 }
 559
 560 const String&
 561 _PackageInfoImpl::GetAppId(void) const
 562 {
 563         return __id;
 564 }
 565
 566 result
 567 _PackageInfoImpl::SetAppId(const String& id)
 568 {
 569         __id = id;
 570         return E_SUCCESS;
 571 }
 572
 573 const String&
 574 _PackageInfoImpl::GetAppVersion(void) const
 575 {
 576         return __version;
 577 }
 578
 579 result
 580 _PackageInfoImpl::SetAppVersion(const String& appVersion)
 581 {
 582         __version = appVersion;
 583         return E_SUCCESS;
 584 }
 585
 586 const String&
 587 _PackageInfoImpl::GetAppType(void) const
 588 {
 589         return __type;
 590 }
 591
 592 result
 593 _PackageInfoImpl::SetAppType(const String& appType)
 594 {
 595         __type = appType;
 596         return E_SUCCESS;
 597 }
 598
 599 const String&
 600 _PackageInfoImpl::GetAppMimeType(void) const
 601 {
 602         return __appMimeType;
 603 }
 604
 605 result
 606 _PackageInfoImpl::SetAppMimeType(const String& appMimeType)
 607 {
 608         __appMimeType = appMimeType;
 609         return E_SUCCESS;
 610 }
 611
 612 const String&
 613 _PackageInfoImpl::GetAppApiVersion(void) const
 614 {
 615         return __appApiVersion;
 616 }
 617
 618 result
 619 _PackageInfoImpl::SetAppApiVersion(const String& appApiVersion)
 620 {
 621         __appApiVersion = appApiVersion;
 622         return E_SUCCESS;
 623 }
 624
 625 const String&
 626 _PackageInfoImpl::GetAppName(void) const
 627 {
 628         return __displayName;
 629 }
 630
 631 result
 632 _PackageInfoImpl::SetAppName(const String& appName)
 633 {
 634         __displayName = appName;
 635         return E_SUCCESS;
 636 }
 637
 638 const String&
 639 _PackageInfoImpl::GetAppDescription(void) const
 640 {
 641         return __description;
 642 }
 643
 644 result
 645 _PackageInfoImpl::SetAppDescription(const String& appDescription)
 646 {
 647         __description = appDescription;
 648         return E_SUCCESS;
 649 }
 650
 651 const String&
 652 _PackageInfoImpl::GetAppVendor(void) const
 653 {
 654         return __author;
 655 }
 656
 657 result
 658 _PackageInfoImpl::SetAppVendor(const String& appVendor)
 659 {
 660         __author = appVendor;
 661         return E_SUCCESS;
 662 }
 663
 664 const String&
 665 _PackageInfoImpl::GetAppUrl(void) const
 666 {
 667         return __url;
 668 }
 669
 670 result
 671 _PackageInfoImpl::SetAppUrl(const String& appUrl)
 672 {
 673         __url = appUrl;
 674         return E_SUCCESS;
 675 }
 676
 677 const String&
 678 _PackageInfoImpl::GetAppCid(void) const
 679 {
 680         return __appCid;
 681 }
 682
 683 result
 684 _PackageInfoImpl::SetAppCid(const String& appCid)
 685 {
 686         __appCid = appCid;
 687         return E_SUCCESS;
 688 }
 689
 690 const String&
 691 _PackageInfoImpl::GetAppRootPath(void) const
 692 {
 693         return __appRootPath;
 694 }
 695
 696 result
 697 _PackageInfoImpl::SetAppRootPath(const String& appRootPath)
 698 {
 699         __appRootPath = appRootPath;
 700         return E_SUCCESS;
 701 }
 702
 703 int
 704 _PackageInfoImpl::GetAppStorageType(void) const
 705 {
 706         return __appStorageType;
 707 }
 708
 709 result
 710 _PackageInfoImpl::SetAppStorageType(int appStorageType)
 711 {
 712         __appStorageType = appStorageType;
 713         return E_SUCCESS;
 714 }
 715
 716 int
 717 _PackageInfoImpl::GetCertType(void) const
 718 {
 719         return __certType;
 720 }
 721
 722 result
 723 _PackageInfoImpl::SetCertType(int certType)
 724 {
 725         __certType = certType;
 726         return E_SUCCESS;
 727 }
 728
 729 ArrayList*
 730 _PackageInfoImpl::GetAppInfoListN(void) const
 731 {
 732         result r = E_SUCCESS;
 733         Database db;
 734         DbStatement* pStmt = null;
 735         DbEnumerator* pEnum = null;
 736         String query;
 737         //int id = 0;
 738         ArrayList* pList = null;
 739
 740         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", GetUniqueId());
 741
 742         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 743         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 744
 745         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 746         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 747
 748         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 749         if (pEnum != null)
 750         {
 751                 pList = new (std::nothrow) ArrayList;
 752                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 753                 pList->Construct();
 754
 755                 while (pEnum->MoveNext() == E_SUCCESS)
 756                 {
 757                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
 758                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
 759
 760                         int uniqueId = 0;
 761                         int pkgId = 0;
 762                         String name;
 763                         String type;
 764                         String defaultapp;
 765                         String mainmenuIcon;
 766                         String settingIcon;
 767                         //String tickerIcon;
 768                         String quickpanelIcon;
 769                         //String launchImageIcon;
 770                         int appFeature = 0;
 771                         String packageName;
 772
 773                         pEnum->GetIntAt(0, uniqueId);
 774                         pEnum->GetIntAt(1, pkgId);
 775                         pEnum->GetStringAt(2, name);
 776                         pEnum->GetStringAt(3, type);
 777                         pEnum->GetStringAt(4, defaultapp);
 778                         pEnum->GetStringAt(5, mainmenuIcon);
 779                         pEnum->GetStringAt(6, settingIcon);
 780                         //pEnum->GetStringAt(7, tickerIcon);
 781                         pEnum->GetStringAt(8, quickpanelIcon);
 782                         //pEnum->GetStringAt(9, launchImageIcon);
 783                         pEnum->GetIntAt(10, appFeature);
 784                         pEnum->GetStringAt(11, packageName);
 785
 786                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
 787                         pPackageAppInfoImpl->SetPkgId(pkgId);
 788                         pPackageAppInfoImpl->SetName(name);
 789                         pPackageAppInfoImpl->SetType(type);
 790                         pPackageAppInfoImpl->SetDefault(defaultapp);
 791                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
 792                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
 793                         //pPackageAppInfoImpl->SetTickerIcon(tickerIcon);
 794                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
 795                         //pPackageAppInfoImpl->SetLaunchImageIcon(launchImageIcon);
 796                         pPackageAppInfoImpl->SetAppFeature(appFeature);
 797                         pPackageAppInfoImpl->SetPackageName(packageName);
 798
 799                         pList->Add(*pPackageAppInfoImpl);
 800                 }
 801
 802                 delete pEnum;
 803         }
 804
 805 CATCH:
 806         delete pStmt;
 807         return pList;
 808 }
 809
 810 ArrayList*
 811 _PackageInfoImpl::GetAppInfoList(void)
 812 {
 813         if (__pAppInfoImplList == null)
 814         {
 815                 __pAppInfoImplList = GetAppInfoListN();
 816         }
 817
 818         return __pAppInfoImplList;
 819 }
 820
 821 result
 822 _PackageInfoImpl::AddAppInfo(const _PackageAppInfoImpl& appInfoImpl)
 823 {
 824         result r = E_SUCCESS;
 825         r = __pAppInfoImplList->Add(appInfoImpl);
 826         SysTryReturnResult(NID_APP, !IsFailed(r), r, "__pAppInfoImplList->Add() is failed.");
 827
 828         return r;
 829 }
 830
 831 result
 832 _PackageInfoImpl::GetPrivileges(String& privileges, String& hmacPrivileges, ArrayList& privilegeList)
 833 {
 834         result r = E_SUCCESS;
 835         Database db;
 836         DbStatement* pStmt = null;
 837         DbEnumerator* pEnum = null;
 838         String query;
 839
 840         String privilegeListString;
 841         String delim("#");
 842         String privilegeToken;
 843
 844
 845         query.Format(1024, L"SELECT * FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
 846
 847         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 848         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 849
 850         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 851         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 852
 853         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 854         if (pEnum != null)
 855         {
 856                 if (pEnum->MoveNext() == E_SUCCESS)
 857                 {
 858                         pEnum->GetStringAt(1, privileges);
 859                         pEnum->GetStringAt(2, hmacPrivileges);
 860                         pEnum->GetStringAt(4, privilegeListString);
 861                 }
 862
 863                 StringTokenizer strTok(privilegeListString, delim);
 864
 865                 while (strTok.HasMoreTokens())
 866                 {
 867                         strTok.GetNextToken(privilegeToken);
 868                         privilegeList.Add(new String(privilegeToken));
 869                 }
 870
 871                 delete pEnum;
 872                 pEnum = null;
 873         }
 874
 875 CATCH:
 876         delete pStmt;
 877         pStmt = null;
 878         return r;
 879 }
 880
 881 result
 882 _PackageInfoImpl::GetPrivilegesValue(String& privileges, String& hmacPrivileges) const
 883 {
 884         privileges = __privileges;
 885         hmacPrivileges = __hmacPrivileges;
 886
 887         return E_SUCCESS;
 888 }
 889
 890 result
 891 _PackageInfoImpl::SetPrivilegesValue(const String& privileges, const String& hmacPrivileges)
 892 {
 893         __privileges = privileges;
 894         __hmacPrivileges = hmacPrivileges;
 895
 896         return E_SUCCESS;
 897 }
 898
 899 int
 900 _PackageInfoImpl::GetApiVisibility() const
 901 {
 902         result r = E_SUCCESS;
 903         int apiVisibility = 0;
 904         Database db;
 905         DbStatement* pStmt = null;
 906         DbEnumerator* pEnum = null;
 907         String query;
 908
 909         query.Format(1024, L"SELECT CERTIFICATE_TYPE FROM PkgPrivileges WHERE ID = %d", GetUniqueId());
 910
 911         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
 912         SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
 913
 914         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
 915         SysTryCatch(NID_APP, pStmt != null, apiVisibility = -1, GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
 916
 917         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
 918         if (pEnum != null)
 919         {
 920                 if (pEnum->MoveNext() == E_SUCCESS)
 921                 {
 922                         if (pEnum->GetColumnType(0) != DB_COLUMNTYPE_NULL)
 923                         {
 924                                 r = pEnum->GetIntAt(0, apiVisibility);
 925                                 SysTryCatch(NID_APP, r == E_SUCCESS, apiVisibility = -1, r, "[%s] GetIntAt() is failed.", GetErrorMessage(r));
 926                         }
 927                 }
 928
 929                 delete pEnum;
 930                 pEnum = null;
 931         }
 932
 933 CATCH:
 934         delete pStmt;
 935         pStmt = null;
 936         return apiVisibility;
 937 }
 938
 939 const String&
 940 _PackageInfoImpl::GetAppIconPath(void) const
 941 {
 942         return __appIconPath;
 943 }
 944
 945 result
 946 _PackageInfoImpl::SetAppIconPath(const Tizen::Base::String& appIconPath)
 947 {
 948         __appIconPath = appIconPath;
 949
 950         return E_SUCCESS;
 951 }
 952
 953 const DateTime&
 954 _PackageInfoImpl::GetAppInstallationTime(void) const
 955 {
 956         return __dateTime;
 957 }
 958
 959 result
 960 _PackageInfoImpl::SetAppInstallationTime(const DateTime& installationTime)
 961 {
 962         __dateTime = installationTime;
 963
 964         return E_SUCCESS;
 965 }
 966
 967 result
 968 _PackageInfoImpl::Construct(const PackageId& packageId)
 969 {
 970         result r = E_SUCCESS;
 971         int result = 0;
 972         char* pPackage = null;
 973         char* pVersion = null;
 974         char* pName = null;
 975         char* pIconPath = null;
 976         char* pType = null;
 977         char* pDescription = null;
 978         char* pAuthor = null;
 979         char* pUrl = null;
 980         char* pMainAppId = null;
 981         char* pStoreClientId = null;
 982         int installedTime = 0;
 983         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 984         bool removable = true;
 985
 986         // temp
 987         Database db;
 988         DbStatement* pStmt = null;
 989         DbEnumerator* pEnum = null;
 990         String query;
 991
 992         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 993         SysTryReturnResult(NID_APP, pPackageId, E_OUT_OF_MEMORY, "pPackageId is null");
 994
 995         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &__packageInfoHandle);
 996         SysTryReturnResult(NID_APP, result == PMINFO_R_OK, E_PKG_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() is failed. result=[%d], packageId=[%s]", result, pPackageId.get());
 997
 998         __fromDatabase = true;
 999
1000         result = pkgmgrinfo_pkginfo_get_pkgname(__packageInfoHandle, &pPackage);
1001         if (result == PMINFO_R_OK)
1002         {
1003                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1004                 String package(pPackage);
1005                 __id = package;
1006         }
1007         else
1008         {
1009                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1010         }
1011
1012         result = pkgmgrinfo_pkginfo_get_version(__packageInfoHandle, &pVersion);
1013         if (result == PMINFO_R_OK)
1014         {
1015                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_version(): version = [%s]", pVersion);
1016                 String version(pVersion);
1017                 __version = version;
1018         }
1019         else
1020         {
1021                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_version() is failed. result = [%d]", result);
1022         }
1023
1024         result = pkgmgrinfo_pkginfo_get_type(__packageInfoHandle, &pType);
1025         if (result == PMINFO_R_OK)
1026         {
1027                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_type(): type = [%s]", pType);
1028                 String type(pType);
1029                 __type = type;
1030         }
1031         else
1032         {
1033                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_type() is failed. result = [%d]", result);
1034         }
1035
1036         result = pkgmgrinfo_pkginfo_get_label(__packageInfoHandle, &pName);
1037         if (result == PMINFO_R_OK)
1038         {
1039                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_label(): name = [%s]", pName);
1040                 String Name(pName);
1041                 __displayName = Name;
1042         }
1043         else
1044         {
1045                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_label() is failed. result = [%d]", result);
1046         }
1047
1048         result = pkgmgrinfo_pkginfo_get_icon(__packageInfoHandle, &pIconPath);
1049         if (result == PMINFO_R_OK)
1050         {
1051                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_icon(): iconpath = [%s]", pIconPath);
1052                 String path(pIconPath);
1053                 __appIconPath = path;
1054         }
1055         else
1056         {
1057                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_icon() is failed. result = [%d]", result);
1058         }
1059
1060         result = pkgmgrinfo_pkginfo_is_removable(__packageInfoHandle, &removable);
1061         if (result == PMINFO_R_OK)
1062         {
1063                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_removable(): removable = [%d]", removable);
1064
1065                 if (removable == false)
1066                 {
1067                         __uninstallable = false;
1068                 }
1069         }
1070         else
1071         {
1072                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_is_removable() is failed. result = [%d]", result);
1073         }
1074
1075         result = pkgmgrinfo_pkginfo_get_description(__packageInfoHandle, &pDescription);
1076         if (result == PMINFO_R_OK)
1077         {
1078                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_description(): description = [%s]", pDescription);
1079                 String description(pDescription);
1080                 __description = description;
1081         }
1082         else
1083         {
1084                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_description() is failed. result = [%d]", result);
1085         }
1086
1087         result = pkgmgrinfo_pkginfo_get_author_name(__packageInfoHandle, &pAuthor);
1088         if (result == PMINFO_R_OK)
1089         {
1090                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_author_name(): author = [%s]", pAuthor);
1091                 String author(pAuthor);
1092                 __author = author;
1093         }
1094         else
1095         {
1096                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_author_name() is failed. result = [%d]", result);
1097         }
1098
1099         result = pkgmgrinfo_pkginfo_get_installed_time(__packageInfoHandle, &installedTime);
1100         if (result == PMINFO_R_OK)
1101         {
1102                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_time(): installedTime = [%d]", installedTime);
1103
1104                 time_t dateTime = (time_t) installedTime;
1105                 struct tm* pGmTime = null;
1106
1107                 pGmTime = gmtime(&dateTime);
1108                 if (pGmTime)
1109                 {
1110                         DateTime tempTime;
1111                         tempTime.SetValue(pGmTime->tm_year + 1900, pGmTime->tm_mon + 1, pGmTime->tm_mday, pGmTime->tm_hour, pGmTime->tm_min, pGmTime->tm_sec);
1112                         __dateTime = tempTime;
1113                         SysLog(NID_APP, "Time %d %d/%d, %d:%d:%d", tempTime.GetYear(), tempTime.GetMonth(), tempTime.GetDay(), tempTime.GetHour(), tempTime.GetMinute(), tempTime.GetSecond());
1114                 }
1115         }
1116         else
1117         {
1118                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_time() is failed. result = [%d]", result);
1119         }
1120
1121         result = pkgmgrinfo_pkginfo_get_installed_storage(__packageInfoHandle, &storage);
1122         if (result == PMINFO_R_OK)
1123         {
1124                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d]", storage);
1125                 if (storage == PMINFO_EXTERNAL_STORAGE)
1126                 {
1127                         __externalStorage = true;
1128                 }
1129         }
1130         else
1131         {
1132                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage() is failed. result = [%d]", result);
1133         }
1134
1135         result = pkgmgrinfo_pkginfo_get_url(__packageInfoHandle, &pUrl);
1136         if (result == PMINFO_R_OK)
1137         {
1138                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_url(): url = [%s]", pUrl);
1139                 String url(pUrl);
1140                 __url = url;
1141         }
1142         else
1143         {
1144                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_url() is failed. result = [%d]", result);
1145         }
1146
1147         result = pkgmgrinfo_pkginfo_get_mainappid(__packageInfoHandle, &pMainAppId);
1148         if (result == PMINFO_R_OK)
1149         {
1150                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_mainappid(): mainAppId = [%s]", pMainAppId);
1151                 AppId mainAppId(pMainAppId);
1152                 __mainAppId = mainAppId;
1153         }
1154         else
1155         {
1156                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_mainappid() is failed. result = [%d]", result);
1157         }
1158
1159         result = pkgmgrinfo_pkginfo_get_storeclientid(__packageInfoHandle, &pStoreClientId);
1160         if (result == PMINFO_R_OK)
1161         {
1162                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_storeclientid(): storeClientId = [%s]", pStoreClientId);
1163                 String storeClientId(pStoreClientId);
1164                 __storeClientId = storeClientId;
1165         }
1166         else
1167         {
1168                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_storeclientid() is failed. result = [%d]", result);
1169         }
1170
1171         // temp
1172         query.Format(1024, L"SELECT PkgInfo.*, AppInfo.APP_MAINMENU_ICON FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = 'True' and PkgInfo.PKG_ID = '%ls'", packageId.GetPointer());
1173
1174         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1175         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1176
1177         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1178         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1179
1180         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1181         if (pEnum != null)
1182         {
1183                 if (pEnum->MoveNext() == E_SUCCESS)
1184                 {
1185                         String rootPath;
1186                         int storageType = 0;
1187
1188                         if (pEnum->GetColumnType(16) != DB_COLUMNTYPE_NULL)
1189                         {
1190                                 pEnum->GetStringAt(16, rootPath);
1191                         }
1192                         if (pEnum->GetColumnType(17) != DB_COLUMNTYPE_NULL)
1193                         {
1194                                 pEnum->GetIntAt(17, storageType);
1195                         }
1196
1197                         SetAppRootPath(rootPath);
1198                         SetAppStorageType(storageType);
1199                 }
1200
1201                 delete pEnum;
1202         }
1203
1204 CATCH:
1205         delete pStmt;
1206         return r;
1207 }
1208
1209 int
1210 _PackageInfoImpl::GetUniqueId(void) const
1211 {
1212         result r = E_SUCCESS;
1213         Database db;
1214         DbStatement* pStmt = null;
1215         DbEnumerator* pEnum = null;
1216         String query;
1217         int uniqueId = 0;
1218
1219         query.Format(1024, L"SELECT UNIQUE_ID FROM PkgInfo WHERE PKG_ID = '%ls'", __id.GetPointer());
1220
1221         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1222         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1223
1224         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1225         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1226
1227         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1228         if (pEnum != null)
1229         {
1230                 if (pEnum->MoveNext() == E_SUCCESS)
1231                 {
1232                         pEnum->GetIntAt(0, uniqueId);
1233                 }
1234
1235                 delete pEnum;
1236         }
1237         else
1238         {
1239                 r = E_OBJ_NOT_FOUND;
1240         }
1241
1242 CATCH:
1243         delete pStmt;
1244
1245         return uniqueId;
1246 }
1247
1248 result
1249 _PackageInfoImpl::GetUiScalabilityInfo(String& baseScreenSize, String& coordinateSystem, String& logicalCoordinate) const
1250 {
1251         result r = E_SUCCESS;
1252         Database db;
1253         DbStatement* pStmt = null;
1254         DbEnumerator* pEnum = null;
1255         String query;
1256
1257         query.Format(1024,
1258                 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());
1259
1260         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1261         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1262
1263         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1264         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1265                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1266
1267         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1268         if (pEnum != null)
1269         {
1270                 while (pEnum->MoveNext() == E_SUCCESS)
1271                 {
1272                         String name;
1273                         String value;
1274
1275                         pEnum->GetStringAt(0, name);
1276                         pEnum->GetStringAt(1, value);
1277
1278                         if (name == L"CoordinateSystem")
1279                         {
1280                                 coordinateSystem = value;
1281                         }
1282                         else if (name == L"BaseScreenSize")
1283                         {
1284                                 baseScreenSize = value;
1285                         }
1286                         else if (name == L"LogicalCoordinate")
1287                         {
1288                                 logicalCoordinate = value;
1289                         }
1290                 }
1291                 delete pEnum;
1292         }
1293         else
1294         {
1295                 r = E_OBJ_NOT_FOUND;
1296                 SetLastResult(r);
1297         }
1298
1299 CATCH:
1300         delete pStmt;
1301
1302         return r;
1303 }
1304
1305 // to be removed
1306 const String&
1307 _PackageInfoImpl::GetAppPackageName(void)
1308 {
1309         if (__appPackageName.IsEmpty() == false)
1310         {
1311                 return __appPackageName;
1312         }
1313
1314         result r = E_SUCCESS;
1315         Database db;
1316         DbStatement* pStmt = null;
1317         DbEnumerator* pEnum = null;
1318         String query;
1319
1320         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo WHERE AppInfo.APP_DEFAULT = 'True' and ID = %d", GetUniqueId());
1321
1322         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1323         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1324
1325         pStmt = _PackageManagerImpl::CreateStatementN(db, query);
1326         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1327
1328         pEnum = _PackageManagerImpl::ExecuteStatementN(db, pStmt);
1329         if (pEnum != null)
1330         {
1331                 if (pEnum->MoveNext() == E_SUCCESS)
1332                 {
1333                         pEnum->GetStringAt(0, __appPackageName);
1334                 }
1335
1336                 delete pEnum;
1337                 pEnum = null;
1338         }
1339
1340 CATCH:
1341         delete pStmt;
1342         pStmt = null;
1343
1344         return __appPackageName;
1345 }
1346
1347 const String&
1348 _PackageInfoImpl::GetApiVersion(void) const
1349 {
1350         return __appApiVersion;
1351 }
1352
1353 const String&
1354 _PackageInfoImpl::GetName(void) const
1355 {
1356         return __displayName;
1357 }
1358
1359 _PackageInfoImpl*
1360 _PackageInfoImpl::GetInstance(PackageInfo* pPackageInfo)
1361 {
1362         if (pPackageInfo)
1363         {
1364                 return pPackageInfo->__pPackageInfoImpl;
1365         }
1366
1367         return null;
1368 }
1369
1370 const _PackageInfoImpl*
1371 _PackageInfoImpl::GetInstance(const PackageInfo* pPackageInfo)
1372 {
1373         if (pPackageInfo)
1374         {
1375                 return pPackageInfo->__pPackageInfoImpl;
1376         }
1377
1378         return null;
1379 }
1380
1381 } } } // Tizen::App::Package