src/mp-video-streaming-ctrl.c

   1 /*
   2  * Copyright (c) [2012] Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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
  18 #include <app.h>
  19 #include <vconf.h>
  20 #include <string.h>
  21 #include <vconf-keys.h>
  22
  23 #include "mp-util.h"
  24 #include "mp-video-log.h"
  25 #include "video-player.h"
  26 #include "mp-video-type-define.h"
  27 #include "mp-video-string-define.h"
  28 #include "mp-video-streaming-ctrl.h"
  29
  30
  31 #define NETWORK_TIMEOUT         30.0
  32
  33 static MpNetworkType nNetworkStatus = MP_NETWORK_TYPE_OFF;
  34 static MpNetworkWifiState nWifiState = MP_NETWORK_WIFI_OFF;
  35 static MpNetworkCellularState nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
  36
  37 static Ecore_Pipe       *pEcorePipeHandleForPause = NULL;
  38 static Ecore_Pipe       *pEcorePipeHandleForResume = NULL;
  39
  40 static Eina_Bool        bIsInitCallbackFunc = FALSE;
  41
  42 static Ecore_Timer      *pNetworkTimeoutTimer = NULL;
  43
  44
  45
  46 /*
  47  * Callback function.
  48  */
  49
  50 static void MpVideoStreamingCtrlExitCb(void *pUserData, Evas_Object *pObject,
  51                                  void *pEventInfo)
  52 {
  53         if (!pUserData) {
  54                 VideoLogInfo("No exist pUserData");
  55                 return;
  56         }
  57
  58         VideoLogInfo("");
  59
  60         VideoAppData *pAppData = (VideoAppData *)pUserData;
  61
  62         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
  63 }
  64
  65 static int MpVideoStreamingCtrlResumeCb(void *pUserData)
  66 {
  67         VideoLogInfo("");
  68
  69         if (!pUserData) {
  70                 VideoLogInfo("No exist pUserData");
  71                 return 0;
  72         }
  73
  74         VideoAppData *pAppData = (VideoAppData *)pUserData;
  75
  76         if (pNetworkTimeoutTimer) {
  77                 ecore_timer_del(pNetworkTimeoutTimer);
  78                 pNetworkTimeoutTimer = NULL;
  79         }
  80
  81         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStopByAppPause(pAppData);
  82         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStartByAppResume(pAppData);
  83
  84         return 0;
  85 }
  86
  87 static Eina_Bool MpVideoStreamingCtrlPopupCb(void *pUserData)
  88 {
  89         VideoLogInfo("");
  90
  91         if (!pUserData) {
  92                 VideoLogInfo("No exist pUserData");
  93                 return EINA_FALSE;
  94         }
  95
  96         VideoAppData *pAppData = (VideoAppData *)pUserData;
  97
  98         if (pNetworkTimeoutTimer) {
  99                 ecore_timer_del(pNetworkTimeoutTimer);
 100                 pNetworkTimeoutTimer = NULL;
 101         }
 102
 103         MpUtilNotifyPopUp(pAppData, MP_COM_CONNECTION_FAIL, MpVideoStreamingCtrlExitCb);
 104
 105         return EINA_FALSE;
 106 }
 107
 108 static int MpVideoStreamingCtrlPauseCb(void *pUserData)
 109 {
 110         VideoLogInfo("");
 111
 112         if (!pUserData) {
 113                 VideoLogInfo("No exist pUserData");
 114                 return 0;
 115         }
 116
 117         VideoAppData *pAppData = (VideoAppData *)pUserData;
 118
 119         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStopByAppPause(pAppData);
 120
 121         if (pNetworkTimeoutTimer) {
 122                 ecore_timer_del(pNetworkTimeoutTimer);
 123                 pNetworkTimeoutTimer = NULL;
 124         }
 125
 126         pNetworkTimeoutTimer = ecore_timer_add(NETWORK_TIMEOUT,
 127                                                 MpVideoStreamingCtrlPopupCb,
 128                                                 pAppData);
 129
 130         return 0;
 131 }
 132
 133
 134 static void MpVideoStreamingCtrlNetworkOnOffCb(keynode_t *pKeyNode,void *pUserData)
 135 {
 136         VideoLogInfo("");
 137
 138         if (!pUserData || !pKeyNode) {
 139                 VideoLogInfo("User data is NULL.");
 140                 return;
 141         }
 142
 143         char *szkeyname = NULL;
 144
 145         szkeyname = vconf_keynode_get_name(pKeyNode);
 146         if (!strcmp(szkeyname, VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND)) {
 147                  switch(vconf_keynode_get_int(pKeyNode))
 148                  {
 149                 case MP_NETWORK_CLOSE:
 150                         VideoLogInfo("MP_NETWORK_CLOSE");
 151                         if(pEcorePipeHandleForPause) {
 152                                 if(!ecore_pipe_write(pEcorePipeHandleForPause,
 153                                                 pUserData, sizeof(VideoAppData))) {
 154                                         VideoLogDebug("FAIL PIPE WRITE");
 155                                 }
 156                         }
 157                         break;
 158
 159                 case MP_NETWORK_ON:
 160                         VideoLogInfo("MP_NETWORK_ON");
 161                         if(pEcorePipeHandleForResume) {
 162                                 if(!ecore_pipe_write(pEcorePipeHandleForResume,
 163                                                 pUserData, sizeof(VideoAppData))) {
 164                                         VideoLogDebug("FAIL PIPE WRITE");
 165                                 }
 166                         }
 167                         break;
 168
 169                 default:
 170                         VideoLogInfo("UNKNOWN NETWORK CONFIG");
 171                         break;
 172                  }
 173         } else {
 174         }
 175 }
 176
 177 static void MpVideoStreamingCtrlNetworkStatusCb(keynode_t *pKeyNode,void *pUserData)
 178 {
 179         if (!pUserData || !pKeyNode) {
 180                 VideoLogInfo("User data is NULL.");
 181                 return;
 182         }
 183
 184         VideoLogInfo("");
 185         char *szkeyname = NULL;
 186
 187         szkeyname = vconf_keynode_get_name(pKeyNode);
 188         if (!strcmp(szkeyname, VCONFKEY_NETWORK_STATUS)) {
 189                 switch(vconf_keynode_get_int(pKeyNode))
 190                 {
 191                 case VCONFKEY_NETWORK_OFF:
 192                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 193                         VideoLogInfo("MP_NETWORK_TYPE_OFF");
 194                         /*
 195                         if(pEcorePipeHandleForPause) {
 196                                 if(!ecore_pipe_write(pEcorePipeHandleForPause,
 197                                                 pUserData, sizeof(VideoAppData))) {
 198                                         VideoLogDebug("FAIL PIPE WRITE");
 199                                 }
 200                         }
 201                         */
 202                         break;
 203
 204                 case VCONFKEY_NETWORK_CELLULAR:
 205                         VideoLogInfo("MP_NETWORK_TYPE_CELLULAR");
 206                         /*
 207                         if(pEcorePipeHandleForResume) {
 208                                 if(!ecore_pipe_write(pEcorePipeHandleForResume,
 209                                                 pUserData, sizeof(VideoAppData))) {
 210                                         VideoLogDebug("FAIL PIPE WRITE");
 211                                 }
 212                         }
 213                         nNetworkStatus = MP_NETWORK_TYPE_CELLULAR;
 214                         */
 215                         break;
 216
 217                 case VCONFKEY_NETWORK_WIFI:
 218                         VideoLogInfo("MP_NETWORK_TYPE_WIFI");
 219                         /*
 220                         if(pEcorePipeHandleForResume) {
 221                                 if(!ecore_pipe_write(pEcorePipeHandleForResume,
 222                                                 pUserData, sizeof(VideoAppData))) {
 223                                         VideoLogDebug("FAIL PIPE WRITE");
 224                                 }
 225                         }
 226                         nNetworkStatus = MP_NETWORK_TYPE_WIFI;
 227                         */
 228                         break;
 229
 230                 default:
 231                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 232                         VideoLogInfo("UNKNOWN NETWORK STATE");
 233                         if(pEcorePipeHandleForPause) {
 234                                 if(!ecore_pipe_write(pEcorePipeHandleForPause,
 235                                                 pUserData, sizeof(VideoAppData))) {
 236                                         VideoLogDebug("FAIL PIPE WRITE");
 237                                 }
 238                         }
 239                         break;
 240                 }
 241         }
 242         else {
 243                 if(pEcorePipeHandleForPause) {
 244                         if(!ecore_pipe_write(pEcorePipeHandleForPause,
 245                                         pUserData, sizeof(VideoAppData))) {
 246                                 VideoLogDebug("FAIL PIPE WRITE");
 247                         }
 248                 }
 249         }
 250 }
 251
 252 static void MpVideoStreamingCtrlChangeIpCb(keynode_t *pKeyNode, void *pUserData)
 253 {
 254         VideoLogInfo("");
 255
 256         if (!pUserData || !pKeyNode) {
 257                 VideoLogInfo("User data is NULL.");
 258                 return;
 259         }
 260
 261         char *szkeyname = NULL;
 262         char *szTmp = NULL;
 263
 264         szkeyname = vconf_keynode_get_name(pKeyNode);
 265         if(szkeyname == NULL) {
 266                 VideoLogInfo("key name value is NULL");
 267                 return;
 268         }
 269
 270         if (!strcmp(szkeyname, VCONFKEY_NETWORK_IP)) {
 271                 szTmp = vconf_keynode_get_str(pKeyNode);
 272
 273                 if(szTmp == NULL) {
 274                         VideoLogInfo("node string value is NULL");
 275                         return;
 276                 }
 277
 278                 VideoLogInfo("Network ip address : %s", szTmp);
 279         }
 280         else {
 281                 VideoLogInfo("Invalid ip address.");
 282         }
 283 }
 284
 285 static void MpVideoStreamingCtrlWiFiStateCb(keynode_t *pKeyNode, void *pUserData)
 286 {
 287         VideoLogInfo("");
 288
 289         if (!pUserData || !pKeyNode) {
 290                 VideoLogInfo("User data is NULL.");
 291                 return;
 292         }
 293
 294         char *szkeyname = NULL;
 295
 296         szkeyname = vconf_keynode_get_name(pKeyNode);
 297         if (!strcmp(szkeyname, VCONFKEY_NETWORK_WIFI_STATE)) {
 298                  switch(vconf_keynode_get_int(pKeyNode))
 299                  {
 300                 case VCONFKEY_NETWORK_WIFI_OFF:
 301                         nWifiState = MP_NETWORK_WIFI_OFF;
 302                         VideoLogInfo("MP_NETWORK_WIFI_OFF");
 303                         break;
 304
 305                 case VCONFKEY_NETWORK_WIFI_NOT_CONNECTED:
 306                         nWifiState = MP_NETWORK_WIFI_NOT_CONNECTED;
 307                         VideoLogInfo("MP_NETWORK_WIFI_NOT_CONNECTED");
 308                         break;
 309
 310                 case VCONFKEY_NETWORK_WIFI_CONNECTED:
 311                         nWifiState = MP_NETWORK_WIFI_CONNECTED;
 312                         VideoLogInfo("MP_NETWORK_WIFI_CONNECTED");
 313                         break;
 314
 315                 default:
 316                         nWifiState = MP_NETWORK_WIFI_OFF;
 317                         VideoLogInfo("MP_NETWORK_WIFI_OFF - default");
 318                         break;
 319                  }
 320         } else {
 321                 nWifiState = MP_NETWORK_WIFI_OFF;
 322                 VideoLogInfo("MP_NETWORK_WIFI_OFF - invalid value");
 323         }
 324 }
 325
 326 static void MpVideoStreamingCtrlCellularStateCb(keynode_t *pKeyNode,void *pUserData)
 327 {
 328         VideoLogInfo("");
 329
 330         if (!pUserData || !pKeyNode) {
 331                 VideoLogInfo("User data is NULL.");
 332                 return;
 333         }
 334
 335         char *szkeyname = NULL;
 336
 337         szkeyname = vconf_keynode_get_name(pKeyNode);
 338         if (!strcmp(szkeyname, VCONFKEY_NETWORK_CELLULAR_STATE)) {
 339                  switch(vconf_keynode_get_int(pKeyNode))
 340                  {
 341                 case VCONFKEY_NETWORK_CELLULAR_ON:
 342                         nCellularState = MP_NETWORK_CELLULAR_ON;
 343                         VideoLogInfo("MP_NETWORK_CELLULAR_ON");
 344                         break;
 345
 346                 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
 347                         nCellularState = MP_NETWORK_CELLULAR_3G_OPTION_OFF;
 348                         VideoLogInfo("MP_NETWORK_CELLULAR_3G_OPTION_OFF");
 349                         break;
 350
 351                 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
 352                         nCellularState = MP_NETWORK_CELLULAR_ROAMING_OFF;
 353                         VideoLogInfo("MP_NETWORK_CELLULAR_ROAMING_OFF");
 354                         break;
 355
 356                 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
 357                         nCellularState = MP_NETWORK_CELLULAR_FLIGHT_MODE;
 358                         VideoLogInfo("MP_NETWORK_CELLULAR_FLIGHT_MODE");
 359                         break;
 360
 361                 case VCONFKEY_NETWORK_CELLULAR_NO_SERVICE :
 362                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 363                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE");
 364                         break;
 365
 366                 default:
 367                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 368                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - default");
 369                         break;
 370                  }
 371         } else {
 372                 nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 373                 VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - invalid value");
 374         }
 375 }
 376
 377 static void MpVideoStreamingCtrlPipeInit(void *pUserData)
 378 {
 379         VideoLogInfo("");
 380
 381         if (!pUserData) {
 382                 VideoLogInfo("No exist pUserData");
 383                 return;
 384         }
 385
 386         VideoAppData *pAppData = (VideoAppData *)pUserData;
 387
 388         if(pEcorePipeHandleForPause) {
 389                 ecore_pipe_del(pEcorePipeHandleForPause);
 390                 pEcorePipeHandleForPause = NULL;
 391         }
 392
 393         pEcorePipeHandleForPause = ecore_pipe_add(
 394                         (Ecore_Pipe_Cb)MpVideoStreamingCtrlPauseCb,
 395                         (void *)pAppData);
 396
 397         if(pEcorePipeHandleForResume) {
 398                 ecore_pipe_del(pEcorePipeHandleForResume);
 399                 pEcorePipeHandleForResume = NULL;
 400         }
 401
 402         pEcorePipeHandleForResume = ecore_pipe_add(
 403                         (Ecore_Pipe_Cb)MpVideoStreamingCtrlResumeCb,
 404                         (void *)pAppData);
 405
 406 }
 407
 408 /*
 409  * Internal function.
 410  */
 411
 412 bool MpVideoStreamingCtrlSetNotifyNetworkOnOff(void *pUserData)
 413 {
 414         if (!pUserData) {
 415                 VideoLogInfo("[ERR] No exist pUserData.");
 416                 return FALSE;
 417         }
 418
 419         VideoLogInfo("");
 420
 421         VideoAppData *pAppData = (VideoAppData *)pUserData;
 422
 423         int nRet = 0;
 424
 425         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND,
 426                                         MpVideoStreamingCtrlNetworkOnOffCb,
 427                                         (void*)pAppData);
 428
 429         if (nRet < 0) {
 430                 VideoLogInfo("[ERR] Fail to set network on/off notification.");
 431                 return FALSE;
 432         }
 433
 434         return TRUE;
 435 }
 436
 437 bool MpVideoStreamingCtrlSetNotifyNetworkStatus(void *pUserData)
 438 {
 439         if (!pUserData) {
 440                 VideoLogInfo("[ERR] No exist pUserData.");
 441                 return FALSE;
 442         }
 443
 444         VideoLogInfo("");
 445
 446         VideoAppData *pAppData = (VideoAppData *)pUserData;
 447
 448         int nRet = 0;
 449
 450         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_STATUS,
 451                                                                         MpVideoStreamingCtrlNetworkStatusCb,
 452                                                                         (void*)pAppData);
 453
 454         if (nRet < 0) {
 455                 VideoLogInfo("[ERR] Fail to set network status notification.");
 456                 return FALSE;
 457         }
 458
 459         return TRUE;
 460 }
 461
 462 bool MpVideoStreamingCtrlSetNotifyChangingIp(void *pUserData)
 463 {
 464         if (!pUserData) {
 465                 VideoLogInfo("[ERR] No exist pUserData.");
 466                 return FALSE;
 467         }
 468
 469         VideoLogInfo("");
 470
 471         VideoAppData *pAppData = (VideoAppData *)pUserData;
 472
 473         int nRet = 0;
 474
 475         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_IP,
 476                                                                         MpVideoStreamingCtrlChangeIpCb,
 477                                                                         (void*)pAppData);
 478
 479         if (nRet < 0) {
 480                 VideoLogInfo("[ERR] Fail to set ip address changing notification.");
 481                 return FALSE;
 482         }
 483
 484         return TRUE;
 485 }
 486
 487 bool MpVideoStreamingCtrlSetNotifyWiFiState(void *pUserData)
 488 {
 489         if (!pUserData) {
 490                 VideoLogInfo("[ERR] No exist pUserData.");
 491                 return FALSE;
 492         }
 493
 494         VideoLogInfo("");
 495
 496         VideoAppData *pAppData = (VideoAppData *)pUserData;
 497
 498         int nRet = 0;
 499
 500         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_WIFI_STATE,
 501                                                                         MpVideoStreamingCtrlWiFiStateCb,
 502                                                                         (void*)pAppData);
 503
 504         if (nRet < 0) {
 505                 VideoLogInfo("[ERR] Fail to set wifi state notification.");
 506                 return FALSE;
 507         }
 508
 509         return TRUE;
 510 }
 511
 512 bool MpVideoStreamingCtrlSetNotifyCellularState(void *pUserData)
 513 {
 514         if (!pUserData) {
 515                 VideoLogInfo("[ERR] No exist pUserData.");
 516                 return FALSE;
 517         }
 518
 519         VideoLogInfo("");
 520
 521         VideoAppData *pAppData = (VideoAppData *)pUserData;
 522
 523         int nRet = 0;
 524
 525         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_CELLULAR_STATE,
 526                                                                         MpVideoStreamingCtrlCellularStateCb,
 527                                                                         (void*)pAppData);
 528
 529         if (nRet < 0) {
 530                 VideoLogInfo("[ERR] Fail to set cellular notification.");
 531                 return FALSE;
 532         }
 533
 534         return TRUE;
 535 }
 536
 537
 538 /*
 539  * External function.
 540  */
 541 bool MpVideoStreamingCtrlGetIpAddress(char* szRetIpAddress)
 542 {
 543         VideoLogInfo("");
 544
 545         char *szTmp = NULL;
 546
 547         szTmp = vconf_get_str(VCONFKEY_NETWORK_IP);
 548         if (szTmp) {
 549                 memset(szRetIpAddress, 0, sizeof(char) * STR_LEN_MAX);
 550                 strncpy(szRetIpAddress, szTmp, STR_LEN_MAX - 1);
 551
 552                 VideoLogInfo("Current network ip address : %s", szRetIpAddress);
 553
 554                 if(szTmp)
 555                         free(szTmp);
 556
 557                 return TRUE;
 558         }
 559
 560         return FALSE;
 561 }
 562
 563 bool MpVideoStreamingCtrlGetProxy(char* szRetProxy)
 564 {
 565         VideoLogInfo("");
 566
 567         char *szTmp = NULL;
 568
 569         szTmp = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 570         if (szTmp) {
 571                 memset(szRetProxy, 0, sizeof(char) * STR_LEN_MAX);
 572                 strncpy(szRetProxy, szTmp, STR_LEN_MAX - 1);
 573
 574                 VideoLogInfo("Current network ip address : %s", szRetProxy);
 575
 576                 if(szTmp)
 577                         free(szTmp);
 578
 579                 return TRUE;
 580         }
 581
 582         return FALSE;
 583 }
 584
 585 bool MpVideoStreamingCtrlIsNetworkOn(void)
 586 {
 587         VideoLogInfo("");
 588
 589         int ntmpCheckNetworkON = 0;
 590
 591         if (!vconf_get_int(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND, &ntmpCheckNetworkON)) {
 592                 switch(ntmpCheckNetworkON)
 593                 {
 594                 case MP_NETWORK_CLOSE:
 595                         VideoLogInfo("Network close.");
 596                         return FALSE;
 597
 598                 case MP_NETWORK_ON:
 599                         VideoLogInfo("Network on.");
 600                         return TRUE;
 601                 }
 602         } else {
 603                 VideoLogInfo("Network close.");
 604         }
 605
 606         return FALSE;
 607 }
 608
 609 int MpVideoStreamingCtrlGetNetworkStatus(void)
 610 {
 611         VideoLogInfo("");
 612
 613         int ntmpGetNetworkStatus = 0;
 614
 615         if (!vconf_get_int(VCONFKEY_NETWORK_STATUS, &ntmpGetNetworkStatus)) {
 616                 switch(ntmpGetNetworkStatus)
 617                 {
 618                 case VCONFKEY_NETWORK_OFF:
 619                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 620                         VideoLogInfo("MP_NETWORK_TYPE_OFF");
 621                         break;
 622
 623                 case VCONFKEY_NETWORK_CELLULAR:
 624                         nNetworkStatus = MP_NETWORK_TYPE_CELLULAR;
 625                         VideoLogInfo("MP_NETWORK_TYPE_CELLULAR");
 626                         break;
 627
 628                 case VCONFKEY_NETWORK_WIFI:
 629                         nNetworkStatus = MP_NETWORK_TYPE_WIFI;
 630                         VideoLogInfo("MP_NETWORK_TYPE_WIFI");
 631                         break;
 632
 633                 default:
 634                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 635                         VideoLogInfo("MP_NETWORK_TYPE_OFF - default");
 636                         break;
 637                 }
 638         } else {
 639                 nNetworkStatus = MP_NETWORK_TYPE_OFF;
 640                 VideoLogInfo("MP_NETWORK_TYPE_OFF - invalid value");
 641         }
 642
 643         return nNetworkStatus;
 644 }
 645
 646 int MpVideoStreamingCtrlGetWifiState()
 647 {
 648         VideoLogInfo("");
 649
 650         int ntmpGetWifiState = 0;
 651
 652         if (!vconf_get_int(VCONFKEY_NETWORK_WIFI_STATE, &ntmpGetWifiState)) {
 653                 switch(ntmpGetWifiState)
 654                 {
 655                 case VCONFKEY_NETWORK_WIFI_OFF:
 656                         nWifiState = MP_NETWORK_WIFI_OFF;
 657                         VideoLogInfo("MP_NETWORK_WIFI_OFF");
 658                         break;
 659
 660                 case VCONFKEY_NETWORK_WIFI_NOT_CONNECTED:
 661                         nWifiState = MP_NETWORK_WIFI_NOT_CONNECTED;
 662                         VideoLogInfo("MP_NETWORK_WIFI_NOT_CONNECTED");
 663                         break;
 664
 665                 case VCONFKEY_NETWORK_WIFI_CONNECTED:
 666                         nWifiState = MP_NETWORK_WIFI_CONNECTED;
 667                         VideoLogInfo("MP_NETWORK_WIFI_CONNECTED");
 668                         break;
 669
 670                 default:
 671                         nWifiState = MP_NETWORK_WIFI_OFF;
 672                         VideoLogInfo("MP_NETWORK_WIFI_OFF - default");
 673                         break;
 674                  }
 675         } else {
 676                 nWifiState = MP_NETWORK_WIFI_OFF;
 677                 VideoLogInfo("MP_NETWORK_WIFI_OFF - invalid value");
 678         }
 679
 680         return nWifiState;
 681
 682 }
 683
 684 int MpVideoStreamingCtrlGetCellularState()
 685 {
 686         VideoLogInfo("");
 687
 688         int ntmpGetCellularState = 0;
 689
 690         if (!vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &ntmpGetCellularState)) {
 691                 switch(ntmpGetCellularState)
 692                 {
 693                 case VCONFKEY_NETWORK_CELLULAR_ON:
 694                         nCellularState = MP_NETWORK_CELLULAR_ON;
 695                         VideoLogInfo("MP_NETWORK_CELLULAR_ON");
 696                         break;
 697
 698                 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
 699                         nCellularState = MP_NETWORK_CELLULAR_3G_OPTION_OFF;
 700                         VideoLogInfo("MP_NETWORK_CELLULAR_3G_OPTION_OFF");
 701                         break;
 702
 703                 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
 704                         nCellularState = MP_NETWORK_CELLULAR_ROAMING_OFF;
 705                         VideoLogInfo("MP_NETWORK_CELLULAR_ROAMING_OFF");
 706                         break;
 707
 708                 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
 709                         nCellularState = MP_NETWORK_CELLULAR_FLIGHT_MODE;
 710                         VideoLogInfo("MP_NETWORK_CELLULAR_FLIGHT_MODE");
 711                         break;
 712
 713                 case VCONFKEY_NETWORK_CELLULAR_NO_SERVICE :
 714                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 715                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE");
 716                         break;
 717
 718                 default:
 719                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 720                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - default");
 721                         break;
 722                 }
 723         } else {
 724                 nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 725                 VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - invalid value");
 726         }
 727
 728         return nCellularState;
 729 }
 730
 731 void MpVideoStreamingCtrlDestroy(void *pUserData)
 732 {
 733         VideoLogInfo("");
 734
 735         if (pNetworkTimeoutTimer) {
 736                 ecore_timer_del(pNetworkTimeoutTimer);
 737                 pNetworkTimeoutTimer = NULL;
 738         }
 739
 740         if(pEcorePipeHandleForPause) {
 741                 ecore_pipe_del(pEcorePipeHandleForPause);
 742                 pEcorePipeHandleForPause = NULL;
 743         }
 744
 745         if(pEcorePipeHandleForResume) {
 746                 ecore_pipe_del(pEcorePipeHandleForResume);
 747                 pEcorePipeHandleForResume = NULL;
 748         }
 749 }
 750
 751
 752
 753 bool MpVideoStreamingCtrlInit(void *pUserData)
 754 {
 755         if (!pUserData) {
 756                 VideoLogInfo("[ERR] No exist pUserData.");
 757                 return FALSE;
 758         }
 759
 760         VideoLogInfo("");
 761
 762         VideoAppData *pAppData = (VideoAppData *)pUserData;
 763         char szTmp[STR_LEN_MAX] = {0};
 764         bool bNetworkState = FALSE;
 765
 766         if(bIsInitCallbackFunc == EINA_FALSE) {
 767                 MpVideoStreamingCtrlPipeInit(pUserData);
 768
 769                 MpVideoStreamingCtrlSetNotifyNetworkStatus(pUserData);
 770                 MpVideoStreamingCtrlSetNotifyChangingIp(pUserData);
 771                 MpVideoStreamingCtrlSetNotifyWiFiState(pUserData);
 772                 MpVideoStreamingCtrlSetNotifyCellularState(pUserData);
 773
 774                 bIsInitCallbackFunc = EINA_TRUE;
 775         }
 776
 777         if (pNetworkTimeoutTimer) {
 778                 ecore_timer_del(pNetworkTimeoutTimer);
 779                 pNetworkTimeoutTimer = NULL;
 780         }
 781
 782         switch(MpVideoStreamingCtrlGetNetworkStatus())
 783         {
 784         case MP_NETWORK_TYPE_OFF:
 785                 VideoLogInfo("MP_NETWORK_TYPE_OFF");
 786                 pNetworkTimeoutTimer = ecore_timer_add(NETWORK_TIMEOUT,
 787                                                 MpVideoStreamingCtrlPopupCb,
 788                                                 pAppData);
 789                 bNetworkState = FALSE;
 790                 break;
 791
 792         case MP_NETWORK_TYPE_CELLULAR:
 793                 VideoLogInfo("MP_NETWORK_TYPE_CELLULAR");
 794                 if(MpVideoStreamingCtrlGetCellularState() == MP_NETWORK_CELLULAR_ON)
 795                         bNetworkState = TRUE;
 796                 break;
 797
 798         case MP_NETWORK_TYPE_WIFI:
 799                 VideoLogInfo("MP_NETWORK_TYPE_WIFI");
 800                 if(MpVideoStreamingCtrlGetWifiState() == MP_NETWORK_WIFI_CONNECTED)
 801                         bNetworkState = TRUE;
 802                 break;
 803         }
 804
 805         if(bNetworkState) {
 806                 MpVideoStreamingCtrlGetIpAddress(szTmp);
 807                 VideoLogInfo("Current IP Address : %s", szTmp);
 808
 809                 memset(szTmp, 0, STR_LEN_MAX);
 810                 MpVideoStreamingCtrlGetProxy(szTmp);
 811                 VideoLogInfo("Current Proxy Address : %s", szTmp);
 812
 813                 memset(pAppData->szProxyAddress, 0, STR_LEN_MAX);
 814                 strncpy(pAppData->szProxyAddress, szTmp, STR_LEN_MAX - 1);
 815         }
 816
 817         return bNetworkState;
 818 }