SET(DBUS_INTERFACE "org.tizen.${PROJECT_NAME}.manager")
ENDIF(NOT DEFINED DBUS_INTERFACE)
-ADD_SUBDIRECTORY(common)
ADD_SUBDIRECTORY(server)
ADD_SUBDIRECTORY(lib)
ADD_SUBDIRECTORY(tool)
INSTALL(FILES ${CMAKE_SOURCE_DIR}/alarmmgr_log_dump.sh DESTINATION ${TZ_SYS_ETC}/dump.d/module.d/)
ENDIF(_APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG)
-IF(BUILD_GTESTS)
- ADD_SUBDIRECTORY(unittest)
-ENDIF(BUILD_GTESTS)
+#IF(BUILD_GTESTS)
+# ADD_SUBDIRECTORY(unittest)
+#ENDIF(BUILD_GTESTS)
+++ /dev/null
-SET(ALARM_DBUS "alarm-mgr")
-STRING(REPLACE ".alarm.manager" "." INTERFACE_PREFIX ${DBUS_INTERFACE})
-
-FIND_PROGRAM(GDBUS_CODEGEN NAMES gdbus-codegen)
-
-ADD_CUSTOM_COMMAND(
- OUTPUT dbus
- COMMAND ${GDBUS_CODEGEN} --generate-c-code ${ALARM_DBUS}-stub
- --interface-prefix ${INTERFACE_PREFIX}
- ${ALARM_DBUS}.xml
- DEPENDS ${ALARM_DBUS}.xml
- COMMENT "Generating Server GDBus .c/.h")
-
-ADD_CUSTOM_TARGET(GENERATED_DBUS_CODE DEPENDS dbus)
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8" ?>
-<node name="/org/tizen/alarm/manager">
- <interface name="org.tizen.alarm.manager">
- <method name="alarm_create_periodic">
- <arg type="s" name="app_service_name" direction="in" />
- <arg type="s" name="app_service_name_mod" direction="in" />
- <arg type="i" name="interval" direction="in" />
- <arg type="i" name="is_ref" direction="in" />
- <arg type="i" name="method" direction="in" />
- <arg type="i" name="alarm_id" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_create">
- <arg type="s" name="app_service_name" direction="in" />
- <arg type="s" name="app_service_name_mod" direction="in" />
- <arg type="i" name="alarm_info_start_year" direction="in" />
- <arg type="i" name="alarm_info_start_month" direction="in" />
- <arg type="i" name="alarm_info_start_day" direction="in" />
- <arg type="i" name="alarm_info_start_hour" direction="in" />
- <arg type="i" name="alarm_info_start_min" direction="in" />
- <arg type="i" name="alarm_info_start_sec" direction="in" />
- <arg type="i" name="alarm_info_msec" direction="in" />
- <arg type="i" name="alarm_info_end_year" direction="in" />
- <arg type="i" name="alarm_info_end_month" direction="in" />
- <arg type="i" name="alarm_info_end_day" direction="in" />
- <arg type="i" name="alarm_info_mode_day_of_week" direction="in" />
- <arg type="i" name="alarm_info_mode_repeat" direction="in" />
- <arg type="i" name="alarm_info_alarm_type" direction="in" />
- <arg type="i" name="alarm_info_reserved_info" direction="in" />
- <arg type="s" name="alarm_info_reserved_service_name" direction="in" />
- <arg type="s" name="alarm_info_reserved_service_name_mod" direction="in" />
- <arg type="i" name="alarm_id" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_create_appsvc">
- <arg type="i" name="alarm_info_start_year" direction="in" />
- <arg type="i" name="alarm_info_start_month" direction="in" />
- <arg type="i" name="alarm_info_start_day" direction="in" />
- <arg type="i" name="alarm_info_start_hour" direction="in" />
- <arg type="i" name="alarm_info_start_min" direction="in" />
- <arg type="i" name="alarm_info_start_sec" direction="in" />
- <arg type="i" name="alarm_info_end_year" direction="in" />
- <arg type="i" name="alarm_info_end_month" direction="in" />
- <arg type="i" name="alarm_info_end_day" direction="in" />
- <arg type="i" name="alarm_info_mode_day_of_week" direction="in" />
- <arg type="i" name="alarm_info_mode_interval" direction="in" />
- <arg type="i" name="alarm_info_mode_repeat" direction="in" />
- <arg type="i" name="alarm_info_alarm_type" direction="in" />
- <arg type="i" name="alarm_info_reserved_info" direction="in" />
- <arg type="s" name="alarm_info_bundle_data" direction="in" />
- <arg type="i" name="alarm_id" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_create_noti">
- <arg type="i" name="alarm_info_start_year" direction="in" />
- <arg type="i" name="alarm_info_start_month" direction="in" />
- <arg type="i" name="alarm_info_start_day" direction="in" />
- <arg type="i" name="alarm_info_start_hour" direction="in" />
- <arg type="i" name="alarm_info_start_min" direction="in" />
- <arg type="i" name="alarm_info_start_sec" direction="in" />
- <arg type="i" name="alarm_info_end_year" direction="in" />
- <arg type="i" name="alarm_info_end_month" direction="in" />
- <arg type="i" name="alarm_info_end_day" direction="in" />
- <arg type="i" name="alarm_info_mode_day_of_week" direction="in" />
- <arg type="i" name="alarm_info_mode_interval" direction="in" />
- <arg type="i" name="alarm_info_mode_repeat" direction="in" />
- <arg type="i" name="alarm_info_alarm_type" direction="in" />
- <arg type="i" name="alarm_info_reserved_info" direction="in" />
- <arg type="s" name="alarm_info_noti_data" direction="in" />
- <arg type="i" name="alarm_id" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_delete">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="i" name="alarm_info_return_code" direction="out" />
- </method>
- <method name="alarm_delete_all">
- <arg type="i" name="alarm_info_return_code" direction="out" />
- </method>
- <method name="alarm_update">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="i" name="alarm_info_start_year" direction="in" />
- <arg type="i" name="alarm_info_start_month" direction="in" />
- <arg type="i" name="alarm_info_start_day" direction="in" />
- <arg type="i" name="alarm_info_start_hour" direction="in" />
- <arg type="i" name="alarm_info_start_min" direction="in" />
- <arg type="i" name="alarm_info_start_sec" direction="in" />
- <arg type="i" name="alarm_info_end_year" direction="in" />
- <arg type="i" name="alarm_info_end_month" direction="in" />
- <arg type="i" name="alarm_info_end_day" direction="in" />
- <arg type="i" name="alarm_info_mode_day_of_week" direction="in" />
- <arg type="i" name="alarm_info_mode_repeat" direction="in" />
- <arg type="i" name="alarm_info_alarm_type" direction="in" />
- <arg type="i" name="alarm_info_reserved_info" direction="in" />
- <arg type="i" name="update_flag" direction="in" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_number_of_ids">
- <arg type="i" name="number_of_ids" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_list_of_ids">
- <arg type="i" name="max_number_of_ids" direction="in" />
- <arg type="ai" name="alarm_id" direction="out" />
- <arg type="i" name="number_of_ids" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_appsvc_info">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="s" name="b_data" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_noti_info">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="s" name="noti_data" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_info">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="i" name="alarm_info_start_year" direction="out" />
- <arg type="i" name="alarm_info_start_month" direction="out" />
- <arg type="i" name="alarm_info_start_day" direction="out" />
- <arg type="i" name="alarm_info_start_hour" direction="out" />
- <arg type="i" name="alarm_info_start_min" direction="out" />
- <arg type="i" name="alarm_info_start_sec" direction="out" />
- <arg type="i" name="alarm_info_end_year" direction="out" />
- <arg type="i" name="alarm_info_end_month" direction="out" />
- <arg type="i" name="alarm_info_end_day" direction="out" />
- <arg type="i" name="alarm_info_mode_day_of_week" direction="out" />
- <arg type="i" name="alarm_info_mode_repeat" direction="out" />
- <arg type="i" name="alarm_info_alarm_type" direction="out" />
- <arg type="i" name="alarm_info_reserved_info" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_set_rtc_time">
- <arg type="i" name="alarm_info_year" direction="in" />
- <arg type="i" name="alarm_info_month" direction="in" />
- <arg type="i" name="alarm_info_day" direction="in" />
- <arg type="i" name="alarm_info_hour" direction="in" />
- <arg type="i" name="alarm_info_min" direction="in" />
- <arg type="i" name="alarm_info_sec" direction="in" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_next_duetime">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="i" name="duetime" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_all_info">
- <arg type="s" name="db_path" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_set_time">
- <arg type="i" name="time" direction="in" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_set_time_with_propagation_delay">
- <arg type="u" name="new_sec" direction="in" />
- <arg type="u" name="new_nsec" direction="in" />
- <arg type="u" name="req_sec" direction="in" />
- <arg type="u" name="req_nsec" direction="in" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_set_timezone">
- <arg type="s" name="tzpath_str" direction="in" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_set_global">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="b" name="global" direction="in" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <method name="alarm_get_global">
- <arg type="i" name="alarm_id" direction="in" />
- <arg type="b" name="global" direction="out" />
- <arg type="i" name="return_code" direction="out" />
- </method>
- <signal name="alarm_expired">
- <arg type="i" name="alarm_id" />
- <arg type="s" name="app_service_name" />
- </signal>
- </interface>
-</node>
*/
#pragma once
-#define MAX_SNOOZE_CNT 5
-#define REPEAT_MODE_ONCE 0x80
-
-#define SIG_TIMER 0x32
-#define ALARM_INFO_MAX 100
-
#ifdef __cplusplus
extern "C" {
#endif
#include "alarm.h"
-#define INIT_ALARM_LIST_SIZE 64
-#define INIT_SCHEDULED_ALARM_LIST_SIZE 32
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "ALARM_MANAGER"
+
#define MAX_BUNDLE_NAME_LEN 2048
#define MAX_SERVICE_NAME_LEN 256
#define MAX_PKG_NAME_LEN MAX_SERVICE_NAME_LEN-8
#define REGULAR_UID_MIN 5000
#define MAX_APP_ID 256
-#define SYSTEM_TIME_CHANGED "setting_time_changed"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "ALARM_MANAGER"
-
typedef struct {
GDBusConnection *connection;
GDBusConnection *session_conn;
bool _send_alarm_delete(alarm_context_t context, alarm_id_t alarm_id, int *error_code);
bool _send_alarm_delete_all(alarm_context_t context, int *error_code);
bool _send_alarm_get_list_of_ids(alarm_context_t context, int maxnum_of_ids,
- alarm_id_t *alarm_id, int *num_of_ids, int *error_code);
+ GVariantIter **iter, int *num_of_ids, int *error_code);
bool _send_alarm_get_number_of_ids(alarm_context_t context, int *num_of_ids, int *error_code);
bool _send_alarm_get_info(alarm_context_t context, alarm_id_t alarm_id, alarm_info_t *alarm_info, int *error_code);
bool _send_alarm_get_next_duetime(alarm_context_t context, alarm_id_t alarm_id, time_t* duetime, int *error_code);
void _alarm_initialize();
time_t _get_periodic_alarm_standard_time(void);
+bool _can_skip_expired_cb(alarm_id_t alarm_id);
+
+int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
+int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
+int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
+int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id);
+int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid);
+int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid);
+int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid);
+int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, int *num_of_ids);
+int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid, pid_t pid, GVariant **alarm_array, int *num_of_alarm);
+int alarm_manager_alarm_get_appsvc_info(GVariant *parameters, uid_t uid, gchar **b_data);
+int alarm_manager_alarm_get_noti_info(GVariant *parameters, uid_t uid, gchar **noti_data);
+int alarm_manager_alarm_get_info(GVariant *parameters, uid_t uid, alarm_info_t *alarm_info);
+int alarm_manager_alarm_get_next_duetime(GVariant *parameters, uid_t uid, int *duetime);
+int alarm_manager_alarm_get_all_info(uid_t uid, char **db_path);
+int alarm_manager_alarm_set_rtc_time(GVariant *parameters);
+int alarm_manager_alarm_set_time(GVariant* parameters);
+int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters);
+int alarm_manager_alarm_set_timezone(GVariant* parameters);
+int alarm_manager_alarm_set_global(GVariant *parameters, uid_t uid);
+int alarm_manager_alarm_get_global(GVariant *parameters, gboolean *global);
#define ALARM_MGR_LOG_PRINT(FMT, ARG...) LOGD(FMT, ##ARG)
#define ALARM_MGR_EXCEPTION_PRINT(FMT, ARG...) LOGW(FMT, ##ARG)
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/server)
AUX_SOURCE_DIRECTORY(./ LIB_SRCS)
-SET(LIB_SRCS ${LIB_SRCS} ${CMAKE_SOURCE_DIR}/common/alarm-mgr-stub.c)
-SET_SOURCE_FILES_PROPERTIES(${CMAKE_SOURCE_DIR}/common/alarm-mgr-stub.c
- PROPERTIES GENERATED TRUE)
PKG_CHECK_MODULES(lib_pkgs REQUIRED glib-2.0 gobject-2.0 dlog bundle appsvc gio-2.0
gio-unix-2.0 libtzplatform-config notification cert-svc-vcore)
LINK_DIRECTORIES(${lib_pkgs_LIBRARY_DIRS})
ADD_LIBRARY(${LIBRARY} SHARED ${LIB_SRCS})
-ADD_DEPENDENCIES(${LIBRARY} GENERATED_DBUS_CODE)
TARGET_LINK_LIBRARIES(${LIBRARY} ${lib_pkgs_LDFLAGS})
SET_TARGET_PROPERTIES(${LIBRARY} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${EXECUTABLE_OUTPUT_PATH}")
SET_TARGET_PROPERTIES(${LIBRARY} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <string.h>
+#include <glib.h>
+#include <notification.h>
+#include <notification_ipc.h>
+
+#include "alarm.h"
+#include "alarm-internal.h"
+
+bool _send_alarm_create_noti(alarm_context_t context, alarm_info_t *alarm_info,
+ alarm_id_t *alarm_id, notification_h noti, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *noti_gv = NULL;
+ char *noti_data;
+ guchar *data;
+ int datalen = 0;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ noti_gv = notification_ipc_make_gvariant_from_noti(noti, true);
+ if (!noti_gv) {
+ if (error_code)
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ return false;
+ }
+
+ datalen = g_variant_get_size(noti_gv);
+ if (datalen < 0)
+ return false;
+
+ data = malloc(datalen);
+ if (!data)
+ return false;
+
+ g_variant_store(noti_gv, data);
+ noti_data = g_base64_encode((guchar *)data, datalen);
+
+ param = g_variant_new("(iiiiiiiiiiiiiis)",
+ alarm_info->start.year,
+ alarm_info->start.month,
+ alarm_info->start.day,
+ alarm_info->start.hour,
+ alarm_info->start.min,
+ alarm_info->start.sec,
+ alarm_info->end.year,
+ alarm_info->end.month,
+ alarm_info->end.day,
+ alarm_info->mode.u_interval.day_of_week,
+ alarm_info->mode.u_interval.interval,
+ alarm_info->mode.repeat,
+ alarm_info->alarm_type,
+ alarm_info->reserved_info,
+ (char *)noti_data);
+
+ if (noti_data)
+ free(noti_data);
+ if (data)
+ free(data);
+ g_variant_unref(noti_gv);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_create_noti", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed. alarm_id[%d],\
+ return_code[%d].error->message is %s(%d)", *(int *)alarm_id,
+ return_code, error->message, error->code);
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(ii)", alarm_id, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_create_noti() success. alarm_id[%d], return_code[%d].",
+ *alarm_id, return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_create_appsvc(alarm_context_t context, alarm_info_t *alarm_info,
+ alarm_id_t *alarm_id, bundle *b, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ bundle_raw *b_data = NULL;
+ int datalen = 0;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ if (bundle_encode(b, &b_data, &datalen)) {
+ ALARM_MGR_EXCEPTION_PRINT("Unable to encode the bundle data\n");
+ if (error_code)
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ return false;
+ }
+
+ param = g_variant_new("(iiiiiiiiiiiiiis)",
+ alarm_info->start.year,
+ alarm_info->start.month,
+ alarm_info->start.day,
+ alarm_info->start.hour,
+ alarm_info->start.min,
+ alarm_info->start.sec,
+ alarm_info->end.year,
+ alarm_info->end.month,
+ alarm_info->end.day,
+ alarm_info->mode.u_interval.day_of_week,
+ alarm_info->mode.u_interval.interval,
+ alarm_info->mode.repeat,
+ alarm_info->alarm_type,
+ alarm_info->reserved_info,
+ (char *)b_data);
+
+ if (b_data)
+ free(b_data);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_create_appsvc", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d], return_code[%d]. error->message is %s(%d)",
+ *alarm_id, return_code, error->message, error->code);
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(ii)", alarm_id, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_create_appsvc() success. alarm_id[%d], return_code[%d].",
+ *alarm_id, return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_create(alarm_context_t context, alarm_info_t *alarm_info,
+ alarm_id_t *alarm_id, const char *dst_service_name, const char *dst_service_name_mod,
+ int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ /*TODO: Dbus bus name validation is must & will be added to avoid alarm-server crash*/
+ if (context.app_service_name == NULL
+ && strlen(dst_service_name) == 4
+ && strncmp(dst_service_name, "null", 4) == 0) {
+ ALARM_MGR_EXCEPTION_PRINT("Invalid arg. Provide valid destination or call alarmmgr_init()\n");
+ if (error_code)
+ *error_code = ERR_ALARM_INVALID_PARAM;
+ return false;
+ }
+
+ param = g_variant_new("(ssiiiiiiiiiiiiiissi)",
+ context.app_service_name,
+ context.app_service_name_mod,
+ alarm_info->start.year,
+ alarm_info->start.month,
+ alarm_info->start.day,
+ alarm_info->start.hour,
+ alarm_info->start.min,
+ alarm_info->start.sec,
+ alarm_info->msec,
+ alarm_info->end.year,
+ alarm_info->end.month,
+ alarm_info->end.day,
+ alarm_info->mode.u_interval.day_of_week,
+ alarm_info->mode.repeat,
+ alarm_info->alarm_type,
+ alarm_info->reserved_info,
+ dst_service_name, dst_service_name_mod);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_create", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d], return_code[%d]. error->message is %s(%d)",
+ *alarm_id, return_code, error->message, error->code);
+ g_error_free(error);
+
+ return false;
+ }
+
+ g_variant_get(reply, "(ii)", alarm_id, return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_create() dbus sync success. alarm_id[%d], return_code[%d].",
+ *alarm_id, return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_create_periodic(alarm_context_t context, int interval, int is_ref,
+ int method, alarm_id_t *alarm_id, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ if (context.app_service_name == NULL) {
+ ALARM_MGR_EXCEPTION_PRINT("Invalid arg. Provide valid destination or call alarmmgr_init()\n");
+ if (error_code)
+ *error_code = ERR_ALARM_INVALID_PARAM;
+ return false;
+ }
+
+ param = g_variant_new("(ssiii)",
+ context.app_service_name,
+ context.app_service_name_mod,
+ interval, is_ref, method);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_create_periodic", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d], return_code[%d]. error->message is %s(%d)",
+ *(int *)alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+
+ return false;
+ }
+
+ g_variant_get(reply, "(ii)", alarm_id, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_create_periodic() dbus sync success. alarm_id[%d], return_code[%d].",
+ *alarm_id, return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bundle *_send_alarm_get_appsvc_info(alarm_context_t context, alarm_id_t alarm_id, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ bundle *b = NULL;
+ gchar *b_data = NULL;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(i)", alarm_id);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_appsvc_info", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d], return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+
+ return NULL;
+ }
+
+ g_variant_get(reply, "(si)", &b_data, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_appsvc_info() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+ } else {
+ b = bundle_decode((bundle_raw *)b_data, strlen(b_data));
+ }
+
+ if (b_data)
+ g_free(b_data);
+
+ g_variant_unref(reply);
+ return b;
+}
+
+notification_h _send_alarm_get_noti_info(alarm_context_t context, alarm_id_t alarm_id, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ int datalen;
+ GVariant *noti_gv = NULL;
+ GVariant *body = NULL;
+ notification_h noti = NULL;
+ gchar *noti_data = NULL;
+ guchar *data;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(i)", alarm_id);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_noti_info", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d], return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+
+ return NULL;
+ }
+
+ g_variant_get(reply, "(si)", ¬i_data, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_noti_info() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+ } else {
+ data = g_base64_decode(noti_data, (gsize *)&datalen);
+
+ noti_gv = g_variant_new_from_data(G_VARIANT_TYPE("(v)"),
+ data, datalen,
+ TRUE, NULL, NULL);
+
+ g_variant_get(noti_gv, "(v)", &body);
+
+ noti = notification_create(NOTIFICATION_TYPE_NOTI);
+ notification_ipc_make_noti_from_gvariant(noti, body);
+
+ g_free(data);
+ g_variant_unref(noti_gv);
+ }
+
+ if (noti_data)
+ g_free(noti_data);
+
+ g_variant_unref(reply);
+ return noti;
+}
+
+bool _send_alarm_set_rtc_time(alarm_context_t context, alarm_date_t *time, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(iiiiii)", time->year, time->month, time->day,
+ time->hour, time->min, time->sec);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_set_rtc_time", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_set_rtc_time() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_delete(alarm_context_t context, alarm_id_t alarm_id, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(i)", alarm_id);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_delete", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d], return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_delete() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_delete_all(alarm_context_t context, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *reply = NULL;
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_delete_all", NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_delete_all() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_get_list_of_ids(alarm_context_t context, int maxnum_of_ids,
+ GVariantIter **iter, int *num_of_ids,
+ int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariantIter *iter_temp = NULL;
+ GVariant *arr = NULL;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(i)", maxnum_of_ids);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_list_of_ids", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+
+ return false;
+ }
+
+ g_variant_get(reply, "(@aiii)", &arr, num_of_ids, &return_code);
+ g_variant_get(arr, "ai", &iter_temp);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_list_of_ids() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ *iter = iter_temp;
+
+ g_variant_unref(reply);
+
+ return true;
+}
+
+bool _send_alarm_get_number_of_ids(alarm_context_t context, int *num_of_ids,
+ int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *reply = NULL;
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_number_of_ids", NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(ii)", num_of_ids, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_number_of_ids() dbus sync success.\
+ num_of_ids[%d] return_code[%d].",
+ *num_of_ids, return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_get_info(alarm_context_t context, alarm_id_t alarm_id,
+ alarm_info_t *alarm_info, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(i)", alarm_id);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_info", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id [%d] return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(iiiiiiiiiiiiii)",
+ &alarm_info->start.year,
+ &alarm_info->start.month,
+ &alarm_info->start.day,
+ &alarm_info->start.hour,
+ &alarm_info->start.min,
+ &alarm_info->start.sec,
+ &alarm_info->end.year,
+ &alarm_info->end.month,
+ &alarm_info->end.day,
+ &alarm_info->mode.u_interval.day_of_week,
+ &alarm_info->mode.repeat,
+ &alarm_info->alarm_type,
+ &alarm_info->reserved_info,
+ &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_info() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_get_next_duetime(alarm_context_t context, alarm_id_t alarm_id,
+ time_t *duetime, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+ int _duetime = 0;
+
+ param = g_variant_new("(i)", alarm_id);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_next_duetime", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id [%d] return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(ii)", &_duetime, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_next_duetime() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ *duetime = (time_t)_duetime;
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_get_all_info(alarm_context_t context, char **db_path, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *reply = NULL;
+ char *_db_path = NULL;
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_all_info", NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(si)", &_db_path, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_all_info() dbus sync success. db_path[%s] return_code[%d].",
+ *db_path, return_code);
+
+ if (return_code != ALARMMGR_RESULT_SUCCESS) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ *db_path = _db_path;
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_set_time(alarm_context_t context, int new_time, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(i)", new_time);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_set_time", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code)
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_set_time() dbus sync success. return_code[%d].",
+ return_code);
+
+ if (return_code != ALARMMGR_RESULT_SUCCESS) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+static void _alarm_set_time_cb(GObject *source_object, GAsyncResult *res,
+ gpointer user_data)
+{
+ int return_code = -1;
+ GError *error = NULL;
+ GVariant *reply = NULL;
+ alarm_set_time_data_t *func_data = (alarm_set_time_data_t *)user_data;
+
+ reply = g_dbus_proxy_call_finish(func_data->proxy, res, &error);
+ if (error) {
+ ALARM_MGR_EXCEPTION_PRINT("dbus error message: %s", error->message);
+ g_error_free(error);
+ return_code = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ g_variant_get(reply, "(i)", &return_code);
+ ALARM_MGR_LOG_PRINT(
+ "alarm_set_time_async() dbus success. return_code[%d].",
+ return_code);
+ }
+
+ if (func_data->callback != NULL)
+ func_data->callback(return_code, func_data->user_data);
+
+ g_variant_unref(reply);
+ g_free(func_data);
+}
+
+bool _send_alarm_set_time_async(alarm_context_t context, int new_time, alarm_set_time_cb_t result_cb, void *user_data)
+{
+ alarm_set_time_data_t *func_data;
+ GVariant *param;
+
+ func_data = g_try_new0(alarm_set_time_data_t, 1);
+
+ if (func_data == NULL)
+ return false;
+
+ func_data->callback = result_cb;
+ func_data->user_data = user_data;
+ func_data->proxy = context.proxy;
+
+ param = g_variant_new("(i)", new_time);
+
+ g_dbus_proxy_call(context.proxy, "alarm_set_time", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, _alarm_set_time_cb, func_data);
+
+ return true;
+}
+
+bool _send_alarm_set_time_with_propagation_delay(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(uuuu)", new_sec, new_nsec, req_sec, req_nsec);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_set_time_with_propagation_delay", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_set_time_with_propagation_delay dbus sync() success.\
+ return_code[%d]", return_code);
+
+ if (return_code != ALARMMGR_RESULT_SUCCESS) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+static void _alarm_set_time_with_delay_cb(GObject *source_object, GAsyncResult *res,
+ gpointer user_data)
+{
+ int return_code = -1;
+ GError *error = NULL;
+ GVariant *reply = NULL;
+ alarm_set_time_data_t *func_data = (alarm_set_time_data_t *)user_data;
+
+ reply = g_dbus_proxy_call_finish(func_data->proxy, res, &error);
+ if (error) {
+ ALARM_MGR_EXCEPTION_PRINT("dbus error message: %s", error->message);
+ g_error_free(error);
+ return_code = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_set_time_with_propagation_delay_async() dbus success.\
+ return_code[%d].", return_code);
+ }
+
+ if (func_data->callback != NULL)
+ func_data->callback(return_code, func_data->user_data);
+
+ g_variant_unref(reply);
+ g_free(func_data);
+}
+
+bool _send_alarm_set_time_with_propagation_delay_async(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, alarm_set_time_cb_t result_cb, void *user_data)
+{
+ alarm_set_time_data_t *func_data;
+ GVariant *param = NULL;
+
+ func_data = g_try_new0(alarm_set_time_data_t, 1);
+
+ if (func_data == NULL)
+ return false;
+
+ func_data->callback = result_cb;
+ func_data->user_data = user_data;
+ func_data->proxy = context.proxy;
+
+ param = g_variant_new("(uuuu)", new_sec, new_nsec, req_sec, req_nsec);
+
+ g_dbus_proxy_call(context.proxy, "alarm_set_time_with_propagation_delay", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, _alarm_set_time_with_delay_cb, func_data);
+
+ return true;
+}
+
+bool _send_alarm_set_timezone(alarm_context_t context, char *tzpath_str, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(s)", tzpath_str);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_set_timezone", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ return_code[%d]. error->message is %s(%d)",
+ return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_set_timezon dbus sync() success. tz_path[%s] return_code[%d]",
+ tzpath_str, return_code);
+
+ if (return_code != ALARMMGR_RESULT_SUCCESS) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_set_global(alarm_context_t context, const alarm_id_t alarm_id, bool global, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(ib)", alarm_id, (gboolean)global);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_set_global", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d] return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_set_global dbus sync() success. alarm_id[%d], global[%d]\
+ return_code[%d]", alarm_id, global, return_code);
+
+ if (return_code != ALARMMGR_RESULT_SUCCESS) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_get_global(alarm_context_t context, const alarm_id_t alarm_id, bool *global, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(i)", alarm_id);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_get_global", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d] return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(bi)", global, &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_get_global dbus sync() success. alarm_id[%d], global[%d]\
+ return_code[%d]", alarm_id, *global, return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+
+bool _send_alarm_update(alarm_context_t context, alarm_id_t alarm_id,
+ alarm_info_t *alarm_info, int update_flag, int *error_code)
+{
+ GError *error = NULL;
+ int return_code = -1;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+
+ param = g_variant_new("(iiiiiiiiiiiiiii)",
+ alarm_id,
+ alarm_info->start.year,
+ alarm_info->start.month,
+ alarm_info->start.day,
+ alarm_info->start.hour,
+ alarm_info->start.min,
+ alarm_info->start.sec,
+ alarm_info->end.year,
+ alarm_info->end.month,
+ alarm_info->end.day,
+ alarm_info->mode.u_interval.interval,
+ alarm_info->mode.repeat,
+ alarm_info->alarm_type,
+ alarm_info->reserved_info,
+ update_flag);
+
+ reply = g_dbus_proxy_call_sync(context.proxy, "alarm_update", param,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ if (error_code) {
+ if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ *error_code = ERR_ALARM_NO_PERMISSION;
+ else
+ *error_code = ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_proxy_call_sync() failed.\
+ alarm_id[%d] return_code[%d]. error->message is %s(%d)",
+ alarm_id, return_code, error->message, error->code);
+
+ g_error_free(error);
+ return false;
+ }
+
+ g_variant_get(reply, "(i)", &return_code);
+
+ ALARM_MGR_LOG_PRINT(
+ "alarm_update dbus sync() success. alarm_id[%d], return_code[%d]",\
+ alarm_id, return_code);
+
+ if (return_code != 0) {
+ if (error_code)
+ *error_code = return_code;
+
+ g_variant_unref(reply);
+ return false;
+ }
+
+ g_variant_unref(reply);
+ return true;
+}
+++ /dev/null
-/*
- * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * 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.
- */
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <string.h>
-#include <glib.h>
-#include <notification.h>
-#include <notification_ipc.h>
-#include "alarm.h"
-#include "alarm-internal.h"
-#include "alarm-mgr-stub.h"
-
-#define ALARM_SERVICE_NAME "appframework.alarm"
-#define ALARM_OBJECT_PATH "/appframework/alarm"
-#define ALARM_INTERFACE_NAME "appframework.alarm"
-
-bool _send_alarm_create(alarm_context_t context, alarm_info_t *alarm_info,
- alarm_id_t *alarm_id, const char *dst_service_name,
- const char *dst_service_name_mod, int *error_code);
-bool _send_alarm_create_appsvc(alarm_context_t context, alarm_info_t *alarm_info,
- alarm_id_t *alarm_id, bundle *b, int *error_code);
-bool _send_alarm_delete(alarm_context_t context, alarm_id_t alarm_id,
- int *error_code);
-bool _send_alarm_get_list_of_ids(alarm_context_t context, int maxnum_of_ids,
- alarm_id_t *alarm_id, int *num_of_ids, int *error_code);
-bool _send_alarm_get_number_of_ids(alarm_context_t context, int *num_of_ids,
- int *error_code);
-bool _send_alarm_get_info(alarm_context_t context, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int *error_code);
-
-bool _send_alarm_create_noti(alarm_context_t context, alarm_info_t *alarm_info,
- alarm_id_t *alarm_id, notification_h noti, int *error_code)
-{
- gboolean ret;
- GError *error = NULL;
- int return_code = 0;
- GVariant *noti_gv = NULL;
- char *noti_data;
- guchar *data;
- int datalen = 0;
-
- noti_gv = notification_ipc_make_gvariant_from_noti(noti, true);
- if (!noti_gv) {
- if (error_code)
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- return false;
- }
-
- datalen = g_variant_get_size(noti_gv);
- if (datalen < 0)
- return false;
-
- data = malloc(datalen);
- if (!data)
- return false;
-
- g_variant_store(noti_gv, data);
- noti_data = g_base64_encode((guchar *)data, datalen);
-
- ret = alarm_manager_call_alarm_create_noti_sync((AlarmManager *)context.proxy,
- alarm_info->start.year,
- alarm_info->start.month,
- alarm_info->start.day,
- alarm_info->start.hour,
- alarm_info->start.min,
- alarm_info->start.sec,
- alarm_info->end.year,
- alarm_info->end.month,
- alarm_info->end.day,
- alarm_info->mode.u_interval.day_of_week,
- alarm_info->mode.u_interval.interval,
- alarm_info->mode.repeat,
- alarm_info->alarm_type,
- alarm_info->reserved_info,
- (char *)noti_data,
- alarm_id, &return_code,
- NULL, &error);
-
- if (noti_data)
- free(noti_data);
- if (data)
- free(data);
- g_variant_unref(noti_gv);
-
- if (ret != TRUE) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_create_noti_sync()failed. alarm_id[%d], return_code[%d].",
- *(int *)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_create_appsvc(alarm_context_t context, alarm_info_t *alarm_info,
- alarm_id_t *alarm_id, bundle *b,
- int *error_code)
-{
- gboolean ret;
- GError *error = NULL;
- int return_code = 0;
- bundle_raw *b_data = NULL;
- int datalen = 0;
-
- if (bundle_encode(b, &b_data, &datalen)) {
- ALARM_MGR_EXCEPTION_PRINT("Unable to encode the bundle data\n");
- if (error_code)
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- return false;
- }
-
- ret = alarm_manager_call_alarm_create_appsvc_sync((AlarmManager *)context.proxy,
- alarm_info->start.year,
- alarm_info->start.month,
- alarm_info->start.day,
- alarm_info->start.hour,
- alarm_info->start.min,
- alarm_info->start.sec,
- alarm_info->end.year,
- alarm_info->end.month,
- alarm_info->end.day,
- alarm_info->mode.u_interval.day_of_week,
- alarm_info->mode.u_interval.interval,
- alarm_info->mode.repeat,
- alarm_info->alarm_type,
- alarm_info->reserved_info,
- (char *)b_data,
- alarm_id, &return_code,
- NULL, &error);
- if (b_data) {
- free(b_data);
- b_data = NULL;
- }
-
- if (ret != TRUE) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_create_appsvc_sync()failed. alarm_id[%d], return_code[%d].",
- *(int *)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_create(alarm_context_t context, alarm_info_t *alarm_info,
- alarm_id_t *alarm_id, const char *dst_service_name, const char *dst_service_name_mod,
- int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- /*TODO: Dbus bus name validation is must & will be added to avoid alarm-server crash*/
- if (context.app_service_name == NULL
- && strlen(dst_service_name) == 4
- && strncmp(dst_service_name, "null", 4) == 0) {
- ALARM_MGR_EXCEPTION_PRINT("Invalid arg. Provide valid destination or call alarmmgr_init()\n");
- if (error_code)
- *error_code = ERR_ALARM_INVALID_PARAM;
- return false;
- }
-
- if (!alarm_manager_call_alarm_create_sync((AlarmManager *)context.proxy,
- context.app_service_name,
- context.app_service_name_mod,
- alarm_info->start.year,
- alarm_info->start.month,
- alarm_info->start.day,
- alarm_info->start.hour,
- alarm_info->start.min,
- alarm_info->start.sec,
- alarm_info->msec,
- alarm_info->end.year,
- alarm_info->end.month,
- alarm_info->end.day,
- alarm_info->mode.u_interval.day_of_week,
- alarm_info->mode.repeat,
- alarm_info->alarm_type,
- alarm_info->reserved_info,
- dst_service_name, dst_service_name_mod,
- alarm_id, &return_code,
- NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_create_sync()failed. alarm_id[%d], return_code[%d]",
- *(int *)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_create_periodic(alarm_context_t context, int interval, int is_ref,
- int method, alarm_id_t *alarm_id, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (context.app_service_name == NULL) {
- ALARM_MGR_EXCEPTION_PRINT("Invalid arg. Provide valid destination or call alarmmgr_init()\n");
- if (error_code)
- *error_code = ERR_ALARM_INVALID_PARAM;
- return false;
- }
-
- if (!alarm_manager_call_alarm_create_periodic_sync((AlarmManager *)context.proxy,
- context.app_service_name,
- context.app_service_name_mod,
- interval, is_ref, method,
- alarm_id, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_create_periodic_sync()failed. alarm_id[%d], return_code[%d]",
- *(int *)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bundle *_send_alarm_get_appsvc_info(alarm_context_t context, alarm_id_t alarm_id, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
- bundle *b = NULL;
- gchar *b_data = NULL;
-
- if (!alarm_manager_call_alarm_get_appsvc_info_sync
- ((AlarmManager *)context.proxy, alarm_id, &b_data, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_get_appsvc_info_sync() failed. alarm_id[%d], return_code[%d].",
- (int)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
-
- if (b_data)
- g_free(b_data);
-
- return NULL;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- } else {
- b = bundle_decode((bundle_raw *)b_data, strlen(b_data));
- }
-
- if (b_data)
- g_free(b_data);
-
- return b;
-}
-
-notification_h _send_alarm_get_noti_info(alarm_context_t context, alarm_id_t alarm_id, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
- int datalen;
- GVariant *noti_gv = NULL;
- GVariant *body = NULL;
- notification_h noti = NULL;
- gchar *noti_data = NULL;
- guchar *data;
-
- if (!alarm_manager_call_alarm_get_noti_info_sync
- ((AlarmManager *)context.proxy, alarm_id, ¬i_data, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_get_appsvc_info_sync() failed. alarm_id[%d], return_code[%d].",
- (int)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
-
- if (noti_data)
- g_free(noti_data);
-
- return NULL;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- } else {
- data = g_base64_decode(noti_data, (gsize *)&datalen);
-
- noti_gv = g_variant_new_from_data(G_VARIANT_TYPE("(v)"),
- data, datalen,
- TRUE, NULL, NULL);
-
- g_variant_get(noti_gv, "(v)", &body);
-
- noti = notification_create(NOTIFICATION_TYPE_NOTI);
- notification_ipc_make_noti_from_gvariant(noti, body);
-
- g_free(data);
- g_variant_unref(noti_gv);
- }
-
- if (noti_data)
- g_free(noti_data);
-
- return noti;
-}
-
-bool _send_alarm_set_rtc_time(alarm_context_t context, alarm_date_t *time, int *error_code)
-{
-
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_set_rtc_time_sync
- ((AlarmManager *)context.proxy, time->year, time->month, time->day,
- time->hour, time->min, time->sec, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_set_rtc_time() failed. return_code[%d]", return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
-
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_delete(alarm_context_t context, alarm_id_t alarm_id, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_delete_sync
- ((AlarmManager *)context.proxy, alarm_id, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_delete_sync() failed. alarm_id[%d], return_code[%d]",
- (int)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
-
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_delete_all(alarm_context_t context, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_delete_all_sync
- ((AlarmManager *)context.proxy, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_delete_all_sync() failed. return_code[%d]", return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
-
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_get_list_of_ids(alarm_context_t context, int maxnum_of_ids,
- alarm_id_t *alarm_id, int *num_of_ids,
- int *error_code)
-{
- GError *error = NULL;
- GVariant *alarm_array = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_get_list_of_ids_sync((AlarmManager *)context.proxy,
- maxnum_of_ids, &alarm_array,
- num_of_ids, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_get_list_of_ids_sync() failed by dbus. alarm_id[%d], return_code[%d]\n",
- *(int *)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
-
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- } else {
- GVariantIter *iter = NULL;
- gint i = 0;
- g_variant_get(alarm_array, "ai", &iter);
- while (g_variant_iter_loop(iter, "i", &alarm_id[i])) {
- ALARM_MGR_LOG_PRINT("alarm_id (%d)", alarm_id[i]);
- i++;
- }
- g_variant_iter_free(iter);
- *num_of_ids = i;
- g_variant_unref(alarm_array);
- }
-
- return true;
-}
-
-bool _send_alarm_get_number_of_ids(alarm_context_t context, int *num_of_ids,
- int *error_code)
-{
- GError *error = NULL;
- gint return_code = 0;
-
- if (!alarm_manager_call_alarm_get_number_of_ids_sync((AlarmManager *)context.proxy, num_of_ids, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_get_number_of_ids_sync() failed by dbus. return_code[%d]",
- return_code);
-
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_get_info(alarm_context_t context, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_get_info_sync((AlarmManager *)context.proxy,
- alarm_id, &alarm_info->start.year,
- &alarm_info->start.month, &alarm_info->start.day,
- &alarm_info->start.hour, &alarm_info->start.min,
- &alarm_info->start.sec, &alarm_info->end.year,
- &alarm_info->end.month, &alarm_info->end.day,
- &alarm_info->mode.u_interval.day_of_week,
- (gint *)&alarm_info->mode.repeat,
- &alarm_info->alarm_type, &alarm_info->reserved_info, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_get_info_sync() failed by dbus. alarm_id[%d], return_code[%d]\n",
- (int)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_get_next_duetime(alarm_context_t context,
- alarm_id_t alarm_id, time_t* duetime,
- int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_get_next_duetime_sync((AlarmManager *)context.proxy,
- alarm_id, (gint *)duetime, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_get_next_duetime_sync() failed by dbus. alarm_id[%d], return_code[%d]\n",
- (int)alarm_id, return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_get_all_info(alarm_context_t context, char **db_path, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_get_all_info_sync((AlarmManager *)context.proxy, db_path, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_get_all_info_sync() failed by dbus. return_code[%d]", return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_set_time(alarm_context_t context, int new_time, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_set_time_sync((AlarmManager *)context.proxy, new_time, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_set_time_sync() failed by dbus. return_code[%d]", return_code);
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("dbus error message: %s", error->message);
- g_error_free(error);
- }
- if (error_code)
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- return false;
- }
-
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-static void _alarm_set_time_cb(GObject *source_object, GAsyncResult *res,
- gpointer user_data)
-{
- int return_code = 0;
- GError *error = NULL;
- alarm_set_time_data_t *func_data = (alarm_set_time_data_t *)user_data;
-
- if (!alarm_manager_call_alarm_set_time_finish((AlarmManager *)func_data->proxy,
- (gint *)&return_code,
- res, &error)) {
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("dbus error message: %s", error->message);
- g_error_free(error);
- }
- return_code = ERR_ALARM_SYSTEM_FAIL;
- }
-
- if (func_data->callback != NULL)
- func_data->callback(return_code, func_data->user_data);
-
- g_free(func_data);
-}
-
-bool _send_alarm_set_time_async(alarm_context_t context, int new_time, alarm_set_time_cb_t result_cb, void *user_data)
-{
- alarm_set_time_data_t *func_data;
-
- func_data = g_try_new0(alarm_set_time_data_t, 1);
-
- if (func_data == NULL)
- return false;
-
- func_data->callback = result_cb;
- func_data->user_data = user_data;
- func_data->proxy = context.proxy;
-
- alarm_manager_call_alarm_set_time((AlarmManager *)context.proxy, new_time,
- NULL, _alarm_set_time_cb, func_data);
-
- return true;
-}
-
-bool _send_alarm_set_time_with_propagation_delay(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_set_time_with_propagation_delay_sync((AlarmManager *)context.proxy, new_sec, new_nsec, req_sec, req_nsec, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_set_time_with_propagation_delay_sync() failed by dbus. return_code[%d]", return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-static void _alarm_set_time_with_delay_cb(GObject *source_object, GAsyncResult *res,
- gpointer user_data)
-{
- int return_code = 0;
- GError *error = NULL;
- alarm_set_time_data_t *func_data = (alarm_set_time_data_t *)user_data;
-
- if (!alarm_manager_call_alarm_set_time_with_propagation_delay_finish((AlarmManager *)func_data->proxy,
- (gint *)&return_code,
- res, &error)) {
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("dbus error message: %s", error->message);
- g_error_free(error);
- }
- return_code = ERR_ALARM_SYSTEM_FAIL;
- }
-
- if (func_data->callback != NULL)
- func_data->callback(return_code, func_data->user_data);
-
- g_free(func_data);
-}
-
-bool _send_alarm_set_time_with_propagation_delay_async(alarm_context_t context, unsigned int new_sec, unsigned int new_nsec, unsigned int req_sec, unsigned int req_nsec, alarm_set_time_cb_t result_cb, void *user_data)
-{
- alarm_set_time_data_t *func_data;
-
- func_data = g_try_new0(alarm_set_time_data_t, 1);
-
- if (func_data == NULL)
- return false;
-
- func_data->callback = result_cb;
- func_data->user_data = user_data;
- func_data->proxy = context.proxy;
-
- alarm_manager_call_alarm_set_time_with_propagation_delay((AlarmManager *)context.proxy,
- new_sec, new_nsec, req_sec, req_nsec,
- NULL, _alarm_set_time_with_delay_cb, func_data);
-
- return true;
-}
-
-bool _send_alarm_set_timezone(alarm_context_t context, char *tzpath_str, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_set_timezone_sync((AlarmManager *)context.proxy, tzpath_str, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_set_timezone_sync() failed by dbus. return_code[%d]", return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_set_global(alarm_context_t context, const alarm_id_t alarm_id, bool global, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_set_global_sync((AlarmManager *)context.proxy, alarm_id, global, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_set_global_sync() failed by dbus. return_code[%d]", return_code);
- if (error_code) {
- if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
-
-bool _send_alarm_get_global(alarm_context_t context, const alarm_id_t alarm_id, bool *global, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
- gboolean _global;
-
- if (!alarm_manager_call_alarm_get_global_sync((AlarmManager *)context.proxy, alarm_id, &_global, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_get_global_sync() failed by dbus. return_code[%d]", return_code);
- if (error_code) {
- if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- g_error_free(error);
- }
- return false;
- }
-
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- *global = (bool)_global;
- return true;
-}
-
-bool _send_alarm_update(alarm_context_t context, alarm_id_t alarm_id,
- alarm_info_t *alarm_info, int update_flag, int *error_code)
-{
- GError *error = NULL;
- int return_code = 0;
-
- if (!alarm_manager_call_alarm_update_sync((AlarmManager *)context.proxy,
- alarm_id,
- alarm_info->start.year,
- alarm_info->start.month,
- alarm_info->start.day,
- alarm_info->start.hour,
- alarm_info->start.min,
- alarm_info->start.sec,
- alarm_info->end.year,
- alarm_info->end.month,
- alarm_info->end.day,
- alarm_info->mode.u_interval.interval,
- alarm_info->mode.repeat,
- alarm_info->alarm_type,
- alarm_info->reserved_info,
- update_flag,
- &return_code,
- NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_update_sync()failed. alarm_id[%d], return_code[%d]",
- (int)alarm_id, return_code);
- ALARM_MGR_EXCEPTION_PRINT("error->message is %s(%d)", error->message, error->code);
- if (error_code) {
- if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
- *error_code = ERR_ALARM_NO_PERMISSION;
- else
- *error_code = ERR_ALARM_SYSTEM_FAIL;
- }
- g_error_free(error);
- return false;
- }
-
- if (return_code != 0) {
- if (error_code)
- *error_code = return_code;
- return false;
- }
-
- return true;
-}
#include "alarm.h"
#include "alarm-internal.h"
-#include "alarm-mgr-stub.h"
#include <bundle.h>
#include <appsvc.h>
#include <aul.h>
#include <pkgmgr-info.h>
#include <notification.h>
#include <tzplatform_config.h>
-#include <cert-svc/ccert.h>
-#include <cert-svc/cinstance.h>
#ifndef EXPORT_API
#define EXPORT_API __attribute__ ((visibility("default")))
if (!_send_alarm_create_appsvc(alarm_context, &alarm_info, alarm_id, b, &error_code))
return error_code;
+
+ ALARM_MGR_LOG_PRINT("alarm_id : %d", *alarm_id);
+
return ALARMMGR_RESULT_SUCCESS;
}
EXPORT_API int alarmmgr_enum_alarm_ids(alarm_enum_fn_t fn, void *user_param)
{
SECURE_LOGD("Enter");
- GError *error = NULL;
- GVariant *alarm_array = NULL;
int return_code = 0;
int maxnum_of_ids = 0;
int num_of_ids = 0;
- alarm_id_t alarm_id = -1;
+ alarm_id_t alarm_id;
int ret = 0;
GVariantIter *iter = NULL;
return ret;
}
- SECURE_LOGD("alarm_manager_call_alarm_get_number_of_ids_sync() is called");
- if (!alarm_manager_call_alarm_get_number_of_ids_sync(
- (AlarmManager *)alarm_context.proxy, &maxnum_of_ids, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_get_number_of_ids_sync() is failed by dbus. return_code[%d], err message[%s] err code[%d]",
- return_code, error->message, error->code);
- if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
- ret = ERR_ALARM_NO_PERMISSION;
- else
- ret = ERR_ALARM_SYSTEM_FAIL;
- g_error_free(error);
- return ret;
- }
-
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- ALARM_MGR_EXCEPTION_PRINT("alarm_manager_call_alarm_get_number_of_ids_sync() is failed. return_code[%d]", return_code);
+ if (!_send_alarm_get_number_of_ids(alarm_context, &maxnum_of_ids, &return_code))
return return_code;
- } else {
- ALARM_MGR_LOG_PRINT("maxnum_of_ids[%d]", maxnum_of_ids);
- }
- SECURE_LOGD("alarm_manager_call_alarm_get_list_of_ids_sync() is called");
- if (!alarm_manager_call_alarm_get_list_of_ids_sync(
- (AlarmManager *)alarm_context.proxy, maxnum_of_ids, &alarm_array, &num_of_ids, &return_code, NULL, &error)) {
- ALARM_MGR_EXCEPTION_PRINT(
- "alarm_manager_call_alarm_get_list_of_ids_sync() failed by dbus. num_of_ids[%d], return_code[%d]. err message[%s] err code[%d]", num_of_ids, return_code, error->message, error->code);
- if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
- ret = ERR_ALARM_NO_PERMISSION;
- else
- ret = ERR_ALARM_SYSTEM_FAIL;
- g_error_free(error);
- return ret;
- }
+ ALARM_MGR_LOG_PRINT("maxnum_of_ids[%d]", maxnum_of_ids);
- if (return_code != ALARMMGR_RESULT_SUCCESS)
+ if (!_send_alarm_get_list_of_ids(alarm_context, maxnum_of_ids, &iter, &num_of_ids, &return_code))
return return_code;
- if (error != NULL) {
- ALARM_MGR_EXCEPTION_PRINT("Alarm server is not ready dbus. error message %s.", error->message);
- return ERR_ALARM_SYSTEM_FAIL;
- }
-
- if (alarm_array == NULL) {
- ALARM_MGR_EXCEPTION_PRINT("alarm server is not initilized.");
- return ERR_ALARM_SYSTEM_FAIL;
- }
-
- g_variant_get(alarm_array, "ai", &iter);
while (g_variant_iter_loop(iter, "i", &alarm_id)) {
- (*fn)(alarm_id, user_param);
ALARM_MGR_LOG_PRINT("alarm_id (%d)", alarm_id);
+ (*fn)(alarm_id, user_param);
}
g_variant_iter_free(iter);
- g_variant_unref(alarm_array);
- SECURE_LOGD("Leave");
return ALARMMGR_RESULT_SUCCESS;
}
return ALARMMGR_RESULT_SUCCESS;
}
-int alarmmgr_get_list_of_ids(int maxnum_of_ids, alarm_id_t *alarm_id,
- int *num_of_ids)
-{
- int error_code;
- ALARM_MGR_LOG_PRINT("[alarm-lib]:alarm_get_list_of_ids() is called.");
-
- if (maxnum_of_ids < 0 || alarm_id == NULL || num_of_ids == NULL)
- return ERR_ALARM_INVALID_PARAM;
-
- if (maxnum_of_ids == 0) {
- *num_of_ids = 0;
- return ALARMMGR_RESULT_SUCCESS;
- }
-
- if (!_send_alarm_get_list_of_ids
- (alarm_context, maxnum_of_ids, alarm_id, num_of_ids, &error_code)) {
- return error_code;
- }
-
- return ALARMMGR_RESULT_SUCCESS;
-}
-
EXPORT_API int alarmmgr_get_next_duetime(alarm_id_t alarm_id, time_t *duetime)
{
int error_code;
bool global)
{
int error_code;
- ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_set_global() is called.");
+ ALARM_MGR_LOG_PRINT("[alarm-lib]:alarmmgr_set_global(%d) is called.", alarm_id);
if (__sub_init() < 0)
return ERR_ALARM_SYSTEM_FAIL;
BuildRequires: zip
%endif
-%define gtests 1
+%define gtests 0
%if 0%{?gtests:1}
BuildRequires: pkgconfig(gmock)
%files -n alarm-config-service-restricted
%{_datadir}/alarm-manager/alarm-config-service-restricted
-%files unittests
-%{_bindir}/gtest*
+#%if 0%{?gtests:1}
+#%files unittests
+#%{_bindir}/gtest*
+#%endif
#################################################
# gcov
INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/server)
AUX_SOURCE_DIRECTORY(./ SRCS)
-SET(SRCS ${SRCS} ${CMAKE_SOURCE_DIR}/common/alarm-mgr-stub.c)
-SET_SOURCE_FILES_PROPERTIES(${CMAKE_SOURCE_DIR}/common/alarm-mgr-stub.c
- PROPERTIES GENERATED TRUE)
PKG_CHECK_MODULES(svr_pkgs REQUIRED glib-2.0 dlog aul bundle appsvc pkgmgr-info pkgmgr vconf
gio-2.0 gio-unix-2.0 capi-system-device libtzplatform-config libsystemd-login
SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fpie")
ADD_EXECUTABLE(${SERVER} ${SRCS})
-ADD_DEPENDENCIES(${SERVER} GENERATED_DBUS_CODE)
TARGET_LINK_LIBRARIES(${SERVER} ${svr_pkgs_LIBRARIES} rt)
INSTALL(TARGETS ${SERVER} DESTINATION ${BIN_INSTALL_DIR})
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+
+#include "alarm.h"
+#include "alarm-internal.h"
+#include "alarm-manager-dbus.h"
+#include "alarm-manager-util.h"
+
+/* GDBus Declaration */
+#define ALARM_MGR_DBUS_PATH "/org/tizen/alarm/manager"
+#define ALARM_MGR_DBUS_NAME "org.tizen.alarm.manager"
+
+extern __alarm_server_context_t alarm_context;
+extern GSList *g_expired_alarm_list;
+
+static GDBusNodeInfo *introspection_data;
+static const gchar introspection_xml[] =
+"<node name='/org/tizen/alarm/manager'>"
+" <interface name='org.tizen.alarm.manager'>"
+" <method name='alarm_create_periodic'>"
+" <arg type='s' name='app_service_name' direction='in' />"
+" <arg type='s' name='app_service_name_mod' direction='in' />"
+" <arg type='i' name='interval' direction='in' />"
+" <arg type='i' name='is_ref' direction='in' />"
+" <arg type='i' name='method' direction='in' />"
+" <arg type='i' name='alarm_id' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_create'>"
+" <arg type='s' name='app_service_name' direction='in' />"
+" <arg type='s' name='app_service_name_mod' direction='in' />"
+" <arg type='i' name='alarm_info_start_year' direction='in' />"
+" <arg type='i' name='alarm_info_start_month' direction='in' />"
+" <arg type='i' name='alarm_info_start_day' direction='in' />"
+" <arg type='i' name='alarm_info_start_hour' direction='in' />"
+" <arg type='i' name='alarm_info_start_min' direction='in' />"
+" <arg type='i' name='alarm_info_start_sec' direction='in' />"
+" <arg type='i' name='alarm_info_msec' direction='in' />"
+" <arg type='i' name='alarm_info_end_year' direction='in' />"
+" <arg type='i' name='alarm_info_end_month' direction='in' />"
+" <arg type='i' name='alarm_info_end_day' direction='in' />"
+" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
+" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
+" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
+" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='s' name='alarm_info_reserved_service_name' direction='in' />"
+" <arg type='s' name='alarm_info_reserved_service_name_mod' direction='in' />"
+" <arg type='i' name='alarm_id' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_create_appsvc'>"
+" <arg type='i' name='alarm_info_start_year' direction='in' />"
+" <arg type='i' name='alarm_info_start_month' direction='in' />"
+" <arg type='i' name='alarm_info_start_day' direction='in' />"
+" <arg type='i' name='alarm_info_start_hour' direction='in' />"
+" <arg type='i' name='alarm_info_start_min' direction='in' />"
+" <arg type='i' name='alarm_info_start_sec' direction='in' />"
+" <arg type='i' name='alarm_info_end_year' direction='in' />"
+" <arg type='i' name='alarm_info_end_month' direction='in' />"
+" <arg type='i' name='alarm_info_end_day' direction='in' />"
+" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
+" <arg type='i' name='alarm_info_mode_interval' direction='in' />"
+" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
+" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
+" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='s' name='alarm_info_bundle_data' direction='in' />"
+" <arg type='i' name='alarm_id' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_create_noti'>"
+" <arg type='i' name='alarm_info_start_year' direction='in' />"
+" <arg type='i' name='alarm_info_start_month' direction='in' />"
+" <arg type='i' name='alarm_info_start_day' direction='in' />"
+" <arg type='i' name='alarm_info_start_hour' direction='in' />"
+" <arg type='i' name='alarm_info_start_min' direction='in' />"
+" <arg type='i' name='alarm_info_start_sec' direction='in' />"
+" <arg type='i' name='alarm_info_end_year' direction='in' />"
+" <arg type='i' name='alarm_info_end_month' direction='in' />"
+" <arg type='i' name='alarm_info_end_day' direction='in' />"
+" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
+" <arg type='i' name='alarm_info_mode_interval' direction='in' />"
+" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
+" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
+" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='s' name='alarm_info_noti_data' direction='in' />"
+" <arg type='i' name='alarm_id' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_delete'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='i' name='alarm_info_return_code' direction='out' />"
+" </method>"
+" <method name='alarm_delete_all'>"
+" <arg type='i' name='alarm_info_return_code' direction='out' />"
+" </method>"
+" <method name='alarm_update'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='i' name='alarm_info_start_year' direction='in' />"
+" <arg type='i' name='alarm_info_start_month' direction='in' />"
+" <arg type='i' name='alarm_info_start_day' direction='in' />"
+" <arg type='i' name='alarm_info_start_hour' direction='in' />"
+" <arg type='i' name='alarm_info_start_min' direction='in' />"
+" <arg type='i' name='alarm_info_start_sec' direction='in' />"
+" <arg type='i' name='alarm_info_end_year' direction='in' />"
+" <arg type='i' name='alarm_info_end_month' direction='in' />"
+" <arg type='i' name='alarm_info_end_day' direction='in' />"
+" <arg type='i' name='alarm_info_mode_day_of_week' direction='in' />"
+" <arg type='i' name='alarm_info_mode_repeat' direction='in' />"
+" <arg type='i' name='alarm_info_alarm_type' direction='in' />"
+" <arg type='i' name='alarm_info_reserved_info' direction='in' />"
+" <arg type='i' name='update_flag' direction='in' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_number_of_ids'>"
+" <arg type='i' name='number_of_ids' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_list_of_ids'>"
+" <arg type='i' name='max_number_of_ids' direction='in' />"
+" <arg type='ai' name='alarm_id' direction='out' />"
+" <arg type='i' name='number_of_ids' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_appsvc_info'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='s' name='b_data' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_noti_info'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='s' name='noti_data' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_info'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='i' name='alarm_info_start_year' direction='out' />"
+" <arg type='i' name='alarm_info_start_month' direction='out' />"
+" <arg type='i' name='alarm_info_start_day' direction='out' />"
+" <arg type='i' name='alarm_info_start_hour' direction='out' />"
+" <arg type='i' name='alarm_info_start_min' direction='out' />"
+" <arg type='i' name='alarm_info_start_sec' direction='out' />"
+" <arg type='i' name='alarm_info_end_year' direction='out' />"
+" <arg type='i' name='alarm_info_end_month' direction='out' />"
+" <arg type='i' name='alarm_info_end_day' direction='out' />"
+" <arg type='i' name='alarm_info_mode_day_of_week' direction='out' />"
+" <arg type='i' name='alarm_info_mode_repeat' direction='out' />"
+" <arg type='i' name='alarm_info_alarm_type' direction='out' />"
+" <arg type='i' name='alarm_info_reserved_info' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_set_rtc_time'>"
+" <arg type='i' name='alarm_info_year' direction='in' />"
+" <arg type='i' name='alarm_info_month' direction='in' />"
+" <arg type='i' name='alarm_info_day' direction='in' />"
+" <arg type='i' name='alarm_info_hour' direction='in' />"
+" <arg type='i' name='alarm_info_min' direction='in' />"
+" <arg type='i' name='alarm_info_sec' direction='in' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_next_duetime'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='i' name='duetime' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_all_info'>"
+" <arg type='s' name='db_path' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_set_time'>"
+" <arg type='i' name='time' direction='in' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_set_time_with_propagation_delay'>"
+" <arg type='u' name='new_sec' direction='in' />"
+" <arg type='u' name='new_nsec' direction='in' />"
+" <arg type='u' name='req_sec' direction='in' />"
+" <arg type='u' name='req_nsec' direction='in' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_set_timezone'>"
+" <arg type='s' name='tzpath_str' direction='in' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_set_global'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='b' name='global' direction='in' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <method name='alarm_get_global'>"
+" <arg type='i' name='alarm_id' direction='in' />"
+" <arg type='b' name='global' direction='out' />"
+" <arg type='i' name='return_code' direction='out' />"
+" </method>"
+" <signal name='alarm_expired'>"
+" <arg type='i' name='alarm_id' />"
+" <arg type='s' name='app_service_name' />"
+" </signal>"
+" </interface>"
+"</node>";
+
+static gboolean __send_noti_to_session_bus(char *service_name,
+ alarm_id_t alarm_id, int msec, uid_t uid)
+{
+ int fd;
+ int ret;
+ int len;
+ struct sockaddr_un saddr;
+ uint8_t *data;
+ GVariant *gv;
+ uint8_t *gv_data;
+
+ fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
+ if (fd < 0)
+ return FALSE;
+
+ saddr.sun_family = AF_UNIX;
+ snprintf(saddr.sun_path, sizeof(saddr.sun_path),
+ "/run/alarm_agent/%d", uid);
+
+ ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
+ if (ret < 0) {
+ ALARM_MGR_EXCEPTION_PRINT("connect failed - (errno %d)", errno);
+ close(fd);
+ return FALSE;
+ }
+
+ gv = g_variant_new("(iis)", alarm_id, msec, service_name);
+ if (!gv) {
+ close(fd);
+ return FALSE;
+ }
+
+ len = g_variant_get_size(gv);
+
+ gv_data = NULL;
+ if (len > 0)
+ gv_data = (uint8_t *)malloc(len);
+
+ if (!gv_data) {
+ g_variant_unref(gv);
+ close(fd);
+ return FALSE;
+ }
+
+ g_variant_store(gv, gv_data);
+ g_variant_unref(gv);
+
+ data = (uint8_t *)malloc(len + 4);
+ if (!data) {
+ close(fd);
+ free(gv_data);
+ return FALSE;
+ }
+
+ memcpy(data, &len, 4);
+ memcpy(data + 4, gv_data, len);
+ free(gv_data);
+
+ if (send(fd, data, len + 4, 0) == -1) {
+ ALARM_MGR_EXCEPTION_PRINT("sendto() failed (errno %d)", errno);
+ free(data);
+ close(fd);
+ return FALSE;
+ }
+
+ free(data);
+ close(fd);
+ return TRUE;
+}
+
+void _alarm_send_noti_to_application_by_dbus(const char *app_service_name,
+ alarm_id_t alarm_id, int msec, uid_t uid)
+{
+ char service_name[MAX_SERVICE_NAME_LEN] = {0,};
+ gboolean ret;
+
+ if (app_service_name == NULL || strlen(app_service_name) == 0) {
+ ALARM_MGR_EXCEPTION_PRINT("This alarm destination is invalid.");
+ return;
+ }
+
+ if (_can_skip_expired_cb(alarm_id))
+ return;
+
+ strncpy(service_name, app_service_name, sizeof(service_name) - 1);
+ SECURE_LOGI("[send expired_alarm(alarm_id=%d) to app_service_name(%s)]",
+ alarm_id, service_name);
+
+ if (uid >= REGULAR_UID_MIN) {
+ ret = __send_noti_to_session_bus(service_name, alarm_id, msec, uid);
+ if (ret != TRUE)
+ ALARM_MGR_EXCEPTION_PRINT("failed to send alarm expired noti for %d, %s",
+ alarm_id, service_name);
+ } else {
+ g_dbus_connection_call(alarm_context.connection,
+ service_name,
+ "/org/tizen/alarm/client",
+ "org.tizen.alarm.client",
+ "alarm_expired",
+ g_variant_new("(iis)", alarm_id, msec, service_name),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ NULL,
+ NULL);
+ }
+}
+
+static uid_t __get_caller_uid(const char *name)
+{
+ guint uid;
+ GVariant *ret;
+ GError *error = NULL;
+
+ ret = g_dbus_connection_call_sync(
+ alarm_context.connection,
+ "org.freedesktop.DBus",
+ "/org/freedesktop/DBus",
+ "org.freedesktop.DBus",
+ "GetConnectionUnixUser",
+ g_variant_new("(s)", name),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (!ret) {
+ ALARM_MGR_EXCEPTION_PRINT("failed to get caller uid");
+ if (error) {
+ ALARM_MGR_EXCEPTION_PRINT("dbus error message : %s", error->message);
+ g_error_free(error);
+ }
+ return -1;
+ }
+ g_variant_get(ret, "(u)", &uid);
+ g_variant_unref(ret);
+
+ return uid;
+}
+
+static pid_t __get_caller_pid(const char *name)
+{
+ guint pid;
+ GVariant *ret;
+ GError *error = NULL;
+
+ ret = g_dbus_connection_call_sync(alarm_context.connection,
+ "org.freedesktop.DBus",
+ "/org/freedesktop/DBus",
+ "org.freedesktop.DBus",
+ "GetConnectionUnixProcessID",
+ g_variant_new("(s)", name),
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ &error);
+ if (!ret) {
+ ALARM_MGR_EXCEPTION_PRINT("failed to get caller pid");
+ if (error) {
+ ALARM_MGR_EXCEPTION_PRINT("dbus error message : %s", error->message);
+ g_error_free(error);
+ }
+ return -1;
+ }
+ g_variant_get(ret, "(u)", &pid);
+ g_variant_unref(ret);
+
+ return pid;
+}
+
+int _display_lock_state(char *state, char *flag, unsigned int timeout)
+{
+ GDBusMessage *msg = NULL;
+ GDBusMessage *reply = NULL;
+ GVariant *body = NULL;
+ int ret = ALARMMGR_RESULT_SUCCESS;
+ int val = -1;
+
+ msg = g_dbus_message_new_method_call(
+ DEVICED_BUS_NAME,
+ DEVICED_PATH_DISPLAY,
+ DEVICED_INTERFACE_DISPLAY,
+ DEVICED_LOCK_STATE);
+ if (!msg) {
+ ALARM_MGR_EXCEPTION_PRINT(
+ "g_dbus_message_new_method_call() is failed. (%s:%s-%s)",
+ DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
+ return ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ g_dbus_message_set_body(
+ msg, g_variant_new("(sssi)", state, flag, "NULL", timeout));
+
+ reply = g_dbus_connection_send_message_with_reply_sync(
+ alarm_context.connection,
+ msg,
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE,
+ DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL);
+ if (!reply) {
+ ALARM_MGR_EXCEPTION_PRINT("No reply.\
+ g_dbus_connection_send_message_with_reply_sync() is failed.");
+ ret = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ body = g_dbus_message_get_body(reply);
+ if (!body) {
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
+ ret = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ g_variant_get(body, "(i)", &val);
+ if (val != 0) {
+ ALARM_MGR_EXCEPTION_PRINT("Failed to lock display");
+ ret = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ ALARM_MGR_LOG_PRINT("Lock LCD OFF is successfully done");
+ }
+ }
+ }
+
+ g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
+ g_object_unref(msg);
+ if (reply)
+ g_object_unref(reply);
+
+ return ret;
+}
+
+int _display_unlock_state(char *state, char *flag)
+{
+ GDBusMessage *msg = NULL;
+ GDBusMessage *reply = NULL;
+ GVariant *body = NULL;
+ int ret = ALARMMGR_RESULT_SUCCESS;
+ int val = -1;
+
+ msg = g_dbus_message_new_method_call(
+ DEVICED_BUS_NAME,
+ DEVICED_PATH_DISPLAY,
+ DEVICED_INTERFACE_DISPLAY,
+ DEVICED_UNLOCK_STATE);
+ if (!msg) {
+ ALARM_MGR_EXCEPTION_PRINT(
+ "g_dbus_message_new_method_call() is failed. (%s:%s-%s)",
+ DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
+ return ERR_ALARM_SYSTEM_FAIL;
+ }
+
+ g_dbus_message_set_body(msg, g_variant_new("(ss)", state, flag));
+
+ reply = g_dbus_connection_send_message_with_reply_sync(
+ alarm_context.connection,
+ msg,
+ G_DBUS_SEND_MESSAGE_FLAGS_NONE,
+ DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL);
+ if (!reply) {
+ ALARM_MGR_EXCEPTION_PRINT("No reply.\
+ g_dbus_connection_send_message_with_reply_sync() is failed.");
+ ret = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ body = g_dbus_message_get_body(reply);
+ if (!body) {
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
+ ret = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ g_variant_get(body, "(i)", &val);
+ if (val != 0) {
+ ALARM_MGR_EXCEPTION_PRINT("Failed to unlock display");
+ ret = ERR_ALARM_SYSTEM_FAIL;
+ } else {
+ ALARM_MGR_LOG_PRINT("Unlock LCD OFF is successfully done");
+ }
+ }
+ }
+
+ g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
+ g_object_unref(msg);
+ if (reply)
+ g_object_unref(reply);
+
+ return ret;
+}
+
+static void handle_method_call(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path,
+ const gchar *interface_name, const gchar *method_name,
+ GVariant *parameters, GDBusMethodInvocation *invoc,
+ gpointer user_data)
+{
+ int ret;
+ int num_of_alarm;
+ int alarm_id;
+ const char *name = g_dbus_method_invocation_get_sender(invoc);
+ uid_t uid = __get_caller_uid(name);
+ pid_t pid = __get_caller_pid(name);
+
+ if (g_strcmp0(method_name, "alarm_create_periodic") == 0) {
+ ret = alarm_manager_alarm_create_periodic(parameters, uid, pid, &alarm_id);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
+ } else if (g_strcmp0(method_name, "alarm_create") == 0) {
+ ret = alarm_manager_alarm_create(parameters, uid, pid, &alarm_id);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
+ } else if (g_strcmp0(method_name, "alarm_create_appsvc") == 0) {
+ ret = alarm_manager_alarm_create_appsvc(parameters, uid, pid, &alarm_id);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
+ } else if (g_strcmp0(method_name, "alarm_create_noti") == 0) {
+ const char *notification_priv = "http://tizen.org/privilege/notification";
+ ret = _cynara_check(invoc, notification_priv, pid);
+ if (ret == ALARMMGR_RESULT_SUCCESS) {
+ ret = alarm_manager_alarm_create_noti(parameters, uid, pid, &alarm_id);
+ }
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, ret));
+ } else if (g_strcmp0(method_name, "alarm_delete") == 0) {
+ ret = alarm_manager_alarm_delete(parameters, uid, pid);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_delete_all") == 0) {
+ ret = alarm_manager_alarm_delete_all(parameters, uid, pid);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_update") == 0) {
+ ret = alarm_manager_alarm_update(parameters, uid, pid);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_get_number_of_ids") == 0) {
+ ret = alarm_manager_alarm_get_number_of_ids(uid, pid, &num_of_alarm);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_alarm, ret));
+ } else if (g_strcmp0(method_name, "alarm_get_list_of_ids") == 0) {
+ GVariant *arr = NULL;
+
+ ret = alarm_manager_alarm_get_list_of_ids(parameters, uid, pid, &arr, &num_of_alarm);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", arr, num_of_alarm, ret));
+ } else if (g_strcmp0(method_name, "alarm_get_appsvc_info") == 0) {
+ gchar *b_data = NULL;
+
+ ret = alarm_manager_alarm_get_appsvc_info(parameters, uid, &b_data);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, ret));
+ if (b_data)
+ free(b_data);
+ } else if (g_strcmp0(method_name, "alarm_get_noti_info") == 0) {
+ gchar *noti_data = NULL;
+
+ ret = alarm_manager_alarm_get_noti_info(parameters, uid, ¬i_data);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", noti_data, ret));
+
+ if (noti_data)
+ free(noti_data);
+ } else if (g_strcmp0(method_name, "alarm_get_info") == 0) {
+ alarm_info_t alarm_info = { 0, };
+
+ ret = alarm_manager_alarm_get_info(parameters, uid, &alarm_info);
+
+ g_dbus_method_invocation_return_value(
+ invoc, g_variant_new("(iiiiiiiiiiiiii)",
+ alarm_info.start.year, alarm_info.start.month,
+ alarm_info.start.day, alarm_info.start.hour,
+ alarm_info.start.min, alarm_info.start.sec,
+ alarm_info.end.year, alarm_info.end.month,
+ alarm_info.end.day, alarm_info.mode.u_interval.day_of_week,
+ alarm_info.mode.repeat, alarm_info.alarm_type,
+ alarm_info.reserved_info, ret));
+ } else if (g_strcmp0(method_name, "alarm_get_next_duetime") == 0) {
+ int duetime;
+ ret = alarm_manager_alarm_get_next_duetime(parameters, uid, &duetime);
+
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, ret));
+ } else if (g_strcmp0(method_name, "alarm_get_all_info") == 0) {
+ char *db_path = NULL;
+
+ ret = alarm_manager_alarm_get_all_info(uid, &db_path);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, ret));
+
+ if (db_path)
+ free(db_path);
+ } else if (g_strcmp0(method_name, "alarm_set_rtc_time") == 0) {
+ ret = alarm_manager_alarm_set_rtc_time(parameters);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_set_time") == 0) {
+ ret = alarm_manager_alarm_set_time(parameters);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_set_time_with_propagation_delay") == 0) {
+ ret = alarm_manager_alarm_set_time_with_propagation_delay(parameters);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_set_timezone") == 0) {
+ ret = alarm_manager_alarm_set_timezone(parameters);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_set_global") == 0) {
+ ret = alarm_manager_alarm_set_global(parameters, uid);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ret));
+ } else if (g_strcmp0(method_name, "alarm_get_global") == 0) {
+ gboolean global;
+
+ ret = alarm_manager_alarm_get_global(parameters, &global);
+ g_dbus_method_invocation_return_value(invoc, g_variant_new("(bi)", global, ret));
+ }
+}
+
+static const GDBusInterfaceVTable interface_vtable = {
+ handle_method_call,
+ NULL,
+ NULL
+};
+
+static void __on_bus_name_acquired(GDBusConnection *connection,
+ const gchar *name,
+ gpointer user_data)
+{
+ ALARM_MGR_LOG_PRINT("bus acquired(%s)", name);
+
+ guint reg_id = 0;
+ GError *error = NULL;
+
+ reg_id = g_dbus_connection_register_object(connection,
+ ALARM_MGR_DBUS_PATH,
+ introspection_data->interfaces[0],
+ &interface_vtable,
+ NULL, NULL, &error);
+ if (reg_id == 0) {
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_connection_register_object error(%s)", error->message);
+ g_error_free(error);
+ }
+}
+
+static void __on_bus_name_owner_changed(GDBusConnection *connection,
+ const gchar *sender_name,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *signal_name,
+ GVariant *parameters,
+ gpointer user_data)
+{
+ GSList *entry = NULL;
+ __expired_alarm_t *expire_info = NULL;
+ char *service_name = NULL;
+
+ /* On expiry, the killed app can be launched by aul. Then, the owner of the bus name which was registered by the app is changed.
+ * In this case, "NameOwnerChange" signal is broadcasted. */
+ if (signal_name && strcmp(signal_name, "NameOwnerChanged") == 0) {
+ g_variant_get(parameters, "(&sss)", &service_name, NULL, NULL);
+
+ for (entry = g_expired_alarm_list; entry; entry = entry->next) {
+ if (entry->data) {
+ expire_info = (__expired_alarm_t *) entry->data;
+ SECURE_LOGD("expired service(%s), owner changed service(%s)",
+ expire_info->service_name, service_name);
+
+ if (strcmp(expire_info->service_name, service_name) == 0) {
+ SECURE_LOGE("expired service name(%s) alarm_id (%d)",
+ expire_info->service_name, expire_info->alarm_id);
+ _alarm_send_noti_to_application_by_dbus(
+ expire_info->service_name,
+ expire_info->alarm_id,
+ 0,
+ expire_info->uid);
+ g_expired_alarm_list =
+ g_slist_remove(g_expired_alarm_list, entry->data);
+ g_free(expire_info);
+ }
+ }
+ }
+ }
+}
+
+bool _initialize_dbus(void)
+{
+ GDBusConnection *connection = NULL;
+ GError *error = NULL;
+ guint subsc_id;
+ guint owner_id;
+ ALARM_MGR_LOG_PRINT("__initialize_dbus Enter");
+
+ connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (connection == NULL) {
+ ALARM_MGR_EXCEPTION_PRINT("g_bus_get_sync() is failed");
+ if (error) {
+ ALARM_MGR_EXCEPTION_PRINT("dbus error message : %s", error->message);
+ g_error_free(error);
+ }
+ return false;
+ }
+
+ subsc_id = g_dbus_connection_signal_subscribe(connection,
+ "org.freedesktop.DBus", "org.freedesktop.DBus",
+ "NameOwnerChanged", "/org/freedesktop/DBus", NULL,
+ G_DBUS_SIGNAL_FLAGS_NONE, __on_bus_name_owner_changed, NULL, NULL);
+ if (subsc_id == 0) {
+ ALARM_MGR_EXCEPTION_PRINT("Subscribing to signal for invoking callback is failed.");
+ g_object_unref(connection);
+ return false;
+ }
+
+ introspection_data = g_dbus_node_info_new_for_xml(introspection_xml, &error);
+ if (!introspection_data) {
+ ALARM_MGR_EXCEPTION_PRINT("g_dbus_node_info_new_for_xml error(%s)", error->message);
+ g_object_unref(connection);
+ g_error_free(error);
+ return false;
+ }
+
+ owner_id = g_bus_own_name_on_connection(connection,
+ ALARM_MGR_DBUS_NAME, G_BUS_NAME_OWNER_FLAGS_NONE,
+ __on_bus_name_acquired, NULL, NULL, NULL);
+
+ if (owner_id == 0) {
+ ALARM_MGR_EXCEPTION_PRINT("Acquiring the own name is failed.");
+ g_dbus_node_info_unref(introspection_data);
+ g_object_unref(connection);
+ return false;
+ }
+
+ alarm_context.connection = connection;
+
+ return true;
+}
--- /dev/null
+/*
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <glib.h>
+#include <gio/gio.h>
+
+/* display lock and unlock */
+#define DEVICED_BUS_NAME "org.tizen.system.deviced"
+#define DEVICED_PATH_DISPLAY "/Org/Tizen/System/DeviceD/Display"
+#define DEVICED_INTERFACE_DISPLAY "org.tizen.system.deviced.display"
+#define DEVICED_LOCK_STATE "lockstate"
+#define DEVICED_UNLOCK_STATE "unlockstate"
+#define DEVICED_DBUS_REPLY_TIMEOUT (120*1000)
+#define DEVICED_LCD_OFF "lcdoff"
+#define DEVICED_STAY_CUR_STATE "staycurstate"
+#define DEVICED_SLEEP_MARGIN "sleepmargin"
+
+bool _initialize_dbus(void);
+
+void _alarm_send_noti_to_application_by_dbus(const char *app_service_name,
+ alarm_id_t alarm_id, int msec, uid_t uid);
+
+int _display_lock_state(char *state, char *flag, unsigned int timeout);
+int _display_unlock_state(char *state, char *flag);
+
+#ifdef __cplusplus
+}
+#endif
+
return ret;
}
+int _get_pid_from_appid(const char *app_id, uid_t uid)
+{
+ int pid;
+ pid = aul_app_get_pid_for_uid(app_id, uid);
+ if (pid < 0) {
+ ALARM_MGR_EXCEPTION_PRINT("aul_app_get_pid_for_uid() is failed. appid %s may not be app. uid : [%d]", app_id, uid);
+ return 0;
+ }
+
+ ALARM_MGR_LOG_PRINT("app_id:%s [pid:%d]", app_id, pid);
+ return pid;
+}
+
char *_get_pkgid_by_appid(const char *app_id, uid_t uid)
{
pkgmgrinfo_pkginfo_h handle;
int _compare_api_version(int *result, int pid, uid_t uid);
bool _permit_by_config(pkgmgrinfo_appinfo_h handle, uid_t uid);
bool _is_permitted(const char *app_id, int alarm_type, uid_t uid);
+int _get_pid_from_appid(const char *app_id, uid_t uid);
#ifdef __cplusplus
}
/*
- * Copyright (c) 2000 - 2017 Samsung Electronics Co., Ltd All Rights Reserved
+ * Copyright (c) 2000 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <stdlib.h>
#include <time.h>
#include <signal.h>
-#include <sys/socket.h>
#include <sys/un.h>
-#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/timerfd.h>
#include <poll.h>
#include <stdint.h>
+#include <errno.h>
+#include <linux/rtc.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
#include <tzplatform_config.h>
#include <aul.h>
#include <bundle_internal.h>
#include <vconf.h>
#include <vconf-keys.h>
-#include <dlfcn.h>
#include <package-manager.h>
#include <device/display.h>
#include <systemd/sd-login.h>
#include <notification_ipc.h>
#include <notification_internal.h>
-#include <glib.h>
-#if !GLIB_CHECK_VERSION(2, 31, 0)
-#include <glib/gmacros.h>
-#endif
-
-#include "gio/gio.h"
#include "alarm.h"
#include "alarm-internal.h"
#include "alarm-manager-db.h"
#include "alarm-manager-util.h"
-#include "alarm-mgr-stub.h"
-
+#include "alarm-manager-dbus.h"
-#define SIG_TIMER 0x32
-#define WAKEUP_ALARM_APP_ID "org.tizen.alarm.ALARM"
-/* alarm ui application's alarm's dbus_service name instead of 21
- * (alarm application's app_id) value */
+#if !GLIB_CHECK_VERSION(2, 31, 0)
+#include <glib/gmacros.h>
+#endif
-__alarm_server_context_t alarm_context;
-bool g_dummy_timer_is_set = FALSE;
+#define BILLION 1000000000 /* for calculating nano seconds */
-GSList *g_scheduled_alarm_list;
-GSList *g_expired_alarm_list;
-GSList *g_disabled_alarm_list;
+/* link path for timezone info */
+#define TIMEZONE_INFO_LINK_PATH tzplatform_mkpath(TZ_SYS_ETC, "localtime")
#ifndef RTC_WKALM_BOOT_SET
#define RTC_WKALM_BOOT_SET _IOW('p', 0x80, struct rtc_wkalrm)
#endif
-#include <errno.h>
-#include <linux/rtc.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-
-static const char default_rtc[] = "/dev/rtc";
-static int gfd = -1;
#define _APPFW_FEATURE_WAKEUP_USING_RTC (_get_profile() != PROFILE_TV)
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
static int log_fd = 0;
#endif
-/* display lock and unlock */
-#define DEVICED_BUS_NAME "org.tizen.system.deviced"
-#define DEVICED_PATH_DISPLAY "/Org/Tizen/System/DeviceD/Display"
-#define DEVICED_INTERFACE_DISPLAY "org.tizen.system.deviced.display"
-#define DEVICED_LOCK_STATE "lockstate"
-#define DEVICED_UNLOCK_STATE "unlockstate"
-#define DEVICED_DBUS_REPLY_TIMEOUT (120*1000)
-#define DEVICED_LCD_OFF "lcdoff"
-#define DEVICED_STAY_CUR_STATE "staycurstate"
-#define DEVICED_SLEEP_MARGIN "sleepmargin"
+static const char default_rtc[] = "/dev/rtc";
+static int gfd = -1;
-/* link path for timezone info */
-#define TIMEZONE_INFO_LINK_PATH tzplatform_mkpath(TZ_SYS_ETC, "localtime")
+__alarm_server_context_t alarm_context;
+bool g_dummy_timer_is_set = FALSE;
-/* GDBus Declaration */
-#define ALARM_MGR_DBUS_PATH "/org/tizen/alarm/manager"
-#define ALARM_MGR_DBUS_NAME "org.tizen.alarm.manager"
-static AlarmManager *interface;
+GSList *g_scheduled_alarm_list;
+GSList *g_expired_alarm_list;
+GSList *g_disabled_alarm_list;
bool is_time_changed = false; /* for calculating next duetime */
-
-#define BILLION 1000000000 /* for calculating nano seconds */
static time_t periodic_alarm_standard_time = 0;
static long __get_proper_interval(long interval, int alarm_type);
static bool __alarm_delete(uid_t uid, alarm_id_t alarm_id, int *error_code);
static bool __alarm_update(uid_t uid, int pid, alarm_id_t alarm_id,
alarm_info_t *alarm_info, int update_flag, int *error_code);
-static void __alarm_send_noti_to_application(const char *app_service_name, alarm_id_t alarm_id, int msec, uid_t uid);
static void __alarm_expired();
static gboolean __alarm_handler_idle(gpointer user_data);
static void __on_system_time_external_changed(keynode_t *node, void *data);
static void __initialize_scheduled_alarm_list();
static bool __initialize_noti();
-static bool __initialize_dbus();
void _release_alarm_info_t(__alarm_info_t *entry);
-void on_bus_name_owner_changed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path,
- const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data);
bool __get_caller_unique_name(int pid, char *unique_name, int size, bool *is_app, uid_t uid);
static notification_h __get_notification(guchar *data, int datalen);
static bool __save_module_log(const char *tag, const char *messgae);
#endif
-int __display_lock_state(char *state, char *flag, unsigned int timeout);
-int __display_unlock_state(char *state, char *flag);
-
int __set_time(time_t _time);
struct running_info_t {
char *unique_name;
} appid_cache_t;
+struct alarm_manager_dbus_map {
+ const char *signal_name;
+ GCallback func;
+};
+
static bool __get_cached_unique_name(int pid, char *unique_name, int size, bool *is_app, uid_t uid)
{
appid_cache_t *data = NULL;
ALARM_MGR_LOG_PRINT("Remove cached data of [%s]", target_name);
return true;
}
+
return false;
}
__alarm_info->app_unique_name = strdup(app_name);
/* caller */
- if (caller_is_app) {
+ if (caller_is_app)
__alarm_info->caller_pkgid = _get_pkgid_by_appid(app_name, uid);
- }
/* callee */
b = bundle_decode((bundle_raw *)bundle_data, strlen(bundle_data));
callee_appid = appsvc_get_appid(b);
- __alarm_info->caller_pkgid = _get_pkgid_by_appid(callee_appid, uid);
+ __alarm_info->callee_pkgid = _get_pkgid_by_appid(callee_appid, uid);
if (b && caller_is_app) {
__set_caller_info(b, pid, uid, app_name,
}
/* Get caller_appid to get caller's package id. There is no callee. */
- if (caller_is_app) {
+ if (caller_is_app)
__alarm_info->caller_pkgid = _get_pkgid_by_appid(unique_name, uid);
- }
SECURE_LOGD("caller_pkgid = %s, callee_pkgid = null", __alarm_info->caller_pkgid);
return true;
}
-static bool __can_skip_expired_cb(alarm_id_t alarm_id)
+bool _can_skip_expired_cb(alarm_id_t alarm_id)
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
return false;
}
-static gboolean __send_noti_to_session_bus(char *service_name,
- alarm_id_t alarm_id, int msec, uid_t uid)
-{
- int fd;
- int ret;
- int len;
- struct sockaddr_un saddr;
- uint8_t *data;
- GVariant *gv;
- uint8_t *gv_data;
-
- fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
- if (fd < 0)
- return FALSE;
-
- saddr.sun_family = AF_UNIX;
- snprintf(saddr.sun_path, sizeof(saddr.sun_path),
- "/run/alarm_agent/%d", uid);
-
- ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
- if (ret < 0) {
- ALARM_MGR_EXCEPTION_PRINT("connect failed - (errno %d)", errno);
- close(fd);
- return FALSE;
- }
-
- gv = g_variant_new("(iis)", alarm_id, msec, service_name);
- if (!gv) {
- close(fd);
- return FALSE;
- }
-
- len = g_variant_get_size(gv);
-
- gv_data = NULL;
- if (len > 0)
- gv_data = (uint8_t *)malloc(len);
-
- if (!gv_data) {
- g_variant_unref(gv);
- close(fd);
- return FALSE;
- }
-
- g_variant_store(gv, gv_data);
- g_variant_unref(gv);
-
- data = (uint8_t *)malloc(len + 4);
- if (!data) {
- close(fd);
- free(gv_data);
- return FALSE;
- }
-
- memcpy(data, &len, 4);
- memcpy(data + 4, gv_data, len);
- free(gv_data);
-
- if (send(fd, data, len + 4, 0) == -1) {
- ALARM_MGR_EXCEPTION_PRINT("sendto() failed (errno %d)", errno);
- free(data);
- close(fd);
- return FALSE;
- }
-
- free(data);
- close(fd);
- return TRUE;
-}
-
-static void __alarm_send_noti_to_application(const char *app_service_name,
- alarm_id_t alarm_id, int msec, uid_t uid)
-{
- char service_name[MAX_SERVICE_NAME_LEN] = {0,};
- gboolean ret;
-
- if (app_service_name == NULL || strlen(app_service_name) == 0) {
- ALARM_MGR_EXCEPTION_PRINT("This alarm destination is invalid.");
- return;
- }
-
- if (__can_skip_expired_cb(alarm_id))
- return;
-
- strncpy(service_name, app_service_name, sizeof(service_name) - 1);
- SECURE_LOGI("[alarm server][send expired_alarm(alarm_id=%d) to app_service_name(%s)]", alarm_id, service_name);
-
- if (uid >= REGULAR_UID_MIN) {
- ret = __send_noti_to_session_bus(service_name, alarm_id, msec, uid);
- if (ret != TRUE)
- ALARM_MGR_EXCEPTION_PRINT("failed to send alarm expired noti for %d, %s",
- alarm_id, service_name);
- } else {
- g_dbus_connection_call(alarm_context.connection,
- service_name,
- "/org/tizen/alarm/client",
- "org.tizen.alarm.client",
- "alarm_expired",
- g_variant_new("(iis)", alarm_id, msec, service_name),
- NULL,
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
- NULL,
- NULL);
- }
-}
-
-static uid_t __get_caller_uid(const char *name)
-{
- guint uid;
- GVariant *ret;
- GError *error = NULL;
-
- ret = g_dbus_connection_call_sync(
- alarm_context.connection,
- "org.freedesktop.DBus",
- "/org/freedesktop/DBus",
- "org.freedesktop.DBus",
- "GetConnectionUnixUser",
- g_variant_new("(s)", name),
- NULL,
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
- &error);
- if (!ret) {
- ALARM_MGR_EXCEPTION_PRINT("failed to get caller uid");
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("dbus error message : %s", error->message);
- g_error_free(error);
- }
- return -1;
- }
- g_variant_get(ret, "(u)", &uid);
- g_variant_unref(ret);
-
- return uid;
-}
-
-static pid_t __get_caller_pid(const char *name)
-{
- guint pid;
- GVariant *ret;
- GError *error = NULL;
-
- ret = g_dbus_connection_call_sync(alarm_context.connection,
- "org.freedesktop.DBus",
- "/org/freedesktop/DBus",
- "org.freedesktop.DBus",
- "GetConnectionUnixProcessID",
- g_variant_new("(s)", name),
- NULL,
- G_DBUS_CALL_FLAGS_NONE,
- -1,
- NULL,
- &error);
- if (!ret) {
- ALARM_MGR_EXCEPTION_PRINT("failed to get caller pid");
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("dbus error message : %s", error->message);
- g_error_free(error);
- }
- return -1;
- }
- g_variant_get(ret, "(u)", &pid);
- g_variant_unref(ret);
-
- return pid;
-}
-
static int __find_login_user(uid_t *uid)
{
uid_t *uids;
}
}
}
+
free(uids);
free(state);
return -1;
alarm = (__scheduled_alarm_t *)iter->data;
alarm_id = alarm->alarm_id;
__alarm_info = alarm->__alarm_info;
- app_pid = __alarm_info->pid;
+ app_pid = _get_pid_from_appid(__alarm_info->app_unique_name,
+ __alarm_info->uid);
/* Case #1. The process is an application launched by app_control.
* It registered an alarm using launch-based APIs like alarm_schedule_xxx, alarmmgr_xxx_appsvc. */
if ((__alarm_info->alarm_info.alarm_type & ALARM_TYPE_NOLAUNCH) && !aul_app_is_running(appid)) {
ALARM_MGR_EXCEPTION_PRINT("This alarm is ignored\n");
} else if (!(__alarm_info->alarm_info.alarm_type & ALARM_TYPE_INEXACT) ||
- !__can_skip_expired_cb(__alarm_info->alarm_id)) {
+ !_can_skip_expired_cb(__alarm_info->alarm_id)) {
if (__alarm_info->global) {
if (__find_login_user(&target_uid) < 0) {
ALARM_MGR_EXCEPTION_PRINT("Fail to get login user\n");
ALARM_MGR_LOG_PRINT("WAKEUP pid: %d", __alarm_info->pid);
aul_update_freezer_status(__alarm_info->pid, "wakeup");
- __alarm_send_noti_to_application(destination_app_service_name,
+ _alarm_send_noti_to_application_by_dbus(destination_app_service_name,
alarm_id, __alarm_info->alarm_info.msec, __alarm_info->uid); /* dbus auto activation */
- ALARM_MGR_LOG_PRINT("after __alarm_send_noti_to_application");
+ ALARM_MGR_LOG_PRINT("after _alarm_send_noti_to_application_by_dbus");
}
}
}
ALARM_MGR_LOG_PRINT("Lock the display not to enter LCD OFF");
- if (__display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS)
- ALARM_MGR_EXCEPTION_PRINT("__display_lock_state() is failed");
+ if (_display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS)
+ ALARM_MGR_EXCEPTION_PRINT("_display_lock_state() is failed");
if (g_dummy_timer_is_set == true) {
ALARM_MGR_LOG_PRINT("dummy alarm timer has expired.");
__rtc_set();
ALARM_MGR_LOG_PRINT("Unlock the display from LCD OFF");
- if (__display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS)
- ALARM_MGR_EXCEPTION_PRINT("__display_unlock_state() is failed");
+ if (_display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS)
+ ALARM_MGR_EXCEPTION_PRINT("_display_unlock_state() is failed");
return false;
}
}
#endif /* _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG */
-int __display_lock_state(char *state, char *flag, unsigned int timeout)
-{
- GDBusMessage *msg = NULL;
- GDBusMessage *reply = NULL;
- GVariant *body = NULL;
- int ret = ALARMMGR_RESULT_SUCCESS;
- int val = -1;
-
- msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
- if (!msg) {
- ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_LOCK_STATE);
- return ERR_ALARM_SYSTEM_FAIL;
- }
-
- g_dbus_message_set_body(msg, g_variant_new("(sssi)", state, flag, "NULL", timeout));
-
- reply = g_dbus_connection_send_message_with_reply_sync(alarm_context.connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL);
- if (!reply) {
- ALARM_MGR_EXCEPTION_PRINT("No reply. g_dbus_connection_send_message_with_reply_sync() is failed.");
- ret = ERR_ALARM_SYSTEM_FAIL;
- } else {
- body = g_dbus_message_get_body(reply);
- if (!body) {
- ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
- ret = ERR_ALARM_SYSTEM_FAIL;
- } else {
- g_variant_get(body, "(i)", &val);
- if (val != 0) {
- ALARM_MGR_EXCEPTION_PRINT("Failed to lock display");
- ret = ERR_ALARM_SYSTEM_FAIL;
- } else {
- ALARM_MGR_LOG_PRINT("Lock LCD OFF is successfully done");
- }
- }
- }
-
- g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
- g_object_unref(msg);
- if (reply)
- g_object_unref(reply);
-
- return ret;
-}
-
-int __display_unlock_state(char *state, char *flag)
-{
- GDBusMessage *msg = NULL;
- GDBusMessage *reply = NULL;
- GVariant *body = NULL;
- int ret = ALARMMGR_RESULT_SUCCESS;
- int val = -1;
-
- msg = g_dbus_message_new_method_call(DEVICED_BUS_NAME, DEVICED_PATH_DISPLAY, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
- if (!msg) {
- ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_new_method_call() is failed. (%s:%s-%s)", DEVICED_BUS_NAME, DEVICED_INTERFACE_DISPLAY, DEVICED_UNLOCK_STATE);
- return ERR_ALARM_SYSTEM_FAIL;
- }
-
- g_dbus_message_set_body(msg, g_variant_new("(ss)", state, flag));
-
- reply = g_dbus_connection_send_message_with_reply_sync(alarm_context.connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, DEVICED_DBUS_REPLY_TIMEOUT, NULL, NULL, NULL);
- if (!reply) {
- ALARM_MGR_EXCEPTION_PRINT("No reply. g_dbus_connection_send_message_with_reply_sync() is failed.");
- ret = ERR_ALARM_SYSTEM_FAIL;
- } else {
- body = g_dbus_message_get_body(reply);
- if (!body) {
- ALARM_MGR_EXCEPTION_PRINT("g_dbus_message_get_body() is failed.");
- ret = ERR_ALARM_SYSTEM_FAIL;
- } else {
- g_variant_get(body, "(i)", &val);
- if (val != 0) {
- ALARM_MGR_EXCEPTION_PRINT("Failed to unlock display");
- ret = ERR_ALARM_SYSTEM_FAIL;
- } else {
- ALARM_MGR_LOG_PRINT("Unlock LCD OFF is successfully done");
- }
- }
- }
-
- g_dbus_connection_flush_sync(alarm_context.connection, NULL, NULL);
- g_object_unref(msg);
- if (reply)
- g_object_unref(reply);
-
- return ret;
-}
-
static long __get_proper_interval(long interval, int alarm_type)
{
GSList *gs_iter = NULL;
/* Expire alarms with duetime equal to newtime by force */
if (alarm_info->due_time == time_sec) {
- if (__display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS)
- ALARM_MGR_EXCEPTION_PRINT("__display_lock_state() is failed");
+ if (_display_lock_state(DEVICED_LCD_OFF, DEVICED_STAY_CUR_STATE, 0) != ALARMMGR_RESULT_SUCCESS)
+ ALARM_MGR_EXCEPTION_PRINT("_display_lock_state() is failed");
if (g_dummy_timer_is_set == true) {
ALARM_MGR_LOG_PRINT("dummy alarm timer has expired.");
_alarm_schedule();
__rtc_set();
- if (__display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS)
- ALARM_MGR_EXCEPTION_PRINT("__display_unlock_state() is failed");
+ if (_display_unlock_state(DEVICED_LCD_OFF, DEVICED_SLEEP_MARGIN) != ALARMMGR_RESULT_SUCCESS)
+ ALARM_MGR_EXCEPTION_PRINT("_display_unlock_state() is failed");
}
return false;
return ERR_ALARM_NOT_PERMITTED_APP;
}
-gboolean alarm_manager_alarm_set_rtc_time(AlarmManager *pObj, GDBusMethodInvocation *invoc,
- int year, int mon, int day,
- int hour, int min, int sec,
- gpointer user_data) {
- int return_code = ALARMMGR_RESULT_SUCCESS;
+int alarm_manager_alarm_set_rtc_time(GVariant *parameters)
+{
/* Indentation ingored to help understand the patch. */
if (_APPFW_FEATURE_WAKEUP_USING_RTC) {
const char *rtc = default_rtc;
/*extract day of the week, day in the year & daylight saving time from system*/
time_t current_time;
char buf[1024];
+ int year, mon, day, hour, min, sec;
+ int return_code = ALARMMGR_RESULT_SUCCESS;
+
+ g_variant_get(parameters, "(iiiiii)", &year, &mon, &day, &hour, &min, &sec);
current_time = time(NULL);
alarm_tm = gmtime_r(¤t_time, &tm);
if (alarm_tm == NULL) {
ALARM_MGR_EXCEPTION_PRINT("alarm_tm is NULL");
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
+ return ERR_ALARM_SYSTEM_FAIL;
}
-
alarm_tm->tm_year = year;
alarm_tm->tm_mon = mon;
alarm_tm->tm_mday = day;
gfd = open(rtc, O_RDWR);
if (gfd < 0) {
ALARM_MGR_EXCEPTION_PRINT("RTC open failed.");
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
+ return ERR_ALARM_SYSTEM_FAIL;
}
}
snprintf(log_message, sizeof(log_message), "wakeup rtc time: %d, %s", (int)rtc_time, ctime(&rtc_time));
__save_module_log(log_tag, log_message);
#endif
+ return return_code;
} else {
ALARM_MGR_LOG_PRINT("[alarm-server] RTC does not work.");
- return_code = ERR_ALARM_SYSTEM_FAIL;
+ return ERR_ALARM_SYSTEM_FAIL;
}
-
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
}
static int accrue_msec = 0; /* To check a millisecond part of current time at changing the system time(sec) */
-gboolean alarm_manager_alarm_set_time(AlarmManager *pObj, GDBusMethodInvocation *invoc, int time_sec, gpointer user_data)
+int alarm_manager_alarm_set_time(GVariant* parameters)
{
double diff_time = 0.0;
struct timeval cur_time = {0,};
- int return_code = ALARMMGR_RESULT_SUCCESS;
+ int time_sec;
+
+ g_variant_get(parameters, "(i)", &time_sec);
_alarm_disable_timer(alarm_context); /* Disable the timer to reschedule the alarm before the time is changed. */
cur_time.tv_sec, time_sec, ctime((const time_t *)&time_sec), diff_time);
__reschedule_alarms_with_newtime(cur_time.tv_sec, time_sec, diff_time);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
+ return ALARMMGR_RESULT_SUCCESS;;
}
-gboolean alarm_manager_alarm_set_time_with_propagation_delay(AlarmManager *pObj, GDBusMethodInvocation *invoc,
- guint new_sec, guint new_nsec, guint req_sec, guint req_nsec, gpointer user_data)
+int alarm_manager_alarm_set_time_with_propagation_delay(GVariant* parameters)
{
double diff_time = 0.0;
struct timespec cur_time = {0,};
struct timespec sleep_time = {0,};
guint real_newtime = 0;
accrue_msec = 0; /* reset accrued msec */
+ guint new_sec, new_nsec, req_sec, req_nsec;
+
+ g_variant_get(parameters, "(uuuu)", &new_sec, &new_nsec, &req_sec, &req_nsec);
_alarm_disable_timer(alarm_context); /* Disable the timer to reschedule the alarm before the time is changed. */
if (req_sec > cur_time.tv_sec || (req_sec == cur_time.tv_sec && req_nsec > cur_time.tv_nsec)) {
ALARM_MGR_EXCEPTION_PRINT("The requeted time(%d.%09d) must be equal to or less than current time(%ld.%09ld).",
req_sec, req_nsec, cur_time.tv_sec, cur_time.tv_nsec);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ERR_ALARM_INVALID_PARAM));
- return true;
+ return ERR_ALARM_INVALID_PARAM;
}
/* Compensate propagation delay */
cur_time.tv_sec, cur_time.tv_nsec, new_sec, new_nsec, real_newtime, diff_time);
ALARM_MGR_LOG_PRINT("Requested(%d.%09d) Delay(%ld.%09ld) Sleep(%09ld)", req_sec, req_nsec, delay.tv_sec, delay.tv_nsec, sleep_time.tv_nsec);
__reschedule_alarms_with_newtime(cur_time.tv_sec, real_newtime, diff_time);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", ALARMMGR_RESULT_SUCCESS));
- return true;
+ return ALARMMGR_RESULT_SUCCESS;
}
-gboolean alarm_manager_alarm_set_timezone(AlarmManager *pObject, GDBusMethodInvocation *invoc, char *tzpath_str, gpointer user_data)
+int alarm_manager_alarm_set_timezone(GVariant* parameters)
{
int retval = 0;
int return_code = ALARMMGR_RESULT_SUCCESS;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
+ char *tzpath_str;
+
+ g_variant_get(parameters, "(&s)", &tzpath_str);
ALARM_MGR_LOG_PRINT("[TIMESTAMP]Set the timezone to %s.", tzpath_str);
bundle_free(b);
done:
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
if (return_code == ALARMMGR_RESULT_SUCCESS)
strncpy(log_tag, "SET TIMEZONE", sizeof(log_tag) - 1);
__save_module_log(log_tag, log_message);
#endif
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_create_appsvc(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- int start_year,
- int start_month, int start_day,
- int start_hour, int start_min,
- int start_sec, int end_year, int end_month,
- int end_day, int mode_day_of_week,
- unsigned int mode_interval,
- int mode_repeat, int alarm_type,
- int reserved_info,
- char *bundle_data,
- gpointer user_data)
+int alarm_manager_alarm_create_appsvc(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
{
alarm_info_t alarm_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
- int alarm_id = 0;
+ int _alarm_id = 0;
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
- uid_t uid;
- pid_t pid;
int result;
bundle *b;
const char *callee_appid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ int start_year, start_month, start_day, start_hour, start_min, start_sec;
+ int end_year, end_month, end_day;
+ int mode_day_of_week, mode_interval, mode_repeat, alarm_type, reserved_info;
+ char *bundle_data;
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
- return true;
- }
+ *alarm_id = _alarm_id;
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(iiiiiiiiiiiiii&s)",
+ &start_year, &start_month, &start_day, &start_hour, &start_min,
+ &start_sec, &end_year, &end_month, &end_day, &mode_day_of_week,
+ &mode_interval, &mode_repeat, &alarm_type, &reserved_info, &bundle_data);
b = bundle_decode((bundle_raw *)bundle_data, strlen(bundle_data));
if (b == NULL) {
int ret_bundle = get_last_result();
ALARM_MGR_EXCEPTION_PRINT("Failed to decode bundle_data[Error:%d]\n", ret_bundle);
return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
- return true;
+ return return_code;
} else {
callee_appid = appsvc_get_appid(b);
if (_compare_api_version(&result, pid, uid) < 0) {
ALARM_MGR_EXCEPTION_PRINT("Unable to check api version\n");
return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
bundle_free(b);
- return true;
+ return return_code;
}
if (result < 0) {
if (!_is_permitted(callee_appid, alarm_type, uid)) {
ALARM_MGR_EXCEPTION_PRINT("[%s] is not permitted \n", callee_appid);
return_code = ERR_ALARM_NOT_PERMITTED_APP;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
bundle_free(b);
- return true;
+ return return_code;
}
}
bundle_free(b);
}
-
alarm_info.start.year = start_year;
alarm_info.start.month = start_month;
alarm_info.start.day = start_day;
alarm_info.mode.u_interval.interval = 0;
}
- if (!__alarm_create_appsvc(&alarm_info, &alarm_id, mode_interval, uid, pid, bundle_data, &return_code)) {
+ if (!__alarm_create_appsvc(&alarm_info, &_alarm_id, mode_interval, uid, pid, bundle_data, &return_code)) {
ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "FAIL: CREATE", sizeof(log_tag) - 1);
#endif
+ return_code = ERR_ALARM_SYSTEM_FAIL;
} else {
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "CREATE", sizeof(log_tag) - 1);
#endif
+ *alarm_id = _alarm_id;
+ return_code = ALARMMGR_RESULT_SUCCESS;
}
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
-
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
- alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
+ *alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
__save_module_log(log_tag, log_message);
#endif
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_create_noti(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- int start_year,
- int start_month, int start_day,
- int start_hour, int start_min,
- int start_sec, int end_year, int end_month,
- int end_day, int mode_day_of_week,
- unsigned int mode_interval,
- int mode_repeat, int alarm_type,
- int reserved_info,
- char *noti_data,
- gpointer user_data)
+int alarm_manager_alarm_create_noti(GVariant *parameters, uid_t uid, pid_t pid,
+ int *alarm_id)
{
alarm_info_t alarm_info;
- int ret;
int return_code = ALARMMGR_RESULT_SUCCESS;
- int alarm_id = 0;
+ int _alarm_id = 0;
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
- const char *notification_priv = "http://tizen.org/privilege/notification";
-
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
- return true;
- }
+ int start_year, start_month, start_day, start_hour, start_min, start_sec;
+ int end_year, end_month, end_day;
+ int mode_day_of_week, mode_interval, mode_repeat, alarm_type, reserved_info;
+ char *noti_data;
- ret = _cynara_check(invoc, notification_priv, pid);
- if (ret != ALARMMGR_RESULT_SUCCESS) {
- return_code = ret;
+ *alarm_id = _alarm_id;
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
- return true;
- }
+ g_variant_get(parameters, "(iiiiiiiiiiiiii&s)",
+ &start_year, &start_month, &start_day, &start_hour, &start_min,
+ &start_sec, &end_year, &end_month, &end_day, &mode_day_of_week,
+ &mode_interval, &mode_repeat, &alarm_type, &reserved_info, ¬i_data);
alarm_info.start.year = start_year;
alarm_info.start.month = start_month;
alarm_info.mode.u_interval.interval = 0;
}
- if (!__alarm_create_noti(&alarm_info, &alarm_id, mode_interval, uid, pid, noti_data, &return_code)) {
+ if (!__alarm_create_noti(&alarm_info, &_alarm_id, mode_interval, uid, pid, noti_data, &return_code)) {
ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "FAIL: CREATE", sizeof(log_tag) - 1);
#endif
+ return_code = ERR_ALARM_SYSTEM_FAIL;
} else {
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "CREATE", sizeof(log_tag) - 1);
#endif
+ return_code = ALARMMGR_RESULT_SUCCESS;
+ *alarm_id = _alarm_id;
}
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
-
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
- alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
+ *alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
__save_module_log(log_tag, log_message);
#endif
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_create(AlarmManager *obj, GDBusMethodInvocation *invoc,
- char *app_service_name, char *app_service_name_mod, int start_year,
- int start_month, int start_day,
- int start_hour, int start_min,
- int start_sec, int msec, int end_year, int end_month,
- int end_day, int mode_day_of_week,
- int mode_repeat, int alarm_type,
- int reserved_info,
- char *reserved_service_name, char *reserved_service_name_mod,
- gpointer user_data)
+int alarm_manager_alarm_create(GVariant *parameters, uid_t uid, pid_t pid, int *alarm_id)
{
alarm_info_t alarm_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
- int alarm_id = 0;
+ int _alarm_id = 0;
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
char *_reserved_service_name = NULL;
char *_reserved_service_name_mod = NULL;
- pid = __get_caller_pid(name);
- uid = __get_caller_uid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
- return true;
- }
+ char *app_service_name = NULL;
+ char *app_service_name_mod = NULL;
+ int start_year, start_month, start_day, start_hour, start_min, start_sec;
+ int msec, end_year, end_month, end_day;
+ int mode_day_of_week, mode_repeat, alarm_type, reserved_info;
+ char *reserved_service_name = NULL;
+ char *reserved_service_name_mod = NULL;
+
+ *alarm_id = _alarm_id;
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(&s&siiiiiiiiiiiiii&s&s)",
+ &app_service_name, &app_service_name_mod,
+ &start_year, &start_month, &start_day, &start_hour, &start_min,
+ &start_sec, &msec, &end_year, &end_month, &end_day,
+ &mode_day_of_week, &mode_repeat, &alarm_type, &reserved_info,
+ &reserved_service_name, &reserved_service_name_mod);
alarm_info.start.year = start_year;
alarm_info.start.month = start_month;
if (strcmp(reserved_service_name_mod, "null") == 0)
_reserved_service_name_mod = NULL;
- if (!__alarm_create(&alarm_info, &alarm_id, uid, pid, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
+ if (!__alarm_create(&alarm_info, &_alarm_id, uid, pid, QUANTUMIZE, 0, 0, app_service_name, app_service_name_mod,
_reserved_service_name, _reserved_service_name_mod, &return_code)) {
ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "FAIL: CREATE", sizeof(log_tag) - 1);
#endif
+ return_code = ERR_ALARM_SYSTEM_FAIL;
} else {
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "CREATE", sizeof(log_tag) - 1);
#endif
+ return_code = ALARMMGR_RESULT_SUCCESS;
+ *alarm_id = _alarm_id;
}
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
-
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
- alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
+ *alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
__save_module_log(log_tag, log_message);
#endif
- return true;
+ return return_code;
}
time_t _get_periodic_alarm_standard_time(void)
return periodic_alarm_standard_time;
}
-gboolean alarm_manager_alarm_create_periodic(AlarmManager *obj, GDBusMethodInvocation *invoc,
- char *app_service_name, char *app_service_name_mod, int interval,
- int is_ref, int method, gpointer user_data)
+int alarm_manager_alarm_create_periodic(GVariant *parameters, uid_t uid,
+ pid_t pid, int *alarm_id)
{
alarm_info_t alarm_info;
int return_code = ALARMMGR_RESULT_SUCCESS;
- int alarm_id = 0;
+ int _alarm_id = 0;
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ char *app_service_name = NULL;
+ char *app_service_name_mod = NULL;
+ int interval, is_ref, method;
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", alarm_id, return_code));
- return true;
- }
+ *alarm_id = _alarm_id;
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(&s&siii)", &app_service_name,
+ &app_service_name_mod, &interval, &is_ref, &method);
struct tm standard_tm;
time_t standard_time = _get_periodic_alarm_standard_time();
alarm_info.mode.u_interval.interval = __get_proper_interval(interval * 60, alarm_info.alarm_type);
}
- if (!__alarm_create(&alarm_info, &alarm_id, uid, pid, (periodic_method_e)method, interval * 60, is_ref,
+ if (!__alarm_create(&alarm_info, &_alarm_id, uid, pid, (periodic_method_e)method, interval * 60, is_ref,
app_service_name, app_service_name_mod,
NULL, NULL, &return_code)) {
ALARM_MGR_EXCEPTION_PRINT("Unable to create alarm! return_code[%d]", return_code);
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "FAIL: CREATE", sizeof(log_tag) - 1);
#endif
+ return_code = ERR_ALARM_SYSTEM_FAIL;
} else {
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "CREATE", sizeof(log_tag) - 1);
#endif
+ return_code = ALARMMGR_RESULT_SUCCESS;
+ *alarm_id = _alarm_id;
}
- g_dbus_method_invocation_return_value(invoc,
- g_variant_new("(ii)", alarm_id, return_code));
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
- alarm_id, uid, pid, alarm_info.start.year, alarm_info.start.month,
+ *alarm_id, uid, pid, alarm_info.start.year, alarm_info.start.month,
alarm_info.start.day, alarm_info.start.hour,
alarm_info.start.min, alarm_info.start.sec);
__save_module_log(log_tag, log_message);
#endif
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_delete(AlarmManager *obj, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id, gpointer user_data)
+int alarm_manager_alarm_delete(GVariant *parameters, uid_t uid, pid_t pid)
{
int return_code = ALARMMGR_RESULT_SUCCESS;
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ int alarm_id;
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
- }
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(i)", &alarm_id);
return_code = __check_modifiable(uid, pid, alarm_id);
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
- }
+ if (return_code != ALARMMGR_RESULT_SUCCESS)
+ return return_code;
if (!__alarm_delete(uid, alarm_id, &return_code)) {
ALARM_MGR_EXCEPTION_PRINT("Unable to delete the alarm! alarm_id[%d], return_code[%d]", alarm_id, return_code);
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "FAIL: DELETE", sizeof(log_tag) - 1);
#endif
+ return_code = ERR_ALARM_SYSTEM_FAIL;
} else {
ALARM_MGR_LOG_PRINT("alarm_id[%d] is removed.", alarm_id);
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
strncpy(log_tag, "DELETE", sizeof(log_tag) - 1);
#endif
+ return_code = ALARMMGR_RESULT_SUCCESS;
}
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
-
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d", alarm_id, uid, pid);
__save_module_log(log_tag, log_message);
#endif
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_delete_all(AlarmManager *obj, GDBusMethodInvocation *invoc,
- gpointer user_data)
+int alarm_manager_alarm_delete_all(GVariant *parameters, uid_t uid, pid_t pid)
{
GSList *gs_iter = NULL;
char app_name[512] = { 0 };
alarm_info_t *alarm_info = NULL;
__alarm_info_t *entry = NULL;
bool is_deleted = false;
- int return_code = ALARMMGR_RESULT_SUCCESS;
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
- }
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
snprintf(log_message, sizeof(log_message), "pid: %d. Can not get the unique_name.", pid);
__save_module_log("FAIL: DELETE ALL", log_message);
#endif
- return true;
+ return ERR_ALARM_SYSTEM_FAIL;
}
SECURE_LOGD("Called by process (pid:%d, unique_name=%s)", pid, app_name);
#endif
__rtc_set();
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
+ return ALARMMGR_RESULT_SUCCESS;
}
-gboolean alarm_manager_alarm_update(AlarmManager *pObj, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id,
- int start_year, int start_month,
- int start_day, int start_hour,
- int start_min, int start_sec, int end_year,
- int end_month, int end_day,
- int mode_interval,
- int mode_repeat,
- int alarm_type, int reserved_info,
- int update_flag,
- gpointer user_data)
+int alarm_manager_alarm_update(GVariant *parameters, uid_t uid, pid_t pid)
{
int return_code = ALARMMGR_RESULT_SUCCESS;
alarm_info_t alarm_info;
char log_tag[ALARMMGR_LOG_TAG_SIZE] = {0,};
char log_message[ALARMMGR_LOG_MESSAGE_SIZE] = {0,};
#endif
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ int alarm_id;
+ int start_year, start_month, start_day, start_hour, start_min, start_sec;
+ int end_year, end_month, end_day;
+ int mode_interval, mode_repeat, alarm_type, reserved_info, update_flag;
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
- }
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(iiiiiiiiiiiiiii)",
+ &alarm_id, &start_year, &start_month, &start_day, &start_hour,
+ &start_min, &start_sec, &end_year, &end_month, &end_day,
+ &mode_interval, &mode_repeat, &alarm_type, &reserved_info,
+ &update_flag);
return_code = __check_modifiable(uid, pid, alarm_id);
- if (return_code != ALARMMGR_RESULT_SUCCESS) {
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
- }
+ if (return_code != ALARMMGR_RESULT_SUCCESS)
+ return return_code;
alarm_info.start.year = start_year;
alarm_info.start.month = start_month;
#endif
}
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
-
#ifdef _APPFW_FEATURE_ALARM_MANAGER_MODULE_LOG
snprintf(log_message, sizeof(log_message), "alarmID: %d, uid: %d, pid: %d, duetime: %d-%d-%d %02d:%02d:%02d",
alarm_id, uid, pid, start_year, start_month, start_day, start_hour, start_min, start_sec);
__save_module_log(log_tag, log_message);
#endif
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_get_number_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- gpointer user_data)
+int alarm_manager_alarm_get_number_of_ids(uid_t uid, pid_t pid, int *num_of_ids)
{
GSList *gs_iter = NULL;
char app_name[256] = { 0 };
__alarm_info_t *entry = NULL;
- int num_of_ids = 0;
- int return_code = ALARMMGR_RESULT_SUCCESS;
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ int _num_of_ids = 0;
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
- return true;
- }
+ *num_of_ids = _num_of_ids;
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
- return true;
- }
+ if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false)
+ return ERR_ALARM_SYSTEM_FAIL;
SECURE_LOGD("Called by process (uid:%d, pid:%d, unique_name:%s)", uid, pid, app_name);
SECURE_LOGD("app_name=%s, app_unique_name=%s", app_name, entry->app_unique_name);
if (entry->uid == uid &&
strncmp(app_name, entry->app_unique_name, strlen(app_name)) == 0) {
- (num_of_ids)++;
- SECURE_LOGD("inc number of alarms of app (uid:%d, pid:%d, unique_name:%s) is %d.", uid, pid, app_name, num_of_ids);
+ (_num_of_ids)++;
+ SECURE_LOGD("inc number of alarms of app (uid:%d, pid:%d, unique_name:%s) is %d.", uid, pid, app_name, _num_of_ids);
}
}
- SECURE_LOGD("number of alarms of the process (uid:%d, pid:%d, unique_name:%s) is %d.", uid, pid, app_name, num_of_ids);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", num_of_ids, return_code));
- return true;
+ SECURE_LOGD("number of alarms of the process (uid:%d, pid:%d, unique_name:%s) is %d.", uid, pid, app_name, _num_of_ids);
+ *num_of_ids = _num_of_ids;
+ return ALARMMGR_RESULT_SUCCESS;
}
-gboolean alarm_manager_alarm_get_list_of_ids(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- int max_number_of_ids, gpointer user_data)
+int alarm_manager_alarm_get_list_of_ids(GVariant *parameters, uid_t uid,
+ pid_t pid, GVariant **alarm_array, int *num_of_alarm)
{
GSList *gs_iter = NULL;
char app_name[512] = { 0 };
__alarm_info_t *entry = NULL;
int index = 0;
- GVariant *arr = NULL;
+ int max_number_of_ids;
GVariantBuilder *builder = NULL;
- int num_of_ids = 0;
- int return_code = ALARMMGR_RESULT_SUCCESS;
- uid_t uid;
- pid_t pid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
- uid = __get_caller_uid(name);
- pid = __get_caller_pid(name);
- if (uid < 0 || pid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
- return true;
- }
+ *alarm_array = g_variant_new("ai", NULL);
+
+ if (uid < 0 || pid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(i)", &max_number_of_ids);
if (max_number_of_ids <= 0) {
SECURE_LOGE("called for uid(%d) pid(%d), but max_number_of_ids(%d) is less than 0.", uid, pid, max_number_of_ids);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
- return true;
+ *num_of_alarm = 0;
+ return ALARMMGR_RESULT_SUCCESS;
}
- if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", g_variant_new("ai", NULL), num_of_ids, return_code));
- return true;
- }
+ if (__get_cached_unique_name(pid, app_name, sizeof(app_name), NULL, uid) == false)
+ return ERR_ALARM_SYSTEM_FAIL;
SECURE_LOGD("Called by process (uid: %d, pid:%d, unique_name=%s).", uid, pid, app_name);
-
builder = g_variant_builder_new(G_VARIANT_TYPE("ai"));
+
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
entry = (__alarm_info_t*)gs_iter->data;
if (entry->uid == uid &&
}
}
- arr = g_variant_new("ai", builder);
- num_of_ids = index;
-
- SECURE_LOGE("Called by uid (%d), pid (%d), but max_number_of_ids(%d) return code %d.", uid, pid, num_of_ids, return_code);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(@aiii)", arr, num_of_ids, return_code));
+ *alarm_array = g_variant_new("ai", builder);
+ *num_of_alarm = index;
g_variant_builder_unref(builder);
- return true;
+ SECURE_LOGE("Called by uid (%d), pid (%d), but max_number_of_ids(%d).", uid, pid, index);
+
+ return ALARMMGR_RESULT_SUCCESS;
}
-gboolean alarm_manager_alarm_get_appsvc_info(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id, gpointer user_data)
+int alarm_manager_alarm_get_appsvc_info(GVariant *parameters, uid_t uid, gchar **b_data)
{
bool found = false;
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
int return_code = ALARMMGR_RESULT_SUCCESS;
- gchar *b_data = NULL;
- uid_t uid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ int alarm_id;
- uid = __get_caller_uid(name);
- if (uid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
- return true;
- }
+ if (uid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(i)", &alarm_id);
SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
entry = (__alarm_info_t*)gs_iter->data;
if (entry->uid == uid && entry->alarm_id == alarm_id) {
found = true;
- b_data = g_strdup(entry->bundle);
+ *b_data = g_strdup(entry->bundle);
break;
}
}
if (found) {
- if (b_data == NULL) {
+ if (*b_data == NULL) {
ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is an regular alarm, not svc alarm.", alarm_id);
return_code = ERR_ALARM_INVALID_TYPE;
}
return_code = ERR_ALARM_INVALID_ID;
}
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", b_data, return_code));
- g_free(b_data);
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_get_noti_info(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id, gpointer user_data)
+int alarm_manager_alarm_get_noti_info(GVariant *parameters, uid_t uid, gchar **noti_data)
{
bool found = false;
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
int return_code = ALARMMGR_RESULT_SUCCESS;
- gchar *noti_data = NULL;
- uid_t uid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ int alarm_id;
- uid = __get_caller_uid(name);
- if (uid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", noti_data, return_code));
- return true;
- }
+ if (uid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(i)", &alarm_id);
SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
entry = (__alarm_info_t*)gs_iter->data;
if (entry->uid == uid && entry->alarm_id == alarm_id) {
found = true;
- noti_data = strdup(entry->noti);
+ *noti_data = strdup(entry->noti);
break;
}
}
if (found) {
- if (noti_data == NULL) {
+ if (*noti_data == NULL) {
ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is an regular alarm, not svc alarm.", alarm_id);
return_code = ERR_ALARM_INVALID_TYPE;
}
return_code = ERR_ALARM_INVALID_ID;
}
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", noti_data, return_code));
- g_free(noti_data);
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_get_info(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id, gpointer user_data)
+int alarm_manager_alarm_get_info(GVariant *parameters, uid_t uid, alarm_info_t *alarm_info)
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
- alarm_info_t *alarm_info = NULL;
- int return_code = ALARMMGR_RESULT_SUCCESS;
- uid_t uid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ alarm_info_t *_alarm_info = NULL;
+ int alarm_id;
- uid = __get_caller_uid(name);
- if (uid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, return_code));
- return true;
- }
+ if (uid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(i)", &alarm_id);
SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
entry = (__alarm_info_t*)gs_iter->data;
if (entry->uid == uid && entry->alarm_id == alarm_id) {
- alarm_info = &(entry->alarm_info);
+ _alarm_info = &(entry->alarm_info);
break;
}
}
- if (alarm_info == NULL) {
+ if (_alarm_info == NULL) {
ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
- return_code = ERR_ALARM_INVALID_ID;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, return_code));
+ return ERR_ALARM_INVALID_ID;
} else {
ALARM_MGR_LOG_PRINT("The alarm(%d) is found.", alarm_id);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(iiiiiiiiiiiiii)", alarm_info->start.year, alarm_info->start.month,
- alarm_info->start.day, alarm_info->start.hour, alarm_info->start.min, alarm_info->start.sec, alarm_info->end.year, alarm_info->end.month,
- alarm_info->end.day, alarm_info->mode.u_interval.day_of_week, alarm_info->mode.repeat, alarm_info->alarm_type, alarm_info->reserved_info, return_code));
+ alarm_info->start.year = _alarm_info->start.year;
+ alarm_info->start.month = _alarm_info->start.month;
+ alarm_info->start.day = _alarm_info->start.day;
+ alarm_info->start.hour = _alarm_info->start.hour;
+ alarm_info->start.min = _alarm_info->start.min;
+ alarm_info->start.sec = _alarm_info->start.sec;
+ alarm_info->end.year = _alarm_info->end.year;
+ alarm_info->end.month = _alarm_info->end.month;
+ alarm_info->end.day = _alarm_info->end.day;
+ alarm_info->mode.u_interval.day_of_week =
+ _alarm_info->mode.u_interval.day_of_week;
+ alarm_info->mode.repeat = _alarm_info->mode.repeat;
+ alarm_info->alarm_type = _alarm_info->alarm_type;
+ alarm_info->reserved_info = _alarm_info->reserved_info;
}
- return true;
+ return ALARMMGR_RESULT_SUCCESS;
}
-gboolean alarm_manager_alarm_get_next_duetime(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id, gpointer user_data)
+int alarm_manager_alarm_get_next_duetime(GVariant *parameters, uid_t uid, int *duetime)
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
__alarm_info_t *find_item = NULL;
- int return_code = ALARMMGR_RESULT_SUCCESS;
- time_t duetime = 0;
- uid_t uid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
+ time_t _duetime = 0;
+ int alarm_id;
- uid = __get_caller_uid(name);
- if (uid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
- return true;
- }
+ if (uid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(i)", &alarm_id);
SECURE_LOGD("called for alarm_id(%d)\n", alarm_id);
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
if (find_item == NULL) {
ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
- return_code = ERR_ALARM_INVALID_ID;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
- return true;
+ return ERR_ALARM_INVALID_ID;
}
- duetime = _alarm_next_duetime(find_item);
- ALARM_MGR_LOG_PRINT("Next duetime : %s", ctime(&duetime));
+ _duetime = _alarm_next_duetime(find_item);
+ ALARM_MGR_LOG_PRINT("Next duetime : %s", ctime(&_duetime));
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(ii)", duetime, return_code));
- return true;
+ *duetime = (int)_duetime;
+ return ALARMMGR_RESULT_SUCCESS;
}
-gboolean alarm_manager_alarm_get_all_info(AlarmManager *pObject, GDBusMethodInvocation *invoc, gpointer user_data)
+int alarm_manager_alarm_get_all_info(uid_t uid, char **db_path)
{
- int return_code = ALARMMGR_RESULT_SUCCESS;
- uid_t uid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
- char *db_path = NULL;
-
- uid = __get_caller_uid(name);
- if (uid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", NULL, return_code));
- return true;
- }
-
- return_code = _get_db_path_for_all_info(uid, &db_path);
-
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(si)", db_path, return_code));
-
- if (db_path)
- free(db_path);
+ if (uid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
- return true;
+ return _get_db_path_for_all_info(uid, &(*db_path));
}
-gboolean alarm_manager_alarm_set_global(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id, bool global, gpointer user_data)
+int alarm_manager_alarm_set_global(GVariant *parameters, uid_t uid)
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
alarm_info_t *alarm_info = NULL;
int retval = 0;
int return_code = ALARMMGR_RESULT_SUCCESS;
- uid_t uid;
- const char *name = g_dbus_method_invocation_get_sender(invoc);
char *callee_pkgid;
+ int alarm_id;
+ gboolean global;
- uid = __get_caller_uid(name);
- if (uid < 0) {
- return_code = ERR_ALARM_SYSTEM_FAIL;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
- return true;
- }
+ if (uid < 0)
+ return ERR_ALARM_SYSTEM_FAIL;
+
+ g_variant_get(parameters, "(ib)", &alarm_id, &global);
SECURE_LOGD("called for uid(%d), alarm_id(%d)\n", uid, alarm_id);
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
if (alarm_info == NULL) {
ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
- return_code = ERR_ALARM_INVALID_ID;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
+ return ERR_ALARM_INVALID_ID;
} else {
ALARM_MGR_LOG_PRINT("The alarm(%d) is found.", alarm_id);
retval = _pkg_is_global(callee_pkgid, uid);
if (retval == ALARMMGR_RESULT_SUCCESS) {
- entry->global = global;
- if (!_alarm_set_global_to_db(entry, global))
+ entry->global = (bool)global;
+ if (!_alarm_set_global_to_db(entry, (bool)global))
return_code = ERR_ALARM_SYSTEM_FAIL;
} else {
ALARM_MGR_EXCEPTION_PRINT("Get pkginfo error [%d]", retval);
return_code = retval;
}
-
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(i)", return_code));
}
- return true;
+ return return_code;
}
-gboolean alarm_manager_alarm_get_global(AlarmManager *pObject, GDBusMethodInvocation *invoc,
- alarm_id_t alarm_id, gpointer user_data)
+int alarm_manager_alarm_get_global(GVariant *parameters, gboolean *global)
{
GSList *gs_iter = NULL;
__alarm_info_t *entry = NULL;
__alarm_info_t *find_item = NULL;
- int return_code = ALARMMGR_RESULT_SUCCESS;
- bool global = false;
+ int alarm_id;
+
+ g_variant_get(parameters, "(i)", &alarm_id);
+ *global = false;
SECURE_LOGD("called for alarm_id(%d)\n", alarm_id);
for (gs_iter = alarm_context.alarms; gs_iter != NULL; gs_iter = g_slist_next(gs_iter)) {
entry = (__alarm_info_t*)gs_iter->data;
if (find_item == NULL) {
ALARM_MGR_EXCEPTION_PRINT("The alarm(%d) is not found.", alarm_id);
- return_code = ERR_ALARM_INVALID_ID;
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(bi)", global, return_code));
- return true;
+ return ERR_ALARM_INVALID_ID;
}
- global = find_item->global;
- ALARM_MGR_LOG_PRINT("Is global : %d", global);
+ *global = (gboolean)find_item->global;
+ ALARM_MGR_LOG_PRINT("Is global : %d", *global);
- g_dbus_method_invocation_return_value(invoc, g_variant_new("(bi)", global, return_code));
- return true;
+ return ALARMMGR_RESULT_SUCCESS;
}
-
static void __timer_glib_finalize(GSource *src)
{
GSList *fd_list;
return true;
}
-void on_bus_name_owner_changed(GDBusConnection *connection,
- const gchar *sender_name,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *signal_name,
- GVariant *parameters,
- gpointer user_data)
-{
- GSList *entry = NULL;
- __expired_alarm_t *expire_info = NULL;
- char *service_name = NULL;
-
- /* On expiry, the killed app can be launched by aul. Then, the owner of the bus name which was registered by the app is changed.
- * In this case, "NameOwnerChange" signal is broadcasted. */
- if (signal_name && strcmp(signal_name , "NameOwnerChanged") == 0) {
- g_variant_get(parameters, "(sss)", &service_name, NULL, NULL);
-
- for (entry = g_expired_alarm_list; entry; entry = entry->next) {
- if (entry->data) {
- expire_info = (__expired_alarm_t *) entry->data;
- SECURE_LOGD("expired service(%s), owner changed service(%s)", expire_info->service_name, service_name);
-
- if (strcmp(expire_info->service_name, service_name) == 0) {
- SECURE_LOGE("expired service name(%s) alarm_id (%d)", expire_info->service_name, expire_info->alarm_id);
- __alarm_send_noti_to_application(expire_info->service_name, expire_info->alarm_id, 0, expire_info->uid);
- g_expired_alarm_list = g_slist_remove(g_expired_alarm_list, entry->data);
- g_free(expire_info);
- }
- }
- }
- g_free(service_name);
- }
-}
-
-static bool __initialize_dbus()
-{
- GDBusConnection *connection = NULL;
- GError *error = NULL;
- guint subsc_id;
- ALARM_MGR_LOG_PRINT("__initialize_dbus Enter");
-
- connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
- if (connection == NULL) {
- ALARM_MGR_EXCEPTION_PRINT("g_bus_get_sync() is failed");
- if (error) {
- ALARM_MGR_EXCEPTION_PRINT("dbus error message : %s", error->message);
- g_error_free(error);
- }
- return false;
- }
-
- interface = alarm_manager_skeleton_new();
- if (interface == NULL) {
- ALARM_MGR_EXCEPTION_PRINT("Creating a skeleton object is failed.");
- g_object_unref(connection);
- return false;
- }
-
- g_signal_connect(interface, "handle_alarm_create", G_CALLBACK(alarm_manager_alarm_create), NULL);
- g_signal_connect(interface, "handle_alarm_create_periodic", G_CALLBACK(alarm_manager_alarm_create_periodic), NULL);
- g_signal_connect(interface, "handle_alarm_create_appsvc", G_CALLBACK(alarm_manager_alarm_create_appsvc), NULL);
- g_signal_connect(interface, "handle_alarm_create_noti", G_CALLBACK(alarm_manager_alarm_create_noti), NULL);
- g_signal_connect(interface, "handle_alarm_delete", G_CALLBACK(alarm_manager_alarm_delete), NULL);
- g_signal_connect(interface, "handle_alarm_delete_all", G_CALLBACK(alarm_manager_alarm_delete_all), NULL);
- g_signal_connect(interface, "handle_alarm_get_appsvc_info", G_CALLBACK(alarm_manager_alarm_get_appsvc_info), NULL);
- g_signal_connect(interface, "handle_alarm_get_info", G_CALLBACK(alarm_manager_alarm_get_info), NULL);
- g_signal_connect(interface, "handle_alarm_get_noti_info", G_CALLBACK(alarm_manager_alarm_get_noti_info), NULL);
- g_signal_connect(interface, "handle_alarm_get_list_of_ids", G_CALLBACK(alarm_manager_alarm_get_list_of_ids), NULL);
- g_signal_connect(interface, "handle_alarm_get_next_duetime", G_CALLBACK(alarm_manager_alarm_get_next_duetime), NULL);
- g_signal_connect(interface, "handle_alarm_get_number_of_ids", G_CALLBACK(alarm_manager_alarm_get_number_of_ids), NULL);
- g_signal_connect(interface, "handle_alarm_set_rtc_time", G_CALLBACK(alarm_manager_alarm_set_rtc_time), NULL);
- g_signal_connect(interface, "handle_alarm_set_time", G_CALLBACK(alarm_manager_alarm_set_time), NULL);
- g_signal_connect(interface, "handle_alarm_set_timezone", G_CALLBACK(alarm_manager_alarm_set_timezone), NULL);
- g_signal_connect(interface, "handle_alarm_update", G_CALLBACK(alarm_manager_alarm_update), NULL);
- g_signal_connect(interface, "handle_alarm_get_all_info", G_CALLBACK(alarm_manager_alarm_get_all_info), NULL);
- g_signal_connect(interface, "handle_alarm_set_time_with_propagation_delay", G_CALLBACK(alarm_manager_alarm_set_time_with_propagation_delay), NULL);
- g_signal_connect(interface, "handle_alarm_set_global", G_CALLBACK(alarm_manager_alarm_set_global), NULL);
- g_signal_connect(interface, "handle_alarm_get_global", G_CALLBACK(alarm_manager_alarm_get_global), NULL);
-
- subsc_id = g_dbus_connection_signal_subscribe(connection,
- "org.freedesktop.DBus", "org.freedesktop.DBus",
- "NameOwnerChanged", "/org/freedesktop/DBus", NULL,
- G_DBUS_SIGNAL_FLAGS_NONE, on_bus_name_owner_changed, NULL, NULL);
- if (subsc_id == 0) {
- ALARM_MGR_EXCEPTION_PRINT("Subscribing to signal for invoking callback is failed.");
- g_object_unref(interface);
- interface = NULL;
- g_object_unref(connection);
- return false;
- }
-
- if (!g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(interface), connection, ALARM_MGR_DBUS_PATH, NULL)) {
- ALARM_MGR_EXCEPTION_PRINT("Exporting the interface is failed.");
- g_object_unref(interface);
- interface = NULL;
- g_object_unref(connection);
- return false;
- }
-
- guint owner_id = g_bus_own_name_on_connection(connection,
- ALARM_MGR_DBUS_NAME, G_BUS_NAME_OWNER_FLAGS_NONE,
- NULL, NULL, NULL, NULL);
-
- if (owner_id == 0) {
- ALARM_MGR_EXCEPTION_PRINT("Acquiring the own name is failed.");
- g_object_unref(interface);
- interface = NULL;
- g_object_unref(connection);
- return false;
- }
-
- alarm_context.connection = connection;
-
- return true;
-}
-
-
void _alarm_initialize()
{
#if !(GLIB_CHECK_VERSION(2, 36, 0))
ALARM_MGR_LOG_PRINT("alarm_expire_mode : %d", expire_mode);
__initialize_timer();
- if (__initialize_dbus() == false) {
+ if (_initialize_dbus() == false) {
/* because dbus's initialize
* failed, we cannot continue any more. */
- ALARM_MGR_EXCEPTION_PRINT("because __initialize_dbus failed, "
+ ALARM_MGR_EXCEPTION_PRINT("because _initialize_dbus failed, "
"alarm-server cannot be runned.\n");
exit(1);
}
free(entry);
}
-
+++ /dev/null
-/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * 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.
- */
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-#include <unistd.h>
-#include <stdio.h>
-
-#include "alarm.h"
-#include "alarm-internal.h"
-
-#include "alarm-manager.c"
-#include "alarm-manager-schedule.c"
-#include "alarm-manager-timer.c"
-#include "alarm-manager-db.c"
-#include "alarm-manager-util.c"
-
-#include "mock/alarm_dbus.h"
-#include "mock/cynara_fake.h"
-#include "mock/gio_fake.h"
-#include "mock/glib_fake.h"
-
-GVariant* __fake_g_dbus_connection_call_sync(GDBusConnection *connection,
- const gchar *bus_name,
- const gchar *object_path,
- const gchar *interface_name,
- const gchar *method_name,
- GVariant *parameters,
- const GVariantType *reply_type,
- GDBusCallFlags flags,
- gint timeout_msec,
- GCancellable *cancellable,
- GError **error)
-{
- GVariant* ret = g_variant_new_string("var");
- return ret;
-}
-
-const gchar* __fake_g_dbus_method_invocation_get_sender(GDBusMethodInvocation *invocation)
-{
- const gchar* ret = "fake";
- return ret;
-}
-
-guint __fake_g_dbus_connection_signal_subscribe(GDBusConnection* con,
- const gchar* sender, const gchar* interface_name, const gchar* member,
- const gchar* object_path, const gchar* arg, GDBusSignalFlags flags,
- GDBusSignalCallback cb, gpointer user_data, GDestroyNotify free_func)
-{
- return 1;
-}
-
-gboolean __fake_g_dbus_interface_skeleton_export(GDBusInterfaceSkeleton* skel,
- GDBusConnection* con, const gchar* path, GError** error)
-{
- return true;
-}
-
-void __fake_g_variant_get(GVariant* value, const gchar* format_string, va_list v)
-{
- gpointer ptr = va_arg(v, gpointer);
- *(guint32 *) ptr = 1;
-}
-
-gboolean __fake_g_variant_iter_loop(GVariantIter* value, const gchar* format_string, va_list v)
-{
- return false;
-}
-
-void __fake_g_variant_unref(GVariant* value)
-{
-}
-
-void __fake_g_variant_iter_free(GVariantIter* value)
-{
-}
-
-GVariant* __fake_g_variant_new(const gchar *string, va_list v)
-{
- return nullptr;
-}
-
-gpointer __fake_g_hash_table_lookup(GHashTable* table, gconstpointer key)
-{
- return nullptr;
-}
-
-guint __fake_g_hash_table_foreach_remove(GHashTable* table,
- GHRFunc func, gpointer key)
-{
- return 0;
-}
-
-gboolean __fake_g_hash_table_insert(GHashTable* table, gpointer key,
- gpointer value)
-{
- return true;
-}
-
-int __fake_cynara_initialize(cynara** c, const cynara_configuration* conf)
-{
- return CYNARA_API_SUCCESS;
-}
-
-int __fake_cynara_creds_gdbus_get_user(GDBusConnection* c, const gchar* sender,
- enum cynara_user_creds method, gchar** user)
-{
- *user = nullptr;
- return CYNARA_API_SUCCESS;
-}
-
-int __fake_cynara_creds_gdbus_get_client(GDBusConnection* c, const gchar* sender,
- enum cynara_client_creds method, gchar** client)
-{
- *client = nullptr;
- return CYNARA_API_SUCCESS;
-}
-
-int __fake_cynara_check(cynara* c, const char* client, const char* session,
- const char* user, const char* privilege)
-{
- return CYNARA_API_ACCESS_ALLOWED;
-}
-char* __fake_cynara_session_from_pid(pid_t pid)
-{
- return strdup("test");
-}
-
-class AlarmManagerTest : public ::testing::Test {
- protected:
- void SetUp() override {
- g_dbus_connection_call_sync_fake.custom_fake = __fake_g_dbus_connection_call_sync;
- g_dbus_method_invocation_get_sender_fake.custom_fake = __fake_g_dbus_method_invocation_get_sender;
- g_variant_get_fake.custom_fake = __fake_g_variant_get;
- g_variant_iter_loop_fake.custom_fake = __fake_g_variant_iter_loop;
- g_variant_unref_fake.custom_fake = __fake_g_variant_unref;
- g_variant_iter_free_fake.custom_fake = __fake_g_variant_iter_free;
- g_variant_new_fake.custom_fake = __fake_g_variant_new;
- g_hash_table_lookup_fake.custom_fake = __fake_g_hash_table_lookup;
- g_hash_table_foreach_remove_fake.custom_fake = __fake_g_hash_table_foreach_remove;
- g_hash_table_insert_fake.custom_fake = __fake_g_hash_table_insert;
-
- char fake[5] = "fake";
- alarm_manager_alarm_create(nullptr, nullptr, fake, fake,
- 2019, 9, 26, 13, 40, 20, 20, 2020, 9, 26, 1, 0, 0, 0, fake,
- fake, nullptr);
- }
-
- void TearDown() override {
- }
-
- alarm_entry_t *alarm;
-};
-
-TEST_F(AlarmManagerTest, __get_proper_interval_p)
-{
- long interval = 30;
-
- __get_proper_interval(interval, ALARM_TYPE_INEXACT);
-}
-
-TEST_F(AlarmManagerTest, _alarm_initialize_p)
-{
- g_dbus_connection_signal_subscribe_fake.custom_fake =
- __fake_g_dbus_connection_signal_subscribe;
- g_dbus_interface_skeleton_export_fake.custom_fake =
- __fake_g_dbus_interface_skeleton_export;
-
- _alarm_initialize();
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_create_p)
-{
- gboolean ret;
- char fake[5] = "fake";
- ret = alarm_manager_alarm_create(nullptr, nullptr, fake, fake,
- 2019, 9, 26, 13, 40, 20, 20, 2020, 9, 26, 1, 0, 0, 0, fake,
- fake, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_create_periodic_p)
-{
- gboolean ret;
- char fake[5] = "fake";
- ret = alarm_manager_alarm_create_periodic(nullptr, nullptr, fake,
- fake, 10000, 0, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_create_appsvc_p)
-{
- gboolean ret;
- bundle *b;
- bundle_raw *b_data = NULL;
- int datalen = 0;
- b = bundle_create();
- bundle_add_str(b, "key", "val");
- bundle_encode(b, &b_data, &datalen);
-
- ret = alarm_manager_alarm_create_appsvc(nullptr, nullptr,
- 2019, 9, 26, 13, 40, 20, 2020, 9, 26, 1, 0, 0, 0, 10, (char*) b_data,
- nullptr);
- EXPECT_EQ(true, ret);
-
- free(b_data);
- bundle_free(b);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_create_noti_p)
-{
- cynara_initialize_fake.custom_fake = __fake_cynara_initialize;
- cynara_creds_gdbus_get_user_fake.custom_fake = __fake_cynara_creds_gdbus_get_user;
- cynara_creds_gdbus_get_client_fake.custom_fake = __fake_cynara_creds_gdbus_get_client;
- cynara_session_from_pid_fake.custom_fake = __fake_cynara_session_from_pid;
- cynara_check_fake.custom_fake = __fake_cynara_check;
-
- gboolean ret;
- ret = alarm_manager_alarm_create_noti(nullptr, nullptr,
- 2019, 9, 26, 13, 40, 20, 2020, 9, 26, 1, 0, 0, 0, 10, nullptr, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_delete_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_delete(nullptr, nullptr, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_delete_all_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_delete_all(nullptr, nullptr, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_appsvc_info_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_appsvc_info(nullptr, nullptr, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_info_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_info(nullptr, nullptr, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_noti_info_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_noti_info(nullptr, nullptr, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_list_of_ids_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_list_of_ids(nullptr, nullptr, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_next_duetime_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_next_duetime(nullptr, nullptr, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_number_of_ids_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_number_of_ids(nullptr, nullptr, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_set_rtc_time_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_set_rtc_time(nullptr, nullptr, 2019, 9, 26, 13,
- 40, 20, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_set_time_p)
-{
- gboolean ret;
- // ret = alarm_manager_alarm_set_time(nullptr, nullptr, 20, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_set_timezone_p)
-{
- gboolean ret;
- char zone[6] = "seoul";
- ret = alarm_manager_alarm_set_timezone(nullptr, nullptr, zone, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_update_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_update(nullptr, nullptr, 1,
- 2019, 9, 26, 13, 40, 20, 2020, 9, 26, 1, 0, 0, 0, 10, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_all_info_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_all_info(nullptr, nullptr, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_set_time_with_propagation_delay_p)
-{
- gboolean ret;
-// ret = alarm_manager_alarm_set_time_with_propagation_delay(nullptr, nullptr,
-// 20, 21, 30, 31, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_set_global_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_set_global(nullptr, nullptr, 1, true, nullptr);
- EXPECT_EQ(true, ret);
-}
-
-TEST_F(AlarmManagerTest, alarm_manager_alarm_get_global_p)
-{
- gboolean ret;
- ret = alarm_manager_alarm_get_global(nullptr, nullptr, 1, nullptr);
- EXPECT_EQ(true, ret);
-}
-
#include "mock.h"
-#include "alarm-mgr-stub.h"
-
DECLARE_FAKE_VALUE_FUNC(gboolean, alarm_manager_call_alarm_get_info_sync,
AlarmManager*, gint, gint*, gint*, gint*, gint*, gint*, gint*, gint*,
gint*, gint*, gint*, gint*, gint*, gint*, gint*, GCancellable*, GError**);
projects / platform / core / appfw / alarm-manager.git / commitdiff