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