From: minho.sun Date: Fri, 8 Sep 2017 07:02:29 +0000 (+0900) Subject: [4.0] Enhance application device signal X-Git-Tag: accepted/tizen/4.0/unified/20171017.212913~1^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;ds=sidebyside;h=07258d253749adf0fc003cdf7329b46d86591cba;p=platform%2Fcore%2Fuifw%2Fdali-adaptor.git [4.0] Enhance application device signal Currently, DALi developer cannot get any information about device events like LanguageChangedSignal. To make user can use these kind of signals fully, 1) Add Language / Region information getter api. - api : GetLanguage() / GetRegion() 2) Add new signal type and new signal for Battery / Memory status. - signal type : LowBatterySignalType / LowMemorySignalType - signal : LowBatterySignal / LowMemorySignalType - enum : BatteryStatus / MemoryStatus Change-Id: Iaf10578871fb6283dcc18dd75402d9e605c171a4 --- diff --git a/adaptors/common/application-impl.cpp b/adaptors/common/application-impl.cpp index 0798462..d7bf4f1 100644 --- a/adaptors/common/application-impl.cpp +++ b/adaptors/common/application-impl.cpp @@ -345,18 +345,21 @@ void Application::OnRegionChanged() mRegionChangedSignal.Emit( application ); } -void Application::OnBatteryLow() +void Application::OnBatteryLow( Dali::DeviceStatus::Battery::Status status ) { Dali::Application application(this); mBatteryLowSignal.Emit( application ); + + mLowBatterySignal.Emit( status ); } -void Application::OnMemoryLow() +void Application::OnMemoryLow( Dali::DeviceStatus::Memory::Status status ) { Dali::Application application(this); mMemoryLowSignal.Emit( application ); -} + mLowMemorySignal.Emit( status ); +} void Application::OnResize(Dali::Adaptor& adaptor) { Dali::Application application(this); @@ -368,6 +371,16 @@ bool Application::AddIdle( CallbackBase* callback ) return mAdaptor->AddIdle( callback ); } +std::string Application::GetRegion() const +{ + return mFramework->GetRegion(); +} + +std::string Application::GetLanguage() const +{ + return mFramework->GetLanguage(); +} + Dali::Adaptor& Application::GetAdaptor() { return *mAdaptor; diff --git a/adaptors/common/application-impl.h b/adaptors/common/application-impl.h index 621facc..8f6e4f8 100644 --- a/adaptors/common/application-impl.h +++ b/adaptors/common/application-impl.h @@ -71,6 +71,8 @@ class Application : public BaseObject, public Framework::Observer { 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; @@ -125,6 +127,16 @@ public: Dali::Window GetWindow(); /** + * @copydoc Dali::Application::GetRegion(); + */ + std::string GetRegion() const; + + /** + * @copydoc Dali::Application::GetLanguage(); + */ + std::string GetLanguage() const; + + /** * @copydoc Dali::Application::ReplaceWindow(); */ void ReplaceWindow( const PositionSize& positionSize, const std::string& name); @@ -241,12 +253,12 @@ public: // From Framework::Observer /** * Called when the framework informs the application that the battery level of the device is low. */ - virtual void OnBatteryLow(); + virtual void OnBatteryLow( Dali::DeviceStatus::Battery::Status status ); /** * Called when the framework informs the application that the memory level of the device is low. */ - virtual void OnMemoryLow(); + virtual void OnMemoryLow( Dali::DeviceStatus::Memory::Status status ); public: @@ -320,6 +332,16 @@ public: // Signals */ Dali::Application::AppSignalType& MemoryLowSignal() { return mMemoryLowSignal; } + /** + * @copydoc Dali::Application::LowBatterySignal() + */ + Dali::Application::LowBatterySignalType& LowBatterySignal() { return mLowBatterySignal; } + + /** + * @copydoc Dali::Application:::LowMemorySignal() + */ + Dali::Application::LowMemorySignalType& LowMemorySignal() { return mLowMemorySignal; } + protected: /** @@ -360,17 +382,19 @@ protected: private: - AppSignalType mInitSignal; - AppSignalType mTerminateSignal; - AppSignalType mPauseSignal; - AppSignalType mResumeSignal; - AppSignalType mResetSignal; - AppSignalType mResizeSignal; - AppControlSignalType mAppControlSignal; - AppSignalType mLanguageChangedSignal; - AppSignalType mRegionChangedSignal; - AppSignalType mBatteryLowSignal; - AppSignalType mMemoryLowSignal; + AppSignalType mInitSignal; + AppSignalType mTerminateSignal; + AppSignalType mPauseSignal; + AppSignalType mResumeSignal; + AppSignalType mResetSignal; + AppSignalType mResizeSignal; + AppControlSignalType mAppControlSignal; + AppSignalType mLanguageChangedSignal; + AppSignalType mRegionChangedSignal; + AppSignalType mBatteryLowSignal; + AppSignalType mMemoryLowSignal; + LowBatterySignalType mLowBatterySignal; + LowMemorySignalType mLowMemorySignal; EventLoop* mEventLoop; Framework* mFramework; diff --git a/adaptors/common/framework.h b/adaptors/common/framework.h index 6037d57..6b5965a 100644 --- a/adaptors/common/framework.h +++ b/adaptors/common/framework.h @@ -27,6 +27,7 @@ // INTERNAL INCLUDES #include +#include namespace Dali { @@ -48,6 +49,7 @@ namespace Adaptor class Framework { public: + enum Type { NORMAL, ///< normal appFramework @@ -122,12 +124,12 @@ public: /** * Invoked when the battery level of the device is low. */ - virtual void OnBatteryLow() {} + virtual void OnBatteryLow( Dali::DeviceStatus::Battery::Status status ) {} /** * Invoked when the memory level of the device is low. */ - virtual void OnMemoryLow() {} + virtual void OnMemoryLow( Dali::DeviceStatus::Memory::Status status ) {} }; public: @@ -187,6 +189,26 @@ public: */ static std::string GetResourcePath(); + /** + * Sets system language. + */ + void SetLanguage( const std::string& language ); + + /** + * Sets system region. + */ + void SetRegion( const std::string& region ); + + /** + * Gets system language. + */ + std::string GetLanguage() const; + + /** + * Gets system region. + */ + std::string GetRegion() const; + private: // Undefined diff --git a/adaptors/public-api/adaptor-framework/application.cpp b/adaptors/public-api/adaptor-framework/application.cpp index 6959651..1db99e3 100644 --- a/adaptors/public-api/adaptor-framework/application.cpp +++ b/adaptors/public-api/adaptor-framework/application.cpp @@ -182,6 +182,16 @@ std::string Application::GetResourcePath() return Internal::Adaptor::Application::GetResourcePath(); } +std::string Application::GetRegion() const +{ + return Internal::Adaptor::GetImplementation(*this).GetRegion(); +} + +std::string Application::GetLanguage() const +{ + return Internal::Adaptor::GetImplementation(*this).GetLanguage(); +} + void Application::SetViewMode( ViewMode viewMode ) { Internal::Adaptor::GetImplementation(*this).SetViewMode( viewMode ); @@ -251,14 +261,26 @@ Application::AppSignalType& Application::RegionChangedSignal() Application::AppSignalType& Application::BatteryLowSignal() { + DALI_LOG_WARNING_NOFN( "DEPRECATION WARNING: BatteryLowSignal() is deprecated and will be removed from next release. Use Application::LowBatterySignal() instead.\n" ); return Internal::Adaptor::GetImplementation(*this).BatteryLowSignal(); } Application::AppSignalType& Application::MemoryLowSignal() { + DALI_LOG_WARNING_NOFN( "DEPRECATION WARNING: MemoryLowSignal() is deprecated and will be removed from next release. Use Application::LowMemorySignal() instead.\n" ); return Internal::Adaptor::GetImplementation(*this).MemoryLowSignal(); } +Application::LowBatterySignalType& Application::LowBatterySignal() +{ + return Internal::Adaptor::GetImplementation(*this).LowBatterySignal(); +} + +Application::LowMemorySignalType& Application::LowMemorySignal() +{ + return Internal::Adaptor::GetImplementation(*this).LowMemorySignal(); +} + Application::Application(Internal::Adaptor::Application* application) : BaseHandle(application) { diff --git a/adaptors/public-api/adaptor-framework/application.h b/adaptors/public-api/adaptor-framework/application.h index a2754e1..483963d 100644 --- a/adaptors/public-api/adaptor-framework/application.h +++ b/adaptors/public-api/adaptor-framework/application.h @@ -24,9 +24,9 @@ #include #include - // INTERNAL INCLUDES #include "application-configuration.h" +#include "device-status.h" #include "window.h" namespace Dali @@ -108,6 +108,8 @@ class DALI_IMPORT_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 @@ -300,6 +302,21 @@ public: */ static std::string GetResourcePath(); + /** + * @brief This is used to get region information from device. + * + * @SINCE_1_2.62 + * @return Region information + */ + std::string GetRegion() const; + + /** + * @brief This is used to get language information from device. + * + * @SINCE_1_2.62 + * @return Language information + */ + std::string GetLanguage() const; public: // Stereoscopy @@ -382,7 +399,7 @@ public: // Signals * @SINCE_1_0.0 * @return The signal to connect to */ - AppSignalType& ResizeSignal(); + AppSignalType& ResizeSignal() DALI_DEPRECATED_API; /** * @brief This signal is emitted when another application sends a launch request to the application. @@ -409,18 +426,34 @@ public: // Signals AppSignalType& RegionChangedSignal(); /** + * @DEPRECATED_1_2.62 Use LowBatterySignal() instead. * @brief This signal is emitted when the battery level of the device is low. * @SINCE_1_0.0 * @return The signal to connect to */ - AppSignalType& BatteryLowSignal(); + AppSignalType& BatteryLowSignal() DALI_DEPRECATED_API; /** + * @DEPRECATED_1_2.62 Use LowMemorySignal() instead. * @brief This signal is emitted when the memory level of the device is low. * @SINCE_1_0.0 * @return The signal to connect to */ - AppSignalType& MemoryLowSignal(); + AppSignalType& MemoryLowSignal() DALI_DEPRECATED_API; + + /** + * @brief This signal is emitted when the battery level of the device is low. + * @SINCE_1_2.62 + * @return The signal to connect to + */ + LowBatterySignalType& LowBatterySignal(); + + /** + * @brief This signal is emitted when the memory level of the device is low. + * @SINCE_1_2.62 + * @return The signal to connect to + */ + LowMemorySignalType& LowMemorySignal(); public: // Not intended for application developers /// @cond internal diff --git a/adaptors/public-api/adaptor-framework/device-status.h b/adaptors/public-api/adaptor-framework/device-status.h new file mode 100644 index 0000000..47d499f --- /dev/null +++ b/adaptors/public-api/adaptor-framework/device-status.h @@ -0,0 +1,73 @@ +#ifndef __DALI_DEVICE_STATUS_H__ +#define __DALI_DEVICE_STATUS_H__ + +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +namespace Dali +{ +/** + * @addtogroup dali_adaptor_framework + * @{ + */ + +namespace DeviceStatus +{ +/** + * @brief Struct for battery of the device. + * @SINCE_1_2.62 + */ +struct Battery +{ + /** + * @brief Enumeration for battery status. + * @SINCE_1_2.62 + */ + enum Status + { + NORMAL, ///< Battery is over 5% @SINCE_1_2.62 + CRITICALLY_LOW, ///< Battery is under 5% @SINCE_1_2.62 + POWER_OFF ///< Battery is under 1% @SINCE_1_2.62 + }; +}; + +/** + * @brief Struct for memory of the device. + * @SINCE_1_2.62 + */ +struct Memory +{ + /** + * @brief Enumeration for memory status. + * @SINCE_1_2.62 + */ + enum Status + { + NORMAL, ///< Normal Status @SINCE_1_2.62 + LOW, ///< Memory is low but not critical @SINCE_1_2.62 + CRITICALLY_LOW ///< Memory is critically low @SINCE_1_2.62 + }; +}; + +}// namespace DeviceStatus + +/** + * @} + */ +} // namespace Dali + +#endif // __DALI_DEVICE_STATUS_H__ diff --git a/adaptors/public-api/dali.h b/adaptors/public-api/dali.h index 240215e..8a37838 100644 --- a/adaptors/public-api/dali.h +++ b/adaptors/public-api/dali.h @@ -22,6 +22,7 @@ // Application / UI Framework adaption #include +#include #include #include #include diff --git a/adaptors/public-api/file.list b/adaptors/public-api/file.list index dbf643f..4df586a 100644 --- a/adaptors/public-api/file.list +++ b/adaptors/public-api/file.list @@ -15,6 +15,7 @@ public_api_header_files = \ public_api_adaptor_framework_header_files = \ $(adaptor_public_api_dir)/adaptor-framework/application.h \ $(adaptor_public_api_dir)/adaptor-framework/application-configuration.h \ + $(adaptor_public_api_dir)/adaptor-framework/device-status.h \ $(adaptor_public_api_dir)/adaptor-framework/input-method.h \ $(adaptor_public_api_dir)/adaptor-framework/key.h \ $(adaptor_public_api_dir)/adaptor-framework/style-change.h \ diff --git a/adaptors/tizen/framework-tizen-3.cpp b/adaptors/tizen/framework-tizen-3.cpp index aeb25c5..1e5a8e8 100644 --- a/adaptors/tizen/framework-tizen-3.cpp +++ b/adaptors/tizen/framework-tizen-3.cpp @@ -24,6 +24,7 @@ #include #include +#include #include #include @@ -84,6 +85,13 @@ struct Framework::Impl #endif mApplicationType = type; mCallbackManager = CallbackManager::New(); + + char* region; + char* language; + system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, ®ion ); + system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &language ); + mRegion = std::string( region ); + mLanguage = std::string( language ); } ~Impl() @@ -123,11 +131,22 @@ struct Framework::Impl } } + std::string GetLanguage() const + { + return mLanguage; + } + + std::string GetRegion() const + { + return mRegion; + } // Data Type mApplicationType; CallbackBase* mAbortCallBack; CallbackManager *mCallbackManager; + std::string mLanguage; + std::string mRegion; Framework* mFramework; app_event_handler_h handlers[5]; @@ -291,7 +310,6 @@ struct Framework::Impl static void AppLanguageChanged(app_event_info_h event, void *data) { Observer *observer = &static_cast(data)->mObserver; - observer->OnLanguageChanged(); } @@ -302,22 +320,19 @@ struct Framework::Impl static void AppRegionChanged(app_event_info_h event, void *data) { Observer *observer = &static_cast(data)->mObserver; - observer->OnRegionChanged(); } static void AppBatteryLow(app_event_info_h event, void *data) { Observer *observer = &static_cast(data)->mObserver; - - observer->OnBatteryLow(); + observer->OnBatteryLow(Dali::DeviceStatus::Battery::NORMAL); } static void AppMemoryLow(app_event_info_h event, void *data) { Observer *observer = &static_cast(data)->mObserver; - - observer->OnMemoryLow(); + observer->OnMemoryLow(Dali::DeviceStatus::Memory::NORMAL); } private: @@ -459,6 +474,16 @@ void Framework::AbortCallback( ) } } +std::string Framework::GetLanguage() const +{ + return mImpl->GetLanguage(); +} + +std::string Framework::GetRegion() const +{ + return mImpl->GetRegion(); +} + } // namespace Adaptor } // namespace Internal diff --git a/adaptors/tizen/framework-tizen.cpp b/adaptors/tizen/framework-tizen.cpp index 4fcba81..addc5a7 100644 --- a/adaptors/tizen/framework-tizen.cpp +++ b/adaptors/tizen/framework-tizen.cpp @@ -26,6 +26,7 @@ #include #include +#include #include // CONDITIONAL INCLUDES @@ -168,6 +169,13 @@ struct Framework::Impl #endif mApplicationType = type; mCallbackManager = CallbackManager::New(); + + char* region; + char* language; + system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, ®ion ); + system_settings_get_value_string( SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &language ); + mRegion = std::string( region ); + mLanguage = std::string( language ); } ~Impl() @@ -207,11 +215,32 @@ struct Framework::Impl } } + void SetLanguage( const std::string& language ) + { + mLanguage = language; + } + + void SetRegion( const std::string& region ) + { + mRegion = region; + } + + std::string GetLanguage() const + { + return mLanguage; + } + + std::string GetRegion() const + { + return mRegion; + } // Data Type mApplicationType; CallbackBase* mAbortCallBack; CallbackManager *mCallbackManager; + std::string mLanguage; + std::string mRegion; Framework* mFramework; AppCore::AppEventHandlerPtr handlers[5]; @@ -350,8 +379,9 @@ struct Framework::Impl static void AppLanguageChanged(AppCore::AppEventInfoPtr event, void *data) { - Observer *observer = &static_cast(data)->mObserver; - + Framework* framework = static_cast(data); + Observer *observer = &framework->mObserver; + framework->SetLanguage( std::string( static_cast(event->value) ) ); observer->OnLanguageChanged(); } @@ -361,23 +391,65 @@ struct Framework::Impl static void AppRegionChanged(AppCore::AppEventInfoPtr event, void *data) { - Observer *observer = &static_cast(data)->mObserver; - + Framework* framework = static_cast(data); + Observer *observer = &framework->mObserver; + framework->SetRegion( std::string( static_cast(event->value) ) ); observer->OnRegionChanged(); } static void AppBatteryLow(AppCore::AppEventInfoPtr event, void *data) { Observer *observer = &static_cast(data)->mObserver; + int status = *static_cast(event->value); + Dali::DeviceStatus::Battery::Status result = Dali::DeviceStatus::Battery::NORMAL; - observer->OnBatteryLow(); + // convert to dali battery status + switch( status ) + { + case 1: + { + result = Dali::DeviceStatus::Battery::POWER_OFF; + break; + } + case 2: + { + result = Dali::DeviceStatus::Battery::CRITICALLY_LOW; + break; + } + default : + break; + } + observer->OnBatteryLow(result); } static void AppMemoryLow(AppCore::AppEventInfoPtr event, void *data) { Observer *observer = &static_cast(data)->mObserver; + int status = *static_cast(event->value); + Dali::DeviceStatus::Memory::Status result = Dali::DeviceStatus::Memory::NORMAL; - observer->OnMemoryLow(); + // convert to dali memmory status + switch( status ) + { + case 1: + { + result = Dali::DeviceStatus::Memory::NORMAL; + break; + } + case 2: + { + result = Dali::DeviceStatus::Memory::LOW; + break; + } + case 4: + { + result = Dali::DeviceStatus::Memory::CRITICALLY_LOW; + break; + } + default : + break; + } + observer->OnMemoryLow(result); } @@ -452,34 +524,6 @@ struct Framework::Impl observer->OnAmbientChanged(ambient); } - static void WatchAppLanguageChanged(app_event_info_h event, void *data) - { - Observer *observer = &static_cast(data)->mObserver; - - observer->OnLanguageChanged(); - } - - static void WatchAppRegionChanged(app_event_info_h event, void *data) - { - Observer *observer = &static_cast(data)->mObserver; - - observer->OnRegionChanged(); - } - - static void WatchAppBatteryLow(app_event_info_h event, void *data) - { - Observer *observer = &static_cast(data)->mObserver; - - observer->OnBatteryLow(); - } - - static void WatchAppMemoryLow(app_event_info_h event, void *data) - { - Observer *observer = &static_cast(data)->mObserver; - - observer->OnMemoryLow(); - } - static void WatchAppControl(app_control_h app_control, void *data) { Framework* framework = static_cast(data); @@ -530,10 +574,10 @@ struct Framework::Impl mWatchCallback.ambient_tick = WatchAppAmbientTick; mWatchCallback.ambient_changed = WatchAppAmbientChanged; - watch_app_add_event_handler(&watchHandlers[APP_EVENT_LOW_BATTERY], APP_EVENT_LOW_BATTERY, WatchAppBatteryLow, mFramework); - watch_app_add_event_handler(&watchHandlers[APP_EVENT_LOW_MEMORY], APP_EVENT_LOW_MEMORY, WatchAppMemoryLow, mFramework); - watch_app_add_event_handler(&watchHandlers[APP_EVENT_LANGUAGE_CHANGED], APP_EVENT_LANGUAGE_CHANGED, WatchAppLanguageChanged, mFramework); - watch_app_add_event_handler(&watchHandlers[APP_EVENT_REGION_FORMAT_CHANGED], APP_EVENT_REGION_FORMAT_CHANGED, WatchAppRegionChanged, mFramework); + 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::LANGUAGE_CHANGED], AppCore::LANGUAGE_CHANGED, AppLanguageChanged, mFramework); + AppCore::AppAddEventHandler(&handlers[AppCore::REGION_FORMAT_CHANGED], AppCore::REGION_FORMAT_CHANGED, AppRegionChanged, mFramework); ret = watch_app_main(*mFramework->mArgc, *mFramework->mArgv, &mWatchCallback, mFramework); #endif @@ -547,7 +591,6 @@ struct Framework::Impl #endif } - private: // Undefined Impl( const Impl& impl ); @@ -687,6 +730,26 @@ void Framework::AbortCallback( ) } } +void Framework::SetLanguage( const std::string& language ) +{ + mImpl->SetLanguage( language ); +} + +void Framework::SetRegion( const std::string& region ) +{ + mImpl->SetRegion( region ); +} + +std::string Framework::GetLanguage() const +{ + return mImpl->GetLanguage(); +} + +std::string Framework::GetRegion() const +{ + return mImpl->GetRegion(); +} + } // namespace Adaptor } // namespace Internal diff --git a/adaptors/ubuntu/framework-ubuntu.cpp b/adaptors/ubuntu/framework-ubuntu.cpp index 22203cc..5fce3b6 100644 --- a/adaptors/ubuntu/framework-ubuntu.cpp +++ b/adaptors/ubuntu/framework-ubuntu.cpp @@ -62,7 +62,9 @@ struct Framework::Impl Impl(void* data) : mAbortCallBack( NULL ), - mCallbackManager( CallbackManager::New() ) + mCallbackManager( CallbackManager::New() ), + mLanguage( "NOT_SUPPORTED" ), + mRegion( "NOT_SUPPORTED" ) { } @@ -76,10 +78,22 @@ struct Framework::Impl delete mCallbackManager; } - // Data + std::string GetLanguage() const + { + return mLanguage; + } + std::string GetRegion() const + { + return mRegion; + } + + // Data CallbackBase* mAbortCallBack; CallbackManager *mCallbackManager; + std::string mLanguage; + std::string mRegion; + // Static methods /** @@ -270,6 +284,16 @@ void Framework::InitThreads() XInitThreads(); } +std::string Framework::GetLanguage() const +{ + return mImpl->GetLanguage(); +} + +std::string Framework::GetRegion() const +{ + return mImpl->GetRegion(); +} + } // namespace Adaptor } // namespace Internal diff --git a/automated-tests/src/dali-adaptor/utc-Dali-Application.cpp b/automated-tests/src/dali-adaptor/utc-Dali-Application.cpp index 829997d..a237f50 100644 --- a/automated-tests/src/dali-adaptor/utc-Dali-Application.cpp +++ b/automated-tests/src/dali-adaptor/utc-Dali-Application.cpp @@ -67,6 +67,14 @@ void ApplicationControlSignalCallback(Application&, void *) } // unnamed namespace +void LowBatterySignalCallback( Dali::DeviceStatus::Battery::Status status ) +{ +} + +void LowMemorySignalCallback( Dali::DeviceStatus::Memory::Status status ) +{ +} + int UtcDaliApplicationNew01(void) { Application application = Application::New(); @@ -611,6 +619,58 @@ int UtcDaliApplicationMemoryLowSignalN(void) END_TEST; } +int UtcDaliApplicationLowBatterySignalP(void) +{ + Application application = Application::New(); + application.LowBatterySignal().Connect( &LowBatterySignalCallback ); + DALI_TEST_CHECK( application ); + + END_TEST; +} + +int UtcDaliApplicationLowBatterySignalN(void) +{ + Application application; + + try + { + application.LowBatterySignal().Connect( &LowBatterySignalCallback ); + DALI_TEST_CHECK( false ); // Should not get here + } + catch( ... ) + { + DALI_TEST_CHECK( true ); + } + + END_TEST; +} + +int UtcDaliApplicationLowMemorySignalP(void) +{ + Application application = Application::New(); + application.LowMemorySignal().Connect( &LowMemorySignalCallback ); + DALI_TEST_CHECK( application ); + + END_TEST; +} + +int UtcDaliApplicationLowMemorySignalN(void) +{ + Application application; + + try + { + application.LowMemorySignal().Connect( &LowMemorySignalCallback ); + DALI_TEST_CHECK( false ); // Should not get here + } + catch( ... ) + { + DALI_TEST_CHECK( true ); + } + + END_TEST; +} + int UtcDaliApplicationGetResourcePathP(void) { Application application = Application::New(); @@ -621,3 +681,22 @@ int UtcDaliApplicationGetResourcePathP(void) END_TEST; } +int UtcDaliApplicationGetRegionP(void) +{ + Application application = Application::New(); + std::string result; + result = application.GetRegion(); + DALI_TEST_CHECK( result == "NOT_SUPPORTED" ); // Not supported in UBUNTU + + END_TEST; +} + +int UtcDaliApplicationGetLanguageP(void) +{ + Application application = Application::New(); + std::string result; + result = application.GetLanguage(); + DALI_TEST_CHECK( result == "NOT_SUPPORTED" ); // Not supported in UBUNTU + + END_TEST; +}