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 <app_control_internal.h>
28 #include <bundle_internal.h>
30 // CONDITIONAL INCLUDES
31 #ifdef APPCORE_WATCH_AVAILABLE
32 #include <appcore-watch/watch_app.h>
34 #ifdef DALI_ELDBUS_AVAILABLE
36 #endif // DALI_ELDBUS_AVAILABLE
38 #if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
39 #include <tzplatform_config.h>
40 #endif // TIZEN_PLATFORM_CONFIG_SUPPORTED
42 #include <dali/integration-api/debug.h>
45 #include <callback-manager.h>
56 #if defined(DEBUG_ENABLED)
59 Integration::Log::Filter* gDBusLogging = Integration::Log::Filter::New( Debug::NoLogging, false, "LOG_ADAPTOR_EVENTS_DBUS" );
60 } // anonymous namespace
64 * Impl to hide EFL data members
66 struct Framework::Impl
69 Impl(void* data, Type type )
70 : mAbortCallBack( NULL ),
71 mCallbackManager( NULL ),
73 #ifdef APPCORE_WATCH_AVAILABLE
77 mFramework = static_cast<Framework*>(data);
79 #ifndef APPCORE_WATCH_AVAILABLE
82 throw Dali::DaliException( "", "Watch Application is not supported." );
85 mApplicationType = type;
86 mCallbackManager = CallbackManager::New();
91 delete mAbortCallBack;
93 // we're quiting the main loop so
94 // mCallbackManager->RemoveAllCallBacks() does not need to be called
95 // to delete our abort handler
96 delete mCallbackManager;
103 if (mApplicationType == NORMAL)
105 ret = AppNormalMain();
109 ret = AppWatchMain();
116 if (mApplicationType == NORMAL)
128 Type mApplicationType;
129 CallbackBase* mAbortCallBack;
130 CallbackManager *mCallbackManager;
132 Framework* mFramework;
133 app_event_handler_h handlers[5];
134 ui_app_lifecycle_callback_s mEventCallback;
135 #ifdef APPCORE_WATCH_AVAILABLE
136 watch_app_lifecycle_callback_s mWatchCallback;
139 static bool AppCreate(void *data)
141 return static_cast<Framework*>(data)->Create();
144 static void AppTerminate(void *data)
146 Observer *observer = &static_cast<Framework*>(data)->mObserver;
148 observer->OnTerminate();
151 static void AppPause(void *data)
153 Observer *observer = &static_cast<Framework*>(data)->mObserver;
158 static void AppResume(void *data)
160 Observer *observer = &static_cast<Framework*>(data)->mObserver;
162 observer->OnResume();
165 static void ProcessBundle(Framework* framework, bundle *bundleData)
167 if(bundleData == NULL)
173 char* bundleName = const_cast<char*>(bundle_get_val(bundleData, "name"));
174 if(bundleName != NULL)
176 framework->SetBundleName(bundleName);
180 char* bundleId = const_cast<char*>(bundle_get_val(bundleData, "id"));
183 framework->SetBundleId(bundleId);
188 * Called by AppCore when the application is launched from another module (e.g. homescreen).
189 * @param[in] b the bundle data which the launcher module sent
191 static void AppControl(app_control_h app_control, void *data)
193 Framework* framework = static_cast<Framework*>(data);
194 Observer *observer = &framework->mObserver;
195 bundle *bundleData = NULL;
197 app_control_to_bundle(app_control, &bundleData);
198 ProcessBundle(framework, bundleData);
201 observer->OnAppControl(app_control);
208 mEventCallback.create = AppCreate;
209 mEventCallback.terminate = AppTerminate;
210 mEventCallback.pause = AppPause;
211 mEventCallback.resume = AppResume;
212 mEventCallback.app_control = AppControl;
214 ui_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
215 ui_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
216 ui_app_add_event_handler(&handlers[APP_EVENT_DEVICE_ORIENTATION_CHANGED], APP_EVENT_DEVICE_ORIENTATION_CHANGED, AppDeviceRotated, mFramework);
217 ui_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
218 ui_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
220 ret = ui_app_main(*mFramework->mArgc, *mFramework->mArgv, &mEventCallback, mFramework);
230 #ifdef APPCORE_WATCH_AVAILABLE
231 static bool AppCreateWatch(int width, int height, void *data)
233 return static_cast<Framework*>(data)->Create();
236 static void AppTimeTick(watch_time_h time, void *data)
238 Observer *observer = &static_cast<Framework*>(data)->mObserver;
239 WatchTime curTime(time);
241 observer->OnTimeTick(curTime);
244 static void AppAmbientTick(watch_time_h time, void *data)
246 Observer *observer = &static_cast<Framework*>(data)->mObserver;
247 WatchTime curTime(time);
249 observer->OnAmbientTick(curTime);
252 static void AppAmbientChanged(bool ambient, void *data)
254 Observer *observer = &static_cast<Framework*>(data)->mObserver;
256 observer->OnAmbientChanged(ambient);
264 #ifdef APPCORE_WATCH_AVAILABLE
265 mWatchCallback.create = AppCreateWatch;
266 mWatchCallback.app_control = AppControl;
267 mWatchCallback.terminate = AppTerminate;
268 mWatchCallback.pause = AppPause;
269 mWatchCallback.resume = AppResume;
270 mWatchCallback.time_tick = AppTimeTick;
271 mWatchCallback.ambient_tick = AppAmbientTick;
272 mWatchCallback.ambient_changed = AppAmbientChanged;
274 watch_app_add_event_handler(&handlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, AppBatteryLow, mFramework);
275 watch_app_add_event_handler(&handlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, AppMemoryLow, mFramework);
276 watch_app_add_event_handler(&handlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
277 watch_app_add_event_handler(&handlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
279 ret = watch_app_main(*mFramework->mArgc, *mFramework->mArgv, &mWatchCallback, mFramework);
286 #ifdef APPCORE_WATCH_AVAILABLE
291 static void AppLanguageChanged(app_event_info_h event, void *data)
293 Observer *observer = &static_cast<Framework*>(data)->mObserver;
295 observer->OnLanguageChanged();
298 static void AppDeviceRotated(app_event_info_h event_info, void *data)
302 static void AppRegionChanged(app_event_info_h event, void *data)
304 Observer *observer = &static_cast<Framework*>(data)->mObserver;
306 observer->OnRegionChanged();
309 static void AppBatteryLow(app_event_info_h event, void *data)
311 Observer *observer = &static_cast<Framework*>(data)->mObserver;
313 observer->OnBatteryLow();
316 static void AppMemoryLow(app_event_info_h event, void *data)
318 Observer *observer = &static_cast<Framework*>(data)->mObserver;
320 observer->OnMemoryLow();
325 Impl( const Impl& impl );
328 Impl& operator=( const Impl& impl );
331 Framework::Framework( Framework::Observer& observer, int *argc, char ***argv, Type type )
332 : mObserver(observer),
339 mAbortHandler( MakeCallback( this, &Framework::AbortCallback ) ),
342 bool featureFlag = true;
343 system_info_get_platform_bool( "tizen.org/feature/opengles.version.2_0", &featureFlag );
345 if( featureFlag == false )
347 set_last_result( TIZEN_ERROR_NOT_SUPPORTED );
349 #ifdef DALI_ELDBUS_AVAILABLE
350 // Initialize ElDBus.
351 DALI_LOG_INFO( gDBusLogging, Debug::General, "Starting DBus Initialization\n" );
356 mImpl = new Impl(this, type);
359 Framework::~Framework()
366 #ifdef DALI_ELDBUS_AVAILABLE
368 DALI_LOG_INFO( gDBusLogging, Debug::General, "Shutting down DBus\n" );
375 bool Framework::Create()
382 void Framework::Run()
387 ret = mImpl->AppMain();
388 if (ret != APP_ERROR_NONE)
390 DALI_LOG_ERROR("Framework::Run(), ui_app_main() is failed. err = %d\n", ret);
395 void Framework::Quit()
400 bool Framework::IsMainLoopRunning()
405 void Framework::AddAbortCallback( CallbackBase* callback )
407 mImpl->mAbortCallBack = callback;
410 std::string Framework::GetBundleName() const
415 void Framework::SetBundleName(const std::string& name)
420 std::string Framework::GetBundleId() const
425 std::string Framework::GetResourcePath()
427 std::string resourcePath = "";
428 #if defined( TIZEN_PLATFORM_CONFIG_SUPPORTED ) && TIZEN_PLATFORM_CONFIG_SUPPORTED
429 resourcePath = app_get_resource_path();
430 #else // For backwards compatibility with older Tizen versions
432 // "DALI_APPLICATION_PACKAGE" is used to get the already configured Application package path.
433 const char* environmentVariable = "DALI_APPLICATION_PACKAGE";
434 char* value = getenv( environmentVariable );
437 resourcePath = value;
439 #endif //TIZEN_PLATFORM_CONFIG_SUPPORTED
444 void Framework::SetBundleId(const std::string& id)
449 void Framework::AbortCallback( )
451 // if an abort call back has been installed run it.
452 if (mImpl->mAbortCallBack)
454 CallbackBase::Execute( *mImpl->mAbortCallBack );
462 } // namespace Adaptor
464 } // namespace Internal