src/mm_radio.c

   1 /*
   2  * mm_radio.c
   3  *
   4  * Copyright (c) 2000 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 /*===========================================================================================
  21 |                                                                                                                                                                                       |
  22 |  INCLUDE FILES                                                                                                                                                        |
  23 |                                                                                                                                                                                       |
  24 ========================================================================================== */
  25
  26 #include <string.h>
  27 #include <glib.h>
  28 #include <mm_types.h>
  29 #include <mm_message.h>
  30 #include "mm_radio.h"
  31 #ifdef TIZEN_FEATURE_RADIO_HAL
  32 #include "mm_radio_priv_hal.h"
  33 #else
  34 #include "mm_radio_priv.h"
  35 #endif
  36 #include "mm_radio_utils.h"
  37 #include "mm_debug.h"
  38
  39 /*===========================================================================================
  40 |                                                                                                                                                                                       |
  41 |  LOCAL DEFINITIONS AND DECLARATIONS FOR MODULE                                                                                        |
  42 |                                                                                                                                                                                       |
  43 ========================================================================================== */
  44
  45 /*---------------------------------------------------------------------------
  46 |    GLOBAL CONSTANT DEFINITIONS:                                                                                       |
  47 ---------------------------------------------------------------------------*/
  48
  49 /*---------------------------------------------------------------------------
  50 |    IMPORTED VARIABLE DECLARATIONS:                                                                            |
  51 ---------------------------------------------------------------------------*/
  52
  53 /*---------------------------------------------------------------------------
  54 |    IMPORTED FUNCTION DECLARATIONS:                                                                            |
  55 ---------------------------------------------------------------------------*/
  56
  57 /*---------------------------------------------------------------------------
  58 |    LOCAL #defines:                                                                                                            |
  59 ---------------------------------------------------------------------------*/
  60
  61 /*---------------------------------------------------------------------------
  62 |    LOCAL CONSTANT DEFINITIONS:                                                                                        |
  63 ---------------------------------------------------------------------------*/
  64
  65 /*---------------------------------------------------------------------------
  66 |    LOCAL DATA TYPE DEFINITIONS:                                                                                       |
  67 ---------------------------------------------------------------------------*/
  68
  69 /*---------------------------------------------------------------------------
  70 |    GLOBAL VARIABLE DEFINITIONS:                                                                                       |
  71 ---------------------------------------------------------------------------*/
  72
  73 /*---------------------------------------------------------------------------
  74 |    LOCAL VARIABLE DEFINITIONS:                                                                                        |
  75 ---------------------------------------------------------------------------*/
  76
  77 /*---------------------------------------------------------------------------
  78 |    LOCAL FUNCTION PROTOTYPES:                                                                                         |
  79 ---------------------------------------------------------------------------*/
  80
  81 /*===========================================================================
  82 |                                                                                                                                                       |
  83 |  FUNCTION DEFINITIONS                                                                                                         |
  84 |                                                                                                                                                       |
  85 ========================================================================== */
  86
  87 int mm_radio_create(MMHandleType *hradio)
  88 {
  89         int result = MM_ERROR_NONE;
  90         mm_radio_t *new_radio = NULL;
  91
  92         MMRADIO_LOG_FENTER();
  93
  94         return_val_if_fail(hradio, MM_ERROR_RADIO_NOT_INITIALIZED);
  95
  96         /* alloc radio structure */
  97         new_radio = (mm_radio_t *)malloc(sizeof(mm_radio_t));
  98         if (!new_radio) {
  99                 debug_critical("cannot allocate memory for radio\n");
 100                 goto ERROR;
 101         }
 102         memset(new_radio, 0, sizeof(mm_radio_t));
 103
 104         /* internal creation stuffs */
 105         result = _mmradio_create_radio(new_radio);
 106
 107         if (result != MM_ERROR_NONE) {
 108                 debug_error("radio creation failed\n");
 109                 goto ERROR;
 110         }
 111
 112         *hradio = (MMHandleType)new_radio;
 113
 114         MMRADIO_LOG_FLEAVE();
 115
 116         return result;
 117
 118 ERROR:
 119
 120         if (new_radio)
 121                 MMRADIO_FREEIF(new_radio);
 122
 123         *hradio = (MMHandleType)0;
 124
 125         MMRADIO_LOG_FLEAVE();
 126
 127         /* FIXIT : need to specify more error case */
 128         return result;
 129 }
 130
 131 int mm_radio_destroy(MMHandleType hradio)
 132 {
 133         int result = MM_ERROR_NONE;
 134         mm_radio_t *radio = (mm_radio_t *)hradio;
 135
 136         MMRADIO_LOG_FENTER();
 137
 138         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 139
 140         result = _mmradio_destroy(radio);
 141
 142         if (result != MM_ERROR_NONE)
 143                 debug_error("failed to destroy radio\n");
 144
 145         /* free radio */
 146         MMRADIO_FREEIF(radio);
 147
 148         MMRADIO_LOG_FLEAVE();
 149
 150         return result;
 151 }
 152
 153 int mm_radio_realize(MMHandleType hradio)
 154 {
 155         int result = MM_ERROR_NONE;
 156         mm_radio_t *radio = (mm_radio_t *)hradio;
 157
 158         MMRADIO_LOG_FENTER();
 159
 160         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 161
 162         MMRADIO_CMD_LOCK(radio);
 163
 164         result = _mmradio_realize(radio);
 165
 166         MMRADIO_CMD_UNLOCK(radio);
 167
 168         MMRADIO_LOG_FLEAVE();
 169
 170         return result;
 171 }
 172
 173 int mm_radio_unrealize(MMHandleType hradio)
 174 {
 175         int result = MM_ERROR_NONE;
 176         mm_radio_t *radio = (mm_radio_t *)hradio;
 177         MMRadioStateType state = 0;
 178
 179         MMRADIO_LOG_FENTER();
 180
 181         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 182
 183         mm_radio_get_state((hradio), &state);
 184         MMRADIO_LOG_DEBUG("mm_radio_unrealize state: %d\n", state);
 185
 186         if (state == MM_RADIO_STATE_SCANNING)
 187                 mm_radio_scan_stop(hradio);
 188
 189         MMRADIO_CMD_LOCK(radio);
 190
 191         result = _mmradio_unrealize(radio);
 192
 193         MMRADIO_CMD_UNLOCK(radio);
 194
 195         MMRADIO_LOG_FLEAVE();
 196
 197         return result;
 198 }
 199
 200 int mm_radio_set_message_callback(MMHandleType hradio, MMMessageCallback callback, void *user_param)
 201 {
 202         int result = MM_ERROR_NONE;
 203         mm_radio_t *radio = (mm_radio_t *)hradio;
 204
 205         MMRADIO_LOG_FENTER();
 206
 207         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 208
 209         MMRADIO_CMD_LOCK(radio);
 210
 211         result = _mmradio_set_message_callback(radio, callback, user_param);
 212
 213         MMRADIO_CMD_UNLOCK(radio);
 214
 215         MMRADIO_LOG_FLEAVE();
 216
 217         return result;
 218 }
 219
 220 int mm_radio_get_state(MMHandleType hradio, MMRadioStateType *pState)
 221 {
 222         int result = MM_ERROR_NONE;
 223         mm_radio_t *radio = (mm_radio_t *)hradio;
 224         int state = 0;
 225
 226         MMRADIO_LOG_FENTER();
 227
 228         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 229         return_val_if_fail(pState, MM_ERROR_COMMON_INVALID_ARGUMENT);
 230
 231         MMRADIO_CMD_LOCK(radio);
 232
 233         result = _mmradio_get_state(radio, &state);
 234
 235         *pState = state;
 236
 237         MMRADIO_CMD_UNLOCK(radio);
 238
 239         MMRADIO_LOG_FLEAVE();
 240
 241         return result;
 242 }
 243
 244 int mm_radio_start(MMHandleType hradio)
 245 {
 246         int result = MM_ERROR_NONE;
 247         mm_radio_t *radio = (mm_radio_t *)hradio;
 248
 249         MMRADIO_LOG_FENTER();
 250
 251         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 252
 253         MMRADIO_CMD_LOCK(radio);
 254
 255         result = _mmradio_start(radio);
 256
 257         MMRADIO_CMD_UNLOCK(radio);
 258
 259         MMRADIO_LOG_FLEAVE();
 260
 261         return result;
 262 }
 263
 264 int mm_radio_stop(MMHandleType hradio)
 265 {
 266         int result = MM_ERROR_NONE;
 267         mm_radio_t *radio = (mm_radio_t *)hradio;
 268
 269         MMRADIO_LOG_FENTER();
 270
 271         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 272
 273         MMRADIO_CMD_LOCK(radio);
 274
 275         result = _mmradio_stop(radio);
 276
 277         MMRADIO_CMD_UNLOCK(radio);
 278
 279         MMRADIO_LOG_FLEAVE();
 280
 281         return result;
 282 }
 283
 284 int mm_radio_seek(MMHandleType hradio, MMRadioSeekDirectionType direction)
 285 {
 286         int result = MM_ERROR_NONE;
 287         mm_radio_t *radio = (mm_radio_t *)hradio;
 288
 289         MMRADIO_LOG_FENTER();
 290
 291         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 292         return_val_if_fail(direction >= MM_RADIO_SEEK_UP && direction <= MM_RADIO_SEEK_DOWN, MM_ERROR_INVALID_ARGUMENT);
 293
 294         MMRADIO_CMD_LOCK(radio);
 295
 296         radio->seek_direction = direction;
 297
 298         result = _mmradio_seek(radio, direction);
 299
 300         MMRADIO_CMD_UNLOCK(radio);
 301
 302         MMRADIO_LOG_FLEAVE();
 303
 304         return result;
 305 }
 306
 307 int mm_radio_set_frequency(MMHandleType hradio, int freq)
 308 {
 309         int result = MM_ERROR_NONE;
 310         mm_radio_t *radio = (mm_radio_t *)hradio;
 311
 312         MMRADIO_LOG_FENTER();
 313
 314         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 315
 316         MMRADIO_CMD_LOCK(radio);
 317
 318         result = _mmradio_set_frequency(radio, freq);
 319
 320         MMRADIO_CMD_UNLOCK(radio);
 321
 322         MMRADIO_LOG_FLEAVE();
 323
 324         return result;
 325 }
 326
 327 int mm_radio_get_frequency(MMHandleType hradio, int *pFreq)
 328 {
 329         int result = MM_ERROR_NONE;
 330         mm_radio_t *radio = (mm_radio_t *)hradio;
 331         int freq = 0;
 332
 333         MMRADIO_LOG_FENTER();
 334
 335         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 336         return_val_if_fail(pFreq, MM_ERROR_INVALID_ARGUMENT);
 337
 338         MMRADIO_CMD_LOCK(radio);
 339
 340         result = _mmradio_get_frequency(radio, &freq);
 341
 342         *pFreq = freq;
 343
 344         MMRADIO_CMD_UNLOCK(radio);
 345
 346         MMRADIO_LOG_FLEAVE();
 347
 348         return result;
 349 }
 350
 351 int mm_radio_scan_start(MMHandleType hradio)
 352 {
 353         int result = MM_ERROR_NONE;
 354         mm_radio_t *radio = (mm_radio_t *)hradio;
 355
 356         MMRADIO_LOG_FENTER();
 357
 358         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 359
 360         MMRADIO_CMD_LOCK(radio);
 361
 362         result = _mmradio_start_scan(radio);
 363
 364         MMRADIO_CMD_UNLOCK(radio);
 365
 366         MMRADIO_LOG_FLEAVE();
 367
 368         return result;
 369 }
 370
 371 int mm_radio_scan_stop(MMHandleType hradio)
 372 {
 373         int result = MM_ERROR_NONE;
 374         mm_radio_t *radio = (mm_radio_t *)hradio;
 375
 376         MMRADIO_LOG_FENTER();
 377
 378         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 379
 380         MMRADIO_CMD_LOCK(radio);
 381
 382         result = _mmradio_stop_scan(radio);
 383
 384         MMRADIO_CMD_UNLOCK(radio);
 385
 386         MMRADIO_LOG_FLEAVE();
 387
 388         return result;
 389 }
 390
 391 int mm_radio_set_mute(MMHandleType hradio, bool muted)
 392 {
 393         int result = MM_ERROR_NONE;
 394         mm_radio_t *radio = (mm_radio_t *)hradio;
 395
 396         MMRADIO_LOG_FENTER();
 397
 398         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 399
 400         MMRADIO_CMD_LOCK(radio);
 401
 402         if (muted)
 403                 result = _mmradio_mute(radio);
 404         else
 405                 result = _mmradio_unmute(radio);
 406
 407         MMRADIO_CMD_UNLOCK(radio);
 408
 409         MMRADIO_LOG_FLEAVE();
 410
 411         return result;
 412 }
 413
 414 int mm_radio_get_signal_strength(MMHandleType hradio, int *value)
 415 {
 416         return_val_if_fail(hradio, MM_ERROR_RADIO_NOT_INITIALIZED);
 417         return_val_if_fail(value, MM_ERROR_INVALID_ARGUMENT);
 418
 419         MMRADIO_LOG_FENTER();
 420
 421         int ret = MM_ERROR_NONE;
 422
 423         mm_radio_t *radio = (mm_radio_t *)hradio;
 424
 425         MMRADIO_CMD_LOCK(radio);
 426
 427         ret = _mm_radio_get_signal_strength(radio, value);
 428
 429         MMRADIO_CMD_UNLOCK(radio);
 430
 431         MMRADIO_LOG_INFO("signal strength = %d\n", *value);
 432         MMRADIO_LOG_FLEAVE();
 433
 434         return ret;
 435 }
 436
 437 int mm_radio_get_region_type(MMHandleType hradio, MMRadioRegionType *type)
 438 {
 439         MMRADIO_LOG_FENTER();
 440         return_val_if_fail(hradio, MM_ERROR_RADIO_NOT_INITIALIZED);
 441         return_val_if_fail(type, MM_ERROR_INVALID_ARGUMENT);
 442
 443         int result = MM_ERROR_NONE;
 444         mm_radio_t *radio = (mm_radio_t *)hradio;
 445         MMRadioRegionType cur_type = MM_RADIO_REGION_GROUP_NONE;
 446
 447         result = _mmradio_get_region_type(radio, &cur_type);
 448
 449         if (result == MM_ERROR_NONE)
 450                 *type = cur_type;
 451
 452         MMRADIO_LOG_FLEAVE();
 453         return result;
 454 }
 455
 456 int mm_radio_get_region_frequency_range(MMHandleType hradio, unsigned int *min, unsigned int *max)
 457 {
 458         MMRADIO_LOG_FENTER();
 459
 460         return_val_if_fail(hradio, MM_ERROR_RADIO_NOT_INITIALIZED);
 461         return_val_if_fail(min && max, MM_ERROR_INVALID_ARGUMENT);
 462
 463         int result = MM_ERROR_NONE;
 464         mm_radio_t *radio = (mm_radio_t *)hradio;
 465         unsigned int min_freq = 0;
 466         unsigned int max_freq = 0;
 467
 468         result = _mmradio_get_region_frequency_range(radio, &min_freq, &max_freq);
 469
 470         if (result == MM_ERROR_NONE) {
 471                 *min = min_freq;
 472                 *max = max_freq;
 473         }
 474
 475         MMRADIO_LOG_FLEAVE();
 476         return result;
 477 }
 478
 479 int mm_radio_get_channel_spacing(MMHandleType hradio, int *channel_spacing)
 480 {
 481         MMRADIO_LOG_FENTER();
 482
 483         return_val_if_fail(hradio, MM_ERROR_RADIO_NOT_INITIALIZED);
 484         return_val_if_fail(channel_spacing, MM_ERROR_INVALID_ARGUMENT);
 485
 486         int result = MM_ERROR_NONE;
 487         mm_radio_t *radio = (mm_radio_t *)hradio;
 488         unsigned int ch_spacing = 0;
 489
 490         result = _mmradio_get_channel_spacing(radio, &ch_spacing);
 491
 492         if (result == MM_ERROR_NONE)
 493                 *channel_spacing = ch_spacing;
 494
 495         MMRADIO_LOG_FLEAVE();
 496         return result;
 497 }
 498
 499 int mm_radio_set_volume(MMHandleType hradio, float volume)
 500 {
 501         int result = MM_ERROR_NONE;
 502         mm_radio_t *radio = (mm_radio_t *)hradio;
 503
 504         MMRADIO_LOG_FENTER();
 505
 506         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 507
 508         MMRADIO_CMD_LOCK(radio);
 509
 510         result = _mmradio_set_volume(radio, volume);
 511
 512         MMRADIO_CMD_UNLOCK(radio);
 513
 514         MMRADIO_LOG_FLEAVE();
 515
 516         return result;
 517 }
 518
 519 int mm_radio_get_volume(MMHandleType hradio, float *pVolume)
 520 {
 521         int result = MM_ERROR_NONE;
 522         mm_radio_t *radio = (mm_radio_t *)hradio;
 523         float volume = 0.0;
 524
 525         MMRADIO_LOG_FENTER();
 526
 527         return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
 528         return_val_if_fail(pVolume, MM_ERROR_INVALID_ARGUMENT);
 529
 530         MMRADIO_CMD_LOCK(radio);
 531
 532         result = _mmradio_get_volume(radio, &volume);
 533         if (result == MM_ERROR_NONE)
 534                 *pVolume = volume;
 535
 536         MMRADIO_CMD_UNLOCK(radio);
 537
 538         MMRADIO_LOG_FLEAVE();
 539
 540         return result;
 541 }
 542