src/mp-video-streaming-ctrl.c

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