From c4868d52f1a2bc254128f1b1f55553fdb152ad81 Mon Sep 17 00:00:00 2001 From: Jiyoung Yun Date: Mon, 16 Mar 2015 15:07:26 +0900 Subject: feedback: Seperate codes between common and mobile profile feedback-ids.h and feedback.h will be public api on Tizen v2.4. If you need a specific enum for your profile, you can make new file like feedback-ids-[PROFILE].h. Change-Id: Iedcd7092866351a6c0b07fed3060b096e073973a Signed-off-by: Jiyoung Yun Signed-off-by: taeyoung --- wearable/data/sound.xml | 181 +++++++++++ wearable/data/sound/operation/notification.ogg | Bin 0 -> 16051 bytes wearable/data/sound/operation/power_on.ogg | Bin 0 -> 36190 bytes wearable/data/sound/operation/ringtone.ogg | Bin 0 -> 38673 bytes wearable/data/sound/operation/shutter.ogg | Bin 0 -> 16468 bytes wearable/data/sound/operation/system.ogg | Bin 0 -> 7657 bytes wearable/data/sound/touch/touch.ogg | Bin 0 -> 4303 bytes wearable/include/feedback-ids-wearable.h | 109 +++++++ wearable/src/check.c | 408 +++++++++++++++++++++++++ 9 files changed, 698 insertions(+) create mode 100644 wearable/data/sound.xml create mode 100755 wearable/data/sound/operation/notification.ogg create mode 100755 wearable/data/sound/operation/power_on.ogg create mode 100755 wearable/data/sound/operation/ringtone.ogg create mode 100755 wearable/data/sound/operation/shutter.ogg create mode 100755 wearable/data/sound/operation/system.ogg create mode 100755 wearable/data/sound/touch/touch.ogg create mode 100644 wearable/include/feedback-ids-wearable.h create mode 100644 wearable/src/check.c (limited to 'wearable') diff --git a/wearable/data/sound.xml b/wearable/data/sound.xml new file mode 100644 index 0000000..d4e2a86 --- /dev/null +++ b/wearable/data/sound.xml @@ -0,0 +1,181 @@ + + + + Sound Resource + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/operation/power_on.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/touch/touch.ogg + + + + /usr/share/feedback/sound/operation/notification.ogg + + + + /usr/share/feedback/sound/operation/notification.ogg + + + + /usr/share/feedback/sound/operation/notification.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/shutter.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + + + /usr/share/feedback/sound/operation/system.ogg + + diff --git a/wearable/data/sound/operation/notification.ogg b/wearable/data/sound/operation/notification.ogg new file mode 100755 index 0000000..457f7e8 Binary files /dev/null and b/wearable/data/sound/operation/notification.ogg differ diff --git a/wearable/data/sound/operation/power_on.ogg b/wearable/data/sound/operation/power_on.ogg new file mode 100755 index 0000000..7756406 Binary files /dev/null and b/wearable/data/sound/operation/power_on.ogg differ diff --git a/wearable/data/sound/operation/ringtone.ogg b/wearable/data/sound/operation/ringtone.ogg new file mode 100755 index 0000000..2653dd6 Binary files /dev/null and b/wearable/data/sound/operation/ringtone.ogg differ diff --git a/wearable/data/sound/operation/shutter.ogg b/wearable/data/sound/operation/shutter.ogg new file mode 100755 index 0000000..c22c810 Binary files /dev/null and b/wearable/data/sound/operation/shutter.ogg differ diff --git a/wearable/data/sound/operation/system.ogg b/wearable/data/sound/operation/system.ogg new file mode 100755 index 0000000..69c8425 Binary files /dev/null and b/wearable/data/sound/operation/system.ogg differ diff --git a/wearable/data/sound/touch/touch.ogg b/wearable/data/sound/touch/touch.ogg new file mode 100755 index 0000000..8be60ce Binary files /dev/null and b/wearable/data/sound/touch/touch.ogg differ diff --git a/wearable/include/feedback-ids-wearable.h b/wearable/include/feedback-ids-wearable.h new file mode 100644 index 0000000..fb7188c --- /dev/null +++ b/wearable/include/feedback-ids-wearable.h @@ -0,0 +1,109 @@ +/* + * libfeedback + * Copyright (c) 2012 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef __FEEDBACK_IDS_WEARABLE_H__ +#define __FEEDBACK_IDS_WEARABLE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file feedback-ids-mobile.h + * @brief This file contains the feedback API + */ + +/** + * @addtogroup CAPI_FEEDBACK_MODULE + * @{ + */ + +/** + * @brief Enumerations of the system pre-defined patterns for feedback interface + * @details + * Each feedback pattern can have separate media files of each types. + * But Depending on vendor design, pattern may not have any type of file. + * + */ +typedef enum +{ + FEEDBACK_PATTERN_WEARABLE_NONE = -1, + + FEEDBACK_PATTERN_WEARABLE_SIP_BACKSPACE = FEEDBACK_PATTERN_END, /**< feedback pattern when touch backspace key */ + FEEDBACK_PATTERN_WEARABLE_SIP_FUNCTION, /**< feedback pattern when touch function key */ + FEEDBACK_PATTERN_WEARABLE_SIP_FJKEY, /**< feedback pattern when touch F,J key */ + FEEDBACK_PATTERN_WEARABLE_MAX_CHARACTER, /**< feedback pattern when max character */ + + FEEDBACK_PATTERN_WEARABLE_MESSAGE_ON_CALL, /**< feedback pattern when incoming a message on call */ + FEEDBACK_PATTERN_WEARABLE_EMAIL_ON_CALL, /**< feedback pattern when incoming an email on call */ + FEEDBACK_PATTERN_WEARABLE_WAKEUP_ON_CALL, /**< feedback pattern when alert wake up call on call */ + FEEDBACK_PATTERN_WEARABLE_SCHEDULE_ON_CALL, /**< feedback pattern when alert schedule alarm on call */ + FEEDBACK_PATTERN_WEARABLE_TIMER_ON_CALL, /**< feedback pattern when alert timer on call */ + FEEDBACK_PATTERN_WEARABLE_GENERAL_ON_CALL, /**< feedback pattern when alert general event on call */ + FEEDBACK_PATTERN_WEARABLE_SMART_ALERT, /**< feedback pattern when alert noti on motion */ + + FEEDBACK_PATTERN_WEARABLE_CHARGERCONN_ON_CALL, /**< feedback pattern when connecting charger on call */ + FEEDBACK_PATTERN_WEARABLE_CHARGING_ERROR_ON_CALL,/**< feedback pattern when occuring charging error on call */ + FEEDBACK_PATTERN_WEARABLE_FULLCHARGED_ON_CALL, /**< feedback pattern when full charged on call */ + FEEDBACK_PATTERN_WEARABLE_LOWBATT_ON_CALL, /**< feedback pattern when low battery on call */ + FEEDBACK_PATTERN_WEARABLE_CALLCONNECT, /**< feedback pattern when connecting call */ + FEEDBACK_PATTERN_WEARABLE_DISCALLCONNECT, /**< feedback pattern when disconnecting call */ + FEEDBACK_PATTERN_WEARABLE_OUTGOING_CALL, /**< feedback pattern when connected outgoing call */ + FEEDBACK_PATTERN_WEARABLE_MINUTEMINDER, /**< feedback pattern when minute minder */ + FEEDBACK_PATTERN_WEARABLE_BT_PAIRING, /**< feedback pattern when starting pare with bluetooth */ + FEEDBACK_PATTERN_WEARABLE_BT_WAITING, /**< feedback pattern when pairing bluetooth */ + FEEDBACK_PATTERN_WEARABLE_SCREEN_CAPTURE, /**< feedback pattern when screen capture */ + FEEDBACK_PATTERN_WEARABLE_MMS, /**< feedback pattern when message state changed to MMS */ + FEEDBACK_PATTERN_WEARABLE_HOURLY_ALERT, /**< feedback pattern when alert every hour on the hour */ + + FEEDBACK_PATTERN_WEARABLE_SAFETY_ALERT, /**< feedback pattern when safety alert from phone */ + FEEDBACK_PATTERN_WEARABLE_ACCIDENT_DETECT, /**< feedback pattern when accident detect */ + FEEDBACK_PATTERN_WEARABLE_SEND_SOS_MESSAGE, /**< feedback pattern when sending SOS message */ + FEEDBACK_PATTERN_WEARABLE_END_SOS_MESSAGE, /**< feedback pattern when finishing SOS message */ + FEEDBACK_PATTERN_WEARABLE_EMERGENCY_BUZZER, /**< feedback pattern when occurs emergency buzzer */ + FEEDBACK_PATTERN_WEARABLE_SAFETY_LOW_POWER, /**< this pattern is a low power ringtone */ + FEEDBACK_PATTERN_WEARABLE_CMAS, /**< feedback pattern when alerting commercial mobile */ + FEEDBACK_PATTERN_WEARABLE_SPEED_UP, /**< feedback pattern when advising user to speed up */ + FEEDBACK_PATTERN_WEARABLE_SLOW_DOWN, /**< feedback pattern when advising user to slow down */ + FEEDBACK_PATTERN_WEARABLE_KEEP_THIS_PACE, /**< feedback pattern when advising user to keep this pace */ + FEEDBACK_PATTERN_WEARABLE_GOAL_ACHIEVED, /**< feedback pattern when alerting goal achieved */ + FEEDBACK_PATTERN_WEARABLE_EXERCISE_COUNT, /**< feedback pattern when changing count number */ + FEEDBACK_PATTERN_WEARABLE_START_CUE, /**< feedback pattern when starting cue */ + FEEDBACK_PATTERN_WEARABLE_HEALTH_PACE, /**< feedback pattern when alerting health pace */ + FEEDBACK_PATTERN_WEARABLE_INACTIVE_TIME, /**< feedback pattern when alerting inactive time */ + FEEDBACK_PATTERN_WEARABLE_MEASURING_SUCCESS, /**< feedback pattern when measuring is succeeded */ + FEEDBACK_PATTERN_WEARABLE_MEASURING_FAILURE, /**< feedback pattern when measuring is failed */ + FEEDBACK_PATTERN_WEARABLE_UV_PROCESSING, /**< feedback pattern when UV is processing */ + FEEDBACK_PATTERN_WEARABLE_SHEALTH_START, /**< feedback pattern when starting s-health */ + FEEDBACK_PATTERN_WEARABLE_SHEALTH_PAUSE, /**< feedback pattern when pausing s-health */ + FEEDBACK_PATTERN_WEARABLE_SHEALTH_STOP, /**< feedback pattern when stoping s-health */ + FEEDBACK_PATTERN_WEARABLE_3RD_APPLICATION, /**< feedback pattern when alert 3rd event */ + + FEEDBACK_PATTERN_WEARABLE_END, + +} feedback_pattern_wearable_e; + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif //__FEEDBACK_IDS_WEARABLE_H__ diff --git a/wearable/src/check.c b/wearable/src/check.c new file mode 100644 index 0000000..345b102 --- /dev/null +++ b/wearable/src/check.c @@ -0,0 +1,408 @@ +/* + * libfeedback + * Copyright (c) 2015 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include + +#include "feedback.h" +#include "feedback-ids-wearable.h" +#include "profiles.h" +#include "log.h" + + +static const char *wearable_str_type[] = +{ + "FEEDBACK_TYPE_NONE", + "FEEDBACK_TYPE_SOUND", + "FEEDBACK_TYPE_VIBRATION", +}; + +static const char *wearable_str_pattern[] = +{ + "FEEDBACK_PATTERN_TAP", + "FEEDBACK_PATTERN_SIP", + "FEEDBACK_PATTERN_KEY0", + "FEEDBACK_PATTERN_KEY1", + "FEEDBACK_PATTERN_KEY2", + "FEEDBACK_PATTERN_KEY3", + "FEEDBACK_PATTERN_KEY4", + "FEEDBACK_PATTERN_KEY5", + "FEEDBACK_PATTERN_KEY6", + "FEEDBACK_PATTERN_KEY7", + "FEEDBACK_PATTERN_KEY8", + "FEEDBACK_PATTERN_KEY9", + "FEEDBACK_PATTERN_KEY_STAR", + "FEEDBACK_PATTERN_KEY_SHARP", + "FEEDBACK_PATTERN_KEY_BACK", + "FEEDBACK_PATTERN_HOLD", + "FEEDBACK_PATTERN_HW_TAP", + "FEEDBACK_PATTERN_HW_HOLD", + + "FEEDBACK_PATTERN_MESSAGE", + "FEEDBACK_PATTERN_EMAIL", + "FEEDBACK_PATTERN_WAKEUP", + "FEEDBACK_PATTERN_SCHEDULE", + "FEEDBACK_PATTERN_TIMER", + "FEEDBACK_PATTERN_GENERAL", + + "FEEDBACK_PATTERN_POWERON", + "FEEDBACK_PATTERN_POWEROFF", + "FEEDBACK_PATTERN_CHARGERCONN", + "FEEDBACK_PATTERN_CHARGING_ERROR", + "FEEDBACK_PATTERN_FULLCHARGED", + "FEEDBACK_PATTERN_LOWBATT", + "FEEDBACK_PATTERN_LOCK", + "FEEDBACK_PATTERN_UNLOCK", + "FEEDBACK_PATTERN_VIBRATION_ON", + "FEEDBACK_PATTERN_SILENT_OFF", + "FEEDBACK_PATTERN_BT_CONNECTED", + "FEEDBACK_PATTERN_BT_DISCONNECTED", + "FEEDBACK_PATTERN_LIST_REORDER", + "FEEDBACK_PATTERN_LIST_SLIDER", + "FEEDBACK_PATTERN_VOLUME_KEY", + + "FEEDBACK_PATTERN_WEARABLE_SIP_BACKSPACE", + "FEEDBACK_PATTERN_WEARABLE_SIP_FUNCTION", + "FEEDBACK_PATTERN_WEARABLE_SIP_FJKEY", + "FEEDBACK_PATTERN_WEARABLE_MAX_CHARACTER", + + "FEEDBACK_PATTERN_WEARABLE_MESSAGE_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_EMAIL_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_WAKEUP_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_SCHEDULE_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_TIMER_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_GENERAL_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_SMART_ALERT", + + "FEEDBACK_PATTERN_WEARABLE_CHARGERCONN_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_CHARGING_ERROR_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_FULLCHARGED_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_LOWBATT_ON_CALL", + "FEEDBACK_PATTERN_WEARABLE_CALLCONNECT", + "FEEDBACK_PATTERN_WEARABLE_DISCALLCONNECT", + "FEEDBACK_PATTERN_WEARABLE_OUTGOING_CALL", + "FEEDBACK_PATTERN_WEARABLE_MINUTEMINDER", + "FEEDBACK_PATTERN_WEARABLE_BT_PAIRING", + "FEEDBACK_PATTERN_WEARABLE_BT_WAITING", + "FEEDBACK_PATTERN_WEARABLE_SCREEN_CAPTURE", + "FEEDBACK_PATTERN_WEARABLE_MMS", + "FEEDBACK_PATTERN_WEARABLE_HOURLY_ALERT", + + "FEEDBACK_PATTERN_WEARABLE_SAFETY_ALERT", + "FEEDBACK_PATTERN_WEARABLE_ACCIDENT_DETECT", + "FEEDBACK_PATTERN_WEARABLE_SEND_SOS_MESSAGE", + "FEEDBACK_PATTERN_WEARABLE_END_SOS_MESSAGE", + "FEEDBACK_PATTERN_WEARABLE_EMERGENCY_BUZZER", + "FEEDBACK_PATTERN_WEARABLE_SAFETY_LOW_POWER", + "FEEDBACK_PATTERN_WEARABLE_CMAS", + "FEEDBACK_PATTERN_WEARABLE_SPEED_UP", + "FEEDBACK_PATTERN_WEARABLE_SLOW_DOWN", + "FEEDBACK_PATTERN_WEARABLE_KEEP_THIS_PACE", + "FEEDBACK_PATTERN_WEARABLE_GOAL_ACHIEVED", + "FEEDBACK_PATTERN_WEARABLE_EXERCISE_COUNT", + "FEEDBACK_PATTERN_WEARABLE_START_CUE", + "FEEDBACK_PATTERN_WEARABLE_HEALTH_PACE", + "FEEDBACK_PATTERN_WEARABLE_INACTIVE_TIME", + "FEEDBACK_PATTERN_WEARABLE_MEASURING_SUCCESS", + "FEEDBACK_PATTERN_WEARABLE_MEASURING_FAILURE", + "FEEDBACK_PATTERN_WEARABLE_UV_PROCESSING", + "FEEDBACK_PATTERN_WEARABLE_SHEALTH_START", + "FEEDBACK_PATTERN_WEARABLE_SHEALTH_PAUSE", + "FEEDBACK_PATTERN_WEARABLE_SHEALTH_STOP", + "FEEDBACK_PATTERN_WEARABLE_3RD_APPLICATION", +}; + +static int callstatus; +static int alert_callstatus; +static int camerastatus; +static int shutter_sndstatus; +static int noti_vibstatus; +static int vib_level; +static int noti_level; +static int feedbackstatus; + +static void feedback_callstatus_cb(keynode_t *key, void* data) +{ + callstatus = vconf_keynode_get_int(key); +} + +static void feedback_alertstatus_cb(keynode_t *key, void* data) +{ + alert_callstatus = vconf_keynode_get_int(key); +} + +static void feedback_camerastatus_cb(keynode_t *key, void* data) +{ + camerastatus = vconf_keynode_get_int(key); +} + +static void feedback_noti_vibstatus_cb(keynode_t *key, void* data) +{ + noti_vibstatus = vconf_keynode_get_bool(key); +} + +static void feedback_vib_cb(keynode_t *key, void* data) +{ + vib_level = vconf_keynode_get_int(key); +} + +static void feedback_noti_cb(keynode_t *key, void* data) +{ + noti_level = vconf_keynode_get_int(key); +} + +static void feedback_feedbackstatus_cb(keynode_t *key, void* data) +{ + feedbackstatus = vconf_keynode_get_bool(key); +} + +static void wearable_init(void) +{ + /* check call status */ + if (vconf_get_int(VCONFKEY_CALL_STATE, &callstatus) < 0) + _W("VCONFKEY_CALL_STATE ==> FAIL!!"); + + /* alert option on call */ + if (vconf_get_int(VCONFKEY_CISSAPPL_ALERT_ON_CALL_INT, &alert_callstatus) < 0) + _W("VCONFKEY_CISSAPPL_ON_CALL_INT ==> FAIL!!"); + + /* check camera status */ + if (vconf_get_int(VCONFKEY_CAMERA_STATE, &camerastatus) < 0) + _W("VCONFKEY_CAMERA_STATE ==> FAIL!!"); + + /* shutter sound policy */ + // This vconf is read just once, because this value is not changed in running time. + if (vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &shutter_sndstatus) < 0) + _W("VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY ==> FAIL!!"); + + /* check vibration status */ + if (vconf_get_bool(VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL, ¬i_vibstatus) < 0) + _W("VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL ==> FAIL!!"); + + /* check vib_level */ + if (vconf_get_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, &vib_level) < 0) + _W("VCONFKEY_FEEDBACK_VIBRATION_LEVEL_INT ==> FAIL!!"); + + /* check noti_level */ + if (vconf_get_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, ¬i_level) < 0) + _W("VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT ==> FAIL!!"); + + /* feedback Init */ + if(vconf_get_bool(VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL, &feedbackstatus) < 0) + _W("VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL ==> FAIL!!"); + + /* add watch for status value */ + vconf_notify_key_changed(VCONFKEY_CALL_STATE, feedback_callstatus_cb, NULL); + vconf_notify_key_changed(VCONFKEY_CISSAPPL_ALERT_ON_CALL_INT, feedback_alertstatus_cb, NULL); + vconf_notify_key_changed(VCONFKEY_CAMERA_STATE, feedback_camerastatus_cb, NULL); + vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL, feedback_noti_vibstatus_cb, NULL); + vconf_notify_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, feedback_vib_cb, NULL); + vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, feedback_noti_cb, NULL); + vconf_notify_key_changed(VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL, feedback_feedbackstatus_cb, NULL); +} + +static void wearable_exit(void) +{ + /* remove watch */ + vconf_ignore_key_changed(VCONFKEY_CALL_STATE, feedback_callstatus_cb); + vconf_ignore_key_changed(VCONFKEY_CISSAPPL_ALERT_ON_CALL_INT, feedback_alertstatus_cb); + vconf_ignore_key_changed(VCONFKEY_CAMERA_STATE, feedback_camerastatus_cb); + vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL, feedback_noti_vibstatus_cb); + vconf_ignore_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, feedback_vib_cb); + vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, feedback_noti_cb); + vconf_ignore_key_changed(VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL, feedback_feedbackstatus_cb); +} + +static bool wearable_get_switched_pattern(int pattern, int *switched) +{ + if (!switched) + return false; + + if (callstatus == VCONFKEY_CALL_OFF) + return false; + + /* in case of call connected or connecting */ + _D("Call status is connected or connecting."); + if (pattern == FEEDBACK_PATTERN_MESSAGE) + *switched = FEEDBACK_PATTERN_WEARABLE_MESSAGE_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_EMAIL) + *switched = FEEDBACK_PATTERN_WEARABLE_EMAIL_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_WAKEUP) + *switched = FEEDBACK_PATTERN_WEARABLE_WAKEUP_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_SCHEDULE) + *switched = FEEDBACK_PATTERN_WEARABLE_SCHEDULE_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_TIMER) + *switched = FEEDBACK_PATTERN_WEARABLE_TIMER_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_GENERAL) + *switched = FEEDBACK_PATTERN_WEARABLE_GENERAL_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_CHARGERCONN) + *switched = FEEDBACK_PATTERN_WEARABLE_CHARGERCONN_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_CHARGING_ERROR) + *switched = FEEDBACK_PATTERN_WEARABLE_CHARGING_ERROR_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_FULLCHARGED) + *switched = FEEDBACK_PATTERN_WEARABLE_FULLCHARGED_ON_CALL; + else if (pattern == FEEDBACK_PATTERN_LOWBATT) + *switched = FEEDBACK_PATTERN_WEARABLE_LOWBATT_ON_CALL; + + return true; +} + +static bool wearable_get_always_alert_case(int type, int pattern) +{ + switch (pattern) { + case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK: + case FEEDBACK_PATTERN_HOLD: + if (CHECK_VIBRATION(type) && feedbackstatus) + return true; + break; + case FEEDBACK_PATTERN_SIP: + case FEEDBACK_PATTERN_WEARABLE_SIP_BACKSPACE: + case FEEDBACK_PATTERN_WEARABLE_SIP_FUNCTION: + case FEEDBACK_PATTERN_WEARABLE_SIP_FJKEY: + if (CHECK_VIBRATION(type)) + return true; + break; + case FEEDBACK_PATTERN_MESSAGE: + case FEEDBACK_PATTERN_EMAIL: + if (CHECK_VIBRATION(type) && noti_vibstatus) + return true; + break; + case FEEDBACK_PATTERN_TIMER: + case FEEDBACK_PATTERN_WEARABLE_TIMER_ON_CALL: + if (CHECK_VIBRATION(type)) + return true; + break; + case FEEDBACK_PATTERN_WAKEUP: + case FEEDBACK_PATTERN_WEARABLE_WAKEUP_ON_CALL: + return true; + case FEEDBACK_PATTERN_WEARABLE_MESSAGE_ON_CALL: + case FEEDBACK_PATTERN_WEARABLE_EMAIL_ON_CALL: + case FEEDBACK_PATTERN_WEARABLE_GENERAL_ON_CALL: + if (alert_callstatus) + return true; + break; + case FEEDBACK_PATTERN_WEARABLE_CHARGERCONN_ON_CALL: + case FEEDBACK_PATTERN_WEARABLE_CHARGING_ERROR_ON_CALL: + case FEEDBACK_PATTERN_WEARABLE_LOWBATT_ON_CALL: + case FEEDBACK_PATTERN_WEARABLE_3RD_APPLICATION: + case FEEDBACK_PATTERN_WEARABLE_MMS: + case FEEDBACK_PATTERN_WEARABLE_HOURLY_ALERT: + /* no matter sound profile */ + if (CHECK_VIBRATION(type)) + return true; + break; + case FEEDBACK_PATTERN_WEARABLE_SMART_ALERT: + case FEEDBACK_PATTERN_WEARABLE_SEND_SOS_MESSAGE: + case FEEDBACK_PATTERN_WEARABLE_END_SOS_MESSAGE: + case FEEDBACK_PATTERN_WEARABLE_CMAS: + case FEEDBACK_PATTERN_WEARABLE_OUTGOING_CALL: + return true; + case FEEDBACK_PATTERN_WEARABLE_SCREEN_CAPTURE: + if (CHECK_SOUND(type) && camerastatus && shutter_sndstatus) + return true; + break; + case FEEDBACK_PATTERN_WEARABLE_SPEED_UP: + case FEEDBACK_PATTERN_WEARABLE_SLOW_DOWN: + case FEEDBACK_PATTERN_WEARABLE_KEEP_THIS_PACE: + case FEEDBACK_PATTERN_WEARABLE_GOAL_ACHIEVED: + case FEEDBACK_PATTERN_WEARABLE_EXERCISE_COUNT: + case FEEDBACK_PATTERN_WEARABLE_START_CUE: + /* except mute case */ + if (CHECK_VIBRATION(type) && + (is_sound_mode() || is_vibration_mode())) + return true; + break; + default: + break; + } + return false; +} + +static bool wearable_get_always_off_case(int type, int pattern) +{ + int ret; + + /* check if the state of voice recorder is recording */ + if (vconf_get_int(VCONFKEY_SOUND_STATUS, &ret) < 0) { + _D("fail to get media sound status, status will be zero"); + ret = 0; + } + + if (CHECK_SOUND(type) && ret & VCONFKEY_SOUND_STATUS_AVRECORDING) { + _D("voice recording status is RECORDING"); + return true; + } + + switch (pattern) { + case FEEDBACK_PATTERN_TAP ... FEEDBACK_PATTERN_SIP: + case FEEDBACK_PATTERN_HOLD ... FEEDBACK_PATTERN_HW_HOLD: + case FEEDBACK_PATTERN_WEARABLE_SIP_BACKSPACE ... FEEDBACK_PATTERN_WEARABLE_MAX_CHARACTER: + if (CHECK_SOUND(type) && !is_touch_sndstatus()) + return true; + break; + case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK: + if (CHECK_SOUND(type) && !is_keytone_sndstatus()) + return true; + else if (CHECK_VIBRATION(type) && !feedbackstatus) + return true; + break; + default: + break; + } + return false; +} + +static int wearable_get_strength_type(int type, int pattern) +{ + if (CHECK_SOUND(type)) { + if (pattern == FEEDBACK_PATTERN_TAP) + return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_TOUCH; + else if (pattern >= FEEDBACK_PATTERN_KEY0 && pattern <= FEEDBACK_PATTERN_KEY_BACK) + return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_DIALER; + else if (pattern == FEEDBACK_PATTERN_VOLUME_KEY) + return VOLUME_TYPE_RINGTONE; + else if (camerastatus && shutter_sndstatus && pattern == FEEDBACK_PATTERN_WEARABLE_SCREEN_CAPTURE) + return VOLUME_TYPE_FIXED; + else + return VOLUME_TYPE_SYSTEM; + } else if (CHECK_VIBRATION(type)) { + if (pattern >= FEEDBACK_PATTERN_MESSAGE && + pattern <= FEEDBACK_PATTERN_GENERAL) + return noti_level * HAPTIC_FEEDBACK_STEP; + else + return vib_level * HAPTIC_FEEDBACK_STEP; + } + + return -EINVAL; +} + +static const struct profile_ops wearable_profile_ops = { + .profile = "wearable", + .init = wearable_init, + .exit = wearable_exit, + .get_switched_pattern = wearable_get_switched_pattern, + .get_always_alert_case = wearable_get_always_alert_case, + .get_always_off_case = wearable_get_always_off_case, + .get_strength_type = wearable_get_strength_type, + .max_type = FEEDBACK_TYPE_END, + .max_pattern = FEEDBACK_PATTERN_WEARABLE_END, + .str_type = wearable_str_type, + .str_pattern = wearable_str_pattern, +}; + +PROFILE_OPS_REGISTER(&wearable_profile_ops); -- cgit v1.2.3