remove notification clear on every osp applicatio nstart
[platform/framework/native/appfw.git] / src / app / FApp_AppImpl.cpp
1 //
2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Apache License, Version 2.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //     http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 /**
18  * @file        FApp_AppImpl.cpp
19  * @brief       This is the implementation for the _AppImpl class.
20  */
21
22 #include <unique_ptr.h>
23
24 #include <notification/notification.h>
25 #include <appsvc/appsvc.h>
26 #include <vconf.h>
27
28 #include <FBaseInteger.h>
29 #include <FBaseColArrayList.h>
30 #include <FBaseColHashMap.h>
31 #include <FBaseRtThread.h>
32 #include <FAppAppRegistry.h>
33 #include <FAppAppControl.h>
34 #include <FAppDataControlProviderManager.h>
35 #include <FAppIAppCheckPointEventListener.h>
36 #include <FAppISqlDataControlProviderEventListener.h>
37 #include <FAppIMapDataControlProviderEventListener.h>
38 #include <FAppIAppControlProviderEventListener.h>
39 #include <FAppIAppLaunchConditionEventListener.h>
40 #include <FIoFile.h>
41
42 #include <FBaseSysLog.h>
43 #include <FIo_RegistryImpl.h>
44 #include <FSys_EnvironmentImpl.h>
45 #include <FSys_PowerManagerImpl.h>
46 #include <FApp_Aul.h>
47 #include <FSys_AlarmManager.h>
48
49 #include "FApp_IAppManager.h"
50 #include "FApp_AppManagerProxy.h"
51 #include "FApp_AppImpl.h"
52 #include "FApp_AppInfo.h"
53 #include "FApp_AppControlManager.h"
54 #include "FApp_AppArg.h"
55 #include "FApp_IAppImpl.h"
56 #include "FApp_AppResourceImpl.h"
57
58 using namespace Tizen::Base;
59 using namespace Tizen::Base::Collection;
60 using namespace Tizen::Base::Runtime;
61 using namespace Tizen::Io;
62 using namespace Tizen::System;
63
64 namespace
65 {
66
67 const int HEARTBEAT_WAIT_COUNT = 3;
68 const wchar_t SERVICE_APPID[] = L"aospd00043.osp-app-service";
69 const char SELECTOR_RESPONSE_KEY[] = "__APP_SVC_START_INFO__";
70 const wchar_t FILE_SCHEME_WITH_DELIMITER[] = L"file://";
71 #ifndef VCONFKEY_APPSERVICE_STATUS
72 #define VCONFKEY_APPSERVICE_STATUS  "memory/appservice/status"
73 #endif
74
75 }
76
77 namespace Tizen { namespace App
78 {
79
80 _AppImpl* _AppImpl::__pAppImpl = null;
81 bool _AppImpl::__isTerminationRequested = false;
82 #if 0
83 static const int _DATACONTROL_PACKET_INDEX_APPID = 0;
84 static const int _DATACONTROL_PACKET_INDEX_REQUESTTYPE = 1;
85 static const int _DATACONTROL_PACKET_INDEX_REQID = 2;
86 static const int _DATACONTROL_PACKET_INDEX_PROVIDERID = 3;
87 #endif
88 static const int _DATACONTROL_PACKET_INDEX_DATAID = 0;
89 static const int _DATACONTROL_PACKET_INDEX_COLUMNCOUNT = 1;
90 static const int _DATACONTROL_PACKET_INDEX_DELETEWHERE = 1;
91 static const int _DATACONTROL_PACKET_INDEX_MAPKEY = 1;
92 static const int _DATACONTROL_PACKET_INDEX_COLUMNLIST = 2;
93 static const int _DATACONTROL_PACKET_INDEX_INSERTMAP = 2;
94 static const int _DATACONTROL_PACKET_INDEX_UPDATEMAP = 2;
95
96 struct charDeleter
97 {
98         void operator()(char* pValue)
99         {
100                 if(pValue != null)
101                 {
102                         free(pValue);
103                         pValue = null;
104                 }
105         }
106 };
107
108 _AppImpl::_AppImpl(App* pApp)
109         : __pCheckpointEventListener(null)
110         , __pSqlDataControlProviderEventListener(null)
111         , __pMapDataControlProviderEventListener(null)
112         , __pAppControlProviderEventListener(null)
113         , __pAppControlProviderInternalEventListener(null)
114         , __pAppLaunchConditionEventListener(null)
115         , __pApp(pApp)
116         , __pIAppImpl(null)
117         , __pRequestHandler(&_AppImpl::HandleAppRequest)
118         , __pLegacyRequestHandler(&_AppImpl::HandleDummyAppRequest)
119         , __forcedTermination(false)
120 {
121         __pAppImpl = this;
122 }
123
124
125 result
126 _AppImpl::Construct(const IList* pArgs)
127 {
128         SysTryReturnResult(NID_APP, pArgs != null, E_INVALID_ARG, "pArguments must not be null.");
129         SysAssertf(__pApp != null, "Getting App instance failed.");
130
131         result r = __appUserEvent.Construct();
132         SysTryLog(NID_APP, !IsFailed(r), "[%s] User event handler failure.", GetErrorMessage(r));
133
134         __appUserEvent.AddListener(*this);
135
136         _AppInfo::SetAppState(INITIALIZING);
137
138         return E_SUCCESS;
139 }
140
141
142 result
143 _AppImpl::Execute(_IAppImpl* pIAppImpl)
144 {
145         SysLogTag(NID_APP, "LAUNCH","[%ls:<Initialize Application>:start]", _AppInfo::GetAppExecutableName().GetPointer());
146         result r = E_SUCCESS;
147         int eflResult = APP_ERROR_NONE;
148         int argc = _AppInfo::GetArgc();
149         char** pArgv = _AppInfo::GetArgv();
150         _IAppManager* pAppManager = null;
151
152         _AppImpl* pAppImpl = _AppImpl::GetInstance();
153         SysTryReturnResult(NID_APP, pAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
154         pAppImpl->__pIAppImpl = pIAppImpl;
155
156         // handle legacy version handling
157         if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
158         {
159                 pAppImpl->SetLegacyRequestHandler();
160         }
161
162         app_event_callback_s state_handler;
163         memset(&state_handler, 0, sizeof(app_event_callback_s));
164
165         state_handler.create = &OnCreate;
166         state_handler.service = &OnService;
167         state_handler.terminate = &OnTerminate;
168         state_handler.pause = &OnPause;
169         state_handler.resume = &OnResume;
170         state_handler.device_orientation = NULL;
171
172         state_handler.low_memory = &OnLowMemory;
173         state_handler.low_battery = NULL;
174         state_handler.language_changed = &OnLanguageChanged;
175         state_handler.region_format_changed = NULL;
176
177         _Aul::SetPowerOffNotiListener(OnPowerOffNotiReceived, this);
178 //      if (pAppManager != null)
179 //      {
180 //              r = pAppManager->RegisterApplication(_AppInfo::GetPackageId(), _AppInfo::GetAppExecutableName(), _AppInfo::GetAppType() , _AppInfo::GetProcessId());
181 //              SysTryCatch(NID_APP, !IsFailed(r), , r, "[%s] Application registration failed.", GetErrorMessage(r));
182 //      }
183
184         eflResult = app_efl_main(&argc, &pArgv, &state_handler, this);
185
186         SysTryLog(NID_APP, eflResult == APP_ERROR_NONE, "app_efl_main failed with error (%d): Unknown", eflResult);
187
188         // clear outstanding ongoing notification
189         notification_delete_all_by_type(NULL, NOTIFICATION_TYPE_ONGOING);
190
191 //CATCH:
192         pAppManager = _AppManagerProxy::GetService();
193
194         if (pAppManager != null)
195         {
196                 pAppManager->UnregisterApplication(_AppInfo::GetProcessId());
197         }
198
199         return r;
200 }
201
202
203 bool
204 _AppImpl::OnCreate(void* user_data)
205 {
206         SysLog(NID_APP, "Platform creation event.");
207
208         _AppImpl* pAppImpl = static_cast<_AppImpl*>(user_data);
209         if (pAppImpl == null)
210         {
211                 _AppInfo::SetAppState(TERMINATED);
212                 SysLogException(NID_APP, E_INIT_FAILED, "[E_INIT_FAILED] Invalid platform state.");
213                 return false;
214         }
215
216         _AppInfo::SetAppState(INITIALIZING);
217
218         if (!ConfirmAppService())
219         {
220                 _AppInfo::SetAppState(TERMINATED);
221                 SysLogException(NID_APP, E_INIT_FAILED, "[E_INIT_FAILED] Osp AppService is not running.");
222                 return false;
223         }
224
225         SysLogTag(NID_APP, "LAUNCH","[%ls:<OnAppInitializing>:start]", _AppInfo::GetAppExecutableName().GetPointer());
226         if (!pAppImpl->__pIAppImpl->OnAppInitializing())
227         {
228                 _AppInfo::SetAppState(TERMINATED);
229                 SysLogException(NID_APP, E_INIT_FAILED, "[E_INIT_FAILED] The initialization of your application failed.");
230                 return false;
231         }
232         SysLogTag(NID_APP, "LAUNCH","[%ls:<OnAppInitializing>:done]", _AppInfo::GetAppExecutableName().GetPointer());
233
234         SysLogTag(NID_APP, "LAUNCH","[%ls:<RegisterApplication>:start]", _AppInfo::GetAppExecutableName().GetPointer());
235         _IAppManager* pAppManager = _AppManagerProxy::GetService();
236
237         if (pAppManager != null)
238         {
239                 result r = pAppManager->RegisterApplication(_AppInfo::GetPackageId(), _AppInfo::GetAppExecutableName(), static_cast<_AppType>(_AppInfo::GetAppType()), _AppInfo::GetProcessId());
240                 SysTryLog(NID_APP, !IsFailed(r), "[%s] Application registration failed.", GetErrorMessage(r));
241         }
242         SysLogTag(NID_APP, "LAUNCH","[%ls:<RegisterApplication>:done]", _AppInfo::GetAppExecutableName().GetPointer());
243         // hide splash window
244
245         _PowerManagerImpl::InitBatteryEvent();
246
247         return true;
248 }
249
250
251 void
252 _AppImpl::OnService(service_s* service, void* user_data)
253 {
254         _AppImpl* pAppImpl = _AppImpl::GetInstance();
255         SysTryReturnVoidResult(NID_APP, pAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
256         SysTryReturnVoidResult(NID_APP, pAppImpl->__pIAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
257
258         // ugly code for app selector event handling
259         bundle* pBundle = _AppArg::GetBundleFromSvc(service);
260         if (pBundle)
261         {
262                 const char* pValue = appsvc_get_data(pBundle, SELECTOR_RESPONSE_KEY);
263                 if (pValue)
264                 {
265                         const int req = _AppArg::GetRequestIdFromBundle(pBundle);
266
267                         const char* pOperation = appsvc_get_operation(pBundle);
268
269                         SysLog(NID_APP, "App selector response [%s, %s], req(%d).", pValue, pOperation, req);
270
271                         //_AppArg::Print(pBundle);
272                         _AppControlManager::GetInstance()->SendAppControlStartResponse(req, pValue, pOperation);
273                         return;
274                 }
275         }
276
277         //_AppArg::Print(pBundle);
278         int req = -1;
279         _AppHandler handler = _APP_HANDLER_NONE;
280         pAppImpl->RegisterAppRequest(service, req, handler);
281
282         bool initialLaunch = false;
283
284         // initial launch
285         // (1) AppControl / DataControl provider listener
286         // (2) OnAppInitialized()
287         // (3) OnResume() (OnForeground()) (UiApp only)
288         // (4) OnUserEventReceivedN()
289
290         // already launched
291         // (1) AppControl / DataControl provider listener
292         // (2) OnResume() (OnForeground()) (UiApp only)
293         // (3) OnUserEventReceivedN()
294
295         if (_AppInfo::GetAppState() == INITIALIZING)
296         {
297                 initialLaunch = true;
298
299                 unsigned int winId = 0;
300                 service_get_window(service, &winId);
301                 if (winId > 0)
302                 {
303                         _AppInfo::GetAppInfo()->SetParentWindowHandle(winId);
304                         SysLog(NID_APP, "Saving window handle 0x%x.", winId);
305                 }
306                 // call for callbacks
307                 // ptr to member function
308                 SysLogTag(NID_APP, "LAUNCH","[%ls:<RequestHandler and OnAppInitialized>:start]", _AppInfo::GetAppExecutableName().GetPointer());
309                 (pAppImpl->*pAppImpl->__pRequestHandler)(service, req, handler);
310
311                 if (!pAppImpl->__pIAppImpl->OnAppInitialized())
312                 {
313                         _AppInfo::SetAppState(TERMINATING);
314                         SysLog(NID_APP, "[E_INIT_FAILED] The Initialization of your application failed.");
315                         app_efl_exit();
316                         return;
317                 }
318                 SysLogTag(NID_APP, "LAUNCH","[%ls:<RequestHandler and OnAppInitialized>:done]", _AppInfo::GetAppExecutableName().GetPointer());
319
320                 _AppInfo::SetAppState(RUNNING);
321
322                 SysLogTag(NID_APP, "LAUNCH","[%ls:<Initialize Application>:done]", _AppInfo::GetAppExecutableName().GetPointer());
323         }
324         else
325         {
326                 // already running
327
328                 // call for callbacks
329                 // ptr to member function
330                 (pAppImpl->*pAppImpl->__pRequestHandler)(service, req, handler);
331
332                 std::unique_ptr<char[], charDeleter> pOperation(null);
333                 char* pBuf = null;
334
335                 int errVal = service_get_operation(service, &pBuf);
336                 pOperation.reset(pBuf);
337
338                 if((errVal == SERVICE_ERROR_NONE) && (!strcmp((const char*)pOperation.get(), "osp.operation.ALARM")))
339                 {
340                         std::unique_ptr<char[], charDeleter> pAlarmId(null);
341                         char* pBuf = null;
342
343                         errVal = service_get_extra_data(service, SERVICE_DATA_ALARM_ID, &pBuf);
344                         pAlarmId.reset(pBuf);
345                         SysTryReturnVoidResult(NID_SYS, errVal == SERVICE_ERROR_NONE, E_SYSTEM, "It is failed to get reserved alarm id.");
346                         int alarmId = atoi((const char*)pAlarmId.get());
347
348                         _AlarmManager* pAlarmManager = _AlarmManager::GetInstance();
349                         pAlarmManager->OnAlarmExpired(alarmId);
350
351                         return;
352                 }
353         }
354
355         pAppImpl->__pIAppImpl->OnService(service, initialLaunch);
356
357         // ptr to member function
358         (pAppImpl->*pAppImpl->__pLegacyRequestHandler)(service, req, handler);
359 }
360
361
362 void
363 _AppImpl::OnTerminate(void* user_data)
364 {
365         SysLog(NID_APP, "Termination event 0x%x state", _AppInfo::GetAppState());
366
367         _AppImpl* pAppImpl = _AppImpl::GetInstance();
368         SysTryReturnVoidResult(NID_APP, pAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
369         SysTryReturnVoidResult(NID_APP, pAppImpl->__pIAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
370
371         __isTerminationRequested = true;
372         pAppImpl->__pIAppImpl->OnTerminate();
373 }
374
375
376 void
377 _AppImpl::OnResume(void* user_data)
378 {
379         SysLog(NID_APP, "System resume event on 0x%x state", _AppInfo::GetAppState());
380         SysLogTag(NID_APP, "LAUNCH","[%ls:<OnResume>:start]", _AppInfo::GetAppExecutableName().GetPointer());
381
382         _AppImpl* pAppImpl = _AppImpl::GetInstance();
383         SysTryReturnVoidResult(NID_APP, pAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
384         SysTryReturnVoidResult(NID_APP, pAppImpl->__pIAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
385         pAppImpl->__pIAppImpl->OnResume();
386         SysLogTag(NID_APP, "LAUNCH","[%ls:<OnResume>:done]", _AppInfo::GetAppExecutableName().GetPointer());
387 }
388
389
390 void
391 _AppImpl::OnPause(void* user_data)
392 {
393         SysLog(NID_APP, "System pause event on 0x%x state", _AppInfo::GetAppState());
394         SysLogTag(NID_APP, "LAUNCH","[%ls:<OnPause>:start]", _AppInfo::GetAppExecutableName().GetPointer());
395
396         _AppImpl* pAppImpl = _AppImpl::GetInstance();
397         SysTryReturnVoidResult(NID_APP, pAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
398         SysTryReturnVoidResult(NID_APP, pAppImpl->__pIAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
399         pAppImpl->__pIAppImpl->OnPause();
400         pAppImpl->OnAppCheckpoint();
401         SysLogTag(NID_APP, "LAUNCH","[%ls:<OnPause>:done]", _AppInfo::GetAppExecutableName().GetPointer());
402 }
403
404
405 _AppImpl::~_AppImpl(void)
406 {
407         __pAppImpl = null;
408 }
409
410
411 _AppImpl*
412 _AppImpl::GetInstance(void)
413 {
414         return __pAppImpl;
415 }
416
417
418 App*
419 _AppImpl::GetAppInstance(void)
420 {
421         return __pApp;
422 }
423
424
425 IList*
426 _AppImpl::GetAppArgumentListN(void) const
427 {
428         ArrayList* pList = null;
429         const _AppArg* pArg = _AppControlManager::GetInstance()->FindResultRequest(0);
430
431         if (pArg)
432         {
433                 pList = pArg->GetArgListN(0);
434         }
435         else
436         {
437                 // fallback
438                 pList = new (std::nothrow) ArrayList();
439                 SysTryReturn(NID_APP, pList != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
440                 String* pData = new (std::nothrow) String(LEGACY_LAUNCH_REASON_NORMAL);
441                 SysTryReturn(NID_APP, pData != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
442                 String* pData2 = new (std::nothrow) String(L"osp.operation.MAIN");
443                 SysTryReturn(NID_APP, pData2 != null, null, E_OUT_OF_MEMORY, "ArrayList creation failure.");
444
445                 pList->Construct();
446                 pList->Add(*pData);
447                 pList->Add(*pData2);
448         }
449
450         return pList;
451 }
452
453
454 result
455 _AppImpl::Terminate(void)
456 {
457         result r = E_SUCCESS;
458
459         __isTerminationRequested = true;
460
461         app_efl_exit();
462         return r;
463 }
464
465
466 bool
467 _AppImpl::OnAppInitializing(void)
468 {
469         return false;
470 }
471
472
473 bool
474 _AppImpl::OnAppWillTerminate(void)
475 {
476         SysTryReturn(NID_APP, __pApp != null, false, E_INVALID_STATE, "[E_INVALID_STATE] Getting internal instance failed.");
477
478         return __pApp->OnAppWillTerminate();
479 }
480
481
482 result
483 _AppImpl::RegisterAppRequest(service_s* service, int& req, _AppHandler& handler)
484 {
485         _AppControlManager* pManager = _AppControlManager::GetInstance();
486         SysTryReturnResult(NID_APP, pManager != null, E_SYSTEM, "Wrong system state.");
487
488         result r = pManager->RegisterRequest(service, req, handler);
489         SysTryReturn(NID_APP, !IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));
490
491         int providerType = _AppInfo::GetAppHandlerType();
492         providerType |= (_APP_HANDLER_LAUNCH_NORMAL | _APP_HANDLER_LAUNCH_COND);
493
494         SysTryLog(NID_APP, (handler & providerType) != 0, "Request 0x%x received for 0x%x.", handler,
495                         _AppInfo::GetAppHandlerType());
496         return E_SUCCESS;
497 }
498
499
500 result
501 _AppImpl::HandleAppRequest(service_s* service, int req, _AppHandler handler)
502 {
503         const _AppArg* pArg = _AppControlManager::GetInstance()->FindResultRequest(req);
504         SysTryReturnResult(NID_APP, pArg != null, E_SYSTEM, "No argument found for %d.", req);
505
506         pArg->Print();
507
508         switch (handler)
509         {
510         case _APP_HANDLER_DATACONTROL:
511                 SysLog(NID_APP, "Handling DataControl request");
512
513                 OnDataControlRequestReceived(*pArg, static_cast< RequestId >(req));
514
515                 //_AppControlManager::GetInstance()->RemoveResultRequest(req);
516                 break;
517
518         case _APP_HANDLER_LAUNCH_COND:
519                 SysLog(NID_APP, "Handling conditional launch request");
520
521                 OnConditionRequestReceived(*pArg, static_cast< RequestId >(req));
522                 break;
523
524         default:
525                 SysLog(NID_APP, "Handling AppControl request");
526
527                 OnAppControlRequestReceived(*pArg, static_cast< RequestId >(req));
528                 break;
529         }
530
531         return E_SUCCESS;
532 }
533
534
535 result
536 _AppImpl::HandleLegacyAppRequest(service_s* service, int req, _AppHandler handler)
537 {
538         const _AppArg* pArg = _AppControlManager::GetInstance()->FindResultRequest(0);
539         SysTryReturnResult(NID_APP, pArg != null, E_SYSTEM, "No argument found for %d.", req);
540
541         //pArg->Print();
542
543         switch (handler)
544         {
545         case _APP_HANDLER_LAUNCH_NORMAL:
546                 SysLog(NID_APP, "Handling normal launch request");
547                 OnUserEventReceivedN(AppLaunchRequestId, pArg->GetArgListN(req));
548
549                 // [TODO] request handle memory cleanup confirm
550                 _AppControlManager::GetInstance()->RemoveResultRequest(req);
551                 break;
552
553         case _APP_HANDLER_LAUNCH_COND:
554                 SysLog(NID_APP, "Handling conditional launch request");
555
556                 OnUserEventReceivedN(AppLaunchRequestId, pArg->GetArgListN(req));
557
558                 // [TODO] request handle memory cleanup confirm
559                 _AppControlManager::GetInstance()->RemoveResultRequest(req);
560                 break;
561
562         default:
563                 break;
564         }
565
566         return E_SUCCESS;
567 }
568
569
570 result
571 _AppImpl::HandleDummyAppRequest(service_s* service, int req, _AppHandler handler)
572 {
573         SysLog(NID_APP, "Dummy handler");
574
575         return E_SUCCESS;
576 }
577
578
579 result
580 _AppImpl::SetLegacyRequestHandler(void)
581 {
582         SysLog(NID_APP, "Setting request handler for legacy application.");
583
584         __pRequestHandler = &_AppImpl::HandleDummyAppRequest;
585         __pLegacyRequestHandler = &_AppImpl::HandleLegacyAppRequest;
586
587         return E_SUCCESS;
588 }
589
590
591 void
592 _AppImpl::OnLowMemory(void* user_data)
593 {
594         _AppImpl* pAppImpl = _AppImpl::GetInstance();
595
596         SysTryReturnVoidResult(NID_APP, pAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting internal instance failed.");
597         SysTryReturnVoidResult(NID_APP, pAppImpl->__pApp != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting internal instance failed.");
598
599         if (_AppInfo::GetAppState() == RUNNING)
600         {
601                 pAppImpl->__pApp->OnLowMemory();
602         }
603 }
604
605
606 void
607 _AppImpl::OnBatteryLevelChanged(BatteryLevel batteryLevel)
608 {
609         SysTryReturnVoidResult(NID_APP, __pApp != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting internal instance failed.");
610
611         __pApp->OnBatteryLevelChanged(batteryLevel);
612 }
613
614 void
615 _AppImpl::OnLanguageChanged(void* user_data)
616 {
617         SysLog(NID_APP, "");
618         _AppInfo::UpdatePackageInfo(true);
619
620         _AppResourceImpl::Reinitialize();
621         SysLog(NID_APP, "Language change done.");
622 }
623
624
625 result
626 _AppImpl::SendUserEvent(RequestId requestId, const IList* pArgs)
627 {
628         _AppUserEventArg* pArg = new (std::nothrow) _AppUserEventArg(requestId, pArgs);
629         SysTryReturnResult(NID_APP, pArg != null, E_OUT_OF_MEMORY, "User event creation failure for %d.", requestId);
630
631         result r = __appUserEvent.FireAsync(*pArg);
632
633         return r;
634 }
635
636
637 void
638 _AppImpl::OnUserEventReceivedN(RequestId requestId, IList* pArgs)
639 {
640         SysTryReturnVoidResult(NID_APP, __pApp != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting internal instance failed.");
641
642         __pApp->OnUserEventReceivedN(requestId, pArgs);
643 }
644
645
646 void
647 _AppImpl::OnAppControlRequestReceived(const _AppArg& arg, RequestId reqId)
648 {
649         IAppControlProviderEventListener* pAppControlProviderEventListener = null;
650
651         const String internalOperation = arg.GetValue(OSP_K_APPCONTROL_INTERNAL_OPERATION);
652         if( !internalOperation.IsEmpty() )
653         {
654                 SysLog(NID_APP, "internalOperation:%ls", internalOperation.GetPointer() );
655                 pAppControlProviderEventListener = __pAppControlProviderInternalEventListener;
656         }
657         else
658         {
659                 pAppControlProviderEventListener = __pAppControlProviderEventListener;
660         }
661
662         if( pAppControlProviderEventListener == null)
663         {
664                 SysLog(NID_APP, "No AppControl provider event listener set for request %d.", reqId);
665                 return;
666         }
667
668         const String& appId = _AppInfo::GetApplicationId();
669
670         const char* p = appsvc_get_operation(arg.GetBundle());
671         String operationId = (p) ? String(p) : TIZEN_OPERATION_MAIN;
672         if (operationId == L"http://tizen.org/appcontrol/operation/default")
673         {
674                 operationId = TIZEN_OPERATION_MAIN;
675         }
676
677         SysLog(NID_APP, "AppControl (%ls, %ls).", appId.GetPointer(), operationId.GetPointer());
678
679         String uri;
680         String mime;
681         const String* pUri = null;
682         const String* pMime = null;
683         p = appsvc_get_uri(arg.GetBundle());
684         if (p)
685         {
686                 uri = p;
687                 if (uri[0] == L'/')
688                 {
689                         // SLP deals with the URI as plain /opt/.../a.jpg.
690                         uri.Insert(FILE_SCHEME_WITH_DELIMITER, 0);
691                 }
692                 pUri = &uri;
693
694                 SysLog(NID_APP, "Delivered uri is [%ls].", pUri->GetPointer());
695         }
696
697         p = appsvc_get_mime(arg.GetBundle());
698         if (p)
699         {
700                 mime = p;
701                 pMime = &mime;
702         }
703
704         std::unique_ptr<HashMap> pMap(arg.GetArgMapN());
705
706         pAppControlProviderEventListener->OnAppControlRequestReceived(reqId, operationId, pUri, pMime, pMap.get());
707
708         SysLog(NID_APP, "AppControl (%ls, %ls) invocation finished.", appId.GetPointer(), operationId.GetPointer());
709 }
710
711
712 void
713 _AppImpl::OnDataControlRequestReceived(const _AppArg& arg, RequestId reqId)
714 {
715         String tempFilePath;
716         ISqlDataControlProviderEventListener* pSqlListener = null;
717         IMapDataControlProviderEventListener* pMapListener = null;
718         ArrayList* pColumnList = null;
719         HashMap* pInsertMap = null;
720         HashMap* pUpdateMap = null;
721         String appId;
722         String reqType;
723         String providerId;
724         String version;
725         String* pDataId = null;
726         String callerReqId;
727         String* pColumnCount = null;
728         String* pColumn = null;
729         String* pValue = null;
730         String* pWhere = null;
731         String* pOrder = null;
732         String* pErrorMsg = null;
733         String* pNo = null;
734         String* pCount = null;
735         String* pTmpPath = null;
736         String empty(L"NULL");
737         _AppArg resultArg;
738         int type = 0;
739         _DataControlRequestType requestType = _DATACONTROL_REQUEST_TYPE_UNDEFINED;
740         int columnCount = 0;
741         int pageNo = 0;
742         int countPerPage = 0;
743         int i = 0;
744         int index = 0;
745         result r = E_SUCCESS;
746         result res = E_SUCCESS;
747         ArrayList* pList = null;
748         String* pKey = null;
749         String* pNewValue = null;
750         String* pOldValue = null;
751
752         SysLog(NID_APP, "[DC_PROV_RECV] Data control request is received.");
753         //arg.Print(); // request info
754
755         // key-based request
756         appId = arg.GetCallerAppId();
757
758         reqType = arg.GetValue(OSP_K_DATACONTROL_REQUEST_TYPE);
759         Integer::Parse(reqType, type);
760         requestType = static_cast< _DataControlRequestType >(type);
761
762         version = arg.GetValue(OSP_K_DATACONTROL_PROTOCOL_VERSION);
763         callerReqId = arg.GetValue(OSP_K_REQUEST_ID);
764         providerId = arg.GetValue(OSP_K_DATACONTROL_PROVIDER);
765
766         // list-based request
767         pList = _AppArg::GetListN(arg.GetBundle(), OSP_K_ARG);
768         SysTryCatch(NID_APP, pList, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid result object");
769
770         pDataId = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_DATAID));// request list[0]: data ID
771         SysTryCatch(NID_APP, pDataId, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
772
773         if (requestType >= _DATACONTROL_REQUEST_TYPE_SQL_QUERY && requestType <= _DATACONTROL_REQUEST_TYPE_SQL_DELETE)
774         {
775                 pSqlListener = __pSqlDataControlProviderEventListener;
776                 SysTryCatch(NID_APP, pSqlListener != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
777         }
778         else if (requestType >= _DATACONTROL_REQUEST_TYPE_MAP_QUERY && requestType <= _DATACONTROL_REQUEST_TYPE_MAP_DELETE)
779         {
780                 pKey = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_MAPKEY)); // request list[1]
781                 SysTryCatch(NID_APP, pKey, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
782
783                 pMapListener = __pMapDataControlProviderEventListener;
784                 SysTryCatch(NID_APP, pMapListener != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
785         }
786         else
787         {
788                 SysLogException(NID_APP, E_SYSTEM, "[E_SYSTEM] invalid request");
789                 r = E_SYSTEM;
790         }
791
792         switch (requestType)
793         {
794         case _DATACONTROL_REQUEST_TYPE_SQL_QUERY:
795                 SysLog(NID_APP, "[DC_PROV_RECV] SqlDataControl SELECT");
796
797                 // request list[1]: selected column count
798                 pColumnCount = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_COLUMNCOUNT));
799                 SysTryCatch(NID_APP, pColumnCount, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
800
801                 if (pColumnCount->Equals(empty) == true)
802                 {
803                         pColumnList = null;
804                 }
805                 else
806                 {
807                         Integer::Parse(*pColumnCount, columnCount);
808                         pColumnList = new (std::nothrow) ArrayList();
809                         SysTryReturnVoidResult(NID_APP, pColumnList, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
810                         pColumnList->Construct();
811                         SysLog(NID_APP, "[DC_PROV_RECV] selected column count: %d", columnCount);
812
813                         i = 0;
814                         while (i < columnCount) // request list[2]: column list
815                         {
816                                 pColumn = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_COLUMNLIST + i));
817                                 SysTryCatch(NID_APP, pColumn != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
818
819                                 pColumnList->Add(*(new String(*pColumn)));
820                                 SysLog(NID_APP, "[DC_PROV_RECV] column[%d]: %ls", i, pColumn->GetPointer());
821                                 i++;
822                         }
823                 }
824
825                 i += _DATACONTROL_PACKET_INDEX_COLUMNLIST;
826                 pWhere = dynamic_cast< String* >(pList->GetAt(i)); // request list: where clause
827                 SysTryCatch(NID_APP, pWhere, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
828
829                 if (pWhere->Equals(empty) == true)
830                 {
831                         pWhere = null;
832                 }
833                 else
834                 {
835                         SysLog(NID_APP, "[DC_PROV_RECV] pWhere: %ls", pWhere->GetPointer());
836                 }
837
838                 i++;
839                 pOrder = dynamic_cast< String* >(pList->GetAt(i)); // request list: order clause
840                 SysTryCatch(NID_APP, pOrder, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
841
842                 if (pOrder->Equals(empty) == true)
843                 {
844                         pOrder = null;
845                 }
846                 else
847                 {
848                         SysLog(NID_APP, "[DC_PROV_RECV] pOrder: %ls", pOrder->GetPointer());
849                 }
850
851                 i++;
852                 pNo = dynamic_cast <String*>(pList->GetAt(i)); // request list: page number
853                 SysTryCatch(NID_APP, pNo, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
854                 Integer::Parse(*pNo, pageNo);
855
856                 i++;
857                 pCount = dynamic_cast <String*>(pList->GetAt(i)); // request list: count per page
858                 SysTryCatch(NID_APP, pCount, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
859                 Integer::Parse(*pCount, countPerPage);
860
861                 pSqlListener->OnSqlDataControlSelectRequestReceived(reqId, providerId, *pDataId, pColumnList,
862                                 pWhere, pOrder);
863
864                 SysSecureLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, pColumnList: 0x%0x, pWhere: 0x%x, pOrder: 0x%x, pageNo: %d, countPerPage: %d",
865                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
866                                 pDataId->GetPointer(), pColumnList, pWhere, pOrder, pageNo, countPerPage);
867                 break;
868         case _DATACONTROL_REQUEST_TYPE_SQL_INSERT:
869                 SysLog(NID_APP, "[DC_PROV_RECV] SqlDataControl INSERT");
870
871                 // request list[1]: inserted column count
872                 pColumnCount = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_COLUMNCOUNT));
873                 SysTryCatch(NID_APP, pColumnCount, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
874
875                 Integer::Parse(*pColumnCount, columnCount);
876                 SysLog(NID_APP, "[DC_PROV_RECV] inserted column count: %d", columnCount);
877
878                 pInsertMap = new (std::nothrow) HashMap();
879                 SysTryReturnVoidResult(NID_APP, pInsertMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
880                 pInsertMap->Construct();
881
882                 SysLog(NID_APP, "[DC_PROV_RECV] version: %ls", version.GetPointer());
883                 if (version == L"ver_2.1.0.2" || version == L"ver_2.1.0.3")
884                 {
885                         pTmpPath = dynamic_cast< String* >(pList->GetAt(2)); // request list[2]: path
886                         SysTryCatch(NID_APP, pTmpPath != null, , E_SYSTEM, "[E_SYSTEM] invalid request");
887                         SysLog(NID_APP, "[DC_PROV_RECV] request: %ls", pTmpPath->GetPointer());
888
889                         File request;
890                         r = request.Construct(*pTmpPath, "r");
891                         SysTryCatch(NID_APP, !IsFailed(r), , E_SYSTEM, "[%s] Failed to open request (%ls).",
892                                         GetErrorMessage(r), pTmpPath->GetPointer());
893
894                         for (i = 0; i < columnCount; ++i) // column-value pairs
895                         {
896                                 int length = -1;
897                                 int ret = request.Read(&length, sizeof(int));
898                                 SysTryCatch(NID_APP, ret > 0, , E_SYSTEM, "[%s] Failed to receive request.",
899                                                 GetErrorMessage(GetLastResult()));
900
901                                 char* pColumn = new (std::nothrow) char[length + 1];
902                                 ret = request.Read(pColumn, length);
903                                 SysTryCatch(NID_APP, ret > 0, delete pColumn, E_SYSTEM, "[%s] Failed to receive request.",
904                                                 GetErrorMessage(GetLastResult()));
905                                 pColumn[length] = '\0';
906                                 SysLog(NID_APP, "[DC_PROV_RECV] column[%d]: %s", i, pColumn);
907
908                                 ret = request.Read(&length, sizeof(int));
909                                 SysTryCatch(NID_APP, ret > 0, delete pColumn, E_SYSTEM, "[%s] Failed to receive request.",
910                                                 GetErrorMessage(GetLastResult()));
911
912                                 char* pValue = new (std::nothrow) char[length + 1];
913                                 ret = request.Read(pValue, length);
914                                 if (ret == 0)
915                                 {
916                                         SysLogException(NID_APP, E_SYSTEM, "[%s] Failed to receive request.", GetErrorMessage(GetLastResult()));
917                                         delete pColumn;
918                                         delete pValue;
919                                 }
920                                 pValue[length] = '\0';
921                                 SysLog(NID_APP, "[DC_PROV_RECV] value[%d]: %s", i, pValue);
922
923                                 pInsertMap->Add(new (std::nothrow) String(pColumn), new (std::nothrow) String(pValue));
924                                 delete pColumn;
925                                 delete pValue;
926                         }
927                 }
928                 else
929                 {
930                         i = 0;
931                         index = 0;
932                         while (i < columnCount * 2) // request list: column-value pairs
933                         {
934                                 pColumn = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_INSERTMAP + i++));
935                                 SysTryCatch(NID_APP, pColumn != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
936                                 SysLog(NID_APP, "[DC_PROV_RECV] column[%d]: %ls", index, pColumn->GetPointer());
937
938                                 pValue = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_INSERTMAP + i++));
939                                 SysTryCatch(NID_APP, pValue != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
940                                 SysLog(NID_APP, "[DC_PROV_RECV] value[%d]: %ls", index, pValue->GetPointer());
941
942                                 pInsertMap->Add(new (std::nothrow) String(*pColumn), new (std::nothrow) String(*pValue));
943                                 index++;
944                         }
945                 }
946
947                 if (pTmpPath)
948                 {
949                         r = File::Remove(*pTmpPath);
950                         SysTryLog(NID_APP, !IsFailed(r), "Failed to remove result: %ls", pTmpPath->GetPointer());
951                 }
952
953                 pSqlListener->OnSqlDataControlInsertRequestReceived(reqId, providerId, *pDataId, *pInsertMap);
954
955                 SysLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, pInsertMap: 0x%x",
956                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
957                                 pDataId->GetPointer(), pInsertMap);
958                 break;
959         case _DATACONTROL_REQUEST_TYPE_SQL_UPDATE:
960                 SysLog(NID_APP, "[DC_PROV_RECV] SqlDataControl UPDATE");
961
962                 // request list[1]: updated column count
963                 pColumnCount = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_COLUMNCOUNT));
964                 SysTryCatch(NID_APP, pColumnCount, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
965
966                 Integer::Parse(*pColumnCount, columnCount);
967                 SysLog(NID_APP, "[DC_PROV_RECV] updated column count: %d", columnCount);
968
969                 pUpdateMap = new (std::nothrow) HashMap();
970                 SysTryReturnVoidResult(NID_APP, pUpdateMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
971                 pUpdateMap->Construct();
972
973                 SysLog(NID_APP, "[DC_PROV_RECV] version: %ls", version.GetPointer());
974                 if (version == L"ver_2.1.0.2" || version == L"ver_2.1.0.3")
975                 {
976                         pTmpPath = dynamic_cast< String* >(pList->GetAt(2)); // request list[2]: path
977                         SysTryCatch(NID_APP, pTmpPath != null, , E_SYSTEM, "[E_SYSTEM] invalid request");
978                         SysLog(NID_APP, "[DC_PROV_RECV] request: %ls", pTmpPath->GetPointer());
979
980                         File request;
981                         r = request.Construct(*pTmpPath, "r");
982                         SysTryCatch(NID_APP, !IsFailed(r), , E_SYSTEM, "[%s] Failed to open request (%ls).",
983                                         GetErrorMessage(r), pTmpPath->GetPointer());
984
985                         for (i = 0; i < columnCount; ++i) // column-value pairs
986                         {
987                                 int length = -1;
988                                 int ret = request.Read(&length, sizeof(int));
989                                 SysTryCatch(NID_APP, ret > 0, , E_SYSTEM, "[%s] Failed to receive request.",
990                                                 GetErrorMessage(GetLastResult()));
991
992                                 char* pColumn = new (std::nothrow) char[length + 1];
993                                 ret = request.Read(pColumn, length);
994                                 SysTryCatch(NID_APP, ret > 0, delete pColumn, E_SYSTEM, "[%s] Failed to receive request.",
995                                                 GetErrorMessage(GetLastResult()));
996                                 pColumn[length] = '\0';
997                                 SysLog(NID_APP, "[DC_PROV_RECV] column[%d]: %s", i, pColumn);
998
999                                 ret = request.Read(&length, sizeof(int));
1000                                 SysTryCatch(NID_APP, ret > 0, delete pColumn, E_SYSTEM, "[%s] Failed to receive request.",
1001                                                 GetErrorMessage(GetLastResult()));
1002
1003                                 char* pValue = new (std::nothrow) char[length + 1];
1004                                 ret = request.Read(pValue, length);
1005                                 if (ret == 0)
1006                                 {
1007                                         SysLogException(NID_APP, E_SYSTEM, "[%s] Failed to receive request.", GetErrorMessage(GetLastResult()));
1008                                         delete pColumn;
1009                                         delete pValue;
1010                                 }
1011                                 pValue[length] = '\0';
1012                                 SysLog(NID_APP, "[DC_PROV_RECV] value[%d]: %s", i, pValue);
1013
1014                                 pUpdateMap->Add(new (std::nothrow) String(pColumn), new (std::nothrow) String(pValue));
1015                                 delete pColumn;
1016                                 delete pValue;
1017                         }
1018
1019                         // request list: where clause
1020                         pWhere = dynamic_cast< String* >(pList->GetAt(3));
1021                         SysTryCatch(NID_APP, pWhere != null, , E_SYSTEM, "[E_SYSTEM] invalid request");
1022                 }
1023                 else
1024                 {
1025                         i = 0;
1026                         index = 0;
1027                         while (i < columnCount * 2) // request list: column-value pairs
1028                         {
1029                                 pColumn = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_UPDATEMAP + i++));
1030                                 SysTryCatch(NID_APP, pColumn != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1031                                 SysLog(NID_APP, "[DC_PROV_RECV] column[%d]: %ls", index, pColumn->GetPointer());
1032
1033                                 pValue = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_UPDATEMAP + i++));
1034                                 SysTryCatch(NID_APP, pValue != null, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1035                                 SysLog(NID_APP, "[DC_PROV_RECV] value[%d]: %ls", index, pValue->GetPointer());
1036
1037                                 pUpdateMap->Add(new (std::nothrow) String(*pColumn), new (std::nothrow) String(*pValue));
1038                                 index++;
1039                         }
1040
1041                         // request list: where clause
1042                         pWhere = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_UPDATEMAP + i));
1043                         SysTryCatch(NID_APP, pWhere, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1044                 }
1045
1046                 if (pWhere->Equals(empty) == true)
1047                 {
1048                         pWhere = null;
1049                 }
1050                 else
1051                 {
1052                         SysLog(NID_APP, "[DC_PROV_RECV] pWhere: %ls", pWhere->GetPointer());
1053                 }
1054
1055                 if (pTmpPath)
1056                 {
1057                         r = File::Remove(*pTmpPath);
1058                         SysTryLog(NID_APP, !IsFailed(r), "Failed to remove result: %ls", pTmpPath->GetPointer());
1059                 }
1060
1061                 pSqlListener->OnSqlDataControlUpdateRequestReceived(reqId, providerId, *pDataId, *pUpdateMap, pWhere);
1062
1063                 SysLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, pUpdateMap: 0x%x, pWhere: 0x%x",
1064                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
1065                                 pDataId->GetPointer(), pUpdateMap, pWhere);
1066                 break;
1067         case _DATACONTROL_REQUEST_TYPE_SQL_DELETE:
1068                 SysLog(NID_APP, "[DC_PROV_RECV] SqlDataControl DELETE");
1069
1070                 // request list[1]: where clause
1071                 pWhere = dynamic_cast< String* >(pList->GetAt(_DATACONTROL_PACKET_INDEX_DELETEWHERE));
1072                 SysTryCatch(NID_APP, pWhere, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1073
1074                 if (pWhere->Equals(empty) == true)
1075                 {
1076                         pWhere = null;
1077                 }
1078                 else
1079                 {
1080                         SysLog(NID_APP, "[DC_PROV_RECV] pWhere: %ls", pWhere->GetPointer());
1081                 }
1082
1083                 pSqlListener->OnSqlDataControlDeleteRequestReceived(reqId, providerId, *pDataId, pWhere);
1084
1085                 SysLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, pWhere: 0x%x",
1086                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
1087                                 pDataId->GetPointer(), pWhere);
1088                 break;
1089         case _DATACONTROL_REQUEST_TYPE_MAP_QUERY:
1090                 SysLog(NID_APP, "[DC_PROV_RECV] MapDataControl GetValue");
1091
1092                 pNo = dynamic_cast <String*>(pList->GetAt(2)); // request list[2]
1093                 SysTryCatch(NID_APP, pNo, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1094                 Integer::Parse(*pNo, pageNo);
1095
1096                 pCount = dynamic_cast <String*>(pList->GetAt(3)); // request list[3]
1097                 SysTryCatch(NID_APP, pCount, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1098                 Integer::Parse(*pCount, countPerPage);
1099
1100                 pMapListener->OnMapDataControlGetValueRequestReceived(reqId, providerId, *pDataId, *pKey);
1101
1102                 SysLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, key: %ls, pageNo: %d, countPerPage: %d",
1103                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
1104                                 pDataId->GetPointer(), pKey->GetPointer(), pageNo, countPerPage);
1105                 break;
1106         case _DATACONTROL_REQUEST_TYPE_MAP_INSERT:
1107                 SysLog(NID_APP, "[DC_PROV_RECV] MapDataControl AddValue");
1108
1109                 pValue = dynamic_cast <String*>(pList->GetAt(2)); // request list[2]
1110                 SysTryCatch(NID_APP, pValue, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1111
1112                 pMapListener->OnMapDataControlAddValueRequestReceived(reqId, providerId, *pDataId, *pKey, *pValue);
1113
1114                 SysLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, key: %ls, value: %ls",
1115                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
1116                                 pDataId->GetPointer(), pKey->GetPointer(), pValue->GetPointer());
1117                 break;
1118         case _DATACONTROL_REQUEST_TYPE_MAP_UPDATE:
1119                 SysLog(NID_APP, "[DC_PROV_RECV] MapDataControl SetValue");
1120
1121                 pOldValue = dynamic_cast <String*>(pList->GetAt(2)); // request list[2]
1122                 SysTryCatch(NID_APP, pOldValue, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1123
1124                 pNewValue = dynamic_cast <String*>(pList->GetAt(3)); // request list[3]
1125                 SysTryCatch(NID_APP, pNewValue, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1126
1127                 pMapListener->OnMapDataControlSetValueRequestReceived(reqId, providerId, *pDataId, *pKey, *pOldValue, *pNewValue);
1128
1129                 SysLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, key: %ls, oldValue: %ls, newValue: %ls",
1130                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
1131                                 pDataId->GetPointer(), pKey->GetPointer(), pOldValue->GetPointer(), pNewValue->GetPointer());
1132                 break;
1133         case _DATACONTROL_REQUEST_TYPE_MAP_DELETE:
1134                 SysLog(NID_APP, "[DC_PROV_RECV] MapDataControl RemoveValue");
1135
1136                 pValue = dynamic_cast <String*>(pList->GetAt(2)); // request list[2]
1137                 SysTryCatch(NID_APP, pValue, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1138
1139                 pMapListener->OnMapDataControlRemoveValueRequestReceived(reqId, providerId, *pDataId, *pKey, *pValue);
1140
1141                 SysLog(NID_APP, "[DC_PROV_RECV] caller app: %ls, requestType: %d, caller req: %ls, provider: %ls, data: %ls, key: %ls, value: %ls",
1142                                 appId.GetPointer(), requestType, callerReqId.GetPointer(), providerId.GetPointer(),
1143                                 pDataId->GetPointer(), pKey->GetPointer(), pValue->GetPointer());
1144                 break;
1145         default:
1146                 SysTryCatch(NID_APP, false, r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] invalid request");
1147                 break;
1148         }
1149
1150         if (pColumnList)
1151         {
1152                 pColumnList->RemoveAll(true);
1153                 delete pColumnList;
1154         }
1155
1156         if (pInsertMap)
1157         {
1158                 pInsertMap->RemoveAll(true);
1159                 delete pInsertMap;
1160         }
1161
1162         if (pUpdateMap)
1163         {
1164                 pUpdateMap->RemoveAll(true);
1165                 delete pUpdateMap;
1166         }
1167
1168         return;
1169
1170 CATCH:
1171         if (r == E_SYSTEM)
1172         {
1173                 pErrorMsg = new (std::nothrow) String("[E_SYSTEM] A system error has occurred.");
1174         }
1175         else if (r == E_OUT_OF_MEMORY)
1176         {
1177                 pErrorMsg = new (std::nothrow) String("[E_OUT_OF_MEMORY] The memory was insufficient.");
1178         }
1179         SysTryReturnVoidResult(NID_APP, pErrorMsg, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory was insufficient.");
1180
1181         res = DataControlProviderManager::GetInstance()->SendDataControlError(reqId, *pErrorMsg);
1182
1183         if (pColumnList)
1184         {
1185                 pColumnList->RemoveAll(true);
1186                 delete pColumnList;
1187         }
1188
1189         if (pInsertMap)
1190         {
1191                 pInsertMap->RemoveAll(true);
1192                 delete pInsertMap;
1193         }
1194
1195         if (pUpdateMap)
1196         {
1197                 pUpdateMap->RemoveAll(true);
1198                 delete pUpdateMap;
1199         }
1200
1201         delete pErrorMsg;
1202
1203         return;
1204 }
1205
1206
1207 void
1208 _AppImpl::OnConditionRequestReceived(const _AppArg& arg, RequestId reqId)
1209 {
1210         if (__pAppLaunchConditionEventListener == null)
1211         {
1212                 SysLog(NID_APP, "No App launch condition event listener");
1213                 return;
1214         }
1215
1216         String condition = arg.GetValue(OSP_K_COND);
1217         //Object* pExtraData = null;//TODO: retrieve NFC extra data.
1218     HashMap* pExtraData = arg.GetArgMapN();
1219         ArrayList* pList = arg.GetArgListN();
1220
1221         __pAppLaunchConditionEventListener->OnAppLaunchConditionMetN(condition, pExtraData, pList);
1222 }
1223
1224
1225 long
1226 _AppImpl::GetWindowHandle(void) const
1227 {
1228         SysTryReturn(NID_APP, __pIAppImpl != null, -1, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
1229
1230         return __pIAppImpl->OnWindowHandleRequest();
1231 }
1232
1233
1234 void
1235 _AppImpl::RaiseWindow(void)
1236 {
1237         SysTryReturnVoidResult(NID_APP, __pIAppImpl != null, E_INVALID_STATE, "[E_INVALID_STATE] Getting App instance failed.");
1238
1239         __pIAppImpl->OnFrameRaiseRequested();
1240 }
1241
1242
1243 void
1244 _AppImpl::OnAppCheckpoint(void)
1245 {
1246         if (__pCheckpointEventListener)
1247         {
1248                 __pCheckpointEventListener->OnAppCheckpointing(*(AppRegistry::GetInstance()));
1249         }
1250 }
1251
1252
1253 bool
1254 _AppImpl::ConfirmAppService(void)
1255 {
1256         if (_AppInfo::GetApplicationId() == SERVICE_APPID)
1257         {
1258                 return true;
1259         }
1260
1261         int value = -1;
1262         int count = 0;
1263         long interval = 100;
1264
1265         while (true)
1266         {
1267                 int res = vconf_get_int(VCONFKEY_APPSERVICE_STATUS, &value);
1268                 if (value > 0)
1269                 {
1270                         return true;
1271                 }
1272
1273                 if (count >= HEARTBEAT_WAIT_COUNT)
1274                 {
1275                         return false;
1276                 }
1277
1278                 SysLog(NID_APP, "Waiting for app service %dth time(%d msec).", count, interval);
1279                 count++;
1280                 Thread::Sleep(interval);
1281                 interval += 100;
1282         }
1283
1284         return false;
1285 }
1286
1287 result
1288 _AppImpl::SetListener(_AppEvent appEvent, IEventListener* pListener)
1289 {
1290         switch (appEvent)
1291         {
1292         case AE_CHECKPOINT:
1293                 SysTryReturnResult(NID_APP, __pCheckpointEventListener == null, E_OBJ_ALREADY_EXIST, "Checkpoint listener is already set.");
1294
1295                 // fall through
1296         case AE_CLEAR_LISTENER:
1297                 __pCheckpointEventListener = dynamic_cast <IAppCheckpointEventListener*>(pListener);
1298                 break;
1299
1300         default:
1301                 break;
1302         }
1303
1304         return E_SUCCESS;
1305 }
1306
1307
1308 result
1309 _AppImpl::SetSqlDataControlProviderEventListener(ISqlDataControlProviderEventListener* pListener)
1310 {
1311         __pSqlDataControlProviderEventListener = pListener;
1312         int tmpAppHandlerType = _AppInfo::GetAppHandlerType();
1313         tmpAppHandlerType |= _APP_HANDLER_DATACONTROL;
1314         _AppInfo::SetAppHandlerType(tmpAppHandlerType);
1315         return E_SUCCESS;
1316 }
1317
1318
1319 result
1320 _AppImpl::SetMapDataControlProviderEventListener(IMapDataControlProviderEventListener* pListener)
1321 {
1322         __pMapDataControlProviderEventListener = pListener;
1323         int tmpAppHandlerType = _AppInfo::GetAppHandlerType();
1324         tmpAppHandlerType |= _APP_HANDLER_DATACONTROL;
1325         _AppInfo::SetAppHandlerType(tmpAppHandlerType);
1326         return E_SUCCESS;
1327 }
1328
1329
1330 result
1331 _AppImpl::SetAppControlProviderEventListener(IAppControlProviderEventListener* pListener)
1332 {
1333         __pAppControlProviderEventListener = pListener;
1334         int tmpAppHandlerType = _AppInfo::GetAppHandlerType();
1335         tmpAppHandlerType |= _APP_HANDLER_APPCONTROL;
1336         _AppInfo::SetAppHandlerType(tmpAppHandlerType);
1337         return E_SUCCESS;
1338 }
1339
1340 result
1341 _AppImpl::SetAppControlProviderInternalEventListener(IAppControlProviderEventListener* pListener)
1342 {
1343         __pAppControlProviderInternalEventListener = pListener;
1344         int tmpAppHandlerType = _AppInfo::GetAppHandlerType();
1345         tmpAppHandlerType |= _APP_HANDLER_APPCONTROL;
1346         _AppInfo::SetAppHandlerType(tmpAppHandlerType);
1347         return E_SUCCESS;
1348 }
1349
1350
1351 result
1352 _AppImpl::SetAppLaunchConditionEventListener(IAppLaunchConditionEventListener* pListener)
1353 {
1354         __pAppLaunchConditionEventListener = pListener;
1355         int tmpAppHandlerType = _AppInfo::GetAppHandlerType();
1356         tmpAppHandlerType |= _APP_HANDLER_LAUNCH_COND;
1357         _AppInfo::SetAppHandlerType(tmpAppHandlerType);
1358
1359         return E_SUCCESS;
1360 }
1361
1362
1363 bool
1364 _AppImpl::IsTerminationRequested(void)
1365 {
1366         return __isTerminationRequested;
1367 }
1368
1369 void
1370 _AppImpl::OnPowerOffNotiReceived(void* user_data)
1371 {
1372         SysLog(NID_APP, "Application is being terminated by power off.");
1373
1374         _AppImpl* pAppImpl = _AppImpl::GetInstance();
1375         if (pAppImpl != null)
1376         {
1377                 pAppImpl->__forcedTermination = true;
1378         }
1379         
1380         app_efl_exit();
1381 }
1382
1383 bool 
1384 _AppImpl::IsForcedTermination(void)
1385 {
1386         return __forcedTermination;
1387 }
1388
1389 }} //Tizen::App
1390