src/app/package/FAppPkg_PackageManagerImpl.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_PackageManagerImpl.cpp
  19  * @brief       This is the implementation for the _PackageManagerImpl class.
  20  */
  21 #include <cstdio>
  22 #include <cstdlib>
  23 #include <new>
  24 #include <memory>
  25 #include <unistd.h>
  26 #include <dlog.h>
  27 #include <unique_ptr.h>
  28
  29 #include <package-manager-types.h>
  30
  31 #include <FAppPkgPackageManager.h>
  32 #include <FAppPkgPackageAppInfo.h>
  33 #include <FAppPkgPackageInfo.h>
  34 #include <FAppPkgIPackageInstallationEventListener.h>
  35 #include <FAppPkgIPackageInstallationResponseListener.h>
  36 #include <FAppPkgIPackageUninstallationResponseListener.h>
  37 #include <FBaseSysLog.h>
  38 #include <FIo.h>
  39 #include <FIoRegistry.h>
  40 #include <FSysSystemTime.h>
  41 #include <FBase_StringConverter.h>
  42
  43 #include "FAppPkg_PackageManagerImpl.h"
  44 #include "FAppPkg_PackageInfoImpl.h"
  45 #include "FAppPkg_PackageAppInfoImpl.h"
  46 #include "FAppPkg_PackageParser.h"
  47 #include "FApp_AppInfo.h"
  48 #include "FApp_PackageManagerProxy.h"
  49
  50 using namespace Tizen::Base;
  51 using namespace Tizen::Base::Runtime;
  52 using namespace Tizen::Base::Collection;
  53 using namespace Tizen::Io;
  54 using namespace Tizen::System;
  55
  56 namespace Tizen { namespace App { namespace Package
  57 {
  58
  59 PackageManager* pPackageManagerInstance = null;
  60
  61 Tizen::Base::Collection::HashMap _PackageManagerImpl::__installationList;
  62
  63 void
  64 _PackageManagerEvent::FireImpl(IEventListener& listener, const IEventArg& arg)
  65 {
  66         IPackageInstallationEventListener* pListener = dynamic_cast<IPackageInstallationEventListener*> (&listener);
  67         SysTryReturnVoidResult(NID_APP, pListener != null, E_OUT_OF_MEMORY, "pListener instance must not be null.");
  68
  69         const _PackageManagerEventArg* pArg = dynamic_cast<const _PackageManagerEventArg*>(&arg);
  70         SysTryReturnVoidResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "pArg instance must not be null.");
  71
  72         if (pArg->__eventKey == L"end")
  73         {
  74                 if (pArg->__eventValue == L"ok")
  75                 {
  76                         if (pArg->__install)
  77                         {
  78                                 SysLog(NID_APP, "Installation is Completed. [Package = %ls]", pArg->__packageId.GetPointer());
  79                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
  80                         }
  81                         else
  82                         {
  83                                 SysLog(NID_APP, "Uninstallation is Completed. [Package = %ls]", pArg->__packageId.GetPointer());
  84                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, true);
  85                         }
  86                 }
  87                 else
  88                 {
  89                         if (pArg->__install)
  90                         {
  91                                 SysLog(NID_APP, "Installation is Completed(Error). [Package = %ls]", pArg->__packageId.GetPointer());
  92                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
  93                         }
  94                         else
  95                         {
  96                                 SysLog(NID_APP, "Uninstallation is Completed(Error). [Package = %ls]", pArg->__packageId.GetPointer());
  97                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, false);
  98                         }
  99                 }
 100         }
 101         else if (pArg->__eventKey == L"install_percent")
 102         {
 103                 std::unique_ptr<char[]> pProgress(_StringConverter::CopyToCharArrayN(pArg->__eventValue));
 104
 105                 int progress = 0;
 106                 sscanf(pProgress.get(), "%d", &progress);
 107
 108                 SysLog(NID_APP, "InstallationInProgress [%d]", progress);
 109                 pListener->OnPackageInstallationInProgress(pArg->__packageId, progress);
 110         }
 111 }
 112
 113 PackageId
 114 _PackageManagerImpl::GetPackageIdByAppId(const AppId& appId)
 115 {
 116         SysTryReturn(NID_APP, appId.IsEmpty() == false, L"", E_INVALID_ARG, "appId is empty");
 117
 118         String packageId;
 119
 120         if (appId.StartsWith(L".", 10) == true)
 121         {
 122                 appId.SubString(0, 10, packageId);
 123         }
 124         else
 125         {
 126                 int result = 0;
 127                 char* pPackageId = null;
 128                 pkgmgrinfo_appinfo_h pAppInfoHandle = null;
 129
 130                 std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 131                 SysTryReturn(NID_APP, pAppId, L"", E_OUT_OF_MEMORY, "pAppId is null");
 132
 133                 result = pkgmgrinfo_appinfo_get_appinfo(pAppId.get(), &pAppInfoHandle);
 134                 SysTryReturn(NID_APP, result == 0, L"", E_PKG_NOT_INSTALLED, "pkgmgrinfo_appinfo_get_appinfo() failed. result=[%d], app=[%s]", result, pAppId.get());
 135
 136                 result = pkgmgrinfo_appinfo_get_pkgname(pAppInfoHandle, &pPackageId);
 137
 138                 packageId.Append(pPackageId);
 139
 140                 if(pAppInfoHandle)
 141                 {
 142                         pkgmgrinfo_appinfo_destroy_appinfo(pAppInfoHandle);
 143                 }
 144         }
 145
 146         SysLog(NID_APP, "app = [%ls], package = [%ls]", appId.GetPointer(), packageId.GetPointer());
 147
 148         return packageId;
 149 }
 150
 151 result
 152 _PackageManagerImpl::AddEventListener(IPackageInstallationEventListener* pListener, int priority)
 153 {
 154         SysTryReturnResult(NID_APP, (priority < 3) && (priority >= 0), E_INVALID_ARG, "priority is invalid.");
 155
 156         result r = E_SUCCESS;
 157         int res = 0;
 158
 159         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 160         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 161
 162         while (pEnum->MoveNext() == E_SUCCESS)
 163         {
 164                 _PackageManagerEvent*   pEvent = null;
 165                 pEnum->GetCurrent(pEvent);
 166                 if (pEvent)
 167                 {
 168                         if (pEvent->__pListener == pListener)
 169                         {
 170                                 SysLog(NID_APP, "The event listener already exist. listener = [0x%x]", pListener);
 171                                 return E_OBJ_ALREADY_EXIST;
 172                         }
 173                 }
 174         }
 175
 176         if (__pListeningClient == null)
 177         {
 178                 __pListeningClient = pkgmgr_client_new(PC_LISTENING);
 179                 SysTryReturnResult(NID_APP, __pListeningClient != null, E_SYSTEM, "pkgmgr_client_new(PC_LISTENING) failed");
 180
 181                 res = pkgmgr_client_listen_status(__pListeningClient, PackageEventHandler, this);
 182                 if (res < PKGMGR_R_OK)
 183                 {
 184                         pkgmgr_client_free(__pListeningClient);
 185                         __pListeningClient = null;
 186
 187                         if (res == PKGMGR_R_EINVAL)
 188                         {
 189                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns ARGV error");
 190                                 return E_INVALID_ARG;
 191                         }
 192                         else if (res == PKGMGR_R_ECOMM)
 193                         {
 194                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns COMM error");
 195                         }
 196                         else if (res == PKGMGR_R_ETIMEOUT)
 197                         {
 198                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns TIME_OUT error");
 199                         }
 200                         else if (res == PKGMGR_R_ERROR)
 201                         {
 202                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error");
 203                         }
 204                         else
 205                         {
 206                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error, res = %d", res);
 207                         }
 208
 209                         return E_SYSTEM;
 210                 }
 211         }
 212
 213         _PackageManagerEvent* pEvent = new (std::nothrow) _PackageManagerEvent();
 214         SysTryReturnResult(NID_APP, pEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 215
 216         r = pEvent->Construct();
 217         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "pEvent->Construct() failed.");
 218
 219         pEvent->__pListener = pListener;
 220
 221         r = pEvent->AddListener(*pListener, true);
 222         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "pEvent->AddListener() failed. [%s]", GetErrorMessage(r));
 223
 224         r = __packageEventListenerList.Add(pEvent);
 225         SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 226
 227         SysLog(NID_APP, "Add PackageInstallationEventListener = [0x%x]", pListener);
 228         return E_SUCCESS;
 229 }
 230
 231 result
 232 _PackageManagerImpl::RemoveEventListener(IPackageInstallationEventListener* pListener)
 233 {
 234         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 235         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 236
 237         result r = E_SUCCESS;
 238
 239         while (pEnum->MoveNext() == E_SUCCESS)
 240         {
 241                 _PackageManagerEvent*   pEvent = null;
 242                 pEnum->GetCurrent(pEvent);
 243                 if (pEvent)
 244                 {
 245                         if (pEvent->__pListener == pListener)
 246                         {
 247                                 r = __packageEventListenerList.Remove(pEvent);
 248                                 SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 249
 250                                 delete pEvent;
 251
 252                                 SysLog(NID_APP, "Remove PackageInstallationEventListener = [0x%x]", pListener);
 253                                 return E_SUCCESS;
 254                         }
 255                 }
 256         }
 257
 258         return E_OBJ_NOT_FOUND;
 259 }
 260
 261 PackageInfo*
 262 _PackageManagerImpl::GetPackageInfoN(const PackageId& packageId) const
 263 {
 264         SysTryReturn(NID_APP, packageId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageId is empty.");
 265         SysTryReturn(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, null, E_INVALID_ARG, "packageId is invalid.(length)");
 266
 267         result r = E_SUCCESS;
 268         PackageInfo* pPackageInfo = null;
 269
 270         pPackageInfo = new (std::nothrow) PackageInfo;
 271         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
 272
 273         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
 274         r = pPackageInfoImpl->Construct(packageId);
 275         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] package (%ls) is not found.", packageId.GetPointer());
 276
 277         return pPackageInfo;
 278
 279 CATCH:
 280         delete pPackageInfo;
 281         return null;
 282 }
 283
 284 PackageAppInfo*
 285 _PackageManagerImpl::GetPackageAppInfoN(const AppId& appId) const
 286 {
 287         SysTryReturn(NID_APP, appId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] appId is empty.");
 288
 289         result r = E_SUCCESS;
 290         PackageAppInfo* pPackageAppInfo = null;
 291
 292         pPackageAppInfo = new (std::nothrow) PackageAppInfo;
 293         SysTryReturn(NID_APP, pPackageAppInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageAppInfo instance must not be null.");
 294
 295         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 296         r = pPackageAppInfoImpl->Construct(appId);
 297         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] app (%ls) is not found.", appId.GetPointer());
 298
 299         return pPackageAppInfo;
 300
 301 CATCH:
 302         delete pPackageAppInfo;
 303         return null;
 304 }
 305
 306 IList*
 307 _PackageManagerImpl::GetPackageInfoListN(void) const
 308 {
 309         result r = E_SUCCESS;
 310         int res = 0;
 311         ArrayList* pList = null;
 312
 313         pList = new (std::nothrow) ArrayList();
 314         SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
 315         pList->Construct();
 316
 317         res = pkgmgrinfo_pkginfo_get_list(PackageInfoEventHandler, pList);
 318         if (res != 0)
 319         {
 320                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_list() is failed. result = [%d]", res);
 321
 322                 pList->RemoveAll(true);
 323                 pList = null;
 324         }
 325
 326         SetLastResult(r);
 327         return pList;
 328 }
 329
 330 bool
 331 _PackageManagerImpl::IsPackageInstalled(const PackageId& packageId) const
 332 {
 333         SysTryReturn(NID_APP, packageId.IsEmpty() == false, false, E_INVALID_ARG, "packageId is empty");
 334
 335         int result = 0;
 336         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 337
 338         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 339         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
 340
 341         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 342         if (result != 0)
 343         {
 344                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", result, pPackageId.get());
 345                 return false;
 346         }
 347
 348         if(pPackageInfoHandle)
 349         {
 350                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 351         }
 352
 353         SysLog(NID_APP, "package = [%ls] is installed.", packageId.GetPointer());
 354
 355         return true;
 356 }
 357
 358 result
 359 _PackageManagerImpl::InstallPackage(const PackageId& packageId, const String& packagePath, IPackageInstallationResponseListener* pListener)
 360 {
 361         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 362         SysTryReturnResult(NID_APP, packagePath.IsEmpty() == false, E_INVALID_ARG, "packagePath is empty.");
 363         SysTryReturnResult(NID_APP, File::IsFileExist(packagePath) == true, E_INVALID_ARG, "packagePath is not existed.");
 364
 365         String extension = File::GetFileExtension(packagePath);
 366         SysTryReturnResult(NID_APP, extension.IsEmpty() == false, E_INVALID_ARG, "extension is empty.");
 367
 368         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(packagePath));
 369         SysTryReturnResult(NID_APP, pPackagePath, E_OUT_OF_MEMORY, "pPackagePath is null.");
 370
 371         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 372         SysTryReturnResult(NID_APP, pExtension, E_OUT_OF_MEMORY, "pExtension is null.");
 373
 374         if ((strcasecmp(pExtension.get(), "tpk") == 0) || (strcasecmp(pExtension.get(), "wgt") == 0))
 375         {
 376                 SysLog(NID_APP, "package = [%ls], packagePath = [%s], extension = [%s]", packageId.GetPointer(), pPackagePath.get(), pExtension.get());
 377         }
 378         else
 379         {
 380                 SysLog(NID_APP, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 381                 return E_SYSTEM;
 382         }
 383
 384         // optionalData = 12345abcde:StoreClientId=XXXXX12345
 385         PackageId StoreClientId = _AppInfo::GetPackageId();
 386         String optionalData;
 387         optionalData.Append(packageId);
 388         optionalData.Append(":StoreClientId=");
 389         optionalData.Append(StoreClientId);
 390
 391         std::unique_ptr<char[]> pOptionalData(_StringConverter::CopyToCharArrayN(optionalData));
 392         SysTryReturnResult(NID_APP, pOptionalData, E_OUT_OF_MEMORY, "pOptionalData is null.");
 393
 394         SysLog(NID_APP, "optionalData = [%s]", pOptionalData.get());
 395
 396         result r = E_SUCCESS;
 397         _PackageManagerProxy packageManagerProxy;
 398         r = packageManagerProxy.Construct();
 399         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 400
 401         r = packageManagerProxy.InstallPackage(packageId, packagePath, null);
 402         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.InstallPackage() failed.");
 403
 404         if (__pRequestClient == null)
 405         {
 406                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 407                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 408         }
 409
 410         int res = pkgmgr_client_install(__pRequestClient, pExtension.get(), null, pPackagePath.get(), pOptionalData.get(), PM_QUIET, InstallationEventHandler, pListener);
 411
 412         if (res < PKGMGR_R_OK)
 413         {
 414                 pkgmgr_client_free(__pRequestClient);
 415                 __pRequestClient = null;
 416
 417                 if (res == PKGMGR_R_EINVAL)
 418                 {
 419                         SysLog(NID_APP, "pkgmgr_client_install() returns ARGV error");
 420                         return E_INVALID_ARG;
 421                 }
 422                 else if (res == PKGMGR_R_ECOMM)
 423                 {
 424                         SysLog(NID_APP, "pkgmgr_client_install() returns COMM error");
 425                 }
 426                 else if (res == PKGMGR_R_ETIMEOUT)
 427                 {
 428                         SysLog(NID_APP, "pkgmgr_client_install() returns TIME_OUT error");
 429                 }
 430                 else if (res == PKGMGR_R_ERROR)
 431                 {
 432                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error");
 433                 }
 434                 else
 435                 {
 436                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error, res = %d", res);
 437                 }
 438
 439                 return E_SYSTEM;
 440         }
 441
 442         return E_SUCCESS;
 443 }
 444
 445 result
 446 _PackageManagerImpl::UninstallPackage(const PackageId& packageId, IPackageUninstallationResponseListener* pListener)
 447 {
 448         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 449         SysTryReturnResult(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, E_INVALID_ARG, "The packageId is invalid.(length)");
 450         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 451
 452         result r = E_SUCCESS;
 453         int res = 0;
 454         char* pType = null;
 455         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 456
 457         _PackageManagerProxy packageManagerProxy;
 458         r = packageManagerProxy.Construct();
 459         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 460
 461         r = packageManagerProxy.UninstallPackage(packageId, pListener);
 462         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.UninstallPackage() failed.");
 463
 464         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 465         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 466
 467         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 468         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", res, pPackageId.get());
 469
 470         res = pkgmgrinfo_pkginfo_get_type(pPackageInfoHandle, &pType);
 471         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], package=[%s]", res, pPackageId.get());
 472
 473         if (__pRequestClient == null)
 474         {
 475                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 476                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 477         }
 478
 479         res = pkgmgr_client_uninstall(__pRequestClient, pType, pPackageId.get(), PM_QUIET, UninstallationEventHandler, pListener);
 480         SysLog(NID_APP, "pkgmgr_client_uninstall - req_id=[%d], package=[%s], type=[%s]", res, pPackageId.get(), pType);
 481
 482         if(pPackageInfoHandle)
 483         {
 484                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 485         }
 486
 487         if (res < PKGMGR_R_OK)
 488         {
 489                 pkgmgr_client_free(__pRequestClient);
 490                 __pRequestClient = null;
 491
 492                 if (res == PKGMGR_R_EINVAL)
 493                 {
 494                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns ARGV error");
 495                         return E_INVALID_ARG;
 496                 }
 497                 else if (res == PKGMGR_R_ECOMM)
 498                 {
 499                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns COMM error");
 500                 }
 501                 else if (res == PKGMGR_R_ETIMEOUT)
 502                 {
 503                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns TIME_OUT error");
 504                 }
 505                 else if (res == PKGMGR_R_ERROR)
 506                 {
 507                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error");
 508                 }
 509                 else
 510                 {
 511                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error, res = %d", res);
 512                 }
 513
 514                 return E_SYSTEM;
 515         }
 516
 517         return E_SUCCESS;
 518 }
 519
 520 result
 521 _PackageManagerImpl::MoveToExternalStorage(const PackageId& packageId)
 522 {
 523         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 524         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 525
 526         int res = 0;
 527         char* pType = null;
 528         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 529         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 530
 531         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 532         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 533
 534         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 535         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", res, pPackageId.get());
 536
 537         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 538         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], package=[%s]", res, pPackageId.get());
 539
 540         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 541         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], package=[%s]", res, pPackageId.get());
 542
 543         if (storage == PMINFO_EXTERNAL_STORAGE)
 544         {
 545                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 546                 return E_INVALID_OPERATION;
 547         }
 548
 549         if (__pRequestClient == null)
 550         {
 551                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 552                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 553         }
 554
 555         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_SDCARD, PM_QUIET);
 556
 557         if(packageInfoHandle)
 558         {
 559                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 560         }
 561
 562         if (res < PKGMGR_R_OK)
 563         {
 564                 pkgmgr_client_free(__pRequestClient);
 565                 __pRequestClient = null;
 566
 567                 if (res == PKGMGR_R_EINVAL)
 568                 {
 569                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 570                         return E_INVALID_ARG;
 571                 }
 572                 else if (res == PKGMGR_R_ERROR)
 573                 {
 574                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 575                 }
 576                 else
 577                 {
 578                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 579                 }
 580
 581                 return E_SYSTEM;
 582         }
 583
 584         return E_SUCCESS;
 585 }
 586
 587 result
 588 _PackageManagerImpl::MoveToInternalStorage(const PackageId& packageId)
 589 {
 590         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 591         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 592
 593         int res = 0;
 594         char* pType = null;
 595         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 596         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 597
 598         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 599         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 600
 601         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 602         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", res, pPackageId.get());
 603
 604         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 605         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], package=[%s]", res, pPackageId.get());
 606
 607         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 608         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], package=[%s]", res, pPackageId.get());
 609
 610         if (storage == PMINFO_INTERNAL_STORAGE)
 611         {
 612                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 613                 return E_INVALID_OPERATION;
 614         }
 615
 616         if (__pRequestClient == null)
 617         {
 618                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 619                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 620         }
 621
 622         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_INTERNAL, PM_QUIET);
 623
 624         if(packageInfoHandle)
 625         {
 626                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 627         }
 628
 629         if (res < PKGMGR_R_OK)
 630         {
 631                 pkgmgr_client_free(__pRequestClient);
 632                 __pRequestClient = null;
 633
 634                 if (res == PKGMGR_R_EINVAL)
 635                 {
 636                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 637                         return E_INVALID_ARG;
 638                 }
 639                 else if (res == PKGMGR_R_ERROR)
 640                 {
 641                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 642                 }
 643                 else
 644                 {
 645                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 646                 }
 647
 648                 return E_SYSTEM;
 649         }
 650
 651         return E_SUCCESS;
 652 }
 653
 654 int
 655 _PackageManagerImpl::InstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 656 {
 657         SysLog(NID_APP, "reqId[%d], Type[%s], Package[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 658
 659         if (pData)
 660         {
 661                 IPackageInstallationResponseListener* pListener = (IPackageInstallationResponseListener*) pData;
 662
 663                 if (strcmp(pKey, "end") == 0)
 664                 {
 665                         if (strcmp(pVal, "ok") == 0)
 666                         {
 667                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
 668                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_SUCCESS)");
 669                         }
 670                         else
 671                         {
 672                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
 673                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE)");
 674                         }
 675
 676                         delete pListener;
 677                 }
 678                 else if (strcmp(pKey, "install_percent") == 0)
 679                 {
 680                         int progress = 0;
 681                         sscanf(pVal, "%d", &progress);
 682
 683                         pListener->OnPackageInstallationInProgressResponseReceived(pPackageId, progress);
 684                         SysLog(NID_APP, "OnPackageInstallationInProgressResponseReceived(%s, %d)", pPackageId, progress);
 685                 }
 686         }
 687
 688         return 0;
 689 }
 690
 691 int
 692 _PackageManagerImpl::UninstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 693 {
 694         SysLog(NID_APP, "reqId[%d], Type[%s], Package[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 695
 696         if (pData)
 697         {
 698                 if (strcmp(pKey, "end") == 0)
 699                 {
 700                         IPackageUninstallationResponseListener* pListener = (IPackageUninstallationResponseListener*) pData;
 701
 702                         if (strcmp(pVal, "ok") == 0)
 703                         {
 704                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(true)");
 705                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, true);
 706                         }
 707                         else
 708                         {
 709                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(false)");
 710                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, false);
 711                         }
 712
 713                         delete pListener;
 714                 }
 715         }
 716
 717         return 0;
 718 }
 719
 720 PackageInfo*
 721 _PackageManagerImpl::GetPackageInfoFromFileN(const String& filePath) const
 722 {
 723         SysTryReturn(NID_APP, filePath.IsEmpty() == false, null, E_INVALID_ARG, "filePath is empty.");
 724         SysTryReturn(NID_APP, File::IsFileExist(filePath) == true, null, E_FILE_NOT_FOUND, "package is not existed.");
 725
 726         String extension = File::GetFileExtension(filePath);
 727         SysTryReturn(NID_APP, extension.IsEmpty() == false, null, E_INVALID_ARG, "extension is empty.");
 728
 729         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(filePath));
 730         SysTryReturn(NID_APP, pPackagePath, null, E_OUT_OF_MEMORY, "pPackagePath is null.");
 731
 732         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 733         SysTryReturn(NID_APP, pExtension, null, E_OUT_OF_MEMORY, "pExtension is null.");
 734
 735         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
 736         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
 737
 738         SysLog(NID_APP, "packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 739
 740         bool res = true;
 741         result r = E_SUCCESS;
 742
 743         if (strcasecmp(pExtension.get(), "tpk") == 0)
 744         {
 745                 _PackageParser packageParser;
 746
 747                 res = packageParser.Construct(pPackageInfo.get());
 748                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Construct() is failed. [%s]", pPackagePath.get());
 749
 750                 res = packageParser.Parse(filePath);
 751                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Parse() is failed. [%s]", pPackagePath.get());
 752         }
 753         else if (strcasecmp(pExtension.get(), "wgt") == 0)
 754         {
 755                 pkgmgr_info* pPkgmgrInfo = null;
 756
 757                 pPkgmgrInfo = pkgmgr_client_check_pkginfo_from_file(pPackagePath.get());
 758                 SysTryReturn(NID_APP, pPkgmgrInfo, null, E_PARSING_FAILED, "pkgmgr_client_check_pkginfo_from_file(%s) is failed.", pPackagePath.get());
 759
 760                 _package_manager_pkg_detail_info_t* pPkgInfo = (_package_manager_pkg_detail_info_t*) pPkgmgrInfo;
 761                 _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
 762
 763                 SysLog(NID_APP, "id(%s), version(%s), label(%s), description(%s), author(%s), icon_size(%d), pkgname(%s)", pPkgInfo->pkgid, pPkgInfo->version, pPkgInfo->label,
 764                                 pPkgInfo->pkg_description, pPkgInfo->author, pPkgInfo->icon_size, pPkgInfo->pkg_name);
 765
 766                 pPackageInfoImpl->SetType(PACKAGE_TYPE_WGT);
 767                 pPackageInfoImpl->SetId(pPkgInfo->pkgid);
 768                 pPackageInfoImpl->SetVersion(pPkgInfo->version);
 769                 pPackageInfoImpl->SetDisplayName(pPkgInfo->label);
 770                 pPackageInfoImpl->SetDescription(pPkgInfo->pkg_description);
 771                 pPackageInfoImpl->SetAuthor(pPkgInfo->author);
 772                 pPackageInfoImpl->SetMainAppId(pPkgInfo->pkg_name);
 773
 774                 if (pPkgInfo->privilege_list)
 775                 {
 776                         GList* pList = null;
 777                         pList = g_list_first(pPkgInfo->privilege_list);
 778                         while (pList)
 779                         {
 780                                 char* pPrivilege = (char*)pList->data;
 781                                 if (pPrivilege)
 782                                 {
 783                                         pPackageInfoImpl->AddPrivilege(*new (std::nothrow) String(pPrivilege));
 784                                         free(pPrivilege);
 785                                 }
 786                                 pList = g_list_next(pList);
 787                         }
 788                         g_list_free(pPkgInfo->privilege_list);
 789                 }
 790
 791                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
 792                 if (pPackageAppInfo)
 793                 {
 794                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
 795
 796                         pPackageAppInfoImpl->SetAppId(pPkgInfo->pkg_name);
 797                         pPackageAppInfoImpl->SetAppName(pPkgInfo->label);
 798                         pPackageAppInfoImpl->SetAppDisplayName(pPkgInfo->label);
 799                         pPackageAppInfoImpl->SetMainApp(true);
 800                         if ((pPkgInfo->icon_buf) && (pPkgInfo->icon_size > 0))
 801                         {
 802                                 String iconPath("/tmp/icon.png");
 803                                 File file;
 804                                 r = file.Construct(iconPath, "w+");
 805                                 r = file.Write(pPkgInfo->icon_buf, pPkgInfo->icon_size);
 806
 807                                 pPackageAppInfoImpl->SetAppTempIconPath(iconPath);
 808                         }
 809
 810                         pPackageInfoImpl->AddPackageAppInfo(*pPackageAppInfo.release());
 811                 }
 812                 else
 813                 {
 814                         SysLog(NID_APP, "pPackageAppInfo instance must not be null.");
 815                         pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 816                         return null;
 817                 }
 818
 819                 pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 820         }
 821         else
 822         {
 823                 SysTryReturn(NID_APP, false, null, E_UNSUPPORTED_FORMAT, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 824         }
 825
 826         return pPackageInfo.release();
 827 }
 828
 829 IList*
 830 _PackageManagerImpl::GetPackageInfoListN(const IMap& packageFilterMap) const
 831 {
 832         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap.GetCount() is invalid.");
 833
 834         std::unique_ptr<IMapEnumerator> pEnum(packageFilterMap.GetMapEnumeratorN());
 835         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 836
 837         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList());
 838         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
 839
 840         pList->Construct();
 841
 842         int res = PMINFO_R_OK;
 843         pkgmgrinfo_pkginfo_filter_h handle = null;
 844
 845         res = pkgmgrinfo_pkginfo_filter_create(&handle);
 846         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_pkginfo_filter_create() is failed. [%d]", res);
 847
 848         while(pEnum->MoveNext() == E_SUCCESS)
 849         {
 850                 String* pKey = static_cast< String* >(pEnum->GetKey());
 851                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 852
 853                 Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 854                 SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 855
 856                 bool value = pVal->ToBool();
 857
 858                 SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), value);
 859
 860                 if ((*pKey) == PACKAGE_FILTER_UNINSTALLABLE)
 861                 {
 862                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE, value);
 863                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(REMOVABLE, %d) is failed. [%d]", value, res);
 864                 }
 865                 else if ((*pKey) == PACKAGE_FILTER_DOWNLOADED)
 866                 {
 867                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD, !value);
 868                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(PRELOAD, %d) is failed. [%d]", !value, res);
 869                 }
 870                 else if ((*pKey) == PACKAGE_FILTER_APP_SETTING)
 871                 {
 872                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING, value);
 873                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(APPSETTING, %d) is failed. [%d]", value, res);
 874                 }
 875                 else if ((*pKey) == PACKAGE_FILTER_EXTERNAL_STORAGE)
 876                 {
 877                         String installedStorage;
 878                         if (value == true)
 879                         {
 880                                 installedStorage = L"installed_external";
 881                         }
 882                         else
 883                         {
 884                                 installedStorage = L"installed_internal";
 885                         }
 886
 887                         std::unique_ptr<char[]> pInstalledStorage(_StringConverter::CopyToCharArrayN(installedStorage));
 888                         SysTryCatch(NID_APP, pInstalledStorage, , E_OUT_OF_MEMORY, "pInstalledStorage is null.");
 889
 890                         SysLog(NID_APP, "Value[%d]->[%s]", value, pInstalledStorage.get());
 891
 892                         res = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE, pInstalledStorage.get());
 893                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_string(STORAGE, %s) is failed. [%d]", pInstalledStorage.get(), res);
 894                 }
 895                 else
 896                 {
 897                         SysTryCatch(NID_APP, false, , E_INVALID_ARG, "Invalid key(%ls)", pKey->GetPointer());
 898                 }
 899         }
 900
 901         res = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, PackageInfoHandler, pList.get());
 902         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_foreach_pkginfo() failed. [%d]", res);
 903
 904 CATCH:
 905         if (handle)
 906         {
 907                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 908         }
 909
 910         if (pList->GetCount() <= 0)
 911         {
 912                 AppLog("pList's count is 0.");
 913                 return null;
 914         }
 915
 916         return pList.release();
 917 }
 918
 919 IList*
 920 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageAppFilterMap) const
 921 {
 922         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 923
 924         std::unique_ptr< IMapEnumerator > pEnum(packageAppFilterMap.GetMapEnumeratorN());
 925         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 926
 927         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList());
 928         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
 929
 930         pList->Construct();
 931
 932         int res = 0;
 933         bool definedKey = false;
 934         bool metadataKey = false;
 935         ArrayList list;
 936         ArrayList metadataList;
 937         ArrayList appIdList;
 938         pkgmgrinfo_appinfo_filter_h handle = null;
 939         pkgmgrinfo_appinfo_metadata_filter_h metaHandle = null;
 940
 941         res = pkgmgrinfo_appinfo_filter_create(&handle);
 942         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_create() is failed. [%d]", res);
 943
 944         res = pkgmgrinfo_appinfo_metadata_filter_create(&metaHandle);
 945         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_create() is failed. [%d]", res);
 946
 947         while(pEnum->MoveNext() == E_SUCCESS)
 948         {
 949                 String* pKey = static_cast< String* >(pEnum->GetKey());
 950                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 951
 952                 if ((*pKey) == PACKAGE_APP_FILTER_MENUICON_VISIBLE)
 953                 {
 954                         definedKey = true;
 955
 956                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 957                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 958
 959                         bool nodisplay = !(pVal->ToBool());
 960                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), nodisplay);
 961
 962                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, nodisplay);
 963                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(NODISPLAY, %d) is failed. [%d]", nodisplay, res);
 964                 }
 965                 else if ((*pKey) == PACKAGE_APP_FILTER_CATEGORY_HOMEAPP || (*pKey) == PACKAGE_APP_FILTER_CATEGORY_LOCKAPP
 966                                                 || (*pKey) == PACKAGE_APP_FILTER_CATEGORY_MENUAPP)
 967                 {
 968                         definedKey = true;
 969
 970                         std::unique_ptr<char[]> pDefinedKey(_StringConverter::CopyToCharArrayN(*pKey));
 971                         SysTryCatch(NID_APP, pDefinedKey, , E_OUT_OF_MEMORY, "pDefinedKey is null.");
 972
 973                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 974                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 975
 976                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), pVal->ToBool());
 977                         SysTryCatch(NID_APP, pVal->ToBool() == true, , E_INVALID_ARG, "Value(false) is not allowed.");
 978
 979                         res = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, pDefinedKey.get());
 980                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_add_string(CATEGORY, %s) is failed. [%d]", pDefinedKey.get(), res);
 981                 }
 982                 else
 983                 {
 984                         metadataKey = true;
 985
 986                         String* pVal = static_cast< String* >(pEnum->GetValue());
 987                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 988
 989                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
 990
 991                         std::unique_ptr<char[]> pMetaKey(_StringConverter::CopyToCharArrayN(*pKey));
 992                         SysTryCatch(NID_APP, pMetaKey, , E_OUT_OF_MEMORY, "pMetaKey is null.");
 993
 994                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 995                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 996
 997                         if ((*pVal) == L"*")
 998                         {
 999                                 res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), null);
1000                                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, null) is failed. [%d]", pMetaKey.get(), res);
1001                         }
1002                         else
1003                         {
1004                                 res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), pValue.get());
1005                                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, %s) is failed. [%d]", pMetaKey.get(), pValue.get(), res);
1006                         }
1007                 }
1008         }
1009
1010         if ((definedKey == true) && (metadataKey == false))
1011         {
1012                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, pList.get());
1013                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_foreach_appinfo() failed. [%d]", res);
1014         }
1015         else if ((definedKey == false) && (metadataKey == true))
1016         {
1017                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, pList.get());
1018                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_foreach() failed. [%d]", res);
1019         }
1020         else
1021         {
1022                 list.Construct();
1023
1024                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, &list);
1025                 if (res != PMINFO_R_OK)
1026                 {
1027                         SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
1028                         goto CATCH;
1029                 }
1030
1031                 metadataList.Construct();
1032
1033                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, &metadataList);
1034                 if (res != PMINFO_R_OK)
1035                 {
1036                         SysLog(NID_APP, "pkgmgrinfo_appinfo_metadata_filter_foreach() is failed. result = [%d]", res);
1037                         goto CATCH;
1038                 }
1039
1040                 for (int i = 0; i < list.GetCount(); i++)
1041                 {
1042                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(list.GetAt(i));
1043                         if (pPackageAppInfo)
1044                         {
1045                                 AppLog("PackageAppFilter - App [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1046
1047                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1048                                 appIdList.Add(pAppId.release());
1049                         }
1050                 }
1051
1052                 for (int j = 0; j < metadataList.GetCount(); j++)
1053                 {
1054                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(metadataList.GetAt(j));
1055                         if (pPackageAppInfo)
1056                         {
1057                                 AppId appId = pPackageAppInfo->GetAppId();
1058
1059                                 if (appIdList.Contains(appId) == true)
1060                                 {
1061                                         AppLog("App [%ls] is matched.", appId.GetPointer());
1062
1063                                         std::unique_ptr< PackageAppInfo > pAppInfo(new (std::nothrow) PackageAppInfo);
1064                                         SysTryCatch(NID_APP, pAppInfo, , E_OUT_OF_MEMORY, "pAppInfo is null.");
1065
1066                                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pAppInfo.get());
1067                                         pPackageAppInfoImpl->Construct(appId);
1068
1069                                         pList->Add(pAppInfo.release());
1070                                 }
1071                                 else
1072                                 {
1073                                         AppLog("App [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1074                                 }
1075                         }
1076                 }
1077         }
1078
1079 CATCH:
1080         if (handle)
1081         {
1082                 pkgmgrinfo_appinfo_filter_destroy(handle);
1083         }
1084
1085         if (metaHandle)
1086         {
1087                 pkgmgrinfo_appinfo_metadata_filter_destroy(metaHandle);
1088         }
1089
1090         if (pList->GetCount() <= 0)
1091         {
1092                 AppLog("pList's count is 0.");
1093                 return null;
1094         }
1095
1096         return pList.release();
1097 }
1098
1099 IList*
1100 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageFilterMap, const IMap& packageAppFilterMap) const
1101 {
1102         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap Count is invalid.");
1103         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap Count is invalid.");
1104
1105         ArrayList appIdList;
1106
1107         std::unique_ptr< IList > pPackageFilterList(GetPackageInfoListN(packageFilterMap));
1108         if (pPackageFilterList == null)
1109         {
1110                 SysLog(NID_APP, "GetPackageInfoListN(packageFilterMap) is null.");
1111                 return null;
1112         }
1113
1114         for (int i = 0; i < pPackageFilterList->GetCount(); i++)
1115         {
1116                 PackageInfo* pPackageInfo = dynamic_cast < PackageInfo* >(pPackageFilterList->GetAt(i));
1117                 if (pPackageInfo)
1118                 {
1119                         std::unique_ptr< IList > pPackageAppInfoList(pPackageInfo->GetPackageAppInfoListN());
1120                         if (pPackageAppInfoList)
1121                         {
1122                                 for (int j = 0; j < pPackageAppInfoList->GetCount(); j++)
1123                                 {
1124                                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pPackageAppInfoList->GetAt(j));
1125                                         if (pPackageAppInfo)
1126                                         {
1127                                                 AppLog("PackageFilter - App [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1128
1129                                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1130                                                 appIdList.Add(pAppId.release());
1131                                         }
1132                                 }
1133                         }
1134                 }
1135         }
1136
1137         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList);
1138         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
1139
1140         std::unique_ptr< IList > pAppFilterList(GetPackageAppInfoListN(packageAppFilterMap));
1141         if (pAppFilterList == null)
1142         {
1143                 SysLog(NID_APP, "GetPackageAppInfoListN(packageAppFilterMap) is null.");
1144                 return null;
1145         }
1146
1147         for (int k = 0; k < pAppFilterList->GetCount(); k++)
1148         {
1149                 PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pAppFilterList->GetAt(k));
1150                 if (pPackageAppInfo)
1151                 {
1152                         AppId appId = pPackageAppInfo->GetAppId();
1153                         AppLog("AppFilter - App [%ls]", appId.GetPointer());
1154
1155                         if (appIdList.Contains(appId) == true)
1156                         {
1157                                 AppLog("App [%ls] is matched.", appId.GetPointer());
1158
1159                                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1160                                 SysTryReturn(NID_APP, pPackageAppInfo, null, E_OUT_OF_MEMORY, "PackageAppInfo is null.");
1161
1162                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1163                                 pPackageAppInfoImpl->Construct(appId);
1164
1165                                 pList->Add(pPackageAppInfo.release());
1166                         }
1167                         else
1168                         {
1169                                 AppLog("App [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1170                         }
1171                 }
1172         }
1173
1174         if (pList->GetCount() <= 0)
1175         {
1176                 AppLog("pList's count is 0.");
1177                 return null;
1178         }
1179
1180         return pList.release();
1181 }
1182
1183 int
1184 _PackageManagerImpl::PackageInfoHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1185 {
1186         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1187         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1188
1189         result r = E_SUCCESS;
1190         int res = PMINFO_R_OK;
1191         char* pPackageId = null;
1192         ArrayList* pList = (ArrayList*)pUserData;
1193
1194         res = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackageId);
1195         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkgname() is failed. [%d]", res);
1196
1197         std::unique_ptr<PackageInfo> pPackageInfo(new (std::nothrow) PackageInfo);
1198         SysTryReturn(NID_APP, pPackageInfo, 0, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1199
1200         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1201         r = pPackageInfoImpl->Construct(pPackageId);
1202         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pPackageId);
1203
1204         pList->Add(*pPackageInfo.release());
1205
1206         return 0;
1207 }
1208
1209 int
1210 _PackageManagerImpl::PackageAppInfoHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1211 {
1212         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1213         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1214
1215         result r = E_SUCCESS;
1216         int res = PMINFO_R_OK;
1217         char* pAppId = null;
1218         ArrayList* pList = (ArrayList*)pUserData;
1219
1220         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1221         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1222
1223         SysLog(NID_APP, "app = [%s]", pAppId);
1224
1225         std::unique_ptr<PackageAppInfo> pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1226         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1227
1228         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1229         r = pPackageAppInfoImpl->Construct(pAppId);
1230         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1231
1232         pList->Add(*pPackageAppInfo.release());
1233
1234         return 0;
1235 }
1236
1237 int
1238 _PackageManagerImpl::PackageAppInfoMetadataHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1239 {
1240         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1241         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1242
1243         result r = E_SUCCESS;
1244         int res = PMINFO_R_OK;
1245         char* pAppId = null;
1246         ArrayList* pList = (ArrayList*)pUserData;
1247
1248         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1249         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1250
1251         SysLog(NID_APP, "app = [%s]", pAppId);
1252
1253         std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1254         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1255
1256         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1257         r = pPackageAppInfoImpl->Construct(pAppId);
1258         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1259
1260         pList->Add(*pPackageAppInfo.release());
1261
1262         return 0;
1263 }
1264
1265 _PackageManagerImpl*
1266 _PackageManagerImpl::GetInstance(void)
1267 {
1268         return PackageManager::GetInstance()->__pPackageManagerImpl;
1269 }
1270
1271 result
1272 _PackageManagerImpl::Construct(void)
1273 {
1274         ClearLastResult();
1275
1276         result r = __installationList.Construct();
1277         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
1278
1279         return E_SUCCESS;
1280 }
1281
1282 _PackageManagerImpl::_PackageManagerImpl(void)
1283 :__pRequestClient(null),
1284 __pListeningClient(null)
1285 {
1286 }
1287
1288 _PackageManagerImpl::~_PackageManagerImpl(void)
1289 {
1290 }
1291
1292 void
1293 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
1294 {
1295         result r = E_SUCCESS;
1296         bool install = true;
1297
1298         if (strcmp(pEventKey, "start") == 0)
1299         {
1300                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
1301                 {
1302                         String* pAppId = new (std::nothrow) String(packageId);
1303                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
1304
1305                         String* pOperation = new (std::nothrow) String(pEventValue);
1306                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
1307
1308                         r = __installationList.Add(*pAppId, *pOperation);
1309                         if (IsFailed(r))
1310                         {
1311                                 delete pAppId;
1312                                 delete pOperation;
1313                                 SysLog(NID_APP, "Failed to add installation condition.");
1314                                 SetLastResult(E_SYSTEM);
1315                                 return;
1316                         }
1317                 }
1318         }
1319         else if (strcmp(pEventKey, "end") == 0)
1320         {
1321                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
1322                 if (pOperation)
1323                 {
1324                         if (pOperation->Equals("uninstall", true) == true)
1325                         {
1326                                 install = false;
1327                         }
1328
1329                         r = __installationList.Remove(packageId, true);
1330                         if (IsFailed(r))
1331                         {
1332                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
1333                         }
1334                 }
1335         }
1336
1337         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
1338         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
1339
1340         while (pEnum->MoveNext() == E_SUCCESS)
1341         {
1342                 _PackageManagerEvent*   pEvent = null;
1343                 pEnum->GetCurrent(pEvent);
1344                 if (pEvent)
1345                 {
1346                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
1347                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
1348
1349                         String eventKey(pEventKey);
1350                         String eventValue(pEventValue);
1351
1352                         pEventArg->__packageId = packageId;
1353                         pEventArg->__eventKey = eventKey;
1354                         pEventArg->__eventValue = eventValue;
1355                         pEventArg->__install = install;
1356
1357                         r = pEvent->Fire(*pEventArg);
1358                         if (r != E_SUCCESS)
1359                         {
1360                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
1361                         }
1362
1363                         SysLog(NID_APP, "Package = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
1364                 }
1365                 else
1366                 {
1367                         SysLog(NID_APP, "pEvent is null.");
1368                 }
1369         }
1370 }
1371
1372 PackageInfo*
1373 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
1374 {
1375         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
1376
1377         result r = E_SUCCESS;
1378         Database db;
1379         DbStatement* pStmt = null;
1380         DbEnumerator* pEnum = null;
1381         String query;
1382         PackageInfo *pPackageInfo = null;
1383
1384         query.Format(   1024, L"SELECT PkgInfo.*, AppInfo.APP_MAINMENU_ICON FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
1385
1386         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1387         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1388
1389         pStmt = CreateStatementN(db, query);
1390
1391         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1392
1393         pEnum = ExecuteStatementN(db, pStmt);
1394         if (pEnum != null)
1395         {
1396                 if (pEnum->MoveNext() == E_SUCCESS)
1397                 {
1398                         pPackageInfo = new (std::nothrow) PackageInfo;
1399                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1400
1401                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1402
1403                         String id;
1404                         String appVersion;
1405                         String appType;
1406                         String appMimeType;
1407                         String appApiVersion;
1408                         String appName;
1409                         String appVendor;
1410                         String appDescription;
1411                         String appUrl;
1412                         String appCid;
1413                         String appRootPath;
1414                         int appStorageType = 0;
1415                         DateTime appInstallationTime;
1416                         String appIconPath;
1417
1418                         pEnum->GetStringAt(1, id);
1419                         pEnum->GetStringAt(3, appVersion);
1420                         pEnum->GetStringAt(4, appType);
1421                         pEnum->GetStringAt(5, appMimeType);
1422                         pEnum->GetStringAt(6, appApiVersion);
1423                         pEnum->GetStringAt(7, appName);
1424                         pEnum->GetStringAt(8, appVendor);
1425                         pEnum->GetStringAt(9, appDescription);
1426                         pEnum->GetStringAt(10, appUrl);
1427                         pEnum->GetStringAt(11, appCid);
1428                         pEnum->GetStringAt(16, appRootPath);
1429                         pEnum->GetIntAt(17, appStorageType);
1430                         pEnum->GetDateTimeAt(18, appInstallationTime);
1431                         pEnum->GetStringAt(21, appIconPath);
1432
1433                         pPackageInfoImpl->SetAppId(id);
1434                         pPackageInfoImpl->SetAppVersion(appVersion);
1435                         pPackageInfoImpl->SetAppMimeType(appMimeType);
1436                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
1437                         pPackageInfoImpl->SetAppName(appName);
1438                         pPackageInfoImpl->SetAppVendor(appVendor);
1439                         pPackageInfoImpl->SetAppDescription(appDescription);
1440                         pPackageInfoImpl->SetAppUrl(appUrl);
1441                         pPackageInfoImpl->SetAppCid(appCid);
1442                         pPackageInfoImpl->SetAppRootPath(appRootPath);
1443                         pPackageInfoImpl->SetAppStorageType(appStorageType);
1444                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
1445                         pPackageInfoImpl->SetAppIconPath(appIconPath);
1446                 }
1447
1448                 delete pEnum;
1449         }
1450         else
1451         {
1452                 r = E_OBJ_NOT_FOUND;
1453         }
1454
1455 CATCH:
1456         delete pStmt;
1457         return pPackageInfo;
1458 }
1459
1460 int
1461 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1462 {
1463         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
1464
1465         result r = E_SUCCESS;
1466         int result = 0;
1467         char* pPackage = null;
1468         ArrayList* pList = (ArrayList*)pUserData;
1469
1470         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
1471         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1472
1473         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1474
1475         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
1476         if (result == 0)
1477         {
1478                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1479         }
1480         else
1481         {
1482                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1483         }
1484
1485         r = pPackageInfoImpl->Construct(pPackage);
1486         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pPackageInfoImpl->Construct() failed.");
1487
1488         r = pList->Add(*pPackageInfo.release());
1489         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pList->Add() failed.");
1490
1491         return result;
1492 }
1493
1494 IList*
1495 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
1496 {
1497         result r = E_SUCCESS;
1498         Database db;
1499         DbStatement* pStmt = null;
1500         DbEnumerator* pEnum = null;
1501         String query;
1502         ArrayList* pList = null;
1503
1504         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, AppFeature WHERE AppFeature.ID = AppInfo.UNIQUE_ID and AppFeature.NAME = '%ls' and AppFeature.VALUE = '%ls' COLLATE NOCASE", feature.GetPointer(), value.GetPointer());
1505
1506         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1507         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1508
1509         pStmt = CreateStatementN(db, query);
1510         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1511
1512         pEnum = ExecuteStatementN(db, pStmt);
1513
1514         if (pEnum != null)
1515         {
1516                 pList = new (std::nothrow) ArrayList();
1517                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1518                 pList->Construct();
1519
1520                 while (pEnum->MoveNext() == E_SUCCESS)
1521                 {
1522                         String* pPackageName = new (std::nothrow) String;
1523                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1524
1525                         pEnum->GetStringAt(0, *pPackageName);
1526
1527                         pList->Add(*pPackageName);
1528                 }
1529
1530                 delete pEnum;
1531
1532         }
1533         else
1534         {
1535                 r = E_OBJ_NOT_FOUND;
1536         }
1537
1538 CATCH:
1539         delete pStmt;
1540         return pList;
1541 }
1542
1543 IList*
1544 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
1545 {
1546         result r = E_SUCCESS;
1547         Database db;
1548         DbStatement* pStmt = null;
1549         DbEnumerator* pEnum = null;
1550         String query;
1551         ArrayList* pList = null;
1552
1553         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME, DataControl.ACCESS FROM AppInfo, DataControl WHERE DataControl.ID = AppInfo.UNIQUE_ID and DataControl.PROVIDER_ID = '%ls' and DataControl.TYPE = '%ls' COLLATE NOCASE", providerId.GetPointer(), type.GetPointer());
1554
1555         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1556         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1557
1558         pStmt = CreateStatementN(db, query);
1559         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1560
1561         pEnum = ExecuteStatementN(db, pStmt);
1562
1563         if (pEnum != null)
1564         {
1565                 pList = new (std::nothrow) ArrayList();
1566                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1567                 pList->Construct();
1568
1569                 while (pEnum->MoveNext() == E_SUCCESS)
1570                 {
1571                         String* pPackageName = new (std::nothrow) String;
1572                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1573
1574                         String* pAccess = new (std::nothrow) String;
1575                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1576
1577                         pEnum->GetStringAt(0, *pPackageName);
1578                         pList->Add(*pPackageName);
1579
1580                         pEnum->GetStringAt(1, *pAccess);
1581                         pList->Add(*pAccess);
1582                 }
1583
1584                 delete pEnum;
1585
1586         }
1587         else
1588         {
1589                 r = E_OBJ_NOT_FOUND;
1590         }
1591
1592 CATCH:
1593         delete pStmt;
1594         return pList;
1595 }
1596
1597 IMap*
1598 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1599 {
1600         result r = E_SUCCESS;
1601         Database db;
1602         DbStatement* pStmt = null;
1603         DbEnumerator* pEnum = null;
1604         String query;
1605         HashMap* pList = null;
1606
1607         query.Format(1024, L"SELECT AppFeature.NAME, AppFeature.VALUE FROM PkgInfo, AppInfo, AppFeature WHERE (AppFeature.ID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID and PkgInfo.PKG_ID = '%ls') and (AppFeature.NAME = 'SystemTheme' or AppFeature.NAME = 'UserDefinedTheme')"
1608                         , packageId.GetPointer());
1609
1610         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1611         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1612
1613         pStmt = CreateStatementN(db, query);
1614         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1615
1616         pEnum = ExecuteStatementN(db, pStmt);
1617
1618         if (pEnum != null)
1619         {
1620                 pList = new (std::nothrow) HashMap();
1621                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1622                 pList->Construct();
1623
1624                 while (pEnum->MoveNext() == E_SUCCESS)
1625                 {
1626                         String* pName = new (std::nothrow) String;
1627                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1628
1629                         String* pValue = new (std::nothrow) String;
1630                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1631
1632                         pEnum->GetStringAt(0, *pName);
1633                         pEnum->GetStringAt(1, *pValue);
1634
1635                         pList->Add(*pName, *pValue);
1636                 }
1637
1638                 delete pEnum;
1639
1640         }
1641         else
1642         {
1643                 r = E_OBJ_NOT_FOUND;
1644         }
1645
1646 CATCH:
1647         delete pStmt;
1648         return pList;
1649 }
1650
1651 bool
1652 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1653 {
1654         if (appId == _AppInfo::GetPackageId())
1655         {
1656                 return true;
1657         }
1658
1659         int result = 0;
1660         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1661
1662         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1663         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1664
1665         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1666         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", result, pPackageId.get());
1667
1668         if(pPackageInfoHandle)
1669         {
1670                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1671         }
1672
1673         return true;
1674 }
1675
1676 int
1677 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1678                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1679 {
1680         SysLog(NID_APP, "PackageEventHandler - req_id: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1681                                 pkg_name, key, val);
1682
1683         PackageType type = PACKAGE_TYPE_TPK;
1684         PackageId packageId(pkg_name);
1685
1686         if (strcmp(pkg_type, "tpk") == 0)
1687         {
1688                 type = PACKAGE_TYPE_TPK;
1689         }
1690         else if (strcmp(pkg_type, "wgt") == 0)
1691         {
1692                 type = PACKAGE_TYPE_WGT;
1693         }
1694         else
1695         {
1696                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1697                 return 0;
1698         }
1699
1700         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1701         pThis->SendPackageEvent(type, packageId, key, val);
1702
1703         return 0;
1704 }
1705
1706 String*
1707 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1708 {
1709         result r = E_SUCCESS;
1710         Database db;
1711         DbStatement* pStmt = null;
1712         DbEnumerator* pEnum = null;
1713         String query;
1714         String* pAppId = null;
1715
1716         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, DataControl WHERE DataControl.PROVIDER_ID = '%ls' and DataControl.ID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID",
1717                         providerId.GetPointer());
1718
1719         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1720         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1721
1722         pStmt = CreateStatementN(db, query);
1723         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1724
1725         pEnum = ExecuteStatementN(db, pStmt);
1726
1727         if (pEnum != null)
1728         {
1729                 if (pEnum->MoveNext() == E_SUCCESS)
1730                 {
1731                         pAppId = new (std::nothrow) String;
1732                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1733
1734                         pEnum->GetStringAt(0, *pAppId);
1735                 }
1736
1737                 delete pEnum;
1738         }
1739
1740 CATCH:
1741         delete pStmt;
1742         return pAppId;
1743 }
1744
1745 PackageInfo*
1746 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1747 {
1748         result r = E_SUCCESS;
1749         PackageInfo* pPkgInfo = null;
1750         Database db;
1751         DbStatement* pStmt = null;
1752         DbEnumerator* pEnum = null;
1753         String query;
1754
1755         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1756                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1757                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1758                         "GROUP BY AppInfoID"
1759                         , providerId.GetPointer(), operationId.GetPointer());
1760
1761         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1762         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1763
1764         pStmt = CreateStatementN(db, query);
1765         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1766
1767         pEnum = ExecuteStatementN(db, pStmt);
1768         if (pEnum != null)
1769         {
1770                 if (pEnum->MoveNext() == E_SUCCESS)
1771                 {
1772                         PackageId packageId;
1773                         pEnum->GetStringAt(0, packageId);
1774
1775                         pPkgInfo = GetPackageInfoN(packageId);
1776                 }
1777
1778                 delete pEnum;
1779         }
1780         else
1781         {
1782                 r = E_OBJ_NOT_FOUND;
1783         }
1784
1785 CATCH:
1786         delete pStmt;
1787         return pPkgInfo;
1788 }
1789
1790 ArrayList*
1791 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1792 {
1793         result r = E_SUCCESS;
1794         Database db;
1795         DbStatement* pStmt = null;
1796         DbEnumerator* pEnum = null;
1797         String query;
1798         //int id = 0;
1799         PackageInfo* pPkgInfo = null;
1800         _PackageInfoImpl* pPackageInfoImpl = null;
1801         ArrayList* pList = null;
1802
1803         pPkgInfo = GetPackageInfoN(packageId);
1804         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1805
1806         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1807         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1808
1809         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1810         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1811
1812         pStmt = CreateStatementN(db, query);
1813         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1814                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1815
1816         pEnum = ExecuteStatementN(db, pStmt);
1817
1818         if (pEnum != null)
1819         {
1820                 pList = new (std::nothrow) ArrayList;
1821                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1822
1823                 pList->Construct();
1824
1825                 while (pEnum->MoveNext() == E_SUCCESS)
1826                 {
1827                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
1828                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
1829
1830                         int uniqueId = 0;
1831                         int pkgId = 0;
1832                         String name;
1833                         String defaultapp;
1834                         String mainmenuIcon;
1835                         String settingIcon;
1836                         String quickpanelIcon;
1837                         int appFeature = 0;
1838                         String packageName;
1839
1840                         pEnum->GetIntAt(0, uniqueId);
1841                         pEnum->GetIntAt(1, pkgId);
1842                         pEnum->GetStringAt(2, name);
1843                         pEnum->GetStringAt(3, defaultapp);
1844                         pEnum->GetStringAt(4, mainmenuIcon);
1845                         pEnum->GetStringAt(5, settingIcon);
1846                         pEnum->GetStringAt(7, quickpanelIcon);
1847                         pEnum->GetIntAt(9, appFeature);
1848                         pEnum->GetStringAt(10, packageName);
1849
1850                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
1851                         pPackageAppInfoImpl->SetPkgId(pkgId);
1852                         pPackageAppInfoImpl->SetName(name);
1853                         pPackageAppInfoImpl->SetDefault(defaultapp);
1854                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
1855                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
1856                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
1857                         pPackageAppInfoImpl->SetAppFeature(appFeature);
1858                         pPackageAppInfoImpl->SetPackageName(packageName);
1859
1860                         pList->Add(*pPackageAppInfoImpl);
1861                 }
1862
1863                 delete pEnum;
1864         }
1865
1866 CATCH:
1867         delete pPkgInfo;
1868         delete pStmt;
1869         return pList;
1870 }
1871
1872 ArrayList*
1873 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1874 {
1875         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1876         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1877
1878         ArrayList* pResult = null;
1879
1880         for (int i = 0; i < pAppInfoList->GetCount(); i++)
1881         {
1882                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
1883                 if (pAppInfoImpl == null)
1884                 {
1885                         continue;
1886                 }
1887
1888                 if (pAppInfoImpl->GetName() == appExecutableName)
1889                 {
1890                         pResult = pAppInfoImpl->GetAppFeatureListN();
1891                         goto OUT;
1892                 }
1893         }
1894
1895 OUT:
1896         pAppInfoList->RemoveAll(true);
1897         delete pAppInfoList;
1898
1899         return pResult;
1900 }
1901
1902 HashMapT<String, _AppFeatureInfoImpl*>*
1903 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1904 {
1905         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1906         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1907
1908         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
1909
1910         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
1911
1912         while (pEnum->MoveNext() == E_SUCCESS)
1913         {
1914                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
1915                 if (pAppInfoImpl == null)
1916                 {
1917                         continue;
1918                 }
1919
1920                 if (pAppInfoImpl->GetName() == appExecutableName)
1921                 {
1922                         pResult = pAppInfoImpl->GetAppFeatureMapN();
1923                         goto OUT;
1924                 }
1925         }
1926
1927 OUT:
1928         pAppInfoList->RemoveAll(true);
1929         delete pAppInfoList;
1930
1931         return pResult;
1932 }
1933
1934 ArrayList*
1935 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
1936 {
1937         result r = E_SUCCESS;
1938         Database db;
1939         DbStatement* pStmt = null;
1940         DbEnumerator* pEnum = null;
1941         String query;
1942         ArrayList* pList = null;
1943
1944         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
1945
1946         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1947         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1948
1949         pStmt = CreateStatementN(db, query);
1950         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1951                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1952
1953         pEnum = ExecuteStatementN(db, pStmt);
1954         if (pEnum != null)
1955         {
1956                 pList = new (std::nothrow) ArrayList;
1957                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1958
1959                 pList->Construct();
1960
1961                 while (pEnum->MoveNext() == E_SUCCESS)
1962                 {
1963                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
1964                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
1965
1966                         String name;
1967                         String value;
1968
1969                         pEnum->GetStringAt(1, name);
1970                         pEnum->GetStringAt(2, value);
1971
1972                         pLaunchCondtion->SetName(name);
1973                         pLaunchCondtion->SetValue(value);
1974
1975                         pList->Add(*pLaunchCondtion);
1976
1977                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
1978                 }
1979
1980                 delete pEnum;
1981         }
1982
1983 CATCH:
1984         delete pStmt;
1985         return pList;
1986 }
1987
1988 result
1989 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
1990 {
1991         result r = E_SUCCESS;
1992         Database db;
1993         DbStatement* pStmt = null;
1994         DbEnumerator* pEnum = null;
1995         String query;
1996         Tizen::Base::String packageName;
1997
1998         if (pName == null)
1999         {
2000                 query.Format(
2001                         1024,
2002                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2003                         "True", packageId.GetPointer());
2004         }
2005         else
2006         {
2007                 query.Format(
2008                         1024,
2009                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
2010                         pName->GetPointer(), packageId.GetPointer());
2011         }
2012
2013         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2014         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2015
2016         pStmt = CreateStatementN(db, query);
2017         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2018                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2019
2020         pEnum = ExecuteStatementN(db, pStmt);
2021         if (pEnum != null)
2022         {
2023                 if (pEnum->MoveNext() == E_SUCCESS)
2024                 {
2025                         pEnum->GetStringAt(0, packageName);
2026                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2027                 }
2028                 delete pEnum;
2029         }
2030         else
2031         {
2032                 r = E_OBJ_NOT_FOUND;
2033         }
2034
2035 CATCH:
2036         delete pStmt;
2037
2038         return r;
2039 }
2040
2041 String
2042 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2043 {
2044         result r = E_SUCCESS;
2045         Database db;
2046         DbStatement* pStmt = null;
2047         DbEnumerator* pEnum = null;
2048         String query;
2049         String executableName;
2050
2051         query.Format(
2052                 1024,
2053                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2054                 "True", packageId.GetPointer());
2055
2056         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2057         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2058
2059         pStmt = CreateStatementN(db, query);
2060         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2061                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2062
2063         pEnum = ExecuteStatementN(db, pStmt);
2064         if (pEnum != null)
2065         {
2066                 if (pEnum->MoveNext() == E_SUCCESS)
2067                 {
2068                         pEnum->GetStringAt(0, executableName);
2069                 }
2070                 delete pEnum;
2071         }
2072         else
2073         {
2074                 r = E_OBJ_NOT_FOUND;
2075                 SetLastResult(r);
2076         }
2077
2078 CATCH:
2079         delete pStmt;
2080
2081         return executableName;
2082 }
2083
2084 DbStatement*
2085 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2086 {
2087         result r = E_SUCCESS;
2088         DbStatement* pStmt = null;
2089
2090         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2091         {
2092                 pStmt = db.CreateStatementN(query);
2093                 r = GetLastResult();
2094
2095                 if (r != E_OBJECT_LOCKED)
2096                 {
2097                         break;
2098                 }
2099                 else
2100                 {
2101                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2102                         delete pStmt;
2103                         pStmt = null;
2104                         usleep(50000);
2105                 }
2106         }
2107
2108         return pStmt;
2109 }
2110
2111 DbEnumerator*
2112 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2113 {
2114         result r = E_SUCCESS;
2115         DbEnumerator* pEnum = null;
2116
2117         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2118         {
2119                 pEnum = db.ExecuteStatementN(*pStmt);
2120                 r = GetLastResult();
2121
2122                 if (r != E_OBJECT_LOCKED)
2123                 {
2124                         break;
2125                 }
2126                 else
2127                 {
2128                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2129                         delete pEnum;
2130                         pEnum = null;
2131                         usleep(50000);
2132                 }
2133         }
2134
2135         return pEnum;
2136 }
2137
2138 } } } // Tizen::App::Package