src/mp-video-volume-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 #include <sound_manager.h>
  18 #include <Elementary.h>
  19
  20 #include "video-player.h"
  21
  22 #include "mp-util.h"
  23 #include "mp-video-log.h"
  24 #include "mp-video-type-define.h"
  25 #include "mp-video-value-define.h"
  26 #include "mp-video-string-define.h"
  27 #include "mp-video-volume-ctrl.h"
  28
  29 //#include "mp-video-statistics.h"
  30
  31 #define VOLUME_CTRL_HIDE_TIMER_INTERVAL         3.0
  32 #define VOLUME_CTRL_DRAG_TIMER_INTERVAL         0.3
  33
  34
  35 typedef struct __MpVolumeCtrlData MpVolumeCtrlData;
  36
  37 struct __MpVolumeCtrlData{
  38         VideoAppData            *pAppData;
  39
  40         Evas_Object             *pLayout;
  41
  42         Ecore_Timer             *pHideTimer;
  43         Ecore_Timer             *pDragTimer;
  44
  45         int                     nMaxVol;
  46         int                     nMinVol;
  47
  48         int                     nCurVol;
  49
  50 };
  51
  52 static MpVolumeCtrlData *pVolumeData = NULL;
  53
  54 static void MpVideoVolumeCtrlUpdateTextValue(void *pUserData)
  55 {
  56
  57         VideoLogInfo("");
  58         if(pUserData == NULL)
  59         {
  60                 VideoLogError("Volume ctrl data is null.");
  61                 return;
  62         }
  63
  64         VideoLogInfo("");
  65
  66         MpVolumeCtrlData        *pCtrlData = (MpVolumeCtrlData *)pUserData;
  67
  68         char szVol[3] = {0,};
  69         snprintf(szVol, 3, "%d", pCtrlData->nCurVol);
  70
  71         VideoLogError("%d , %s", pCtrlData->nCurVol, szVol);
  72
  73         edje_object_part_text_set(_EDJ(pCtrlData->pLayout), "volume.progress.circle.txt", szVol);
  74
  75 }
  76
  77 static void MpVideoVolumeCtrlUpdateDragValue(void *pUserData)
  78 {
  79
  80         VideoLogInfo("");
  81         if(pUserData == NULL)
  82         {
  83                 VideoLogError("Volume ctrl data is null.");
  84                 return;
  85         }
  86
  87         VideoLogInfo("");
  88
  89         MpVolumeCtrlData        *pCtrlData = (MpVolumeCtrlData *)pUserData;
  90
  91
  92         double fVolPos = 0.0;
  93         fVolPos = ((double)pCtrlData->nCurVol/(double)pCtrlData->nMaxVol);
  94         edje_object_part_drag_value_set(_EDJ(pCtrlData->pLayout), "volume.progress.drag", fVolPos, 0.0);
  95
  96 }
  97
  98 static int MpVideoVolumeCtrlGetMaxVolume()
  99 {
 100         VideoLogInfo("");
 101
 102         int nRet = SOUND_MANAGER_ERROR_NONE;
 103         int nMax = 0;
 104         nRet = sound_manager_get_max_volume (SOUND_TYPE_MEDIA, &nMax);
 105         if(nRet != SOUND_MANAGER_ERROR_NONE)
 106         {
 107                 VideoLogError("Sound manage get max volue fail : %d", nRet);
 108                 return -1;
 109         }
 110
 111         return nMax;
 112 }
 113 static int MpVideoVolumeCtrlGetCurVolume()
 114 {
 115         VideoLogInfo("");
 116
 117         int nRet = SOUND_MANAGER_ERROR_NONE;
 118         int nVol = 0;
 119         nRet = sound_manager_get_volume  (SOUND_TYPE_MEDIA, &nVol);
 120         if(nRet != SOUND_MANAGER_ERROR_NONE)
 121         {
 122                 VideoLogError("Sound manage get current volue fail : %d", nRet);
 123                 return -1;
 124         }
 125
 126         return nVol;
 127 }
 128
 129 static void MpVideoVolumeCtrlSetCurVolume(int nVol)
 130 {
 131         VideoLogInfo("");
 132
 133         int nRet = SOUND_MANAGER_ERROR_NONE;
 134         nRet = sound_manager_set_volume  (SOUND_TYPE_MEDIA, nVol);
 135         if(nRet != SOUND_MANAGER_ERROR_NONE)
 136         {
 137                 VideoLogError("Sound manage get current volue fail : %d", nRet);
 138                 return;
 139         }
 140
 141         return;
 142 }
 143
 144 static Eina_Bool MpVideoVolumeCtrlHideTimerCb(void *pUserData)
 145 {
 146         VideoLogInfo("");
 147         if(pUserData == NULL)
 148         {
 149                 VideoLogError("pAppData is null.");
 150                 return EINA_FALSE;
 151         }
 152
 153         MpVolumeCtrlData        *pCtrlData = (MpVolumeCtrlData *)pUserData;
 154         if(pCtrlData->pHideTimer)
 155         {
 156                 ecore_timer_del(pCtrlData->pHideTimer);
 157                 pCtrlData->pHideTimer = NULL;
 158         }
 159
 160         pCtrlData->pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideVolume(pCtrlData->pAppData);
 161
 162         return EINA_FALSE;
 163 }
 164
 165
 166 static Eina_Bool MpVideoVolumeCtrlDragTimerCb(void *pUserData)
 167 {
 168         VideoLogInfo("");
 169         if(pUserData == NULL)
 170         {
 171                 VideoLogError("pAppData is null.");
 172                 return EINA_FALSE;
 173         }
 174
 175         VideoLogInfo("");
 176
 177         MpVolumeCtrlData        *pCtrlData = (MpVolumeCtrlData *)pUserData;
 178
 179         double fVolPos = 0.0;
 180
 181         edje_object_part_drag_value_get(_EDJ(pCtrlData->pLayout), "volume.progress.drag", &fVolPos, NULL);
 182
 183         pCtrlData->nCurVol = (int)(pCtrlData->nMaxVol * fVolPos);
 184
 185         MpVideoVolumeCtrlSetCurVolume(pCtrlData->nCurVol);
 186
 187         MpVideoVolumeCtrlUpdateTextValue((void *)pCtrlData);
 188
 189         return EINA_TRUE;
 190 }
 191
 192
 193
 194 static void MpVideoVolumeCtrlDragStartcb(void *pUserData, Evas_Object *obj, const char *szEmission, const char *szSource)
 195 {
 196         VideoLogInfo("");
 197         if(pUserData == NULL)
 198         {
 199                 VideoLogError("pAppData is null.");
 200                 return;
 201         }
 202         MpVolumeCtrlData        *pCtrlData = (MpVolumeCtrlData *)pUserData;
 203
 204         if(pCtrlData->pHideTimer)
 205         {
 206                 ecore_timer_del(pCtrlData->pHideTimer);
 207                 pCtrlData->pHideTimer = NULL;
 208         }
 209
 210         pCtrlData->pDragTimer = ecore_timer_add(VOLUME_CTRL_DRAG_TIMER_INTERVAL, MpVideoVolumeCtrlDragTimerCb, (void *)pCtrlData);
 211 }
 212
 213 static void MpVideoVolumeCtrlDragStopcb(void *pUserData, Evas_Object *obj, const char *szEmission, const char *szSource)
 214 {
 215         VideoLogInfo("");
 216         if(pUserData == NULL)
 217         {
 218                 VideoLogError("pAppData is null.");
 219                 return;
 220         }
 221         MpVolumeCtrlData        *pCtrlData = (MpVolumeCtrlData *)pUserData;
 222
 223         if(pCtrlData->pHideTimer)
 224         {
 225                 ecore_timer_del(pCtrlData->pHideTimer);
 226                 pCtrlData->pHideTimer = NULL;
 227         }
 228
 229         pCtrlData->pHideTimer = ecore_timer_add(VOLUME_CTRL_HIDE_TIMER_INTERVAL, MpVideoVolumeCtrlHideTimerCb, (void *)pCtrlData);
 230
 231         if(pCtrlData->pDragTimer)
 232         {
 233                 ecore_timer_del(pCtrlData->pDragTimer);
 234                 pCtrlData->pDragTimer = NULL;
 235         }
 236
 237         double fVolPos = 0.0;
 238         edje_object_part_drag_value_get(_EDJ(pCtrlData->pLayout), "volume.progress.drag", &fVolPos, NULL);
 239         pCtrlData->nCurVol = (int)(pCtrlData->nMaxVol * fVolPos);
 240
 241         MpVideoVolumeCtrlSetCurVolume(pCtrlData->nCurVol);
 242         MpVideoVolumeCtrlUpdateTextValue((void *)pCtrlData);
 243 }
 244
 245 static void MpVideoVolumeCtrlDragcb(void *pUserData, Evas_Object *obj, const char *szEmission, const char *szSource)
 246 {
 247         VideoLogInfo("");
 248
 249         if(pUserData == NULL)
 250         {
 251                 VideoLogError("pAppData is null.");
 252                 return;
 253         }
 254
 255         VideoLogInfo("");
 256
 257         MpVolumeCtrlData        *pCtrlData = (MpVolumeCtrlData *)pUserData;
 258         double fVolPos = 0.0;
 259         edje_object_part_drag_value_get(_EDJ(pCtrlData->pLayout), "volume.progress.drag", &fVolPos, NULL);
 260         pCtrlData->nCurVol = (int)(pCtrlData->nMaxVol * fVolPos);
 261
 262         MpVideoVolumeCtrlUpdateTextValue((void *)pCtrlData);
 263
 264 }
 265
 266
 267 void *MpVideoVolumeCtrlInit(void *pParent, void* pUserData)
 268 {
 269         if(pUserData == NULL)
 270         {
 271                 VideoLogError("pAppData is null.");
 272                 return NULL;
 273         }
 274
 275         if(pParent == NULL)
 276         {
 277                 VideoLogError("pParent is null.");
 278                 return NULL;
 279         }
 280
 281         VideoLogInfo("");
 282
 283         MpVolumeCtrlData        *pCtrlData = NULL;
 284         VideoAppData            *pAppData = (VideoAppData *)pUserData;
 285
 286         pCtrlData = calloc(1, sizeof(MpVolumeCtrlData));
 287
 288         pCtrlData->nMinVol = 0;
 289         pCtrlData->nMaxVol = MpVideoVolumeCtrlGetMaxVolume();
 290         pCtrlData->nCurVol = MpVideoVolumeCtrlGetCurVolume();
 291
 292         Evas_Object *layout = elm_layout_add(pParent);
 293         elm_layout_file_set(layout, VIDEO_PLAYER_VOLUME_POPUP_EDJ, VOLUME_EDJ_GROUP);
 294         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 295         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 296         evas_object_hide(layout);
 297
 298         edje_object_signal_callback_add(_EDJ(layout), "drag,start", "volume.progress.drag", MpVideoVolumeCtrlDragStartcb, (void *)pCtrlData);
 299         edje_object_signal_callback_add(_EDJ(layout), "drag,stop", "volume.progress.drag", MpVideoVolumeCtrlDragStopcb, (void *)pCtrlData);
 300         edje_object_signal_callback_add(_EDJ(layout), "drag", "volume.progress.drag", MpVideoVolumeCtrlDragcb, (void *)pCtrlData);
 301
 302         pCtrlData->pAppData = pAppData;
 303         pCtrlData->pLayout = layout;
 304
 305         MpVideoVolumeCtrlSetCurVolume(pCtrlData->nCurVol);
 306         MpVideoVolumeCtrlUpdateTextValue((void *)pCtrlData);
 307         MpVideoVolumeCtrlUpdateDragValue((void *)pCtrlData);
 308
 309         pVolumeData = pCtrlData;
 310
 311         return layout;
 312
 313 }
 314
 315 void MpVideoVolumeCtrlDestroy(void)
 316 {
 317         VideoLogInfo("");
 318
 319         if(pVolumeData == NULL)
 320         {
 321                 VideoLogError("Volume Ctrl data is NULL");
 322                 return;
 323         }
 324
 325         if(pVolumeData->pLayout)
 326         {
 327                 evas_object_del(pVolumeData->pLayout);
 328                 pVolumeData->pLayout = NULL;
 329
 330         }
 331
 332         if(pVolumeData->pHideTimer)
 333         {
 334                 ecore_timer_del(pVolumeData->pHideTimer);
 335                 pVolumeData->pHideTimer = NULL;
 336         }
 337
 338         if(pVolumeData->pDragTimer)
 339         {
 340                 ecore_timer_del(pVolumeData->pDragTimer);
 341                 pVolumeData->pDragTimer = NULL;
 342         }
 343
 344         free(pVolumeData);
 345         pVolumeData = NULL;
 346
 347 }
 348
 349
 350 void MpVideoVolumeCtrlShow()
 351 {
 352         VideoLogInfo("");
 353
 354         if(pVolumeData == NULL)
 355         {
 356                 VideoLogError("Volume Ctrl data is NULL");
 357                 return;
 358         }
 359         MpVolumeCtrlData *pCtrlData = pVolumeData;
 360
 361         evas_object_show(pCtrlData->pLayout);
 362
 363         if(pCtrlData->pHideTimer)
 364         {
 365                 ecore_timer_del(pCtrlData->pHideTimer);
 366                 pCtrlData->pHideTimer = NULL;
 367         }
 368
 369         pCtrlData->pHideTimer = ecore_timer_add(VOLUME_CTRL_HIDE_TIMER_INTERVAL, MpVideoVolumeCtrlHideTimerCb, (void *)pCtrlData);
 370
 371 }
 372
 373 void MpVideoVolumeCtrlHide()
 374 {
 375         VideoLogInfo("");
 376
 377         if(pVolumeData == NULL)
 378         {
 379                 VideoLogError("Volume Ctrl data is NULL");
 380                 return;
 381         }
 382
 383         MpVolumeCtrlData *pCtrlData = pVolumeData;
 384
 385         if(pCtrlData->pHideTimer)
 386         {
 387                 ecore_timer_del(pCtrlData->pHideTimer);
 388                 pCtrlData->pHideTimer = NULL;
 389         }
 390
 391         evas_object_hide(pCtrlData->pLayout);
 392 }
 393
 394
 395 void MpVideoVolumeCtrlSetVolume(int nVol)
 396 {
 397         VideoLogInfo("");
 398
 399         if(pVolumeData == NULL)
 400         {
 401                 VideoLogError("Volume Ctrl data is NULL");
 402                 return;
 403         }
 404         MpVolumeCtrlData *pCtrlData = pVolumeData;
 405
 406         if(nVol > pCtrlData->nMaxVol)
 407         {
 408                 nVol = pCtrlData->nMaxVol;
 409         }
 410
 411         if(nVol < 0)
 412         {
 413                 nVol = 0;
 414         }
 415
 416         MpVideoVolumeCtrlShow();
 417
 418         pCtrlData->nCurVol = nVol;
 419         MpVideoVolumeCtrlSetCurVolume(nVol);
 420         MpVideoVolumeCtrlUpdateTextValue((void *)pCtrlData);
 421         MpVideoVolumeCtrlUpdateDragValue((void *)pCtrlData);
 422
 423 }
 424
 425 int MpVideoVolumeCtrlGetVolume()
 426 {
 427         VideoLogInfo("");
 428
 429         return MpVideoVolumeCtrlGetCurVolume();
 430 }
 431
 432 bool MpVideoVolumeCtrlGetShowStatus()
 433 {
 434         VideoLogInfo("");
 435
 436         if(pVolumeData == NULL)
 437         {
 438                 VideoLogError("Volume Ctrl data is NULL");
 439                 return FALSE;
 440         }
 441         MpVolumeCtrlData *pCtrlData = pVolumeData;
 442
 443         if(pCtrlData->pHideTimer)
 444         {
 445                 return TRUE;
 446         }
 447
 448         return FALSE;
 449 }
 450