test/sound_manager_test.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20
  21 #include <sound_manager.h>
  22 #include <pthread.h>
  23 #include <glib.h>
  24 //#include <dlfcn.h>
  25
  26 #define MAX_STRING_LEN  2048
  27
  28
  29 enum
  30 {
  31         CURRENT_STATUS_MAINMENU,
  32         CURRENT_STATUS_GET_MAX_VOLUME,
  33         CURRENT_STATUS_SET_VOLUME,
  34         CURRENT_STATUS_GET_VOLUME,
  35         CURRENT_STATUS_SET_CURRENT_SOUND_TYPE,
  36         CURRENT_STATUS_GET_CURRENT_SOUND_TYPE,
  37         CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE,
  38         CURRENT_STATUS_SET_VOLUME_CHANGED_CB,
  39         CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB,
  40         CURRENT_STATUS_SET_SESSION_TYPE,
  41         CURRENT_STATUS_GET_SESSION_TYPE,
  42         CURRENT_STATUS_SET_MEDIA_SESSION_OPTION,
  43         CURRENT_STATUS_GET_MEDIA_SESSION_OPTION,
  44         CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION,
  45         CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION,
  46         CURRENT_STATUS_SET_VOIP_SESSION_MODE,
  47         CURRENT_STATUS_GET_VOIP_SESSION_MODE,
  48         CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB,
  49         CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB,
  50         CURRENT_STATUS_SET_DEVICE_MASK,
  51         CURRENT_STATUS_GET_DEVICE_MASK,
  52         CURRENT_STATUS_GET_DEVICE_LIST,
  53         CURRENT_STATUS_GET_DEVICE_NEXT,
  54         CURRENT_STATUS_GET_DEVICE_PREV,
  55         CURRENT_STATUS_SET_DEVICE_CONNECTED_CB,
  56         CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB,
  57         CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB,
  58         CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB,
  59 };
  60
  61
  62 static int g_menu_state = CURRENT_STATUS_MAINMENU;
  63
  64 GMainLoop* g_loop;
  65 sound_device_list_h g_device_list = NULL;
  66 sound_device_mask_e g_device_mask = SOUND_DEVICE_ALL_MASK;
  67
  68 void quit_program()
  69 {
  70         g_main_loop_quit(g_loop);
  71 }
  72
  73 void _interpret_main_menu(char *cmd)
  74 {
  75                 if (strncmp(cmd, "gx", 2) == 0)
  76                 {
  77                         g_menu_state = CURRENT_STATUS_GET_MAX_VOLUME;
  78                 }
  79             else if (strncmp(cmd, "sv", 2) == 0)
  80                 {
  81                         g_menu_state = CURRENT_STATUS_SET_VOLUME;
  82                 }
  83                 else if (strncmp(cmd, "gv", 2) == 0)
  84                 {
  85                         g_menu_state = CURRENT_STATUS_GET_VOLUME;
  86                 }
  87                 else if (strncmp(cmd, "st", 2) == 0)
  88                 {
  89                         g_menu_state = CURRENT_STATUS_SET_CURRENT_SOUND_TYPE;
  90                 }
  91                 else if (strncmp(cmd, "gt", 2) == 0)
  92                 {
  93                         g_menu_state = CURRENT_STATUS_GET_CURRENT_SOUND_TYPE;
  94                 }
  95                 else if (strncmp(cmd, "ut", 2) == 0)
  96                 {
  97                         g_menu_state = CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE;
  98                 }
  99                 else if (strncmp(cmd, "vc", 2) == 0)
 100                 {
 101                         g_menu_state = CURRENT_STATUS_SET_VOLUME_CHANGED_CB;
 102                 }
 103                 else if (strncmp(cmd, "uv", 2) == 0)
 104                 {
 105                         g_menu_state = CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB;
 106                 }
 107                 else if (strncmp(cmd, "ss", 2) == 0 )
 108                 {
 109                         g_menu_state = CURRENT_STATUS_SET_SESSION_TYPE;
 110                 }
 111                 else if (strncmp(cmd, "gs", 2) == 0 )
 112                 {
 113                         g_menu_state = CURRENT_STATUS_GET_SESSION_TYPE;
 114                 }
 115                 else if (strncmp(cmd, "sm", 2) == 0 )
 116                 {
 117                         g_menu_state = CURRENT_STATUS_SET_MEDIA_SESSION_OPTION;
 118                 }
 119                 else if (strncmp(cmd, "gm", 2) == 0 )
 120                 {
 121                         g_menu_state = CURRENT_STATUS_GET_MEDIA_SESSION_OPTION;
 122                 }
 123                 else if (strncmp(cmd, "sr", 2) == 0 )
 124                 {
 125                         g_menu_state = CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION;
 126                 }
 127                 else if (strncmp(cmd, "gr", 2) == 0 )
 128                 {
 129                         g_menu_state = CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION;
 130                 }
 131                 else if (strncmp(cmd, "so", 2) == 0 )
 132                 {
 133                         g_menu_state = CURRENT_STATUS_SET_VOIP_SESSION_MODE;
 134                 }
 135                 else if (strncmp(cmd, "go", 2) == 0 )
 136                 {
 137                         g_menu_state = CURRENT_STATUS_GET_VOIP_SESSION_MODE;
 138                 }
 139                 else if (strncmp(cmd, "sc", 2) == 0 )
 140                 {
 141                         g_menu_state = CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB;
 142                 }
 143                 else if (strncmp(cmd, "us", 2) == 0 )
 144                 {
 145                         g_menu_state = CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB;
 146                 }
 147                 else if (strncmp(cmd, "sk", 2) == 0 )
 148                 {
 149                         g_menu_state = CURRENT_STATUS_SET_DEVICE_MASK;
 150                 }
 151                 else if (strncmp(cmd, "gk", 2) == 0 )
 152                 {
 153                         g_menu_state = CURRENT_STATUS_GET_DEVICE_MASK;
 154                 }
 155                 else if (strncmp(cmd, "gl", 2) == 0 )
 156                 {
 157                         g_menu_state = CURRENT_STATUS_GET_DEVICE_LIST;
 158                 }
 159                 else if (strncmp(cmd, "gn", 2) == 0 )
 160                 {
 161                         g_menu_state = CURRENT_STATUS_GET_DEVICE_NEXT;
 162                 }
 163                 else if (strncmp(cmd, "gp", 2) == 0 )
 164                 {
 165                         g_menu_state = CURRENT_STATUS_GET_DEVICE_PREV;
 166                 }
 167                 else if (strncmp(cmd, "sd", 2) == 0 )
 168                 {
 169                         g_menu_state = CURRENT_STATUS_SET_DEVICE_CONNECTED_CB;
 170                 }
 171                 else if (strncmp(cmd, "ud", 2) == 0 )
 172                 {
 173                         g_menu_state = CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB;
 174                 }
 175                 else if (strncmp(cmd, "si", 2) == 0 )
 176                 {
 177                         g_menu_state = CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB;
 178                 }
 179                 else if (strncmp(cmd, "ui", 2) == 0 )
 180                 {
 181                         g_menu_state = CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB;
 182                 }
 183                 else if (strncmp(cmd, "q", 1) == 0 )
 184                 {
 185                         g_print("closing the test suite\n");
 186                         quit_program();
 187                 }
 188                 else
 189                 {
 190                         g_print("unknown menu \n");
 191                 }
 192
 193 }
 194
 195 void display_sub_basic()
 196 {
 197         g_print("\n");
 198         g_print("=========================================================================================\n");
 199         g_print("                          Sound Manager Test (press q to quit) \n");
 200         g_print("-----------------------------------------------------------------------------------------\n");
 201         g_print("                                       VOLUME MODULE \n");
 202         g_print("-----------------------------------------------------------------------------------------\n");
 203         g_print("gx. Get Max Volume \n");
 204         g_print("sv. Set Volume \t");
 205         g_print("gv. Get Volume \n");
 206         g_print("st. Set Current Sound Type \t");
 207         g_print("gt. Get Current Sound Type \t");
 208         g_print("ut. Unset Current Sound Type \n");
 209         g_print("vc. Set Volume Changed CB \t");
 210         g_print("uv. Unset Volume Changed CB \n");
 211         g_print("-----------------------------------------------------------------------------------------\n");
 212         g_print("                                       SESSION MODULE \n");
 213         g_print("-----------------------------------------------------------------------------------------\n");
 214         g_print("ss. Set Session Type\t\t");
 215         g_print("gs. Get Session Type\n");
 216         g_print("sm. Set Media Session Option \t");
 217         g_print("gm. Get Media Session Option \n");
 218         g_print("sr. Set Media Session Resumption Option \t");
 219         g_print("gr. Get Media Session Resumption Option \n");
 220         g_print("so. Set Voip Session Mode \t");
 221         g_print("go. Get Voip Session Mode \n");
 222         g_print("sc. Set Session Interruped CB \t");
 223         g_print("us. Unset Session Interrupted CB \n");
 224         g_print("-----------------------------------------------------------------------------------------\n");
 225         g_print("                                       DEVICE MODULE \n");
 226         g_print("-----------------------------------------------------------------------------------------\n");
 227         g_print("sk. Set Devices Mask(default ALL)\t");
 228         g_print("gk. Get Devices Mask\n");
 229         g_print("gl. Get Devices List\n");
 230         g_print("gn. Get Next Device\t\t");
 231         g_print("gp. Get Prev Device\n");
 232         g_print("sd. Set Device Connenected CB\t\t");
 233         g_print("ud. Unset Device Connenected CB\n");
 234         g_print("si. Set Device Information Changed CB\t");
 235         g_print("ui. Unset Device Information Changed CB\n");
 236         g_print("\n");
 237         g_print("=========================================================================================\n");
 238 }
 239
 240 static void displaymenu()
 241 {
 242         static int flag = 0;
 243         if (g_menu_state == CURRENT_STATUS_MAINMENU)
 244         {
 245                 display_sub_basic();
 246                 flag = 0;
 247         }
 248         else if (g_menu_state == CURRENT_STATUS_GET_MAX_VOLUME)
 249         {
 250                 g_print("*** input sound type(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE)\n");
 251         }
 252         else if (g_menu_state == CURRENT_STATUS_SET_VOLUME)
 253         {
 254                 if(flag == 0)
 255                 g_print("*** input sound type and desired volume level(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE, (0~max volum).\n");
 256                 flag =1;
 257         }
 258         else if (g_menu_state == CURRENT_STATUS_GET_VOLUME)
 259         {
 260                 g_print("*** input sound type(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE)\n");
 261         }
 262         else if (g_menu_state == CURRENT_STATUS_SET_CURRENT_SOUND_TYPE)
 263         {
 264                 g_print("*** input sound type.(0:SYSTEM 1:NOTIFICATION 2:ALARM 3:RINGTONE 4:MEDIA 5:CALL 6:VOIP 7:VOICE)\n");
 265         }
 266         else if (g_menu_state == CURRENT_STATUS_GET_CURRENT_SOUND_TYPE)
 267         {
 268                 g_print("*** press enter to get current sound type\n");
 269         }
 270         else if (g_menu_state == CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE)
 271         {
 272                 g_print("*** press enter to unset current sound type\n");
 273         }
 274         else if (g_menu_state == CURRENT_STATUS_SET_VOLUME_CHANGED_CB)
 275         {
 276                 g_print("*** press enter to set volume changed cb\n");
 277         }
 278         else if (g_menu_state == CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB)
 279         {
 280                 g_print("*** press enter to unset volume changed cb\n");
 281         }
 282         else if (g_menu_state == CURRENT_STATUS_SET_SESSION_TYPE)
 283         {
 284                 g_print("*** input session type(0:MEDIA, 1:ALARM, 2:NOTIFICATION, 3:EMERGENCY, 4:VOIP)\n");
 285         }
 286         else if (g_menu_state == CURRENT_STATUS_GET_SESSION_TYPE)
 287         {
 288                 g_print("*** press enter to get session type\n");
 289         }
 290         else if (g_menu_state == CURRENT_STATUS_SET_MEDIA_SESSION_OPTION)
 291         {
 292                 if(flag == 0)
 293                 g_print("*** input starting option, and ongoing(for starting(0:MIX WITH OTHERS, 1:PAUSE OTHERS), for ongoing(0:INTERRUPTABLE, 1:UNINTERRUPABLE)\n");
 294                 flag = 1;
 295         }
 296         else if (g_menu_state == CURRENT_STATUS_GET_MEDIA_SESSION_OPTION)
 297         {
 298                 g_print("*** press enter to get media session option\n");
 299         }
 300         else if (g_menu_state == CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION)
 301         {
 302                 g_print("*** input media session resumption option(0:BY SYSTEM, 1:OR MEDIA PAUSE)\n");
 303         }
 304         else if (g_menu_state == CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION)
 305         {
 306                 g_print("*** press enter to get media session resumption option\n");
 307         }
 308         else if (g_menu_state == CURRENT_STATUS_SET_VOIP_SESSION_MODE)
 309         {
 310                 g_print("*** input voip session mode (0:RINGTONE, 1:VOICE with RCV, 2:VOICE with SPK, 3:VOICE with AudioJack, 4:VOICE with BT)\n");
 311         }
 312         else if (g_menu_state == CURRENT_STATUS_GET_VOIP_SESSION_MODE)
 313         {
 314                 g_print("*** press enter to get voip session mode\n");
 315         }
 316         else if (g_menu_state == CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB)
 317         {
 318                 g_print("*** press enter to set session interrupted cb\n");
 319         }
 320         else if (g_menu_state == CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB)
 321         {
 322                 g_print("*** press enter to unset session interrupted cb\n");
 323         }
 324         else if (g_menu_state == CURRENT_STATUS_SET_DEVICE_MASK)
 325         {
 326                 g_print("*** input device mask (0:ALL, 1:INTERNAL, 2:EXTERNAL, 3:INPUT, 4:OUTPUT, 5:BOTH, 6:ACTIVATED, 7:DEACTIVATED, b:back to the menu\n");
 327         }
 328         else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_MASK)
 329         {
 330                 g_print("*** press enter to get device mask\n");
 331         }
 332         else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_LIST)
 333         {
 334                 g_print("*** press enter to get device list\n");
 335         }
 336         else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_NEXT)
 337         {
 338                 g_print("*** press enter to get next device from the list\n");
 339         }
 340         else if (g_menu_state == CURRENT_STATUS_GET_DEVICE_PREV)
 341         {
 342                 g_print("*** press enter to get previous device from the list\n");
 343         }
 344         else if (g_menu_state == CURRENT_STATUS_SET_DEVICE_CONNECTED_CB)
 345         {
 346                 g_print("*** press enter to set device connected cb\n");
 347         }
 348         else if (g_menu_state == CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB)
 349         {
 350                 g_print("*** press enter to unset device connected cb\n");
 351         }
 352         else if (g_menu_state == CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB)
 353         {
 354                 g_print("*** press enter to set device information changed cb\n");
 355         }
 356         else if (g_menu_state == CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB)
 357         {
 358                 g_print("*** press enter to unset device information changed cb\n");
 359         }
 360         else
 361         {
 362                 g_print("*** unknown status.\n");
 363                 quit_program();
 364         }
 365         g_print(" >>> ");
 366 }
 367
 368 gboolean timeout_menu_display(void* data)
 369 {
 370         displaymenu();
 371         return FALSE;
 372 }
 373
 374 gboolean timeout_quit_program(void* data)
 375 {
 376         //elm_exit();
 377         quit_program();
 378         return FALSE;
 379 }
 380
 381 int convert_sound_type(sound_type_e *type, char *cmd)
 382 {
 383         int sound_type_n = atoi(cmd);
 384                 if (SOUND_TYPE_SYSTEM > sound_type_n || sound_type_n > SOUND_TYPE_VOICE)
 385                 {
 386                         g_print("not supported sound type(%d)\n", sound_type_n);
 387                         return 0;
 388                 }
 389                 else
 390                 {
 391                         switch (sound_type_n)
 392                         {
 393                                 case 0:
 394                                         *type = SOUND_TYPE_SYSTEM;
 395                                         break;
 396                                 case 1:
 397                                         *type = SOUND_TYPE_NOTIFICATION;
 398                                         break;
 399                                 case 2:
 400                                         *type = SOUND_TYPE_ALARM;
 401                                         break;
 402                                 case 3:
 403                                         *type = SOUND_TYPE_RINGTONE;
 404                                         break;
 405                                 case 4:
 406                                         *type = SOUND_TYPE_MEDIA;
 407                                         break;
 408                                 case 5:
 409                                         *type = SOUND_TYPE_CALL;
 410                                         break;
 411                                 case 6:
 412                                         *type = SOUND_TYPE_VOIP;
 413                                         break;
 414                                 case 7:
 415                                         *type = SOUND_TYPE_VOICE;
 416                                         break;
 417                                 default:
 418                                         break;
 419                         }
 420                 }
 421         return 1;
 422 }
 423
 424 int convert_session_type(sound_session_type_e *type, char *cmd)
 425 {
 426         int session_type_n = atoi(cmd);
 427                 if (SOUND_SESSION_TYPE_MEDIA > session_type_n || session_type_n > SOUND_SESSION_TYPE_VOIP)
 428                 {
 429                         g_print("not supported session type(%d)\n", session_type_n);
 430                         return 0;
 431                 }
 432                 else
 433                 {
 434                         switch (session_type_n)
 435                         {
 436                                 case 0:
 437                                         *type = SOUND_SESSION_TYPE_MEDIA;
 438                                         break;
 439                                 case 1:
 440                                         *type = SOUND_SESSION_TYPE_ALARM;
 441                                         break;
 442                                 case 2:
 443                                         *type = SOUND_SESSION_TYPE_NOTIFICATION;
 444                                         break;
 445                                 case 3:
 446                                         *type = SOUND_SESSION_TYPE_EMERGENCY;
 447                                         break;
 448                                 case 4:
 449                                         *type = SOUND_SESSION_TYPE_VOIP;
 450                                         break;
 451                                 default:
 452                                         break;
 453                         }
 454                 }
 455         return 1;
 456 }
 457
 458 void _set_volume_changed_cb(sound_type_e type, unsigned int volume, void *user_data)
 459 {
 460         g_print("***the volume has changed. the volume of this sound type(%d) is : %d \n", type, volume);
 461 }
 462
 463 void _set_session_interrupted_cb(sound_session_interrupted_code_e code, void *user_data)
 464 {
 465         g_print("***your session has been interrupted by (%d)\n", code);
 466 }
 467
 468 void _set_device_connected_cb(sound_device_h device, bool is_connected, void *user_data)
 469 {
 470         sound_device_type_e type;
 471         sound_device_io_direction_e io_direction;
 472         sound_device_state_e state;
 473         int id;
 474         char *name;
 475         int ret = SOUND_MANAGER_ERROR_NONE;
 476
 477         g_print("***device connected callback is called, is_connected[%d]\n", is_connected);
 478
 479         if ((ret = sound_manager_get_device_type (device, &type)))
 480                 g_print("failed to get device type, ret[0x%x]\n", ret);
 481         if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
 482                 g_print("failed to get device io direction, ret[0x%x]\n", ret);
 483         if ((ret = sound_manager_get_device_id (device, &id)))
 484                 g_print("failed to get device id, ret[0x%x]\n", ret);
 485         if ((ret = sound_manager_get_device_name (device, &name)))
 486                 g_print("failed to get device name, ret[0x%x]\n", ret);
 487         if ((ret = sound_manager_get_device_state (device, &state)))
 488                 g_print("failed to get device state, ret[0x%x]\n", ret);
 489         if (!ret)
 490                 g_print(" -- device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
 491 }
 492
 493 void _set_device_info_changed_cb(sound_device_h device, sound_device_changed_info_e changed_info, void *user_data)
 494 {
 495         sound_device_type_e type;
 496         sound_device_io_direction_e io_direction;
 497         sound_device_state_e state;
 498         int id;
 499         char *name;
 500         int ret = SOUND_MANAGER_ERROR_NONE;
 501
 502         g_print("***device information changed callback is called, changed_info[%d](0:STATE 1:IO_DIRECTION)\n", changed_info);
 503
 504         if ((ret = sound_manager_get_device_type (device, &type)))
 505                 g_print("failed to get device type, ret[0x%x]\n", ret);
 506         if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
 507                 g_print("failed to get device io direction, ret[0x%x]\n", ret);
 508         if ((ret = sound_manager_get_device_id (device, &id)))
 509                 g_print("failed to get device id, ret[0x%x]\n", ret);
 510         if ((ret = sound_manager_get_device_name (device, &name)))
 511                 g_print("failed to get device name, ret[0x%x]\n", ret);
 512         if ((ret = sound_manager_get_device_state (device, &state)))
 513                 g_print("failed to get device state, ret[0x%x]\n", ret);
 514         if (!ret)
 515                 g_print(" -- device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
 516 }
 517
 518 void reset_menu_state(void)
 519 {
 520         g_menu_state = CURRENT_STATUS_MAINMENU;
 521 }
 522
 523 static void interpret (char *cmd)
 524 {
 525         switch (g_menu_state)
 526         {
 527                 case CURRENT_STATUS_MAINMENU:
 528                 {
 529                         _interpret_main_menu(cmd);
 530                 }
 531                 break;
 532                 case CURRENT_STATUS_GET_MAX_VOLUME:
 533                 {
 534                         static sound_type_e type;
 535                         static int max;
 536                         if(convert_sound_type(&type,cmd) == 1)
 537                         {
 538                                 if(sound_manager_get_max_volume(type, &max) != 0)
 539                                         g_print("failt to get max volume\n");
 540                                 else
 541                                         g_print("the max volume of this type(%d) is %d\n", type, max);
 542                         }
 543                         reset_menu_state();
 544                 }
 545                 break;
 546                 case CURRENT_STATUS_SET_VOLUME:
 547                 {
 548                         static int cnt =0;
 549                         static sound_type_e type;
 550                         static int volume;
 551                         switch(cnt)
 552                         {
 553                         case 0:
 554                                 if(convert_sound_type(&type,cmd) == 1)
 555                                 cnt ++;
 556                                 else
 557                                 reset_menu_state();
 558                                 break;
 559                         case 1:
 560                                 volume = atoi(cmd);
 561                                 if(sound_manager_set_volume(type, volume) != 0)
 562                                         g_print("fail to set volume(%d) check sound type(%d)'s available volume level\n", volume, type);
 563                                 else
 564                                         g_print("set volume success : sound type(%d), volume(%d)\n",type, volume);
 565                                 cnt = 0;
 566                                 reset_menu_state();
 567                                 break;
 568                         default:
 569                                 break;
 570                         }
 571                 }
 572                 break;
 573                 case CURRENT_STATUS_GET_VOLUME:
 574                 {
 575                         static sound_type_e type;
 576                         static int volume;
 577                         if(convert_sound_type(&type,cmd) == 1)
 578                         {
 579                                 if(sound_manager_get_volume(type, &volume) != 0)
 580                                         g_print("fail to get volume\n");
 581                                 else
 582                                         g_print("current volume of this type(%d) is : %d\n", type, volume);
 583                         }
 584                         reset_menu_state();
 585                 }
 586                 break;
 587                 case CURRENT_STATUS_SET_CURRENT_SOUND_TYPE:
 588                 {
 589                         static sound_type_e type;
 590                         if(convert_sound_type(&type,cmd) == 1)
 591                         {
 592                                 if(sound_manager_set_current_sound_type(type) != 0)
 593                                         g_print("fail to set sound type(%d)\n", type);
 594                                 else
 595                                         g_print("success to set sound type(%d)\n", type);
 596                         }
 597                         reset_menu_state();
 598                 }
 599                 break;
 600                 case CURRENT_STATUS_GET_CURRENT_SOUND_TYPE:
 601                 {
 602                         static sound_type_e type;
 603                         if(sound_manager_get_current_sound_type(&type) !=0)
 604                                 g_print("fail to get current sound type\n");
 605                         else
 606                                 g_print("current sound type is (%d)\n", type);
 607                         reset_menu_state();
 608                 }
 609                 break;
 610                 case CURRENT_STATUS_UNSET_CURRENT_SOUND_TYPE:
 611                 {
 612                         if(sound_manager_unset_current_sound_type() !=0)
 613                                 g_print("fail to unset current sound type\n");
 614                         else
 615                                 g_print("success to unset current sound type\n");
 616                         reset_menu_state();
 617                 }
 618                 break;
 619                 case CURRENT_STATUS_SET_VOLUME_CHANGED_CB:
 620                 {
 621                         if(sound_manager_set_volume_changed_cb(_set_volume_changed_cb, NULL) !=0)
 622                                 g_print("fail to set volume changed cb\n");
 623                         else
 624                                 g_print("success to set volume changed cb\n");
 625                         reset_menu_state();
 626                 }
 627                 break;
 628                 case CURRENT_STATUS_UNSET_VOLUME_CHANGED_CB:
 629                 {
 630                         if(sound_manager_unset_volume_changed_cb() !=0)
 631                                 g_print("fail to unset volume changed cb\n");
 632                         else
 633                                 g_print("success to unset volume changed cb\n");
 634                         reset_menu_state();
 635                 }
 636                 break;
 637                 case CURRENT_STATUS_SET_SESSION_TYPE:
 638                 {
 639                         static sound_session_type_e type;
 640                         if(convert_session_type(&type, cmd) == 1)
 641                         {
 642                                 if(sound_manager_set_session_type(type) !=0)
 643                                         g_print("fail to set session type\n");
 644                                 else
 645                                         g_print("success to set session type(%d)\n",type);
 646                         }
 647                         reset_menu_state();
 648                 }
 649                 break;
 650                 case CURRENT_STATUS_GET_SESSION_TYPE:
 651                 {
 652                         static sound_session_type_e type;
 653                         if(sound_manager_get_session_type(&type) !=0)
 654                                 g_print("fail to get session type\n");
 655                         else
 656                                 g_print("current session type is : %d (0:MEDIA, 1:ALARM, 2:NOTIFICATION, 3:EMERGENCY, 4:VOIP)\n", type);
 657
 658                         reset_menu_state();
 659                 }
 660                 break;
 661                 case CURRENT_STATUS_SET_MEDIA_SESSION_OPTION:
 662                 {
 663                         static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
 664                         static sound_session_option_for_starting_e option_s;
 665                         static sound_session_option_for_during_play_e option_d;
 666                         static int cnt = 0;
 667                         if(sound_manager_set_session_type(type) !=0)
 668                         {
 669                                 g_print("fail to set media session type\n");
 670                                 reset_menu_state();
 671                         }
 672                         else
 673                         {
 674                                 switch(cnt)
 675                                 {
 676                                         case 0:
 677                                                 option_s = (sound_session_option_for_starting_e)atoi(cmd);
 678                                                 if(SOUND_SESSION_OPTION_MIX_WITH_OTHERS_WHEN_START > option_s || SOUND_SESSION_OPTION_PAUSE_OTHERS_WHEN_START < option_s)
 679                                                         g_print("not supported option type\n");
 680                                                 else
 681                                                         cnt ++;
 682                                                 break;
 683                                         case 1:
 684                                                 option_d = (sound_session_option_for_during_play_e)atoi(cmd);
 685                                                 if(SOUND_SESSION_OPTION_INTERRUPTIBLE_DURING_PLAY > option_d || SOUND_SESSION_OPTION_UNINTERRUPTIBLE_DURING_PLAY < option_d)
 686                                                         g_print("not supported option type\n");
 687                                                 else
 688                                                 {
 689                                                         if(sound_manager_set_media_session_option(option_s, option_d) != 0)
 690                                                                 g_print("fail to set media session option\n");
 691                                                         else
 692                                                                 g_print("success to set media session option\n");
 693                                                         cnt = 0;
 694                                                 }
 695                                                 reset_menu_state();
 696                                                 break;
 697                                         default:
 698                                                 break;
 699                                 }
 700                         }
 701                 }
 702                 break;
 703                 case CURRENT_STATUS_GET_MEDIA_SESSION_OPTION:
 704                 {
 705                         static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
 706                         static sound_session_option_for_starting_e option_s;
 707                         static sound_session_option_for_during_play_e option_d;
 708                         if(sound_manager_set_session_type(type) != 0)
 709                                 g_print("fail to set media session type\n");
 710                         else
 711                         {
 712                                 if(sound_manager_get_media_session_option(&option_s,&option_d) !=0)
 713                                         g_print("fail to get media session option\n");
 714                                 else
 715                                         g_print("current media session options are (%d) for starting, (%d) for ongoing\n", option_s, option_d);
 716                         }
 717                         reset_menu_state();
 718                 }
 719                 break;
 720                 case CURRENT_STATUS_SET_MEDIA_SESSION_RESUMPTION_OPTION:
 721                 {
 722                         static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
 723                         static sound_session_option_for_resumption_e option_r;
 724                         if(sound_manager_set_session_type(type) != 0)
 725                                 g_print("fail to set media session type\n");
 726                         else
 727                         {
 728                                 option_r = (sound_session_option_for_resumption_e)atoi(cmd);
 729                                 if(SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM > option_r || SOUND_SESSION_OPTION_RESUMPTION_BY_SYSTEM_OR_MEDIA_PAUSED < option_r)
 730                                         g_print("not supported option type\n");
 731                                 else
 732                                 {
 733                                         if(sound_manager_set_media_session_resumption_option(option_r) !=0)
 734                                                 g_print("fail to set media session resumption option\n");
 735                                         else
 736                                                 g_print("succese to set media session resumption option\n");
 737                                 }
 738                         }
 739                         reset_menu_state();
 740                 }
 741                 break;
 742                 case CURRENT_STATUS_GET_MEDIA_SESSION_RESUMPTION_OPTION:
 743                 {
 744                         static sound_session_type_e type = SOUND_SESSION_TYPE_MEDIA;
 745                         static sound_session_option_for_resumption_e option_r;
 746                         if(sound_manager_set_session_type(type) != 0)
 747                                 g_print("fail to set media session type\n");
 748                         else
 749                         {
 750                                 if(sound_manager_get_media_session_resumption_option(&option_r) != 0)
 751                                         g_print("fail to get media session resumption option\n");
 752                                 else
 753                                         g_print("current media session resumption option is : %d\n", option_r);
 754                         }
 755                         reset_menu_state();
 756                 }
 757                 break;
 758                 case CURRENT_STATUS_SET_VOIP_SESSION_MODE:
 759                 {
 760                         int ret = SOUND_MANAGER_ERROR_NONE;
 761                         sound_session_voip_mode_e mode;
 762                         mode = (sound_session_voip_mode_e)atoi(cmd);
 763                         ret = sound_manager_set_voip_session_mode(mode);
 764                         if (ret) {
 765                                 g_print("failed to set voip session mode(%d), ret[0x%x]\n", mode, ret);
 766                         } else {
 767                                 g_print("success to set voip session mode\n");
 768                         }
 769                         reset_menu_state();
 770                 }
 771                 break;
 772                 case CURRENT_STATUS_GET_VOIP_SESSION_MODE:
 773                 {
 774                         int ret = SOUND_MANAGER_ERROR_NONE;
 775                         sound_session_voip_mode_e mode;
 776                         ret = sound_manager_get_voip_session_mode(&mode);
 777                         if(ret)
 778                                 g_print("fail to get voip session mode, ret[0x%x]\n", ret);
 779                         else
 780                                 g_print("success to get voip session mode, mode[%d]\n", mode);
 781                         reset_menu_state();
 782                 }
 783                 break;
 784                 case CURRENT_STATUS_SET_SESSION_INTERRUPTED_CB:
 785                 {
 786                         if(sound_manager_set_session_interrupted_cb(_set_session_interrupted_cb, NULL) != 0)
 787                                 g_print("fail to set interrupted changed cb\n");
 788                         else
 789                                 g_print("success to set interrupted changed cb\n");
 790                         reset_menu_state();
 791                 }
 792                 break;
 793                 case CURRENT_STATUS_UNSET_SESSION_INTERRUPTED_CB:
 794                 {
 795                         if(sound_manager_unset_session_interrupted_cb() != 0)
 796                                 g_print("fail to unset interrupted changed cb\n");
 797                         else
 798                                 g_print("success to unset interrupted changed cb\n");
 799                         reset_menu_state();
 800                 }
 801                 break;
 802                 case CURRENT_STATUS_SET_DEVICE_MASK:
 803                 {
 804                         if (strncmp(cmd, "0", 1) == 0) {
 805                                 g_device_mask = SOUND_DEVICE_ALL_MASK;
 806                                 reset_menu_state();
 807                         } else if (strncmp(cmd, "1", 1) == 0) {
 808                                 if (g_device_mask == SOUND_DEVICE_ALL_MASK)
 809                                         g_device_mask = SOUND_DEVICE_TYPE_INTERNAL_MASK;
 810                                 else
 811                                         g_device_mask |= SOUND_DEVICE_TYPE_INTERNAL_MASK;
 812                                 g_print("add TYPE_INTERNAL MASK\n");
 813                         } else if (strncmp(cmd, "2", 1) == 0) {
 814                                 if (g_device_mask == SOUND_DEVICE_ALL_MASK)
 815                                         g_device_mask = SOUND_DEVICE_TYPE_EXTERNAL_MASK;
 816                                 else
 817                                         g_device_mask |= SOUND_DEVICE_TYPE_EXTERNAL_MASK;
 818                                 g_print("add TYPE_EXTERNAL MASK\n");
 819                         } else if (strncmp(cmd, "3", 1) == 0) {
 820                                 if (g_device_mask == SOUND_DEVICE_ALL_MASK)
 821                                         g_device_mask = SOUND_DEVICE_IO_DIRECTION_IN_MASK;
 822                                 else
 823                                         g_device_mask |= SOUND_DEVICE_IO_DIRECTION_IN_MASK;
 824                                 g_print("add IO_DIRECTION_IN MASK\n");
 825                         } else if (strncmp(cmd, "4", 1) == 0) {
 826                                 if (g_device_mask == SOUND_DEVICE_ALL_MASK)
 827                                         g_device_mask = SOUND_DEVICE_IO_DIRECTION_OUT_MASK;
 828                                 else
 829                                         g_device_mask |= SOUND_DEVICE_IO_DIRECTION_OUT_MASK;
 830                                 g_print("add IO_DIRECTION_OUT MASK\n");
 831                         } else if (strncmp(cmd, "5", 1) == 0) {
 832                                 if (g_device_mask == SOUND_DEVICE_ALL_MASK)
 833                                         g_device_mask = SOUND_DEVICE_IO_DIRECTION_BOTH_MASK;
 834                                 else
 835                                         g_device_mask |= SOUND_DEVICE_IO_DIRECTION_BOTH_MASK;
 836                                 g_print("add IO_DIRECTION_BOTH MASK\n");
 837                         } else if (strncmp(cmd, "6", 1) == 0) {
 838                                 if (g_device_mask == SOUND_DEVICE_ALL_MASK)
 839                                         g_device_mask = SOUND_DEVICE_STATE_ACTIVATED_MASK;
 840                                 else
 841                                         g_device_mask |= SOUND_DEVICE_STATE_ACTIVATED_MASK;
 842                                 g_print("add STATE_ACTIVATED MASK\n");
 843                         } else if (strncmp(cmd, "7", 1) == 0) {
 844                                 if (g_device_mask == SOUND_DEVICE_ALL_MASK)
 845                                         g_device_mask = SOUND_DEVICE_STATE_DEACTIVATED_MASK;
 846                                 else
 847                                         g_device_mask |= SOUND_DEVICE_STATE_DEACTIVATED_MASK;
 848                                 g_print("add STATE_DEACTIVATED MASK\n");
 849                         } else if (strncmp(cmd, "b", 1) == 0) {
 850                                 g_print("device mask[0x%x]\n", g_device_mask);
 851                                 reset_menu_state();
 852                         } else {
 853                                 g_print("invalid selection, please select again..\n");
 854                         }
 855                 }
 856                 break;
 857                 case CURRENT_STATUS_GET_DEVICE_MASK:
 858                 {
 859                         g_print("current device mask[0x%x]\n", g_device_mask);
 860                         reset_menu_state();
 861                 }
 862                 break;
 863                 case CURRENT_STATUS_GET_DEVICE_LIST:
 864                 {
 865                         int ret = SOUND_MANAGER_ERROR_NONE;
 866                         if (!(ret = sound_manager_get_current_device_list(g_device_mask, &g_device_list)))
 867                                 g_print("success to get current device list\n");
 868                         else
 869                                 g_print("fail to get current device list, ret[0x%x]\n", ret);
 870                         reset_menu_state();
 871                 }
 872                 break;
 873                 case CURRENT_STATUS_GET_DEVICE_NEXT:
 874                 {
 875                         sound_device_h device;
 876                         sound_device_type_e type;
 877                         sound_device_io_direction_e io_direction;
 878                         sound_device_state_e state;
 879                         int id;
 880                         char *name;
 881                         int ret = SOUND_MANAGER_ERROR_NONE;
 882                         if (!(ret = sound_manager_get_next_device(g_device_list, &device))) {
 883                                 g_print("success to get next device\n");
 884                                 if ((ret = sound_manager_get_device_type (device, &type)))
 885                                         g_print("failed to get device type, ret[0x%x]\n", ret);
 886                                 if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
 887                                         g_print("failed to get device io direction, ret[0x%x]\n", ret);
 888                                 if ((ret = sound_manager_get_device_id (device, &id)))
 889                                         g_print("failed to get device id, ret[0x%x]\n", ret);
 890                                 if ((ret = sound_manager_get_device_name (device, &name)))
 891                                         g_print("failed to get device name, ret[0x%x]\n", ret);
 892                                 if ((ret = sound_manager_get_device_state (device, &state)))
 893                                         g_print("failed to get device state, ret[0x%x]\n", ret);
 894                                 if (!ret)
 895                                         g_print("-- NEXT device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
 896                         } else {
 897                                 g_print("failed to get next device, ret[0x%x]\n", ret);
 898                         }
 899                         reset_menu_state();
 900                 }
 901                 break;
 902                 case CURRENT_STATUS_GET_DEVICE_PREV:
 903                 {
 904                         sound_device_h device;
 905                         sound_device_type_e type;
 906                         sound_device_io_direction_e io_direction;
 907                         sound_device_state_e state;
 908                         int id;
 909                         char *name;
 910                         int ret = SOUND_MANAGER_ERROR_NONE;
 911                         if (!(ret = sound_manager_get_prev_device(g_device_list, &device))) {
 912                                 g_print("success to get previous device\n");
 913                                 if ((ret = sound_manager_get_device_type (device, &type)))
 914                                         g_print("failed to get device type, ret[0x%x]\n", ret);
 915                                 if ((ret = sound_manager_get_device_io_direction (device, &io_direction)))
 916                                         g_print("failed to get device io direction, ret[0x%x]\n", ret);
 917                                 if ((ret = sound_manager_get_device_id (device, &id)))
 918                                         g_print("failed to get device id, ret[0x%x]\n", ret);
 919                                 if ((ret = sound_manager_get_device_name (device, &name)))
 920                                         g_print("failed to get device name, ret[0x%x]\n", ret);
 921                                 if ((ret = sound_manager_get_device_state (device, &state)))
 922                                         g_print("failed to get device state, ret[0x%x]\n", ret);
 923                                 if (!ret)
 924                                         g_print("-- PREV device type[%d], io_direction[%d], id[%d], name[%s], state[%d]\n", type, io_direction, id, name, state);
 925                         } else {
 926                                 g_print("failed to get previous device, ret[0x%x]\n", ret);
 927                         }
 928                         reset_menu_state();
 929                 }
 930                 break;
 931                 case CURRENT_STATUS_SET_DEVICE_CONNECTED_CB:
 932                 {
 933                         if (sound_manager_set_device_connected_cb(g_device_mask, _set_device_connected_cb, NULL))
 934                                 g_print("fail to set device connected cb\n");
 935                         else
 936                                 g_print("success to set device connected cb\n");
 937                         reset_menu_state();
 938                 }
 939                 break;
 940                 case CURRENT_STATUS_UNSET_DEVICE_CONNECTED_CB:
 941                 {
 942                         if (sound_manager_unset_device_connected_cb())
 943                                 g_print("fail to unset device connected cb\n");
 944                         else
 945                                 g_print("success to unset device connected cb\n");
 946                         reset_menu_state();
 947                 }
 948                 break;
 949                 case CURRENT_STATUS_SET_DEVICE_INFO_CHANGED_CB:
 950                 {
 951                         if (sound_manager_set_device_information_changed_cb(g_device_mask, _set_device_info_changed_cb, NULL))
 952                                 g_print("fail to set device information changed cb\n");
 953                         else
 954                                 g_print("success to set device information changed cb\n");
 955                         reset_menu_state();
 956                 }
 957                 break;
 958                 case CURRENT_STATUS_UNSET_DEVICE_INFO_CHANGED_CB:
 959                 {
 960                         if (sound_manager_unset_device_information_changed_cb())
 961                                 g_print("fail to unset device information changed cb\n");
 962                         else
 963                                 g_print("success to unset device information changed cb\n");
 964                         reset_menu_state();
 965                 }
 966                 break;
 967         }
 968         g_timeout_add(100, timeout_menu_display, 0);
 969 }
 970
 971 gboolean input (GIOChannel *channel)
 972 {
 973     gchar buf[MAX_STRING_LEN];
 974     gsize read;
 975     GError *error = NULL;
 976
 977     g_io_channel_read_chars(channel, buf, MAX_STRING_LEN, &read, &error);
 978     buf[read] = '\0';
 979     g_strstrip(buf);
 980     interpret (buf);
 981
 982     return TRUE;
 983 }
 984
 985 int main(int argc, char *argv[])
 986 {
 987         GIOChannel *stdin_channel;
 988         stdin_channel = g_io_channel_unix_new(0);
 989         g_io_channel_set_flags (stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
 990         g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
 991         g_loop = g_main_loop_new (NULL, 1);
 992
 993         displaymenu();
 994         g_main_loop_run (g_loop);
 995
 996         return 0;
 997 }