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         } else {
  50                 sound_manager_set_volume(SOUND_TYPE_MEDIA, m->volume);
  51         }
  52
  53         m->mute = mute;
  54 }
  55
  56 void CVolume::m_SetVolume(volume_val val)
  57 {
  58         int vol;
  59         int r;
  60
  61         vol = 0;
  62
  63         switch (val) {
  64         case E_VOLUME_UP:
  65         case E_VOLUME_DOWN:
  66                 m_SetMute(false);
  67
  68                 r = sound_manager_get_volume(SOUND_TYPE_MEDIA, &vol);
  69                 if (r != SOUND_MANAGER_ERROR_NONE) {
  70                         _ERR("get volume error");
  71                         return;
  72                 }
  73
  74                 vol += val;
  75
  76                 sound_manager_set_volume(SOUND_TYPE_MEDIA, vol);
  77                 break;
  78         case E_VOLUME_MUTE:
  79                 m_SetMute(!m->mute);
  80                 break;
  81         default:
  82                 break;
  83         }
  84 }
  85
  86 void CVolume::m_UpdateVolume(void)
  87 {
  88         double val;
  89         int vol;
  90         char buf[8];
  91         int r;
  92
  93         if (!m->bar)
  94                 return;
  95
  96         r = sound_manager_get_volume(SOUND_TYPE_MEDIA, &vol);
  97         if (r != SOUND_MANAGER_ERROR_NONE) {
  98                 _ERR("get volume error");
  99                 vol = 0;
 100         }
 101
 102         if (vol == 0 || m->mute) {
 103                 elm_object_signal_emit(m->ly, SIG_VOLUME_MUTE, "base");
 104                 val = 0;
 105         } else {
 106                 elm_object_signal_emit(m->ly, SIG_VOLUME_UNMUTE, "base");
 107                 val = vol * 0.01;
 108         }
 109
 110         elm_progressbar_value_set(m->bar, val);
 111
 112         snprintf(buf, sizeof(buf), "%d", vol);
 113         elm_object_part_text_set(m->ly, PART_VOLUME_VALUE, buf);
 114 }
 115
 116 Eina_Bool CVolume::sm_CbTimer(void *dt)
 117 {
 118         SVolumeData *data;
 119
 120         if (!dt)
 121                 return ECORE_CALLBACK_CANCEL;
 122
 123         data = (SVolumeData *)dt;
 124
 125         evas_object_hide(data->ly);
 126         data->timer = NULL;
 127
 128         return ECORE_CALLBACK_CANCEL;
 129 }
 130
 131 void CVolume::Show(volume_val val)
 132 {
 133         ASSERT(m);
 134
 135         if (!m->timer) {
 136                 m->timer = ecore_timer_add(TIME_INTERVAL, sm_CbTimer, m);
 137                 evas_object_show(m->ly);
 138         } else {
 139                 ecore_timer_reset(m->timer);
 140         }
 141
 142         m_SetVolume(val);
 143         m_UpdateVolume();
 144 }
 145
 146 void CVolume::Hide(void)
 147 {
 148         ASSERT(m);
 149
 150         evas_object_hide(m->ly);
 151
 152         ecore_timer_del(m->timer);
 153         m->timer = NULL;
 154 }
 155
 156 bool CVolume::Create(Evas_Object *base)
 157 {
 158         ASSERT(!m);
 159
 160         Evas_Object *ly;
 161         Evas_Object *bar;
 162
 163         m = new SVolumeData;
 164         if (!m) {
 165                 _ERR("allocation fail");
 166                 return false;
 167         }
 168
 169         ly = elm_layout_add(base);
 170         if (!ly) {
 171                 delete m;
 172                 return false;
 173         }
 174
 175         elm_layout_file_set(ly, EDJEFILE, GRP_VOLUME);
 176         elm_win_resize_object_add(base, ly);
 177         evas_object_hide(ly);
 178
 179         bar = elm_progressbar_add(ly);
 180         if (!bar) {
 181                 _ERR("failed to create progressbar");
 182                 delete m;
 183                 evas_object_del(ly);
 184                 return false;
 185         }
 186
 187         evas_object_size_hint_weight_set(bar, EVAS_HINT_EXPAND,
 188                         EVAS_HINT_EXPAND);
 189         elm_progressbar_horizontal_set(bar, EINA_TRUE);
 190         elm_object_style_set(bar, STYLE_VOLUME_BAR);
 191         elm_object_part_content_set(ly, PART_VOLUME_BAR, bar);
 192         evas_object_show(bar);
 193
 194         m->ly = ly;
 195         m->bar = bar;
 196
 197         sound_manager_set_session_type(SOUND_SESSION_TYPE_EXCLUSIVE);
 198
 199         return true;
 200 }
 201
 202 void CVolume::Destroy(void)
 203 {
 204         ASSERT(m);
 205
 206         ecore_timer_del(m->timer);
 207         delete m;
 208         m = NULL;
 209 }