src/app/package/FAppPkg_PackageManagerImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        FAppPkg_PackageManagerImpl.cpp
  19  * @brief       This is the implementation for the _PackageManagerImpl class.
  20  */
  21 #include <cstdio>
  22 #include <cstdlib>
  23 #include <new>
  24 #include <memory>
  25 #include <unistd.h>
  26 #include <dlog.h>
  27 #include <unique_ptr.h>
  28
  29 #include <package-manager-types.h>
  30
  31 #include <FAppPkgPackageManager.h>
  32 #include <FAppPkgPackageAppInfo.h>
  33 #include <FAppPkgPackageInfo.h>
  34 #include <FAppPkgIPackageInstallationEventListener.h>
  35 #include <FAppPkgIPackageInstallationResponseListener.h>
  36 #include <FAppPkgIPackageUninstallationResponseListener.h>
  37 #include <FBaseSysLog.h>
  38 #include <FIo.h>
  39 #include <FIoRegistry.h>
  40 #include <FSysSystemTime.h>
  41 #include <FBase_StringConverter.h>
  42
  43 #include "FAppPkg_PackageManagerImpl.h"
  44 #include "FAppPkg_PackageInfoImpl.h"
  45 #include "FAppPkg_PackageAppInfoImpl.h"
  46 #include "FAppPkg_PackageParser.h"
  47 #include "FApp_AppInfo.h"
  48 #include "FApp_PackageManagerProxy.h"
  49
  50 using namespace Tizen::Base;
  51 using namespace Tizen::Base::Runtime;
  52 using namespace Tizen::Base::Collection;
  53 using namespace Tizen::Io;
  54 using namespace Tizen::System;
  55
  56 namespace Tizen { namespace App { namespace Package
  57 {
  58
  59 PackageManager* pPackageManagerInstance = null;
  60
  61 Tizen::Base::Collection::HashMap _PackageManagerImpl::__installationList;
  62
  63 void
  64 _PackageManagerEvent::FireImpl(IEventListener& listener, const IEventArg& arg)
  65 {
  66         IPackageInstallationEventListener* pListener = dynamic_cast<IPackageInstallationEventListener*> (&listener);
  67         SysTryReturnVoidResult(NID_APP, pListener != null, E_OUT_OF_MEMORY, "pListener instance must not be null.");
  68
  69         const _PackageManagerEventArg* pArg = dynamic_cast<const _PackageManagerEventArg*>(&arg);
  70         SysTryReturnVoidResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "pArg instance must not be null.");
  71
  72         if (pArg->__eventKey == L"end")
  73         {
  74                 if (pArg->__eventValue == L"ok")
  75                 {
  76                         if (pArg->__install)
  77                         {
  78                                 SysLog(NID_APP, "Installation is Completed. [PackageId = %ls]", pArg->__packageId.GetPointer());
  79                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
  80                         }
  81                         else
  82                         {
  83                                 SysLog(NID_APP, "Uninstallation is Completed. [PackageId = %ls]", pArg->__packageId.GetPointer());
  84                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, true);
  85                         }
  86                 }
  87                 else
  88                 {
  89                         if (pArg->__install)
  90                         {
  91                                 SysLog(NID_APP, "Installation is Completed(Error). [PackageId = %ls]", pArg->__packageId.GetPointer());
  92                                 pListener->OnPackageInstallationCompleted(pArg->__packageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
  93                         }
  94                         else
  95                         {
  96                                 SysLog(NID_APP, "Uninstallation is Completed(Error). [PackageId = %ls]", pArg->__packageId.GetPointer());
  97                                 pListener->OnPackageUninstallationCompleted(pArg->__packageId, false);
  98                         }
  99                 }
 100         }
 101         else if (pArg->__eventKey == L"install_percent")
 102         {
 103                 std::unique_ptr<char[]> pProgress(_StringConverter::CopyToCharArrayN(pArg->__eventValue));
 104
 105                 int progress = 0;
 106                 sscanf(pProgress.get(), "%d", &progress);
 107
 108                 SysLog(NID_APP, "InstallationInProgress [%d]", progress);
 109                 pListener->OnPackageInstallationInProgress(pArg->__packageId, progress);
 110         }
 111 }
 112
 113 PackageId
 114 _PackageManagerImpl::GetPackageIdByAppId(const AppId& appId)
 115 {
 116         SysTryReturn(NID_APP, appId.IsEmpty() == false, L"", E_INVALID_ARG, "appId is empty");
 117
 118         String packageId;
 119
 120         if (appId.StartsWith(L".", 10) == true)
 121         {
 122                 appId.SubString(0, 10, packageId);
 123         }
 124         else
 125         {
 126                 int result = 0;
 127                 char* pPackageId = null;
 128                 pkgmgrinfo_appinfo_h pAppInfoHandle = null;
 129
 130                 std::unique_ptr<char[]> pAppId(_StringConverter::CopyToCharArrayN(appId));
 131                 SysTryReturn(NID_APP, pAppId, L"", E_OUT_OF_MEMORY, "pAppId is null");
 132
 133                 result = pkgmgrinfo_appinfo_get_appinfo(pAppId.get(), &pAppInfoHandle);
 134                 SysTryReturn(NID_APP, result == 0, L"", E_PKG_NOT_INSTALLED, "pkgmgrinfo_appinfo_get_appinfo() failed. result=[%d], appId=[%s]", result, pAppId.get());
 135
 136                 result = pkgmgrinfo_appinfo_get_pkgname(pAppInfoHandle, &pPackageId);
 137
 138                 packageId.Append(pPackageId);
 139
 140                 if(pAppInfoHandle)
 141                 {
 142                         pkgmgrinfo_appinfo_destroy_appinfo(pAppInfoHandle);
 143                 }
 144         }
 145
 146         SysLog(NID_APP, "appId = [%ls], packageId = [%ls]", appId.GetPointer(), packageId.GetPointer());
 147
 148         return packageId;
 149 }
 150
 151 result
 152 _PackageManagerImpl::AddEventListener(IPackageInstallationEventListener* pListener, int priority)
 153 {
 154         SysTryReturnResult(NID_APP, (priority < 3) && (priority >= 0), E_INVALID_ARG, "priority is invalid.");
 155
 156         result r = E_SUCCESS;
 157         int res = 0;
 158
 159         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 160         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 161
 162         while (pEnum->MoveNext() == E_SUCCESS)
 163         {
 164                 _PackageManagerEvent*   pEvent = null;
 165                 pEnum->GetCurrent(pEvent);
 166                 if (pEvent)
 167                 {
 168                         if (pEvent->__pListener == pListener)
 169                         {
 170                                 SysLog(NID_APP, "The event listener already exist. listener = [0x%x]", pListener);
 171                                 return E_OBJ_ALREADY_EXIST;
 172                         }
 173                 }
 174         }
 175
 176         if (__pListeningClient == null)
 177         {
 178                 __pListeningClient = pkgmgr_client_new(PC_LISTENING);
 179                 SysTryReturnResult(NID_APP, __pListeningClient != null, E_SYSTEM, "pkgmgr_client_new(PC_LISTENING) failed");
 180
 181                 res = pkgmgr_client_listen_status(__pListeningClient, PackageEventHandler, this);
 182                 if (res < PKGMGR_R_OK)
 183                 {
 184                         pkgmgr_client_free(__pListeningClient);
 185                         __pListeningClient = null;
 186
 187                         if (res == PKGMGR_R_EINVAL)
 188                         {
 189                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns ARGV error");
 190                                 return E_INVALID_ARG;
 191                         }
 192                         else if (res == PKGMGR_R_ECOMM)
 193                         {
 194                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns COMM error");
 195                         }
 196                         else if (res == PKGMGR_R_ETIMEOUT)
 197                         {
 198                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns TIME_OUT error");
 199                         }
 200                         else if (res == PKGMGR_R_ERROR)
 201                         {
 202                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error");
 203                         }
 204                         else
 205                         {
 206                                 SysLog(NID_APP, "pkgmgr_client_listen_status() returns Unknown error, res = %d", res);
 207                         }
 208
 209                         return E_SYSTEM;
 210                 }
 211         }
 212
 213         _PackageManagerEvent* pEvent = new (std::nothrow) _PackageManagerEvent();
 214         SysTryReturnResult(NID_APP, pEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
 215
 216         r = pEvent->Construct();
 217         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "pEvent->Construct() failed.");
 218
 219         pEvent->__pListener = pListener;
 220
 221         r = pEvent->AddListener(*pListener, true);
 222         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "pEvent->AddListener() failed. [%s]", GetErrorMessage(r));
 223
 224         r = __packageEventListenerList.Add(pEvent);
 225         SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 226
 227         SysLog(NID_APP, "Add PackageInstallationEventListener = [0x%x]", pListener);
 228         return E_SUCCESS;
 229 }
 230
 231 result
 232 _PackageManagerImpl::RemoveEventListener(IPackageInstallationEventListener* pListener)
 233 {
 234         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 235         SysTryReturnResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 236
 237         result r = E_SUCCESS;
 238
 239         while (pEnum->MoveNext() == E_SUCCESS)
 240         {
 241                 _PackageManagerEvent*   pEvent = null;
 242                 pEnum->GetCurrent(pEvent);
 243                 if (pEvent)
 244                 {
 245                         if (pEvent->__pListener == pListener)
 246                         {
 247                                 r = __packageEventListenerList.Remove(pEvent);
 248                                 SysTryReturnResult(NID_APP, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));
 249
 250                                 delete pEvent;
 251
 252                                 SysLog(NID_APP, "Remove PackageInstallationEventListener = [0x%x]", pListener);
 253                                 return E_SUCCESS;
 254                         }
 255                 }
 256         }
 257
 258         return E_OBJ_NOT_FOUND;
 259 }
 260
 261 PackageInfo*
 262 _PackageManagerImpl::GetPackageInfoN(const PackageId& packageId) const
 263 {
 264         SysTryReturn(NID_APP, packageId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageId is empty.");
 265         SysTryReturn(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, null, E_INVALID_ARG, "packageId is invalid.(length)");
 266
 267         result r = E_SUCCESS;
 268         PackageInfo* pPackageInfo = null;
 269
 270         pPackageInfo = new (std::nothrow) PackageInfo;
 271         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
 272
 273         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
 274         r = pPackageInfoImpl->Construct(packageId);
 275         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] packageId (%ls) is not found.", packageId.GetPointer());
 276
 277         return pPackageInfo;
 278
 279 CATCH:
 280         delete pPackageInfo;
 281         return null;
 282 }
 283
 284 PackageAppInfo*
 285 _PackageManagerImpl::GetPackageAppInfoN(const AppId& appId) const
 286 {
 287         SysTryReturn(NID_APP, appId.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] appId is empty.");
 288
 289         result r = E_SUCCESS;
 290         PackageAppInfo* pPackageAppInfo = null;
 291
 292         pPackageAppInfo = new (std::nothrow) PackageAppInfo;
 293         SysTryReturn(NID_APP, pPackageAppInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageAppInfo instance must not be null.");
 294
 295         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo);
 296         r = pPackageAppInfoImpl->Construct(appId);
 297         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[E_PKG_NOT_INSTALLED] appId (%ls) is not found.", appId.GetPointer());
 298
 299         return pPackageAppInfo;
 300
 301 CATCH:
 302         delete pPackageAppInfo;
 303         return null;
 304 }
 305
 306 IList*
 307 _PackageManagerImpl::GetPackageInfoListN(void) const
 308 {
 309         result r = E_SUCCESS;
 310         int res = 0;
 311         ArrayList* pList = null;
 312
 313         pList = new (std::nothrow) ArrayList();
 314         SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
 315         pList->Construct();
 316
 317         res = pkgmgrinfo_pkginfo_get_list(PackageInfoEventHandler, pList);
 318         if (res != 0)
 319         {
 320                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_list() is failed. result = [%d]", res);
 321
 322                 pList->RemoveAll(true);
 323                 pList = null;
 324         }
 325
 326         SetLastResult(r);
 327         return pList;
 328 }
 329
 330 bool
 331 _PackageManagerImpl::IsPackageInstalled(const PackageId& packageId) const
 332 {
 333         SysTryReturn(NID_APP, packageId.IsEmpty() == false, false, E_INVALID_ARG, "packageId is empty");
 334
 335         int result = 0;
 336         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 337
 338         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 339         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
 340
 341         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 342         if (result != 0)
 343         {
 344                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
 345                 return false;
 346         }
 347
 348         if(pPackageInfoHandle)
 349         {
 350                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 351         }
 352
 353         SysLog(NID_APP, "packageId = [%ls] is installed.", packageId.GetPointer());
 354
 355         return true;
 356 }
 357
 358 result
 359 _PackageManagerImpl::InstallPackage(const PackageId& packageId, const String& packagePath, IPackageInstallationResponseListener* pListener)
 360 {
 361         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 362         SysTryReturnResult(NID_APP, packagePath.IsEmpty() == false, E_INVALID_ARG, "packagePath is empty.");
 363         SysTryReturnResult(NID_APP, File::IsFileExist(packagePath) == true, E_FILE_NOT_FOUND, "packagePath is not existed.");
 364
 365         String extension = File::GetFileExtension(packagePath);
 366         SysTryReturnResult(NID_APP, extension.IsEmpty() == false, E_INVALID_ARG, "extension is empty.");
 367
 368         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(packagePath));
 369         SysTryReturnResult(NID_APP, pPackagePath, E_OUT_OF_MEMORY, "pPackagePath is null");
 370
 371         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 372         SysTryReturnResult(NID_APP, pExtension, E_OUT_OF_MEMORY, "pExtension is null");
 373
 374         if ((strcasecmp(pExtension.get(), "tpk") == 0) || (strcasecmp(pExtension.get(), "wgt") == 0))
 375         {
 376                 SysLog(NID_APP, "packageId = [%ls], packagePath = [%s], extension = [%s]", packageId.GetPointer(), pPackagePath.get(), pExtension.get());
 377         }
 378         else
 379         {
 380                 SysLog(NID_APP, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 381                 return E_SYSTEM;
 382         }
 383
 384         result r = E_SUCCESS;
 385         _PackageManagerProxy packageManagerProxy;
 386         r = packageManagerProxy.Construct();
 387         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 388
 389         r = packageManagerProxy.InstallPackage(packageId, packagePath, null);
 390         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.InstallPackage() failed.");
 391
 392         if (__pRequestClient == null)
 393         {
 394                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 395                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 396         }
 397
 398         int res = pkgmgr_client_install(__pRequestClient, pExtension.get(), null, pPackagePath.get(), null, PM_QUIET, InstallationEventHandler, pListener);
 399
 400         if (res < PKGMGR_R_OK)
 401         {
 402                 pkgmgr_client_free(__pRequestClient);
 403                 __pRequestClient = null;
 404
 405                 if (res == PKGMGR_R_EINVAL)
 406                 {
 407                         SysLog(NID_APP, "pkgmgr_client_install() returns ARGV error");
 408                         return E_INVALID_ARG;
 409                 }
 410                 else if (res == PKGMGR_R_ECOMM)
 411                 {
 412                         SysLog(NID_APP, "pkgmgr_client_install() returns COMM error");
 413                 }
 414                 else if (res == PKGMGR_R_ETIMEOUT)
 415                 {
 416                         SysLog(NID_APP, "pkgmgr_client_install() returns TIME_OUT error");
 417                 }
 418                 else if (res == PKGMGR_R_ERROR)
 419                 {
 420                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error");
 421                 }
 422                 else
 423                 {
 424                         SysLog(NID_APP, "pkgmgr_client_install() returns Unknown error, res = %d", res);
 425                 }
 426
 427                 return E_SYSTEM;
 428         }
 429
 430         return E_SUCCESS;
 431 }
 432
 433 result
 434 _PackageManagerImpl::UninstallPackage(const PackageId& packageId, IPackageUninstallationResponseListener* pListener)
 435 {
 436         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty.");
 437         SysTryReturnResult(NID_APP, packageId.GetLength() < NATIVE_APP_MAX_APPID_LENGTH, E_INVALID_ARG, "The packageId is invalid.(length)");
 438         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 439
 440         result r = E_SUCCESS;
 441         int res = 0;
 442         char* pType = null;
 443         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
 444
 445         _PackageManagerProxy packageManagerProxy;
 446         r = packageManagerProxy.Construct();
 447         SysTryReturnResult(NID_APP, r == E_SUCCESS, E_SYSTEM, "packageManagerProxy.Construct() failed.");
 448
 449         r = packageManagerProxy.UninstallPackage(packageId, pListener);
 450         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "packageManagerProxy.UninstallPackage() failed.");
 451
 452         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 453         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 454
 455         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
 456         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 457
 458         res = pkgmgrinfo_pkginfo_get_type(pPackageInfoHandle, &pType);
 459         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 460
 461         if (__pRequestClient == null)
 462         {
 463                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 464                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 465         }
 466
 467         res = pkgmgr_client_uninstall(__pRequestClient, pType, pPackageId.get(), PM_QUIET, UninstallationEventHandler, pListener);
 468         SysLog(NID_APP, "pkgmgr_client_uninstall - req_id=[%d], packageId=[%s], type=[%s]", res, pPackageId.get(), pType);
 469
 470         if(pPackageInfoHandle)
 471         {
 472                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
 473         }
 474
 475         if (res < PKGMGR_R_OK)
 476         {
 477                 pkgmgr_client_free(__pRequestClient);
 478                 __pRequestClient = null;
 479
 480                 if (res == PKGMGR_R_EINVAL)
 481                 {
 482                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns ARGV error");
 483                         return E_INVALID_ARG;
 484                 }
 485                 else if (res == PKGMGR_R_ECOMM)
 486                 {
 487                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns COMM error");
 488                 }
 489                 else if (res == PKGMGR_R_ETIMEOUT)
 490                 {
 491                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns TIME_OUT error");
 492                 }
 493                 else if (res == PKGMGR_R_ERROR)
 494                 {
 495                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error");
 496                 }
 497                 else
 498                 {
 499                         SysLog(NID_APP, "pkgmgr_client_uninstall() returns Unknown error, res = %d", res);
 500                 }
 501
 502                 return E_SYSTEM;
 503         }
 504
 505         return E_SUCCESS;
 506 }
 507
 508 result
 509 _PackageManagerImpl::MoveToExternalStorage(const PackageId& packageId)
 510 {
 511         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 512         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 513
 514         int res = 0;
 515         char* pType = null;
 516         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 517         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 518
 519         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 520         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 521
 522         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 523         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 524
 525         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 526         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 527
 528         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 529         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 530
 531         if (storage == PMINFO_EXTERNAL_STORAGE)
 532         {
 533                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 534                 return E_INVALID_OPERATION;
 535         }
 536
 537         if (__pRequestClient == null)
 538         {
 539                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 540                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 541         }
 542
 543         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_SDCARD, PM_QUIET);
 544
 545         if(packageInfoHandle)
 546         {
 547                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 548         }
 549
 550         if (res < PKGMGR_R_OK)
 551         {
 552                 pkgmgr_client_free(__pRequestClient);
 553                 __pRequestClient = null;
 554
 555                 if (res == PKGMGR_R_EINVAL)
 556                 {
 557                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 558                         return E_INVALID_ARG;
 559                 }
 560                 else if (res == PKGMGR_R_ERROR)
 561                 {
 562                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 563                 }
 564                 else
 565                 {
 566                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 567                 }
 568
 569                 return E_SYSTEM;
 570         }
 571
 572         return E_SUCCESS;
 573 }
 574
 575 result
 576 _PackageManagerImpl::MoveToInternalStorage(const PackageId& packageId)
 577 {
 578         SysTryReturnResult(NID_APP, packageId.IsEmpty() == false, E_INVALID_ARG, "packageId is empty");
 579         SysTryReturnResult(NID_APP, IsPackageInstalled(packageId) == true, E_PKG_NOT_INSTALLED, "package is not installed.");
 580
 581         int res = 0;
 582         char* pType = null;
 583         pkgmgrinfo_installed_storage storage = PMINFO_INTERNAL_STORAGE;
 584         pkgmgrinfo_pkginfo_h packageInfoHandle = null;
 585
 586         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(packageId));
 587         SysTryReturnResult(NID_APP, pPackageId != null, E_OUT_OF_MEMORY, "pPackageId is null");
 588
 589         res = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &packageInfoHandle);
 590         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 591
 592         res = pkgmgrinfo_pkginfo_get_type(packageInfoHandle, &pType);
 593         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_type() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 594
 595         res = pkgmgrinfo_pkginfo_get_installed_storage(packageInfoHandle, &storage);
 596         SysTryReturnResult(NID_APP, res == 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_installed_storage() failed. result=[%d], packageId=[%s]", res, pPackageId.get());
 597
 598         if (storage == PMINFO_INTERNAL_STORAGE)
 599         {
 600                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_installed_storage(): storage = [%d][E_INVALID_OPERATION]", storage);
 601                 return E_INVALID_OPERATION;
 602         }
 603
 604         if (__pRequestClient == null)
 605         {
 606                 __pRequestClient = pkgmgr_client_new(PC_REQUEST);
 607                 SysTryReturnResult(NID_APP, __pRequestClient != null, E_SYSTEM, "pkgmgr_client_new(PC_REQUEST) failed");
 608         }
 609
 610         res = pkgmgr_client_move(__pRequestClient, pType, pPackageId.get(), PM_MOVE_TO_INTERNAL, PM_QUIET);
 611
 612         if(packageInfoHandle)
 613         {
 614                 pkgmgrinfo_pkginfo_destroy_pkginfo(packageInfoHandle);
 615         }
 616
 617         if (res < PKGMGR_R_OK)
 618         {
 619                 pkgmgr_client_free(__pRequestClient);
 620                 __pRequestClient = null;
 621
 622                 if (res == PKGMGR_R_EINVAL)
 623                 {
 624                         SysLog(NID_APP, "pkgmgr_client_move() returns ARGV error");
 625                         return E_INVALID_ARG;
 626                 }
 627                 else if (res == PKGMGR_R_ERROR)
 628                 {
 629                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error");
 630                 }
 631                 else
 632                 {
 633                         SysLog(NID_APP, "pkgmgr_client_move() returns Unknown error, res = %d", res);
 634                 }
 635
 636                 return E_SYSTEM;
 637         }
 638
 639         return E_SUCCESS;
 640 }
 641
 642 int
 643 _PackageManagerImpl::InstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 644 {
 645         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 646
 647         if (pData)
 648         {
 649                 IPackageInstallationResponseListener* pListener = (IPackageInstallationResponseListener*) pData;
 650
 651                 if (strcmp(pKey, "end") == 0)
 652                 {
 653                         if (strcmp(pVal, "ok") == 0)
 654                         {
 655                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_SUCCESS);
 656                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_SUCCESS)");
 657                         }
 658                         else
 659                         {
 660                                 pListener->OnPackageInstallationResponseReceived(pPackageId, PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE);
 661                                 SysLog(NID_APP, "OnPackageInstallationResponseReceived(PACKAGE_INSTALLATION_RESULT_INVALID_PACKAGE)");
 662                         }
 663
 664                         delete pListener;
 665                 }
 666                 else if (strcmp(pKey, "install_percent") == 0)
 667                 {
 668                         int progress = 0;
 669                         sscanf(pVal, "%d", &progress);
 670
 671                         pListener->OnPackageInstallationInProgressResponseReceived(pPackageId, progress);
 672                         SysLog(NID_APP, "OnPackageInstallationInProgressResponseReceived(%s, %d)", pPackageId, progress);
 673                 }
 674         }
 675
 676         return 0;
 677 }
 678
 679 int
 680 _PackageManagerImpl::UninstallationEventHandler(int reqId, const char* pType, const char* pPackageId, const char* pKey, const char* pVal, const void* pMsg, void* pData)
 681 {
 682         SysLog(NID_APP, "reqId[%d], Type[%s], PackageId[%s], Key[%s], Val[%s]", reqId, pType, pPackageId, pKey, pVal);
 683
 684         if (pData)
 685         {
 686                 if (strcmp(pKey, "end") == 0)
 687                 {
 688                         IPackageUninstallationResponseListener* pListener = (IPackageUninstallationResponseListener*) pData;
 689
 690                         if (strcmp(pVal, "ok") == 0)
 691                         {
 692                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(true)");
 693                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, true);
 694                         }
 695                         else
 696                         {
 697                                 SysLog(NID_APP, "OnPackageUninstallationResponseReceived(false)");
 698                                 pListener->OnPackageUninstallationResponseReceived(pPackageId, false);
 699                         }
 700
 701                         delete pListener;
 702                 }
 703         }
 704
 705         return 0;
 706 }
 707
 708 PackageInfo*
 709 _PackageManagerImpl::GetPackageInfoFromFileN(const String& filePath) const
 710 {
 711         SysTryReturn(NID_APP, filePath.IsEmpty() == false, null, E_INVALID_ARG, "filePath is empty.");
 712         SysTryReturn(NID_APP, File::IsFileExist(filePath) == true, null, E_FILE_NOT_FOUND, "package is not existed.");
 713
 714         String extension = File::GetFileExtension(filePath);
 715         SysTryReturn(NID_APP, extension.IsEmpty() == false, null, E_INVALID_ARG, "extension is empty.");
 716
 717         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(filePath));
 718         SysTryReturn(NID_APP, pPackagePath, null, E_OUT_OF_MEMORY, "pPackagePath is null.");
 719
 720         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 721         SysTryReturn(NID_APP, pExtension, null, E_OUT_OF_MEMORY, "pExtension is null.");
 722
 723         std::unique_ptr< PackageInfo > pPackageInfo(new (std::nothrow) PackageInfo);
 724         SysTryReturn(NID_APP, pPackageInfo, null, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
 725
 726         SysLog(NID_APP, "packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 727
 728         bool res = true;
 729
 730         if (strcasecmp(pExtension.get(), "tpk") == 0)
 731         {
 732                 _PackageParser packageParser;
 733
 734                 res = packageParser.Construct(pPackageInfo.get());
 735                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Construct() is failed. [%s]", pPackagePath.get());
 736
 737                 res = packageParser.Parse(filePath);
 738                 SysTryReturn(NID_APP, res, null, E_PARSING_FAILED, "Parse() is failed. [%s]", pPackagePath.get());
 739         }
 740         else if (strcasecmp(pExtension.get(), "wgt") == 0)
 741         {
 742                 pkgmgr_info* pPkgmgrInfo = null;
 743
 744                 pPkgmgrInfo = pkgmgr_client_check_pkginfo_from_file(pPackagePath.get());
 745                 SysTryReturn(NID_APP, pPkgmgrInfo, null, E_PARSING_FAILED, "pkgmgr_client_check_pkginfo_from_file(%s) is failed.", pPackagePath.get());
 746
 747                 _package_manager_pkg_detail_info_t* pPkgInfo = (_package_manager_pkg_detail_info_t*) pPkgmgrInfo;
 748                 _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
 749
 750                 SysLog(NID_APP, "id(%s), version(%s), label(%s), description(%s), author(%s)", pPkgInfo->pkgid, pPkgInfo->version, pPkgInfo->label, pPkgInfo->pkg_description, pPkgInfo->author);
 751
 752                 pPackageInfoImpl->SetType(PACKAGE_TYPE_WGT);
 753                 pPackageInfoImpl->SetId(pPkgInfo->pkgid);
 754                 pPackageInfoImpl->SetVersion(pPkgInfo->version);
 755                 pPackageInfoImpl->SetDisplayName(pPkgInfo->label);
 756                 pPackageInfoImpl->SetDescription(pPkgInfo->pkg_description);
 757                 pPackageInfoImpl->SetAuthor(pPkgInfo->author);
 758                 // icon
 759                 // privilege
 760
 761                 pkgmgr_client_free_pkginfo(pPkgmgrInfo);
 762         }
 763         else
 764         {
 765                 SysTryReturn(NID_APP, false, null, E_UNSUPPORTED_FORMAT, "invalid extension! - packagePath = [%s], extension = [%s]", pPackagePath.get(), pExtension.get());
 766         }
 767
 768         return pPackageInfo.release();
 769 }
 770
 771 IList*
 772 _PackageManagerImpl::GetPackageInfoListN(const IMap& packageFilterMap) const
 773 {
 774         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap.GetCount() is invalid.");
 775
 776         return null;
 777 }
 778
 779 IList*
 780 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageAppFilterMap) const
 781 {
 782         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 783
 784         std::unique_ptr<IMapEnumerator> pEnum(packageAppFilterMap.GetMapEnumeratorN());
 785         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 786
 787         int res = 0;
 788         ArrayList* pList = null;
 789         pkgmgrinfo_appinfo_filter_h handle = null;
 790
 791         res = pkgmgrinfo_appinfo_filter_create(&handle);
 792         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_appinfo_filter_create() is failed. [%d]", res);
 793
 794         while(pEnum->MoveNext() == E_SUCCESS)
 795         {
 796                 String* pKey = static_cast<String*>(pEnum->GetKey());
 797                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 798
 799                 if ((*pKey) == PACKAGE_APP_FILTER_MENUICON_VISIBLE)
 800                 {
 801                         Boolean* pVal = static_cast<Boolean*>(pEnum->GetValue());
 802                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 803
 804                         bool nodisplay = !(pVal->ToBool());
 805                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), nodisplay);
 806
 807                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, nodisplay);
 808                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(NODISPLAY, %d) is failed. [%d]", nodisplay, res);
 809                 }
 810                 else if ((*pKey) == PACKAGE_APP_FILTER_CATEGORY)
 811                 {
 812                         String* pVal = static_cast<String*>(pEnum->GetValue());
 813                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 814
 815                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
 816
 817                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 818                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 819
 820                         res = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, pValue.get());
 821                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_add_string(CATEGORY, %s) is failed. [%d]", pValue.get(), res);
 822                 }
 823                 else
 824                 {
 825                         SysTryCatch(NID_APP, false, , E_INVALID_ARG, "Invalid key(%ls)", pKey->GetPointer());
 826                 }
 827         }
 828
 829         pList = new (std::nothrow) ArrayList();
 830         SysTryCatch(NID_APP, pList, , E_OUT_OF_MEMORY, "ArrayList creation failure.");
 831         pList->Construct();
 832
 833         res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, pList);
 834         if (res != 0)
 835         {
 836                 SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
 837
 838                 pList->RemoveAll(true);
 839                 pList = null;
 840         }
 841
 842 CATCH:
 843         if (handle)
 844         {
 845                 pkgmgrinfo_appinfo_filter_destroy(handle);
 846         }
 847
 848         return pList;
 849 }
 850
 851 IList*
 852 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageFilterMap, const IMap& packageAppFilterMap) const
 853 {
 854         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap.GetCount() is invalid.");
 855         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 856
 857         return null;
 858 }
 859
 860 int
 861 _PackageManagerImpl::PackageAppInfoHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
 862 {
 863         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
 864         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
 865
 866         result r = E_SUCCESS;
 867         int res = PMINFO_R_OK;
 868         char* pAppId = null;
 869         ArrayList* pList = (ArrayList*)pUserData;
 870
 871         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
 872         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
 873
 874         std::unique_ptr<PackageAppInfo> pPackageAppInfo(new (std::nothrow) PackageAppInfo);
 875         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
 876
 877         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
 878         r = pPackageAppInfoImpl->Construct(pAppId);
 879         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
 880
 881         pList->Add(*pPackageAppInfo.release());
 882
 883         return 0;
 884 }
 885
 886 _PackageManagerImpl*
 887 _PackageManagerImpl::GetInstance(void)
 888 {
 889         return PackageManager::GetInstance()->__pPackageManagerImpl;
 890 }
 891
 892 result
 893 _PackageManagerImpl::Construct(void)
 894 {
 895         ClearLastResult();
 896
 897         result r = __installationList.Construct();
 898         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
 899
 900         return E_SUCCESS;
 901 }
 902
 903 _PackageManagerImpl::_PackageManagerImpl(void)
 904 :__pRequestClient(null),
 905 __pListeningClient(null),
 906 __pDb(null)
 907 {
 908         CreatePackageTables();
 909 }
 910
 911 _PackageManagerImpl::~_PackageManagerImpl(void)
 912 {
 913 }
 914
 915 void
 916 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
 917 {
 918         result r = E_SUCCESS;
 919         bool install = true;
 920
 921         if (strcmp(pEventKey, "start") == 0)
 922         {
 923                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
 924                 {
 925                         String* pAppId = new (std::nothrow) String(packageId);
 926                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
 927
 928                         String* pOperation = new (std::nothrow) String(pEventValue);
 929                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
 930
 931                         r = __installationList.Add(*pAppId, *pOperation);
 932                         if (IsFailed(r))
 933                         {
 934                                 delete pAppId;
 935                                 delete pOperation;
 936                                 SysLog(NID_APP, "Failed to add installation condition.");
 937                                 SetLastResult(E_SYSTEM);
 938                                 return;
 939                         }
 940                 }
 941         }
 942         else if (strcmp(pEventKey, "end") == 0)
 943         {
 944                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
 945                 if (pOperation)
 946                 {
 947                         if (pOperation->Equals("uninstall", true) == true)
 948                         {
 949                                 install = false;
 950                         }
 951
 952                         r = __installationList.Remove(packageId, true);
 953                         if (IsFailed(r))
 954                         {
 955                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
 956                         }
 957                 }
 958         }
 959
 960         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
 961         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
 962
 963         while (pEnum->MoveNext() == E_SUCCESS)
 964         {
 965                 _PackageManagerEvent*   pEvent = null;
 966                 pEnum->GetCurrent(pEvent);
 967                 if (pEvent)
 968                 {
 969                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
 970                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
 971
 972                         String eventKey(pEventKey);
 973                         String eventValue(pEventValue);
 974
 975                         pEventArg->__packageId = packageId;
 976                         pEventArg->__eventKey = eventKey;
 977                         pEventArg->__eventValue = eventValue;
 978                         pEventArg->__install = install;
 979
 980                         r = pEvent->Fire(*pEventArg);
 981                         if (r != E_SUCCESS)
 982                         {
 983                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
 984                         }
 985
 986                         SysLog(NID_APP, "PackageId = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
 987                 }
 988                 else
 989                 {
 990                         SysLog(NID_APP, "pEvent is null.");
 991                 }
 992         }
 993 }
 994
 995 PackageInfo*
 996 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
 997 {
 998         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
 999
1000         result r = E_SUCCESS;
1001         Database db;
1002         DbStatement* pStmt = null;
1003         DbEnumerator* pEnum = null;
1004         String query;
1005         PackageInfo *pPackageInfo = null;
1006
1007         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());
1008
1009         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1010         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1011
1012         pStmt = CreateStatementN(db, query);
1013
1014         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1015
1016         pEnum = ExecuteStatementN(db, pStmt);
1017         if (pEnum != null)
1018         {
1019                 if (pEnum->MoveNext() == E_SUCCESS)
1020                 {
1021                         pPackageInfo = new (std::nothrow) PackageInfo;
1022                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1023
1024                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1025
1026                         String id;
1027                         String appVersion;
1028                         String appType;
1029                         String appMimeType;
1030                         String appApiVersion;
1031                         String appName;
1032                         String appVendor;
1033                         String appDescription;
1034                         String appUrl;
1035                         String appCid;
1036                         String appRootPath;
1037                         int appStorageType = 0;
1038                         DateTime appInstallationTime;
1039                         String appIconPath;
1040
1041                         pEnum->GetStringAt(1, id);
1042                         pEnum->GetStringAt(3, appVersion);
1043                         pEnum->GetStringAt(4, appType);
1044                         pEnum->GetStringAt(5, appMimeType);
1045                         pEnum->GetStringAt(6, appApiVersion);
1046                         pEnum->GetStringAt(7, appName);
1047                         pEnum->GetStringAt(8, appVendor);
1048                         pEnum->GetStringAt(9, appDescription);
1049                         pEnum->GetStringAt(10, appUrl);
1050                         pEnum->GetStringAt(11, appCid);
1051                         pEnum->GetStringAt(16, appRootPath);
1052                         pEnum->GetIntAt(17, appStorageType);
1053                         pEnum->GetDateTimeAt(18, appInstallationTime);
1054                         pEnum->GetStringAt(21, appIconPath);
1055
1056                         pPackageInfoImpl->SetAppId(id);
1057                         pPackageInfoImpl->SetAppVersion(appVersion);
1058                         pPackageInfoImpl->SetAppMimeType(appMimeType);
1059                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
1060                         pPackageInfoImpl->SetAppName(appName);
1061                         pPackageInfoImpl->SetAppVendor(appVendor);
1062                         pPackageInfoImpl->SetAppDescription(appDescription);
1063                         pPackageInfoImpl->SetAppUrl(appUrl);
1064                         pPackageInfoImpl->SetAppCid(appCid);
1065                         pPackageInfoImpl->SetAppRootPath(appRootPath);
1066                         pPackageInfoImpl->SetAppStorageType(appStorageType);
1067                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
1068                         pPackageInfoImpl->SetAppIconPath(appIconPath);
1069                 }
1070
1071                 delete pEnum;
1072         }
1073         else
1074         {
1075                 r = E_OBJ_NOT_FOUND;
1076         }
1077
1078 CATCH:
1079         delete pStmt;
1080         return pPackageInfo;
1081 }
1082
1083 int
1084 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1085 {
1086         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
1087
1088         int result = 0;
1089         char* pPackage = null;
1090         ArrayList* pList = (ArrayList*)pUserData;
1091
1092         PackageInfo *pPackageInfo = new (std::nothrow) PackageInfo;
1093         SysTryReturn(NID_APP, pPackageInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1094
1095         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1096
1097         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
1098         if (result == 0)
1099         {
1100                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1101         }
1102         else
1103         {
1104                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1105         }
1106
1107         pPackageInfoImpl->Construct(pPackage);
1108         pList->Add(*pPackageInfo);
1109
1110         return result;
1111 }
1112
1113 IList*
1114 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
1115 {
1116         result r = E_SUCCESS;
1117         Database db;
1118         DbStatement* pStmt = null;
1119         DbEnumerator* pEnum = null;
1120         String query;
1121         ArrayList* pList = null;
1122
1123         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());
1124
1125         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1126         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1127
1128         pStmt = CreateStatementN(db, query);
1129         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1130
1131         pEnum = ExecuteStatementN(db, pStmt);
1132
1133         if (pEnum != null)
1134         {
1135                 pList = new (std::nothrow) ArrayList();
1136                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1137                 pList->Construct();
1138
1139                 while (pEnum->MoveNext() == E_SUCCESS)
1140                 {
1141                         String* pPackageName = new (std::nothrow) String;
1142                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1143
1144                         pEnum->GetStringAt(0, *pPackageName);
1145
1146                         pList->Add(*pPackageName);
1147                 }
1148
1149                 delete pEnum;
1150
1151         }
1152         else
1153         {
1154                 r = E_OBJ_NOT_FOUND;
1155         }
1156
1157 CATCH:
1158         delete pStmt;
1159         return pList;
1160 }
1161
1162 IList*
1163 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
1164 {
1165         result r = E_SUCCESS;
1166         Database db;
1167         DbStatement* pStmt = null;
1168         DbEnumerator* pEnum = null;
1169         String query;
1170         ArrayList* pList = null;
1171
1172         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());
1173
1174         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1175         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1176
1177         pStmt = CreateStatementN(db, query);
1178         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1179
1180         pEnum = ExecuteStatementN(db, pStmt);
1181
1182         if (pEnum != null)
1183         {
1184                 pList = new (std::nothrow) ArrayList();
1185                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1186                 pList->Construct();
1187
1188                 while (pEnum->MoveNext() == E_SUCCESS)
1189                 {
1190                         String* pPackageName = new (std::nothrow) String;
1191                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1192
1193                         String* pAccess = new (std::nothrow) String;
1194                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1195
1196                         pEnum->GetStringAt(0, *pPackageName);
1197                         pList->Add(*pPackageName);
1198
1199                         pEnum->GetStringAt(1, *pAccess);
1200                         pList->Add(*pAccess);
1201                 }
1202
1203                 delete pEnum;
1204
1205         }
1206         else
1207         {
1208                 r = E_OBJ_NOT_FOUND;
1209         }
1210
1211 CATCH:
1212         delete pStmt;
1213         return pList;
1214 }
1215
1216 IMap*
1217 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1218 {
1219         result r = E_SUCCESS;
1220         Database db;
1221         DbStatement* pStmt = null;
1222         DbEnumerator* pEnum = null;
1223         String query;
1224         HashMap* pList = null;
1225
1226         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')"
1227                         , packageId.GetPointer());
1228
1229         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1230         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1231
1232         pStmt = CreateStatementN(db, query);
1233         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1234
1235         pEnum = ExecuteStatementN(db, pStmt);
1236
1237         if (pEnum != null)
1238         {
1239                 pList = new (std::nothrow) HashMap();
1240                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1241                 pList->Construct();
1242
1243                 while (pEnum->MoveNext() == E_SUCCESS)
1244                 {
1245                         String* pName = new (std::nothrow) String;
1246                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1247
1248                         String* pValue = new (std::nothrow) String;
1249                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1250
1251                         pEnum->GetStringAt(0, *pName);
1252                         pEnum->GetStringAt(1, *pValue);
1253
1254                         pList->Add(*pName, *pValue);
1255                 }
1256
1257                 delete pEnum;
1258
1259         }
1260         else
1261         {
1262                 r = E_OBJ_NOT_FOUND;
1263         }
1264
1265 CATCH:
1266         delete pStmt;
1267         return pList;
1268 }
1269
1270 bool
1271 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1272 {
1273         if (appId == _AppInfo::GetPackageId())
1274         {
1275                 return true;
1276         }
1277
1278         int result = 0;
1279         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1280
1281         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1282         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1283
1284         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1285         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
1286
1287         if(pPackageInfoHandle)
1288         {
1289                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1290         }
1291
1292         return true;
1293 }
1294
1295 int
1296 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1297                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1298 {
1299         SysLog(NID_APP, "PackageEventHandler - req_id: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1300                                 pkg_name, key, val);
1301
1302         PackageType type = PACKAGE_TYPE_TPK;
1303         PackageId packageId(pkg_name);
1304
1305         if (strcmp(pkg_type, "tpk") == 0)
1306         {
1307                 type = PACKAGE_TYPE_TPK;
1308         }
1309         else if (strcmp(pkg_type, "wgt") == 0)
1310         {
1311                 type = PACKAGE_TYPE_WGT;
1312         }
1313         else
1314         {
1315                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1316                 return 0;
1317         }
1318
1319         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1320         pThis->SendPackageEvent(type, packageId, key, val);
1321
1322         return 0;
1323 }
1324
1325 String*
1326 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1327 {
1328         result r = E_SUCCESS;
1329         Database db;
1330         DbStatement* pStmt = null;
1331         DbEnumerator* pEnum = null;
1332         String query;
1333         String* pAppId = null;
1334
1335         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, DataControl WHERE DataControl.PROVIDER_ID = '%ls' and DataControl.ID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID",
1336                         providerId.GetPointer());
1337
1338         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1339         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1340
1341         pStmt = CreateStatementN(db, query);
1342         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1343
1344         pEnum = ExecuteStatementN(db, pStmt);
1345
1346         if (pEnum != null)
1347         {
1348                 if (pEnum->MoveNext() == E_SUCCESS)
1349                 {
1350                         pAppId = new (std::nothrow) String;
1351                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1352
1353                         pEnum->GetStringAt(0, *pAppId);
1354                 }
1355
1356                 delete pEnum;
1357         }
1358
1359 CATCH:
1360         delete pStmt;
1361         return pAppId;
1362 }
1363
1364 result
1365 _PackageManagerImpl::CreatePackageTables(void)
1366 {
1367         result r = E_SUCCESS;
1368         Database db;
1369         String createQuery;
1370
1371         if (File::IsFileExist(PACKAGE_DATABASE_FILE_NAME) == true)
1372         {
1373                 SysLog(NID_APP, ".app-package.db is already existed!");
1374                 return r;
1375         }
1376
1377         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, true);
1378         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.Construct is failed. [%s]", GetErrorMessage(r));
1379
1380         // PkgInfo
1381         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgInfo"
1382                                                          "( UNIQUE_ID                                   INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1383                                                          "PKG_ID                        TEXT,"
1384                                                          "PKG_SECRET                    TEXT,"
1385                                                          "PKG_VERSION                   TEXT,"
1386                                                          "PKG_TYPE                  TEXT,"
1387                                                          "PKG_MIMETYPE              TEXT,"
1388                                                          "PKG_APIVERSION                TEXT,"
1389                                                          "PKG_NAME                  TEXT,"
1390                                                          "PKG_VENDOR                    TEXT,"
1391                                                          "PKG_DESCRIPTION           TEXT,"
1392                                                          "PKG_URL                       TEXT,"
1393                                                          "PKG_CID                       TEXT,"
1394                                                          "PKG_READONLY_SIZE             INTEGER,"
1395                                                          "PKG_DATA_SIZE                 INTEGER,"
1396                                                          "PKG_PARENT_ID                         TEXT,"
1397                                                          "PKG_ATTRIBUTE                         INTEGER,"
1398                                                          "PKG_ROOTPATH              TEXT,"
1399                                                          "PKG_STORAGE_TYPE          INTEGER,"
1400                                                          "PKG_INSTALLATION_DATE         TEXT,"
1401                                                          "PKG_STATE                     INTEGER,"
1402                                                          "PKG_INITIATOR                 INTEGER )");
1403         r = db.ExecuteSql(createQuery, true);
1404         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1405         createQuery.Clear();
1406
1407         // PkgPrivileges
1408         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgPrivileges"
1409                                                          "( ID                          INTEGER,"
1410                                                          "PRIVILEGES                                    TEXT,"
1411                                                          "HMAC_PPRIVILEGES                      TEXT,"
1412                                                          "CERTIFICATE_TYPE              INTEGER,"
1413                                                      "STR_PRIVILEGES            TEXT )");
1414         r = db.ExecuteSql(createQuery, true);
1415         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1416         createQuery.Clear();
1417
1418         // PkgIntegrity
1419         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgIntegrity"
1420                                                          "( ID                          INTEGER,"
1421                                                          "HMAC_APPID                                    TEXT,"
1422                                                          "HMAC_APPSECRET                                TEXT,"
1423                                                          "HMAC_HTB                                              TEXT,"
1424                                                          "SLOT_NUM                              INTEGER )");
1425         r = db.ExecuteSql(createQuery, true);
1426         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1427         createQuery.Clear();
1428
1429         // AppInfo
1430         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppInfo"
1431                                                          "( UNIQUE_ID                                   INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1432                                                          "ID                            INTEGER,"
1433                                                          "APP_NAME                  TEXT,"
1434                                                          "APP_TYPE                  TEXT,"
1435                                                          "APP_DEFAULT                   TEXT,"
1436                                                          "APP_MAINMENU_ICON             TEXT,"
1437                                                          "APP_SETTING_ICON          TEXT,"
1438                                                          "APP_TICKER_ICON                               TEXT,"
1439                                                          "APP_QUICKPANEL_ICON                   TEXT,"
1440                                                          "APP_LAUNCHIMAGE_ICON      TEXT,"
1441                                                          "APP_FEATURE               INTEGER,"
1442                                                          "PACKAGE_NAME              TEXT )");
1443         r = db.ExecuteSql(createQuery, true);
1444         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1445         createQuery.Clear();
1446
1447         // Notification
1448         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS Notification"
1449                                                          "( ID                          INTEGER,"
1450                                                          "NAME                      TEXT,"
1451                                                          "VALUE                     TEXT )");
1452         r = db.ExecuteSql(createQuery, true);
1453         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1454         createQuery.Clear();
1455
1456         // AppFeature
1457         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppFeature"
1458                                                          "( ID                          INTEGER,"
1459                                                          "NAME                      TEXT,"
1460                                                          "VALUE                     TEXT )");
1461         r = db.ExecuteSql(createQuery, true);
1462         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1463         createQuery.Clear();
1464
1465         // LaunchCondition
1466         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS LaunchCondition"
1467                                                          "( ID                          INTEGER,"
1468                                                          "NAME                      TEXT,"
1469                                                          "VALUE                     TEXT )");
1470         r = db.ExecuteSql(createQuery, true);
1471         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1472         createQuery.Clear();
1473
1474         // DataControl
1475         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS DataControl"
1476                                                          "( ID INTEGER,"
1477                                                          "PROVIDER_ID TEXT,"
1478                                                          "TYPE TEXT,"
1479                                                          "ACCESS TEXT )");
1480         r = db.ExecuteSql(createQuery, true);
1481         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1482         createQuery.Clear();
1483
1484         // Capability
1485         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS Capability"
1486                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1487                                                          "OPERATION_ID                          TEXT )");
1488         r = db.ExecuteSql(createQuery, true);
1489         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1490         createQuery.Clear();
1491
1492         // ResolutionUriScheme
1493         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS ResolutionUriScheme"
1494                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1495                                                          "URI_SCHEME                            TEXT )");
1496         r = db.ExecuteSql(createQuery, true);
1497         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1498         createQuery.Clear();
1499
1500         // ResolutionMimeType
1501         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS ResolutionMimeType"
1502                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1503                                                          "MIME_TYPE                             TEXT )");
1504         r = db.ExecuteSql(createQuery, true);
1505         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1506         createQuery.Clear();
1507
1508         // AppControl
1509         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppControl"
1510                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1511                                                          "PROVIDER_ID                   TEXT,"
1512                                                          "CATEGORY                                      TEXT )");
1513         r = db.ExecuteSql(createQuery, true);
1514         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1515         createQuery.Clear();
1516
1517         // AppInfoLookup
1518         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppInfoLookup"
1519                                                          "( AppInfoID                   INTEGER,"
1520                                                          "CapabilityID              INTEGER,"
1521                                                          "ResolutionUriSchemeID         INTEGER,"
1522                                                          "ResolutionMimeTypeID      INTEGER,"
1523                                                          "AppControlID                              INTEGER )");
1524         r = db.ExecuteSql(createQuery, true);
1525         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1526         createQuery.Clear();
1527
1528         return r;
1529 }
1530
1531 result
1532 _PackageManagerImpl::RegisterPackageInfo(_PackageInfoImpl& pkgInfoImpl)
1533 {
1534         result r = E_SUCCESS;
1535         Database db;
1536         DbStatement* pStmt = null;
1537         DbEnumerator* pEnum = null;
1538         String query;
1539         String privileges;
1540         String hmacPrivileges;
1541         PackageInfo packageInfo;
1542         int uniqueId = 0;
1543
1544         SysLog(NID_APP, "_PackageManagerImpl::RegisterPackageInfo()");
1545
1546         query.Format(
1547                 1024, L"INSERT INTO PkgInfo "
1548                           "(PKG_ID, PKG_SECRET, PKG_VERSION, PKG_TYPE, PKG_MIMETYPE, PKG_APIVERSION, PKG_NAME, PKG_VENDOR, PKG_DESCRIPTION, PKG_URL, PKG_CID, PKG_READONLY_SIZE, PKG_DATA_SIZE, PKG_PARENT_ID,"
1549                           " PKG_ATTRIBUTE, PKG_ROOTPATH, PKG_STORAGE_TYPE, PKG_INSTALLATION_DATE, PKG_STATE, PKG_INITIATOR) "
1550                           "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
1551
1552         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1553         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1554
1555         pStmt = CreateStatementN(db, query);
1556         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1557
1558         PackageId packageId = pkgInfoImpl.GetAppId();
1559         String appVersion = pkgInfoImpl.GetAppVersion();
1560         String type = pkgInfoImpl.GetAppType();
1561         String appMimeType = pkgInfoImpl.GetAppMimeType();
1562         String appApiVersion = pkgInfoImpl.GetAppApiVersion();
1563         String appName = pkgInfoImpl.GetAppName();
1564         String appVendor = pkgInfoImpl.GetAppVendor();
1565         String appDescription = pkgInfoImpl.GetAppDescription();
1566         String appUrl = pkgInfoImpl.GetAppUrl();
1567         String appCid = pkgInfoImpl.GetAppCid();
1568
1569         pkgInfoImpl.GetPrivilegesValue(privileges, hmacPrivileges);
1570         String appRootPath = pkgInfoImpl.GetAppRootPath();
1571         int appStorageType = pkgInfoImpl.GetAppStorageType();
1572         int certType = pkgInfoImpl.GetCertType();
1573         ArrayList* pAppInfoImplList = pkgInfoImpl.GetAppInfoList();
1574
1575         DateTime time;
1576         r = SystemTime::GetCurrentTime(time);
1577         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "An error occurs while getting a current time.");
1578
1579         if (!packageId.IsEmpty())
1580         {
1581                 r = pStmt->BindString(0, packageId);
1582                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1583         }
1584
1585         if (!appVersion.IsEmpty())
1586         {
1587                 r = pStmt->BindString(2, appVersion);
1588                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1589         }
1590
1591         if (!type.IsEmpty())
1592         {
1593                 r = pStmt->BindString(3, type);
1594                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1595         }
1596
1597         if (!appMimeType.IsEmpty())
1598         {
1599                 r = pStmt->BindString(4, appMimeType);
1600                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1601         }
1602
1603         if (!appApiVersion.IsEmpty())
1604         {
1605                 r = pStmt->BindString(5, appApiVersion);
1606                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1607         }
1608
1609         if (!appName.IsEmpty())
1610         {
1611                 r = pStmt->BindString(6, appName);
1612                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1613         }
1614
1615         if (!appVendor.IsEmpty())
1616         {
1617                 r = pStmt->BindString(7, appVendor);
1618                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1619         }
1620
1621         if (!appDescription.IsEmpty())
1622         {
1623                 r = pStmt->BindString(8, appDescription);
1624                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1625         }
1626
1627         if (!appUrl.IsEmpty())
1628         {
1629                 r = pStmt->BindString(9, appUrl);
1630                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1631         }
1632
1633         if (!appCid.IsEmpty())
1634         {
1635                 r = pStmt->BindString(10, appCid);
1636                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1637         }
1638
1639         if (!appRootPath.IsEmpty())
1640         {
1641                 r = pStmt->BindString(15, appRootPath);
1642                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1643         }
1644
1645         if (appStorageType != 0)
1646         {
1647                 r = pStmt->BindInt(16, appStorageType);
1648                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1649         }
1650
1651         r = pStmt->BindDateTime(17, time);
1652         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1653
1654         pEnum = ExecuteStatementN(db, pStmt);
1655
1656         r = GetLastResult();
1657
1658         uniqueId = pkgInfoImpl.GetUniqueId();
1659
1660         SysLog(NID_APP, "_PackageManagerImpl::RegisterPackageInfo()-GetUniqueId(%d)", uniqueId);
1661
1662         __pDb = &db;
1663
1664         // AppInfo
1665         RegisterAppInfoList(uniqueId, pAppInfoImplList);
1666
1667         // PkgPrivileges
1668         RegisterPrivileges(uniqueId, privileges, hmacPrivileges, certType);
1669
1670 CATCH:
1671         __pDb = null;
1672         delete pEnum;
1673         delete pStmt;
1674         return r;
1675 }
1676
1677 result
1678 _PackageManagerImpl::UnregisterPackageInfo(const PackageId& packageId)
1679 {
1680         SysLog(NID_APP, "packageId = [%ls]", packageId.GetPointer());
1681
1682         result r = E_SUCCESS;
1683         Database db;
1684         String query;
1685         int id = 0;
1686         PackageInfo* pPkgInfo;
1687         _PackageInfoImpl* pPackageInfoImpl = null;
1688         ArrayList* pList = null;
1689
1690         pPkgInfo = GetPackageInfoN(packageId);
1691         SysTryReturn(NID_APP, pPkgInfo != null, r, r, "UnregisterPackageInfo: GetUniqueId() is invalid. [%d]", id);
1692
1693         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1694         pPackageInfoImpl->SetAppId(packageId);
1695         id = pPackageInfoImpl->GetUniqueId();
1696         SysTryReturn(NID_APP, id > 0, r, r, "UnregisterPackageInfo: GetUniqueId() is invalid. [%d]", id);
1697
1698         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1699         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.Construct is failed. [%s]", GetErrorMessage(r));
1700
1701         // AppInfoLookup
1702         pList = pPackageInfoImpl->GetAppInfoListN();
1703         if (pList != null)
1704         {
1705                 for (int i = 0; i < pList->GetCount(); i++)
1706                 {
1707                         _PackageAppInfoImpl* pAppInfoImpl = dynamic_cast <_PackageAppInfoImpl*>(pList->GetAt(i));
1708
1709                         if (pAppInfoImpl != null)
1710                         {
1711                                 int uniqueId = 0;
1712                                 uniqueId = pAppInfoImpl->GetUniqueId();
1713
1714                                 query.Format(1024, L"DELETE FROM AppInfoLookup WHERE AppInfoID = %d", uniqueId);
1715                                 r = db.ExecuteSql(query, true);
1716                                 SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1717                                 query.Clear();
1718                         }
1719                 }
1720                 delete pList;
1721         }
1722
1723         // PkgInfo
1724         query.Format(1024, L"DELETE FROM PkgInfo WHERE PKG_ID = '%ls'", packageId.GetPointer());
1725         r = db.ExecuteSql(query, true);
1726         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1727         query.Clear();
1728
1729         // AppInfo
1730         query.Format(1024, L"DELETE FROM AppInfo WHERE ID = %d", id);
1731         r = db.ExecuteSql(query, true);
1732         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1733         query.Clear();
1734
1735         // PkgPrivileges
1736         query.Format(1024, L"DELETE FROM PkgPrivileges WHERE ID = %d", id);
1737         r = db.ExecuteSql(query, true);
1738         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1739         query.Clear();
1740
1741         // DataControl
1742         query.Format(1024, L"DELETE FROM DataControl WHERE ID = %d", id);
1743         r = db.ExecuteSql(query, true);
1744         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1745         query.Clear();
1746
1747         delete pPkgInfo;
1748         return r;
1749 }
1750
1751 PackageInfo*
1752 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1753 {
1754         result r = E_SUCCESS;
1755         PackageInfo* pPkgInfo = null;
1756         Database db;
1757         DbStatement* pStmt = null;
1758         DbEnumerator* pEnum = null;
1759         String query;
1760
1761         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1762                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1763                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1764                         "GROUP BY AppInfoID"
1765                         , providerId.GetPointer(), operationId.GetPointer());
1766
1767         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1768         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1769
1770         pStmt = CreateStatementN(db, query);
1771         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1772
1773         pEnum = ExecuteStatementN(db, pStmt);
1774         if (pEnum != null)
1775         {
1776                 if (pEnum->MoveNext() == E_SUCCESS)
1777                 {
1778                         PackageId packageId;
1779                         pEnum->GetStringAt(0, packageId);
1780
1781                         pPkgInfo = GetPackageInfoN(packageId);
1782                 }
1783
1784                 delete pEnum;
1785         }
1786         else
1787         {
1788                 r = E_OBJ_NOT_FOUND;
1789         }
1790
1791 CATCH:
1792         delete pStmt;
1793         return pPkgInfo;
1794 }
1795
1796 result
1797 _PackageManagerImpl::GetAppInfo(int uniqueId, _PackageAppInfoImpl& appInfo) const
1798 {
1799         result r = E_SUCCESS;
1800         Database db;
1801         DbStatement* pStmt = null;
1802         DbEnumerator* pEnum = null;
1803         String query;
1804
1805         query.Format(1024, L"SELECT * FROM AppInfo WHERE UNIQUE_ID = %d", uniqueId);
1806
1807         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1808         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1809
1810         pStmt = CreateStatementN(db, query);
1811         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1812
1813         pEnum = ExecuteStatementN(db, pStmt);
1814         if (pEnum != null)
1815         {
1816                 if (pEnum->MoveNext() == E_SUCCESS)
1817                 {
1818                         int uniqueId = 0;
1819                         int pkgId = 0;
1820                         String name;
1821                         String defaultapp;
1822                         String mainmenuIcon;
1823                         String settingIcon;
1824                         String tickerIcon;
1825                         String quickpanelIcon;
1826                         String launchImageIcon;
1827                         int appFeature = 0;
1828                         String packageName;
1829
1830                         pEnum->GetIntAt(0, uniqueId);
1831                         pEnum->GetIntAt(1, pkgId);
1832                         pEnum->GetStringAt(2, name);
1833                         pEnum->GetStringAt(3, defaultapp);
1834                         pEnum->GetStringAt(4, mainmenuIcon);
1835                         pEnum->GetStringAt(5, settingIcon);
1836                         pEnum->GetStringAt(7, quickpanelIcon);
1837                         pEnum->GetIntAt(9, appFeature);
1838                         pEnum->GetStringAt(10, packageName);
1839
1840                         appInfo.SetUniqueId(uniqueId);
1841                         appInfo.SetPkgId(pkgId);
1842                         appInfo.SetName(name);
1843                         appInfo.SetDefault(defaultapp);
1844                         appInfo.SetMainmenuIcon(mainmenuIcon);
1845                         appInfo.SetSettingIcon(settingIcon);
1846                         appInfo.SetQuickpanelIcon(quickpanelIcon);
1847                         appInfo.SetAppFeature(appFeature);
1848                         appInfo.SetPackageName(packageName);
1849                 }
1850
1851                 delete pEnum;
1852         }
1853         else
1854         {
1855                 r = E_OBJ_NOT_FOUND;
1856         }
1857
1858 CATCH:
1859         delete pStmt;
1860         return r;
1861 }
1862
1863 ArrayList*
1864 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1865 {
1866         result r = E_SUCCESS;
1867         Database db;
1868         DbStatement* pStmt = null;
1869         DbEnumerator* pEnum = null;
1870         String query;
1871         //int id = 0;
1872         PackageInfo* pPkgInfo = null;
1873         _PackageInfoImpl* pPackageInfoImpl = null;
1874         ArrayList* pList = null;
1875
1876         pPkgInfo = GetPackageInfoN(packageId);
1877         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1878
1879         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1880         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1881
1882         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1883         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1884
1885         pStmt = CreateStatementN(db, query);
1886         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1887                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1888
1889         pEnum = ExecuteStatementN(db, pStmt);
1890
1891         if (pEnum != null)
1892         {
1893                 pList = new (std::nothrow) ArrayList;
1894                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
1895
1896                 pList->Construct();
1897
1898                 while (pEnum->MoveNext() == E_SUCCESS)
1899                 {
1900                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
1901                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
1902
1903                         int uniqueId = 0;
1904                         int pkgId = 0;
1905                         String name;
1906                         String defaultapp;
1907                         String mainmenuIcon;
1908                         String settingIcon;
1909                         String quickpanelIcon;
1910                         int appFeature = 0;
1911                         String packageName;
1912
1913                         pEnum->GetIntAt(0, uniqueId);
1914                         pEnum->GetIntAt(1, pkgId);
1915                         pEnum->GetStringAt(2, name);
1916                         pEnum->GetStringAt(3, defaultapp);
1917                         pEnum->GetStringAt(4, mainmenuIcon);
1918                         pEnum->GetStringAt(5, settingIcon);
1919                         pEnum->GetStringAt(7, quickpanelIcon);
1920                         pEnum->GetIntAt(9, appFeature);
1921                         pEnum->GetStringAt(10, packageName);
1922
1923                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
1924                         pPackageAppInfoImpl->SetPkgId(pkgId);
1925                         pPackageAppInfoImpl->SetName(name);
1926                         pPackageAppInfoImpl->SetDefault(defaultapp);
1927                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
1928                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
1929                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
1930                         pPackageAppInfoImpl->SetAppFeature(appFeature);
1931                         pPackageAppInfoImpl->SetPackageName(packageName);
1932
1933                         pList->Add(*pPackageAppInfoImpl);
1934                 }
1935
1936                 delete pEnum;
1937         }
1938
1939 CATCH:
1940         delete pPkgInfo;
1941         delete pStmt;
1942         return pList;
1943 }
1944
1945 ArrayList*
1946 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1947 {
1948         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1949         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1950
1951         ArrayList* pResult = null;
1952
1953         for (int i = 0; i < pAppInfoList->GetCount(); i++)
1954         {
1955                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
1956                 if (pAppInfoImpl == null)
1957                 {
1958                         continue;
1959                 }
1960
1961                 if (pAppInfoImpl->GetName() == appExecutableName)
1962                 {
1963                         pResult = pAppInfoImpl->GetAppFeatureListN();
1964                         goto OUT;
1965                 }
1966         }
1967
1968 OUT:
1969         pAppInfoList->RemoveAll(true);
1970         delete pAppInfoList;
1971
1972         return pResult;
1973 }
1974
1975 HashMapT<String, _AppFeatureInfoImpl*>*
1976 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
1977 {
1978         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
1979         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
1980
1981         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
1982
1983         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
1984
1985         while (pEnum->MoveNext() == E_SUCCESS)
1986         {
1987                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
1988                 if (pAppInfoImpl == null)
1989                 {
1990                         continue;
1991                 }
1992
1993                 if (pAppInfoImpl->GetName() == appExecutableName)
1994                 {
1995                         pResult = pAppInfoImpl->GetAppFeatureMapN();
1996                         goto OUT;
1997                 }
1998         }
1999
2000 OUT:
2001         pAppInfoList->RemoveAll(true);
2002         delete pAppInfoList;
2003
2004         return pResult;
2005 }
2006
2007 ArrayList*
2008 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
2009 {
2010         result r = E_SUCCESS;
2011         Database db;
2012         DbStatement* pStmt = null;
2013         DbEnumerator* pEnum = null;
2014         String query;
2015         ArrayList* pList = null;
2016
2017         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
2018
2019         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2020         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2021
2022         pStmt = CreateStatementN(db, query);
2023         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2024                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2025
2026         pEnum = ExecuteStatementN(db, pStmt);
2027         if (pEnum != null)
2028         {
2029                 pList = new (std::nothrow) ArrayList;
2030                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
2031
2032                 pList->Construct();
2033
2034                 while (pEnum->MoveNext() == E_SUCCESS)
2035                 {
2036                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
2037                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
2038
2039                         String name;
2040                         String value;
2041
2042                         pEnum->GetStringAt(1, name);
2043                         pEnum->GetStringAt(2, value);
2044
2045                         pLaunchCondtion->SetName(name);
2046                         pLaunchCondtion->SetValue(value);
2047
2048                         pList->Add(*pLaunchCondtion);
2049
2050                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
2051                 }
2052
2053                 delete pEnum;
2054         }
2055
2056 CATCH:
2057         delete pStmt;
2058         return pList;
2059 }
2060
2061 result
2062 _PackageManagerImpl::RegisterAppInfoList(int id, ArrayList* pList)
2063 {
2064         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2065
2066         result r = E_SUCCESS;
2067         String query;
2068         DbStatement* pStmt = null;
2069
2070         if (pList != null)
2071         {
2072                 for (int i = 0; i < pList->GetCount(); i++)
2073                 {
2074                         _PackageAppInfoImpl* pAppInfoImpl = dynamic_cast <_PackageAppInfoImpl*>(pList->GetAt(i));
2075
2076                         if (pAppInfoImpl != null)
2077                         {
2078                                 DbEnumerator* pEnum = null;
2079                                 int uniqueId = 0;
2080
2081                                 String name = pAppInfoImpl->GetName();
2082                                 String defaultapp = pAppInfoImpl->GetDefault();
2083                                 String mainmenuIcon = pAppInfoImpl->GetMainmenuIcon();
2084                                 String settingIcon = pAppInfoImpl->GetSettingIcon();
2085                                 String quickpanelIcon = pAppInfoImpl->GetQuickpanelIcon();
2086                                 int appFeature = pAppInfoImpl->GetAppFeature();
2087                                 String packageName = pAppInfoImpl->GetPackageName();
2088                                 String type = pAppInfoImpl->GetType();
2089
2090                                 ArrayList* pLaunchConditionImplList = pAppInfoImpl->GetLaunchConditionList();
2091                                 ArrayList* pNotificationImplList = pAppInfoImpl->GetNotificationList();
2092                                 ArrayList* pAppFeatureImplList = pAppInfoImpl->GetAppFeatureList();
2093                                 ArrayList* pDataControlImplList = pAppInfoImpl->GetDataControlList();
2094
2095                                 query.Format(
2096                                         1024, L"INSERT INTO AppInfo "
2097                                                   "(ID, APP_NAME, APP_DEFAULT, APP_MAINMENU_ICON, APP_SETTING_ICON, APP_TICKER_ICON, APP_QUICKPANEL_ICON, APP_LAUNCHIMAGE_ICON, APP_FEATURE, PACKAGE_NAME, APP_TYPE) "
2098                                                   "VALUES (?,?,?,?,?,?,?,?,?,?,?)");
2099
2100                                 pStmt = CreateStatementN(*__pDb, query);
2101                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2102
2103                                 if (id != 0)
2104                                 {
2105                                         r = pStmt->BindInt(0, id);
2106                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2107                                 }
2108
2109                                 if (!name.IsEmpty())
2110                                 {
2111                                         r = pStmt->BindString(1, name);
2112                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2113                                 }
2114
2115                                 if (!defaultapp.IsEmpty())
2116                                 {
2117                                         r = pStmt->BindString(2, defaultapp);
2118                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2119                                 }
2120
2121                                 if (!mainmenuIcon.IsEmpty())
2122                                 {
2123                                         r = pStmt->BindString(3, mainmenuIcon);
2124                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2125                                 }
2126
2127                                 if (!settingIcon.IsEmpty())
2128                                 {
2129                                         r = pStmt->BindString(4, settingIcon);
2130                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2131                                 }
2132
2133                                 if (!quickpanelIcon.IsEmpty())
2134                                 {
2135                                         r = pStmt->BindString(6, quickpanelIcon);
2136                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2137                                 }
2138
2139                                 if (appFeature != 0)
2140                                 {
2141                                         r = pStmt->BindInt(8, appFeature);
2142                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2143                                 }
2144
2145                                 if (!packageName.IsEmpty())
2146                                 {
2147                                         r = pStmt->BindString(9, packageName);
2148                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2149                                 }
2150
2151                                 if (!type.IsEmpty())
2152                                 {
2153                                         r = pStmt->BindString(10, type);
2154                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2155                                 }
2156
2157                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2158
2159                                 query.Clear();
2160                                 delete pStmt;
2161                                 pStmt = null;
2162                                 delete pEnum;
2163
2164                                 pAppInfoImpl->SetPkgId(id);
2165                                 uniqueId = pAppInfoImpl->GetUniqueId();
2166                                 RegisterLaunchConditionList(uniqueId, pLaunchConditionImplList);
2167                                 RegisterNotificationList(uniqueId, pNotificationImplList);
2168                                 RegisterAppFeatureList(uniqueId, pAppFeatureImplList);
2169                                 RegisterDataControlList(uniqueId, pDataControlImplList);
2170                                 //RegisterAppControlList(uniqueId, pAppControlImplList);
2171                         }
2172                 }
2173         }
2174
2175         r = GetLastResult();
2176
2177 CATCH:
2178         delete pStmt;
2179
2180         return r;
2181 }
2182
2183 result
2184 _PackageManagerImpl::RegisterLaunchConditionList(int id, ArrayList* pList)
2185 {
2186         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2187
2188         result r = E_SUCCESS;
2189         String query;
2190         DbStatement* pStmt = null;
2191
2192         if (pList != null)
2193         {
2194                 for (int i = 0; i < pList->GetCount(); i++)
2195                 {
2196                         _LaunchConditionInfoImpl* pLaunchCondition = dynamic_cast<_LaunchConditionInfoImpl*>(pList->GetAt(i));
2197
2198                         if (pLaunchCondition != null)
2199                         {
2200                                 DbEnumerator* pEnum = null;
2201
2202                                 String name = pLaunchCondition->GetName();
2203                                 String value = pLaunchCondition->GetValue();
2204
2205                                 query.Format(1024, L"INSERT INTO LaunchCondition (ID, NAME, VALUE) VALUES (?,?,?)");
2206
2207                                 pStmt = CreateStatementN(*__pDb, query);
2208                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2209
2210                                 if (id != 0)
2211                                 {
2212                                         r = pStmt->BindInt(0, id);
2213                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2214                                 }
2215
2216                                 if (!name.IsEmpty())
2217                                 {
2218                                         r = pStmt->BindString(1, name);
2219                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2220                                 }
2221
2222                                 if (!value.IsEmpty())
2223                                 {
2224                                         r = pStmt->BindString(2, value);
2225                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2226                                 }
2227
2228                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2229
2230                                 query.Clear();
2231                                 delete pStmt;
2232                                 pStmt = null;
2233                                 delete pEnum;
2234                         }
2235                 }
2236         }
2237
2238         r = GetLastResult();
2239
2240 CATCH:
2241         delete pStmt;
2242
2243         return r;
2244 }
2245
2246 result
2247 _PackageManagerImpl::RegisterNotificationList(int id, ArrayList* pList)
2248 {
2249         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2250
2251         result r = E_SUCCESS;
2252         String query;
2253         DbStatement* pStmt = null;
2254
2255         if (pList != null)
2256         {
2257                 for (int i = 0; i < pList->GetCount(); i++)
2258                 {
2259                         _NotificationInfoImpl* pNotification = dynamic_cast<_NotificationInfoImpl*>(pList->GetAt(i));
2260
2261                         if (pNotification != null)
2262                         {
2263                                 DbEnumerator* pEnum = null;
2264
2265                                 String name = pNotification->GetName();
2266                                 String value = pNotification->GetValue();
2267
2268                                 query.Format(1024, L"INSERT INTO Notification (ID, NAME, VALUE) VALUES (?,?,?)");
2269
2270                                 pStmt = CreateStatementN(*__pDb, query);
2271                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2272
2273                                 if (id != 0)
2274                                 {
2275                                         r = pStmt->BindInt(0, id);
2276                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2277                                 }
2278
2279                                 if (!name.IsEmpty())
2280                                 {
2281                                         r = pStmt->BindString(1, name);
2282                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2283                                 }
2284
2285                                 if (!value.IsEmpty())
2286                                 {
2287                                         r = pStmt->BindString(2, value);
2288                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2289                                 }
2290
2291                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2292
2293                                 query.Clear();
2294                                 delete pStmt;
2295                                 pStmt = null;
2296                                 delete pEnum;
2297                         }
2298                 }
2299         }
2300
2301         r = GetLastResult();
2302
2303 CATCH:
2304         delete pStmt;
2305
2306         return r;
2307 }
2308
2309 result
2310 _PackageManagerImpl::RegisterAppFeatureList(int id, ArrayList* pList)
2311 {
2312         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2313
2314         result r = E_SUCCESS;
2315         String query;
2316         DbStatement* pStmt = null;
2317
2318         if (pList != null)
2319         {
2320                 for (int i = 0; i < pList->GetCount(); i++)
2321                 {
2322                         _AppFeatureInfoImpl* pAppFeature = dynamic_cast<_AppFeatureInfoImpl*>(pList->GetAt(i));
2323
2324                         if (pAppFeature != null)
2325                         {
2326                                 DbEnumerator* pEnum = null;
2327
2328                                 String name = pAppFeature->GetName();
2329                                 String value = pAppFeature->GetValue();
2330
2331                                 query.Format(1024, L"INSERT INTO AppFeature (ID, NAME, VALUE) VALUES (?,?,?)");
2332
2333                                 pStmt = CreateStatementN(*__pDb, query);
2334                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2335
2336                                 if (id != 0)
2337                                 {
2338                                         r = pStmt->BindInt(0, id);
2339                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2340                                 }
2341
2342                                 if (!name.IsEmpty())
2343                                 {
2344                                         r = pStmt->BindString(1, name);
2345                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2346                                 }
2347
2348                                 if (!value.IsEmpty())
2349                                 {
2350                                         r = pStmt->BindString(2, value);
2351                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2352                                 }
2353
2354                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2355
2356                                 query.Clear();
2357                                 delete pStmt;
2358                                 pStmt = null;
2359                                 delete pEnum;
2360                         }
2361                 }
2362         }
2363
2364         r = GetLastResult();
2365
2366 CATCH:
2367         delete pStmt;
2368
2369         return r;
2370 }
2371
2372 result
2373 _PackageManagerImpl::RegisterDataControlList(int id, ArrayList* pList)
2374 {
2375         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2376
2377         result r = E_SUCCESS;
2378         String query;
2379         DbStatement* pStmt = null;
2380
2381         if (pList != null)
2382         {
2383                 for (int i = 0; i < pList->GetCount(); i++)
2384                 {
2385                         _DataControlInfoImpl* pDataControl = dynamic_cast<_DataControlInfoImpl*>(pList->GetAt(i));
2386
2387                         if (pDataControl != null)
2388                         {
2389                                 DbEnumerator* pEnum = null;
2390
2391                                 String providerId = pDataControl->GetProviderId();
2392                                 ArrayList* pTypeList = pDataControl->GetControlTypeList();
2393
2394                                 if (pTypeList != null)
2395                                 {
2396                                         for (int j = 0; j < pTypeList->GetCount(); j++)
2397                                         {
2398                                                 _DataControlTypeImpl* pControlType = dynamic_cast<_DataControlTypeImpl*>(pTypeList->GetAt(j));
2399
2400                                                 if (pControlType != null)
2401                                                 {
2402                                                         String access = pControlType->GetAccess();
2403                                                         String type = pControlType->GetType();
2404
2405                                                         query.Format(1024, L"INSERT INTO DataControl (ID, PROVIDER_ID, TYPE, ACCESS) VALUES (?,?,?,?)");
2406
2407                                                         pStmt = CreateStatementN(*__pDb, query);
2408                                                         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2409
2410                                                         if (id != 0)
2411                                                         {
2412                                                                 r = pStmt->BindInt(0, id);
2413                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2414                                                         }
2415
2416                                                         if (!providerId.IsEmpty())
2417                                                         {
2418                                                                 r = pStmt->BindString(1, providerId);
2419                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2420                                                         }
2421
2422                                                         if (!type.IsEmpty())
2423                                                         {
2424                                                                 r = pStmt->BindString(2, type);
2425                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2426                                                         }
2427
2428                                                         if (!access.IsEmpty())
2429                                                         {
2430                                                                 r = pStmt->BindString(3, access);
2431                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2432                                                         }
2433
2434                                                         pEnum = ExecuteStatementN(*__pDb, pStmt);
2435
2436                                                         query.Clear();
2437                                                         delete pStmt;
2438                                                         pStmt = null;
2439                                                         delete pEnum;
2440                                                 }
2441                                         }
2442                                 }
2443                         }
2444                 }
2445         }
2446
2447         r = GetLastResult();
2448
2449 CATCH:
2450         delete pStmt;
2451
2452         return r;
2453 }
2454
2455 int
2456 _PackageManagerImpl::FindRecord(const String& tableName, const String& columnName, const String& value) const
2457 {
2458
2459         result r = E_SUCCESS;
2460         Database db;
2461         String query;
2462         DbStatement* pStmt = null;
2463         DbEnumerator* pEnum = null;
2464         int uniqueId = 0;
2465
2466         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2467         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2468
2469         query.Format(1024, L"SELECT * FROM %ls WHERE %ls = '%ls'", tableName.GetPointer(), columnName.GetPointer(), value.GetPointer());
2470
2471         pStmt = CreateStatementN(db, query);
2472         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2473
2474         pEnum = ExecuteStatementN(db, pStmt);
2475
2476         if (pEnum != null)
2477         {
2478                 if (pEnum->MoveNext() == E_SUCCESS)
2479                 {
2480                         pEnum->GetIntAt(0, uniqueId);
2481                 }
2482
2483                 delete pEnum;
2484         }
2485
2486 //CATCH:
2487         delete pStmt;
2488
2489         return uniqueId;
2490 }
2491
2492 result
2493 _PackageManagerImpl::GetRecord(const String& tableName, int uniqueId, const String& columnName, String& value) const
2494 {
2495         result r = E_SUCCESS;
2496         Database db;
2497         String query;
2498         DbStatement* pStmt = null;
2499         DbEnumerator* pEnum = null;
2500
2501         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2502         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2503
2504         query.Format(1024, L"SELECT %ls FROM %ls WHERE UNIQUE_ID = %d", columnName.GetPointer(), tableName.GetPointer(), uniqueId);
2505
2506         pStmt = CreateStatementN(db, query);
2507         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2508
2509         pEnum = ExecuteStatementN(db, pStmt);
2510
2511         if (pEnum != null)
2512         {
2513                 if (pEnum->MoveNext() == E_SUCCESS)
2514                 {
2515                         pEnum->GetStringAt(0, value);
2516                 }
2517
2518                 delete pEnum;
2519         }
2520
2521 //CATCH:
2522         delete pStmt;
2523
2524         return r;
2525 }
2526
2527 result
2528 _PackageManagerImpl::RegisterPrivileges(int id, const String& privileges, const String& hmacPrivileges, int certType)
2529 {
2530         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2531
2532         result r = E_SUCCESS;
2533         String query;
2534         DbStatement* pStmt = null;
2535         DbEnumerator* pEnum = null;
2536
2537         query.Format(1024, L"INSERT INTO PkgPrivileges (ID, PRIVILEGES, HMAC_PPRIVILEGES, CERTIFICATE_TYPE) VALUES (?,?,?,?)");
2538
2539         pStmt = CreateStatementN(*__pDb, query);
2540         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2541
2542         if (id != 0)
2543         {
2544                 r = pStmt->BindInt(0, id);
2545                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2546         }
2547
2548         if (!privileges.IsEmpty())
2549         {
2550                 r = pStmt->BindString(1, privileges);
2551                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2552         }
2553
2554         if (!hmacPrivileges.IsEmpty())
2555         {
2556                 r = pStmt->BindString(2, hmacPrivileges);
2557                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2558         }
2559
2560         if (certType != 0)
2561         {
2562                 r = pStmt->BindInt(3, certType);
2563                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2564         }
2565
2566         pEnum = ExecuteStatementN(*__pDb, pStmt);
2567
2568         delete pStmt;
2569         pStmt = null;
2570         delete pEnum;
2571         pEnum = null;
2572
2573         r = GetLastResult();
2574
2575 CATCH:
2576         delete pStmt;
2577         return r;
2578 }
2579
2580 result
2581 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
2582 {
2583         result r = E_SUCCESS;
2584         Database db;
2585         DbStatement* pStmt = null;
2586         DbEnumerator* pEnum = null;
2587         String query;
2588         Tizen::Base::String packageName;
2589
2590         if (pName == null)
2591         {
2592                 query.Format(
2593                         1024,
2594                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2595                         "True", packageId.GetPointer());
2596         }
2597         else
2598         {
2599                 query.Format(
2600                         1024,
2601                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
2602                         pName->GetPointer(), packageId.GetPointer());
2603         }
2604
2605         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2606         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2607
2608         pStmt = CreateStatementN(db, query);
2609         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2610                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2611
2612         pEnum = ExecuteStatementN(db, pStmt);
2613         if (pEnum != null)
2614         {
2615                 if (pEnum->MoveNext() == E_SUCCESS)
2616                 {
2617                         pEnum->GetStringAt(0, packageName);
2618                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2619                 }
2620                 delete pEnum;
2621         }
2622         else
2623         {
2624                 r = E_OBJ_NOT_FOUND;
2625         }
2626
2627 CATCH:
2628         delete pStmt;
2629
2630         return r;
2631 }
2632
2633 String
2634 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2635 {
2636         result r = E_SUCCESS;
2637         Database db;
2638         DbStatement* pStmt = null;
2639         DbEnumerator* pEnum = null;
2640         String query;
2641         String executableName;
2642
2643         query.Format(
2644                 1024,
2645                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2646                 "True", packageId.GetPointer());
2647
2648         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2649         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2650
2651         pStmt = CreateStatementN(db, query);
2652         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2653                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2654
2655         pEnum = ExecuteStatementN(db, pStmt);
2656         if (pEnum != null)
2657         {
2658                 if (pEnum->MoveNext() == E_SUCCESS)
2659                 {
2660                         pEnum->GetStringAt(0, executableName);
2661                 }
2662                 delete pEnum;
2663         }
2664         else
2665         {
2666                 r = E_OBJ_NOT_FOUND;
2667                 SetLastResult(r);
2668         }
2669
2670 CATCH:
2671         delete pStmt;
2672
2673         return executableName;
2674 }
2675
2676 DbStatement*
2677 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2678 {
2679         result r = E_SUCCESS;
2680         DbStatement* pStmt = null;
2681
2682         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2683         {
2684                 pStmt = db.CreateStatementN(query);
2685                 r = GetLastResult();
2686
2687                 if (r != E_OBJECT_LOCKED)
2688                 {
2689                         break;
2690                 }
2691                 else
2692                 {
2693                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2694                         delete pStmt;
2695                         pStmt = null;
2696                         usleep(50000);
2697                 }
2698         }
2699
2700         return pStmt;
2701 }
2702
2703 DbEnumerator*
2704 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2705 {
2706         result r = E_SUCCESS;
2707         DbEnumerator* pEnum = null;
2708
2709         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2710         {
2711                 pEnum = db.ExecuteStatementN(*pStmt);
2712                 r = GetLastResult();
2713
2714                 if (r != E_OBJECT_LOCKED)
2715                 {
2716                         break;
2717                 }
2718                 else
2719                 {
2720                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2721                         delete pEnum;
2722                         pEnum = null;
2723                         usleep(50000);
2724                 }
2725         }
2726
2727         return pEnum;
2728 }
2729
2730 } } } // Tizen::App::Package