src/volume.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   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 <Elementary.h>
  18 #include <Eina.h>
  19 #include <media/sound_manager.h>
  20 #include <AppCommon.h>
  21 #include <dbg.h>
  22 #include "define.h"
  23 #include "volume.h"
  24
  25 #define TIME_INTERVAL 3.0
  26
  27 struct SVolumeData {
  28         Evas_Object *ly;
  29         Evas_Object *bar;
  30         Ecore_Timer *timer;
  31         int volume;
  32         bool mute;
  33 };
  34
  35 void CVolume::m_SetMute(bool mute)
  36 {
  37         int r;
  38         int vol;
  39
  40         if (m->mute == mute)
  41                 return;
  42
  43         if (mute) {
  44                 r = sound_manager_get_volume(SOUND_TYPE_MEDIA, &vol);
  45                 if (r < 0)
  46                         return;
  47
  48                 m->volume = vol;
  49                 sound_manager_set_volume(SOUND_TYPE_MEDIA, 0);
  50         } else {
  51                 sound_manager_set_volume(SOUND_TYPE_MEDIA, m->volume);
  52         }
  53
  54         m->mute = mute;
  55 }
  56
  57 void CVolume::m_SetVolume(volume_val val)
  58 {
  59         int vol;
  60         int r;
  61
  62         vol = 0;
  63
  64         switch (val) {
  65         case E_VOLUME_UP:
  66         case E_VOLUME_DOWN:
  67                 m_SetMute(false);
  68
  69                 r = sound_manager_get_volume(SOUND_TYPE_MEDIA, &vol);
  70                 if (r != SOUND_MANAGER_ERROR_NONE) {
  71                         _ERR("get volume error");
  72                         return;
  73                 }
  74
  75                 vol += val;
  76
  77                 sound_manager_set_volume(SOUND_TYPE_MEDIA, vol);
  78                 break;
  79         case E_VOLUME_MUTE:
  80                 m_SetMute(!m->mute);
  81                 break;
  82         default:
  83                 break;
  84         }
  85 }
  86
  87 void CVolume::m_UpdateVolume(void)
  88 {
  89         double val;
  90         int vol;
  91         char buf[8];
  92         int r;
  93
  94         r = sound_manager_get_volume(SOUND_TYPE_MEDIA, &vol);
  95         if (r != SOUND_MANAGER_ERROR_NONE) {
  96                 _ERR("get volume error");
  97                 vol = 0;
  98         }
  99
 100         if (vol == 0 || m->mute) {
 101                 elm_object_signal_emit(m->ly, SIG_VOLUME_MUTE, "base");
 102                 val = 0;
 103         } else {
 104                 elm_object_signal_emit(m->ly, SIG_VOLUME_UNMUTE, "base");
 105                 val = vol * 0.01;
 106         }
 107
 108         elm_progressbar_value_set(m->bar, val);
 109
 110         snprintf(buf, sizeof(buf), "%d", vol);
 111         elm_object_part_text_set(m->ly, PART_VOLUME_VALUE, buf);
 112 }
 113
 114 Eina_Bool CVolume::sm_CbTimer(void *dt)
 115 {
 116         ASSERT(dt);
 117
 118         SVolumeData *data;
 119
 120         data = (SVolumeData *)dt;
 121
 122         evas_object_hide(data->ly);
 123         data->timer = NULL;
 124
 125         return ECORE_CALLBACK_CANCEL;
 126 }
 127
 128 void CVolume::Show(volume_val val)
 129 {
 130         ASSERT(m);
 131
 132         if (!m->timer) {
 133                 m->timer = ecore_timer_add(TIME_INTERVAL, sm_CbTimer, m);
 134                 evas_object_show(m->ly);
 135         } else {
 136                 ecore_timer_reset(m->timer);
 137         }
 138
 139         m_SetVolume(val);
 140         m_UpdateVolume();
 141 }
 142
 143 void CVolume::Hide(void)
 144 {
 145         ASSERT(m);
 146
 147         evas_object_hide(m->ly);
 148
 149         ecore_timer_del(m->timer);
 150         m->timer = NULL;
 151 }
 152
 153 bool CVolume::Create(Evas_Object *base)
 154 {
 155         ASSERT(!m);
 156
 157         Evas_Object *ly;
 158         Evas_Object *bar;
 159
 160         ly = elm_layout_add(base);
 161         if (!ly)
 162                 return false;
 163
 164         elm_layout_file_set(ly, EDJEFILE, GRP_VOLUME);
 165         elm_win_resize_object_add(base, ly);
 166         evas_object_hide(ly);
 167
 168         bar = elm_progressbar_add(ly);
 169         if (!bar) {
 170                 _ERR("failed to create progressbar");
 171                 evas_object_del(ly);
 172                 return false;
 173         }
 174
 175         evas_object_size_hint_weight_set(bar, EVAS_HINT_EXPAND,
 176                         EVAS_HINT_EXPAND);
 177         elm_progressbar_horizontal_set(bar, EINA_TRUE);
 178         elm_object_style_set(bar, STYLE_VOLUME_BAR);
 179         elm_object_part_content_set(ly, PART_VOLUME_BAR, bar);
 180         evas_object_show(bar);
 181
 182         m = new SVolumeData;
 183         if (!m) {
 184                 _ERR("allocation fail");
 185                 evas_object_del(ly);
 186                 return false;
 187         }
 188
 189         m->ly = ly;
 190         m->bar = bar;
 191         m->timer = NULL;
 192
 193         sound_manager_set_session_type(SOUND_SESSION_TYPE_EXCLUSIVE);
 194
 195         return true;
 196 }
 197
 198 void CVolume::Destroy(void)
 199 {
 200         ASSERT(m);
 201
 202         ecore_timer_del(m->timer);
 203
 204         delete m;
 205         m = NULL;
 206 }