%define tizen_feature_ham_support 0
%else
# I586
-%define tizen_feature_ham_support 0
+%define tizen_feature_ham_support 1
%endif
%define tizen_feature_location_batch 0
%define tizen_feature_key_manager_support 0
%define tizen_feature_media_key_support 1
%else
# I586
-%define tizen_feature_media_key_support 1
+%define tizen_feature_media_key_support 0
%endif
%define tizen_feature_message_port_support 1
%define tizen_feature_messaging_support 1
%define tizen_feature_notification_support 1
%define tizen_feature_package_support 1
%define tizen_feature_power_support 1
-%define tizen_feature_push_support 0
+%define tizen_feature_push_support 1
%ifarch %{arm}
# ARM
%define tizen_feature_se_support 1
# Badge API is mandatory in Tizen Wearable Profile.
%define tizen_feature_badge_support 1
-%define tizen_feature_bluetooth_support 0
+%define tizen_feature_bluetooth_support 1
# Bookmark API is optional in Tizen Wearable Profile.
%define tizen_feature_bookmark_support 0
%define tizen_feature_exif_support 1
%define tizen_feature_filesystem_support 1
%define tizen_feature_fm_radio_support 0
-%define tizen_feature_ham_support 0
+%define tizen_feature_ham_support 1
%define tizen_feature_location_batch 0
-%define tizen_feature_media_controller_support 0
+%define tizen_feature_media_controller_support 1
# MediayKey API is optional in Tizen Wearable Profile.
# tizen.org/feature/network.bluetooth.audio.media is required for MediayKey API
%ifarch %{arm}
# ARM
-%define tizen_feature_media_key_support 0
+%define tizen_feature_media_key_support 1
%else
# I586
%define tizen_feature_media_key_support 0
%define tizen_feature_nfc_emulation_support 0
%define tizen_feature_nfc_support 0
%endif
-%define tizen_feature_notification_support 0
-%define tizen_feature_package_support 0
-%define tizen_feature_power_support 0
-%define tizen_feature_push_support 0
+%define tizen_feature_notification_support 1
+%define tizen_feature_package_support 1
+%define tizen_feature_power_support 1
+%define tizen_feature_push_support 1
%if 0%{?model_build_feature_smartcard }
%define tizen_feature_se_support 1
%else
%define tizen_feature_application_support 1
%define tizen_feature_archive_support 1
%define tizen_feature_badge_support 0
-%define tizen_feature_bluetooth_support 1
-%define tizen_feature_bookmark_support 1
+%define tizen_feature_bluetooth_support 0
+%define tizen_feature_bookmark_support 0
%define tizen_feature_calendar_support 0
%define tizen_feature_callhistory_support 0
%define tizen_feature_contact_support 0
%define tizen_feature_nfc_support 0
%define tizen_feature_notification_support 0
%define tizen_feature_package_support 1
-%define tizen_feature_power_support 1
+%define tizen_feature_power_support 0
%define tizen_feature_push_support 0
%define tizen_feature_se_support 0
%define tizen_feature_sensor_support 0
%if 0%{?tizen_feature_bookmark_support}
BuildRequires: pkgconfig(capi-web-bookmark)
-#BuildRequires: pkgconfig(bookmark-adaptor)
+BuildRequires: pkgconfig(bookmark-adaptor)
%endif
%if 0%{?tizen_feature_datacontrol_support}
%if 0%{?tizen_feature_power_support}
BuildRequires: pkgconfig(deviced)
+%endif
+
+%if 0%{?tizen_feature_power_support}
BuildRequires: pkgconfig(capi-appfw-application)
%endif
%if 0%{?tizen_feature_push_support}
BuildRequires: pkgconfig(push)
-BuildRequires: pkgconfig(libcapi-network-connection)
%endif
%if 0%{?tizen_feature_key_manager_support}
%endif
%if 0%{?tizen_feature_message_port_support}
-BuildRequires: pkgconfig(message-port)
+BuildRequires: pkgconfig(capi-message-port)
%endif
%if 0%{?tizen_feature_notification_support}
BuildRequires: pkgconfig(notification)
-BuildRequires: pkgconfig(capi-appfw-app-control)
%endif
%if 0%{?tizen_feature_sound_support}
#include <app_info.h>
#include <app_manager.h>
-//#include <app_manager_extension.h>
+#include <app_manager_extension.h>
#include <aul.h>
#include <package_manager.h>
#include <pkgmgr-info.h>
LoggerD("Kill async, KILL!!!!!!!!!");
// terminate application
- // TODO(r.galka) temporarily removed - not supported by platform
- //ret = app_manager_terminate_app(app_context);
- //
- //if (APP_MANAGER_ERROR_NONE != ret) {
- // LoggerE("Failed to terminate application.");
- // result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to terminate application.");
- // CHECK_RESULT(result, response, handler)
- //}
+ ret = app_manager_terminate_app(app_context);
+
+ if (APP_MANAGER_ERROR_NONE != ret) {
+ LoggerE("Failed to terminate application.");
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to terminate application.");
+ CHECK_RESULT(result, response, handler)
+ }
LoggerD("Kill async, end, waiting for notification");
};
}
g_application_list_changed_broker.AddApplicationInstance(&instance_);
-/* pkgmgr_client_listen_status(pkgmgr_client_handle_,
+ /* TODO - causes build break on Tizen 3.0
+ pkgmgr_client_listen_status(pkgmgr_client_handle_,
ApplicationListChangedBroker::ClientStatusListener,
&g_application_list_changed_broker);*/
} else {
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
+
#include "requested_application_control.h"
#include <app_manager.h>
int ret = bt_gatt_client_read_value(handle, read_value, (void*)user_data);
if (BT_ERROR_NONE != ret) {
LOGE("Couldn't register callback for read value");
- delete user_data;
}
ReportSuccess(out);
}
le_device->insert(
std::make_pair(kDeviceName, picojson::value(std::string(device_name))));
- free(device_name);
+ g_free(device_name);
int power_level = 0;
found = false;
}
switch (type) {
case DATA_CONTROL_SQL_COLUMN_TYPE_INT64: {
- long long int data = 0;
+ int64_t data = 0;
result = data_control_sql_get_int64_data(cursor, columnIndex, &data);
if (result != DATA_CONTROL_ERROR_NONE) break;
val = picojson::value(static_cast<double>(data));
}
static void SQLInsertResponseCallback(int requestId, data_control_h handle,
- long long int inserted_row_id,
+ int64_t inserted_row_id,
bool providerResult,
const char *error, void *user_data) {
LoggerD("Enter");
instance->ReportError(NotFoundException(
"Download ID does not exist in download service module"), out);
break;
- // TODO(p.kaczmarek3) temporarily removed - not supported by platform
- //case DOWNLOAD_ERROR_INVALID_NETWORK_TYPE:
- // instance->ReportError(InvalidValuesException(
- // "Network bonding is set but network type is not set as ALL"), out);
- // break;
+ case DOWNLOAD_ERROR_INVALID_NETWORK_TYPE:
+ instance->ReportError(InvalidValuesException(
+ "Network bonding is set but network type is not set as ALL"), out);
+ break;
case DOWNLOAD_ERROR_NO_DATA:
instance->ReportError(NotFoundException(
"No data because the set API is not called"), out);
'variables': {
'packages': [
'vconf',
- 'message-port',
+ 'capi-message-port',
'dlog'
]
},
#define MESSAGEPORT_MESSAGEPORT_INSTANCE_H_
#include <bundle.h>
+#include <bundle_internal.h>
#include <message_port.h>
#include "common/extension.h"
int ret = nfc_tag_transceive(m_last_tag_handle, buffer,
data_array.size(), tagTransceiveCb, (void*) callback_id_pointer);
- delete[] buffer;
- buffer = nullptr;
if (NFC_ERROR_NONE != ret) {
delete callback_id_pointer;
callback_id_pointer = nullptr;
+ delete[] buffer;
+ buffer = nullptr;
// for permission related error throw exception
if(NFC_ERROR_SECURITY_RESTRICTED == ret ||
'variables': {
'packages': [
'notification',
- 'capi-appfw-app-control',
'capi-system-device',
]
},
PlatformResult NotificationManager::RemoveAll() {
LoggerD("Enter");
- int ret = notification_delete_all_by_type(NULL, NOTIFICATION_TYPE_NOTI);
+ int ret = notification_delete_all(NOTIFICATION_TYPE_NOTI);
if (ret != NOTIFICATION_ERROR_NONE) {
LoggerE("Notification remove all failed: %d", ret);
return PlatformResult(ErrorCode::UNKNOWN_ERR,
"Notification noti remove all failed");
}
- ret = notification_delete_all_by_type(NULL, NOTIFICATION_TYPE_ONGOING);
+ ret = notification_delete_all(NOTIFICATION_TYPE_ONGOING);
if (ret != NOTIFICATION_ERROR_NONE) {
LoggerE("Notification remove all failed: %d", ret);
return PlatformResult(ErrorCode::UNKNOWN_ERR,
LoggerE("type is not DISPLAY_STATE");
return;
}
- display_state_e state = static_cast<display_state_e>(*static_cast<int*>(value));
+ display_state_e state = static_cast<display_state_e>(reinterpret_cast<int>(value));
PowerState current = POWER_STATE_SCREEN_OFF;
switch (state) {
case DISPLAY_STATE_NORMAL :
'push',
'capi-appfw-application',
'libpcrecpp',
- 'libcapi-network-connection'
]
},
}],
#include <memory>
#include <mutex>
-#include <runtime_info.h>
+#include <system_settings.h>
#include <system_info.h>
#include <sys/statfs.h>
static void OnDeviceAutoRotationChangedCb(keynode_t* node, void* event_ptr);
static void OnDeviceOrientationChangedCb(sensor_t sensor, unsigned int event_type,
sensor_data_t *data, void *user_data);
-static void OnLocaleChangedCb(runtime_info_key_e key, void* event_ptr);
+static void OnLocaleChangedCb(system_settings_key_e key, void* event_ptr);
static void OnNetworkChangedCb(connection_type_e type, void* event_ptr);
static void OnNetworkValueChangedCb(const char* ipv4_address,
const char* ipv6_address, void* event_ptr);
void OnDeviceAutoRotationChangedCallback(keynode_t* node, void* event_ptr);
void OnDeviceOrientationChangedCallback(sensor_t sensor, unsigned int event_type,
sensor_data_t *data, void *user_data);
- void OnLocaleChangedCallback(runtime_info_key_e key, void* event_ptr);
+ void OnLocaleChangedCallback(system_settings_key_e key, void* event_ptr);
void OnNetworkChangedCallback(connection_type_e type, void* event_ptr);
void OnNetworkValueCallback(const char* ipv4_address,
const char* ipv6_address, void* event_ptr);
SysteminfoInstance& instance)
{
if (nullptr == m_locale_listener) {
- if (RUNTIME_INFO_ERROR_NONE !=
- runtime_info_set_changed_cb(RUNTIME_INFO_KEY_REGION,
+ if (SYSTEM_SETTINGS_ERROR_NONE !=
+ system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY,
OnLocaleChangedCb, static_cast<void*>(&instance)) ) {
LoggerE("Country change callback registration failed");
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Country change callback registration failed");
}
- if (RUNTIME_INFO_ERROR_NONE !=
- runtime_info_set_changed_cb(RUNTIME_INFO_KEY_LANGUAGE,
+ if (SYSTEM_SETTINGS_ERROR_NONE !=
+ system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE,
OnLocaleChangedCb, static_cast<void*>(&instance)) ) {
LoggerE("Language change callback registration failed");
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Language change callback registration failed");
PlatformResult SystemInfoListeners::UnregisterLocaleListener()
{
if (nullptr != m_locale_listener) {
- if (RUNTIME_INFO_ERROR_NONE !=
- runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_LANGUAGE) ) {
+ if (SYSTEM_SETTINGS_ERROR_NONE !=
+ system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE) ) {
LoggerE("Unregistration of language change callback failed");
}
- if (RUNTIME_INFO_ERROR_NONE !=
- runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_REGION) ) {
+ if (SYSTEM_SETTINGS_ERROR_NONE !=
+ system_settings_unset_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY) ) {
LoggerE("Unregistration of country change callback failed");
}
LoggerD("Removed callback for LOCALE");
CHECK_LISTENER_ERROR(RegisterVconfCallback(VCONFKEY_SYSMAN_HDMI,
OnPeripheralChangedCb, instance))
}
+
LoggerD("Added callback for PERIPHERAL");
m_peripheral_listener = callback;
}
}
}
-void SystemInfoListeners::OnLocaleChangedCallback(runtime_info_key_e /*key*/, void* event_ptr)
+void SystemInfoListeners::OnLocaleChangedCallback(system_settings_key_e /*key*/, void* event_ptr)
{
if (nullptr != m_locale_listener) {
SysteminfoInstance* instance = static_cast<SysteminfoInstance*>(event_ptr);
system_info_listeners.OnDeviceOrientationChangedCallback(sensor, event_type, data, user_data);
}
-void OnLocaleChangedCb(runtime_info_key_e key, void* event_ptr)
+void OnLocaleChangedCb(system_settings_key_e key, void* event_ptr)
{
LoggerD("");
system_info_listeners.OnLocaleChangedCallback(key, event_ptr);
return PlatformResult(ErrorCode::NO_ERROR);
}
-static PlatformResult GetRuntimeInfoString(runtime_info_key_e key, std::string& platform_string) {
+static PlatformResult GetRuntimeInfoString(system_settings_key_e key, std::string& platform_string) {
char* platform_c_string;
- int err = runtime_info_get_value_string(key, &platform_c_string);
- if (RUNTIME_INFO_ERROR_NONE == err) {
+ int err = system_settings_get_value_string(key, &platform_c_string);
+ if (SYSTEM_SETTINGS_ERROR_NONE == err) {
if (nullptr != platform_c_string) {
platform_string = platform_c_string;
free(platform_c_string);
PlatformResult SysteminfoUtils::ReportLocale(picojson::object& out) {
std::string str_language = "";
- PlatformResult ret = GetRuntimeInfoString(RUNTIME_INFO_KEY_LANGUAGE, str_language);
+ PlatformResult ret = GetRuntimeInfoString(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, str_language);
if (ret.IsError()) {
return ret;
}
std::string str_country = "";
- ret = GetRuntimeInfoString(RUNTIME_INFO_KEY_REGION, str_country);
+ ret = GetRuntimeInfoString(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY, str_country);
if (ret.IsError()) {
return ret;
}