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);
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;
{
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;
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);
/**
* 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:
*/
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:
/**
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;
// INTERNAL INCLUDES
#include <abort-handler.h>
+#include <device-status.h>
namespace Dali
{
class Framework
{
public:
+
enum Type
{
NORMAL, ///< normal appFramework
/**
* 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:
*/
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
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 );
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)
{
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/signals/callback.h>
-
// INTERNAL INCLUDES
#include "application-configuration.h"
+#include "device-status.h"
#include "window.h"
namespace Dali
{
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
*/
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
* @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.
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
--- /dev/null
+#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__
// Application / UI Framework adaption
#include <dali/public-api/adaptor-framework/application.h>
+#include <dali/public-api/adaptor-framework/device-status.h>
#include <dali/public-api/adaptor-framework/input-method.h>
#include <dali/public-api/adaptor-framework/key.h>
#include <dali/public-api/adaptor-framework/timer.h>
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 \
#include <Ecore.h>
#include <system_info.h>
+#include <system_settings.h>
#include <app_control_internal.h>
#include <bundle_internal.h>
#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()
}
}
+ 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];
static void AppLanguageChanged(app_event_info_h event, void *data)
{
Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
observer->OnLanguageChanged();
}
static void AppRegionChanged(app_event_info_h event, void *data)
{
Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
observer->OnRegionChanged();
}
static void AppBatteryLow(app_event_info_h event, void *data)
{
Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
- observer->OnBatteryLow();
+ observer->OnBatteryLow(Dali::DeviceStatus::Battery::NORMAL);
}
static void AppMemoryLow(app_event_info_h event, void *data)
{
Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
- observer->OnMemoryLow();
+ observer->OnMemoryLow(Dali::DeviceStatus::Memory::NORMAL);
}
private:
}
}
+std::string Framework::GetLanguage() const
+{
+ return mImpl->GetLanguage();
+}
+
+std::string Framework::GetRegion() const
+{
+ return mImpl->GetRegion();
+}
+
} // namespace Adaptor
} // namespace Internal
#include <Ecore.h>
#include <system_info.h>
+#include <system_settings.h>
#include <bundle_internal.h>
// CONDITIONAL INCLUDES
#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()
}
}
+ 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];
static void AppLanguageChanged(AppCore::AppEventInfoPtr event, void *data)
{
- Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
+ Framework* framework = static_cast<Framework*>(data);
+ Observer *observer = &framework->mObserver;
+ framework->SetLanguage( std::string( static_cast<const char *>(event->value) ) );
observer->OnLanguageChanged();
}
static void AppRegionChanged(AppCore::AppEventInfoPtr event, void *data)
{
- Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
+ Framework* framework = static_cast<Framework*>(data);
+ Observer *observer = &framework->mObserver;
+ framework->SetRegion( std::string( static_cast<const char *>(event->value) ) );
observer->OnRegionChanged();
}
static void AppBatteryLow(AppCore::AppEventInfoPtr event, void *data)
{
Observer *observer = &static_cast<Framework*>(data)->mObserver;
+ int status = *static_cast<int *>(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<Framework*>(data)->mObserver;
+ int status = *static_cast<int *>(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);
}
observer->OnAmbientChanged(ambient);
}
- static void WatchAppLanguageChanged(app_event_info_h event, void *data)
- {
- Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
- observer->OnLanguageChanged();
- }
-
- static void WatchAppRegionChanged(app_event_info_h event, void *data)
- {
- Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
- observer->OnRegionChanged();
- }
-
- static void WatchAppBatteryLow(app_event_info_h event, void *data)
- {
- Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
- observer->OnBatteryLow();
- }
-
- static void WatchAppMemoryLow(app_event_info_h event, void *data)
- {
- Observer *observer = &static_cast<Framework*>(data)->mObserver;
-
- observer->OnMemoryLow();
- }
-
static void WatchAppControl(app_control_h app_control, void *data)
{
Framework* framework = static_cast<Framework*>(data);
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
#endif
}
-
private:
// Undefined
Impl( const Impl& impl );
}
}
+void Framework::SetLanguage( const std::string& language )
+{
+ mImpl->SetLanguage( language );
+}
+
+void Framework::SetRegion( const std::string& region ) const
+{
+ mImpl->SetRegion( region );
+}
+
+std::string Framework::GetLanguage() const
+{
+ return mImpl->GetLanguage();
+}
+
+std::string Framework::GetRegion()
+{
+ return mImpl->GetRegion();
+}
+
} // namespace Adaptor
} // namespace Internal
Impl(void* data)
: mAbortCallBack( NULL ),
- mCallbackManager( CallbackManager::New() )
+ mCallbackManager( CallbackManager::New() ),
+ mLanguage( "NOT_SUPPORTED" ),
+ mRegion( "NOT_SUPPORTED" )
{
}
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
/**
XInitThreads();
}
+std::string Framework::GetLanguage() const
+{
+ return mImpl->GetLanguage();
+}
+
+std::string Framework::GetRegion() const
+{
+ return mImpl->GetRegion();
+}
+
} // namespace Adaptor
} // namespace Internal
} // unnamed namespace
+void LowBatterySignalCallback( Dali::DeviceStatus::Battery::Status status )
+{
+}
+
+void LowMemorySignalCallback( Dali::DeviceStatus::Memory::Status status )
+{
+}
+
int UtcDaliApplicationNew01(void)
{
Application application = Application::New();
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();
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;
+}