src/app/FApp_SqlDataControlImpl.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 /**
  19  * @file        FApp_SqlDataControlImpl.cpp
  20  * @brief       This is the implementation for the %_SqlDataControlImpl class.
  21  */
  22
  23 #include <typeinfo>
  24 #include <new>
  25 #include <unique_ptr.h>
  26
  27 #include <appsvc/appsvc.h>
  28
  29 #include <FBaseInteger.h>
  30 #include <FBaseString.h>
  31 #include <FBaseLongLong.h>
  32 #include <FBaseColIList.h>
  33 #include <FBaseColIMap.h>
  34 #include <FBaseColIMapEnumerator.h>
  35 #include <FBaseRtIEventArg.h>
  36 #include <FIoFile.h>
  37 #include <FAppSqlDataControl.h>
  38 #include <FAppISqlDataControlResponseListener.h>
  39
  40 #include <FBaseSysLog.h>
  41
  42 #include <FIo_DataControlResultSetEnumerator.h>
  43
  44 #include "FApp_AppControlManager.h"
  45 #include "FApp_SqlDataControlImpl.h"
  46 #include "FApp_AppArg.h"
  47
  48 using namespace std;
  49
  50 using namespace Tizen::Base;
  51 using namespace Tizen::Base::Collection;
  52 using namespace Tizen::Base::Runtime;
  53 using namespace Tizen::App;
  54 using namespace Tizen::Io;
  55
  56 namespace Tizen { namespace App
  57 {
  58
  59 static const int MAX_REQUEST_COUNT = 128;
  60
  61 class _SqlDataControlEventArg
  62         : public IEventArg
  63 {
  64 public:
  65                 _SqlDataControlEventArg(_DataControlRequestType requestType, RequestId reqId, String providerId, String dataId,
  66                                 _DataControlResultSetEnumerator* pResultSetEnum, long long insertRowId, bool providerResult, String* pErrorMsg)
  67                         : __requestType(requestType)
  68                         , __reqId(reqId)
  69                         , __providerId(providerId)
  70                         , __dataId(dataId)
  71                         , __pResultSetEnum(pResultSetEnum)
  72                         , __insertRowId(insertRowId)
  73                         , __providerResult(providerResult)
  74                         , __pErrorMsg(pErrorMsg)
  75                 {
  76                 }
  77                 ~_SqlDataControlEventArg(void)
  78                 {
  79                         delete __pResultSetEnum;
  80                         delete __pErrorMsg;
  81                 }
  82
  83                 _DataControlRequestType __requestType;
  84                 RequestId __reqId;
  85                 String __providerId;
  86                 String __dataId;
  87                 _DataControlResultSetEnumerator* __pResultSetEnum;
  88                 long long __insertRowId;
  89                 bool __providerResult;
  90                 String* __pErrorMsg;
  91 };
  92
  93 class _SqlDataControlEvent
  94         : public Event
  95 {
  96 protected:
  97                 virtual void FireImpl(IEventListener& listener, const IEventArg& arg);
  98 };
  99
 100 void
 101 _SqlDataControlEvent::FireImpl(IEventListener& listener, const IEventArg& arg)
 102 {
 103         const _SqlDataControlEventArg* pArg = dynamic_cast<const _SqlDataControlEventArg*>(&arg);
 104         if (pArg != null)
 105         {
 106                 ISqlDataControlResponseListener* pListener = dynamic_cast<ISqlDataControlResponseListener*> (&listener);
 107                 if (pListener != null)
 108                 {
 109                         switch (pArg->__requestType)
 110                         {
 111                         case _DATACONTROL_REQUEST_TYPE_SQL_QUERY:
 112                                 pListener->OnSqlDataControlSelectResponseReceived(pArg->__reqId, pArg->__providerId, pArg->__dataId,
 113                                                 *(pArg->__pResultSetEnum), pArg->__providerResult, pArg->__pErrorMsg);
 114                                 break;
 115                         case _DATACONTROL_REQUEST_TYPE_SQL_INSERT:
 116                                 pListener->OnSqlDataControlInsertResponseReceived(pArg->__reqId, pArg->__providerId, pArg->__dataId,
 117                                                  pArg->__insertRowId, pArg->__providerResult, pArg->__pErrorMsg);
 118                                 break;
 119                         case _DATACONTROL_REQUEST_TYPE_SQL_UPDATE:
 120                                 pListener->OnSqlDataControlUpdateResponseReceived(pArg->__reqId, pArg->__providerId, pArg->__dataId,
 121                                                 pArg->__providerResult, pArg->__pErrorMsg);
 122                                 break;
 123                         case _DATACONTROL_REQUEST_TYPE_SQL_DELETE:
 124                                 pListener->OnSqlDataControlDeleteResponseReceived(pArg->__reqId, pArg->__providerId, pArg->__dataId,
 125                                                 pArg->__providerResult, pArg->__pErrorMsg);
 126                                 break;
 127                         default:
 128                                 break;
 129                         }
 130                 }
 131         }
 132 }
 133
 134 // private
 135 _SqlDataControlImpl::_SqlDataControlImpl(void)
 136         : __appId(L"")
 137         , __providerId(L"")
 138         , __access(_DATACONTROL_ACCESS_UNDEFINED)
 139         , __pPreviousListener(null)
 140         , __pSqlDataControlEvent(null)
 141 {
 142 }
 143
 144 _SqlDataControlImpl::~_SqlDataControlImpl(void)
 145 {
 146         delete __pSqlDataControlEvent;
 147 }
 148
 149 _SqlDataControlImpl*
 150 _SqlDataControlImpl::GetInstance(SqlDataControl& dc)
 151 {
 152         return dc.__pSqlDataControlImpl;
 153 }
 154
 155 const _SqlDataControlImpl*
 156 _SqlDataControlImpl::GetInstance(const SqlDataControl& dc)
 157 {
 158         return dc.__pSqlDataControlImpl;
 159 }
 160
 161 result
 162 _SqlDataControlImpl::StartSqlDataControl(int type, const IList* pDataList, int* pReq)
 163 {
 164         result r = E_SUCCESS;
 165
 166         int req = -1;
 167         _AppControlManager* pAppManagerImpl = _AppControlManager::GetInstance();
 168
 169         // Check the request count of DataControl operation
 170         int count = pAppManagerImpl->GetLaunchRequestCount();
 171         SysLog(NID_APP, "Current launch request count: %d", count);
 172
 173         SysTryReturnResult(NID_APP, count < MAX_REQUEST_COUNT, E_MAX_EXCEEDED, "The number of requests has exceeded the maximum limit.");
 174
 175         _AppArg* pArg = new (std::nothrow) _AppArg;  // XXX: pArg will be released in _AppManagerImpl::LaunchApp().
 176         SysTryReturnResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "insufficient memory");
 177
 178         pArg->Construct(*this, static_cast <_DataControlRequestType>(type), pDataList);
 179
 180         if (__pSqlDataControlEvent)
 181         {
 182                 // reqId is system-wide id because the bundle is system-wide.
 183                 _AppControlManager::_RequestGuard reqObj = _AppControlManager::_RequestGuard(*pAppManagerImpl, pArg, SqlDataControlCallback, __pSqlDataControlEvent, -1);
 184                 req = reqObj.GetRequestNumber();
 185
 186                 r = pAppManagerImpl->LaunchApp(__appId, pArg, req);
 187                 SysTryCatch(NID_APP, r == E_SUCCESS, reqObj.Invalidate(), r, "[%s] Propagating.", GetErrorMessage(r));
 188
 189                 if (pReq)
 190                 {
 191                         *pReq = req;
 192                 }
 193         }
 194         else
 195         {
 196                 r = pAppManagerImpl->LaunchApp(__appId, pArg);
 197                 delete pArg;
 198         }
 199
 200 CATCH:
 201         return r;
 202 }
 203
 204 result
 205 _SqlDataControlImpl::Select(const String& dataId, const IList* pColumnList, const String* pWhere,
 206                 const String *pOrder, RequestId& reqId, int pageNo, int countPerPage)
 207 {
 208         SysTryReturnResult(NID_APP, pageNo > 0, E_INVALID_ARG, "The specified pageNo parameter is less than 1");
 209         SysTryReturnResult(NID_APP, countPerPage > 0, E_INVALID_ARG, "The specified countPerPage parameter is less than 1");
 210         SysTryReturnResult(NID_APP, (__access & _DATACONTROL_ACCESS_READ) > 0, E_ILLEGAL_ACCESS,
 211                         "The SELECT query is not permitted by DataControl provider.");
 212
 213         const String* pColumn = null;
 214         int id = 0;
 215         result r = E_SUCCESS;
 216         SysLog(NID_APP, "[DC_CALLER] SqlDataControl SELECT");
 217
 218         ArrayList* pArgList = new ArrayList();
 219         pArgList->Construct();
 220
 221         pArgList->Add(*(new String(dataId))); // list(0): data ID
 222
 223         if (pColumnList != null)
 224         {
 225                 int columnCount = pColumnList->GetCount();
 226                 SysTryCatch(NID_APP, columnCount > 0, r = E_INVALID_ARG, E_INVALID_ARG,
 227                                 "[E_INVALID_ARG] The specified pColumnList parameter is empty.");
 228
 229                 pArgList->Add(*(new String(Integer::ToString(columnCount)))); // list(1): selected column count
 230                 SysLog(NID_APP, "[DC_CALLER] selected column count: %d", columnCount);
 231
 232                 int i = 0;
 233                 while (i < columnCount) // list(2): column list
 234                 {
 235                         pColumn = dynamic_cast< const String* >(pColumnList->GetAt(i));
 236                         SysTryCatch(NID_APP, pColumn != null, r = E_INVALID_ARG, E_INVALID_ARG,
 237                                         "[E_INVALID_ARG] The object is not String class.");
 238
 239                         pArgList->Add(*(new String(*pColumn)));
 240                         SysLog(NID_APP, "[DC_CALLER] column[%d]: %ls", i, pColumn->GetPointer());
 241                         i++;
 242                 }
 243         }
 244         else
 245         {
 246                 pArgList->Add(*(new String(L"NULL")));
 247         }
 248
 249         if (pWhere != null)     // list(3): where clause
 250         {
 251                 pArgList->Add(*(new String(*pWhere)));
 252                 SysLog(NID_APP, "[DC_CALLER] pWhere: %ls", pWhere->GetPointer());
 253         }
 254         else
 255         {
 256                 pArgList->Add(*(new String(L"NULL")));
 257         }
 258
 259         if (pOrder != null)     // list(4): order clause
 260         {
 261                 pArgList->Add(*(new String(*pOrder)));
 262                 SysLog(NID_APP, "[DC_CALLER] pOrder: %ls", pOrder->GetPointer());
 263         }
 264         else
 265         {
 266                 pArgList->Add(*(new String(L"NULL")));
 267         }
 268
 269         pArgList->Add(*(new String(Integer::ToString(pageNo)))); // list(5): page number
 270
 271         pArgList->Add(*(new String(Integer::ToString(countPerPage)))); // list(6): count per page
 272
 273         r = StartSqlDataControl(_DATACONTROL_REQUEST_TYPE_SQL_QUERY, pArgList, &id);
 274         SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating to caller...", GetErrorMessage(r));
 275
 276         reqId = static_cast< RequestId >(id);
 277
 278         SysLog(NID_APP, "[DC_CALLER] dataId: %ls, pColumnList: 0x%x, pWhere: 0x%x, pOrder: 0x%x, reqId: %d, pageNo: %d, countPerPage: %d",
 279                         dataId.GetPointer(), pColumnList, pWhere, pOrder, reqId, pageNo, countPerPage);
 280
 281         // fall through
 282 CATCH:
 283         pArgList->RemoveAll(true);
 284         delete pArgList;
 285
 286         return r;
 287 }
 288
 289 result
 290 _SqlDataControlImpl::SqlDataControlCallback(void* data, _AppArg* pArg, _AppArg* pResArg, service_result_e res, int prop)
 291 {
 292         ArrayList* pResultList = null;
 293         ArrayList* pOrigList = null;
 294         String* pResult = null;
 295         String* pRequestType = null;
 296         String* pReqId = null;
 297         String* pProviderId = null;
 298         String* pDataId = null;
 299         String* pErrorMessage = null;
 300         String* pErrorMsg = null;
 301         String* pTmpPath = null;
 302         String* pInsertRowId = null;
 303         _DataControlResultSetEnumerator* pResultSetEnum = null;
 304         int requestType = 0;
 305         int reqId = 0;
 306         int providerRes = 0;
 307         bool providerResult = true;
 308         bundle* origBundle = null;
 309         bundle* resBundle = null;
 310         _SqlDataControlEventArg* pEventArg = null;
 311         result r = E_SUCCESS;
 312
 313         SysTryReturnResult(NID_APP, pResArg != null, E_INVALID_ARG, "Empty result callback.");
 314         SysLog(NID_APP, "appsvc result value: %d", res);
 315
 316         resBundle = pResArg->GetBundle();
 317         if (resBundle)
 318         {
 319                 //ISqlDataControlResponseListener* pListener = static_cast< ISqlDataControlResponseListener* >(data);
 320         _SqlDataControlEvent* pSqlDataControlEvent = static_cast< _SqlDataControlEvent* >(data);
 321
 322                 if (pSqlDataControlEvent != null && typeid(pSqlDataControlEvent) == typeid(_SqlDataControlEvent*))
 323                 {
 324                         const char* p = null;
 325
 326                         // result list
 327                         pResultList = _AppArg::GetListN(resBundle, OSP_K_ARG);
 328                         SysTryCatch(NID_APP, pResultList, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid result");
 329
 330                         pResult = dynamic_cast <String*>(pResultList->GetAt(0));
 331                         SysTryCatch(NID_APP, pResult, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid result");
 332                         Integer::Parse(*pResult, providerRes);
 333                         providerResult = static_cast< bool >(providerRes);
 334
 335                         pErrorMessage = dynamic_cast< String* >(pResultList->GetAt(1));
 336                         SysTryCatch(NID_APP, pErrorMessage, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid result");
 337                         pErrorMsg = new (std::nothrow) String(*pErrorMessage);
 338                         SysTryCatch(NID_APP, pErrorMsg, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 339                                         "[E_OUT_OF_MEMORY] The memory is insufficient.");
 340
 341                         origBundle = pArg->GetBundle();
 342
 343                         // request info
 344                         p = appsvc_get_data(origBundle, OSP_K_DATACONTROL_REQUEST_TYPE);
 345                         SysTryCatch(NID_APP, p, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid bundle");
 346                         pRequestType = new (std::nothrow) String(p);
 347                         SysTryCatch(NID_APP, pRequestType, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 348                                         "[E_OUT_OF_MEMORY] The memory is insufficient.");
 349                         Integer::Parse(*pRequestType, requestType);
 350
 351                         p = appsvc_get_data(origBundle, OSP_K_REQUEST_ID);
 352                         SysTryCatch(NID_APP, p, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid bundle");
 353                         pReqId = new (std::nothrow) String(p);
 354                         SysTryCatch(NID_APP, pReqId, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 355                                         "[E_OUT_OF_MEMORY] The memory is insufficient.");
 356                         Integer::Parse(*pReqId, reqId);
 357
 358                         p = appsvc_get_data(origBundle, OSP_K_DATACONTROL_PROVIDER);
 359                         SysTryCatch(NID_APP, p, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid bundle");
 360                         pProviderId = new (std::nothrow) String(p);
 361                         SysTryCatch(NID_APP, pProviderId, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 362                                         "[E_OUT_OF_MEMORY] The memory is insufficient.");
 363
 364                         pOrigList = _AppArg::GetListN(origBundle, OSP_K_ARG);
 365                         SysTryCatch(NID_APP, pOrigList, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid bundle");
 366                         pDataId = dynamic_cast <String*>(pOrigList->GetAt(0));
 367                         SysTryCatch(NID_APP, pDataId, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid bundle");
 368
 369                         SysLog(NID_APP, "providerResult: %ld, requestType: %d, reqId: %d, providerId: %ls, dataId: %ls, errorMsg: %ls ",
 370                                         providerRes, requestType, reqId, pProviderId->GetPointer(), pDataId->GetPointer(), pErrorMsg->GetPointer());
 371
 372                         switch (static_cast <_DataControlRequestType>(requestType))
 373                         {
 374                         case _DATACONTROL_REQUEST_TYPE_SQL_QUERY:
 375                         {
 376                                 pResultSetEnum = new (std::nothrow) _DataControlResultSetEnumerator;
 377                                 SysTryCatch(NID_APP, pResultSetEnum, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
 378                                                 "[E_OUT_OF_MEMORY] The memory is insufficient.");
 379
 380                                 if (providerResult == true)
 381                                 {
 382                                         pTmpPath = dynamic_cast< String* >(pResultList->GetAt(2)); // result list[2]
 383                                         if (pTmpPath == null)
 384                                         {
 385                                                 SysLogException(NID_APP, E_SYSTEM, "[E_SYSTEM] invalid result");
 386                                                 delete pResultSetEnum;
 387                                                 goto CATCH;
 388                                         }
 389
 390                                         SysLog(NID_APP, "tempPath: %ls", pTmpPath->GetPointer());
 391                                         if (pTmpPath->Equals(L"NoResultSet", true) == false) // Result set exists
 392                                         {
 393                                                 pResultSetEnum->SetPath(*pTmpPath);
 394                                         }
 395                                 }
 396
 397                                 pEventArg = new (std::nothrow) _SqlDataControlEventArg(_DATACONTROL_REQUEST_TYPE_SQL_QUERY, static_cast <RequestId>(reqId),
 398                                                 *pProviderId, *pDataId, pResultSetEnum, -1, providerResult, pErrorMsg);
 399                                 SysTryCatch(NID_APP, pEventArg != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 400                                 pSqlDataControlEvent->Fire(*pEventArg);
 401
 402                                 if (pTmpPath)
 403                                 {
 404                                         r = File::Remove(*pTmpPath); // Remove temporary file after releasing _ResultSetEnumerator.
 405                                         SysTryLog(NID_APP, !IsFailed(r), "Failed to remove temp file for result set: %ls", pTmpPath->GetPointer());
 406                                 }
 407
 408                                 break;
 409                         }
 410                         case _DATACONTROL_REQUEST_TYPE_SQL_INSERT:
 411                         {
 412                                 long long insertRowId = -1;
 413                                 if (providerResult == true)
 414                                 {
 415                                         pInsertRowId = dynamic_cast< String* >(pResultList->GetAt(2)); // result list[2]
 416                                         SysTryCatch(NID_APP, pInsertRowId, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid result");
 417
 418                                         LongLong::Parse(*pInsertRowId, insertRowId);
 419                                 }
 420
 421                                 pEventArg = new (std::nothrow) _SqlDataControlEventArg(_DATACONTROL_REQUEST_TYPE_SQL_INSERT, static_cast <RequestId>(reqId),
 422                                                 *pProviderId, *pDataId, null, insertRowId, providerResult, pErrorMsg);
 423                                 SysTryCatch(NID_APP, pEventArg != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 424                                 pSqlDataControlEvent->Fire(*pEventArg);
 425                                 break;
 426                         }
 427                         case _DATACONTROL_REQUEST_TYPE_SQL_UPDATE:
 428                         {
 429                                 pEventArg = new (std::nothrow) _SqlDataControlEventArg(_DATACONTROL_REQUEST_TYPE_SQL_UPDATE, static_cast <RequestId>(reqId),
 430                                                 *pProviderId, *pDataId, null, -1, providerResult, pErrorMsg);
 431                                 SysTryCatch(NID_APP, pEventArg != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 432                                 pSqlDataControlEvent->Fire(*pEventArg);
 433                                 break;
 434                         }
 435                         case _DATACONTROL_REQUEST_TYPE_SQL_DELETE:
 436                         {
 437                                 pEventArg = new (std::nothrow) _SqlDataControlEventArg(_DATACONTROL_REQUEST_TYPE_SQL_DELETE, static_cast <RequestId>(reqId),
 438                                                 *pProviderId, *pDataId, null, -1, providerResult, pErrorMsg);
 439                                 SysTryCatch(NID_APP, pEventArg != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 440                                 pSqlDataControlEvent->Fire(*pEventArg);
 441                                 break;
 442                         }
 443                         default:
 444                                 break;
 445                         }
 446
 447                         pResultList->RemoveAll(true);
 448                         delete pResultList;
 449
 450                         pOrigList->RemoveAll(true);
 451                         delete pOrigList;
 452
 453                         delete pRequestType;
 454                         delete pReqId;
 455                         delete pProviderId;
 456                 }
 457         }
 458
 459         // Remove the request count
 460         SysLog(NID_APP, "Remove a launch request: reqId: %d", reqId);
 461         _AppControlManager::GetInstance()->RemoveLaunchRequest(reqId);
 462
 463         return E_SUCCESS;
 464
 465 CATCH:
 466         if (pResultList)
 467         {
 468                 pResultList->RemoveAll(true);
 469                 delete pResultList;
 470         }
 471
 472         if (pOrigList)
 473         {
 474                 pOrigList->RemoveAll(true);
 475                 delete pOrigList;
 476         }
 477
 478         delete pRequestType;
 479         delete pReqId;
 480         delete pProviderId;
 481
 482         return r;
 483 }
 484
 485 result
 486 _SqlDataControlImpl::Insert(const Tizen::Base::String& dataId, const Tizen::Base::Collection::IMap& insertMap,
 487                 RequestId& reqId)
 488 {
 489         SysTryReturnResult(NID_APP, (__access & _DATACONTROL_ACCESS_WRITE) > 0, E_ILLEGAL_ACCESS,
 490                         "The INSERT query is not permitted by DataControl provider.");
 491
 492         int columnCount = 0;
 493         int id = 0;
 494         int i = 0;
 495         result r = E_SUCCESS;
 496         SysLog(NID_APP, "[DC_CALLER] SqlDataControl INSERT");
 497
 498         columnCount = insertMap.GetCount();
 499         SysTryReturnResult(NID_APP, columnCount > 0, E_INVALID_ARG, "The specified insertMap parameter is empty.");
 500
 501         ArrayList* pArgList = new ArrayList();
 502         pArgList->Construct();
 503
 504         pArgList->Add(*(new String(dataId))); // list(0): data ID
 505
 506         pArgList->Add(*(new String(Integer::ToString(columnCount)))); // list(1): inserted column count
 507         SysLog(NID_APP, "[DC_CALLER] inserted column count: %d", columnCount);
 508
 509         IMapEnumerator* pMapEnum = const_cast< IMap* >(&insertMap)->GetMapEnumeratorN();
 510         while (pMapEnum->MoveNext() == E_SUCCESS) // list(2): column-value pairs
 511         {
 512                 String* pColumn = dynamic_cast< String* >(pMapEnum->GetKey());
 513                 SysTryCatch(NID_APP, pColumn != null, r = E_INVALID_ARG, E_INVALID_ARG,
 514                                 "[E_INVALID_ARG] The object is not String class.");
 515
 516                 pArgList->Add(*(new String(*pColumn)));
 517                 SysLog(NID_APP, "[DC_CALLER] pColumn[%d]: %ls", i, pColumn->GetPointer());
 518
 519                 String* pValue = dynamic_cast< String* >(pMapEnum->GetValue());
 520                 SysTryCatch(NID_APP, pValue != null, r = E_INVALID_ARG, E_INVALID_ARG,
 521                                 "[E_INVALID_ARG] The object is not String class.");
 522
 523                 pArgList->Add(*(new String(*pValue)));
 524                 SysLog(NID_APP, "[DC_CALLER] pValue[%d]: %ls", i, pValue->GetPointer());
 525
 526                 i++;
 527         }
 528
 529         r = StartSqlDataControl(_DATACONTROL_REQUEST_TYPE_SQL_INSERT, pArgList, &id);
 530         SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating to caller...", GetErrorMessage(r));
 531
 532         reqId = static_cast< RequestId >(id);
 533
 534         SysLog(NID_APP, "[DC_CALLER] dataId: %ls, insertMap: 0x%x, reqId: %d", dataId.GetPointer(), &insertMap, reqId);
 535
 536         // fall through
 537 CATCH:
 538         pArgList->RemoveAll(true);
 539         delete pArgList;
 540
 541         delete pMapEnum;
 542
 543         return r;
 544 }
 545
 546 result
 547 _SqlDataControlImpl::Update(const Tizen::Base::String& dataId, const Tizen::Base::Collection::IMap& updateMap,
 548                         const Tizen::Base::String* pWhere, RequestId& reqId)
 549 {
 550         SysTryReturnResult(NID_APP, (__access & _DATACONTROL_ACCESS_WRITE) > 0, E_ILLEGAL_ACCESS,
 551                         "The UPDATE query is not permitted by DataControl provider.");
 552
 553         int columnCount = 0;
 554         int id = 0;
 555         int i = 0;
 556         result r = E_SUCCESS;
 557         SysLog(NID_APP, "[DC_CALLER] SqlDataControl UPDATE");
 558
 559         columnCount = updateMap.GetCount();
 560         SysTryReturnResult(NID_APP, columnCount > 0, E_INVALID_ARG, "The specified insertMap parameter is empty.");
 561
 562         ArrayList* pArgList = new ArrayList();
 563         pArgList->Construct();
 564
 565         pArgList->Add(*(new String(dataId))); // list(0): data ID
 566
 567         pArgList->Add(*(new String(Integer::ToString(columnCount)))); // list(1): updated column count
 568         SysLog(NID_APP, "[DC_CALLER] updated column count: %d", columnCount);
 569
 570         IMapEnumerator* pMapEnum = const_cast< IMap* >(&updateMap)->GetMapEnumeratorN();
 571         while (pMapEnum->MoveNext() == E_SUCCESS) // list(2): column-value pairs
 572         {
 573                 String* pColumn = dynamic_cast< String* >(pMapEnum->GetKey());
 574                 SysTryCatch(NID_APP, pColumn != null, r = E_INVALID_ARG, E_INVALID_ARG,
 575                                 "[E_INVALID_ARG] The object is not String class.");
 576
 577                 pArgList->Add(*(new String(*pColumn)));
 578                 SysLog(NID_APP, "[DC_CALLER] pColumn[%d]: %ls", i, pColumn->GetPointer());
 579
 580                 String* pValue = dynamic_cast< String* >(pMapEnum->GetValue());
 581                 SysTryCatch(NID_APP, pValue != null, r = E_INVALID_ARG, E_INVALID_ARG,
 582                                 "[E_INVALID_ARG] The object is not String class.");
 583
 584                 pArgList->Add(*(new String(*pValue)));
 585                 SysLog(NID_APP, "[DC_CALLER] pValue[%d]: %ls", i, pValue->GetPointer());
 586
 587                 i++;
 588         }
 589
 590         if (pWhere != null)     // list(3): where clause
 591         {
 592                 pArgList->Add(*(new String(*pWhere)));
 593                 SysLog(NID_APP, "[DC_CALLER] pWhere: %ls", pWhere->GetPointer());
 594         }
 595         else
 596         {
 597                 pArgList->Add(*(new String(L"NULL")));
 598         }
 599
 600         r = StartSqlDataControl(_DATACONTROL_REQUEST_TYPE_SQL_UPDATE, pArgList, &id);
 601         SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating to caller...", GetErrorMessage(r));
 602
 603         reqId = static_cast< RequestId >(id);
 604
 605         SysLog(NID_APP, "[DC_CALLER] dataId: %ls, updateMap: 0x%x, pWhere: 0x%x, reqId: %d",
 606                                 dataId.GetPointer(), &updateMap, pWhere, reqId);
 607
 608         // fall through
 609 CATCH:
 610         pArgList->RemoveAll(true);
 611         delete pArgList;
 612
 613         delete pMapEnum;
 614
 615         return r;
 616 }
 617
 618 result
 619 _SqlDataControlImpl::Delete(const Tizen::Base::String& dataId, const Tizen::Base::String* pWhere, RequestId& reqId)
 620 {
 621         SysTryReturnResult(NID_APP, (__access & _DATACONTROL_ACCESS_WRITE) > 0, E_ILLEGAL_ACCESS,
 622                         "The DELETE query is not permitted by DataControl provider.");
 623
 624         int id = 0;
 625         result r = E_SUCCESS;
 626         SysLog(NID_APP, "[DC_CALLER] SqlDataControl DELETE");
 627
 628         ArrayList* pArgList = new ArrayList();
 629         pArgList->Construct();
 630
 631         pArgList->Add(*(new String(dataId))); // list(0): data ID
 632
 633         if (pWhere != null)     // list(1): where clause
 634         {
 635                 pArgList->Add(*(new String(*pWhere)));
 636                 SysLog(NID_APP, "[DC_CALLER] pWhere: %ls", pWhere->GetPointer());
 637         }
 638         else
 639         {
 640                 pArgList->Add(*(new String(L"NULL")));
 641         }
 642
 643         r = StartSqlDataControl(_DATACONTROL_REQUEST_TYPE_SQL_DELETE, pArgList, &id);
 644         SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Propagating to caller...", GetErrorMessage(r));
 645
 646         reqId = static_cast< RequestId >(id);
 647
 648         SysLog(NID_APP, "[DC_CALLER] dataId: %ls, pWhere: 0x%x, reqId: %d", dataId.GetPointer(), pWhere, reqId);
 649
 650         // fall through
 651 CATCH:
 652         pArgList->RemoveAll(true);
 653         delete pArgList;
 654
 655         return r;
 656 }
 657
 658 result
 659 _SqlDataControlImpl::SetSqlDataControlResponseListener(ISqlDataControlResponseListener* pListener)
 660 {
 661         result r = E_SUCCESS;
 662
 663         if (__pPreviousListener != null)
 664         {
 665                 r =  __pSqlDataControlEvent->RemoveListener(*__pPreviousListener);
 666                 SysTryReturnResult(NID_APP, !IsFailed(r), E_SYSTEM, "Remove listener failed.");
 667                  __pPreviousListener = null;
 668         }
 669
 670         if (pListener != null)
 671         {
 672                 r =  __pSqlDataControlEvent->AddListener(*pListener);
 673                 if (IsFailed(r))
 674                 {
 675                         switch (r)
 676                         {
 677                         case E_OBJ_ALREADY_EXIST:
 678                                 return E_SUCCESS;
 679                         case E_INVALID_OPERATION:
 680                                 SysLogException(NID_APP, E_SYSTEM, "[E_SYSTEM] The thread setting the listener is worker thread.");
 681                                 return E_SYSTEM;
 682                         default:
 683                                 SysLogException(NID_APP, r, "[%s] Propagating to caller...", GetErrorMessage(r));
 684                                 return r;
 685                         }
 686                 }
 687         }
 688
 689         __pPreviousListener = pListener;
 690
 691         return E_SUCCESS;
 692 }
 693
 694 // private
 695 SqlDataControl*
 696 _SqlDataControlImpl::CreateSqlDataControl(const String& appId, const String& providerId, const String& access)
 697 {
 698         unique_ptr<SqlDataControl> pDc(new (std::nothrow) SqlDataControl);
 699         SysTryReturn(NID_APP, pDc != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient");
 700
 701         _SqlDataControlImpl* pDcImpl = _SqlDataControlImpl::GetInstance(*pDc);
 702         pDcImpl->__appId = appId;
 703         pDcImpl->__providerId = providerId;
 704         unique_ptr<_SqlDataControlEvent> pSqlDataControlEvent(new (std::nothrow) _SqlDataControlEvent);
 705         SysTryReturn(NID_IO, pSqlDataControlEvent != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 706
 707         pDcImpl->__pSqlDataControlEvent = pSqlDataControlEvent.release();
 708
 709         if (access == L"readonly")
 710         {
 711                 pDcImpl->__access = _DATACONTROL_ACCESS_READ;
 712         }
 713         else if (access == L"writeonly")
 714         {
 715                 pDcImpl->__access = _DATACONTROL_ACCESS_WRITE;
 716         }
 717         else if (access == L"readwrite")
 718         {
 719                 pDcImpl->__access = _DATACONTROL_ACCESS_READWRITE;
 720         }
 721         else
 722         {
 723                 pDcImpl->__access = _DATACONTROL_ACCESS_UNDEFINED;
 724                 SysLog(NID_IO, "The accessibility of DataControl provider is invalid.");
 725         }
 726
 727         return pDc.release();
 728 }
 729
 730 }} // Tizen::App
 731