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