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_INVALID_ARG, "packagePath is not existed.");
 364
 365         String extension = File::GetFileExtension(packagePath);
 366         SysTryReturnResult(NID_APP, extension.IsEmpty() == false, E_INVALID_ARG, "extension is empty.");
 367
 368         std::unique_ptr<char[]> pPackagePath(_StringConverter::CopyToCharArrayN(packagePath));
 369         SysTryReturnResult(NID_APP, pPackagePath, E_OUT_OF_MEMORY, "pPackagePath is null");
 370
 371         std::unique_ptr<char[]> pExtension(_StringConverter::CopyToCharArrayN(extension));
 372         SysTryReturnResult(NID_APP, pExtension, E_OUT_OF_MEMORY, "pExtension is null");
 373
 374         if ((strcasecmp(pExtension.get(), "tpk") == 0) || (strcasecmp(pExtension.get(), "wgt") == 0))
 375         {
 376                 SysLog(NID_APP, "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         std::unique_ptr<IMapEnumerator> pEnum(packageFilterMap.GetMapEnumeratorN());
 777         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 778
 779         int res = 0;
 780         ArrayList* pList = null;
 781         pkgmgrinfo_pkginfo_filter_h handle = null;
 782
 783         res = pkgmgrinfo_pkginfo_filter_create(&handle);
 784         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_pkginfo_filter_create() is failed. [%d]", res);
 785
 786         while(pEnum->MoveNext() == E_SUCCESS)
 787         {
 788                 String* pKey = static_cast< String* >(pEnum->GetKey());
 789                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 790
 791                 Boolean* pVal = static_cast< Boolean* >(pEnum->GetValue());
 792                 SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 793
 794                 bool value = pVal->ToBool();
 795
 796                 SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), value);
 797
 798                 if ((*pKey) == PACKAGE_FILTER_UNINSTALLABLE)
 799                 {
 800                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_REMOVABLE, value);
 801                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(REMOVABLE, %d) is failed. [%d]", value, res);
 802                 }
 803                 else if ((*pKey) == PACKAGE_FILTER_DOWNLOADED)
 804                 {
 805                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD, !value);
 806                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(PRELOAD, %d) is failed. [%d]", !value, res);
 807                 }
 808                 else if ((*pKey) == PACKAGE_FILTER_APP_SETTING)
 809                 {
 810                         res = pkgmgrinfo_pkginfo_filter_add_bool(handle, PMINFO_PKGINFO_PROP_PACKAGE_APPSETTING, value);
 811                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(APPSETTING, %d) is failed. [%d]", value, res);
 812                 }
 813                 else if ((*pKey) == PACKAGE_FILTER_EXTERNAL_STORAGE)
 814                 {
 815                         String installedStorage;
 816                         if (value == true)
 817                         {
 818                                 installedStorage = L"installed_external";
 819                         }
 820                         else
 821                         {
 822                                 installedStorage = L"installed_internal";
 823                         }
 824
 825                         std::unique_ptr<char[]> pInstalledStorage(_StringConverter::CopyToCharArrayN(installedStorage));
 826                         SysTryCatch(NID_APP, pInstalledStorage, , E_OUT_OF_MEMORY, "pInstalledStorage is null.");
 827
 828                         SysLog(NID_APP, "Value[%d]->[%s]", value, pInstalledStorage.get());
 829
 830                         res = pkgmgrinfo_pkginfo_filter_add_string(handle, PMINFO_PKGINFO_PROP_PACKAGE_INSTALLED_STORAGE, pInstalledStorage.get());
 831                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_string(STORAGE, %s) is failed. [%d]", pInstalledStorage.get(), res);
 832                 }
 833                 else
 834                 {
 835                         SysTryCatch(NID_APP, false, , E_INVALID_ARG, "Invalid key(%ls)", pKey->GetPointer());
 836                 }
 837         }
 838
 839         pList = new (std::nothrow) ArrayList();
 840         SysTryCatch(NID_APP, pList, , E_OUT_OF_MEMORY, "ArrayList creation failure.");
 841         pList->Construct();
 842
 843         res = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle, PackageInfoHandler, pList);
 844         if (res != 0)
 845         {
 846                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_filter_foreach_pkginfo() is failed. result = [%d]", res);
 847
 848                 pList->RemoveAll(true);
 849                 pList = null;
 850         }
 851
 852 CATCH:
 853         if (handle)
 854         {
 855                 pkgmgrinfo_pkginfo_filter_destroy(handle);
 856         }
 857
 858         return pList;
 859 }
 860
 861 IList*
 862 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageAppFilterMap) const
 863 {
 864         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 865
 866         std::unique_ptr<IMapEnumerator> pEnum(packageAppFilterMap.GetMapEnumeratorN());
 867         SysTryReturn(NID_APP, pEnum, null, E_INVALID_ARG, "GetMapEnumeratorN() is failed.");
 868
 869         int res = 0;
 870         ArrayList* pList = null;
 871         pkgmgrinfo_appinfo_filter_h handle = null;
 872
 873         res = pkgmgrinfo_appinfo_filter_create(&handle);
 874         SysTryReturn(NID_APP, res == PMINFO_R_OK, null, E_SYSTEM, "pkgmgrinfo_appinfo_filter_create() is failed. [%d]", res);
 875
 876         while(pEnum->MoveNext() == E_SUCCESS)
 877         {
 878                 String* pKey = static_cast<String*>(pEnum->GetKey());
 879                 SysTryCatch(NID_APP, pKey, , E_INVALID_ARG, "GetKey() is failed.");
 880
 881                 if ((*pKey) == PACKAGE_APP_FILTER_MENUICON_VISIBLE)
 882                 {
 883                         Boolean* pVal = static_cast<Boolean*>(pEnum->GetValue());
 884                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 885
 886                         bool nodisplay = !(pVal->ToBool());
 887                         SysLog(NID_APP, "Key[%ls], Value[%d]", pKey->GetPointer(), nodisplay);
 888
 889                         res = pkgmgrinfo_appinfo_filter_add_bool(handle, PMINFO_APPINFO_PROP_APP_NODISPLAY, nodisplay);
 890                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_pkginfo_filter_add_bool(NODISPLAY, %d) is failed. [%d]", nodisplay, res);
 891                 }
 892                 else if ((*pKey) == PACKAGE_APP_FILTER_CATEGORY)
 893                 {
 894                         String* pVal = static_cast<String*>(pEnum->GetValue());
 895                         SysTryCatch(NID_APP, pVal, , E_INVALID_ARG, "GetValue() is failed.");
 896
 897                         SysLog(NID_APP, "Key[%ls], Value[%ls]", pKey->GetPointer(), pVal->GetPointer());
 898
 899                         std::unique_ptr<char[]> pValue(_StringConverter::CopyToCharArrayN(*pVal));
 900                         SysTryCatch(NID_APP, pValue, , E_OUT_OF_MEMORY, "pValue is null.");
 901
 902                         res = pkgmgrinfo_appinfo_filter_add_string(handle, PMINFO_APPINFO_PROP_APP_CATEGORY, pValue.get());
 903                         SysTryCatch(NID_APP, res == PMINFO_R_OK, , E_SYSTEM, "pkgmgrinfo_appinfo_filter_add_string(CATEGORY, %s) is failed. [%d]", pValue.get(), res);
 904                 }
 905                 else
 906                 {
 907                         SysTryCatch(NID_APP, false, , E_INVALID_ARG, "Invalid key(%ls)", pKey->GetPointer());
 908                 }
 909         }
 910
 911         pList = new (std::nothrow) ArrayList();
 912         SysTryCatch(NID_APP, pList, , E_OUT_OF_MEMORY, "ArrayList creation failure.");
 913         pList->Construct();
 914
 915         res = pkgmgrinfo_appinfo_filter_foreach_appinfo(handle, PackageAppInfoHandler, pList);
 916         if (res != 0)
 917         {
 918                 SysLog(NID_APP, "pkgmgrinfo_appinfo_filter_foreach_appinfo() is failed. result = [%d]", res);
 919
 920                 pList->RemoveAll(true);
 921                 pList = null;
 922         }
 923
 924 CATCH:
 925         if (handle)
 926         {
 927                 pkgmgrinfo_appinfo_filter_destroy(handle);
 928         }
 929
 930         return pList;
 931 }
 932
 933 IList*
 934 _PackageManagerImpl::GetPackageAppInfoListN(const IMap& packageFilterMap, const IMap& packageAppFilterMap) const
 935 {
 936         SysTryReturn(NID_APP, packageFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageFilterMap.GetCount() is invalid.");
 937         SysTryReturn(NID_APP, packageAppFilterMap.GetCount() > 0, null, E_INVALID_ARG, "packageAppFilterMap.GetCount() is invalid.");
 938
 939         return null;
 940 }
 941
 942 int
 943 _PackageManagerImpl::PackageInfoHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
 944 {
 945         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
 946         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
 947
 948         result r = E_SUCCESS;
 949         int res = PMINFO_R_OK;
 950         char* pPackageId = null;
 951         ArrayList* pList = (ArrayList*)pUserData;
 952
 953         res = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackageId);
 954         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_pkginfo_get_pkgname() is failed. [%d]", res);
 955
 956         std::unique_ptr<PackageInfo> pPackageInfo(new (std::nothrow) PackageInfo);
 957         SysTryReturn(NID_APP, pPackageInfo, 0, E_OUT_OF_MEMORY, "pPackageInfo instance must not be null.");
 958
 959         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo.get());
 960         r = pPackageInfoImpl->Construct(pPackageId);
 961         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pPackageId);
 962
 963         pList->Add(*pPackageInfo.release());
 964
 965         return 0;
 966 }
 967
 968 int
 969 _PackageManagerImpl::PackageAppInfoHandler(const pkgmgrinfo_appinfo_h handle, void* pUserData)
 970 {
 971         SysTryReturn(NID_APP, handle, 0, E_SYSTEM, "handle must not be null.");
 972         SysTryReturn(NID_APP, pUserData, 0, E_SYSTEM, "pUserData must not be null.");
 973
 974         result r = E_SUCCESS;
 975         int res = PMINFO_R_OK;
 976         char* pAppId = null;
 977         ArrayList* pList = (ArrayList*)pUserData;
 978
 979         res = pkgmgrinfo_appinfo_get_appid(handle, &pAppId);
 980         SysTryReturn(NID_APP, res == PMINFO_R_OK, 0, E_SYSTEM, "pkgmgrinfo_appinfo_get_appid is failed. [%d]", res);
 981
 982         std::unique_ptr<PackageAppInfo> pPackageAppInfo(new (std::nothrow) PackageAppInfo);
 983         SysTryReturn(NID_APP, pPackageAppInfo, 0, E_OUT_OF_MEMORY, "pPackageAppInfo instance must not be null.");
 984
 985         _PackageAppInfoImpl* pPackageAppInfoImpl = _PackageAppInfoImpl::GetInstance(pPackageAppInfo.get());
 986         r = pPackageAppInfoImpl->Construct(pAppId);
 987         SysTryReturn(NID_APP, r == E_SUCCESS, 0, E_SYSTEM, "Construct(%s) is failed.", pAppId);
 988
 989         pList->Add(*pPackageAppInfo.release());
 990
 991         return 0;
 992 }
 993
 994 _PackageManagerImpl*
 995 _PackageManagerImpl::GetInstance(void)
 996 {
 997         return PackageManager::GetInstance()->__pPackageManagerImpl;
 998 }
 999
1000 result
1001 _PackageManagerImpl::Construct(void)
1002 {
1003         ClearLastResult();
1004
1005         result r = __installationList.Construct();
1006         SysTryReturnResult(NID_APP, r == E_SUCCESS, r, "The memory is insufficient.");
1007
1008         return E_SUCCESS;
1009 }
1010
1011 _PackageManagerImpl::_PackageManagerImpl(void)
1012 :__pRequestClient(null),
1013 __pListeningClient(null),
1014 __pDb(null)
1015 {
1016         CreatePackageTables();
1017 }
1018
1019 _PackageManagerImpl::~_PackageManagerImpl(void)
1020 {
1021 }
1022
1023 void
1024 _PackageManagerImpl::SendPackageEvent(PackageType type, const PackageId& packageId, const char* pEventKey, const char* pEventValue)
1025 {
1026         result r = E_SUCCESS;
1027         bool install = true;
1028
1029         if (strcmp(pEventKey, "start") == 0)
1030         {
1031                 if ((strcmp(pEventValue, "install") == 0) || (strcmp(pEventValue, "uninstall") == 0))
1032                 {
1033                         String* pAppId = new (std::nothrow) String(packageId);
1034                         SysTryReturnVoidResult(NID_APP, pAppId != null, E_OUT_OF_MEMORY, "pAppId instance must not be null.");
1035
1036                         String* pOperation = new (std::nothrow) String(pEventValue);
1037                         SysTryReturnVoidResult(NID_APP, pOperation != null, E_OUT_OF_MEMORY, "pOperation instance must not be null.");
1038
1039                         r = __installationList.Add(*pAppId, *pOperation);
1040                         if (IsFailed(r))
1041                         {
1042                                 delete pAppId;
1043                                 delete pOperation;
1044                                 SysLog(NID_APP, "Failed to add installation condition.");
1045                                 SetLastResult(E_SYSTEM);
1046                                 return;
1047                         }
1048                 }
1049         }
1050         else if (strcmp(pEventKey, "end") == 0)
1051         {
1052                 String* pOperation = static_cast <String*>(__installationList.GetValue(packageId));
1053                 if (pOperation)
1054                 {
1055                         if (pOperation->Equals("uninstall", true) == true)
1056                         {
1057                                 install = false;
1058                         }
1059
1060                         r = __installationList.Remove(packageId, true);
1061                         if (IsFailed(r))
1062                         {
1063                                 SysLogException(NID_APP, r, "[%s] Remove Element [%ls] is failed from installing list.", GetErrorMessage(r), packageId.GetPointer());
1064                         }
1065                 }
1066         }
1067
1068         std::unique_ptr< IEnumeratorT<_PackageManagerEvent*> > pEnum(__packageEventListenerList.GetEnumeratorN());
1069         SysTryReturnVoidResult(NID_APP, pEnum, E_OUT_OF_MEMORY, "The memory is insufficient.");
1070
1071         while (pEnum->MoveNext() == E_SUCCESS)
1072         {
1073                 _PackageManagerEvent*   pEvent = null;
1074                 pEnum->GetCurrent(pEvent);
1075                 if (pEvent)
1076                 {
1077                         _PackageManagerEventArg* pEventArg= new (std::nothrow) _PackageManagerEventArg();
1078                         SysTryReturnVoidResult(NID_APP, pEventArg, E_OUT_OF_MEMORY, "The memory is insufficient.");
1079
1080                         String eventKey(pEventKey);
1081                         String eventValue(pEventValue);
1082
1083                         pEventArg->__packageId = packageId;
1084                         pEventArg->__eventKey = eventKey;
1085                         pEventArg->__eventValue = eventValue;
1086                         pEventArg->__install = install;
1087
1088                         r = pEvent->Fire(*pEventArg);
1089                         if (r != E_SUCCESS)
1090                         {
1091                                 SysLog(NID_APP, "pEvent->Fire(*pEventArg) failed. [%s]", GetErrorMessage(r));
1092                         }
1093
1094                         SysLog(NID_APP, "PackageId = [%ls], Key = [%ls], Value = [%ls], install = [%d]", pEventArg->__packageId.GetPointer(), pEventArg->__eventKey.GetPointer(), pEventArg->__eventValue.GetPointer(), pEventArg->__install);
1095                 }
1096                 else
1097                 {
1098                         SysLog(NID_APP, "pEvent is null.");
1099                 }
1100         }
1101 }
1102
1103 PackageInfo*
1104 _PackageManagerImpl::GetPackageInfoN(PackageType packageType, const String& packageName) const
1105 {
1106         SysTryReturn(NID_APP, packageName.IsEmpty() == false, null, E_INVALID_ARG, "[E_INVALID_ARG] packageName is empty.");
1107
1108         result r = E_SUCCESS;
1109         Database db;
1110         DbStatement* pStmt = null;
1111         DbEnumerator* pEnum = null;
1112         String query;
1113         PackageInfo *pPackageInfo = null;
1114
1115         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());
1116
1117         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1118         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1119
1120         pStmt = CreateStatementN(db, query);
1121
1122         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1123
1124         pEnum = ExecuteStatementN(db, pStmt);
1125         if (pEnum != null)
1126         {
1127                 if (pEnum->MoveNext() == E_SUCCESS)
1128                 {
1129                         pPackageInfo = new (std::nothrow) PackageInfo;
1130                         SysTryReturn(NID_APP, pPackageInfo != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1131
1132                         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1133
1134                         String id;
1135                         String appVersion;
1136                         String appType;
1137                         String appMimeType;
1138                         String appApiVersion;
1139                         String appName;
1140                         String appVendor;
1141                         String appDescription;
1142                         String appUrl;
1143                         String appCid;
1144                         String appRootPath;
1145                         int appStorageType = 0;
1146                         DateTime appInstallationTime;
1147                         String appIconPath;
1148
1149                         pEnum->GetStringAt(1, id);
1150                         pEnum->GetStringAt(3, appVersion);
1151                         pEnum->GetStringAt(4, appType);
1152                         pEnum->GetStringAt(5, appMimeType);
1153                         pEnum->GetStringAt(6, appApiVersion);
1154                         pEnum->GetStringAt(7, appName);
1155                         pEnum->GetStringAt(8, appVendor);
1156                         pEnum->GetStringAt(9, appDescription);
1157                         pEnum->GetStringAt(10, appUrl);
1158                         pEnum->GetStringAt(11, appCid);
1159                         pEnum->GetStringAt(16, appRootPath);
1160                         pEnum->GetIntAt(17, appStorageType);
1161                         pEnum->GetDateTimeAt(18, appInstallationTime);
1162                         pEnum->GetStringAt(21, appIconPath);
1163
1164                         pPackageInfoImpl->SetAppId(id);
1165                         pPackageInfoImpl->SetAppVersion(appVersion);
1166                         pPackageInfoImpl->SetAppMimeType(appMimeType);
1167                         pPackageInfoImpl->SetAppApiVersion(appApiVersion);
1168                         pPackageInfoImpl->SetAppName(appName);
1169                         pPackageInfoImpl->SetAppVendor(appVendor);
1170                         pPackageInfoImpl->SetAppDescription(appDescription);
1171                         pPackageInfoImpl->SetAppUrl(appUrl);
1172                         pPackageInfoImpl->SetAppCid(appCid);
1173                         pPackageInfoImpl->SetAppRootPath(appRootPath);
1174                         pPackageInfoImpl->SetAppStorageType(appStorageType);
1175                         pPackageInfoImpl->SetAppInstallationTime(appInstallationTime);
1176                         pPackageInfoImpl->SetAppIconPath(appIconPath);
1177                 }
1178
1179                 delete pEnum;
1180         }
1181         else
1182         {
1183                 r = E_OBJ_NOT_FOUND;
1184         }
1185
1186 CATCH:
1187         delete pStmt;
1188         return pPackageInfo;
1189 }
1190
1191 int
1192 _PackageManagerImpl::PackageInfoEventHandler(const pkgmgrinfo_pkginfo_h handle, void* pUserData)
1193 {
1194         SysTryReturn(NID_APP, handle != null, 0, E_SYSTEM, "[E_SYSTEM] handle must not be null.");
1195
1196         int result = 0;
1197         char* pPackage = null;
1198         ArrayList* pList = (ArrayList*)pUserData;
1199
1200         PackageInfo *pPackageInfo = new (std::nothrow) PackageInfo;
1201         SysTryReturn(NID_APP, pPackageInfo != null, 0, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageInfo instance must not be null.");
1202
1203         _PackageInfoImpl* pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPackageInfo);
1204
1205         result = pkgmgrinfo_pkginfo_get_pkgname(handle, &pPackage);
1206         if (result == 0)
1207         {
1208                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname(): package = [%s]", pPackage);
1209         }
1210         else
1211         {
1212                 SysLog(NID_APP, "pkgmgrinfo_pkginfo_get_pkgname() is failed. result = [%d]", result);
1213         }
1214
1215         pPackageInfoImpl->Construct(pPackage);
1216         pList->Add(*pPackageInfo);
1217
1218         return result;
1219 }
1220
1221 IList*
1222 _PackageManagerImpl::GetFilteredAppIdListN(const String& feature, const String& value) const
1223 {
1224         result r = E_SUCCESS;
1225         Database db;
1226         DbStatement* pStmt = null;
1227         DbEnumerator* pEnum = null;
1228         String query;
1229         ArrayList* pList = null;
1230
1231         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());
1232
1233         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1234         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1235
1236         pStmt = CreateStatementN(db, query);
1237         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1238
1239         pEnum = ExecuteStatementN(db, pStmt);
1240
1241         if (pEnum != null)
1242         {
1243                 pList = new (std::nothrow) ArrayList();
1244                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1245                 pList->Construct();
1246
1247                 while (pEnum->MoveNext() == E_SUCCESS)
1248                 {
1249                         String* pPackageName = new (std::nothrow) String;
1250                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1251
1252                         pEnum->GetStringAt(0, *pPackageName);
1253
1254                         pList->Add(*pPackageName);
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 IList*
1271 _PackageManagerImpl::GetDataControlInfoN(const String& providerId, const String& type) const
1272 {
1273         result r = E_SUCCESS;
1274         Database db;
1275         DbStatement* pStmt = null;
1276         DbEnumerator* pEnum = null;
1277         String query;
1278         ArrayList* pList = null;
1279
1280         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());
1281
1282         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1283         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1284
1285         pStmt = CreateStatementN(db, query);
1286         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1287
1288         pEnum = ExecuteStatementN(db, pStmt);
1289
1290         if (pEnum != null)
1291         {
1292                 pList = new (std::nothrow) ArrayList();
1293                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
1294                 pList->Construct();
1295
1296                 while (pEnum->MoveNext() == E_SUCCESS)
1297                 {
1298                         String* pPackageName = new (std::nothrow) String;
1299                         SysTryReturn(NID_APP, pPackageName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pPackageName instance must not be null.");
1300
1301                         String* pAccess = new (std::nothrow) String;
1302                         SysTryReturn(NID_APP, pAccess != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pAccess instance must not be null.");
1303
1304                         pEnum->GetStringAt(0, *pPackageName);
1305                         pList->Add(*pPackageName);
1306
1307                         pEnum->GetStringAt(1, *pAccess);
1308                         pList->Add(*pAccess);
1309                 }
1310
1311                 delete pEnum;
1312
1313         }
1314         else
1315         {
1316                 r = E_OBJ_NOT_FOUND;
1317         }
1318
1319 CATCH:
1320         delete pStmt;
1321         return pList;
1322 }
1323
1324 IMap*
1325 _PackageManagerImpl::GetUiThemeListN(const PackageId& packageId) const
1326 {
1327         result r = E_SUCCESS;
1328         Database db;
1329         DbStatement* pStmt = null;
1330         DbEnumerator* pEnum = null;
1331         String query;
1332         HashMap* pList = null;
1333
1334         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')"
1335                         , packageId.GetPointer());
1336
1337         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1338         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1339
1340         pStmt = CreateStatementN(db, query);
1341         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1342
1343         pEnum = ExecuteStatementN(db, pStmt);
1344
1345         if (pEnum != null)
1346         {
1347                 pList = new (std::nothrow) HashMap();
1348                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "HashMap creation failure.");
1349                 pList->Construct();
1350
1351                 while (pEnum->MoveNext() == E_SUCCESS)
1352                 {
1353                         String* pName = new (std::nothrow) String;
1354                         SysTryCatch(NID_APP, pName != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pName instance must not be null.");
1355
1356                         String* pValue = new (std::nothrow) String;
1357                         SysTryCatch(NID_APP, pValue != null, , E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] pValue instance must not be null.");
1358
1359                         pEnum->GetStringAt(0, *pName);
1360                         pEnum->GetStringAt(1, *pValue);
1361
1362                         pList->Add(*pName, *pValue);
1363                 }
1364
1365                 delete pEnum;
1366
1367         }
1368         else
1369         {
1370                 r = E_OBJ_NOT_FOUND;
1371         }
1372
1373 CATCH:
1374         delete pStmt;
1375         return pList;
1376 }
1377
1378 bool
1379 _PackageManagerImpl::IsAppInstalled(const AppId& appId)
1380 {
1381         if (appId == _AppInfo::GetPackageId())
1382         {
1383                 return true;
1384         }
1385
1386         int result = 0;
1387         pkgmgrinfo_pkginfo_h pPackageInfoHandle = null;
1388
1389         std::unique_ptr<char[]> pPackageId(_StringConverter::CopyToCharArrayN(appId));
1390         SysTryReturn(NID_APP, pPackageId, false, E_OUT_OF_MEMORY, "pPackageId is null");
1391
1392         result = pkgmgrinfo_pkginfo_get_pkginfo(pPackageId.get(), &pPackageInfoHandle);
1393         SysTryReturn(NID_APP, result == 0, false, E_APP_NOT_INSTALLED, "pkgmgrinfo_pkginfo_get_pkginfo() failed. result=[%d], packageId=[%s]", result, pPackageId.get());
1394
1395         if(pPackageInfoHandle)
1396         {
1397                 pkgmgrinfo_pkginfo_destroy_pkginfo(pPackageInfoHandle);
1398         }
1399
1400         return true;
1401 }
1402
1403 int
1404 _PackageManagerImpl::PackageEventHandler(int req_id, const char* pkg_type, const char* pkg_name,
1405                                                                                 const char* key, const char* val, const void* pmsg, void* data)
1406 {
1407         SysLog(NID_APP, "PackageEventHandler - req_id: %d, pkg_type: %s, pkg_name: %s, key: %s, val: %s", req_id, pkg_type,
1408                                 pkg_name, key, val);
1409
1410         PackageType type = PACKAGE_TYPE_TPK;
1411         PackageId packageId(pkg_name);
1412
1413         if (strcmp(pkg_type, "tpk") == 0)
1414         {
1415                 type = PACKAGE_TYPE_TPK;
1416         }
1417         else if (strcmp(pkg_type, "wgt") == 0)
1418         {
1419                 type = PACKAGE_TYPE_WGT;
1420         }
1421         else
1422         {
1423                 SysLog(NID_APP, "Invalid type - pkg_type: %s", pkg_type);
1424                 return 0;
1425         }
1426
1427         _PackageManagerImpl* pThis = _PackageManagerImpl::GetInstance();
1428         pThis->SendPackageEvent(type, packageId, key, val);
1429
1430         return 0;
1431 }
1432
1433 String*
1434 _PackageManagerImpl::GetAppIdOfDataControlN(const String& providerId)
1435 {
1436         result r = E_SUCCESS;
1437         Database db;
1438         DbStatement* pStmt = null;
1439         DbEnumerator* pEnum = null;
1440         String query;
1441         String* pAppId = null;
1442
1443         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",
1444                         providerId.GetPointer());
1445
1446         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1447         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1448
1449         pStmt = CreateStatementN(db, query);
1450         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1451
1452         pEnum = ExecuteStatementN(db, pStmt);
1453
1454         if (pEnum != null)
1455         {
1456                 if (pEnum->MoveNext() == E_SUCCESS)
1457                 {
1458                         pAppId = new (std::nothrow) String;
1459                         SysTryReturn(NID_APP, pAppId != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory");
1460
1461                         pEnum->GetStringAt(0, *pAppId);
1462                 }
1463
1464                 delete pEnum;
1465         }
1466
1467 CATCH:
1468         delete pStmt;
1469         return pAppId;
1470 }
1471
1472 result
1473 _PackageManagerImpl::CreatePackageTables(void)
1474 {
1475         result r = E_SUCCESS;
1476         Database db;
1477         String createQuery;
1478
1479         if (File::IsFileExist(PACKAGE_DATABASE_FILE_NAME) == true)
1480         {
1481                 SysLog(NID_APP, ".app-package.db is already existed!");
1482                 return r;
1483         }
1484
1485         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, true);
1486         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.Construct is failed. [%s]", GetErrorMessage(r));
1487
1488         // PkgInfo
1489         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgInfo"
1490                                                          "( UNIQUE_ID                                   INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1491                                                          "PKG_ID                        TEXT,"
1492                                                          "PKG_SECRET                    TEXT,"
1493                                                          "PKG_VERSION                   TEXT,"
1494                                                          "PKG_TYPE                  TEXT,"
1495                                                          "PKG_MIMETYPE              TEXT,"
1496                                                          "PKG_APIVERSION                TEXT,"
1497                                                          "PKG_NAME                  TEXT,"
1498                                                          "PKG_VENDOR                    TEXT,"
1499                                                          "PKG_DESCRIPTION           TEXT,"
1500                                                          "PKG_URL                       TEXT,"
1501                                                          "PKG_CID                       TEXT,"
1502                                                          "PKG_READONLY_SIZE             INTEGER,"
1503                                                          "PKG_DATA_SIZE                 INTEGER,"
1504                                                          "PKG_PARENT_ID                         TEXT,"
1505                                                          "PKG_ATTRIBUTE                         INTEGER,"
1506                                                          "PKG_ROOTPATH              TEXT,"
1507                                                          "PKG_STORAGE_TYPE          INTEGER,"
1508                                                          "PKG_INSTALLATION_DATE         TEXT,"
1509                                                          "PKG_STATE                     INTEGER,"
1510                                                          "PKG_INITIATOR                 INTEGER )");
1511         r = db.ExecuteSql(createQuery, true);
1512         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1513         createQuery.Clear();
1514
1515         // PkgPrivileges
1516         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgPrivileges"
1517                                                          "( ID                          INTEGER,"
1518                                                          "PRIVILEGES                                    TEXT,"
1519                                                          "HMAC_PPRIVILEGES                      TEXT,"
1520                                                          "CERTIFICATE_TYPE              INTEGER,"
1521                                                      "STR_PRIVILEGES            TEXT )");
1522         r = db.ExecuteSql(createQuery, true);
1523         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1524         createQuery.Clear();
1525
1526         // PkgIntegrity
1527         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS PkgIntegrity"
1528                                                          "( ID                          INTEGER,"
1529                                                          "HMAC_APPID                                    TEXT,"
1530                                                          "HMAC_APPSECRET                                TEXT,"
1531                                                          "HMAC_HTB                                              TEXT,"
1532                                                          "SLOT_NUM                              INTEGER )");
1533         r = db.ExecuteSql(createQuery, true);
1534         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1535         createQuery.Clear();
1536
1537         // AppInfo
1538         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppInfo"
1539                                                          "( UNIQUE_ID                                   INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1540                                                          "ID                            INTEGER,"
1541                                                          "APP_NAME                  TEXT,"
1542                                                          "APP_TYPE                  TEXT,"
1543                                                          "APP_DEFAULT                   TEXT,"
1544                                                          "APP_MAINMENU_ICON             TEXT,"
1545                                                          "APP_SETTING_ICON          TEXT,"
1546                                                          "APP_TICKER_ICON                               TEXT,"
1547                                                          "APP_QUICKPANEL_ICON                   TEXT,"
1548                                                          "APP_LAUNCHIMAGE_ICON      TEXT,"
1549                                                          "APP_FEATURE               INTEGER,"
1550                                                          "PACKAGE_NAME              TEXT )");
1551         r = db.ExecuteSql(createQuery, true);
1552         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1553         createQuery.Clear();
1554
1555         // Notification
1556         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS Notification"
1557                                                          "( ID                          INTEGER,"
1558                                                          "NAME                      TEXT,"
1559                                                          "VALUE                     TEXT )");
1560         r = db.ExecuteSql(createQuery, true);
1561         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1562         createQuery.Clear();
1563
1564         // AppFeature
1565         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppFeature"
1566                                                          "( ID                          INTEGER,"
1567                                                          "NAME                      TEXT,"
1568                                                          "VALUE                     TEXT )");
1569         r = db.ExecuteSql(createQuery, true);
1570         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1571         createQuery.Clear();
1572
1573         // LaunchCondition
1574         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS LaunchCondition"
1575                                                          "( ID                          INTEGER,"
1576                                                          "NAME                      TEXT,"
1577                                                          "VALUE                     TEXT )");
1578         r = db.ExecuteSql(createQuery, true);
1579         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1580         createQuery.Clear();
1581
1582         // DataControl
1583         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS DataControl"
1584                                                          "( ID INTEGER,"
1585                                                          "PROVIDER_ID TEXT,"
1586                                                          "TYPE TEXT,"
1587                                                          "ACCESS TEXT )");
1588         r = db.ExecuteSql(createQuery, true);
1589         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1590         createQuery.Clear();
1591
1592         // Capability
1593         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS Capability"
1594                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1595                                                          "OPERATION_ID                          TEXT )");
1596         r = db.ExecuteSql(createQuery, true);
1597         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1598         createQuery.Clear();
1599
1600         // ResolutionUriScheme
1601         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS ResolutionUriScheme"
1602                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1603                                                          "URI_SCHEME                            TEXT )");
1604         r = db.ExecuteSql(createQuery, true);
1605         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1606         createQuery.Clear();
1607
1608         // ResolutionMimeType
1609         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS ResolutionMimeType"
1610                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1611                                                          "MIME_TYPE                             TEXT )");
1612         r = db.ExecuteSql(createQuery, true);
1613         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1614         createQuery.Clear();
1615
1616         // AppControl
1617         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppControl"
1618                                                          "( ID                          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
1619                                                          "PROVIDER_ID                   TEXT,"
1620                                                          "CATEGORY                                      TEXT )");
1621         r = db.ExecuteSql(createQuery, true);
1622         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1623         createQuery.Clear();
1624
1625         // AppInfoLookup
1626         createQuery.Format(1024, L"CREATE TABLE IF NOT EXISTS AppInfoLookup"
1627                                                          "( AppInfoID                   INTEGER,"
1628                                                          "CapabilityID              INTEGER,"
1629                                                          "ResolutionUriSchemeID         INTEGER,"
1630                                                          "ResolutionMimeTypeID      INTEGER,"
1631                                                          "AppControlID                              INTEGER )");
1632         r = db.ExecuteSql(createQuery, true);
1633         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "MakePackageDb: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1634         createQuery.Clear();
1635
1636         return r;
1637 }
1638
1639 result
1640 _PackageManagerImpl::RegisterPackageInfo(_PackageInfoImpl& pkgInfoImpl)
1641 {
1642         result r = E_SUCCESS;
1643         Database db;
1644         DbStatement* pStmt = null;
1645         DbEnumerator* pEnum = null;
1646         String query;
1647         String privileges;
1648         String hmacPrivileges;
1649         PackageInfo packageInfo;
1650         int uniqueId = 0;
1651
1652         SysLog(NID_APP, "_PackageManagerImpl::RegisterPackageInfo()");
1653
1654         query.Format(
1655                 1024, L"INSERT INTO PkgInfo "
1656                           "(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,"
1657                           " PKG_ATTRIBUTE, PKG_ROOTPATH, PKG_STORAGE_TYPE, PKG_INSTALLATION_DATE, PKG_STATE, PKG_INITIATOR) "
1658                           "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
1659
1660         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1661         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1662
1663         pStmt = CreateStatementN(db, query);
1664         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1665
1666         PackageId packageId = pkgInfoImpl.GetAppId();
1667         String appVersion = pkgInfoImpl.GetAppVersion();
1668         String type = pkgInfoImpl.GetAppType();
1669         String appMimeType = pkgInfoImpl.GetAppMimeType();
1670         String appApiVersion = pkgInfoImpl.GetAppApiVersion();
1671         String appName = pkgInfoImpl.GetAppName();
1672         String appVendor = pkgInfoImpl.GetAppVendor();
1673         String appDescription = pkgInfoImpl.GetAppDescription();
1674         String appUrl = pkgInfoImpl.GetAppUrl();
1675         String appCid = pkgInfoImpl.GetAppCid();
1676
1677         pkgInfoImpl.GetPrivilegesValue(privileges, hmacPrivileges);
1678         String appRootPath = pkgInfoImpl.GetAppRootPath();
1679         int appStorageType = pkgInfoImpl.GetAppStorageType();
1680         int certType = pkgInfoImpl.GetCertType();
1681         ArrayList* pAppInfoImplList = pkgInfoImpl.GetAppInfoList();
1682
1683         DateTime time;
1684         r = SystemTime::GetCurrentTime(time);
1685         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "An error occurs while getting a current time.");
1686
1687         if (!packageId.IsEmpty())
1688         {
1689                 r = pStmt->BindString(0, packageId);
1690                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1691         }
1692
1693         if (!appVersion.IsEmpty())
1694         {
1695                 r = pStmt->BindString(2, appVersion);
1696                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1697         }
1698
1699         if (!type.IsEmpty())
1700         {
1701                 r = pStmt->BindString(3, type);
1702                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1703         }
1704
1705         if (!appMimeType.IsEmpty())
1706         {
1707                 r = pStmt->BindString(4, appMimeType);
1708                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1709         }
1710
1711         if (!appApiVersion.IsEmpty())
1712         {
1713                 r = pStmt->BindString(5, appApiVersion);
1714                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1715         }
1716
1717         if (!appName.IsEmpty())
1718         {
1719                 r = pStmt->BindString(6, appName);
1720                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1721         }
1722
1723         if (!appVendor.IsEmpty())
1724         {
1725                 r = pStmt->BindString(7, appVendor);
1726                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1727         }
1728
1729         if (!appDescription.IsEmpty())
1730         {
1731                 r = pStmt->BindString(8, appDescription);
1732                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1733         }
1734
1735         if (!appUrl.IsEmpty())
1736         {
1737                 r = pStmt->BindString(9, appUrl);
1738                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1739         }
1740
1741         if (!appCid.IsEmpty())
1742         {
1743                 r = pStmt->BindString(10, appCid);
1744                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1745         }
1746
1747         if (!appRootPath.IsEmpty())
1748         {
1749                 r = pStmt->BindString(15, appRootPath);
1750                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1751         }
1752
1753         if (appStorageType != 0)
1754         {
1755                 r = pStmt->BindInt(16, appStorageType);
1756                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1757         }
1758
1759         r = pStmt->BindDateTime(17, time);
1760         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
1761
1762         pEnum = ExecuteStatementN(db, pStmt);
1763
1764         r = GetLastResult();
1765
1766         uniqueId = pkgInfoImpl.GetUniqueId();
1767
1768         SysLog(NID_APP, "_PackageManagerImpl::RegisterPackageInfo()-GetUniqueId(%d)", uniqueId);
1769
1770         __pDb = &db;
1771
1772         // AppInfo
1773         RegisterAppInfoList(uniqueId, pAppInfoImplList);
1774
1775         // PkgPrivileges
1776         RegisterPrivileges(uniqueId, privileges, hmacPrivileges, certType);
1777
1778 CATCH:
1779         __pDb = null;
1780         delete pEnum;
1781         delete pStmt;
1782         return r;
1783 }
1784
1785 result
1786 _PackageManagerImpl::UnregisterPackageInfo(const PackageId& packageId)
1787 {
1788         SysLog(NID_APP, "packageId = [%ls]", packageId.GetPointer());
1789
1790         result r = E_SUCCESS;
1791         Database db;
1792         String query;
1793         int id = 0;
1794         PackageInfo* pPkgInfo;
1795         _PackageInfoImpl* pPackageInfoImpl = null;
1796         ArrayList* pList = null;
1797
1798         pPkgInfo = GetPackageInfoN(packageId);
1799         SysTryReturn(NID_APP, pPkgInfo != null, r, r, "UnregisterPackageInfo: GetUniqueId() is invalid. [%d]", id);
1800
1801         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1802         pPackageInfoImpl->SetAppId(packageId);
1803         id = pPackageInfoImpl->GetUniqueId();
1804         SysTryReturn(NID_APP, id > 0, r, r, "UnregisterPackageInfo: GetUniqueId() is invalid. [%d]", id);
1805
1806         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, false);
1807         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.Construct is failed. [%s]", GetErrorMessage(r));
1808
1809         // AppInfoLookup
1810         pList = pPackageInfoImpl->GetAppInfoListN();
1811         if (pList != null)
1812         {
1813                 for (int i = 0; i < pList->GetCount(); i++)
1814                 {
1815                         _PackageAppInfoImpl* pAppInfoImpl = dynamic_cast <_PackageAppInfoImpl*>(pList->GetAt(i));
1816
1817                         if (pAppInfoImpl != null)
1818                         {
1819                                 int uniqueId = 0;
1820                                 uniqueId = pAppInfoImpl->GetUniqueId();
1821
1822                                 query.Format(1024, L"DELETE FROM AppInfoLookup WHERE AppInfoID = %d", uniqueId);
1823                                 r = db.ExecuteSql(query, true);
1824                                 SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1825                                 query.Clear();
1826                         }
1827                 }
1828                 delete pList;
1829         }
1830
1831         // PkgInfo
1832         query.Format(1024, L"DELETE FROM PkgInfo WHERE PKG_ID = '%ls'", packageId.GetPointer());
1833         r = db.ExecuteSql(query, true);
1834         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1835         query.Clear();
1836
1837         // AppInfo
1838         query.Format(1024, L"DELETE FROM AppInfo WHERE ID = %d", id);
1839         r = db.ExecuteSql(query, true);
1840         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1841         query.Clear();
1842
1843         // PkgPrivileges
1844         query.Format(1024, L"DELETE FROM PkgPrivileges WHERE ID = %d", id);
1845         r = db.ExecuteSql(query, true);
1846         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1847         query.Clear();
1848
1849         // DataControl
1850         query.Format(1024, L"DELETE FROM DataControl WHERE ID = %d", id);
1851         r = db.ExecuteSql(query, true);
1852         SysTryReturn(NID_APP, r == E_SUCCESS, r, r, "UnregisterPackageInfo: db.ExecuteSql is failed. [%s]", GetErrorMessage(r));
1853         query.Clear();
1854
1855         delete pPkgInfo;
1856         return r;
1857 }
1858
1859 PackageInfo*
1860 _PackageManagerImpl::GetPackageInfoN(const String& providerId, const String& operationId) const
1861 {
1862         result r = E_SUCCESS;
1863         PackageInfo* pPkgInfo = null;
1864         Database db;
1865         DbStatement* pStmt = null;
1866         DbEnumerator* pEnum = null;
1867         String query;
1868
1869         query.Format(1024, L"SELECT PkgInfo.PKG_ID FROM PkgInfo, AppInfo, AppInfoLookup, AppControl, Capability "
1870                         "WHERE AppControl.PROVIDER_ID ='%ls' and Capability.OPERATION_ID ='%ls' and AppControl.ID = AppInfoLookup.AppControlID "
1871                         "and Capability.ID = AppInfoLookup.CapabilityID and AppInfoLookup.AppInfoID = AppInfo.UNIQUE_ID and AppInfo.ID = PkgInfo.UNIQUE_ID "
1872                         "GROUP BY AppInfoID"
1873                         , providerId.GetPointer(), operationId.GetPointer());
1874
1875         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1876         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1877
1878         pStmt = CreateStatementN(db, query);
1879         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1880
1881         pEnum = ExecuteStatementN(db, pStmt);
1882         if (pEnum != null)
1883         {
1884                 if (pEnum->MoveNext() == E_SUCCESS)
1885                 {
1886                         PackageId packageId;
1887                         pEnum->GetStringAt(0, packageId);
1888
1889                         pPkgInfo = GetPackageInfoN(packageId);
1890                 }
1891
1892                 delete pEnum;
1893         }
1894         else
1895         {
1896                 r = E_OBJ_NOT_FOUND;
1897         }
1898
1899 CATCH:
1900         delete pStmt;
1901         return pPkgInfo;
1902 }
1903
1904 result
1905 _PackageManagerImpl::GetAppInfo(int uniqueId, _PackageAppInfoImpl& appInfo) const
1906 {
1907         result r = E_SUCCESS;
1908         Database db;
1909         DbStatement* pStmt = null;
1910         DbEnumerator* pEnum = null;
1911         String query;
1912
1913         query.Format(1024, L"SELECT * FROM AppInfo WHERE UNIQUE_ID = %d", uniqueId);
1914
1915         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1916         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1917
1918         pStmt = CreateStatementN(db, query);
1919         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1920
1921         pEnum = ExecuteStatementN(db, pStmt);
1922         if (pEnum != null)
1923         {
1924                 if (pEnum->MoveNext() == E_SUCCESS)
1925                 {
1926                         int uniqueId = 0;
1927                         int pkgId = 0;
1928                         String name;
1929                         String defaultapp;
1930                         String mainmenuIcon;
1931                         String settingIcon;
1932                         String tickerIcon;
1933                         String quickpanelIcon;
1934                         String launchImageIcon;
1935                         int appFeature = 0;
1936                         String packageName;
1937
1938                         pEnum->GetIntAt(0, uniqueId);
1939                         pEnum->GetIntAt(1, pkgId);
1940                         pEnum->GetStringAt(2, name);
1941                         pEnum->GetStringAt(3, defaultapp);
1942                         pEnum->GetStringAt(4, mainmenuIcon);
1943                         pEnum->GetStringAt(5, settingIcon);
1944                         pEnum->GetStringAt(7, quickpanelIcon);
1945                         pEnum->GetIntAt(9, appFeature);
1946                         pEnum->GetStringAt(10, packageName);
1947
1948                         appInfo.SetUniqueId(uniqueId);
1949                         appInfo.SetPkgId(pkgId);
1950                         appInfo.SetName(name);
1951                         appInfo.SetDefault(defaultapp);
1952                         appInfo.SetMainmenuIcon(mainmenuIcon);
1953                         appInfo.SetSettingIcon(settingIcon);
1954                         appInfo.SetQuickpanelIcon(quickpanelIcon);
1955                         appInfo.SetAppFeature(appFeature);
1956                         appInfo.SetPackageName(packageName);
1957                 }
1958
1959                 delete pEnum;
1960         }
1961         else
1962         {
1963                 r = E_OBJ_NOT_FOUND;
1964         }
1965
1966 CATCH:
1967         delete pStmt;
1968         return r;
1969 }
1970
1971 ArrayList*
1972 _PackageManagerImpl::GetPackageAppInfoImplListN(const String& packageId) const
1973 {
1974         result r = E_SUCCESS;
1975         Database db;
1976         DbStatement* pStmt = null;
1977         DbEnumerator* pEnum = null;
1978         String query;
1979         //int id = 0;
1980         PackageInfo* pPkgInfo = null;
1981         _PackageInfoImpl* pPackageInfoImpl = null;
1982         ArrayList* pList = null;
1983
1984         pPkgInfo = GetPackageInfoN(packageId);
1985         SysTryCatch(NID_APP, pPkgInfo != null, , r, "[%s] GetPackageInfoN() is failed", GetErrorMessage(r));
1986
1987         pPackageInfoImpl = _PackageInfoImpl::GetInstance(pPkgInfo);
1988         query.Format(1024, L"SELECT * FROM AppInfo WHERE ID = %d", pPackageInfoImpl->GetUniqueId());
1989
1990         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
1991         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
1992
1993         pStmt = CreateStatementN(db, query);
1994         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
1995                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
1996
1997         pEnum = ExecuteStatementN(db, pStmt);
1998
1999         if (pEnum != null)
2000         {
2001                 pList = new (std::nothrow) ArrayList;
2002                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
2003
2004                 pList->Construct();
2005
2006                 while (pEnum->MoveNext() == E_SUCCESS)
2007                 {
2008                         _PackageAppInfoImpl* pPackageAppInfoImpl = new (std::nothrow) _PackageAppInfoImpl;
2009                         SysTryReturn(NID_APP, pPackageAppInfoImpl != null, null, E_OUT_OF_MEMORY, "pPackageAppInfoImpl instance must not be null.");
2010
2011                         int uniqueId = 0;
2012                         int pkgId = 0;
2013                         String name;
2014                         String defaultapp;
2015                         String mainmenuIcon;
2016                         String settingIcon;
2017                         String quickpanelIcon;
2018                         int appFeature = 0;
2019                         String packageName;
2020
2021                         pEnum->GetIntAt(0, uniqueId);
2022                         pEnum->GetIntAt(1, pkgId);
2023                         pEnum->GetStringAt(2, name);
2024                         pEnum->GetStringAt(3, defaultapp);
2025                         pEnum->GetStringAt(4, mainmenuIcon);
2026                         pEnum->GetStringAt(5, settingIcon);
2027                         pEnum->GetStringAt(7, quickpanelIcon);
2028                         pEnum->GetIntAt(9, appFeature);
2029                         pEnum->GetStringAt(10, packageName);
2030
2031                         pPackageAppInfoImpl->SetUniqueId(uniqueId);
2032                         pPackageAppInfoImpl->SetPkgId(pkgId);
2033                         pPackageAppInfoImpl->SetName(name);
2034                         pPackageAppInfoImpl->SetDefault(defaultapp);
2035                         pPackageAppInfoImpl->SetMainmenuIcon(mainmenuIcon);
2036                         pPackageAppInfoImpl->SetSettingIcon(settingIcon);
2037                         pPackageAppInfoImpl->SetQuickpanelIcon(quickpanelIcon);
2038                         pPackageAppInfoImpl->SetAppFeature(appFeature);
2039                         pPackageAppInfoImpl->SetPackageName(packageName);
2040
2041                         pList->Add(*pPackageAppInfoImpl);
2042                 }
2043
2044                 delete pEnum;
2045         }
2046
2047 CATCH:
2048         delete pPkgInfo;
2049         delete pStmt;
2050         return pList;
2051 }
2052
2053 ArrayList*
2054 _PackageManagerImpl::GetPackageAppFeatureListN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
2055 {
2056         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
2057         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
2058
2059         ArrayList* pResult = null;
2060
2061         for (int i = 0; i < pAppInfoList->GetCount(); i++)
2062         {
2063                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pAppInfoList->GetAt(i));
2064                 if (pAppInfoImpl == null)
2065                 {
2066                         continue;
2067                 }
2068
2069                 if (pAppInfoImpl->GetName() == appExecutableName)
2070                 {
2071                         pResult = pAppInfoImpl->GetAppFeatureListN();
2072                         goto OUT;
2073                 }
2074         }
2075
2076 OUT:
2077         pAppInfoList->RemoveAll(true);
2078         delete pAppInfoList;
2079
2080         return pResult;
2081 }
2082
2083 HashMapT<String, _AppFeatureInfoImpl*>*
2084 _PackageManagerImpl::GetPackageAppFeatureMapN(const PackageId& packageId, const Tizen::Base::String& appExecutableName) const
2085 {
2086         ArrayList* pAppInfoList = GetPackageAppInfoImplListN(packageId);
2087         SysTryReturn(NID_APP, pAppInfoList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] AppInfo list instance must not be null.");
2088
2089         HashMapT<String, _AppFeatureInfoImpl*>* pResult = null;
2090
2091         std::auto_ptr<IEnumerator> pEnum(pAppInfoList->GetEnumeratorN());
2092
2093         while (pEnum->MoveNext() == E_SUCCESS)
2094         {
2095                 const _PackageAppInfoImpl* pAppInfoImpl = static_cast<const _PackageAppInfoImpl*>(pEnum->GetCurrent());
2096                 if (pAppInfoImpl == null)
2097                 {
2098                         continue;
2099                 }
2100
2101                 if (pAppInfoImpl->GetName() == appExecutableName)
2102                 {
2103                         pResult = pAppInfoImpl->GetAppFeatureMapN();
2104                         goto OUT;
2105                 }
2106         }
2107
2108 OUT:
2109         pAppInfoList->RemoveAll(true);
2110         delete pAppInfoList;
2111
2112         return pResult;
2113 }
2114
2115 ArrayList*
2116 _PackageManagerImpl::GetAppLaunchConditionListN(const String& packageName) const
2117 {
2118         result r = E_SUCCESS;
2119         Database db;
2120         DbStatement* pStmt = null;
2121         DbEnumerator* pEnum = null;
2122         String query;
2123         ArrayList* pList = null;
2124
2125         query.Format(1024, L"SELECT LaunchCondition.* FROM LaunchCondition, AppInfo WHERE AppInfo.UNIQUE_ID = LaunchCondition.ID and AppInfo.PACKAGE_NAME = '%ls'", packageName.GetPointer());
2126
2127         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2128         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2129
2130         pStmt = CreateStatementN(db, query);
2131         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2132                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2133
2134         pEnum = ExecuteStatementN(db, pStmt);
2135         if (pEnum != null)
2136         {
2137                 pList = new (std::nothrow) ArrayList;
2138                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Container allocation failure.");
2139
2140                 pList->Construct();
2141
2142                 while (pEnum->MoveNext() == E_SUCCESS)
2143                 {
2144                         _LaunchConditionInfoImpl* pLaunchCondtion = new (std::nothrow) _LaunchConditionInfoImpl;
2145                         SysTryReturn(NID_APP, pLaunchCondtion != null, null, E_OUT_OF_MEMORY, "pLaunchCondtion instance must not be null.");
2146
2147                         String name;
2148                         String value;
2149
2150                         pEnum->GetStringAt(1, name);
2151                         pEnum->GetStringAt(2, value);
2152
2153                         pLaunchCondtion->SetName(name);
2154                         pLaunchCondtion->SetValue(value);
2155
2156                         pList->Add(*pLaunchCondtion);
2157
2158                         SysLog(NID_APP, "Name[%ls], Value[%ls]", name.GetPointer(), value.GetPointer());
2159                 }
2160
2161                 delete pEnum;
2162         }
2163
2164 CATCH:
2165         delete pStmt;
2166         return pList;
2167 }
2168
2169 result
2170 _PackageManagerImpl::RegisterAppInfoList(int id, ArrayList* pList)
2171 {
2172         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2173
2174         result r = E_SUCCESS;
2175         String query;
2176         DbStatement* pStmt = null;
2177
2178         if (pList != null)
2179         {
2180                 for (int i = 0; i < pList->GetCount(); i++)
2181                 {
2182                         _PackageAppInfoImpl* pAppInfoImpl = dynamic_cast <_PackageAppInfoImpl*>(pList->GetAt(i));
2183
2184                         if (pAppInfoImpl != null)
2185                         {
2186                                 DbEnumerator* pEnum = null;
2187                                 int uniqueId = 0;
2188
2189                                 String name = pAppInfoImpl->GetName();
2190                                 String defaultapp = pAppInfoImpl->GetDefault();
2191                                 String mainmenuIcon = pAppInfoImpl->GetMainmenuIcon();
2192                                 String settingIcon = pAppInfoImpl->GetSettingIcon();
2193                                 String quickpanelIcon = pAppInfoImpl->GetQuickpanelIcon();
2194                                 int appFeature = pAppInfoImpl->GetAppFeature();
2195                                 String packageName = pAppInfoImpl->GetPackageName();
2196                                 String type = pAppInfoImpl->GetType();
2197
2198                                 ArrayList* pLaunchConditionImplList = pAppInfoImpl->GetLaunchConditionList();
2199                                 ArrayList* pNotificationImplList = pAppInfoImpl->GetNotificationList();
2200                                 ArrayList* pAppFeatureImplList = pAppInfoImpl->GetAppFeatureList();
2201                                 ArrayList* pDataControlImplList = pAppInfoImpl->GetDataControlList();
2202
2203                                 query.Format(
2204                                         1024, L"INSERT INTO AppInfo "
2205                                                   "(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) "
2206                                                   "VALUES (?,?,?,?,?,?,?,?,?,?,?)");
2207
2208                                 pStmt = CreateStatementN(*__pDb, query);
2209                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2210
2211                                 if (id != 0)
2212                                 {
2213                                         r = pStmt->BindInt(0, id);
2214                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2215                                 }
2216
2217                                 if (!name.IsEmpty())
2218                                 {
2219                                         r = pStmt->BindString(1, name);
2220                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2221                                 }
2222
2223                                 if (!defaultapp.IsEmpty())
2224                                 {
2225                                         r = pStmt->BindString(2, defaultapp);
2226                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2227                                 }
2228
2229                                 if (!mainmenuIcon.IsEmpty())
2230                                 {
2231                                         r = pStmt->BindString(3, mainmenuIcon);
2232                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2233                                 }
2234
2235                                 if (!settingIcon.IsEmpty())
2236                                 {
2237                                         r = pStmt->BindString(4, settingIcon);
2238                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2239                                 }
2240
2241                                 if (!quickpanelIcon.IsEmpty())
2242                                 {
2243                                         r = pStmt->BindString(6, quickpanelIcon);
2244                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2245                                 }
2246
2247                                 if (appFeature != 0)
2248                                 {
2249                                         r = pStmt->BindInt(8, appFeature);
2250                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2251                                 }
2252
2253                                 if (!packageName.IsEmpty())
2254                                 {
2255                                         r = pStmt->BindString(9, packageName);
2256                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2257                                 }
2258
2259                                 if (!type.IsEmpty())
2260                                 {
2261                                         r = pStmt->BindString(10, type);
2262                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2263                                 }
2264
2265                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2266
2267                                 query.Clear();
2268                                 delete pStmt;
2269                                 pStmt = null;
2270                                 delete pEnum;
2271
2272                                 pAppInfoImpl->SetPkgId(id);
2273                                 uniqueId = pAppInfoImpl->GetUniqueId();
2274                                 RegisterLaunchConditionList(uniqueId, pLaunchConditionImplList);
2275                                 RegisterNotificationList(uniqueId, pNotificationImplList);
2276                                 RegisterAppFeatureList(uniqueId, pAppFeatureImplList);
2277                                 RegisterDataControlList(uniqueId, pDataControlImplList);
2278                                 //RegisterAppControlList(uniqueId, pAppControlImplList);
2279                         }
2280                 }
2281         }
2282
2283         r = GetLastResult();
2284
2285 CATCH:
2286         delete pStmt;
2287
2288         return r;
2289 }
2290
2291 result
2292 _PackageManagerImpl::RegisterLaunchConditionList(int id, ArrayList* pList)
2293 {
2294         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2295
2296         result r = E_SUCCESS;
2297         String query;
2298         DbStatement* pStmt = null;
2299
2300         if (pList != null)
2301         {
2302                 for (int i = 0; i < pList->GetCount(); i++)
2303                 {
2304                         _LaunchConditionInfoImpl* pLaunchCondition = dynamic_cast<_LaunchConditionInfoImpl*>(pList->GetAt(i));
2305
2306                         if (pLaunchCondition != null)
2307                         {
2308                                 DbEnumerator* pEnum = null;
2309
2310                                 String name = pLaunchCondition->GetName();
2311                                 String value = pLaunchCondition->GetValue();
2312
2313                                 query.Format(1024, L"INSERT INTO LaunchCondition (ID, NAME, VALUE) VALUES (?,?,?)");
2314
2315                                 pStmt = CreateStatementN(*__pDb, query);
2316                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2317
2318                                 if (id != 0)
2319                                 {
2320                                         r = pStmt->BindInt(0, id);
2321                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2322                                 }
2323
2324                                 if (!name.IsEmpty())
2325                                 {
2326                                         r = pStmt->BindString(1, name);
2327                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2328                                 }
2329
2330                                 if (!value.IsEmpty())
2331                                 {
2332                                         r = pStmt->BindString(2, value);
2333                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2334                                 }
2335
2336                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2337
2338                                 query.Clear();
2339                                 delete pStmt;
2340                                 pStmt = null;
2341                                 delete pEnum;
2342                         }
2343                 }
2344         }
2345
2346         r = GetLastResult();
2347
2348 CATCH:
2349         delete pStmt;
2350
2351         return r;
2352 }
2353
2354 result
2355 _PackageManagerImpl::RegisterNotificationList(int id, ArrayList* pList)
2356 {
2357         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2358
2359         result r = E_SUCCESS;
2360         String query;
2361         DbStatement* pStmt = null;
2362
2363         if (pList != null)
2364         {
2365                 for (int i = 0; i < pList->GetCount(); i++)
2366                 {
2367                         _NotificationInfoImpl* pNotification = dynamic_cast<_NotificationInfoImpl*>(pList->GetAt(i));
2368
2369                         if (pNotification != null)
2370                         {
2371                                 DbEnumerator* pEnum = null;
2372
2373                                 String name = pNotification->GetName();
2374                                 String value = pNotification->GetValue();
2375
2376                                 query.Format(1024, L"INSERT INTO Notification (ID, NAME, VALUE) VALUES (?,?,?)");
2377
2378                                 pStmt = CreateStatementN(*__pDb, query);
2379                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2380
2381                                 if (id != 0)
2382                                 {
2383                                         r = pStmt->BindInt(0, id);
2384                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2385                                 }
2386
2387                                 if (!name.IsEmpty())
2388                                 {
2389                                         r = pStmt->BindString(1, name);
2390                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2391                                 }
2392
2393                                 if (!value.IsEmpty())
2394                                 {
2395                                         r = pStmt->BindString(2, value);
2396                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2397                                 }
2398
2399                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2400
2401                                 query.Clear();
2402                                 delete pStmt;
2403                                 pStmt = null;
2404                                 delete pEnum;
2405                         }
2406                 }
2407         }
2408
2409         r = GetLastResult();
2410
2411 CATCH:
2412         delete pStmt;
2413
2414         return r;
2415 }
2416
2417 result
2418 _PackageManagerImpl::RegisterAppFeatureList(int id, ArrayList* pList)
2419 {
2420         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2421
2422         result r = E_SUCCESS;
2423         String query;
2424         DbStatement* pStmt = null;
2425
2426         if (pList != null)
2427         {
2428                 for (int i = 0; i < pList->GetCount(); i++)
2429                 {
2430                         _AppFeatureInfoImpl* pAppFeature = dynamic_cast<_AppFeatureInfoImpl*>(pList->GetAt(i));
2431
2432                         if (pAppFeature != null)
2433                         {
2434                                 DbEnumerator* pEnum = null;
2435
2436                                 String name = pAppFeature->GetName();
2437                                 String value = pAppFeature->GetValue();
2438
2439                                 query.Format(1024, L"INSERT INTO AppFeature (ID, NAME, VALUE) VALUES (?,?,?)");
2440
2441                                 pStmt = CreateStatementN(*__pDb, query);
2442                                 //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2443
2444                                 if (id != 0)
2445                                 {
2446                                         r = pStmt->BindInt(0, id);
2447                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2448                                 }
2449
2450                                 if (!name.IsEmpty())
2451                                 {
2452                                         r = pStmt->BindString(1, name);
2453                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2454                                 }
2455
2456                                 if (!value.IsEmpty())
2457                                 {
2458                                         r = pStmt->BindString(2, value);
2459                                         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2460                                 }
2461
2462                                 pEnum = ExecuteStatementN(*__pDb, pStmt);
2463
2464                                 query.Clear();
2465                                 delete pStmt;
2466                                 pStmt = null;
2467                                 delete pEnum;
2468                         }
2469                 }
2470         }
2471
2472         r = GetLastResult();
2473
2474 CATCH:
2475         delete pStmt;
2476
2477         return r;
2478 }
2479
2480 result
2481 _PackageManagerImpl::RegisterDataControlList(int id, ArrayList* pList)
2482 {
2483         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2484
2485         result r = E_SUCCESS;
2486         String query;
2487         DbStatement* pStmt = null;
2488
2489         if (pList != null)
2490         {
2491                 for (int i = 0; i < pList->GetCount(); i++)
2492                 {
2493                         _DataControlInfoImpl* pDataControl = dynamic_cast<_DataControlInfoImpl*>(pList->GetAt(i));
2494
2495                         if (pDataControl != null)
2496                         {
2497                                 DbEnumerator* pEnum = null;
2498
2499                                 String providerId = pDataControl->GetProviderId();
2500                                 ArrayList* pTypeList = pDataControl->GetControlTypeList();
2501
2502                                 if (pTypeList != null)
2503                                 {
2504                                         for (int j = 0; j < pTypeList->GetCount(); j++)
2505                                         {
2506                                                 _DataControlTypeImpl* pControlType = dynamic_cast<_DataControlTypeImpl*>(pTypeList->GetAt(j));
2507
2508                                                 if (pControlType != null)
2509                                                 {
2510                                                         String access = pControlType->GetAccess();
2511                                                         String type = pControlType->GetType();
2512
2513                                                         query.Format(1024, L"INSERT INTO DataControl (ID, PROVIDER_ID, TYPE, ACCESS) VALUES (?,?,?,?)");
2514
2515                                                         pStmt = CreateStatementN(*__pDb, query);
2516                                                         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2517
2518                                                         if (id != 0)
2519                                                         {
2520                                                                 r = pStmt->BindInt(0, id);
2521                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2522                                                         }
2523
2524                                                         if (!providerId.IsEmpty())
2525                                                         {
2526                                                                 r = pStmt->BindString(1, providerId);
2527                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2528                                                         }
2529
2530                                                         if (!type.IsEmpty())
2531                                                         {
2532                                                                 r = pStmt->BindString(2, type);
2533                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2534                                                         }
2535
2536                                                         if (!access.IsEmpty())
2537                                                         {
2538                                                                 r = pStmt->BindString(3, access);
2539                                                                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2540                                                         }
2541
2542                                                         pEnum = ExecuteStatementN(*__pDb, pStmt);
2543
2544                                                         query.Clear();
2545                                                         delete pStmt;
2546                                                         pStmt = null;
2547                                                         delete pEnum;
2548                                                 }
2549                                         }
2550                                 }
2551                         }
2552                 }
2553         }
2554
2555         r = GetLastResult();
2556
2557 CATCH:
2558         delete pStmt;
2559
2560         return r;
2561 }
2562
2563 int
2564 _PackageManagerImpl::FindRecord(const String& tableName, const String& columnName, const String& value) const
2565 {
2566
2567         result r = E_SUCCESS;
2568         Database db;
2569         String query;
2570         DbStatement* pStmt = null;
2571         DbEnumerator* pEnum = null;
2572         int uniqueId = 0;
2573
2574         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2575         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2576
2577         query.Format(1024, L"SELECT * FROM %ls WHERE %ls = '%ls'", tableName.GetPointer(), columnName.GetPointer(), value.GetPointer());
2578
2579         pStmt = CreateStatementN(db, query);
2580         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2581
2582         pEnum = ExecuteStatementN(db, pStmt);
2583
2584         if (pEnum != null)
2585         {
2586                 if (pEnum->MoveNext() == E_SUCCESS)
2587                 {
2588                         pEnum->GetIntAt(0, uniqueId);
2589                 }
2590
2591                 delete pEnum;
2592         }
2593
2594 //CATCH:
2595         delete pStmt;
2596
2597         return uniqueId;
2598 }
2599
2600 result
2601 _PackageManagerImpl::GetRecord(const String& tableName, int uniqueId, const String& columnName, String& value) const
2602 {
2603         result r = E_SUCCESS;
2604         Database db;
2605         String query;
2606         DbStatement* pStmt = null;
2607         DbEnumerator* pEnum = null;
2608
2609         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2610         //SysTryCatch(NID_APP, r == E_SUCCESS, r, r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2611
2612         query.Format(1024, L"SELECT %ls FROM %ls WHERE UNIQUE_ID = %d", columnName.GetPointer(), tableName.GetPointer(), uniqueId);
2613
2614         pStmt = CreateStatementN(db, query);
2615         //SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2616
2617         pEnum = ExecuteStatementN(db, pStmt);
2618
2619         if (pEnum != null)
2620         {
2621                 if (pEnum->MoveNext() == E_SUCCESS)
2622                 {
2623                         pEnum->GetStringAt(0, value);
2624                 }
2625
2626                 delete pEnum;
2627         }
2628
2629 //CATCH:
2630         delete pStmt;
2631
2632         return r;
2633 }
2634
2635 result
2636 _PackageManagerImpl::RegisterPrivileges(int id, const String& privileges, const String& hmacPrivileges, int certType)
2637 {
2638         SysTryReturnResult(NID_APP, __pDb != null, E_SYSTEM, "__pDb is null");
2639
2640         result r = E_SUCCESS;
2641         String query;
2642         DbStatement* pStmt = null;
2643         DbEnumerator* pEnum = null;
2644
2645         query.Format(1024, L"INSERT INTO PkgPrivileges (ID, PRIVILEGES, HMAC_PPRIVILEGES, CERTIFICATE_TYPE) VALUES (?,?,?,?)");
2646
2647         pStmt = CreateStatementN(*__pDb, query);
2648         SysTryCatch(NID_APP, pStmt != null, GetLastResult(), GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2649
2650         if (id != 0)
2651         {
2652                 r = pStmt->BindInt(0, id);
2653                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2654         }
2655
2656         if (!privileges.IsEmpty())
2657         {
2658                 r = pStmt->BindString(1, privileges);
2659                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2660         }
2661
2662         if (!hmacPrivileges.IsEmpty())
2663         {
2664                 r = pStmt->BindString(2, hmacPrivileges);
2665                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2666         }
2667
2668         if (certType != 0)
2669         {
2670                 r = pStmt->BindInt(3, certType);
2671                 SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while constructing a database.", GetErrorMessage(r));
2672         }
2673
2674         pEnum = ExecuteStatementN(*__pDb, pStmt);
2675
2676         delete pStmt;
2677         pStmt = null;
2678         delete pEnum;
2679         pEnum = null;
2680
2681         r = GetLastResult();
2682
2683 CATCH:
2684         delete pStmt;
2685         return r;
2686 }
2687
2688 result
2689 _PackageManagerImpl::GetPackageName(const PackageId& packageId, const String* pName, char* pPackageName, int bufferSize)
2690 {
2691         result r = E_SUCCESS;
2692         Database db;
2693         DbStatement* pStmt = null;
2694         DbEnumerator* pEnum = null;
2695         String query;
2696         Tizen::Base::String packageName;
2697
2698         if (pName == null)
2699         {
2700                 query.Format(
2701                         1024,
2702                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2703                         "True", packageId.GetPointer());
2704         }
2705         else
2706         {
2707                 query.Format(
2708                         1024,
2709                         L"SELECT AppInfo.PACKAGE_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and APP_NAME = '%ls' and PkgInfo.PKG_ID = '%ls'",
2710                         pName->GetPointer(), packageId.GetPointer());
2711         }
2712
2713         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2714         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2715
2716         pStmt = CreateStatementN(db, query);
2717         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2718                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2719
2720         pEnum = ExecuteStatementN(db, pStmt);
2721         if (pEnum != null)
2722         {
2723                 if (pEnum->MoveNext() == E_SUCCESS)
2724                 {
2725                         pEnum->GetStringAt(0, packageName);
2726                         snprintf(pPackageName, bufferSize, "%ls", packageName.GetPointer());
2727                 }
2728                 delete pEnum;
2729         }
2730         else
2731         {
2732                 r = E_OBJ_NOT_FOUND;
2733         }
2734
2735 CATCH:
2736         delete pStmt;
2737
2738         return r;
2739 }
2740
2741 String
2742 _PackageManagerImpl::GetDefaultAppExecutableName(const PackageId& packageId)
2743 {
2744         result r = E_SUCCESS;
2745         Database db;
2746         DbStatement* pStmt = null;
2747         DbEnumerator* pEnum = null;
2748         String query;
2749         String executableName;
2750
2751         query.Format(
2752                 1024,
2753                 L"SELECT AppInfo.APP_NAME FROM AppInfo, PkgInfo WHERE AppInfo.ID = PkgInfo.UNIQUE_ID and AppInfo.APP_DEFAULT = '%s' and PkgInfo.PKG_ID = '%ls'",
2754                 "True", packageId.GetPointer());
2755
2756         r = db.Construct(PACKAGE_DATABASE_FILE_NAME, "r");
2757         SysTryCatch(NID_APP, r == E_SUCCESS, , r, "[%s] An error occurs while opening a database.", GetErrorMessage(r));
2758
2759         pStmt = CreateStatementN(db, query);
2760         SysTryCatch(NID_APP, pStmt != null, GetLastResult(),
2761                            GetLastResult(), "[%s] An error occurs while creating a database statement.", GetErrorMessage(GetLastResult()));
2762
2763         pEnum = ExecuteStatementN(db, pStmt);
2764         if (pEnum != null)
2765         {
2766                 if (pEnum->MoveNext() == E_SUCCESS)
2767                 {
2768                         pEnum->GetStringAt(0, executableName);
2769                 }
2770                 delete pEnum;
2771         }
2772         else
2773         {
2774                 r = E_OBJ_NOT_FOUND;
2775                 SetLastResult(r);
2776         }
2777
2778 CATCH:
2779         delete pStmt;
2780
2781         return executableName;
2782 }
2783
2784 DbStatement*
2785 _PackageManagerImpl::CreateStatementN(Database& db, const String& query)
2786 {
2787         result r = E_SUCCESS;
2788         DbStatement* pStmt = null;
2789
2790         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2791         {
2792                 pStmt = db.CreateStatementN(query);
2793                 r = GetLastResult();
2794
2795                 if (r != E_OBJECT_LOCKED)
2796                 {
2797                         break;
2798                 }
2799                 else
2800                 {
2801                         SysLog(NID_APP, "RetryCount[%d] CreateStatementN - E_OBJECT_LOCKED", i);
2802                         delete pStmt;
2803                         pStmt = null;
2804                         usleep(50000);
2805                 }
2806         }
2807
2808         return pStmt;
2809 }
2810
2811 DbEnumerator*
2812 _PackageManagerImpl::ExecuteStatementN(Database& db, const DbStatement* pStmt)
2813 {
2814         result r = E_SUCCESS;
2815         DbEnumerator* pEnum = null;
2816
2817         for (int i = 0; i < MAX_DATABASE_RETRY_COUNT; i++)
2818         {
2819                 pEnum = db.ExecuteStatementN(*pStmt);
2820                 r = GetLastResult();
2821
2822                 if (r != E_OBJECT_LOCKED)
2823                 {
2824                         break;
2825                 }
2826                 else
2827                 {
2828                         SysLog(NID_APP, "RetryCount[%d] ExecuteStatementN - E_OBJECT_LOCKED", i);
2829                         delete pEnum;
2830                         pEnum = null;
2831                         usleep(50000);
2832                 }
2833         }
2834
2835         return pEnum;
2836 }
2837
2838 } } } // Tizen::App::Package