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