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