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 mobile_get_priority(int pattern)
 583 {
 584         switch (pattern) {
 585         case FEEDBACK_PATTERN_TAP ... FEEDBACK_PATTERN_KEY_BACK:
 586                 return PRIORITY_MIN;
 587         case FEEDBACK_PATTERN_WAKEUP:
 588         case FEEDBACK_PATTERN_SCHEDULE:
 589         case FEEDBACK_PATTERN_TIMER:
 590                 return PRIORITY_HIGH;
 591         case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 592         case FEEDBACK_PATTERN_RINGER:
 593                 return PRIORITY_TOP;
 594         }
 595
 596         return PRIORITY_MIDDLE;
 597 }
 598
 599 static int profile_get_priority(int pattern)
 600 {
 601         int prof;
 602
 603         prof = get_profile();
 604
 605         if (prof == PROFILE_MOBILE)
 606                 return mobile_get_priority(pattern);
 607         else
 608                 return PRIORITY_MIDDLE;
 609 }
 610
 611 static bool mobile_get_always_alert_case(int type, int pattern)
 612 {
 613         switch (pattern) {
 614         case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 615         case FEEDBACK_PATTERN_HOLD:
 616                 if (CHECK_VIBRATION(type) && feedbackstatus)
 617                         return true;
 618                 break;
 619         case FEEDBACK_PATTERN_SIP:
 620                 if (CHECK_VIBRATION(type))
 621                         return true;
 622                 break;
 623         case FEEDBACK_PATTERN_MESSAGE:
 624         case FEEDBACK_PATTERN_EMAIL:
 625                 if (CHECK_VIBRATION(type) && noti_vibstatus)
 626                         return true;
 627                 break;
 628         case FEEDBACK_PATTERN_TIMER:
 629         case FEEDBACK_PATTERN_TIMER_ON_CALL:
 630                 if (CHECK_VIBRATION(type))
 631                         return true;
 632                 break;
 633         case FEEDBACK_PATTERN_WAKEUP:
 634         case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 635                 return true;
 636         case FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 637         case FEEDBACK_PATTERN_EMAIL_ON_CALL:
 638         case FEEDBACK_PATTERN_GENERAL_ON_CALL:
 639                 break;
 640         case FEEDBACK_PATTERN_CHARGERCONN_ON_CALL:
 641         case FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL:
 642         case FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 643                 /* no matter sound profile */
 644                 if (CHECK_VIBRATION(type))
 645                         return true;
 646                 break;
 647         case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 648         case FEEDBACK_PATTERN_OUTGOING_CALL:
 649                 return true;
 650         case FEEDBACK_PATTERN_SCREEN_CAPTURE:
 651                 if (CHECK_SOUND(type) && camerastatus && shutter_sndstatus)
 652                         return true;
 653                 break;
 654         case FEEDBACK_PATTERN_RINGER:
 655                 return true;
 656         default:
 657                 break;
 658         }
 659         return false;
 660 }
 661
 662 static bool wearable_get_always_alert_case(int type, int pattern)
 663 {
 664         if (CHECK_SOUND(type)) {
 665                 switch (pattern) {
 666                 case FEEDBACK_PATTERN_WAKEUP:
 667                 case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 668                         return true;
 669                 case FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 670                 case FEEDBACK_PATTERN_EMAIL_ON_CALL:
 671                 case FEEDBACK_PATTERN_GENERAL_ON_CALL:
 672                         break;
 673                 case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 674                         return true;
 675                 case FEEDBACK_PATTERN_SCREEN_CAPTURE:
 676                         if (camerastatus && shutter_sndstatus)
 677                                 return true;
 678                         break;
 679                 case FEEDBACK_PATTERN_OUTGOING_CALL:
 680                         return true;
 681                 default:
 682                         break;
 683                 }
 684         } else if (CHECK_VIBRATION(type)) {
 685                 switch (pattern) {
 686                 case FEEDBACK_PATTERN_TAP:
 687                 case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 688                 case FEEDBACK_PATTERN_HOLD:
 689                         if (feedbackstatus)
 690                                 return true;
 691                         break;
 692                 case FEEDBACK_PATTERN_MESSAGE:
 693                 case FEEDBACK_PATTERN_EMAIL:
 694                 case FEEDBACK_PATTERN_GENERAL:
 695                 case FEEDBACK_PATTERN_SCHEDULE:
 696                         if (noti_vibstatus)
 697                                 return true;
 698                         break;
 699                 case FEEDBACK_PATTERN_SIP:
 700                 case FEEDBACK_PATTERN_TIMER:
 701                 case FEEDBACK_PATTERN_TIMER_ON_CALL:
 702                 case FEEDBACK_PATTERN_WAKEUP:
 703                 case FEEDBACK_PATTERN_WAKEUP_ON_CALL:
 704                 case FEEDBACK_PATTERN_MESSAGE_ON_CALL:
 705                 case FEEDBACK_PATTERN_EMAIL_ON_CALL:
 706                 case FEEDBACK_PATTERN_GENERAL_ON_CALL:
 707                 case FEEDBACK_PATTERN_CHARGERCONN_ON_CALL:
 708                 case FEEDBACK_PATTERN_CHARGING_ERROR_ON_CALL:
 709                 case FEEDBACK_PATTERN_LOWBATT_ON_CALL:
 710                 case FEEDBACK_PATTERN_BT_DISCONNECTED:
 711                 case FEEDBACK_PATTERN_SEND_SOS_MESSAGE:
 712                 case FEEDBACK_PATTERN_OUTGOING_CALL:
 713                         return true;
 714                 default:
 715                         break;
 716                 }
 717         }
 718         return false;
 719 }
 720
 721 static bool common_get_always_alert_case(int type, int pattern)
 722 {
 723         switch (pattern) {
 724         case FEEDBACK_PATTERN_SIP:
 725         case FEEDBACK_PATTERN_TIMER:
 726                 if (CHECK_VIBRATION(type))
 727                         return true;
 728                 break;
 729         case FEEDBACK_PATTERN_WAKEUP:
 730                 return true;
 731         default:
 732                 break;
 733         }
 734         return false;
 735 }
 736
 737 static bool profile_get_always_alert_case(int type, int pattern)
 738 {
 739         int prof;
 740
 741         prof = get_profile();
 742
 743         if (prof == PROFILE_MOBILE)
 744                 return mobile_get_always_alert_case(type, pattern);
 745         else if (prof == PROFILE_WEARABLE)
 746                 return wearable_get_always_alert_case(type, pattern);
 747         else
 748                 return common_get_always_alert_case(type, pattern);
 749 }
 750
 751 static bool mobile_get_always_off_case(int type, int pattern)
 752 {
 753         int ret;
 754
 755         /* check if the state of voice recorder is recording */
 756         if (vconf_get_int(VCONFKEY_RECORDER_STATE, &ret) < 0) {
 757                 _W("fail to get media sound status, status will be zero"); //LCOV_EXCL_LINE
 758                 ret = 0;
 759         }
 760
 761         if (CHECK_SOUND(type) && ret == VCONFKEY_RECORDER_STATE_RECORDING) {
 762                 _D("voice recording status is RECORDING"); //LCOV_EXCL_LINE
 763                 return true;
 764         }
 765
 766         switch (pattern) {
 767         case FEEDBACK_PATTERN_TAP:
 768         case FEEDBACK_PATTERN_HOLD ... FEEDBACK_PATTERN_HW_HOLD:
 769                 if (CHECK_SOUND(type) && !is_touch_sndstatus())
 770                         return true;
 771                 break;
 772         case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 773                 if (CHECK_SOUND(type) && !is_keytone_sndstatus())
 774                         return true;
 775                 else if (CHECK_VIBRATION(type) && !feedbackstatus)
 776                         return true;
 777                 break;
 778         case FEEDBACK_PATTERN_LOCK:
 779         case FEEDBACK_PATTERN_UNLOCK:
 780                 if (CHECK_SOUND(type) && !lock_sndstatus)
 781                         return true;
 782                 break;
 783         default:
 784                 break;
 785         }
 786         return false;
 787 }
 788
 789 static bool wearable_is_system_type(int pattern)
 790 {
 791         switch (pattern) {
 792         case FEEDBACK_PATTERN_POWERON ... FEEDBACK_PATTERN_VOLUME_KEY:
 793                 return true;
 794         }
 795         return false;
 796 }
 797
 798 static bool wearable_get_always_off_case(int type, int pattern)
 799 {
 800         int ret;
 801
 802         if (CHECK_SOUND(type)) {
 803                 if ((wearable_is_notification_type(pattern) || wearable_is_system_type(pattern)) &&
 804                     callstatus) {
 805                         _W("skip %s sound during call", profile_str_pattern(pattern));
 806                         return true;
 807                 }
 808                 /* check if the state of voice recorder is recording */
 809                 if (vconf_get_int(VCONFKEY_RECORDER_STATE, &ret) == 0 &&
 810                     ret == VCONFKEY_RECORDER_STATE_RECORDING) {
 811                         _D("voice recording status is RECORDING");
 812                         return true;
 813                 }
 814
 815                 switch (pattern) {
 816                 case FEEDBACK_PATTERN_TAP:
 817                 case FEEDBACK_PATTERN_HOLD ... FEEDBACK_PATTERN_HW_HOLD:
 818                         if (!is_touch_sndstatus())
 819                                 return true;
 820                         break;
 821                 case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 822                         if (!is_keytone_sndstatus())
 823                                 return true;
 824                         break;
 825                 default:
 826                         break;
 827                 }
 828         } else if (CHECK_VIBRATION(type)) {
 829                 switch (pattern) {
 830                 case FEEDBACK_PATTERN_TAP:
 831                 case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 832                 case FEEDBACK_PATTERN_HOLD:
 833                         if (!feedbackstatus)
 834                                 return true;
 835                         break;
 836                 default:
 837                         break;
 838                 }
 839         }
 840         return false;
 841 }
 842
 843 static bool common_get_always_off_case(int type, int pattern)
 844 {
 845         switch (pattern) {
 846         case FEEDBACK_PATTERN_TAP ... FEEDBACK_PATTERN_SIP:
 847         case FEEDBACK_PATTERN_HOLD ... FEEDBACK_PATTERN_HW_HOLD:
 848                 if (CHECK_SOUND(type) && !is_touch_sndstatus())
 849                         return true;
 850                 break;
 851         case FEEDBACK_PATTERN_KEY0 ... FEEDBACK_PATTERN_KEY_BACK:
 852                 if (CHECK_SOUND(type) && !is_keytone_sndstatus())
 853                         return true;
 854                 break;
 855         default:
 856                 break;
 857         }
 858         return false;
 859 }
 860
 861 static bool profile_get_always_off_case(int type, int pattern)
 862 {
 863         int prof;
 864
 865         prof = get_profile();
 866
 867         if (prof == PROFILE_MOBILE)
 868                 return mobile_get_always_off_case(type, pattern);
 869         else if (prof == PROFILE_WEARABLE)
 870                 return wearable_get_always_off_case(type, pattern);
 871         else
 872                 return common_get_always_off_case(type, pattern);
 873 }
 874
 875 static int mobile_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)
 883                         return VOLUME_TYPE_RINGTONE;
 884                 else if (camerastatus && shutter_sndstatus && pattern == FEEDBACK_PATTERN_SCREEN_CAPTURE)
 885                         return VOLUME_TYPE_FIXED;
 886                 else
 887                         return VOLUME_TYPE_SYSTEM;
 888         } else if (CHECK_VIBRATION(type)) {
 889                 if (pattern >= FEEDBACK_PATTERN_MESSAGE &&
 890                     pattern <= FEEDBACK_PATTERN_GENERAL)
 891                         return noti_level * HAPTIC_FEEDBACK_STEP;
 892                 else
 893                         return vib_level * HAPTIC_FEEDBACK_STEP;
 894         }
 895
 896         return -EINVAL;
 897 }
 898
 899 static int wearable_get_strength_type(int type, int pattern)
 900 {
 901         if (CHECK_SOUND(type)) {
 902                 if (pattern == FEEDBACK_PATTERN_TAP)
 903                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_TOUCH;
 904                 else if (pattern >= FEEDBACK_PATTERN_KEY0 && pattern <= FEEDBACK_PATTERN_KEY_BACK)
 905                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_DIALER;
 906                 else if (pattern == FEEDBACK_PATTERN_VOLUME_KEY || pattern == FEEDBACK_PATTERN_SILENT_OFF)
 907                         return VOLUME_TYPE_RINGTONE;
 908                 else if (camerastatus && shutter_sndstatus && pattern == FEEDBACK_PATTERN_SCREEN_CAPTURE)
 909                         return VOLUME_TYPE_FIXED;
 910                 return VOLUME_TYPE_SYSTEM;
 911         } else if (CHECK_VIBRATION(type)) {
 912                 if (pattern >= FEEDBACK_PATTERN_TAP && pattern <= FEEDBACK_PATTERN_HW_HOLD) {
 913                         _D("use default level");
 914                         return DEFAULT_VIB_LEVEL * HAPTIC_FEEDBACK_STEP;
 915                 }
 916                 /* if call status is ON, vibration magnitude is 20% */
 917                 if (pattern != FEEDBACK_PATTERN_RINGER &&
 918                     (callstatus == VCONFKEY_CALL_VOICE_ACTIVE || callstatus == VCONFKEY_CALL_VIDEO_ACTIVE)) {
 919                         _W("force change weak level");
 920                         return HAPTIC_FEEDBACK_STEP;
 921                 }
 922                 return noti_level * HAPTIC_FEEDBACK_STEP;
 923         }
 924         return -EINVAL;
 925 }
 926
 927 static int common_get_strength_type(int type, int pattern)
 928 {
 929         if (CHECK_SOUND(type)) {
 930                 if (pattern == FEEDBACK_PATTERN_TAP)
 931                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_TOUCH;
 932                 else if (pattern >= FEEDBACK_PATTERN_KEY0 && pattern <= FEEDBACK_PATTERN_KEY_BACK)
 933                         return VOLUME_TYPE_SYSTEM|VOLUME_GAIN_DIALER;
 934                 else if (pattern == FEEDBACK_PATTERN_VOLUME_KEY)
 935                         return VOLUME_TYPE_RINGTONE;
 936                 else
 937                         return VOLUME_TYPE_SYSTEM;
 938         } else if (CHECK_VIBRATION(type)) {
 939                 return DEFAULT_VIB_LEVEL * HAPTIC_FEEDBACK_STEP;
 940         }
 941
 942         return -EINVAL;
 943 }
 944
 945 static int profile_get_strength_type(int type, int pattern)
 946 {
 947         int prof;
 948
 949         prof = get_profile();
 950
 951         if (prof == PROFILE_MOBILE)
 952                 return mobile_get_strength_type(type, pattern);
 953         else if (prof == PROFILE_WEARABLE)
 954                 return wearable_get_strength_type(type, pattern);
 955         else
 956                 return common_get_strength_type(type, pattern);
 957 }
 958
 959 static const struct profile_ops feedback_profile_ops = {
 960         .profile               = profile_get_name,
 961         .init                  = profile_init,
 962         .exit                  = profile_exit,
 963         .get_switched_pattern  = profile_get_switched_pattern,
 964         .get_always_alert_case = profile_get_always_alert_case,
 965         .get_always_off_case   = profile_get_always_off_case,
 966         .get_strength_type     = profile_get_strength_type,
 967         .get_priority          = profile_get_priority,
 968         .is_notification_type  = profile_is_notification_type,
 969         .max_type              = FEEDBACK_TYPE_END,
 970         .max_pattern           = FEEDBACK_PATTERN_INTERNAL_END,
 971         .str_type              = profile_str_type,
 972         .str_pattern           = profile_str_pattern,
 973 };
 974
 975 PROFILE_OPS_REGISTER(&feedback_profile_ops);