src/mp-video-streaming-ctrl.c

   1 /*
   2  * Copyright 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://www.tizenopensource.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
  19 #include <string.h>
  20 #include <vconf.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 static char szNetworkProxy[STR_LEN_MAX] = {0};
  32 static char szNetworkIpAddress[STR_LEN_MAX] = {0};
  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 Eina_Bool        bIsInitCallbackFunc = FALSE;
  38
  39
  40 /*
  41  * Callback function.
  42  */
  43
  44
  45
  46 static void MpVideoStreamingCtrlNetworkOnOffCb(keynode_t *pKeyNode,void *pUserData)
  47 {
  48         VideoLogInfo("");
  49
  50         if (!pUserData || !pKeyNode) {
  51                 VideoLogInfo("User data is NULL.");
  52                 return;
  53         }
  54
  55         char *szkeyname = NULL;
  56
  57         szkeyname = vconf_keynode_get_name(pKeyNode);
  58         if (!strcmp(szkeyname, VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND)) {
  59                  switch(vconf_keynode_get_int(pKeyNode))
  60                  {
  61                 case MP_NETWORK_CLOSE:
  62                         VideoLogInfo("MP_NETWORK_CLOSE");
  63                         break;
  64
  65                 case MP_NETWORK_ON:
  66                         VideoLogInfo("MP_NETWORK_ON");
  67                         break;
  68
  69                 default:
  70                         VideoLogInfo("UNKNOWN NETWORK CONFIG");
  71                         break;
  72                  }
  73         } else {
  74         }
  75 }
  76
  77 static void MpVideoStreamingCtrlNetworkStatusCb(keynode_t *pKeyNode,void *pUserData)
  78 {
  79         if (!pUserData || !pKeyNode) {
  80                 VideoLogInfo("User data is NULL.");
  81                 return;
  82         }
  83
  84         VideoLogInfo("");
  85         char *szkeyname = NULL;
  86
  87         szkeyname = vconf_keynode_get_name(pKeyNode);
  88         if (!strcmp(szkeyname, VCONFKEY_NETWORK_STATUS)) {
  89                 switch(vconf_keynode_get_int(pKeyNode))
  90                 {
  91                 case VCONFKEY_NETWORK_OFF:
  92                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
  93                         VideoLogInfo("MP_NETWORK_TYPE_OFF");
  94                         break;
  95
  96                 case VCONFKEY_NETWORK_CELLULAR:
  97                         VideoLogInfo("MP_NETWORK_TYPE_CELLULAR");
  98                         nNetworkStatus = MP_NETWORK_TYPE_CELLULAR;
  99                         break;
 100
 101                 case VCONFKEY_NETWORK_WIFI:
 102                         VideoLogInfo("MP_NETWORK_TYPE_WIFI");
 103                         nNetworkStatus = MP_NETWORK_TYPE_WIFI;
 104                         break;
 105
 106                 default:
 107                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 108                         VideoLogInfo("UNKNOWN NETWORK STATE");
 109                         break;
 110                 }
 111         }
 112 }
 113
 114 static void MpVideoStreamingCtrlChangeIpCb(keynode_t *pKeyNode, void *pUserData)
 115 {
 116         VideoLogInfo("");
 117
 118         if (!pUserData || !pKeyNode) {
 119                 VideoLogInfo("User data is NULL.");
 120                 return;
 121         }
 122
 123         char *szkeyname = NULL;
 124         char *szTmp = NULL;
 125
 126         memset(szNetworkIpAddress, 0, sizeof(char) * STR_LEN_MAX);
 127         szkeyname = vconf_keynode_get_name(pKeyNode);
 128         if(szkeyname == NULL) {
 129                 VideoLogInfo("key name value is NULL");
 130                 return;
 131         }
 132
 133         if (!strcmp(szkeyname, VCONFKEY_NETWORK_IP)) {
 134                 szTmp = vconf_keynode_get_str(pKeyNode);
 135
 136                 if(szTmp == NULL) {
 137                         VideoLogInfo("node string value is NULL");
 138                         return;
 139                 }
 140
 141                 strncpy(szNetworkIpAddress, szTmp, STR_LEN_MAX - 1);
 142
 143                 VideoLogInfo("Network ip address : %s", szNetworkIpAddress);
 144         }
 145         else {
 146                 VideoLogInfo("Invalid ip address.");
 147         }
 148 }
 149
 150 static void MpVideoStreamingCtrlWiFiStateCb(keynode_t *pKeyNode, void *pUserData)
 151 {
 152         VideoLogInfo("");
 153
 154         if (!pUserData || !pKeyNode) {
 155                 VideoLogInfo("User data is NULL.");
 156                 return;
 157         }
 158
 159         char *szkeyname = NULL;
 160
 161         szkeyname = vconf_keynode_get_name(pKeyNode);
 162         if (!strcmp(szkeyname, VCONFKEY_NETWORK_WIFI_STATE)) {
 163                  switch(vconf_keynode_get_int(pKeyNode))
 164                  {
 165                 case VCONFKEY_NETWORK_WIFI_OFF:
 166                         nWifiState = MP_NETWORK_WIFI_OFF;
 167                         VideoLogInfo("MP_NETWORK_WIFI_OFF");
 168                         break;
 169
 170                 case VCONFKEY_NETWORK_WIFI_NOT_CONNECTED:
 171                         nWifiState = MP_NETWORK_WIFI_NOT_CONNECTED;
 172                         VideoLogInfo("MP_NETWORK_WIFI_NOT_CONNECTED");
 173                         break;
 174
 175                 case VCONFKEY_NETWORK_WIFI_CONNECTED:
 176                         nWifiState = MP_NETWORK_WIFI_CONNECTED;
 177                         VideoLogInfo("MP_NETWORK_WIFI_CONNECTED");
 178                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 179                         break;
 180
 181                 default:
 182                         nWifiState = MP_NETWORK_WIFI_OFF;
 183                         VideoLogInfo("MP_NETWORK_WIFI_OFF - default");
 184                         break;
 185                  }
 186         } else {
 187                 nWifiState = MP_NETWORK_WIFI_OFF;
 188                 VideoLogInfo("MP_NETWORK_WIFI_OFF - invalid value");
 189         }
 190 }
 191
 192 static void MpVideoStreamingCtrlCellularStateCb(keynode_t *pKeyNode,void *pUserData)
 193 {
 194         VideoLogInfo("");
 195
 196         if (!pUserData || !pKeyNode) {
 197                 VideoLogInfo("User data is NULL.");
 198                 return;
 199         }
 200
 201         char *szkeyname = NULL;
 202
 203         szkeyname = vconf_keynode_get_name(pKeyNode);
 204         if (!strcmp(szkeyname, VCONFKEY_NETWORK_CELLULAR_STATE)) {
 205                  switch(vconf_keynode_get_int(pKeyNode))
 206                  {
 207                 case VCONFKEY_NETWORK_CELLULAR_ON:
 208                         nCellularState = MP_NETWORK_CELLULAR_ON;
 209                         VideoLogInfo("MP_NETWORK_CELLULAR_ON");
 210                         break;
 211
 212                 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
 213                         nCellularState = MP_NETWORK_CELLULAR_3G_OPTION_OFF;
 214                         VideoLogInfo("MP_NETWORK_CELLULAR_3G_OPTION_OFF");
 215                         break;
 216
 217                 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
 218                         nCellularState = MP_NETWORK_CELLULAR_ROAMING_OFF;
 219                         VideoLogInfo("MP_NETWORK_CELLULAR_ROAMING_OFF");
 220                         break;
 221
 222                 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
 223                         nCellularState = MP_NETWORK_CELLULAR_FLIGHT_MODE;
 224                         VideoLogInfo("MP_NETWORK_CELLULAR_FLIGHT_MODE");
 225                         break;
 226
 227                 case VCONFKEY_NETWORK_CELLULAR_NO_SERVICE :
 228                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 229                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE");
 230                         break;
 231
 232                 default:
 233                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 234                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - default");
 235                         break;
 236                  }
 237         } else {
 238                 nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 239                 VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - invalid value");
 240         }
 241 }
 242
 243
 244 /*
 245  * Internal function.
 246  */
 247
 248 bool MpVideoStreamingCtrlSetNotifyNetworkOnOff(void *pUserData)
 249 {
 250         if (!pUserData) {
 251                 VideoLogInfo("[ERR] No exist pUserData.");
 252                 return FALSE;
 253         }
 254
 255         VideoLogInfo("");
 256
 257         VideoAppData *pAppData = (VideoAppData *)pUserData;
 258
 259         int nRet = 0;
 260
 261         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND,
 262                                         MpVideoStreamingCtrlNetworkOnOffCb,
 263                                         (void*)pAppData);
 264
 265         if (nRet < 0) {
 266                 VideoLogInfo("[ERR] Fail to set network on/off notification.");
 267                 return FALSE;
 268         }
 269
 270         return TRUE;
 271 }
 272
 273 bool MpVideoStreamingCtrlSetNotifyNetworkStatus(void *pUserData)
 274 {
 275         if (!pUserData) {
 276                 VideoLogInfo("[ERR] No exist pUserData.");
 277                 return FALSE;
 278         }
 279
 280         VideoLogInfo("");
 281
 282         VideoAppData *pAppData = (VideoAppData *)pUserData;
 283
 284         int nRet = 0;
 285
 286         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_STATUS,
 287                                                                         MpVideoStreamingCtrlNetworkStatusCb,
 288                                                                         (void*)pAppData);
 289
 290         if (nRet < 0) {
 291                 VideoLogInfo("[ERR] Fail to set network status notification.");
 292                 return FALSE;
 293         }
 294
 295         return TRUE;
 296 }
 297
 298 bool MpVideoStreamingCtrlSetNotifyChangingIp(void *pUserData)
 299 {
 300         if (!pUserData) {
 301                 VideoLogInfo("[ERR] No exist pUserData.");
 302                 return FALSE;
 303         }
 304
 305         VideoLogInfo("");
 306
 307         VideoAppData *pAppData = (VideoAppData *)pUserData;
 308
 309         int nRet = 0;
 310
 311         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_IP,
 312                                                                         MpVideoStreamingCtrlChangeIpCb,
 313                                                                         (void*)pAppData);
 314
 315         if (nRet < 0) {
 316                 VideoLogInfo("[ERR] Fail to set ip address changing notification.");
 317                 return FALSE;
 318         }
 319
 320         return TRUE;
 321 }
 322
 323 bool MpVideoStreamingCtrlSetNotifyWiFiState(void *pUserData)
 324 {
 325         if (!pUserData) {
 326                 VideoLogInfo("[ERR] No exist pUserData.");
 327                 return FALSE;
 328         }
 329
 330         VideoLogInfo("");
 331
 332         VideoAppData *pAppData = (VideoAppData *)pUserData;
 333
 334         int nRet = 0;
 335
 336         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_WIFI_STATE,
 337                                                                         MpVideoStreamingCtrlWiFiStateCb,
 338                                                                         (void*)pAppData);
 339
 340         if (nRet < 0) {
 341                 VideoLogInfo("[ERR] Fail to set wifi state notification.");
 342                 return FALSE;
 343         }
 344
 345         return TRUE;
 346 }
 347
 348 bool MpVideoStreamingCtrlSetNotifyCellularState(void *pUserData)
 349 {
 350         if (!pUserData) {
 351                 VideoLogInfo("[ERR] No exist pUserData.");
 352                 return FALSE;
 353         }
 354
 355         VideoLogInfo("");
 356
 357         VideoAppData *pAppData = (VideoAppData *)pUserData;
 358
 359         int nRet = 0;
 360
 361         nRet = vconf_notify_key_changed(VCONFKEY_NETWORK_CELLULAR_STATE,
 362                                                                         MpVideoStreamingCtrlCellularStateCb,
 363                                                                         (void*)pAppData);
 364
 365         if (nRet < 0) {
 366                 VideoLogInfo("[ERR] Fail to set cellular notification.");
 367                 return FALSE;
 368         }
 369
 370         return TRUE;
 371 }
 372
 373
 374 /*
 375  * External function.
 376  */
 377 bool MpVideoStreamingCtrlGetIpAddress(char* szRetIpAddress)
 378 {
 379         VideoLogInfo("");
 380
 381         char *szTmp = NULL;
 382
 383         szTmp = vconf_get_str(VCONFKEY_NETWORK_IP);
 384         if (szTmp) {
 385                 memset(szNetworkIpAddress, 0, sizeof(char) * STR_LEN_MAX);
 386                 strncpy(szNetworkIpAddress, szTmp, STR_LEN_MAX - 1);
 387
 388                 memset(szRetIpAddress, 0, sizeof(char) * STR_LEN_MAX);
 389                 strncpy(szRetIpAddress, szTmp, STR_LEN_MAX - 1);
 390
 391                 VideoLogInfo("Current network ip address : %s", szNetworkIpAddress);
 392
 393                 if(szTmp)
 394                         free(szTmp);
 395
 396                 return TRUE;
 397         }
 398
 399         return FALSE;
 400 }
 401
 402 bool MpVideoStreamingCtrlGetProxy(char* szRetProxy)
 403 {
 404         VideoLogInfo("");
 405
 406         char *szTmp = NULL;
 407
 408         szTmp = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 409         if (szTmp) {
 410                 memset(szNetworkProxy, 0, sizeof(char) * STR_LEN_MAX);
 411                 strncpy(szNetworkProxy, szTmp, STR_LEN_MAX - 1);
 412
 413                 memset(szRetProxy, 0, sizeof(char) * STR_LEN_MAX);
 414                 strncpy(szRetProxy, szTmp, STR_LEN_MAX - 1);
 415
 416                 VideoLogInfo("Current network ip address : %s", szNetworkProxy);
 417
 418                 if(szTmp)
 419                         free(szTmp);
 420
 421                 return TRUE;
 422         }
 423
 424         return FALSE;
 425 }
 426
 427 bool MpVideoStreamingCtrlIsNetworkOn(void)
 428 {
 429         VideoLogInfo("");
 430
 431         int ntmpCheckNetworkON = 0;
 432
 433         if (!vconf_get_int(VCONFKEY_NETWORK_CONFIGURATION_CHANGE_IND, &ntmpCheckNetworkON)) {
 434                 switch(ntmpCheckNetworkON)
 435                 {
 436                 case MP_NETWORK_CLOSE:
 437                         VideoLogInfo("Network close.");
 438                         return FALSE;
 439
 440                 case MP_NETWORK_ON:
 441                         VideoLogInfo("Network on.");
 442                         return TRUE;
 443                 }
 444         } else {
 445                 VideoLogInfo("Network close.");
 446         }
 447
 448         return FALSE;
 449 }
 450
 451 int MpVideoStreamingCtrlGetNetworkStatus(void)
 452 {
 453         VideoLogInfo("");
 454
 455         int ntmpGetNetworkStatus = 0;
 456
 457         if (!vconf_get_int(VCONFKEY_NETWORK_STATUS, &ntmpGetNetworkStatus)) {
 458                 switch(ntmpGetNetworkStatus)
 459                 {
 460                 case VCONFKEY_NETWORK_OFF:
 461                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 462                         VideoLogInfo("MP_NETWORK_TYPE_OFF");
 463                         break;
 464
 465                 case VCONFKEY_NETWORK_CELLULAR:
 466                         nNetworkStatus = MP_NETWORK_TYPE_CELLULAR;
 467                         VideoLogInfo("MP_NETWORK_TYPE_CELLULAR");
 468                         break;
 469
 470                 case VCONFKEY_NETWORK_WIFI:
 471                         nNetworkStatus = MP_NETWORK_TYPE_WIFI;
 472                         VideoLogInfo("MP_NETWORK_TYPE_WIFI");
 473                         break;
 474
 475                 default:
 476                         nNetworkStatus = MP_NETWORK_TYPE_OFF;
 477                         VideoLogInfo("MP_NETWORK_TYPE_OFF - default");
 478                         break;
 479                 }
 480         } else {
 481                 nNetworkStatus = MP_NETWORK_TYPE_OFF;
 482                 VideoLogInfo("MP_NETWORK_TYPE_OFF - invalid value");
 483         }
 484
 485         return nNetworkStatus;
 486 }
 487
 488 int MpVideoStreamingCtrlGetWifiState()
 489 {
 490         VideoLogInfo("");
 491
 492         int ntmpGetWifiState = 0;
 493
 494         if (!vconf_get_int(VCONFKEY_NETWORK_WIFI_STATE, &ntmpGetWifiState)) {
 495                 switch(ntmpGetWifiState)
 496                 {
 497                 case VCONFKEY_NETWORK_WIFI_OFF:
 498                         nWifiState = MP_NETWORK_WIFI_OFF;
 499                         VideoLogInfo("MP_NETWORK_WIFI_OFF");
 500                         break;
 501
 502                 case VCONFKEY_NETWORK_WIFI_NOT_CONNECTED:
 503                         nWifiState = MP_NETWORK_WIFI_NOT_CONNECTED;
 504                         VideoLogInfo("MP_NETWORK_WIFI_NOT_CONNECTED");
 505                         break;
 506
 507                 case VCONFKEY_NETWORK_WIFI_CONNECTED:
 508                         nWifiState = MP_NETWORK_WIFI_CONNECTED;
 509                         VideoLogInfo("MP_NETWORK_WIFI_CONNECTED");
 510                         break;
 511
 512                 default:
 513                         nWifiState = MP_NETWORK_WIFI_OFF;
 514                         VideoLogInfo("MP_NETWORK_WIFI_OFF - default");
 515                         break;
 516                  }
 517         } else {
 518                 nWifiState = MP_NETWORK_WIFI_OFF;
 519                 VideoLogInfo("MP_NETWORK_WIFI_OFF - invalid value");
 520         }
 521
 522         return nWifiState;
 523
 524 }
 525
 526 int MpVideoStreamingCtrlGetCellularState()
 527 {
 528         VideoLogInfo("");
 529
 530         int ntmpGetCellularState = 0;
 531
 532         if (!vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &ntmpGetCellularState)) {
 533                 switch(ntmpGetCellularState)
 534                 {
 535                 case VCONFKEY_NETWORK_CELLULAR_ON:
 536                         nCellularState = MP_NETWORK_CELLULAR_ON;
 537                         VideoLogInfo("MP_NETWORK_CELLULAR_ON");
 538                         break;
 539
 540                 case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
 541                         nCellularState = MP_NETWORK_CELLULAR_3G_OPTION_OFF;
 542                         VideoLogInfo("MP_NETWORK_CELLULAR_3G_OPTION_OFF");
 543                         break;
 544
 545                 case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
 546                         nCellularState = MP_NETWORK_CELLULAR_ROAMING_OFF;
 547                         VideoLogInfo("MP_NETWORK_CELLULAR_ROAMING_OFF");
 548                         break;
 549
 550                 case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
 551                         nCellularState = MP_NETWORK_CELLULAR_FLIGHT_MODE;
 552                         VideoLogInfo("MP_NETWORK_CELLULAR_FLIGHT_MODE");
 553                         break;
 554
 555                 case VCONFKEY_NETWORK_CELLULAR_NO_SERVICE :
 556                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 557                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE");
 558                         break;
 559
 560                 default:
 561                         nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 562                         VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - default");
 563                         break;
 564                 }
 565         } else {
 566                 nCellularState = MP_NETWORK_CELLULAR_NO_SERVICE;
 567                 VideoLogInfo("MP_NETWORK_CELLULAR_NO_SERVICE - invalid value");
 568         }
 569
 570         return nCellularState;
 571 }
 572
 573 void MpVideoStreamingCtrlDestroy(void *pUserData)
 574 {
 575         VideoLogInfo("");
 576
 577 }
 578
 579
 580
 581 bool MpVideoStreamingCtrlInit(void *pUserData)
 582 {
 583         if (!pUserData) {
 584                 VideoLogInfo("[ERR] No exist pUserData.");
 585                 return FALSE;
 586         }
 587
 588         VideoLogInfo("");
 589
 590         VideoAppData *pAppData = (VideoAppData *)pUserData;
 591         char szTmp[STR_LEN_MAX] = {0};
 592         bool bNetworkState = FALSE;
 593
 594         if(bIsInitCallbackFunc == EINA_FALSE) {
 595                 MpVideoStreamingCtrlSetNotifyNetworkStatus(pUserData);
 596                 MpVideoStreamingCtrlSetNotifyChangingIp(pUserData);
 597                 MpVideoStreamingCtrlSetNotifyWiFiState(pUserData);
 598                 MpVideoStreamingCtrlSetNotifyCellularState(pUserData);
 599
 600                 bIsInitCallbackFunc = EINA_TRUE;
 601         }
 602
 603         switch(MpVideoStreamingCtrlGetNetworkStatus())
 604         {
 605         case MP_NETWORK_TYPE_OFF:
 606                 VideoLogInfo("MP_NETWORK_TYPE_OFF");
 607                 bNetworkState = FALSE;
 608                 break;
 609
 610         case MP_NETWORK_TYPE_CELLULAR:
 611                 VideoLogInfo("MP_NETWORK_TYPE_CELLULAR");
 612                 if(MpVideoStreamingCtrlGetCellularState() == MP_NETWORK_CELLULAR_ON)
 613                         bNetworkState = TRUE;
 614                 break;
 615
 616         case MP_NETWORK_TYPE_WIFI:
 617                 VideoLogInfo("MP_NETWORK_TYPE_WIFI");
 618                 if(MpVideoStreamingCtrlGetWifiState() == MP_NETWORK_WIFI_CONNECTED)
 619                         bNetworkState = TRUE;
 620                 break;
 621         }
 622
 623         if(bNetworkState) {
 624                 MpVideoStreamingCtrlGetIpAddress(szTmp);
 625                 VideoLogInfo("Current IP Address : %s", szTmp);
 626
 627                 memset(szTmp, 0, STR_LEN_MAX);
 628                 MpVideoStreamingCtrlGetProxy(szTmp);
 629                 VideoLogInfo("Current Proxy Address : %s", szTmp);
 630                 VideoLogInfo("Current Proxy Address : %s", szTmp);
 631
 632                 memset(pAppData->szProxyAddress, 0, STR_LEN_MAX);
 633                 strncpy(pAppData->szProxyAddress, szTmp, STR_LEN_MAX - 1);
 634         }
 635
 636         return bNetworkState;
 637 }
 638
 639
 640