src/app/package/FAppPkg_PackageManagerImpl.cpp

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