homescreen/src/paclient.cpp

   1 /*
   2  * Copyright (C) 2016,2017 Konsulko Group
   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 "paclient.h"
  18
  19 #include <QtCore/QDebug>
  20
  21 PaClient::PaClient()
  22         : m_init(false), m_ml(nullptr), m_mlapi(nullptr), m_ctx(nullptr)
  23 {
  24 }
  25
  26 PaClient::~PaClient()
  27 {
  28         if (m_init)
  29                 close();
  30 }
  31
  32 void PaClient::close()
  33 {
  34         if (!m_init) return;
  35         pa_threaded_mainloop_stop(m_ml);
  36         pa_threaded_mainloop_free(m_ml);
  37         m_init = false;
  38 }
  39
  40 static void set_sink_volume_cb(pa_context *c, int success, void *data)
  41 {
  42         Q_UNUSED(data);
  43
  44         if (!success)
  45                 qWarning() << "PaClient: set sink volume: " <<
  46                         pa_strerror(pa_context_errno(c));
  47 }
  48
  49 void PaClient::incDecVolume(const int volume_delta)
  50 {
  51         pa_operation *o;
  52         pa_context *c = context();
  53         pa_sink_info *i = getDefaultSinkInfo();
  54
  55         if (volume_delta > 0)
  56                 pa_cvolume_inc_clamp(&i->volume, volume_delta, 65536);
  57         else
  58                 pa_cvolume_dec(&i->volume, abs(volume_delta));
  59
  60         o = pa_context_set_sink_volume_by_index(c, i->index, &i->volume, set_sink_volume_cb, NULL);
  61         if (!o) {
  62                 qWarning() << "PaClient: set sink #" << i->index <<
  63                         " volume: " << pa_strerror(pa_context_errno(c));
  64                 return;
  65         }
  66         pa_operation_unref(o);
  67 }
  68
  69 void get_sink_info_change_cb(pa_context *c,
  70                 const pa_sink_info *i,
  71                 int eol,
  72                 void *data)
  73 {
  74         Q_UNUSED(c);
  75         Q_ASSERT(i);
  76         Q_ASSERT(data);
  77
  78         if (eol) return;
  79
  80         PaClient *self = reinterpret_cast<PaClient*>(data);
  81         pa_sink_info *si = self->getDefaultSinkInfo();
  82         if (i->index == si->index) {
  83                 self->setDefaultSinkInfo(i);
  84                 pa_cvolume *cvolume = &self->getDefaultSinkInfo()->volume;
  85                 emit self->volumeExternallyChanged(pa_cvolume_avg(cvolume));
  86         }
  87 }
  88
  89 void get_default_sink_info_cb(pa_context *c,
  90                 const pa_sink_info *i,
  91                 int eol,
  92                 void *data)
  93 {
  94         Q_UNUSED(c);
  95         Q_ASSERT(i);
  96         Q_ASSERT(data);
  97
  98         if (eol) return;
  99
 100         PaClient *self = reinterpret_cast<PaClient*>(data);
 101         self->setDefaultSinkInfo(i);
 102 }
 103
 104 pa_sink_info *PaClient::getDefaultSinkInfo(void)
 105 {
 106         return &m_default_sink_info;
 107 }
 108
 109 void PaClient::setDefaultSinkInfo(const pa_sink_info *i)
 110 {
 111         m_default_sink_info.index = i->index;
 112         m_default_sink_info.channel_map.channels = i->channel_map.channels;
 113         pa_cvolume *cvolume = &m_default_sink_info.volume;
 114         cvolume->channels = i->volume.channels;
 115         for (int chan = 0; chan < i->channel_map.channels; chan++) {
 116                 cvolume->values[chan] = i->volume.values[chan];
 117         }
 118 }
 119
 120 void get_server_info_cb(pa_context *c,
 121                 const pa_server_info *i,
 122                 void *data)
 123 {
 124         pa_operation *o;
 125         o = pa_context_get_sink_info_by_name(c, i->default_sink_name, get_default_sink_info_cb, data);
 126         if (!o) {
 127                 qWarning() << "PaClient: get sink info by name: " <<
 128                         pa_strerror(pa_context_errno(c));
 129                 return;
 130         }
 131 }
 132
 133 void subscribe_cb(pa_context *c,
 134                 pa_subscription_event_type_t type,
 135                 uint32_t index,
 136                 void *data)
 137 {
 138         pa_operation *o;
 139
 140         if ((type & PA_SUBSCRIPTION_EVENT_TYPE_MASK) != PA_SUBSCRIPTION_EVENT_CHANGE) {
 141                 qWarning("PaClient: unhandled subscribe event operation");
 142                 return;
 143         }
 144
 145         switch (type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
 146                 case PA_SUBSCRIPTION_EVENT_SINK:
 147                         o = pa_context_get_sink_info_by_index(c, index, get_sink_info_change_cb, data);
 148                         if (!o) {
 149                                 qWarning() << "PaClient: get sink info by index: " <<
 150                                         pa_strerror(pa_context_errno(c));
 151                                 return;
 152                         }
 153                         break;
 154                 default:
 155                         qWarning("PaClient: unhandled subscribe event facility");
 156         }
 157 }
 158
 159 void context_state_cb(pa_context *c, void *data)
 160 {
 161         pa_operation *o;
 162         PaClient *self = reinterpret_cast<PaClient*>(data);
 163
 164         switch (pa_context_get_state(c)) {
 165                 case PA_CONTEXT_CONNECTING:
 166                 case PA_CONTEXT_AUTHORIZING:
 167                 case PA_CONTEXT_SETTING_NAME:
 168                         break;
 169                 case PA_CONTEXT_READY:
 170                         o = pa_context_get_server_info(c, get_server_info_cb, data);
 171                         if (!o) {
 172                                 qWarning() << "PaClient: get server info: " <<
 173                                         pa_strerror(pa_context_errno(c));
 174                                 return;
 175                         }
 176                         pa_operation_unref(o);
 177                         pa_context_set_subscribe_callback(c, subscribe_cb, data);
 178                         o = pa_context_subscribe(c, (pa_subscription_mask_t)(PA_SUBSCRIPTION_MASK_SINK), NULL, NULL);
 179                         if (!o) {
 180                                 qWarning() << "PaClient: subscribe: " <<
 181                                         pa_strerror(pa_context_errno(c));
 182                                 return;
 183                         }
 184                         break;
 185                 case PA_CONTEXT_TERMINATED:
 186                         self->close();
 187                         break;
 188
 189                 case PA_CONTEXT_FAILED:
 190                 default:
 191                         qCritical() << "PaClient: connection failed: " <<
 192                                 pa_strerror(pa_context_errno(c));
 193                         self->close();
 194                         break;
 195         }
 196 }
 197
 198 void PaClient::init()
 199 {
 200         m_ml = pa_threaded_mainloop_new();
 201         if (!m_ml) {
 202                 qCritical("PaClient: failed to create mainloop");
 203                 return;
 204         }
 205
 206         pa_threaded_mainloop_set_name(m_ml, "PaClient mainloop");
 207
 208         m_mlapi = pa_threaded_mainloop_get_api(m_ml);
 209
 210         lock();
 211
 212         m_ctx = pa_context_new(m_mlapi, "HomeScreen");
 213         if (!m_ctx) {
 214                 qCritical("PaClient: failed to create context");
 215                 unlock();
 216                 pa_threaded_mainloop_free(m_ml);
 217                 return;
 218         }
 219         pa_context_set_state_callback(m_ctx, context_state_cb, this);
 220
 221         if (pa_context_connect(m_ctx, 0, (pa_context_flags_t)0, 0) < 0) {
 222                 qCritical("PaClient: failed to connect");
 223                 pa_context_unref(m_ctx);
 224                 unlock();
 225                 pa_threaded_mainloop_free(m_ml);
 226                 return;
 227         }
 228
 229         if (pa_threaded_mainloop_start(m_ml) != 0) {
 230                 qCritical("PaClient: failed to start mainloop");
 231                 pa_context_unref(m_ctx);
 232                 unlock();
 233                 pa_threaded_mainloop_free(m_ml);
 234                 return;
 235         }
 236
 237         unlock();
 238
 239         m_init = true;
 240 }