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