src/mp-video-volume-ctrl.c

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