git.maemo.org Git - mafwsubrenderer/blob - qmafw-gst-subtitles-renderer/unittests/ut_MafwGstRendererVolume/MafwVolumeStubs.cpp

   1 #include <QDebug>
   2 #include <QVariant>
   3 #include <dbus/dbus.h>
   4 #include <dbusconnectioneventloop.h>
   5 #include "MafwStubHelper.h"
   6
   7 char obj_path[] = "/org/pulseaudio/stream_restore1/entry7";
   8
   9 MafwStubHelper* m_stubHelper = 0;
  10 void* m_user_data;
  11 DBusHandleMessageFunction m_signalCb;
  12 DBusPendingCallNotifyFunction m_restoreObjectCb = 0;
  13 DBusPendingCallNotifyFunction m_volumeCb = 0;
  14 DBusMessage* m_getVolumeMethodCall = 0;
  15 DBusMessage* m_setVolumeMethod = 0;
  16
  17 QMap<uint, uint> m_volumes;
  18
  19 void setStubHelper(MafwStubHelper* stubHlp)
  20 {
  21     m_stubHelper = stubHlp;
  22 }
  23
  24 dbus_bool_t dbus_error_is_set(const DBusError* error)
  25 {
  26     Q_UNUSED(error);
  27     return m_stubHelper->getReturn("dbus_error_is_set").toBool();
  28 }
  29
  30 struct DBusConnection
  31 {
  32   int aField;
  33 };
  34
  35 DBusConnection* dbus_connection_open(const char *address, DBusError *error)
  36 {
  37     DBusConnection* conn = 0;
  38
  39     if (m_stubHelper->getReturn("dbus_connection_open").toBool())
  40     {
  41         conn = static_cast<DBusConnection*>( malloc(sizeof(DBusConnection)) );
  42     }
  43     Q_UNUSED(address);
  44     Q_UNUSED(error);
  45     return conn;
  46 }
  47
  48 void dbus_connection_unref(DBusConnection* conn)
  49 {
  50     if (conn)
  51     {
  52         free(conn);
  53     }
  54 }
  55
  56 bool DBUSConnectionEventLoop::addConnection(DBusConnection* conn)
  57 {
  58     Q_UNUSED(conn);
  59
  60     return m_stubHelper->getReturn("addConnection").toBool();
  61 }
  62
  63 void DBUSConnectionEventLoop::removeConnection(DBusConnection* conn)
  64 {
  65     Q_UNUSED(conn);
  66
  67     m_stubHelper->getReturn("removeConnection");
  68 }
  69
  70 dbus_bool_t dbus_connection_add_filter(DBusConnection* connection,
  71                                        DBusHandleMessageFunction function,
  72                                        void* user_data,
  73                                        DBusFreeFunction free_data_function)
  74 {
  75     Q_UNUSED(connection);
  76     Q_UNUSED(free_data_function);
  77     m_signalCb = function;
  78     m_user_data = user_data;
  79     return true;
  80 }
  81
  82 void dbus_pending_call_cancel(DBusPendingCall* pending)
  83 {
  84     Q_UNUSED(pending);
  85 }
  86
  87 dbus_bool_t dbus_set_error_from_message(DBusError* error, DBusMessage* message)
  88 {
  89     Q_UNUSED(error);
  90     Q_UNUSED(message);
  91     return m_stubHelper->getReturn("dbus_set_error_from_message").toBool();
  92 }
  93
  94 void signalVolumeUpdated(uint channel, uint value)
  95 {
  96     DBusMessage* message = dbus_message_new_signal(obj_path, "org.PulseAudio.Ext.StreamRestore1.RestoreEntry", "VolumeUpdated");
  97
  98     DBusMessageIter argument_iterator, variant_iterator, struct_iterator;
  99     dbus_message_iter_init_append (message, &argument_iterator);
 100     dbus_message_iter_open_container (&argument_iterator,
 101                                       DBUS_TYPE_VARIANT,
 102                                       "(uu)",
 103                                       &variant_iterator);
 104     dbus_message_iter_open_container (&variant_iterator,
 105                                       DBUS_TYPE_STRUCT,
 106                                       NULL,
 107                                       &struct_iterator);
 108
 109     dbus_message_iter_append_basic (&struct_iterator, DBUS_TYPE_UINT32, &channel);
 110     dbus_message_iter_append_basic (&struct_iterator, DBUS_TYPE_UINT32, &value);
 111
 112     dbus_message_iter_close_container (&variant_iterator, &struct_iterator);
 113     dbus_message_iter_close_container (&argument_iterator, &variant_iterator);
 114
 115     DBusConnection* conn = 0;
 116     (*m_signalCb)(conn, message, m_user_data);
 117     dbus_message_unref(message);
 118 }
 119
 120 struct DBusPendingCall
 121 {
 122     uint a;
 123 };
 124
 125 dbus_bool_t dbus_connection_send_with_reply(DBusConnection* connection,
 126                                             DBusMessage* message,
 127                                             DBusPendingCall ** pending_return,
 128                                             int timeout_milliseconds)
 129 {
 130     DBusPendingCall pending;
 131     *pending_return = &pending;
 132     Q_UNUSED(connection);
 133     m_getVolumeMethodCall = message;
 134     Q_UNUSED(pending_return);
 135     Q_UNUSED(timeout_milliseconds);
 136     return true;
 137 }
 138
 139 // Saves callback function pointer. Assumes that first call gives callback for
 140 // GetEntryByName and the second one gives callback for Get Volume
 141 dbus_bool_t dbus_pending_call_set_notify( DBusPendingCall* pending,
 142                                           DBusPendingCallNotifyFunction function,
 143                                           void* user_data,
 144                                           DBusFreeFunction free_user_data)
 145 {
 146     if (!m_restoreObjectCb)
 147     {
 148         m_restoreObjectCb = function;
 149     }
 150     else
 151     {
 152         m_volumeCb = function;
 153     }
 154
 155     Q_UNUSED(pending);
 156     Q_UNUSED(user_data);
 157     Q_UNUSED(free_user_data);
 158     return true;
 159 }
 160
 161 void giveRestoreEntryReply()
 162 {
 163     DBusPendingCall pending;
 164     (*m_restoreObjectCb) (&pending, m_user_data);
 165 }
 166
 167 void giveVolumeReply(QMap<uint, uint> volumes)
 168 {
 169     DBusPendingCall pending;
 170     m_volumes = volumes;
 171     (*m_volumeCb) (&pending, m_user_data);
 172 }
 173
 174 DBusMessage* dbus_pending_call_steal_reply(DBusPendingCall* pending)
 175 {
 176     Q_UNUSED(pending);
 177     bool replyForGetVolume = dbus_message_has_member (m_getVolumeMethodCall, "Get");
 178     DBusMessage* message = dbus_message_new_method_return(m_getVolumeMethodCall);
 179
 180     qDebug() << "replyForGetVolume= " << replyForGetVolume;
 181     qDebug() << "m_volumes.count()= " << m_volumes.count();
 182     if (replyForGetVolume)
 183     {
 184         qDebug() << "Jee";
 185         DBusMessageIter argument_iterator, variant_iterator, array_iterator;
 186         dbus_message_iter_init_append (message, &argument_iterator);
 187         dbus_message_iter_open_container (&argument_iterator,
 188                                           DBUS_TYPE_VARIANT,
 189                                           "a(uu)",
 190                                           &variant_iterator);
 191         dbus_message_iter_open_container (&variant_iterator,
 192                                           DBUS_TYPE_ARRAY,
 193                                           "(uu)",
 194                                           &array_iterator);
 195         if (m_volumes.isEmpty())
 196         {
 197             qDebug() << "Stub is giving an invalid reply";
 198         }
 199         else
 200         {
 201             QMapIterator<uint, uint> i(m_volumes);
 202             i.toBack();
 203             while (i.hasPrevious())
 204             {
 205                 DBusMessageIter iterator;
 206                 dbus_message_iter_open_container (&array_iterator,
 207                                                   DBUS_TYPE_STRUCT,
 208                                                   NULL,
 209                                                   &iterator);
 210                 i.previous();
 211                 dbus_message_iter_append_basic (&iterator, DBUS_TYPE_UINT32, &i.key());
 212                 dbus_message_iter_append_basic (&iterator, DBUS_TYPE_UINT32, &i.value());
 213                 dbus_message_iter_close_container (&array_iterator, &iterator);
 214             }
 215         }
 216         dbus_message_iter_close_container (&variant_iterator, &array_iterator);
 217         dbus_message_iter_close_container (&argument_iterator, &variant_iterator);
 218     }
 219     return message;
 220 }
 221
 222 dbus_uint32_t dbus_message_get_serial(DBusMessage* message)
 223 {
 224     Q_UNUSED(message);
 225     return 1;
 226 }
 227
 228 dbus_bool_t dbus_message_get_args (DBusMessage* message,
 229                                    DBusError* error,
 230                                    int first_arg_type,
 231                                    ...)
 232 {
 233     qDebug() << "dbus_message_get_args";
 234     va_list var_args;
 235     va_start (var_args, first_arg_type);
 236
 237     while (first_arg_type != DBUS_TYPE_INVALID)
 238     {
 239         if (first_arg_type == DBUS_TYPE_OBJECT_PATH)
 240         {
 241             char** str_p;
 242             str_p = va_arg (var_args, char**);
 243             *str_p = obj_path;
 244         }
 245         first_arg_type = va_arg(var_args, int);
 246     }
 247     va_end(var_args);
 248     Q_UNUSED(error);
 249     Q_UNUSED(message);
 250     return true;
 251 }
 252
 253 dbus_bool_t dbus_connection_send( DBusConnection* connection,
 254                                   DBusMessage* message,
 255                                   dbus_uint32_t* serial)
 256 {
 257     Q_UNUSED(connection);
 258     Q_UNUSED(serial);
 259
 260     if (dbus_message_has_member (m_getVolumeMethodCall, "Set"))
 261     {
 262         m_setVolumeMethod = message;
 263     }
 264
 265     return true;
 266 }
 267
 268 void dbus_connection_flush( DBusConnection* connection)
 269 {
 270     Q_UNUSED(connection);
 271 }