src/check.c

   1 /*
   2  * libfeedback
   3  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <vconf.h>
  22 #include <system_info.h>
  23
  24 #include "feedback.h"
  25 #include "feedback-ids-internal.h"
  26 #include "profiles.h"
  27 #include "log.h"
  28
  29 /* Temporary keys */
  30 #ifndef VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL
  31 #define VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL "db/setting/sound/vibrate_when_notification"
  32 #endif
  33 #ifndef VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL
  34 #define VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL "db/setting/sound/haptic_feedback_on"
  35 #endif
  36
  37
  38 static const char *profile_str_type[] = {
  39         "FEEDBACK_TYPE_NONE",
  40         "FEEDBACK_TYPE_SOUND",
  41         "FEEDBACK_TYPE_VIBRATION",
  42 };
  43
  44 static const struct pattern_field mobile_str_pattern[] = {
  45         {"FEEDBACK_PATTERN_TAP", FEEDBACK_PATTERN_TAP},
  46         {"FEEDBACK_PATTERN_SIP", FEEDBACK_PATTERN_SIP},
  47
  48         {"FEEDBACK_PATTERN_KEY0", FEEDBACK_PATTERN_KEY0},
  49         {"FEEDBACK_PATTERN_KEY1", FEEDBACK_PATTERN_KEY1},
  50         {"FEEDBACK_PATTERN_KEY2", FEEDBACK_PATTERN_KEY2},
  51         {"FEEDBACK_PATTERN_KEY3", FEEDBACK_PATTERN_KEY3},
  52         {"FEEDBACK_PATTERN_KEY4", FEEDBACK_PATTERN_KEY4},
  53         {"FEEDBACK_PATTERN_KEY5", FEEDBACK_PATTERN_KEY5},
  54         {"FEEDBACK_PATTERN_KEY6", FEEDBACK_PATTERN_KEY6},
  55         {"FEEDBACK_PATTERN_KEY7", FEEDBACK_PATTERN_KEY7},
  56         {"FEEDBACK_PATTERN_KEY8", FEEDBACK_PATTERN_KEY8},
  57         {"FEEDBACK_PATTERN_KEY9", FEEDBACK_PATTERN_KEY9},
  58         {"FEEDBACK_PATTERN_KEY_STAR", FEEDBACK_PATTERN_KEY_STAR},
  59         {"FEEDBACK_PATTERN_KEY_SHARP", FEEDBACK_PATTERN_KEY_SHARP},
  60         {"FEEDBACK_PATTERN_KEY_BACK", FEEDBACK_PATTERN_KEY_BACK},
  61         {"FEEDBACK_PATTERN_HOLD", FEEDBACK_PATTERN_HOLD},
  62
  63         {"FEEDBACK_PATTERN_HW_TAP", FEEDBACK_PATTERN_HW_TAP},
  64         {"FEEDBACK_PATTERN_HW_HOLD", FEEDBACK_PATTERN_HW_HOLD},
  65
  66         {"FEEDBACK_PATTERN_MESSAGE", FEEDBACK_PATTERN_MESSAGE},
  67         {"FEEDBACK_PATTERN_MESSAGE_ON_CALL", FEEDBACK_PATTERN_MESSAGE_ON_CALL},
  68         {"FEEDBACK_PATTERN_EMAIL", FEEDBACK_PATTERN_EMAIL},
  69         {"FEEDBACK_PATTERN_EMAIL_ON_CALL", FEEDBACK_PATTERN_EMAIL_ON_CALL},
  70         {"FEEDBACK_PATTERN_WAKEUP", FEEDBACK_PATTERN_WAKEUP},
  71         {"FEEDBACK_PATTERN_WAKEUP_ON_CALL", FEEDBACK_PATTERN_WAKEUP_ON_CALL},
  72         {"FEEDBACK_PATTERN_SCHEDULE", FEEDBACK_PATTERN_SCHEDULE},
  73         {"FEEDBACK_PATTERN_SCHEDULE_ON_CALL", FEEDBACK_PATTERN_SCHEDULE_ON_CALL},
  74         {"FEEDBACK_PATTERN_TIMER", FEEDBACK_PATTERN_TIMER},
  75         {"FEEDBACK_PATTERN_TIMER_ON_CALL", FEEDBACK_PATTERN_TIMER_ON_CALL},
  76         {"FEEDBACK_PATTERN_GENERAL", FEEDBACK_PATTERN_GENERAL},
  77         {"FEEDBACK_PATTERN_GENERAL_ON_CALL", FEEDBACK_PATTERN_GENERAL_ON_CALL},
  78
  79         {"FEEDBACK_PATTERN_POWERON", FEEDBACK_PATTERN_POWERON},
  80         {"FEEDBACK_PATTERN_POWEROFF", FEEDBACK_PATTERN_POWEROFF},
  81         {"FEEDBACK_PATTERN_CHARGERCONN", FEEDBACK_PATTERN_CHARGERCONN},
  82         {"FEEDBACK_PATTERN_CHARGERCONN_ON_CALL", FEEDBACK_PATTERN_CHARGERCONN_ON_CALL},
  83         {"FEEDBACK_PATTERN_CHARGING_ERROR", FEEDBACK_PATTERN_CHARGING_ERROR},
  84         {"FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL", FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL},
  85         {"FEEDBACK_PATTERN_FULLCHARGED", FEEDBACK_PATTERN_FULLCHARGED},
  86         {"FEEDBACK_PATTERN_FULLCHARGED_ON_CALL", FEEDBACK_PATTERN_FULLCHARGED_ON_CALL},
  87         {"FEEDBACK_PATTERN_LOWBATT", FEEDBACK_PATTERN_LOWBATT},
  88         {"FEEDBACK_PATTERN_LOWBATT_ON_CALL", FEEDBACK_PATTERN_LOWBATT_ON_CALL},
  89         {"FEEDBACK_PATTERN_LOCK", FEEDBACK_PATTERN_LOCK},
  90         {"FEEDBACK_PATTERN_UNLOCK", FEEDBACK_PATTERN_UNLOCK},
  91
  92         {"FEEDBACK_PATTERN_OUTGOING_CALL", FEEDBACK_PATTERN_OUTGOING_CALL},
  93
  94         {"FEEDBACK_PATTERN_VIBRATION_ON", FEEDBACK_PATTERN_VIBRATION_ON},
  95         {"FEEDBACK_PATTERN_SILENT_OFF", FEEDBACK_PATTERN_SILENT_OFF},
  96         {"FEEDBACK_PATTERN_BT_CONNECTED", FEEDBACK_PATTERN_BT_CONNECTED},
  97         {"FEEDBACK_PATTERN_BT_DISCONNECTED", FEEDBACK_PATTERN_BT_DISCONNECTED},
  98
  99         {"FEEDBACK_PATTERN_SCREEN_CAPTURE", FEEDBACK_PATTERN_SCREEN_CAPTURE},
 100         {"FEEDBACK_PATTERN_LIST_REORDER", FEEDBACK_PATTERN_LIST_REORDER},
 101         {"FEEDBACK_PATTERN_LIST_SLIDER", FEEDBACK_PATTERN_LIST_SLIDER},
 102         {"FEEDBACK_PATTERN_VOLUME_KEY", FEEDBACK_PATTERN_VOLUME_KEY},
 103
 104         {"FEEDBACK_PATTERN_SEND_SOS_MESSAGE", FEEDBACK_PATTERN_SEND_SOS_MESSAGE},
 105         {"FEEDBACK_PATTERN_SYSTEM_SHORT", FEEDBACK_PATTERN_SYSTEM_SHORT},
 106         {"FEEDBACK_PATTERN_SYSTEM_ERROR", FEEDBACK_PATTERN_SYSTEM_ERROR},
 107         {"FEEDBACK_PATTERN_SYSTEM_LONG", FEEDBACK_PATTERN_SYSTEM_LONG},
 108         {"FEEDBACK_PATTERN_SYSTEM_MID", FEEDBACK_PATTERN_SYSTEM_MID},
 109         {"FEEDBACK_PATTERN_RINGER", FEEDBACK_PATTERN_RINGER},
 110         {"FEEDBACK_PATTERN_NOTIFICATION", FEEDBACK_PATTERN_NOTIFICATION},
 111 };
 112
 113 static const struct pattern_field wearable_str_pattern[] = {
 114         {"FEEDBACK_PATTERN_TAP", FEEDBACK_PATTERN_TAP},
 115         {"FEEDBACK_PATTERN_SIP", FEEDBACK_PATTERN_SIP},
 116
 117         {"FEEDBACK_PATTERN_KEY0", FEEDBACK_PATTERN_KEY0},
 118         {"FEEDBACK_PATTERN_KEY1", FEEDBACK_PATTERN_KEY1},
 119         {"FEEDBACK_PATTERN_KEY2", FEEDBACK_PATTERN_KEY2},
 120         {"FEEDBACK_PATTERN_KEY3", FEEDBACK_PATTERN_KEY3},
 121         {"FEEDBACK_PATTERN_KEY4", FEEDBACK_PATTERN_KEY4},
 122         {"FEEDBACK_PATTERN_KEY5", FEEDBACK_PATTERN_KEY5},
 123         {"FEEDBACK_PATTERN_KEY6", FEEDBACK_PATTERN_KEY6},
 124         {"FEEDBACK_PATTERN_KEY7", FEEDBACK_PATTERN_KEY7},
 125         {"FEEDBACK_PATTERN_KEY8", FEEDBACK_PATTERN_KEY8},
 126         {"FEEDBACK_PATTERN_KEY9", FEEDBACK_PATTERN_KEY9},
 127         {"FEEDBACK_PATTERN_KEY_STAR", FEEDBACK_PATTERN_KEY_STAR},
 128         {"FEEDBACK_PATTERN_KEY_SHARP", FEEDBACK_PATTERN_KEY_SHARP},
 129         {"FEEDBACK_PATTERN_KEY_BACK", FEEDBACK_PATTERN_KEY_BACK},
 130         {"FEEDBACK_PATTERN_HOLD", FEEDBACK_PATTERN_HOLD},
 131
 132         {"FEEDBACK_PATTERN_HW_TAP", FEEDBACK_PATTERN_HW_TAP},
 133         {"FEEDBACK_PATTERN_HW_HOLD", FEEDBACK_PATTERN_HW_HOLD},
 134
 135         {"FEEDBACK_PATTERN_MESSAGE", FEEDBACK_PATTERN_MESSAGE},
 136         {"FEEDBACK_PATTERN_MESSAGE_ON_CALL", FEEDBACK_PATTERN_MESSAGE_ON_CALL},
 137         {"FEEDBACK_PATTERN_EMAIL", FEEDBACK_PATTERN_EMAIL},
 138         {"FEEDBACK_PATTERN_EMAIL_ON_CALL", FEEDBACK_PATTERN_EMAIL_ON_CALL},
 139         {"FEEDBACK_PATTERN_WAKEUP", FEEDBACK_PATTERN_WAKEUP},
 140         {"FEEDBACK_PATTERN_WAKEUP_ON_CALL", FEEDBACK_PATTERN_WAKEUP_ON_CALL},
 141         {"FEEDBACK_PATTERN_SCHEDULE", FEEDBACK_PATTERN_SCHEDULE},
 142         {"FEEDBACK_PATTERN_SCHEDULE_ON_CALL", FEEDBACK_PATTERN_SCHEDULE_ON_CALL},
 143         {"FEEDBACK_PATTERN_TIMER", FEEDBACK_PATTERN_TIMER},
 144         {"FEEDBACK_PATTERN_TIMER_ON_CALL", FEEDBACK_PATTERN_TIMER_ON_CALL},
 145         {"FEEDBACK_PATTERN_GENERAL", FEEDBACK_PATTERN_GENERAL},
 146         {"FEEDBACK_PATTERN_GENERAL_ON_CALL", FEEDBACK_PATTERN_GENERAL_ON_CALL},
 147
 148         {"FEEDBACK_PATTERN_POWERON", FEEDBACK_PATTERN_POWERON},
 149         {"FEEDBACK_PATTERN_POWEROFF", FEEDBACK_PATTERN_POWEROFF},
 150         {"FEEDBACK_PATTERN_CHARGERCONN", FEEDBACK_PATTERN_CHARGERCONN},
 151         {"FEEDBACK_PATTERN_CHARGERCONN_ON_CALL", FEEDBACK_PATTERN_CHARGERCONN_ON_CALL},
 152         {"FEEDBACK_PATTERN_CHARGING_ERROR", FEEDBACK_PATTERN_CHARGING_ERROR},
 153         {"FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL", FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL},
 154         {"FEEDBACK_PATTERN_FULLCHARGED", FEEDBACK_PATTERN_FULLCHARGED},
 155         {"FEEDBACK_PATTERN_FULLCHARGED_ON_CALL", FEEDBACK_PATTERN_FULLCHARGED_ON_CALL},
 156         {"FEEDBACK_PATTERN_LOWBATT", FEEDBACK_PATTERN_LOWBATT},
 157         {"FEEDBACK_PATTERN_LOWBATT_ON_CALL", FEEDBACK_PATTERN_LOWBATT_ON_CALL},
 158         {"FEEDBACK_PATTERN_LOCK", FEEDBACK_PATTERN_LOCK},
 159         {"FEEDBACK_PATTERN_UNLOCK", FEEDBACK_PATTERN_UNLOCK},
 160
 161         {"FEEDBACK_PATTERN_VIBRATION_ON", FEEDBACK_PATTERN_VIBRATION_ON},
 162         {"FEEDBACK_PATTERN_SILENT_OFF", FEEDBACK_PATTERN_SILENT_OFF},
 163         {"FEEDBACK_PATTERN_BT_CONNECTED", FEEDBACK_PATTERN_BT_CONNECTED},
 164         {"FEEDBACK_PATTERN_BT_DISCONNECTED", FEEDBACK_PATTERN_BT_DISCONNECTED},
 165
 166         {"FEEDBACK_PATTERN_SCREEN_CAPTURE", FEEDBACK_PATTERN_SCREEN_CAPTURE},
 167         {"FEEDBACK_PATTERN_LIST_REORDER", FEEDBACK_PATTERN_LIST_REORDER},
 168         {"FEEDBACK_PATTERN_LIST_SLIDER", FEEDBACK_PATTERN_LIST_SLIDER},
 169         {"FEEDBACK_PATTERN_VOLUME_KEY", FEEDBACK_PATTERN_VOLUME_KEY},
 170
 171         {"FEEDBACK_PATTERN_SEND_SOS_MESSAGE", FEEDBACK_PATTERN_SEND_SOS_MESSAGE},
 172         {"FEEDBACK_PATTERN_SYSTEM_SHORT", FEEDBACK_PATTERN_SYSTEM_SHORT},
 173         {"FEEDBACK_PATTERN_SYSTEM_ERROR", FEEDBACK_PATTERN_SYSTEM_ERROR},
 174         {"FEEDBACK_PATTERN_SYSTEM_LONG", FEEDBACK_PATTERN_SYSTEM_LONG},
 175         {"FEEDBACK_PATTERN_SYSTEM_MID", FEEDBACK_PATTERN_SYSTEM_MID},
 176         {"FEEDBACK_PATTERN_RINGER", FEEDBACK_PATTERN_RINGER},
 177         {"FEEDBACK_PATTERN_NOTIFICATION", FEEDBACK_PATTERN_NOTIFICATION},
 178 };
 179
 180 static const struct pattern_field common_str_pattern[] = {
 181         {"FEEDBACK_PATTERN_TAP", FEEDBACK_PATTERN_TAP},
 182         {"FEEDBACK_PATTERN_SIP", FEEDBACK_PATTERN_SIP},
 183
 184         {"FEEDBACK_PATTERN_KEY0", FEEDBACK_PATTERN_KEY0},
 185         {"FEEDBACK_PATTERN_KEY1", FEEDBACK_PATTERN_KEY1},
 186         {"FEEDBACK_PATTERN_KEY2", FEEDBACK_PATTERN_KEY2},
 187         {"FEEDBACK_PATTERN_KEY3", FEEDBACK_PATTERN_KEY3},
 188         {"FEEDBACK_PATTERN_KEY4", FEEDBACK_PATTERN_KEY4},
 189         {"FEEDBACK_PATTERN_KEY5", FEEDBACK_PATTERN_KEY5},
 190         {"FEEDBACK_PATTERN_KEY6", FEEDBACK_PATTERN_KEY6},
 191         {"FEEDBACK_PATTERN_KEY7", FEEDBACK_PATTERN_KEY7},
 192         {"FEEDBACK_PATTERN_KEY8", FEEDBACK_PATTERN_KEY8},
 193         {"FEEDBACK_PATTERN_KEY9", FEEDBACK_PATTERN_KEY9},
 194         {"FEEDBACK_PATTERN_KEY_STAR", FEEDBACK_PATTERN_KEY_STAR},
 195         {"FEEDBACK_PATTERN_KEY_SHARP", FEEDBACK_PATTERN_KEY_SHARP},
 196         {"FEEDBACK_PATTERN_KEY_BACK", FEEDBACK_PATTERN_KEY_BACK},
 197         {"FEEDBACK_PATTERN_HOLD", FEEDBACK_PATTERN_HOLD},
 198
 199         {"FEEDBACK_PATTERN_HW_TAP", FEEDBACK_PATTERN_HW_TAP},
 200         {"FEEDBACK_PATTERN_HW_HOLD", FEEDBACK_PATTERN_HW_HOLD},
 201
 202         {"FEEDBACK_PATTERN_MESSAGE", FEEDBACK_PATTERN_MESSAGE},
 203
 204         {"FEEDBACK_PATTERN_EMAIL", FEEDBACK_PATTERN_EMAIL},
 205
 206         {"FEEDBACK_PATTERN_WAKEUP", FEEDBACK_PATTERN_WAKEUP},
 207
 208         {"FEEDBACK_PATTERN_SCHEDULE", FEEDBACK_PATTERN_SCHEDULE},
 209
 210         {"FEEDBACK_PATTERN_TIMER", FEEDBACK_PATTERN_TIMER},
 211
 212         {"FEEDBACK_PATTERN_GENERAL", FEEDBACK_PATTERN_GENERAL},
 213
 214         {"FEEDBACK_PATTERN_POWERON", FEEDBACK_PATTERN_POWERON},
 215         {"FEEDBACK_PATTERN_POWEROFF", FEEDBACK_PATTERN_POWEROFF},
 216         {"FEEDBACK_PATTERN_CHARGERCONN", FEEDBACK_PATTERN_CHARGERCONN},
 217
 218         {"FEEDBACK_PATTERN_CHARGING_ERROR", FEEDBACK_PATTERN_CHARGING_ERROR},
 219
 220         {"FEEDBACK_PATTERN_FULLCHARGED", FEEDBACK_PATTERN_FULLCHARGED},
 221
 222         {"FEEDBACK_PATTERN_LOWBATT", FEEDBACK_PATTERN_LOWBATT},
 223
 224         {"FEEDBACK_PATTERN_LOCK", FEEDBACK_PATTERN_LOCK},
 225         {"FEEDBACK_PATTERN_UNLOCK", FEEDBACK_PATTERN_UNLOCK},
 226
 227         {"FEEDBACK_PATTERN_VIBRATION_ON", FEEDBACK_PATTERN_VIBRATION_ON},
 228         {"FEEDBACK_PATTERN_SILENT_OFF", FEEDBACK_PATTERN_SILENT_OFF},
 229         {"FEEDBACK_PATTERN_BT_CONNECTED", FEEDBACK_PATTERN_BT_CONNECTED},
 230         {"FEEDBACK_PATTERN_BT_DISCONNECTED", FEEDBACK_PATTERN_BT_DISCONNECTED},
 231
 232         {"FEEDBACK_PATTERN_LIST_REORDER", FEEDBACK_PATTERN_LIST_REORDER},
 233         {"FEEDBACK_PATTERN_LIST_SLIDER", FEEDBACK_PATTERN_LIST_SLIDER},
 234         {"FEEDBACK_PATTERN_VOLUME_KEY", FEEDBACK_PATTERN_VOLUME_KEY},
 235 };
 236
 237 typedef enum {
 238         PROFILE_NONE = -1,
 239         PROFILE_MOBILE = 1,
 240         PROFILE_WEARABLE = 2,
 241         PROFILE_COMMON = 3,
 242 } profile_e;
 243
 244 static int callstatus;
 245 static int lock_sndstatus;
 246 static int camerastatus;
 247 static int shutter_sndstatus;
 248 static int noti_vibstatus;
 249 static int vib_level;
 250 static int noti_level;
 251 static int feedbackstatus;
 252
 253 static char *profile_name = NULL;
 254
 255 #define PROFILE                 "tizen.org/feature/profile"
 256 #define PROFILE_MOBILE_STRING   "mobile"
 257 #define PROFILE_WEARABLE_STRING "wearable"
 258 #define PROFILE_COMMON_STRING   "common"
 259
 260 static profile_e get_profile(void)
 261 {
 262         int ret;
 263         int len;
 264         char *profile = NULL;
 265         static int set = 0;
 266
 267         if (set != 0)
 268                 return set;
 269
 270         ret = system_info_get_platform_string(PROFILE, &profile);
 271         if (ret < 0) {
 272                 _E("Cannot get profile(%d)", ret);
 273                 return PROFILE_NONE;
 274         }
 275
 276         len = strlen(profile) + 1;
 277         if (!strncmp(PROFILE_MOBILE_STRING, profile, len))
 278                 set = PROFILE_MOBILE;
 279         else if (!strncmp(PROFILE_WEARABLE_STRING, profile, len))
 280                 set = PROFILE_WEARABLE;
 281         else
 282                 set = PROFILE_COMMON;
 283
 284         free(profile);
 285         return set;
 286 }
 287
 288 static char *profile_get_name()
 289 {
 290         int prof;
 291
 292         if (profile_name)
 293                 return profile_name;
 294
 295         prof = get_profile();
 296
 297         if (prof == PROFILE_MOBILE)
 298                 profile_name = PROFILE_MOBILE_STRING;
 299         else if (prof == PROFILE_WEARABLE)
 300                 profile_name = PROFILE_WEARABLE_STRING;
 301         else
 302                 profile_name = PROFILE_COMMON_STRING;
 303
 304         return profile_name;
 305 }
 306
 307 /* Return how many patterns profile supports */
 308 static int profile_get_num_of_pattern()
 309 {
 310         int prof;
 311
 312         prof = get_profile();
 313
 314         if (prof == PROFILE_MOBILE)
 315                 return ARR_SIZE(mobile_str_pattern);
 316         else if (prof == PROFILE_WEARABLE)
 317                 return ARR_SIZE(wearable_str_pattern);
 318         else
 319                 return ARR_SIZE(common_str_pattern);
 320 }
 321
 322 static const char *profile_str_pattern(int pattern)
 323 {
 324         int prof;
 325         int i;
 326
 327         prof = get_profile();
 328
 329         if (prof == PROFILE_MOBILE) {
 330                 for (i = 0; i < profile_get_num_of_pattern(); i++) {
 331                         if (pattern == mobile_str_pattern[i].id) {
 332                                 return mobile_str_pattern[i].string;
 333                         }
 334                 }
 335         } else if (prof == PROFILE_WEARABLE) {
 336                 for (i = 0; i < profile_get_num_of_pattern(); i++) {
 337                         if (pattern == wearable_str_pattern[i].id)
 338                                 return wearable_str_pattern[i].string;
 339                 }
 340         } else {
 341                 for (i = 0; i < profile_get_num_of_pattern(); i++) {
 342                         if (pattern == common_str_pattern[i].id)
 343                                 return common_str_pattern[i].string;
 344                 }
 345         }
 346         return "";
 347
 348 }
 349
 350 static int profile_get_pattern_enum(char *pattern)
 351 {
 352         int prof;
 353         int i;
 354         int len;
 355
 356         prof = get_profile();
 357
 358         len = strlen(pattern);
 359         if (prof == PROFILE_MOBILE) {
 360                 for (i = 0; i < profile_get_num_of_pattern(); i++) {
 361                         if (!strncmp(pattern, mobile_str_pattern[i].string, len))
 362                                 return mobile_str_pattern[i].id;
 363                 }
 364         } else if (prof == PROFILE_WEARABLE) {
 365                 for (i = 0; i < profile_get_num_of_pattern(); i++) {
 366                         if (!strncmp(pattern, wearable_str_pattern[i].string, len))
 367                                 return wearable_str_pattern[i].id;
 368                 }
 369         } else {
 370                 for (i = 0; i < profile_get_num_of_pattern(); i++) {
 371                         if (!strncmp(pattern, common_str_pattern[i].string, len))
 372                                 return common_str_pattern[i].id;
 373                 }
 374         }
 375
 376         return -1;
 377 }
 378
 379 //LCOV_EXCL_START Not called Callback
 380 static void feedback_callstatus_cb(keynode_t *key, void* data)
 381 {
 382         callstatus = vconf_keynode_get_int(key);
 383 }
 384
 385 static void feedback_lock_sndstatus_cb(keynode_t *key, void* data)
 386 {
 387         lock_sndstatus = vconf_keynode_get_bool(key);
 388 }
 389
 390 static void feedback_camerastatus_cb(keynode_t *key, void* data)
 391 {
 392         camerastatus = vconf_keynode_get_int(key);
 393 }
 394
 395 static void feedback_noti_vibstatus_cb(keynode_t *key, void* data)
 396 {
 397         noti_vibstatus = vconf_keynode_get_bool(key);
 398 }
 399
 400 static void feedback_vib_cb(keynode_t *key, void* data)
 401 {
 402         vib_level = vconf_keynode_get_int(key);
 403 }
 404
 405 static void feedback_noti_cb(keynode_t *key, void* data)
 406 {
 407         noti_level = vconf_keynode_get_int(key);
 408 }
 409
 410 static void feedback_feedbackstatus_cb(keynode_t *key, void* data)
 411 {
 412         feedbackstatus = vconf_keynode_get_bool(key);
 413 }
 414 //LCOV_EXCL_STOP
 415
 416 static void profile_init(void)
 417 {
 418         int prof;
 419
 420         prof = get_profile();
 421
 422         if (prof == PROFILE_COMMON)
 423                 return;
 424         else if (prof == PROFILE_MOBILE) {
 425                 if (vconf_get_bool(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, &lock_sndstatus) < 0)
 426                         _W("VCONFKEY_SETAPPL_SOUND_LOCK_BOOL ==> FAIL!!"); //LCOV_EXCL_LINE
 427                 vconf_notify_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, feedback_lock_sndstatus_cb, NULL);
 428         }
 429
 430         /* check call status */
 431         if (vconf_get_int(VCONFKEY_CALL_STATE, &callstatus) < 0)
 432                 _W("VCONFKEY_CALL_STATE ==> FAIL!!"); //LCOV_EXCL_LINE
 433
 434         /* check camera status */
 435         if (vconf_get_int(VCONFKEY_CAMERA_STATE, &camerastatus) < 0)
 436                 _W("VCONFKEY_CAMERA_STATE ==> FAIL!!"); //LCOV_EXCL_LINE
 437
 438         /* shutter sound policy */
 439         /* This vconf is read just once, because this value is not changed in running time. */
 440         if (vconf_get_int(VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY, &shutter_sndstatus) < 0)
 441                 _W("VCONFKEY_CAMERA_SHUTTER_SOUND_POLICY ==> FAIL!!"); //LCOV_EXCL_LINE
 442
 443         /* check vibration status */
 444         if (vconf_get_bool(VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL, &noti_vibstatus) < 0)
 445                 _W("VCONFKEY_SETAPPL_VIBRATION_STATUS_BOOL ==> FAIL!!"); //LCOV_EXCL_LINE
 446
 447         /* check vib_level */
 448         if (vconf_get_int(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, &vib_level) < 0)
 449                 _W("VCONFKEY_FEEDBACK_VIBRATION_LEVEL_INT ==> FAIL!!"); //LCOV_EXCL_LINE
 450
 451         /* check noti_level */
 452         if (vconf_get_int(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, &noti_level) < 0)
 453                 _W("VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT ==> FAIL!!"); //LCOV_EXCL_LINE
 454
 455         /* feedback Init */
 456         if (vconf_get_bool(VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL, &feedbackstatus) < 0)
 457                 _W("VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL ==> FAIL!!"); //LCOV_EXCL_LINE
 458
 459         /* add watch for status value */
 460         vconf_notify_key_changed(VCONFKEY_CALL_STATE, feedback_callstatus_cb, NULL);
 461         vconf_notify_key_changed(VCONFKEY_CAMERA_STATE, feedback_camerastatus_cb, NULL);
 462         vconf_notify_key_changed(VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL, feedback_noti_vibstatus_cb, NULL);
 463         vconf_notify_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, feedback_vib_cb, NULL);
 464         vconf_notify_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, feedback_noti_cb, NULL);
 465         vconf_notify_key_changed(VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL, feedback_feedbackstatus_cb, NULL);
 466 }
 467
 468 static void profile_exit(void)
 469 {
 470         int prof;
 471
 472         prof = get_profile();
 473
 474         if (prof == PROFILE_COMMON)
 475                 return;
 476         else if (prof == PROFILE_MOBILE)
 477                 vconf_ignore_key_changed(VCONFKEY_SETAPPL_SOUND_LOCK_BOOL, feedback_lock_sndstatus_cb);
 478
 479         /* remove watch */
 480         vconf_ignore_key_changed(VCONFKEY_CALL_STATE, feedback_callstatus_cb);
 481         vconf_ignore_key_changed(VCONFKEY_CAMERA_STATE, feedback_camerastatus_cb);
 482         vconf_ignore_key_changed(VCONFKEY_SETAPPL_VIBRATE_WHEN_NOTIFICATION_BOOL, feedback_noti_vibstatus_cb);
 483         vconf_ignore_key_changed(VCONFKEY_SETAPPL_TOUCH_FEEDBACK_VIBRATION_LEVEL_INT, feedback_vib_cb);
 484         vconf_ignore_key_changed(VCONFKEY_SETAPPL_NOTI_VIBRATION_LEVEL_INT, feedback_noti_cb);
 485         vconf_ignore_key_changed(VCONFKEY_SETAPPL_HAPTIC_FEEDBACK_STATUS_BOOL, feedback_feedbackstatus_cb);
 486 }
 487
 488 static bool profile_get_switched_pattern(int pattern, int *switched)
 489 {
 490         int prof;
 491
 492         prof = get_profile();
 493
 494         if (prof == PROFILE_COMMON)
 495                 return false;
 496
 497         if (!switched)
 498                 return false;
 499
 500         if (callstatus == VCONFKEY_CALL_OFF)
 501                 return false;
 502
 503         /* in case of call connected or connecting */
 504         _D("Call status is connected or connecting."); //LCOV_EXCL_LINE
 505         if (pattern == FEEDBACK_PATTERN_MESSAGE)
 506                 *switched = FEEDBACK_PATTERN_MESSAGE_ON_CALL;
 507         else if (pattern == FEEDBACK_PATTERN_EMAIL)
 508                 *switched = FEEDBACK_PATTERN_EMAIL_ON_CALL;
 509         else if (pattern == FEEDBACK_PATTERN_WAKEUP)
 510                 *switched = FEEDBACK_PATTERN_WAKEUP_ON_CALL;
 511         else if (pattern == FEEDBACK_PATTERN_SCHEDULE)
 512                 *switched = FEEDBACK_PATTERN_SCHEDULE_ON_CALL;
 513         else if (pattern == FEEDBACK_PATTERN_TIMER)
 514                 *switched = FEEDBACK_PATTERN_TIMER_ON_CALL;
 515         else if (pattern == FEEDBACK_PATTERN_GENERAL)
 516                 *switched = FEEDBACK_PATTERN_GENERAL_ON_CALL;
 517         else if (pattern == FEEDBACK_PATTERN_CHARGERCONN)
 518                 *switched = FEEDBACK_PATTERN_CHARGERCONN_ON_CALL;
 519         else if (pattern == FEEDBACK_PATTERN_CHARGING_ERROR)
 520                 *switched = FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL;
 521         else if (pattern == FEEDBACK_PATTERN_FULLCHARGED)
 522                 *switched = FEEDBACK_PATTERN_FULLCHARGED_ON_CALL;
 523         else if (pattern == FEEDBACK_PATTERN_LOWBATT)
 524                 *switched = FEEDBACK_PATTERN_LOWBATT_ON_CALL;
 525         else
 526                 return false;
 527
 528         return true;
 529 }
 530
 531 static bool mobile_is_notification_type(int pattern)
 532 {
 533         switch (pattern) {
 534         case FEEDBACK_PATTERN_WAKEUP:
 535         case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 536         case FEEDBACK_PATTERN_TIMER:
 537         case FEEDBACK_PATTERN_TIMER_ON_CALL:
 538         case FEEDBACK_PATTERN_MESSAGE ... FEEDBACK_PATTERN_EMAIL_ON_CALL:
 539         case FEEDBACK_PATTERN_SCHEDULE:
 540         case FEEDBACK_PATTERN_SCHEDULE_ON_CALL:
 541         case FEEDBACK_PATTERN_GENERAL ... FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 542                 return true;
 543         }
 544         return false;
 545 }
 546
 547 static bool wearable_is_notification_type(int pattern)
 548 {
 549         switch (pattern) {
 550         case FEEDBACK_PATTERN_WAKEUP:
 551         case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 552         case FEEDBACK_PATTERN_TIMER:
 553         case FEEDBACK_PATTERN_TIMER_ON_CALL:
 554                 return false;
 555         case FEEDBACK_PATTERN_MESSAGE ... FEEDBACK_PATTERN_EMAIL_ON_CALL:
 556         case FEEDBACK_PATTERN_SCHEDULE:
 557         case FEEDBACK_PATTERN_SCHEDULE_ON_CALL:
 558         case FEEDBACK_PATTERN_GENERAL ... FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 559                 return true;
 560         }
 561         return false;
 562 }
 563
 564 static bool profile_is_notification_type(int pattern)
 565 {
 566         int prof;
 567
 568         prof = get_profile();
 569
 570         if (prof == PROFILE_MOBILE)
 571                 return mobile_is_notification_type(pattern);
 572         else if (prof == PROFILE_WEARABLE)
 573                 return wearable_is_notification_type(pattern);
 574         else
 575                 return false;
 576 }
 577
 578 static int mobile_get_priority(int pattern)
 579 {
 580         switch (pattern) {
 581         case FEEDBACK_PATTERN_TAP ... FEEDBACK_PATTERN_KEY_BACK:
 582                 return PRIORITY_MIN;
 583         case FEEDBACK_PATTERN_WAKEUP:
 584         case FEEDBACK_PATTERN_SCHEDULE:
 585         case FEEDBACK_PATTERN_TIMER:
 586                 return PRIORITY_HIGH;
 587         case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 588         case FEEDBACK_PATTERN_RINGER:
 589                 return PRIORITY_TOP;
 590         }
 591
 592         return PRIORITY_MIDDLE;
 593 }
 594
 595 static int profile_get_priority(int pattern)
 596 {
 597         int prof;
 598
 599         prof = get_profile();
 600
 601         if (prof == PROFILE_MOBILE)
 602                 return mobile_get_priority(pattern);
 603         else
 604                 return PRIORITY_MIDDLE;
 605 }
 606
 607 static bool mobile_get_always_alert_case(int type, int pattern)
 608 {
 609         switch (pattern) {
 610         case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 611         case FEEDBACK_PATTERN_HOLD:
 612                 if (CHECK_VIBRATION(type) && feedbackstatus)
 613                         return true;
 614                 break;
 615         case FEEDBACK_PATTERN_SIP:
 616                 if (CHECK_VIBRATION(type))
 617                         return true;
 618                 break;
 619         case FEEDBACK_PATTERN_MESSAGE:
 620         case FEEDBACK_PATTERN_EMAIL:
 621                 if (CHECK_VIBRATION(type) && noti_vibstatus)
 622                         return true;
 623                 break;
 624         case FEEDBACK_PATTERN_TIMER:
 625         case FEEDBACK_PATTERN_TIMER_ON_CALL:
 626                 if (CHECK_VIBRATION(type))
 627                         return true;
 628                 break;
 629         case FEEDBACK_PATTERN_WAKEUP:
 630         case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 631                 return true;
 632         case FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 633         case FEEDBACK_PATTERN_EMAIL_ON_CALL:
 634         case FEEDBACK_PATTERN_GENERAL_ON_CALL:
 635                 break;
 636         case FEEDBACK_PATTERN_CHARGERCONN_ON_CALL:
 637         case FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL:
 638         case FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 639                 /* no matter sound profile */
 640                 if (CHECK_VIBRATION(type))
 641                         return true;
 642                 break;
 643         case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 644         case FEEDBACK_PATTERN_OUTGOING_CALL:
 645                 return true;
 646         case FEEDBACK_PATTERN_SCREEN_CAPTURE:
 647                 if (CHECK_SOUND(type) && camerastatus && shutter_sndstatus)
 648                         return true;
 649                 break;
 650         case FEEDBACK_PATTERN_RINGER:
 651                 return true;
 652         default:
 653                 break;
 654         }
 655         return false;
 656 }
 657
 658 static bool wearable_get_always_alert_case(int type, int pattern)
 659 {
 660         if (CHECK_SOUND(type)) {
 661                 switch (pattern) {
 662                 case FEEDBACK_PATTERN_WAKEUP:
 663                 case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 664                         return true;
 665                 case FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 666                 case FEEDBACK_PATTERN_EMAIL_ON_CALL:
 667                 case FEEDBACK_PATTERN_GENERAL_ON_CALL:
 668                         break;
 669                 case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 670                         return true;
 671                 case FEEDBACK_PATTERN_SCREEN_CAPTURE:
 672                         if (camerastatus && shutter_sndstatus)
 673                                 return true;
 674                         break;
 675                 case FEEDBACK_PATTERN_OUTGOING_CALL:
 676                         return true;
 677                 default:
 678                         break;
 679                 }
 680         } else if (CHECK_VIBRATION(type)) {
 681                 switch (pattern) {
 682                 case FEEDBACK_PATTERN_TAP:
 683                 case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 684                 case FEEDBACK_PATTERN_HOLD:
 685                         if (feedbackstatus)
 686                                 return true;
 687                         break;
 688                 case FEEDBACK_PATTERN_MESSAGE:
 689                 case FEEDBACK_PATTERN_EMAIL:
 690                 case FEEDBACK_PATTERN_GENERAL:
 691                 case FEEDBACK_PATTERN_SCHEDULE:
 692                         if (noti_vibstatus)
 693                                 return true;
 694                         break;
 695                 case FEEDBACK_PATTERN_SIP:
 696                 case FEEDBACK_PATTERN_TIMER:
 697                 case FEEDBACK_PATTERN_TIMER_ON_CALL:
 698                 case FEEDBACK_PATTERN_WAKEUP:
 699                 case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 700                 case FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 701                 case FEEDBACK_PATTERN_EMAIL_ON_CALL:
 702                 case FEEDBACK_PATTERN_GENERAL_ON_CALL:
 703                 case FEEDBACK_PATTERN_CHARGERCONN_ON_CALL:
 704                 case FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL:
 705                 case FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 706                 case FEEDBACK_PATTERN_BT_DISCONNECTED:
 707                 case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 708                 case FEEDBACK_PATTERN_OUTGOING_CALL:
 709                         return true;
 710                 default:
 711                         break;
 712                 }
 713         }
 714         return false;
 715 }
 716
 717 static bool common_get_always_alert_case(int type, int pattern)
 718 {
 719         switch (pattern) {
 720         case FEEDBACK_PATTERN_SIP:
 721         case FEEDBACK_PATTERN_TIMER:
 722                 if (CHECK_VIBRATION(type))
 723                         return true;
 724                 break;
 725         case FEEDBACK_PATTERN_WAKEUP:
 726                 return true;
 727         default:
 728                 break;
 729         }
 730         return false;
 731 }
 732
 733 static bool profile_get_always_alert_case(int type, int pattern)
 734 {
 735         int prof;
 736
 737         prof = get_profile();
 738
 739         if (prof == PROFILE_MOBILE)
 740                 return mobile_get_always_alert_case(type, pattern);
 741         else if (prof == PROFILE_WEARABLE)
 742                 return wearable_get_always_alert_case(type, pattern);
 743         else
 744                 return common_get_always_alert_case(type, pattern);
 745 }
 746
 747 static bool mobile_get_always_off_case(int type, int pattern)
 748 {
 749         int ret;
 750
 751         /* check if the state of voice recorder is recording */
 752         if (vconf_get_int(VCONFKEY_RECORDER_STATE, &ret) < 0) {
 753                 _W("fail to get media sound status, status will be zero"); //LCOV_EXCL_LINE
 754                 ret = 0;
 755         }
 756
 757         if (CHECK_SOUND(type) && ret == VCONFKEY_RECORDER_STATE_RECORDING) {
 758                 _D("voice recording status is RECORDING"); //LCOV_EXCL_LINE
 759                 return true;
 760         }
 761
 762         switch (pattern) {
 763         case FEEDBACK_PATTERN_TAP:
 764         case FEEDBACK_PATTERN_HOLD ... FEEDBACK_PATTERN_HW_HOLD:
 765                 if (CHECK_SOUND(type) && !is_touch_sndstatus())
 766                         return true;
 767                 break;
 768         case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 769                 if (CHECK_SOUND(type) && !is_keytone_sndstatus())
 770                         return true;
 771                 else if (CHECK_VIBRATION(type) && !feedbackstatus)
 772                         return true;
 773                 break;
 774         case FEEDBACK_PATTERN_LOCK:
 775         case FEEDBACK_PATTERN_UNLOCK:
 776                 if (CHECK_SOUND(type) && !lock_sndstatus)
 777                         return true;
 778                 break;
 779         default:
 780                 break;
 781         }
 782         return false;
 783 }
 784
 785 static bool wearable_is_system_type(int pattern)
 786 {
 787         switch (pattern) {
 788         case FEEDBACK_PATTERN_POWERON ... FEEDBACK_PATTERN_VOLUME_KEY:
 789                 return true;
 790         }
 791         return false;
 792 }
 793
 794 static bool wearable_get_always_off_case(int type, int pattern)
 795 {
 796         int ret;
 797
 798         if (CHECK_SOUND(type)) {
 799                 if ((wearable_is_notification_type(pattern) || wearable_is_system_type(pattern)) &&
 800                     callstatus) {
 801                         _W("skip %d sound during call", pattern);
 802                         return true;
 803                 }
 804                 /* check if the state of voice recorder is recording */
 805                 if (vconf_get_int(VCONFKEY_RECORDER_STATE, &ret) == 0 &&
 806                     ret == VCONFKEY_RECORDER_STATE_RECORDING) {
 807                         _D("voice recording status is RECORDING");
 808                         return true;
 809                 }
 810
 811                 switch (pattern) {
 812                 case FEEDBACK_PATTERN_TAP:
 813                 case FEEDBACK_PATTERN_HOLD ... FEEDBACK_PATTERN_HW_HOLD:
 814                         if (!is_touch_sndstatus())
 815                                 return true;
 816                         break;
 817                 case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 818                         if (!is_keytone_sndstatus())
 819                                 return true;
 820                         break;
 821                 default:
 822                         break;
 823                 }
 824         } else if (CHECK_VIBRATION(type)) {
 825                 switch (pattern) {
 826                 case FEEDBACK_PATTERN_TAP:
 827                 case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 828                 case FEEDBACK_PATTERN_HOLD:
 829                         if (!feedbackstatus)
 830                                 return true;
 831                         break;
 832                 default:
 833                         break;
 834                 }
 835         }
 836         return false;
 837 }
 838
 839 static bool common_get_always_off_case(int type, int pattern)
 840 {
 841         switch (pattern) {
 842         case FEEDBACK_PATTERN_TAP ... FEEDBACK_PATTERN_SIP:
 843         case FEEDBACK_PATTERN_HOLD ... FEEDBACK_PATTERN_HW_HOLD:
 844                 if (CHECK_SOUND(type) && !is_touch_sndstatus())
 845                         return true;
 846                 break;
 847         case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 848                 if (CHECK_SOUND(type) && !is_keytone_sndstatus())
 849                         return true;
 850                 break;
 851         default:
 852                 break;
 853         }
 854         return false;
 855 }
 856
 857 static bool profile_get_always_off_case(int type, int pattern)
 858 {
 859         int prof;
 860
 861         prof = get_profile();
 862
 863         if (prof == PROFILE_MOBILE)
 864                 return mobile_get_always_off_case(type, pattern);
 865         else if (prof == PROFILE_WEARABLE)
 866                 return wearable_get_always_off_case(type, pattern);
 867         else
 868                 return common_get_always_off_case(type, pattern);
 869 }
 870
 871 static int mobile_get_strength_type(int type, int pattern)
 872 {
 873         if (CHECK_SOUND(type)) {
 874                 if (pattern == FEEDBACK_PATTERN_TAP)
 875                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_TOUCH;
 876                 else if (pattern >= FEEDBACK_PATTERN_KEY0 && pattern <= FEEDBACK_PATTERN_KEY_BACK)
 877                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_DIALER;
 878                 else if (pattern == FEEDBACK_PATTERN_VOLUME_KEY)
 879                         return VOLUME_TYPE_RINGTONE;
 880                 else if (camerastatus && shutter_sndstatus && pattern == FEEDBACK_PATTERN_SCREEN_CAPTURE)
 881                         return VOLUME_TYPE_FIXED;
 882                 else
 883                         return VOLUME_TYPE_SYSTEM;
 884         } else if (CHECK_VIBRATION(type)) {
 885                 if (pattern >= FEEDBACK_PATTERN_MESSAGE &&
 886                     pattern <= FEEDBACK_PATTERN_GENERAL)
 887                         return noti_level * HAPTIC_FEEDBACK_STEP;
 888                 else
 889                         return vib_level * HAPTIC_FEEDBACK_STEP;
 890         }
 891
 892         return -EINVAL;
 893 }
 894
 895 static int wearable_get_strength_type(int type, int pattern)
 896 {
 897         if (CHECK_SOUND(type)) {
 898                 if (pattern == FEEDBACK_PATTERN_TAP)
 899                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_TOUCH;
 900                 else if (pattern >= FEEDBACK_PATTERN_KEY0 && pattern <= FEEDBACK_PATTERN_KEY_BACK)
 901                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_DIALER;
 902                 else if (pattern == FEEDBACK_PATTERN_VOLUME_KEY || pattern == FEEDBACK_PATTERN_SILENT_OFF)
 903                         return VOLUME_TYPE_RINGTONE;
 904                 else if (camerastatus && shutter_sndstatus && pattern == FEEDBACK_PATTERN_SCREEN_CAPTURE)
 905                         return VOLUME_TYPE_FIXED;
 906                 return VOLUME_TYPE_SYSTEM;
 907         } else if (CHECK_VIBRATION(type)) {
 908                 if (pattern >= FEEDBACK_PATTERN_TAP && pattern <= FEEDBACK_PATTERN_HW_HOLD) {
 909                         _D("use default level");
 910                         return DEFAULT_VIB_LEVEL * HAPTIC_FEEDBACK_STEP;
 911                 }
 912                 /* if call status is ON, vibration magnitude is 20% */
 913                 if (pattern != FEEDBACK_PATTERN_RINGER &&
 914                     (callstatus == VCONFKEY_CALL_VOICE_ACTIVE || callstatus == VCONFKEY_CALL_VIDEO_ACTIVE)) {
 915                         _W("force change weak level");
 916                         return HAPTIC_FEEDBACK_STEP;
 917                 }
 918                 return noti_level * HAPTIC_FEEDBACK_STEP;
 919         }
 920         return -EINVAL;
 921 }
 922
 923 static int common_get_strength_type(int type, int pattern)
 924 {
 925         if (CHECK_SOUND(type)) {
 926                 if (pattern == FEEDBACK_PATTERN_TAP)
 927                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_TOUCH;
 928                 else if (pattern >= FEEDBACK_PATTERN_KEY0 && pattern <= FEEDBACK_PATTERN_KEY_BACK)
 929                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_DIALER;
 930                 else if (pattern == FEEDBACK_PATTERN_VOLUME_KEY)
 931                         return VOLUME_TYPE_RINGTONE;
 932                 else
 933                         return VOLUME_TYPE_SYSTEM;
 934         } else if (CHECK_VIBRATION(type)) {
 935                 return DEFAULT_VIB_LEVEL * HAPTIC_FEEDBACK_STEP;
 936         }
 937
 938         return -EINVAL;
 939 }
 940
 941 static int profile_get_strength_type(int type, int pattern)
 942 {
 943         int prof;
 944
 945         prof = get_profile();
 946
 947         if (prof == PROFILE_MOBILE)
 948                 return mobile_get_strength_type(type, pattern);
 949         else if (prof == PROFILE_WEARABLE)
 950                 return wearable_get_strength_type(type, pattern);
 951         else
 952                 return common_get_strength_type(type, pattern);
 953 }
 954
 955 static const struct profile_ops feedback_profile_ops = {
 956         .profile               = profile_get_name,
 957         .init                  = profile_init,
 958         .exit                  = profile_exit,
 959         .get_switched_pattern  = profile_get_switched_pattern,
 960         .get_always_alert_case = profile_get_always_alert_case,
 961         .get_always_off_case   = profile_get_always_off_case,
 962         .get_strength_type     = profile_get_strength_type,
 963         .get_priority          = profile_get_priority,
 964         .is_notification_type  = profile_is_notification_type,
 965         .max_type              = FEEDBACK_TYPE_END,
 966         .max_pattern           = FEEDBACK_PATTERN_INTERNAL_END,
 967         .str_type              = profile_str_type,
 968         .get_num_of_pattern    = profile_get_num_of_pattern,
 969         .str_pattern           = profile_str_pattern,
 970         .get_pattern_enum      = profile_get_pattern_enum,
 971 };
 972
 973 PROFILE_OPS_REGISTER(&feedback_profile_ops);