2 * Copyright (c) 2017 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include "framework.h"
26 #include <system_info.h>
27 #include <system_settings.h>
28 #include <app_control_internal.h>
29 #include <bundle_internal.h>
31 // CONDITIONAL INCLUDES
32 #ifdef APPCORE_WATCH_AVAILABLE
33 #include <appcore-watch/watch_app.h>
35 #ifdef DALI_ELDBUS_AVAILABLE
37 #endif // DALI_ELDBUS_AVAILABLE
39 #if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
40 #include <tzplatform_config.h>
41 #endif // TIZEN_PLATFORM_CONFIG_SUPPORTED
43 #include <dali/integration-api/debug.h>
46 #include <callback-manager.h>
57 #if defined(DEBUG_ENABLED)
60 Integration::Log::Filter* gDBusLogging = Integration::Log::Filter::New( Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DBUS" );
61 } // anonymous namespace
65 * Impl to hide EFL data members
67 struct Framework::Impl
70 Impl(void* data, Type type )
71 : mAbortCallBack( NULL ),
72 mCallbackManager( NULL ),
74 #ifdef APPCORE_WATCH_AVAILABLE
78 mFramework = static_cast<Framework*>(data);
80 #ifndef APPCORE_WATCH_AVAILABLE
83 throw Dali::DaliException( "", "Watch Application is not supported." );
86 mApplicationType = type;
87 mCallbackManager = CallbackManager::New();
91 system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, ®ion );
92 system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &language );
93 mRegion = std::string( region );
94 mLanguage = std::string( language );
99 delete mAbortCallBack;
101 // we're quiting the main loop so
102 // mCallbackManager->RemoveAllCallBacks() does not need to be called
103 // to delete our abort handler
104 delete mCallbackManager;
111 if (mApplicationType == NORMAL)
113 ret = AppNormalMain();
117 ret = AppWatchMain();
124 if (mApplicationType == NORMAL)
134 std::string GetLanguage() const
139 std::string GetRegion() const
145 Type mApplicationType;
146 CallbackBase* mAbortCallBack;
147 CallbackManager *mCallbackManager;
148 std::string mLanguage;
151 Framework* mFramework;
152 app_event_handler_h handlers[5];
153 ui_app_lifecycle_callback_s mEventCallback;
154 #ifdef APPCORE_WATCH_AVAILABLE
155 watch_app_lifecycle_callback_s mWatchCallback;
158 static bool AppCreate(void *data)
160 return static_cast<Framework*>(data)->Create();
163 static void AppTerminate(void *data)
165 Observer *observer = &static_cast<Framework*>(data)->mObserver;
167 observer->OnTerminate();
170 static void AppPause(void *data)
172 Observer *observer = &static_cast<Framework*>(data)->mObserver;
177 static void AppResume(void *data)
179 Observer *observer = &static_cast<Framework*>(data)->mObserver;
181 observer->OnResume();
184 static void ProcessBundle(Framework* framework, bundle *bundleData)
186 if(bundleData == NULL)
192 char* bundleName = const_cast<char*>(bundle_get_val(bundleData, "name"));
193 if(bundleName != NULL)
195 framework->SetBundleName(bundleName);
199 char* bundleId = const_cast<char*>(bundle_get_val(bundleData, "id"));
202 framework->SetBundleId(bundleId);
207 * Called by AppCore when the application is launched from another module (e.g. homescreen).
208 * @param[in] b the bundle data which the launcher module sent
210 static void AppControl(app_control_h app_control, void *data)
212 Framework* framework = static_cast<Framework*>(data);
213 Observer *observer = &framework->mObserver;
214 bundle *bundleData = NULL;
216 app_control_to_bundle(app_control, &bundleData);
217 ProcessBundle(framework, bundleData);
220 observer->OnAppControl(app_control);
227 mEventCallback.create = AppCreate;
228 mEventCallback.terminate = AppTerminate;
229 mEventCallback.pause = AppPause;
230 mEventCallback.resume = AppResume;
231 mEventCallback.app_control = AppControl;
233 ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
234 ui_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
235 ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED], APP_EVENT_DEVICE_ORIENTATION_CHANGED, AppDeviceRotated, mFramework);
236 ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
237 ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
239 ret = ui_app_main(*mFramework->mArgc, *mFramework->mArgv, &mEventCallback, mFramework);
249 #ifdef APPCORE_WATCH_AVAILABLE
250 static bool AppCreateWatch(int width, int height, void *data)
252 return static_cast<Framework*>(data)->Create();
255 static void AppTimeTick(watch_time_h time, void *data)
257 Observer *observer = &static_cast<Framework*>(data)->mObserver;
258 WatchTime curTime(time);
260 observer->OnTimeTick(curTime);
263 static void AppAmbientTick(watch_time_h time, void *data)
265 Observer *observer = &static_cast<Framework*>(data)->mObserver;
266 WatchTime curTime(time);
268 observer->OnAmbientTick(curTime);
271 static void AppAmbientChanged(bool ambient, void *data)
273 Observer *observer = &static_cast<Framework*>(data)->mObserver;
275 observer->OnAmbientChanged(ambient);
283 #ifdef APPCORE_WATCH_AVAILABLE
284 mWatchCallback.create = AppCreateWatch;
285 mWatchCallback.app_control = AppControl;
286 mWatchCallback.terminate = AppTerminate;
287 mWatchCallback.pause = AppPause;
288 mWatchCallback.resume = AppResume;
289 mWatchCallback.time_tick = AppTimeTick;
290 mWatchCallback.ambient_tick = AppAmbientTick;
291 mWatchCallback.ambient_changed = AppAmbientChanged;
293 watch_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
294 watch_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
295 watch_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
296 watch_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
298 ret = watch_app_main(*mFramework->mArgc, *mFramework->mArgv, &mWatchCallback, mFramework);
305 #ifdef APPCORE_WATCH_AVAILABLE
310 static void AppLanguageChanged(app_event_info_h event, void *data)
312 Observer *observer = &static_cast<Framework*>(data)->mObserver;
313 observer->OnLanguageChanged();
316 static void AppDeviceRotated(app_event_info_h event_info, void *data)
320 static void AppRegionChanged(app_event_info_h event, void *data)
322 Observer *observer = &static_cast<Framework*>(data)->mObserver;
323 observer->OnRegionChanged();
326 static void AppBatteryLow(app_event_info_h event, void *data)
328 Observer *observer = &static_cast<Framework*>(data)->mObserver;
329 observer->OnBatteryLow(Dali::DeviceStatus::Battery::NORMAL);
332 static void AppMemoryLow(app_event_info_h event, void *data)
334 Observer *observer = &static_cast<Framework*>(data)->mObserver;
335 observer->OnMemoryLow(Dali::DeviceStatus::Memory::NORMAL);
340 Impl( const Impl& impl );
343 Impl& operator=( const Impl& impl );
346 Framework::Framework( Framework::Observer& observer, int *argc, char ***argv, Type type )
347 : mObserver(observer),
354 mAbortHandler( MakeCallback( this, &Framework::AbortCallback ) ),
357 bool featureFlag = true;
358 system_info_get_platform_bool( "tizen.org/feature/opengles.version.2_0", &featureFlag );
360 if( featureFlag == false )
362 set_last_result( TIZEN_ERROR_NOT_SUPPORTED );
364 #ifdef DALI_ELDBUS_AVAILABLE
365 // Initialize ElDBus.
366 DALI_LOG_INFO( gDBusLogging, Debug::General, "Starting DBus Initialization\n" );
371 mImpl = new Impl(this, type);
374 Framework::~Framework()
381 #ifdef DALI_ELDBUS_AVAILABLE
383 DALI_LOG_INFO( gDBusLogging, Debug::General, "Shutting down DBus\n" );
390 bool Framework::Create()
397 void Framework::Run()
402 ret = mImpl->AppMain();
403 if (ret != APP_ERROR_NONE)
405 DALI_LOG_ERROR("Framework::Run(), ui_app_main() is failed. err = %d\n", ret);
410 void Framework::Quit()
415 bool Framework::IsMainLoopRunning()
420 void Framework::AddAbortCallback( CallbackBase* callback )
422 mImpl->mAbortCallBack = callback;
425 std::string Framework::GetBundleName() const
430 void Framework::SetBundleName(const std::string& name)
435 std::string Framework::GetBundleId() const
440 std::string Framework::GetResourcePath()
442 std::string resourcePath = "";
443 #if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
444 resourcePath = app_get_resource_path();
445 #else // For backwards compatibility with older Tizen versions
447 // "DALI_APPLICATION_PACKAGE" is used to get the already configured Application package path.
448 const char* environmentVariable = "DALI_APPLICATION_PACKAGE";
449 char* value = getenv( environmentVariable );
452 resourcePath = value;
454 #endif //TIZEN_PLATFORM_CONFIG_SUPPORTED
459 void Framework::SetBundleId(const std::string& id)
464 void Framework::AbortCallback( )
466 // if an abort call back has been installed run it.
467 if (mImpl->mAbortCallBack)
469 CallbackBase::Execute( *mImpl->mAbortCallBack );
477 std::string Framework::GetLanguage() const
479 return mImpl->GetLanguage();
482 std::string Framework::GetRegion() const
484 return mImpl->GetRegion();
487 } // namespace Adaptor
489 } // namespace Internal