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 <FSecPrivilegeInfo.h>
  40 #include <FSysSystemTime.h>
  41 #include <FBase_StringConverter.h>
  42
  43 #include "FAppPkg_PackageManagerImpl.h"
  44 #include "FAppPkg_PackageInfoImpl.h"
  45 #include "FAppPkg_PackageAppInfoImpl.h"
  46 #include "FAppPkg_PackageParser.h"
  47 #include "FApp_AppInfo.h"
  48 #include "FApp_PackageManagerProxy.h"
  49
  50 using namespace Tizen::Base;
  51 using namespace Tizen::Base::Runtime;
  52 using namespace Tizen::Base::Collection;
  53 using namespace Tizen::Base::Utility;
  54 using namespace Tizen::Io;
  55 using namespace Tizen::Security;
  56 using namespace Tizen::System;
  57
  58 namespace Tizen { namespace App { namespace Package
  59 {
  60
  61 PackageManager* pPackageManagerInstance = null;
  62
  63 Tizen::Base::Collection::HashMap _PackageManagerImpl::__installationList;
  64
  65 void
  66 _PackageManagerEvent::FireImpl(IEventListener& listener, const IEventArg& arg)
  67 {
  68         IPackageInstallationEventListener* pListener = dynamic_cast<IPackageInstallationEventListener*> (&listener);
  69         SysTryReturnVoidResult(NID_APP, pListener != null, E_OUT_OF_MEMORY, "pListener instance must not be null.");
  70
  71         const _PackageManagerEventArg* pArg = dynamic_cast<const _PackageManagerEventArg*>(&arg);
  72         SysTryReturnVoidResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "pArg instance must not be null.");
  73
  74         if (pArg->__eventKey == L"end")
  75         {
  76                 if (pArg->__eventValue == L"ok")
  77                 {
  78                         if (pArg->__install)
  79                         {
  80                                 SysLog(NID_APP, "Installation is Completed. [Package = %ls]", pArg->__packageId.GetPointer());
  81                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
  82                         }
  83                         else
  84                         {
  85                                 SysLog(NID_APP, "Uninstallation is Completed. [Package = %ls]", pArg->__packageId.GetPointer());
  86                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, true);
  87                         }
  88                 }
  89                 else
  90                 {
  91                         if (pArg->__install)
  92                         {
  93                                 SysLog(NID_APP, "Installation is Completed(Error). [Package = %ls]", pArg->__packageId.GetPointer());
  94                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
  95                         }
  96                         else
  97                         {
  98                                 SysLog(NID_APP, "Uninstallation is Completed(Error). [Package = %ls]", pArg->__packageId.GetPointer());
  99                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, false);
 100                         }
 101                 }
 102         }
 103         else if (pArg->__eventKey == L"install_percent")
 104         {
 105                 std::unique_ptr<char[]> pProgress(_StringConverter::CopyToCharArrayN(pArg->__eventValue));
 106
 107                 int progress = 0;
 108                 sscanf(pProgress.get(), "%d", &progress);
 109
 110                 SysLog(NID_APP, "InstallationInProgress [%d]", progress);
 111                 pListener->OnPackageInstallationInProgress(pArg->__packageId, progress);
 112         }
 113 }
 114
 115 PackageId
 116 _PackageManagerImpl::GetPackageIdByAppId(const AppId& appId)
 117 {
 118         SysTryReturn(NID_APP, appId.IsEmpty() == false, L"", E_INVALID_ARG, "appId is empty");
 119
 120         String packageId;
 121
 122         if (appId.StartsWith(L".", 10) == true)
 123         {
 124                 appId.SubString(0, 10, packageId);
 125         }
 126         else
 127         {
 128                 int result = 0;
 129                 char* pPackageId = null;
 130                 pkgmgrinfo_appinfo_h pAppInfoHandle = null;
 131
 132                 std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 133                 SysTryReturn(NID_APP, pAppId, L"", E_OUT_OF_MEMORY, "pAppId is null");
 134
 135                 result = pkgmgrinfo_appinfo_get_appinfo(pAppId.get(), &pAppInfoHandle);
 136                 SysTryReturn(NID_APP, result == 0, L"", E_PKG_NOT_INSTALLED, "pkgmgrinfo_appinfo_get_appinfo() failed. result=[%d], app=[%s]", result, pAppId.get());
 137
 138                 result = pkgmgrinfo_appinfo_get_pkgname(pAppInfoHandle, &pPackageId);
 139
 140                 packageId.Append(pPackageId);
 141
 142                 if(pAppInfoHandle)
 143                 {
 144                         pkgmgrinfo_appinfo_destroy_appinfo(pAppInfoHandle);
 145                 }
 146         }
 147
 148         SysLog(NID_APP, "app = [%ls], package = [%ls]", appId.GetPointer(), packageId.GetPointer());
 149
 150         return packageId;
 151 }
 152
 153 result
 154 _PackageManagerImpl::AddEventListener(IPackageInstallationEventListener* pListener, int priority)
 155 {
 156         SysTryReturnResult(NID_APP, (priority < 3) && (priority >= 0), E_INVALID_ARG, "priority is invalid.");
 157
 158         result r = E_SUCCESS;
 159         int res = 0;
 160
 161         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 162         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 163
 164         while (pEnum->MoveNext() == E_SUCCESS)
 165         {
 166                 _PackageManagerEvent*   pEvent = null;
 167                 pEnum->GetCurrent(pEvent);
 168                 if (pEvent)
 169                 {
 170                         if (pEvent->__pListener == pListener)
 171                         {
 172                                 SysLog(NID_APP, "The event listener already exist. listener = [0x%x]", pListener);
 173                                 return E_OBJ_ALREADY_EXIST;
 174                         }
 175                 }
 176         }
 177
 178         if (__pListeningClient == null)
 179         {
 180                 __pListeningClient = pkgmgr_client_new(PC_LISTENING);
 181                 SysTryReturnResult(NID_APP, __pListeningClient != null, E_SYSTEM, "pkgmgr_client_new(PC_LISTENING) failed");
 182
 183                 res = pkgmgr_client_listen_status(__pListeningClient, PackageEventHandler, this);
 184                 if (res < PKGMGR_R_OK)
 185                 {
 186                         pkgmgr_client_free(__pListeningClient);
 187                         __pListeningClient = null;
 188
 189                         if (res == PKGMGR_R_EINVAL)
 190                         {
 191                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns ARGV error");
 192                                 return E_INVALID_ARG;
 193                         }
 194                         else if (res == PKGMGR_R_ECOMM)
 195                         {
 196                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns COMM error");
 197                         }
 198                         else if (res == PKGMGR_R_ETIMEOUT)
 199                         {
 200                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns TIME_OUT error");
 201                         }
 202                         else if (res == PKGMGR_R_ERROR)
 203                         {
 204                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error");
 205                         }
 206                         else
 207                         {
 208                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error, res = %d", res);
 209                         }
 210
 211                         return E_SYSTEM;
 212                 }
 213         }
 214
 215         _PackageManagerEvent* pEvent = new (std::nothrow) _PackageManagerEvent();
 216         SysTryReturnResult(NID_APP, pEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 217
 218         r = pEvent->Construct();
 219         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "pEvent->Construct() failed.");
 220
 221         pEvent->__pListener = pListener;
 222
 223         r = pEvent->AddListener(*pListener, true);
 224         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "pEvent->AddListener() failed. [%s]", GetErrorMessage(r));
 225
 226         r = __packageEventListenerList.Add(pEvent);
 227         SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 228
 229         SysLog(NID_APP, "Add PackageInstallationEventListener = [0x%x]", pListener);
 230         return E_SUCCESS;
 231 }
 232
 233 result
 234 _PackageManagerImpl::RemoveEventListener(IPackageInstallationEventListener* pListener)
 235 {
 236         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 237         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 238
 239         result r = E_SUCCESS;
 240
 241         while (pEnum->MoveNext() == E_SUCCESS)
 242         {
 243                 _PackageManagerEvent*   pEvent = null;
 244                 pEnum->GetCurrent(pEvent);
 245                 if (pEvent)
 246                 {
 247                         if (pEvent->__pListener == pListener)
 248                         {
 249                                 r = __packageEventListenerList.Remove(pEvent);
 250                                 SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 251
 252                                 delete pEvent;
 253
 254                                 SysLog(NID_APP, "Remove PackageInstallationEventListener = [0x%x]", pListener);
 255                                 return E_SUCCESS;
 256                         }
 257                 }
 258         }
 259
 260         return E_OBJ_NOT_FOUND;
 261 }
 262
 263 PackageInfo*
 264 _PackageManagerImpl::GetPackageInfoN(const PackageId& packageId) const
 265 {
 266         SysTryReturn(NID_APP, packageId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageId is empty.");
 267         SysTryReturn(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, null, E_INVALID_ARG, "packageId is invalid.(length)");
 268
 269         result r = E_SUCCESS;
 270         PackageInfo* pPackageInfo = null;
 271
 272         pPackageInfo = new (std::nothrow) PackageInfo;
 273         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
 274
 275         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
 276         r = pPackageInfoImpl->Construct(packageId);
 277         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] package (%ls) is not found.", packageId.GetPointer());
 278
 279         return pPackageInfo;
 280
 281 CATCH:
 282         delete pPackageInfo;
 283         return null;
 284 }
 285
 286 PackageAppInfo*
 287 _PackageManagerImpl::GetPackageAppInfoN(const AppId& appId) const
 288 {
 289         SysTryReturn(NID_APP, appId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] appId is empty.");
 290
 291         result r = E_SUCCESS;
 292         PackageAppInfo* pPackageAppInfo = null;
 293
 294         pPackageAppInfo = new (std::nothrow) PackageAppInfo;
 295         SysTryReturn(NID_APP, pPackageAppInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageAppInfo instance must not be null.");
 296
 297         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 298         r = pPackageAppInfoImpl->Construct(appId);
 299         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] app (%ls) is not found.", appId.GetPointer());
 300
 301         return pPackageAppInfo;
 302
 303 CATCH:
 304         delete pPackageAppInfo;
 305         return null;
 306 }
 307
 308 IList*
 309 _PackageManagerImpl::GetPackageInfoListN(void) const
 310 {
 311         result r = E_SUCCESS;
 312         int res = 0;
 313         ArrayList* pList = null;
 314
 315         pList = new (std::nothrow) ArrayList();
 316         SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
 317         pList->Construct();
 318
 319         res = pkgmgrinfo_pkginfo_get_list(PackageInfoEventHandler, pList);
 320         if (res != 0)
 321         {
 322                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_list() is failed. result = [%d]", res);
 323
 324                 pList->RemoveAll(true);
 325                 pList = null;
 326         }
 327
 328         SetLastResult(r);
 329         return pList;
 330 }
 331
 332 bool
 333 _PackageManagerImpl::IsPackageInstalled(const PackageId& packageId) const
 334 {
 335         SysTryReturn(NID_APP, packageId.IsEmpty() == false, false, E_INVALID_ARG, "packageId is empty");
 336
 337         int result = 0;
 338         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 339
 340         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 341         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
 342
 343         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 344         if (result != 0)
 345         {
 346                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", result, pPackageId.get());
 347                 return false;
 348         }
 349
 350         if(pPackageInfoHandle)
 351         {
 352                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 353         }
 354
 355         SysLog(NID_APP, "package = [%ls] is installed.", packageId.GetPointer());
 356
 357         return true;
 358 }
 359
 360 result
 361 _PackageManagerImpl::InstallPackage(const PackageId& packageId, const String& packagePath, IPackageInstallationResponseListener* pListener)
 362 {
 363         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 364         SysTryReturnResult(NID_APP, packagePath.IsEmpty() == false, E_INVALID_ARG, "packagePath is empty.");
 365         SysTryReturnResult(NID_APP, File::IsFileExist(packagePath) == true, E_INVALID_ARG, "packagePath is not existed.");
 366
 367         String extension = File::GetFileExtension(packagePath);
 368         SysTryReturnResult(NID_APP, extension.IsEmpty() == false, E_INVALID_ARG, "extension is empty.");
 369
 370         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(packagePath));
 371         SysTryReturnResult(NID_APP, pPackagePath, E_OUT_OF_MEMORY, "pPackagePath is null.");
 372
 373         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 374         SysTryReturnResult(NID_APP, pExtension, E_OUT_OF_MEMORY, "pExtension is null.");
 375
 376         if ((strcasecmp(pExtension.get(), "tpk") == 0) || (strcasecmp(pExtension.get(), "wgt") == 0))
 377         {
 378                 SysLog(NID_APP, "package = [%ls], packagePath = [%s], extension = [%s]", packageId.GetPointer(), pPackagePath.get(), pExtension.get());
 379         }
 380         else
 381         {
 382                 SysLog(NID_APP, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 383                 return E_SYSTEM;
 384         }
 385
 386         // optionalData = 12345abcde
 387         String optionalData;
 388         optionalData.Append(packageId);
 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 (IsHybridPackage(filePath) == true)
 775                 {
 776                         PackageInfo hybridServiceInfo;
 777                         _PackageParser packageParser;
 778
 779                         res = packageParser.Construct(&hybridServiceInfo);
 780                         SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Construct() is failed. [%s]", pPackagePath.get());
 781
 782                         res = packageParser.Parse(filePath);
 783                         SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Parse() is failed. [%s]", pPackagePath.get());
 784
 785                         IList* pList = hybridServiceInfo.GetPrivilegeListN();
 786                         if (pList)
 787                         {
 788                                 for (int i = 0; i < pList->GetCount(); i++)
 789                                 {
 790                                         PrivilegeInfo* pPrivilegeInfo = dynamic_cast < PrivilegeInfo* >(pList->GetAt(i));
 791                                         if (pPrivilegeInfo)
 792                                         {
 793                                                 String privilege = pPrivilegeInfo->GetId();
 794                                                 pPackageInfoImpl->AddPrivilege(*new (std::nothrow) String(privilege));
 795                                                 SysLog(NID_APP, "privilege[%ls] is added for hybrid.", privilege.GetPointer());
 796                                         }
 797                                  }
 798                         }
 799                 }
 800
 801                 if (pPkgInfo->privilege_list)
 802                 {
 803                         GList* pList = null;
 804                         pList = g_list_first(pPkgInfo->privilege_list);
 805                         while (pList)
 806                         {
 807                                 char* pPrivilege = (char*)pList->data;
 808                                 if (pPrivilege)
 809                                 {
 810                                         pPackageInfoImpl->AddPrivilege(*new (std::nothrow) String(pPrivilege));
 811                                         free(pPrivilege);
 812                                 }
 813                                 pList = g_list_next(pList);
 814                         }
 815                         g_list_free(pPkgInfo->privilege_list);
 816                 }
 817
 818                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
 819                 if (pPackageAppInfo)
 820                 {
 821                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
 822
 823                         pPackageAppInfoImpl->SetAppId(pPkgInfo->pkg_name);
 824                         pPackageAppInfoImpl->SetAppName(pPkgInfo->label);
 825                         pPackageAppInfoImpl->SetAppDisplayName(pPkgInfo->label);
 826                         pPackageAppInfoImpl->SetMainApp(true);
 827                         if ((pPkgInfo->icon_buf) && (pPkgInfo->icon_size > 0))
 828                         {
 829                                 pPackageAppInfoImpl->SetAppMenuIconBuffer(pPkgInfo->icon_buf, pPkgInfo->icon_size);
 830                         }
 831
 832                         pPackageInfoImpl->AddPackageAppInfo(*pPackageAppInfo.release());
 833                 }
 834                 else
 835                 {
 836                         SysLog(NID_APP, "pPackageAppInfo instance must not be null.");
 837                         pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 838                         return null;
 839                 }
 840
 841                 pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 842         }
 843         else
 844         {
 845                 SysTryReturn(NID_APP, false, null, E_UNSUPPORTED_FORMAT, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 846         }
 847
 848         return pPackageInfo.release();
 849 }
 850
 851 IList*
 852 _PackageManagerImpl::GetPackageInfoListN(const IMap& packageFilterMap) const
 853 {
 854         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap.GetCount() is invalid.");
 855
 856         std::unique_ptr<IMapEnumerator> pEnum(packageFilterMap.GetMapEnumeratorN());
 857         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 858
 859         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList());
 860         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
 861
 862         pList->Construct();
 863
 864         int res = PMINFO_R_OK;
 865         pkgmgrinfo_pkginfo_filter_h handle = null;
 866
 867         res = pkgmgrinfo_pkginfo_filter_create(&handle);
 868         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_pkginfo_filter_create() is failed. [%d]", res);
 869
 870         while(pEnum->MoveNext() == E_SUCCESS)
 871         {
 872                 String* pKey = static_cast< String* >(pEnum->GetKey());
 873                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 874
 875                 Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 876                 SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 877
 878                 bool value = pVal->ToBool();
 879
 880                 SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), value);
 881
 882                 if ((*pKey) == PACKAGE_FILTER_UNINSTALLABLE)
 883                 {
 884                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE, value);
 885                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(REMOVABLE, %d) is failed. [%d]", value, res);
 886                 }
 887                 else if ((*pKey) == PACKAGE_FILTER_DOWNLOADED)
 888                 {
 889                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD, !value);
 890                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(PRELOAD, %d) is failed. [%d]", !value, res);
 891                 }
 892                 else if ((*pKey) == PACKAGE_FILTER_APP_SETTING)
 893                 {
 894                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING, value);
 895                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(APPSETTING, %d) is failed. [%d]", value, res);
 896                 }
 897                 else if ((*pKey) == PACKAGE_FILTER_TPK)
 898                 {
 899                         SysTryCatch(NID_APP, value == true, , E_SYSTEM, "Value(false) is invalid for PACKAGE_FILTER_TPK.");
 900
 901                         res = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_TYPE, "tpk");
 902                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_string(TYPE, tpk) is failed. [%d]", res);
 903                 }
 904                 else if ((*pKey) == PACKAGE_FILTER_EXTERNAL_STORAGE)
 905                 {
 906                         String installedStorage;
 907                         if (value == true)
 908                         {
 909                                 installedStorage = L"installed_external";
 910                         }
 911                         else
 912                         {
 913                                 installedStorage = L"installed_internal";
 914                         }
 915
 916                         std::unique_ptr<char[]> pInstalledStorage(_StringConverter::CopyToCharArrayN(installedStorage));
 917                         SysTryCatch(NID_APP, pInstalledStorage, , E_OUT_OF_MEMORY, "pInstalledStorage is null.");
 918
 919                         SysLog(NID_APP, "Value[%d]->[%s]", value, pInstalledStorage.get());
 920
 921                         res = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE, pInstalledStorage.get());
 922                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_string(STORAGE, %s) is failed. [%d]", pInstalledStorage.get(), res);
 923                 }
 924                 else
 925                 {
 926                         SysTryCatch(NID_APP, false, , E_INVALID_ARG, "Invalid key(%ls)", pKey->GetPointer());
 927                 }
 928         }
 929
 930         res = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, PackageInfoHandler, pList.get());
 931         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_foreach_pkginfo() failed. [%d]", res);
 932
 933 CATCH:
 934         if (handle)
 935         {
 936                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 937         }
 938
 939         if (pList->GetCount() <= 0)
 940         {
 941                 SysLog(NID_APP, "pList's count is 0.");
 942                 return null;
 943         }
 944
 945         return pList.release();
 946 }
 947
 948 IList*
 949 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageAppFilterMap) const
 950 {
 951         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 952
 953         std::unique_ptr< IMapEnumerator > pEnum(packageAppFilterMap.GetMapEnumeratorN());
 954         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 955
 956         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList());
 957         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
 958
 959         pList->Construct();
 960
 961         int res = 0;
 962         bool definedKey = false;
 963         bool metadataKey = false;
 964         ArrayList list;
 965         ArrayList metadataList;
 966         ArrayList appIdList;
 967         pkgmgrinfo_appinfo_filter_h handle = null;
 968         pkgmgrinfo_appinfo_metadata_filter_h metaHandle = null;
 969
 970         res = pkgmgrinfo_appinfo_filter_create(&handle);
 971         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_create() is failed. [%d]", res);
 972
 973         res = pkgmgrinfo_appinfo_metadata_filter_create(&metaHandle);
 974         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_create() is failed. [%d]", res);
 975
 976         while(pEnum->MoveNext() == E_SUCCESS)
 977         {
 978                 String* pKey = static_cast< String* >(pEnum->GetKey());
 979                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 980
 981                 if ((*pKey) == PACKAGE_APP_FILTER_MENUICON_VISIBLE)
 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 nodisplay = !(pVal->ToBool());
 989                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), nodisplay);
 990
 991                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, nodisplay);
 992                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(NODISPLAY, %d) is failed. [%d]", nodisplay, res);
 993                 }
 994 #if 0
 995                 else if ((*pKey) == PACKAGE_APP_FILTER_LAUNCH_ONBOOT)
 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_ONBOOT, value);
1006                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(ONBOOT, %d) is failed. [%d]", value, res);
1007                 }
1008                 else if ((*pKey) == PACKAGE_APP_FILTER_AUTO_RESTART)
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_AUTORESTART, value);
1019                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(AUTORESTART, %d) is failed. [%d]", value, res);
1020                 }
1021 #endif
1022                 else if ((*pKey) == PACKAGE_APP_FILTER_LAUNCHING_HISTORY_VISIBLE)
1023                 {
1024                         definedKey = true;
1025
1026                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
1027                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
1028
1029                         bool value = pVal->ToBool();
1030                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), value);
1031
1032                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_TASKMANAGE, value);
1033                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(TASKMANAGE, %d) is failed. [%d]", value, res);
1034                 }
1035                 else if ((*pKey) == PACKAGE_APP_FILTER_LAUNCH_CONDITION)
1036                 {
1037                         definedKey = true;
1038
1039                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
1040                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
1041
1042                         bool value = pVal->ToBool();
1043                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), value);
1044
1045                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_LAUNCHCONDITION, value);
1046                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(LAUNCHCONDITION, %d) is failed. [%d]", value, res);
1047                 }
1048                 else if ((*pKey) == PACKAGE_APP_FILTER_CATEGORY_HOMEAPP || (*pKey) == PACKAGE_APP_FILTER_CATEGORY_LOCKAPP
1049                                                 || (*pKey) == PACKAGE_APP_FILTER_CATEGORY_MENUAPP)
1050                 {
1051                         definedKey = true;
1052
1053                         std::unique_ptr<char[]> pDefinedKey(_StringConverter::CopyToCharArrayN(*pKey));
1054                         SysTryCatch(NID_APP, pDefinedKey, , E_OUT_OF_MEMORY, "pDefinedKey is null.");
1055
1056                         Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
1057                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
1058
1059                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), pVal->ToBool());
1060                         SysTryCatch(NID_APP, pVal->ToBool() == true, , E_INVALID_ARG, "Value(false) is not allowed.");
1061
1062                         res = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, pDefinedKey.get());
1063                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_add_string(CATEGORY, %s) is failed. [%d]", pDefinedKey.get(), res);
1064                 }
1065                 else
1066                 {
1067                         metadataKey = true;
1068
1069                         String* pVal = static_cast< String* >(pEnum->GetValue());
1070                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
1071
1072                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
1073
1074                         std::unique_ptr<char[]> pMetaKey(_StringConverter::CopyToCharArrayN(*pKey));
1075                         SysTryCatch(NID_APP, pMetaKey, , E_OUT_OF_MEMORY, "pMetaKey is null.");
1076
1077                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
1078                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
1079
1080                         if ((*pVal) == L"*")
1081                         {
1082                                 res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), null);
1083                                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, null) is failed. [%d]", pMetaKey.get(), res);
1084                         }
1085                         else
1086                         {
1087                                 res = pkgmgrinfo_appinfo_metadata_filter_add(metaHandle, pMetaKey.get(), pValue.get());
1088                                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_add(%s, %s) is failed. [%d]", pMetaKey.get(), pValue.get(), res);
1089                         }
1090                 }
1091         }
1092
1093         if ((definedKey == true) && (metadataKey == false))
1094         {
1095                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, pList.get());
1096                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_foreach_appinfo() failed. [%d]", res);
1097         }
1098         else if ((definedKey == false) && (metadataKey == true))
1099         {
1100                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, pList.get());
1101                 SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_metadata_filter_foreach() failed. [%d]", res);
1102         }
1103         else
1104         {
1105                 list.Construct();
1106
1107                 res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, &list);
1108                 if (res != PMINFO_R_OK)
1109                 {
1110                         SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
1111                         goto CATCH;
1112                 }
1113
1114                 metadataList.Construct();
1115
1116                 res = pkgmgrinfo_appinfo_metadata_filter_foreach(metaHandle, PackageAppInfoMetadataHandler, &metadataList);
1117                 if (res != PMINFO_R_OK)
1118                 {
1119                         SysLog(NID_APP, "pkgmgrinfo_appinfo_metadata_filter_foreach() is failed. result = [%d]", res);
1120                         goto CATCH;
1121                 }
1122
1123                 for (int i = 0; i < list.GetCount(); i++)
1124                 {
1125                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(list.GetAt(i));
1126                         if (pPackageAppInfo)
1127                         {
1128                                 SysLog(NID_APP, "PackageAppFilter - App [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1129
1130                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1131                                 appIdList.Add(pAppId.release());
1132                         }
1133                 }
1134
1135                 for (int j = 0; j < metadataList.GetCount(); j++)
1136                 {
1137                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(metadataList.GetAt(j));
1138                         if (pPackageAppInfo)
1139                         {
1140                                 AppId appId = pPackageAppInfo->GetAppId();
1141
1142                                 if (appIdList.Contains(appId) == true)
1143                                 {
1144                                         SysLog(NID_APP, "App [%ls] is matched.", appId.GetPointer());
1145
1146                                         std::unique_ptr< PackageAppInfo > pAppInfo(new (std::nothrow) PackageAppInfo);
1147                                         SysTryCatch(NID_APP, pAppInfo, , E_OUT_OF_MEMORY, "pAppInfo is null.");
1148
1149                                         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pAppInfo.get());
1150                                         pPackageAppInfoImpl->Construct(appId);
1151
1152                                         pList->Add(pAppInfo.release());
1153                                 }
1154                                 else
1155                                 {
1156                                         SysLog(NID_APP, "App [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1157                                 }
1158                         }
1159                 }
1160         }
1161
1162 CATCH:
1163         if (handle)
1164         {
1165                 pkgmgrinfo_appinfo_filter_destroy(handle);
1166         }
1167
1168         if (metaHandle)
1169         {
1170                 pkgmgrinfo_appinfo_metadata_filter_destroy(metaHandle);
1171         }
1172
1173         if (pList->GetCount() <= 0)
1174         {
1175                 SysLog(NID_APP, "pList's count is 0.");
1176                 return null;
1177         }
1178
1179         return pList.release();
1180 }
1181
1182 IList*
1183 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageFilterMap, const IMap& packageAppFilterMap) const
1184 {
1185         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap Count is invalid.");
1186         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap Count is invalid.");
1187
1188         ArrayList appIdList;
1189
1190         std::unique_ptr< IList > pPackageFilterList(GetPackageInfoListN(packageFilterMap));
1191         if (pPackageFilterList == null)
1192         {
1193                 SysLog(NID_APP, "GetPackageInfoListN(packageFilterMap) is null.");
1194                 return null;
1195         }
1196
1197         for (int i = 0; i < pPackageFilterList->GetCount(); i++)
1198         {
1199                 PackageInfo* pPackageInfo = dynamic_cast < PackageInfo* >(pPackageFilterList->GetAt(i));
1200                 if (pPackageInfo)
1201                 {
1202                         std::unique_ptr< IList > pPackageAppInfoList(pPackageInfo->GetPackageAppInfoListN());
1203                         if (pPackageAppInfoList)
1204                         {
1205                                 for (int j = 0; j < pPackageAppInfoList->GetCount(); j++)
1206                                 {
1207                                         PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pPackageAppInfoList->GetAt(j));
1208                                         if (pPackageAppInfo)
1209                                         {
1210                                                 SysLog(NID_APP, "PackageFilter - App [%ls]", pPackageAppInfo->GetAppId().GetPointer());
1211
1212                                                 std::unique_ptr< AppId > pAppId(new (std::nothrow) AppId(pPackageAppInfo->GetAppId()));
1213                                                 appIdList.Add(pAppId.release());
1214                                         }
1215                                 }
1216                         }
1217                 }
1218         }
1219
1220         std::unique_ptr< ArrayList > pList(new (std::nothrow) ArrayList);
1221         SysTryReturn(NID_APP, pList, null, E_OUT_OF_MEMORY, "pList is null.");
1222
1223         std::unique_ptr< IList > pAppFilterList(GetPackageAppInfoListN(packageAppFilterMap));
1224         if (pAppFilterList == null)
1225         {
1226                 SysLog(NID_APP, "GetPackageAppInfoListN(packageAppFilterMap) is null.");
1227                 return null;
1228         }
1229
1230         for (int k = 0; k < pAppFilterList->GetCount(); k++)
1231         {
1232                 PackageAppInfo* pPackageAppInfo = dynamic_cast < PackageAppInfo* >(pAppFilterList->GetAt(k));
1233                 if (pPackageAppInfo)
1234                 {
1235                         AppId appId = pPackageAppInfo->GetAppId();
1236                         SysLog(NID_APP, "AppFilter - App [%ls]", appId.GetPointer());
1237
1238                         if (appIdList.Contains(appId) == true)
1239                         {
1240                                 SysLog(NID_APP, "App [%ls] is matched.", appId.GetPointer());
1241
1242                                 std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1243                                 SysTryReturn(NID_APP, pPackageAppInfo, null, E_OUT_OF_MEMORY, "PackageAppInfo is null.");
1244
1245                                 _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1246                                 pPackageAppInfoImpl->Construct(appId);
1247
1248                                 pList->Add(pPackageAppInfo.release());
1249                         }
1250                         else
1251                         {
1252                                 SysLog(NID_APP, "App [%ls] is not matched.", pPackageAppInfo->GetAppId().GetPointer());
1253                         }
1254                 }
1255         }
1256
1257         if (pList->GetCount() <= 0)
1258         {
1259                 SysLog(NID_APP, "pList's count is 0.");
1260                 return null;
1261         }
1262
1263         return pList.release();
1264 }
1265
1266 int
1267 _PackageManagerImpl::PackageInfoHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1268 {
1269         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1270         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1271
1272         result r = E_SUCCESS;
1273         int res = PMINFO_R_OK;
1274         char* pPackageId = null;
1275         ArrayList* pList = (ArrayList*)pUserData;
1276
1277         res = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackageId);
1278         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkgname() is failed. [%d]", res);
1279
1280         std::unique_ptr<PackageInfo> pPackageInfo(new (std::nothrow) PackageInfo);
1281         SysTryReturn(NID_APP, pPackageInfo, 0, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1282
1283         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1284         r = pPackageInfoImpl->Construct(pPackageId);
1285         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pPackageId);
1286
1287         pList->Add(*pPackageInfo.release());
1288
1289         return 0;
1290 }
1291
1292 int
1293 _PackageManagerImpl::PackageAppInfoHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1294 {
1295         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1296         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1297
1298         result r = E_SUCCESS;
1299         int res = PMINFO_R_OK;
1300         char* pAppId = null;
1301         ArrayList* pList = (ArrayList*)pUserData;
1302
1303         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1304         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1305
1306         SysLog(NID_APP, "app = [%s]", pAppId);
1307
1308         std::unique_ptr<PackageAppInfo> pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1309         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1310
1311         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1312         r = pPackageAppInfoImpl->Construct(pAppId);
1313         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1314
1315         pList->Add(*pPackageAppInfo.release());
1316
1317         return 0;
1318 }
1319
1320 int
1321 _PackageManagerImpl::PackageAppInfoMetadataHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
1322 {
1323         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
1324         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
1325
1326         result r = E_SUCCESS;
1327         int res = PMINFO_R_OK;
1328         char* pAppId = null;
1329         ArrayList* pList = (ArrayList*)pUserData;
1330
1331         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
1332         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
1333
1334         SysLog(NID_APP, "app = [%s]", pAppId);
1335
1336         std::unique_ptr< PackageAppInfo > pPackageAppInfo(new (std::nothrow) PackageAppInfo);
1337         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
1338
1339         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
1340         r = pPackageAppInfoImpl->Construct(pAppId);
1341         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
1342
1343         pList->Add(*pPackageAppInfo.release());
1344
1345         return 0;
1346 }
1347
1348 bool
1349 _PackageManagerImpl::IsHybridPackage(const String& filePath) const
1350 {
1351         SysTryReturn(NID_APP, filePath.IsEmpty() == false, false, E_INVALID_ARG, "filePath is empty.");
1352
1353         bool res = true;
1354         FileUnzipper unzipper;
1355         ZipEntry zipEntry;
1356
1357         result r = unzipper.Construct(filePath);
1358         SysTryReturn(NID_APP, !IsFailed(r), false, E_SYSTEM, "unzipper.Construct() failed.");
1359
1360         r = unzipper.GetEntry(L"info/manifest.xml", zipEntry);
1361         if (!IsFailed(r))
1362         {
1363                 SysLog(NID_APP, "It's hybrid package. [%ls]", filePath.GetPointer());
1364                 res = true;
1365         }
1366         else
1367         {
1368                 SysLog(NID_APP, "It's not hybrid package. [%ls]", filePath.GetPointer());
1369                 res = false;
1370         }
1371
1372         return res;
1373 }
1374
1375 _PackageManagerImpl*
1376 _PackageManagerImpl::GetInstance(void)
1377 {
1378         return PackageManager::GetInstance()->__pPackageManagerImpl;
1379 }
1380
1381 result
1382 _PackageManagerImpl::Construct(void)
1383 {
1384         ClearLastResult();
1385
1386         result r = __installationList.Construct();
1387         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
1388
1389         return E_SUCCESS;
1390 }
1391
1392 _PackageManagerImpl::_PackageManagerImpl(void)
1393 :__pRequestClient(null),
1394 __pListeningClient(null)
1395 {
1396 }
1397
1398 _PackageManagerImpl::~_PackageManagerImpl(void)
1399 {
1400 }
1401
1402 void
1403 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
1404 {
1405         result r = E_SUCCESS;
1406         bool install = true;
1407
1408         if (strcmp(pEventKey, "start") == 0)
1409         {
1410                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
1411                 {
1412                         String* pAppId = new (std::nothrow) String(packageId);
1413                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
1414
1415                         String* pOperation = new (std::nothrow) String(pEventValue);
1416                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
1417
1418                         r = __installationList.Add(*pAppId, *pOperation);
1419                         if (IsFailed(r))
1420                         {
1421                                 delete pAppId;
1422                                 delete pOperation;
1423                                 SysLog(NID_APP, "Failed to add installation condition.");
1424                                 SetLastResult(E_SYSTEM);
1425                                 return;
1426                         }
1427                 }
1428         }
1429         else if (strcmp(pEventKey, "end") == 0)
1430         {
1431                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
1432                 if (pOperation)
1433                 {
1434                         if (pOperation->Equals("uninstall", true) == true)
1435                         {
1436                                 install = false;
1437                         }
1438
1439                         r = __installationList.Remove(packageId, true);
1440                         if (IsFailed(r))
1441                         {
1442                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
1443                         }
1444                 }
1445         }
1446
1447         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
1448         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
1449
1450         while (pEnum->MoveNext() == E_SUCCESS)
1451         {
1452                 _PackageManagerEvent*   pEvent = null;
1453                 pEnum->GetCurrent(pEvent);
1454                 if (pEvent)
1455                 {
1456                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
1457                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
1458
1459                         String eventKey(pEventKey);
1460                         String eventValue(pEventValue);
1461
1462                         pEventArg->__packageId = packageId;
1463                         pEventArg->__eventKey = eventKey;
1464                         pEventArg->__eventValue = eventValue;
1465                         pEventArg->__install = install;
1466
1467                         r = pEvent->Fire(*pEventArg);
1468                         if (r != E_SUCCESS)
1469                         {
1470                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
1471                         }
1472
1473                         SysLog(NID_APP, "Package = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
1474                 }
1475                 else
1476                 {
1477                         SysLog(NID_APP, "pEvent is null.");
1478                 }
1479         }
1480 }
1481
1482 PackageInfo*
1483 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
1484 {
1485         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
1486
1487         result r = E_SUCCESS;
1488         Database db;
1489         DbStatement* pStmt = null;
1490         DbEnumerator* pEnum = null;
1491         String query;
1492         PackageInfo *pPackageInfo = null;
1493
1494         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());
1495
1496         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1497         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1498
1499         pStmt = CreateStatementN(db, query);
1500
1501         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1502
1503         pEnum = ExecuteStatementN(db, pStmt);
1504         if (pEnum != null)
1505         {
1506                 if (pEnum->MoveNext() == E_SUCCESS)
1507                 {
1508                         pPackageInfo = new (std::nothrow) PackageInfo;
1509                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1510
1511                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1512
1513                         String id;
1514                         String appVersion;
1515                         String appType;
1516                         String appMimeType;
1517                         String appApiVersion;
1518                         String appName;
1519                         String appVendor;
1520                         String appDescription;
1521                         String appUrl;
1522                         String appCid;
1523                         String appRootPath;
1524                         int appStorageType = 0;
1525                         DateTime appInstallationTime;
1526                         String appIconPath;
1527
1528                         pEnum->GetStringAt(1, id);
1529                         pEnum->GetStringAt(3, appVersion);
1530                         pEnum->GetStringAt(4, appType);
1531                         pEnum->GetStringAt(5, appMimeType);
1532                         pEnum->GetStringAt(6, appApiVersion);
1533                         pEnum->GetStringAt(7, appName);
1534                         pEnum->GetStringAt(8, appVendor);
1535                         pEnum->GetStringAt(9, appDescription);
1536                         pEnum->GetStringAt(10, appUrl);
1537                         pEnum->GetStringAt(11, appCid);
1538                         pEnum->GetStringAt(16, appRootPath);
1539                         pEnum->GetIntAt(17, appStorageType);
1540                         pEnum->GetDateTimeAt(18, appInstallationTime);
1541                         pEnum->GetStringAt(21, appIconPath);
1542
1543                         pPackageInfoImpl->SetAppId(id);
1544                         pPackageInfoImpl->SetAppVersion(appVersion);
1545                         pPackageInfoImpl->SetAppMimeType(appMimeType);
1546                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
1547                         pPackageInfoImpl->SetAppName(appName);
1548                         pPackageInfoImpl->SetAppVendor(appVendor);
1549                         pPackageInfoImpl->SetAppDescription(appDescription);
1550                         pPackageInfoImpl->SetAppUrl(appUrl);
1551                         pPackageInfoImpl->SetAppCid(appCid);
1552                         pPackageInfoImpl->SetAppRootPath(appRootPath);
1553                         pPackageInfoImpl->SetAppStorageType(appStorageType);
1554                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
1555                         pPackageInfoImpl->SetAppIconPath(appIconPath);
1556                 }
1557
1558                 delete pEnum;
1559         }
1560         else
1561         {
1562                 r = E_OBJ_NOT_FOUND;
1563         }
1564
1565 CATCH:
1566         delete pStmt;
1567         return pPackageInfo;
1568 }
1569
1570 int
1571 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1572 {
1573         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
1574
1575         result r = E_SUCCESS;
1576         int result = 0;
1577         char* pPackage = null;
1578         ArrayList* pList = (ArrayList*)pUserData;
1579
1580         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
1581         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
1582
1583         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
1584
1585         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
1586         if (result == 0)
1587         {
1588                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1589         }
1590         else
1591         {
1592                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1593         }
1594
1595         r = pPackageInfoImpl->Construct(pPackage);
1596         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pPackageInfoImpl->Construct() failed.");
1597
1598         r = pList->Add(*pPackageInfo.release());
1599         SysTryReturn(NID_APP, r == E_SUCCESS, -1, E_SYSTEM, "pList->Add() failed.");
1600
1601         return result;
1602 }
1603
1604 IList*
1605 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
1606 {
1607         result r = E_SUCCESS;
1608         Database db;
1609         DbStatement* pStmt = null;
1610         DbEnumerator* pEnum = null;
1611         String query;
1612         ArrayList* pList = null;
1613
1614         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());
1615
1616         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1617         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1618
1619         pStmt = CreateStatementN(db, query);
1620         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1621
1622         pEnum = ExecuteStatementN(db, pStmt);
1623
1624         if (pEnum != null)
1625         {
1626                 pList = new (std::nothrow) ArrayList();
1627                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1628                 pList->Construct();
1629
1630                 while (pEnum->MoveNext() == E_SUCCESS)
1631                 {
1632                         String* pPackageName = new (std::nothrow) String;
1633                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1634
1635                         pEnum->GetStringAt(0, *pPackageName);
1636
1637                         pList->Add(*pPackageName);
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 IList*
1654 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
1655 {
1656         result r = E_SUCCESS;
1657         Database db;
1658         DbStatement* pStmt = null;
1659         DbEnumerator* pEnum = null;
1660         String query;
1661         ArrayList* pList = null;
1662
1663         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());
1664
1665         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1666         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1667
1668         pStmt = CreateStatementN(db, query);
1669         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1670
1671         pEnum = ExecuteStatementN(db, pStmt);
1672
1673         if (pEnum != null)
1674         {
1675                 pList = new (std::nothrow) ArrayList();
1676                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1677                 pList->Construct();
1678
1679                 while (pEnum->MoveNext() == E_SUCCESS)
1680                 {
1681                         String* pPackageName = new (std::nothrow) String;
1682                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1683
1684                         String* pAccess = new (std::nothrow) String;
1685                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1686
1687                         pEnum->GetStringAt(0, *pPackageName);
1688                         pList->Add(*pPackageName);
1689
1690                         pEnum->GetStringAt(1, *pAccess);
1691                         pList->Add(*pAccess);
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 IMap*
1708 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1709 {
1710         result r = E_SUCCESS;
1711         Database db;
1712         DbStatement* pStmt = null;
1713         DbEnumerator* pEnum = null;
1714         String query;
1715         HashMap* pList = null;
1716
1717         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')"
1718                         , packageId.GetPointer());
1719
1720         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1721         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1722
1723         pStmt = CreateStatementN(db, query);
1724         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1725
1726         pEnum = ExecuteStatementN(db, pStmt);
1727
1728         if (pEnum != null)
1729         {
1730                 pList = new (std::nothrow) HashMap();
1731                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1732                 pList->Construct();
1733
1734                 while (pEnum->MoveNext() == E_SUCCESS)
1735                 {
1736                         String* pName = new (std::nothrow) String;
1737                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1738
1739                         String* pValue = new (std::nothrow) String;
1740                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1741
1742                         pEnum->GetStringAt(0, *pName);
1743                         pEnum->GetStringAt(1, *pValue);
1744
1745                         pList->Add(*pName, *pValue);
1746                 }
1747
1748                 delete pEnum;
1749
1750         }
1751         else
1752         {
1753                 r = E_OBJ_NOT_FOUND;
1754         }
1755
1756 CATCH:
1757         delete pStmt;
1758         return pList;
1759 }
1760
1761 bool
1762 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1763 {
1764         if (appId == _AppInfo::GetPackageId())
1765         {
1766                 return true;
1767         }
1768
1769         int result = 0;
1770         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1771
1772         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1773         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1774
1775         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1776         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], package=[%s]", result, pPackageId.get());
1777
1778         if(pPackageInfoHandle)
1779         {
1780                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1781         }
1782
1783         return true;
1784 }
1785
1786 int
1787 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1788                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1789 {
1790         SysLog(NID_APP, "PackageEventHandler - req: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1791                                 pkg_name, key, val);
1792
1793         PackageType type = PACKAGE_TYPE_TPK;
1794         PackageId packageId(pkg_name);
1795
1796         if (strcmp(pkg_type, "tpk") == 0)
1797         {
1798                 type = PACKAGE_TYPE_TPK;
1799         }
1800         else if (strcmp(pkg_type, "wgt") == 0)
1801         {
1802                 type = PACKAGE_TYPE_WGT;
1803         }
1804         else
1805         {
1806                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1807                 return 0;
1808         }
1809
1810         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1811         pThis->SendPackageEvent(type, packageId, key, val);
1812
1813         return 0;
1814 }
1815
1816 String*
1817 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1818 {
1819         result r = E_SUCCESS;
1820         Database db;
1821         DbStatement* pStmt = null;
1822         DbEnumerator* pEnum = null;
1823         String query;
1824         String* pAppId = null;
1825
1826         query.Format(1024, L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, DataControl WHERE DataControl.PROVIDER_ID = '%ls' and DataControl.ID = AppInfo.UNIQUE_ID",
1827                         providerId.GetPointer());
1828
1829         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1830         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1831
1832         pStmt = CreateStatementN(db, query);
1833         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1834
1835         pEnum = ExecuteStatementN(db, pStmt);
1836
1837         if (pEnum != null)
1838         {
1839                 if (pEnum->MoveNext() == E_SUCCESS)
1840                 {
1841                         pAppId = new (std::nothrow) String;
1842                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1843
1844                         pEnum->GetStringAt(0, *pAppId);
1845                 }
1846
1847                 delete pEnum;
1848         }
1849
1850 CATCH:
1851         delete pStmt;
1852         return pAppId;
1853 }
1854
1855 PackageInfo*
1856 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1857 {
1858         result r = E_SUCCESS;
1859         PackageInfo* pPkgInfo = null;
1860         Database db;
1861         DbStatement* pStmt = null;
1862         DbEnumerator* pEnum = null;
1863         String query;
1864
1865         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1866                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1867                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1868                         "GROUP BY AppInfoID"
1869                         , providerId.GetPointer(), operationId.GetPointer());
1870
1871         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1872         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1873
1874         pStmt = CreateStatementN(db, query);
1875         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1876
1877         pEnum = ExecuteStatementN(db, pStmt);
1878         if (pEnum != null)
1879         {
1880                 if (pEnum->MoveNext() == E_SUCCESS)
1881                 {
1882                         PackageId packageId;
1883                         pEnum->GetStringAt(0, packageId);
1884
1885                         pPkgInfo = GetPackageInfoN(packageId);
1886                 }
1887
1888                 delete pEnum;
1889         }
1890         else
1891         {
1892                 r = E_OBJ_NOT_FOUND;
1893         }
1894
1895 CATCH:
1896         delete pStmt;
1897         return pPkgInfo;
1898 }
1899
1900 ArrayList*
1901 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1902 {
1903         result r = E_SUCCESS;
1904         Database db;
1905         DbStatement* pStmt = null;
1906         DbEnumerator* pEnum = null;
1907         String query;
1908         //int id = 0;
1909         PackageInfo* pPkgInfo = null;
1910         _PackageInfoImpl* pPackageInfoImpl = null;
1911         ArrayList* pList = null;
1912
1913         pPkgInfo = GetPackageInfoN(packageId);
1914         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1915
1916         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1917         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1918
1919         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1920         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1921
1922         pStmt = CreateStatementN(db, query);
1923         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1924                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1925
1926         pEnum = ExecuteStatementN(db, pStmt);
1927
1928         if (pEnum != null)
1929         {
1930                 pList = new (std::nothrow) ArrayList;
1931                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1932
1933                 pList->Construct();
1934
1935                 while (pEnum->MoveNext() == E_SUCCESS)
1936                 {
1937                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
1938                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
1939
1940                         int uniqueId = 0;
1941                         int pkgId = 0;
1942                         String name;
1943                         String defaultapp;
1944                         String mainmenuIcon;
1945                         String settingIcon;
1946                         String quickpanelIcon;
1947                         int appFeature = 0;
1948                         String packageName;
1949
1950                         pEnum->GetIntAt(0, uniqueId);
1951                         pEnum->GetIntAt(1, pkgId);
1952                         pEnum->GetStringAt(2, name);
1953                         pEnum->GetStringAt(3, defaultapp);
1954                         pEnum->GetStringAt(4, mainmenuIcon);
1955                         pEnum->GetStringAt(5, settingIcon);
1956                         pEnum->GetStringAt(7, quickpanelIcon);
1957                         pEnum->GetIntAt(9, appFeature);
1958                         pEnum->GetStringAt(10, packageName);
1959
1960                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
1961                         pPackageAppInfoImpl->SetPkgId(pkgId);
1962                         pPackageAppInfoImpl->SetName(name);
1963                         pPackageAppInfoImpl->SetDefault(defaultapp);
1964                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
1965                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
1966                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
1967                         pPackageAppInfoImpl->SetAppFeature(appFeature);
1968                         pPackageAppInfoImpl->SetPackageName(packageName);
1969
1970                         pList->Add(*pPackageAppInfoImpl);
1971                 }
1972
1973                 delete pEnum;
1974         }
1975
1976 CATCH:
1977         delete pPkgInfo;
1978         delete pStmt;
1979         return pList;
1980 }
1981
1982 ArrayList*
1983 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1984 {
1985         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1986         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1987
1988         ArrayList* pResult = null;
1989
1990         for (int i = 0; i < pAppInfoList->GetCount(); i++)
1991         {
1992                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
1993                 if (pAppInfoImpl == null)
1994                 {
1995                         continue;
1996                 }
1997
1998                 if (pAppInfoImpl->GetName() == appExecutableName)
1999                 {
2000                         pResult = pAppInfoImpl->GetAppFeatureListN();
2001                         goto OUT;
2002                 }
2003         }
2004
2005 OUT:
2006         pAppInfoList->RemoveAll(true);
2007         delete pAppInfoList;
2008
2009         return pResult;
2010 }
2011
2012 HashMapT<String, _AppFeatureInfoImpl*>*
2013 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
2014 {
2015         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
2016         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
2017
2018         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
2019
2020         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
2021
2022         while (pEnum->MoveNext() == E_SUCCESS)
2023         {
2024                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
2025                 if (pAppInfoImpl == null)
2026                 {
2027                         continue;
2028                 }
2029
2030                 if (pAppInfoImpl->GetName() == appExecutableName)
2031                 {
2032                         pResult = pAppInfoImpl->GetAppFeatureMapN();
2033                         goto OUT;
2034                 }
2035         }
2036
2037 OUT:
2038         pAppInfoList->RemoveAll(true);
2039         delete pAppInfoList;
2040
2041         return pResult;
2042 }
2043
2044 ArrayList*
2045 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
2046 {
2047         result r = E_SUCCESS;
2048         Database db;
2049         DbStatement* pStmt = null;
2050         DbEnumerator* pEnum = null;
2051         String query;
2052         ArrayList* pList = null;
2053
2054         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
2055
2056         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2057         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2058
2059         pStmt = CreateStatementN(db, query);
2060         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2061                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2062
2063         pEnum = ExecuteStatementN(db, pStmt);
2064         if (pEnum != null)
2065         {
2066                 pList = new (std::nothrow) ArrayList;
2067                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
2068
2069                 pList->Construct();
2070
2071                 while (pEnum->MoveNext() == E_SUCCESS)
2072                 {
2073                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
2074                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
2075
2076                         String name;
2077                         String value;
2078
2079                         pEnum->GetStringAt(1, name);
2080                         pEnum->GetStringAt(2, value);
2081
2082                         pLaunchCondtion->SetName(name);
2083                         pLaunchCondtion->SetValue(value);
2084
2085                         pList->Add(*pLaunchCondtion);
2086
2087                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
2088                 }
2089
2090                 delete pEnum;
2091         }
2092
2093 CATCH:
2094         delete pStmt;
2095         return pList;
2096 }
2097
2098 result
2099 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
2100 {
2101         result r = E_SUCCESS;
2102         Database db;
2103         DbStatement* pStmt = null;
2104         DbEnumerator* pEnum = null;
2105         String query;
2106         Tizen::Base::String packageName;
2107
2108         if (pName == null)
2109         {
2110                 query.Format(
2111                         1024,
2112                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2113                         "True", packageId.GetPointer());
2114         }
2115         else
2116         {
2117                 query.Format(
2118                         1024,
2119                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
2120                         pName->GetPointer(), packageId.GetPointer());
2121         }
2122
2123         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2124         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2125
2126         pStmt = CreateStatementN(db, query);
2127         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2128                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2129
2130         pEnum = ExecuteStatementN(db, pStmt);
2131         if (pEnum != null)
2132         {
2133                 if (pEnum->MoveNext() == E_SUCCESS)
2134                 {
2135                         pEnum->GetStringAt(0, packageName);
2136                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2137                 }
2138                 delete pEnum;
2139         }
2140         else
2141         {
2142                 r = E_OBJ_NOT_FOUND;
2143         }
2144
2145 CATCH:
2146         delete pStmt;
2147
2148         return r;
2149 }
2150
2151 String
2152 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2153 {
2154         result r = E_SUCCESS;
2155         Database db;
2156         DbStatement* pStmt = null;
2157         DbEnumerator* pEnum = null;
2158         String query;
2159         String executableName;
2160
2161         query.Format(
2162                 1024,
2163                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2164                 "True", packageId.GetPointer());
2165
2166         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2167         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2168
2169         pStmt = CreateStatementN(db, query);
2170         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2171                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2172
2173         pEnum = ExecuteStatementN(db, pStmt);
2174         if (pEnum != null)
2175         {
2176                 if (pEnum->MoveNext() == E_SUCCESS)
2177                 {
2178                         pEnum->GetStringAt(0, executableName);
2179                 }
2180                 delete pEnum;
2181         }
2182         else
2183         {
2184                 r = E_OBJ_NOT_FOUND;
2185                 SetLastResult(r);
2186         }
2187
2188 CATCH:
2189         delete pStmt;
2190
2191         return executableName;
2192 }
2193
2194 DbStatement*
2195 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2196 {
2197         result r = E_SUCCESS;
2198         DbStatement* pStmt = null;
2199
2200         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2201         {
2202                 pStmt = db.CreateStatementN(query);
2203                 r = GetLastResult();
2204
2205                 if (r != E_OBJECT_LOCKED)
2206                 {
2207                         break;
2208                 }
2209                 else
2210                 {
2211                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2212                         delete pStmt;
2213                         pStmt = null;
2214                         usleep(50000);
2215                 }
2216         }
2217
2218         return pStmt;
2219 }
2220
2221 DbEnumerator*
2222 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2223 {
2224         result r = E_SUCCESS;
2225         DbEnumerator* pEnum = null;
2226
2227         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2228         {
2229                 pEnum = db.ExecuteStatementN(*pStmt);
2230                 r = GetLastResult();
2231
2232                 if (r != E_OBJECT_LOCKED)
2233                 {
2234                         break;
2235                 }
2236                 else
2237                 {
2238                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2239                         delete pEnum;
2240                         pEnum = null;
2241                         usleep(50000);
2242                 }
2243         }
2244
2245         return pEnum;
2246 }
2247
2248 } } } // Tizen::App::Package