{
}
+void OnDeviceOrientationChangedSignalCallback(DeviceStatus::Orientation::Status status)
+{
+}
+
int UtcDaliApplicationNew01(void)
{
Application application = Application::New();
END_TEST;
}
+int UtcDaliApplicationOrientationChangedSignalP(void)
+{
+ Application application = Application::New();
+ application.DeviceOrientationChangedSignal().Connect(&OnDeviceOrientationChangedSignalCallback);
+ DALI_TEST_CHECK(application);
+
+ END_TEST;
+}
+
+int UtcDaliApplicationOrientationChangedSignalN(void)
+{
+ Application application;
+
+ try
+ {
+ application.DeviceOrientationChangedSignal().Connect(&OnDeviceOrientationChangedSignalCallback);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true);
+ }
+
+ END_TEST;
+}
+
int UtcDaliApplicationGetResourcePathP(void)
{
Application application = Application::New();
{
try
{
- Dali::Window instance;
+ Dali::Window instance;
DevelWindow::Maximize(instance, true);
DALI_TEST_CHECK(false); // Should not reach here!
}
{
try
{
- Dali::Window instance;
+ Dali::Window instance;
DevelWindow::IsMaximized(instance);
DALI_TEST_CHECK(false); // Should not reach here!
}
{
try
{
- Dali::Window instance;
+ Dali::Window instance;
Dali::Window::WindowSize size(100, 100);
DevelWindow::SetMaximumSize(instance, size);
DALI_TEST_CHECK(false); // Should not reach here!
{
try
{
- Dali::Window instance;
+ Dali::Window instance;
DevelWindow::Minimize(instance, true);
DALI_TEST_CHECK(false); // Should not reach here!
}
{
try
{
- Dali::Window instance;
+ Dali::Window instance;
DevelWindow::IsMinimized(instance);
DALI_TEST_CHECK(false); // Should not reach here!
}
{
try
{
- Dali::Window instance;
+ Dali::Window instance;
Dali::Window::WindowSize size(100, 100);
DevelWindow::SetMimimumSize(instance, size);
DALI_TEST_CHECK(false); // Should not reach here!
Dali::Window instance;
try
{
- Rect<int> includedInputRegion(0,0,720,640);
+ Rect<int> includedInputRegion(0, 0, 720, 640);
DevelWindow::IncludeInputRegion(instance, includedInputRegion);
DALI_TEST_CHECK(false); // Should not get here
}
Dali::Window instance;
try
{
- Rect<int> includedInputRegion(0,0,720,1280);
+ Rect<int> includedInputRegion(0, 0, 720, 1280);
DevelWindow::IncludeInputRegion(instance, includedInputRegion);
- Rect<int> excludedInputRegion(0,641,720,640);
+ Rect<int> excludedInputRegion(0, 641, 720, 640);
DevelWindow::ExcludeInputRegion(instance, excludedInputRegion);
DALI_TEST_CHECK(false); // Should not get here
END_TEST;
}
-
int UtcDaliWindowSetNeedsRotationCompletedAcknowledgementNegative(void)
{
try
}
END_TEST;
}
+
+int UtcDaliWindowMovedSignalNegative(void)
+{
+ Dali::Window instance;
+ try
+ {
+ DevelWindow::MovedSignal(instance);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliWindowOrientationChangedSignalNegative(void)
+{
+ Dali::Window instance;
+ try
+ {
+ DevelWindow::OrientationChangedSignal(instance);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
return GetImplementation(window).MovedSignal();
}
+OrientationChangedSignalType& OrientationChangedSignal(Window window)
+{
+ return GetImplementation(window).OrientationChangedSignal();
+}
+
void SetParent(Window window, Window parent)
{
GetImplementation(window).SetParent(parent);
typedef Signal<void(Window, bool)> AccessibilityHighlightSignalType; ///< Accessibility Highlight signal type
typedef Signal<bool(const KeyEvent&)> InterceptKeyEventSignalType; ///< Intercept Key event signal type
typedef Signal<void(Window, Dali::Window::WindowPosition)> MovedSignalType; ///< Window Moved signal type
+typedef Signal<void(Window, Dali::WindowOrientation)> OrientationChangedSignalType; ///< Window orientation changed signal type
/**
* @brief Creates an initialized handle to a new Window.
* @param[in] isTransparent Whether Window is transparent
* @return A new window
* @note This creates an extra window in addition to the default main window
-*/
+ */
DALI_ADAPTOR_API Window New(Any surface, PositionSize windowPosition, const std::string& name, bool isTransparent = false);
/**
*/
DALI_ADAPTOR_API MovedSignalType& MovedSignal(Window window);
+/**
+ * @brief This signal is emitted when the window orientation is changed.
+ *
+ * To emit Window Orientation signal, AddAvailableOrientation() or SetPreferredOrientation() should be called before device is rotated.
+ * Most of cases, AddAvailableOrientation() or SetPreferredOrientation() is callled in onCreate().
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName( Window window, Dali::WindowOrientation orientation );
+ * @endcode
+ * The parameter is the changed window orientation.
+ * and window means this signal was called from what window
+ *
+ * @param[in] window The window instance.
+ * @return The signal to connect to
+ */
+DALI_ADAPTOR_API OrientationChangedSignalType& OrientationChangedSignal(Window window);
+
} // namespace DevelWindow
} // namespace Dali
mLowMemorySignal.Emit(status);
}
+void Application::OnDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status)
+{
+ Dali::Application application(this);
+ mDeviceOrientationChangedSignal.Emit(status);
+}
+
void Application::OnSurfaceCreated(Any newSurface)
{
void* newWindow = AnyCast<void*>(newSurface);
mTaskLowMemorySignal.Emit(status);
}
+void Application::OnTaskDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status)
+{
+ Dali::Application application(this);
+ mTaskDeviceOrientationChangedSignal.Emit(status);
+}
+
bool Application::AddIdle(CallbackBase* callback, bool hasReturnValue)
{
return mAdaptor->AddIdle(callback, hasReturnValue);
class Application : public BaseObject, public Framework::Observer, public Framework::TaskObserver
{
public:
- typedef Dali::Application::LowBatterySignalType LowBatterySignalType;
- typedef Dali::Application::LowMemorySignalType LowMemorySignalType;
- typedef Dali::Application::AppSignalType AppSignalType;
- typedef Dali::Application::AppControlSignalType AppControlSignalType;
- typedef Dali::Application::WINDOW_MODE WINDOW_MODE;
+ typedef Dali::Application::LowBatterySignalType LowBatterySignalType;
+ typedef Dali::Application::LowMemorySignalType LowMemorySignalType;
+ typedef Dali::Application::DeviceOrientationChangedSignalType DeviceOrientationChangedSignalType;
+ typedef Dali::Application::AppSignalType AppSignalType;
+ typedef Dali::Application::AppControlSignalType AppControlSignalType;
+ typedef Dali::Application::WINDOW_MODE WINDOW_MODE;
/**
* Create a new application
void OnMemoryLow(Dali::DeviceStatus::Memory::Status status) override;
/**
+ * Called when the framework informs the application that device orientation is changed.
+ */
+ void OnDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status) override;
+
+ /**
* Called when the framework informs the application that the platform surface is created.
*/
void OnSurfaceCreated(Any newSurface) override;
*/
void OnTaskMemoryLow(Dali::DeviceStatus::Memory::Status status) override;
+ /**
+ * Called when the framework informs the application that the device orientation is changed.
+ *
+ * Device orientation changed event is from Application Framework(Sensor Framework), it means it is system event.
+ * If UIThreading is enable, DALI application has the main thread and UI thread.
+ * This event is emitted in main thread, then it is posted to the UI thread in this callback function.
+ */
+ void OnTaskDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status) override;
+
public:
/**
* Sets a user defined theme file.
}
/**
+ * @copydoc Dali::Application:::DeviceOrientationChangedSignalType()
+ */
+ Dali::Application::DeviceOrientationChangedSignalType& DeviceOrientationChangedSignal()
+ {
+ return mDeviceOrientationChangedSignal;
+ }
+
+ /**
* @copydoc Dali::Application::TaskInitSignal()
*/
Dali::Application::AppSignalType& TaskInitSignal()
return mTaskLowMemorySignal;
}
+ /**
+ * @copydoc Dali::Application::TaskDeviceOrientationChangedSignal()
+ */
+ Dali::Application::DeviceOrientationChangedSignalType& TaskDeviceOrientationChangedSignal()
+ {
+ return mTaskDeviceOrientationChangedSignal;
+ }
+
protected:
/**
* Private Constructor
void ChangePreInitializedWindowSize();
private:
- AppSignalType mInitSignal;
- AppSignalType mTerminateSignal;
- AppSignalType mPauseSignal;
- AppSignalType mResumeSignal;
- AppSignalType mResetSignal;
- AppControlSignalType mAppControlSignal;
- AppSignalType mLanguageChangedSignal;
- AppSignalType mRegionChangedSignal;
- LowBatterySignalType mLowBatterySignal;
- LowMemorySignalType mLowMemorySignal;
-
- AppSignalType mTaskInitSignal;
- AppSignalType mTaskTerminateSignal;
- AppControlSignalType mTaskAppControlSignal;
- AppSignalType mTaskLanguageChangedSignal;
- AppSignalType mTaskRegionChangedSignal;
- LowBatterySignalType mTaskLowBatterySignal;
- LowMemorySignalType mTaskLowMemorySignal;
+ AppSignalType mInitSignal;
+ AppSignalType mTerminateSignal;
+ AppSignalType mPauseSignal;
+ AppSignalType mResumeSignal;
+ AppSignalType mResetSignal;
+ AppControlSignalType mAppControlSignal;
+ AppSignalType mLanguageChangedSignal;
+ AppSignalType mRegionChangedSignal;
+ LowBatterySignalType mLowBatterySignal;
+ LowMemorySignalType mLowMemorySignal;
+ DeviceOrientationChangedSignalType mDeviceOrientationChangedSignal;
+
+ AppSignalType mTaskInitSignal;
+ AppSignalType mTaskTerminateSignal;
+ AppControlSignalType mTaskAppControlSignal;
+ AppSignalType mTaskLanguageChangedSignal;
+ AppSignalType mTaskRegionChangedSignal;
+ LowBatterySignalType mTaskLowBatterySignal;
+ LowMemorySignalType mTaskLowMemorySignal;
+ DeviceOrientationChangedSignalType mTaskDeviceOrientationChangedSignal;
EventLoop* mEventLoop;
Framework* mFramework;
}
/**
+ * Invoked when the device orientation is changed.
+ */
+ virtual void OnDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status)
+ {
+ }
+
+ /**
* Invoked when the platform surface is created.
*/
virtual void OnSurfaceCreated(Any newSurface)
virtual void OnTaskMemoryLow(Dali::DeviceStatus::Memory::Status status)
{
}
+
+ /**
+ * Invoked when the device orientation is changed.
+ *
+ * Device orientation changed event is from Application Framework(Sensor Framework), it means it is system event.
+ * If UIThreading is enable, DALI application has the main thread and UI thread.
+ * This event is emitted in main thread, then it is posted to the UI thread in this callback function.
+ */
+ virtual void OnTaskDeviceOrientationChanged(Dali::DeviceStatus::Orientation::Status status)
+ {
+ }
};
public:
}
}
+DeviceStatus::Orientation::Status GetOrientationStatus(app_device_orientation_e orientationStatus)
+{
+ switch(orientationStatus)
+ {
+ case APP_DEVICE_ORIENTATION_0:
+ {
+ return Dali::DeviceStatus::Orientation::Status::ORIENTATION_0;
+ }
+ case APP_DEVICE_ORIENTATION_90:
+ {
+ return Dali::DeviceStatus::Orientation::Status::ORIENTATION_90;
+ }
+ case APP_DEVICE_ORIENTATION_180:
+ {
+ return Dali::DeviceStatus::Orientation::Status::ORIENTATION_180;
+ }
+ case APP_DEVICE_ORIENTATION_270:
+ {
+ return Dali::DeviceStatus::Orientation::Status::ORIENTATION_270;
+ }
+ default:
+ {
+ return Dali::DeviceStatus::Orientation::Status::ORIENTATION_0;
+ }
+ }
+}
+
} // namespace AppCore
/**
explicit Task(Framework* framework)
: mFramework(framework),
mNewBatteryStatus(Dali::DeviceStatus::Battery::Status::NORMAL),
- mNewMemoryStatus(Dali::DeviceStatus::Memory::NORMAL)
+ mNewMemoryStatus(Dali::DeviceStatus::Memory::NORMAL),
+ mNewDeviceOrientationStatus(Dali::DeviceStatus::Orientation::ORIENTATION_0)
{
}
mNewMemoryStatus = AppCore::GetMemoryStatus(static_cast<app_event_low_memory_status_e>(state));
PostToUiThread(
- [](gpointer userData) -> gboolean {
+ [](gpointer userData) -> gboolean
+ {
auto* task = static_cast<Task*>(userData);
auto* framework = static_cast<Framework*>(task->mFramework);
framework->mObserver.OnMemoryLow(task->mNewMemoryStatus);
AppCoreTaskBase::OnLowMemory(state);
}
+ void OnDeviceOrientationChanged(AppCoreTaskBase::DeviceOrientationState state) override
+ {
+ print_log(DLOG_INFO, "DALI", "%s: %s(%d) > OnDeviceOrientationChanged() emitted, orientation :%d", __MODULE__, __func__, __LINE__, state);
+
+ mNewDeviceOrientationStatus = AppCore::GetOrientationStatus(static_cast<app_device_orientation_e>(state));
+
+ PostToUiThread(
+ [](gpointer userData) -> gboolean
+ {
+ auto* task = static_cast<Task*>(userData);
+ auto* framework = static_cast<Framework*>(task->mFramework);
+ framework->mObserver.OnDeviceOrientationChanged(task->mNewDeviceOrientationStatus);
+ return G_SOURCE_REMOVE;
+ });
+
+ mFramework->mTaskObserver.OnTaskDeviceOrientationChanged(mNewDeviceOrientationStatus);
+
+ AppCoreTaskBase::OnDeviceOrientationChanged(state);
+ }
void OnLowBattery(AppCoreTaskBase::LowBatteryState state) override
{
print_log(DLOG_INFO, "DALI", "%s: %s(%d) > OnLowBattery() emitted", __MODULE__, __func__, __LINE__);
mNewBatteryStatus = AppCore::GetBatteryStatus(static_cast<app_event_low_battery_status_e>(state));
PostToUiThread(
- [](gpointer userData) -> gboolean {
+ [](gpointer userData) -> gboolean
+ {
auto* task = static_cast<Task*>(userData);
auto* framework = static_cast<Framework*>(task->mFramework);
framework->mObserver.OnBatteryLow(task->mNewBatteryStatus);
mFramework->SetLanguage(mNewLanguage);
PostToUiThread(
- [](gpointer userData) -> gboolean {
+ [](gpointer userData) -> gboolean
+ {
auto* task = static_cast<Task*>(userData);
auto* framework = static_cast<Framework*>(task->mFramework);
framework->mObserver.OnLanguageChanged();
mFramework->SetRegion(mNewRegion);
PostToUiThread(
- [](gpointer userData) -> gboolean {
+ [](gpointer userData) -> gboolean
+ {
auto* task = static_cast<Task*>(userData);
auto* framework = static_cast<Framework*>(task->mFramework);
framework->mObserver.OnRegionChanged();
AppCoreTaskBase::OnRegionChanged(mNewRegion);
}
- void OnDeviceOrientationChanged(AppCoreTaskBase::DeviceOrientationState state) override
- {
- print_log(DLOG_INFO, "DALI", "%s: %s(%d) > OnDeviceOrientationChanged() emitted", __MODULE__, __func__, __LINE__);
- // Note: This isn't emitted to the App.
- AppCoreTaskBase::OnDeviceOrientationChanged(state);
- }
-
private:
GMainContext* GetTizenGlibContext()
{
}
private:
- Framework* mFramework;
- std::string mNewLanguage;
- std::string mNewRegion;
- Dali::DeviceStatus::Battery::Status mNewBatteryStatus;
- Dali::DeviceStatus::Memory::Status mNewMemoryStatus;
+ Framework* mFramework;
+ std::string mNewLanguage;
+ std::string mNewRegion;
+ Dali::DeviceStatus::Battery::Status mNewBatteryStatus;
+ Dali::DeviceStatus::Memory::Status mNewMemoryStatus;
+ Dali::DeviceStatus::Orientation::Status mNewDeviceOrientationStatus;
};
explicit UiAppContext(unsigned int hint, Framework* framework)
}
}
- static void OnDeviceOrientationChanged(app_event_info_h event_info, void* user_data)
- {
- }
-
static void OnRegionFormatChanged(app_event_info_h event_info, void* user_data)
{
auto* context = static_cast<UiAppContext*>(user_data);
observer->OnMemoryLow(result);
}
+ static void OnDeviceOrientationChanged(app_event_info_h event_info, void* user_data)
+ {
+ auto* context = static_cast<UiAppContext*>(user_data);
+ auto* framework = context->mFramework;
+ Observer* observer = &framework->mObserver;
+
+ app_device_orientation_e status;
+ app_event_get_device_orientation(event_info, &status);
+ Dali::DeviceStatus::Orientation::Status result = AppCore::GetOrientationStatus(status);
+ observer->OnDeviceOrientationChanged(result);
+ }
+
void ProcessBundle(Framework* framework, bundle* bundleData)
{
if(bundleData == nullptr)
}
}
- static void AppDeviceRotated(AppCore::AppEventInfoPtr event_info, void* data)
- {
- }
-
static void AppRegionChanged(AppCore::AppEventInfoPtr event, void* data)
{
Framework* framework = static_cast<Framework*>(data);
{
Observer* observer = &static_cast<Framework*>(data)->mObserver;
int status = *static_cast<int*>(event->value);
- Dali::DeviceStatus::Battery::Status result = Dali::DeviceStatus::Battery::NORMAL;
+ Dali::DeviceStatus::Battery::Status result = Dali::DeviceStatus::Battery::Status::NORMAL;
// convert to dali battery status
switch(status)
{
Observer* observer = &static_cast<Framework*>(data)->mObserver;
int status = *static_cast<int*>(event->value);
- Dali::DeviceStatus::Memory::Status result = Dali::DeviceStatus::Memory::NORMAL;
+ Dali::DeviceStatus::Memory::Status result = Dali::DeviceStatus::Memory::Status::NORMAL;
// convert to dali memmory status
switch(status)
observer->OnMemoryLow(result);
}
+ static void AppDeviceOrientationChanged(AppCore::AppEventInfoPtr event, void* data)
+ {
+ Observer* observer = &static_cast<Framework*>(data)->mObserver;
+ int status = *static_cast<int*>(event->value);
+ Dali::DeviceStatus::Orientation::Status result = Dali::DeviceStatus::Orientation::Status::ORIENTATION_0;
+
+ switch(status)
+ {
+ case APP_DEVICE_ORIENTATION_0:
+ {
+ result = Dali::DeviceStatus::Orientation::Status::ORIENTATION_0;
+ break;
+ }
+ case APP_DEVICE_ORIENTATION_90:
+ {
+ result = Dali::DeviceStatus::Orientation::Status::ORIENTATION_90;
+ break;
+ }
+ case APP_DEVICE_ORIENTATION_180:
+ {
+ result = Dali::DeviceStatus::Orientation::Status::ORIENTATION_180;
+ break;
+ }
+ case APP_DEVICE_ORIENTATION_270:
+ {
+ result = Dali::DeviceStatus::Orientation::Status::ORIENTATION_270;
+ break;
+ }
+
+ default:
+ break;
+ }
+ observer->OnDeviceOrientationChanged(result);
+ }
+
int AppNormalMain()
{
if(mUiAppContext.get() == nullptr)
AppCore::AppAddEventHandler(&handlers[AppCore::LOW_BATTERY], AppCore::LOW_BATTERY, AppBatteryLow, mFramework);
AppCore::AppAddEventHandler(&handlers[AppCore::LOW_MEMORY], AppCore::LOW_MEMORY, AppMemoryLow, mFramework);
- AppCore::AppAddEventHandler(&handlers[AppCore::DEVICE_ORIENTATION_CHANGED], AppCore::DEVICE_ORIENTATION_CHANGED, AppDeviceRotated, mFramework);
+ AppCore::AppAddEventHandler(&handlers[AppCore::DEVICE_ORIENTATION_CHANGED], AppCore::DEVICE_ORIENTATION_CHANGED, AppDeviceOrientationChanged, mFramework);
AppCore::AppAddEventHandler(&handlers[AppCore::LANGUAGE_CHANGED], AppCore::LANGUAGE_CHANGED, AppLanguageChanged, mFramework);
AppCore::AppAddEventHandler(&handlers[AppCore::REGION_FORMAT_CHANGED], AppCore::REGION_FORMAT_CHANGED, AppRegionChanged, mFramework);
mKeyboardRepeatSettingsChangedSignal(),
mAuxiliaryMessageSignal(),
mMovedSignal(),
+ mOrientationChangedSignal(),
mLastKeyEvent(),
mLastTouchEvent(),
mIsTransparent(false),
Dali::Window handle(this);
mResizeSignal.Emit(handle, Dali::Window::WindowSize(mWindowWidth, mWindowHeight));
+ mOrientationChangedSignal.Emit(handle, GetCurrentOrientation());
mAdaptor->SurfaceResizeComplete(mSurface.get(), Adaptor::SurfaceSize(mWindowWidth, mWindowHeight));
}
typedef Dali::DevelWindow::AuxiliaryMessageSignalType AuxiliaryMessageSignalType;
typedef Dali::DevelWindow::AccessibilityHighlightSignalType AccessibilityHighlightSignalType;
typedef Dali::DevelWindow::MovedSignalType MovedSignalType;
+ typedef Dali::DevelWindow::OrientationChangedSignalType OrientationChangedSignalType;
typedef Signal<void()> SignalType;
/**
return mMovedSignal;
}
+ /**
+ * @copydoc Dali::DevelWindow::OrientationChangedSignal()
+ */
+ OrientationChangedSignalType& OrientationChangedSignal()
+ {
+ return mOrientationChangedSignal;
+ }
+
private:
WindowRenderSurface* mWindowSurface; ///< The window rendering surface
WindowBase* mWindowBase;
AuxiliaryMessageSignalType mAuxiliaryMessageSignal;
AccessibilityHighlightSignalType mAccessibilityHighlightSignal;
MovedSignalType mMovedSignal;
+ OrientationChangedSignalType mOrientationChangedSignal;
Dali::KeyEvent mLastKeyEvent;
Dali::TouchEvent mLastTouchEvent;
return Internal::Adaptor::GetImplementation(*this).LowMemorySignal();
}
+Application::DeviceOrientationChangedSignalType& Application::DeviceOrientationChangedSignal()
+{
+ return Internal::Adaptor::GetImplementation(*this).DeviceOrientationChangedSignal();
+}
+
Application::AppSignalType& Application::TaskInitSignal()
{
return Internal::Adaptor::GetImplementation(*this).TaskInitSignal();
return Internal::Adaptor::GetImplementation(*this).TaskLowMemorySignal();
}
+Application::DeviceOrientationChangedSignalType& Application::TaskDeviceOrientationChangedSignal()
+{
+ return Internal::Adaptor::GetImplementation(*this).TaskDeviceOrientationChangedSignal();
+}
+
Application::Application(Internal::Adaptor::Application* application)
: BaseHandle(application)
{
class DALI_ADAPTOR_API Application : public BaseHandle
{
public:
- typedef Signal<void(DeviceStatus::Battery::Status)> LowBatterySignalType; ///< Application device signal type @SINCE_1_2.62
- typedef Signal<void(DeviceStatus::Memory::Status)> LowMemorySignalType; ///< Application device signal type @SINCE_1_2.62
- typedef Signal<void(Application&)> AppSignalType; ///< Application lifecycle signal and system signal callback type @SINCE_1_0.0
- typedef Signal<void(Application&, void*)> AppControlSignalType; ///< Application control signal callback type @SINCE_1_0.0
+ typedef Signal<void(DeviceStatus::Battery::Status)> LowBatterySignalType; ///< Application device signal type @SINCE_1_2.62
+ typedef Signal<void(DeviceStatus::Memory::Status)> LowMemorySignalType; ///< Application device signal type @SINCE_1_2.62
+ typedef Signal<void(DeviceStatus::Orientation::Status)> DeviceOrientationChangedSignalType; ///< Application device orientation changed signal type @SINCE_2_2.1
+ typedef Signal<void(Application&)> AppSignalType; ///< Application lifecycle signal and system signal callback type @SINCE_1_0.0
+ typedef Signal<void(Application&, void*)> AppControlSignalType; ///< Application control signal callback type @SINCE_1_0.0
/**
* @brief Enumeration for deciding whether a Dali application window is opaque or transparent.
/**
* @brief The user should connect to this signal to determine when they should initialize
* their application.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
/**
* @brief The user should connect to this signal to determine when they should terminate
* their application.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
/**
* @brief The user should connect to this signal if they need to perform any special
* activities when the application is about to be paused.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
/**
* @brief The user should connect to this signal if they need to perform any special
* activities when the application has resumed.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
/**
* @brief This signal is sent when the system requires the user to reinitialize itself.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
*
* When the application is launched, this signal is emitted after the main loop of the application starts up.
* The passed parameter describes the launch request and contains the information about why the application is launched.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
/**
* @brief This signal is emitted when the language is changed on the device.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
/**
* @brief This signal is emitted when the region of the device is changed.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_0.0
* @return The signal to connect to
/**
* @brief This signal is emitted when the battery level of the device is low.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_2.62
* @return The signal to connect to
/**
* @brief This signal is emitted when the memory level of the device is low.
- * Only when the user uses the UiThread, this signal is emitted on the UI thread.
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
* Otherwise, it is emitted on the main thread.
* @SINCE_1_2.62
* @return The signal to connect to
*/
LowMemorySignalType& LowMemorySignal();
+ /**
+ * @brief This signal is emitted when the device orientation is changed
+ * Only when the user uses the UI thread, this signal is emitted on the UI thread.
+ * Otherwise, it is emitted on the main thread.
+ *
+ * This signal is only used in Application, it is different to Window's orientation signal.
+ * @SINCE_2_2.1
+ * @return The signal to connect to
+ */
+ DeviceOrientationChangedSignalType& DeviceOrientationChangedSignal();
+
// TaskSignal
/**
* @brief The user should connect to this signal to determine when they should initialize
* their application.
- * Only when the user uses the UiThread, this signal is emitted on the main thread.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
* Otherwise, it is not emitted at all.
* @return The signal to connect to
*/
/**
* @brief The user should connect to this signal to determine when they should terminate
* their application.
- * Only when the user uses the UiThread, this signal is emitted on the main thread.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
* Otherwise, it is not emitted at all.
* @return The signal to connect to
*/
*
* When the application is launched, this signal is emitted after the main loop of the application starts up.
* The passed parameter describes the launch request and contains the information about why the application is launched.
- * Only when the user uses the UiThread, this signal is emitted on the main thread.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
* Otherwise, it is not emitted at all.
* @return The signal to connect to
*/
/**
* @brief This signal is emitted when the language is changed on the device.
- * Only when the user uses the UiThread, this signal is emitted on the main thread.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
* Otherwise, it is not emitted at all.
* @return The signal to connect to
*/
/**
* @brief This signal is emitted when the region of the device is changed.
- * Only when the user uses the UiThread, this signal is emitted on the main thread.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
* Otherwise, it is not emitted at all.
* @return The signal to connect to
*/
/**
* @brief This signal is emitted when the battery level of the device is low.
- * Only when the user uses the UiThread, this signal is emitted on the main thread.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
* Otherwise, it is not emitted at all.
* @return The signal to connect to
*/
/**
* @brief This signal is emitted when the memory level of the device is low.
- * Only when the user uses the UiThread, this signal is emitted on the main thread.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
+ * Otherwise, it is not emitted at all.
+ * @return The signal to connect to
+ */
+ LowMemorySignalType& TaskLowMemorySignal();
+
+ /**
+ * @brief This signal is emitted when the device orientation is changed.
+ * Only when the user uses the UI thread, this signal is emitted on the main thread.
* Otherwise, it is not emitted at all.
+ * @SINCE_2_2.1
* @return The signal to connect to
*/
- LowMemorySignalType& TaskLowMemorySignal();
+ DeviceOrientationChangedSignalType& TaskDeviceOrientationChangedSignal();
public: // Not intended for application developers
/// @cond internal
};
};
+/**
+ * @brief Struct for orientation of the device.
+ * @SINCE_2_2.1
+ */
+struct Orientation
+{
+ /**
+ * @brief Enumeration for orientation status.
+ * @SINCE_2_2.1
+ */
+ enum Status
+ {
+ ORIENTATION_0 = 0, ///< The device is oriented in a natural position @SINCE_2_2.1
+ ORIENTATION_90 = 90, ///< The device's left side is at the top @SINCE_2_2.1
+ ORIENTATION_180 = 180, ///< The device is upside down @SINCE_2_2.1
+ ORIENTATION_270 = 270 ///< The device's right side is at the top @SINCE_2_2.1
+ };
+};
+
} // namespace DeviceStatus
/**
projects / platform / core / uifw / dali-adaptor.git / commitdiff