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
#define __DALI_INTERNAL_GL_IMPLEMENTATION_H__
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * 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.
void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
{
#if DALI_GLES_VERSION >= 30
- // if OpenGL ES 2.0 compatibility is need this can be implemented with
- // glDiscardFramebufferEXT
glInvalidateFramebuffer(target,numAttachments,attachments);
+#else
+ mGlExtensions.DiscardFrameBuffer(target, numAttachments, attachments);
#endif // DALI_GLES_VERSION >= 30
}
}
}
+bool VideoPlayer::IsVideoTextureSupported() const
+{
+ if( mPlugin != NULL )
+ {
+ return mPlugin->IsVideoTextureSupported();
+ }
+
+ return false;
+}
+
} // namespace Adaptor;
} // namespace Internal;
} // namespace Dali;
*/
void Backward( int millisecond );
+ /**
+ * @brief Dali::VideoPlayer::IsVideoTextureSupported()
+ */
+ bool IsVideoTextureSupported() const;
+
private:
/**
#define __DALI_INTERNAL_VIRTUAL_KEYBOARD_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * 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.
/**
* @copydox Dali::VirtualKeyboard::ResizedSignal()
*/
-Dali::VirtualKeyboard::VoidSignalType& ResizedSignal();
+Dali::VirtualKeyboard::KeyboardResizedSignalType& ResizedSignal();
/**
* @copydox Dali::VirtualKeyboard::LanguageChangedSignal()
*/
-Dali::VirtualKeyboard::VoidSignalType& LanguageChangedSignal();
+Dali::VirtualKeyboard::LanguageChangedSignalType& LanguageChangedSignal();
/**
* @copydoc Dali::VirtualKeyboard::GetTextDirection
*
* @return The maximum texture size
*/
-unsigned int GetMaxTextureSize();
+DALI_IMPORT_API unsigned int GetMaxTextureSize();
} // Dali
return Internal::Adaptor::ImfManager::GetImplementation(*this).StatusChangedSignal();
}
-ImfManager::VoidSignalType& ImfManager::ResizedSignal()
+ImfManager::KeyboardResizedSignalType& ImfManager::ResizedSignal()
{
return Internal::Adaptor::ImfManager::GetImplementation(*this).ResizedSignal();
}
-ImfManager::VoidSignalType& ImfManager::LanguageChangedSignal()
+ImfManager::LanguageChangedSignalType& ImfManager::LanguageChangedSignal()
{
return Internal::Adaptor::ImfManager::GetImplementation(*this).LanguageChangedSignal();
}
typedef Signal< void (ImfManager&) > ImfManagerSignalType; ///< Keyboard actived signal
typedef Signal< ImfCallbackData ( ImfManager&, const ImfEventData& ) > ImfEventSignalType; ///< keyboard events
typedef Signal< void () > VoidSignalType;
- typedef Signal< void (bool) > StatusSignalType;
- typedef Signal< void (KeyboardType) > KeyboardTypeSignalType; ///< keyboard type
+ typedef Signal< void ( bool ) > StatusSignalType;
+ typedef Signal< void ( KeyboardType ) > KeyboardTypeSignalType; ///< keyboard type
+ typedef Signal< void ( int ) > KeyboardResizedSignalType; ///< Keyboard resized signal
+ typedef Signal< void ( int ) > LanguageChangedSignalType; ///< Language changed signal
public:
*
* A callback of the following type may be connected:
* @code
- * void YourCallbackName();
+ * void YourCallbackName( int resolvedResize );
* @endcode
+ * The parameter sends the resolved resize defined by the IMF.
+ *
* User can get changed size by using GetInputMethodArea() in the callback
* @return The signal to connect to.
*/
- VoidSignalType& ResizedSignal();
+ KeyboardResizedSignalType& ResizedSignal();
/**
* @brief Connect to this signal to be notified when the virtual keyboard's language is changed.
*
* A callback of the following type may be connected:
* @code
- * void YourCallbackName();
+ * void YourCallbackName( int resolvedLanguage );
* @endcode
+ * The parameter sends the resolved language defined by the IMF.
+ *
* User can get the text direction of the language by calling GetTextDirection() in the callback.
* @return The signal to connect to.
*/
- VoidSignalType& LanguageChangedSignal();
+ LanguageChangedSignalType& LanguageChangedSignal();
/**
* @brief Connect to this signal to be notified when the keyboard type is changed.
*/
virtual void Backward( int millisecond ) = 0;
+ /**
+ * @brief Checks whether the video texture is supported
+ * @return True if supported, otherwise false.
+ */
+ virtual bool IsVideoTextureSupported() const = 0;
+
};
} // namespace Dali;
GetImplementation( *this ).Backward( millisecond );
}
+bool VideoPlayer::IsVideoTextureSupported() const
+{
+ return GetImplementation( *this ).IsVideoTextureSupported();
+}
+
} // namespace Dali;
*/
void Backward( int millisecond );
+ /**
+ * @brief Checks whether the video texture is supported
+ * @return True if supported, otherwise false.
+ */
+ bool IsVideoTextureSupported() const;
+
private: // Not intended for application developers
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * 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.
return Internal::Adaptor::VirtualKeyboard::StatusChangedSignal();
}
-VoidSignalType& ResizedSignal()
+KeyboardResizedSignalType& ResizedSignal()
{
return Internal::Adaptor::VirtualKeyboard::ResizedSignal();
}
-VoidSignalType& LanguageChangedSignal()
+LanguageChangedSignalType& LanguageChangedSignal()
{
return Internal::Adaptor::VirtualKeyboard::LanguageChangedSignal();
}
#define __DALI_VIRTUAL_KEYBOARD_H__
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * 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.
// Types
typedef Signal< void () > VoidSignalType;
-typedef Signal< void (bool) > StatusSignalType;
+typedef Signal< void ( bool ) > StatusSignalType;
+typedef Signal< void ( int ) > KeyboardResizedSignalType;
+typedef Signal< void ( int ) > LanguageChangedSignalType;
// Enumerations
*
* A callback of the following type may be connected:
* @code
- * void YourCallbackName();
+ * void YourCallbackName( int resolvedResize );
* @endcode
+ * The parameter sends the resolved resize defined by the IMF.
+ *
* User can get changed size by using GetSizeAndPosition() in the callback
* @return The signal to connect to.
*/
-DALI_IMPORT_API VoidSignalType& ResizedSignal();
+DALI_IMPORT_API KeyboardResizedSignalType& ResizedSignal();
/**
* @brief Connect to this signal to be notified when the virtual keyboard's language is changed.
*
* A callback of the following type may be connected:
* @code
- * void YourCallbackName();
+ * void YourCallbackName( int resolvedLanguage );
* @endcode
+ * The parameter sends the resolved language defined by the IMF.
+ *
* User can get the text direction of the language by calling GetTextDirection() in the callback.
* @return The signal to connect to.
*/
-DALI_IMPORT_API VoidSignalType& LanguageChangedSignal();
+DALI_IMPORT_API LanguageChangedSignalType& LanguageChangedSignal();
} // namespace VirtualKeyboard
return imfManager.StatusChangedSignal();
}
-Dali::VirtualKeyboard::VoidSignalType& ResizedSignal()
+Dali::VirtualKeyboard::KeyboardResizedSignalType& ResizedSignal()
{
DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: ResizedSignal() is deprecated and will be removed from next release. Use ImfManager.ResizedSignal() instead.\n" );
return imfManager.ResizedSignal();
}
-Dali::VirtualKeyboard::VoidSignalType& LanguageChangedSignal()
+Dali::VirtualKeyboard::LanguageChangedSignalType& LanguageChangedSignal()
{
DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: LanguageChangedSignal() is deprecated and will be removed from next release. Use ImfManager.LanguageChangedSignal() instead.\n" );
}
ImfManager* imfManager = reinterpret_cast< ImfManager* > ( data );
// Emit the signal that the language has changed
- imfManager->LanguageChangedSignal().Emit();
+ imfManager->LanguageChangedSignal().Emit( value );
}
void InputPanelGeometryChangedCallback ( void *data, Ecore_IMF_Context *context, int value )
}
ImfManager* imfManager = reinterpret_cast< ImfManager* > ( data );
// Emit signal that the keyboard is resized
- imfManager->ResizedSignal().Emit();
+ imfManager->ResizedSignal().Emit( value );
}
void InputPanelKeyboardTypeChangedCallback( void *data, Ecore_IMF_Context *context, int value )
typedef Dali::ImfManager::StatusSignalType ImfStatusSignalType;
typedef Dali::ImfManager::VoidSignalType ImfVoidSignalType;
typedef Dali::ImfManager::KeyboardTypeSignalType ImfKeyboardTypeSignalType;
+ typedef Dali::ImfManager::KeyboardResizedSignalType KeyboardResizedSignalType;
+ typedef Dali::ImfManager::LanguageChangedSignalType LanguageChangedSignalType;
public:
/**
* @copydoc Dali::ImfManager::ResizedSignal()
*/
- ImfVoidSignalType& ResizedSignal() { return mKeyboardResizeSignal; }
+ KeyboardResizedSignalType& ResizedSignal() { return mKeyboardResizeSignal; }
/**
* @copydoc Dali::ImfManager::LanguageChangedSignal()
*/
- ImfVoidSignalType& LanguageChangedSignal() { return mKeyboardLanguageChangedSignal; }
+ LanguageChangedSignalType& LanguageChangedSignal() { return mKeyboardLanguageChangedSignal; }
/**
* @copydoc Dali::ImfManager::KeyboardTypeChangedSignal()
ImfManagerSignalType mActivatedSignal;
ImfEventSignalType mEventSignal;
ImfStatusSignalType mKeyboardStatusSignal;
- ImfVoidSignalType mKeyboardResizeSignal;
- ImfVoidSignalType mKeyboardLanguageChangedSignal;
+ KeyboardResizedSignalType mKeyboardResizeSignal;
+ LanguageChangedSignalType mKeyboardLanguageChangedSignal;
ImfKeyboardTypeSignalType mKeyboardTypeChangedSignal;
public:
typedef Dali::ImfManager::StatusSignalType ImfStatusSignalType;
typedef Dali::ImfManager::VoidSignalType ImfVoidSignalType;
typedef Dali::ImfManager::KeyboardTypeSignalType ImfKeyboardTypeSignalType;
+ typedef Dali::ImfManager::KeyboardResizedSignalType KeyboardResizedSignalType;
+ typedef Dali::ImfManager::LanguageChangedSignalType LanguageChangedSignalType;
public:
/**
* @copydoc Dali::ImfManager::ResizedSignal()
*/
- ImfVoidSignalType& ResizedSignal() { return mKeyboardResizeSignal; }
+ KeyboardResizedSignalType& ResizedSignal() { return mKeyboardResizeSignal; }
/**
* @copydoc Dali::ImfManager::LanguageChangedSignal()
*/
- ImfVoidSignalType& LanguageChangedSignal() { return mKeyboardLanguageChangedSignal; }
+ LanguageChangedSignalType& LanguageChangedSignal() { return mKeyboardLanguageChangedSignal; }
/**
* @copydoc Dali::ImfManager::KeyboardTypeChangedSignal()
ImfManagerSignalType mActivatedSignal;
ImfEventSignalType mEventSignal;
ImfStatusSignalType mKeyboardStatusSignal;
- ImfVoidSignalType mKeyboardResizeSignal;
- ImfVoidSignalType mKeyboardLanguageChangedSignal;
+ KeyboardResizedSignalType mKeyboardResizeSignal;
+ LanguageChangedSignalType mKeyboardLanguageChangedSignal;
ImfKeyboardTypeSignalType mKeyboardTypeChangedSignal;
public:
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 )
+{
+ mImpl->SetRegion( region );
+}
+
+std::string Framework::GetLanguage() const
+{
+ return mImpl->GetLanguage();
+}
+
+std::string Framework::GetRegion() const
+{
+ 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
typedef Dali::ImfManager::StatusSignalType ImfStatusSignalType;
typedef Dali::ImfManager::VoidSignalType ImfVoidSignalType;
typedef Dali::ImfManager::KeyboardTypeSignalType ImfKeyboardTypeSignalType;
+ typedef Dali::ImfManager::KeyboardResizedSignalType KeyboardResizedSignalType;
+ typedef Dali::ImfManager::LanguageChangedSignalType LanguageChangedSignalType;
public:
/**
* @copydoc Dali::ImfManager::ResizedSignal()
*/
- ImfVoidSignalType& ResizedSignal() { return mKeyboardResizeSignal; }
+ KeyboardResizedSignalType& ResizedSignal() { return mKeyboardResizeSignal; }
/**
* @copydoc Dali::ImfManager::LanguageChangedSignal()
*/
- ImfVoidSignalType& LanguageChangedSignal() { return mKeyboardLanguageChangedSignal; }
+ LanguageChangedSignalType& LanguageChangedSignal() { return mKeyboardLanguageChangedSignal; }
/**
* @copydoc Dali::ImfManager::KeyboardTypeChangedSignal()
ImfManagerSignalType mActivatedSignal;
ImfEventSignalType mEventSignal;
ImfStatusSignalType mKeyboardStatusSignal;
- ImfVoidSignalType mKeyboardResizeSignal;
- ImfVoidSignalType mKeyboardLanguageChangedSignal;
+ KeyboardResizedSignalType mKeyboardResizeSignal;
+ LanguageChangedSignalType mKeyboardLanguageChangedSignal;
ImfKeyboardTypeSignalType mKeyboardTypeChangedSignal;
// Undefined
} // 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;
+}