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