diff options
Diffstat (limited to 'audiomanagerdbusinterface.cpp')
| -rw-r--r-- | audiomanagerdbusinterface.cpp | 635 |
1 files changed, 635 insertions, 0 deletions
diff --git a/audiomanagerdbusinterface.cpp b/audiomanagerdbusinterface.cpp new file mode 100644 index 0000000..96ae120 --- /dev/null +++ b/audiomanagerdbusinterface.cpp @@ -0,0 +1,635 @@ +#include <QTimer> +#include "audiomanagerdbusinterface.h" + +AudioManagerDBusInterface::AudioManagerDBusInterface(QObject* parent, QString serviceName, QString objectPath, QString interfaceName) : + QObject(parent), + mDBusConnection(QDBusConnection::sessionBus()) +{ + initDBusInterface(serviceName, objectPath, interfaceName); + log("AudioManagerDBusInterface created"); + connectInternalSignalToSlot(); + + QTimer::singleShot(0, this, SLOT(callAllDataForInit())); +} + + +AudioManagerDBusInterface::AudioManagerDBusInterface(QObject* parent) : + QObject(parent), + mDBusConnection(QDBusConnection::sessionBus()) +{ + initDBusInterface("org.genivi.audiomanager", "/org/genivi/audiomanager/commandinterface", "org.genivi.audiomanager.commandinterface"); + log("AudioManagerDBusInterface created"); + connectInternalSignalToSlot(); + + QTimer::singleShot(0, this, SLOT(callAllDataForInit())); +} + +void AudioManagerDBusInterface::callAllDataForInit() +{ + qDebug() << "callAllDataForInit"; + getListMainConnections(); + for (int i = 0; i < mMainConnectionTypeList.size(); i++) + emit connectionAdded(mMainConnectionTypeList.at(i)); + + getListMainSinkClasses(); + getListMainSinks(); + getListMainSourceClasses(); + getListMainSources(); + + emit initAMMonitorCompleted(); +} + +void AudioManagerDBusInterface::connectInternalSignalToSlot() +{ + mDBusConnection.connect(mServiceName, mObjectPath, mInterfaceName, "MainConnectionStateChanged", this, SLOT(onMainConnectionStateChanged(ushort,short))); + mDBusConnection.connect(mServiceName,mObjectPath,mInterfaceName,"VolumeChanged",this,SLOT(onVolumeChanged(ushort,short))); + mDBusConnection.connect(mServiceName,mObjectPath,mInterfaceName,"NumberOfMainConnectionsChanged",this,SLOT(onNumberOfMainConnectionsChanged())); +} + +void AudioManagerDBusInterface::onMainConnectionStateChanged(ushort mainConnectionID, short state) +{ + qDebug() << "GET MAIN CONNECTION STATE CHANGED"; + + getListMainConnections(); + + if (state == am::CS_CONNECTED) { + QMap<QString, QVariant> connection; + for (int i = 0; i < mMainConnectionTypeList.size(); i++) { + QVariantMap element = mMainConnectionTypeList.at(i); + if (element["id"] == mainConnectionID) { + connection = element; + connection["state"] = QVariant::fromValue(state); + } + } + + emit connectionAdded(connection); + } else if (state == am::CS_DISCONNECTED) { + QMap<QString, QVariant> connection; + for (int i = 0; i < mMainConnectionTypeList.size(); i++) { + QVariantMap element = mMainConnectionTypeList.at(i); + if (element["id"] == mainConnectionID) { + mMainConnectionTypeList.removeAt(i); + break; + } + } + emit connectionRemoved(mainConnectionID); + } +} + +void AudioManagerDBusInterface::onNumberOfMainConnectionsChanged() +{ + //getListMainConnections(); +} + +void AudioManagerDBusInterface::onVolumeChanged(ushort sinkID, short volume) +{ + qDebug() << "Volume Changed"; + + emit volumeChanged(sinkID, volume); + +// getListMainSinks(); +// getListMainSources(); +} + +void AudioManagerDBusInterface::initDBusInterface(QString serviceName, QString objectPath, QString interfaceName) +{ + mServiceName = serviceName; + mObjectPath = objectPath; + mInterfaceName = interfaceName; + + if (!mDBusConnection.isConnected()) { + mDBusConnection.connectToBus(QDBusConnection::SessionBus, serviceName); + return; + } + + qDBusRegisterMetaType<Availability>(); + qDBusRegisterMetaType<MainConnectionType>(); + qDBusRegisterMetaType<QList<MainConnectionType>>(); + qDBusRegisterMetaType<ClassProperty>(); + qDBusRegisterMetaType<QList<ClassProperty>>(); + qDBusRegisterMetaType<SinkClasses>(); + qDBusRegisterMetaType<QList<SinkClasses>>(); + qDBusRegisterMetaType<SourceClasses>(); + qDBusRegisterMetaType<QList<SourceClasses>>(); + qDBusRegisterMetaType<SinkType>(); + qDBusRegisterMetaType<QList<SinkType>>(); + qDBusRegisterMetaType<SourceType>(); + qDBusRegisterMetaType<QList<SourceType>>(); + qDBusRegisterMetaType<SoundProperty>(); + qDBusRegisterMetaType<QList<SoundProperty>>(); +} + +void AudioManagerDBusInterface::log(QString message) +{ + /* + mTempLogFile = fopen("/tmp/tempQTLog","a"); + fprintf(mTempLogFile,"%s\n", message.toUtf8().constData()); + fclose(mTempLogFile); + */ + qDebug() << message; +} + +ushort AudioManagerDBusInterface::getSourceIDFromName(QString name) +{ + for (int i = 0; i < mMainSourceList.size(); i++) { + QVariantMap item = mMainSourceList.at(i); + if(item["name"] == name) + return (ushort)item["id"].toInt(); + } + return 0; +} + +ushort AudioManagerDBusInterface::getSinkIDFromName(QString name) +{ + for (int i = 0; i < mMainSinkList.size(); i++) { + QVariantMap item = mMainSinkList.at(i); + if(item["name"] == name) + return (ushort)item["id"].toInt(); + } + return 0; +} + +void AudioManagerDBusInterface::connectToSignal(QString signalName, QObject *receiver, const char* slot) +{ + mDBusConnection.connect(mServiceName,mObjectPath,mInterfaceName,signalName, receiver,slot); +} + +void AudioManagerDBusInterface::disconnectToSignal(QString signalName, QObject* receiver, const char* slot) +{ + mDBusConnection.disconnect(mServiceName, mObjectPath, mInterfaceName, signalName, receiver, slot); +} + +QDBusMessage AudioManagerDBusInterface::getDBusMessage(QString command) +{ + return QDBusMessage::createMethodCall(mServiceName, mObjectPath, mInterfaceName,command); +} + +ushort AudioManagerDBusInterface::connect(QString sourceName, QString sinkName) +{ + QDBusMessage message = getDBusMessage("Connect"); + ushort sourceID = getSourceIDFromName(sourceName); + ushort sinkID = getSinkIDFromName(sinkName); + + message << QVariant::fromValue(sourceID); + message << QVariant::fromValue(sinkID); + + qDebug() << "====="; + qDebug() << "source " << sourceName << sourceID; + qDebug() << "sink " << sinkName << sinkID; + qDebug() << "====="; + + QDBusMessage result = mDBusConnection.call(message); + if(result.type() == QDBusMessage::ReplyMessage) { + qDebug() << result.arguments(); + return (ushort)result.arguments().at(1).toInt(); + } + qDebug() << result.errorMessage(); + return 0; +} + +bool AudioManagerDBusInterface::setVolume(QString sinkName, short value) +{ + QDBusMessage message = getDBusMessage("SetVolume"); + ushort sinkID = getSinkIDFromName(sinkName); + if (sinkID == 0) + return false; + message << QVariant::fromValue(sinkID); + message << QVariant::fromValue(value); + QDBusMessage result = mDBusConnection.call(message); + + if (result.type() != QDBusMessage::ReplyMessage) { + qDebug() << "Error occured in setVolume()"; + return false; + } + + mLastError = result.arguments().takeFirst().toInt(); + + if (mLastError == am::am_Error_e::E_OK) + return true; + else + return false; +} + +bool AudioManagerDBusInterface::disconnect(ushort connectionID) +{ + QDBusMessage message = getDBusMessage("Disconnect"); + message << QVariant::fromValue(connectionID); + QDBusMessage result = mDBusConnection.call(message); + if(result.type() == QDBusMessage::ReplyMessage) + return true; + return false; +} + +bool AudioManagerDBusInterface::getListMainConnections() +{ + QDBusMessage message = getDBusMessage("GetListMainConnections"); + QDBusMessage ret = mDBusConnection.call(message); + if (ret.type() != QDBusMessage::ReplyMessage) { + qDebug() << "DBus Error occured in getListMainConenctions"; + return false; + } + + QList<QVariant> result = ret.arguments(); + mLastError = result.takeFirst().toInt(); + QDBusMessage retMessage; + retMessage.setArguments(result); + + if (mLastError == am::am_Error_e::E_OK) { + QDBusReply<QList<MainConnectionType>> reply(retMessage); + + QList<MainConnectionType> connectionList = reply.value(); + mMainConnectionTypeList.clear(); + + for (int i = 0; i < connectionList.size(); i++) { + MainConnectionType info = connectionList[i]; + QMap<QString, QVariant> connection; + connection["id"] = QVariant::fromValue(info.mainConnectionID); + connection["sourceId"] = QVariant::fromValue(info.sourceID); + connection["sinkId"] = QVariant::fromValue(info.sinkID); + connection["state"] = QVariant::fromValue(info.connectionState); + + mMainConnectionTypeList << connection; + } + } else { + return false; + } + + return true; +} + +bool AudioManagerDBusInterface::getListMainSinks() +{ + + QDBusMessage message = getDBusMessage("GetListMainSinks"); + QDBusMessage ret = mDBusConnection.call(message); + + if (ret.type() != QDBusMessage::ReplyMessage) { + qDebug() << "DBus Error occured in getListMainConenctions"; + return false; + } + + QList<QVariant> result = ret.arguments(); + mLastError = result.takeFirst().toInt(); + QDBusMessage retMessage; + retMessage.setArguments(result); + + qDebug() << "REPLY MESSAGE SIZE : " + QString::number(ret.arguments().size()); + + if (mLastError == am::am_Error_e::E_OK) { + QDBusReply<QList<SinkType>> reply(retMessage); + + QList<SinkType> sinkList = reply.value(); + mMainSinkList.clear(); + + for (int i = 0; i < sinkList.size(); i++) { + SinkType info = sinkList[i]; + QMap<QString, QVariant> element; + element["name"] = info.name; + element["volume"] = info.volume; + element["id"] = info.sinkID; + element["muteState"] = info.muteState; + emit sinkAdded(element); + mMainSinkList << element; + } + } else { + return false; + } + + return true; +} + +bool AudioManagerDBusInterface::getListMainSources() +{ + + QDBusMessage message = getDBusMessage("GetListMainSources"); + QDBusMessage ret = mDBusConnection.call(message); + + if (ret.type() != QDBusMessage::ReplyMessage) { + qDebug() << "DBus Error occured in getListMainConenctions"; + return false; + } + QList<QVariant> result = ret.arguments(); + mLastError = result.takeFirst().toInt(); + QDBusMessage retMessage; + retMessage.setArguments(result); + + if (mLastError == am::am_Error_e::E_OK) { + QDBusReply<QList<SourceType>> reply(retMessage); + + QList<SourceType> sourceList = reply.value(); + mMainSourceList.clear(); + + for (int i = 0; i < sourceList.size(); i++) { + SourceType info = sourceList[i]; + QMap<QString, QVariant> element; + element["name"] = info.name; + element["id"] = info.sourceID; + mMainSourceList << element; + emit sourceAdded(element); + } + } else { + return false; + } + return true; +} + +bool AudioManagerDBusInterface::getListMainSourceClasses() +{ + mMainSourceClassList.clear(); + + QDBusMessage message = getDBusMessage("GetListSourceClasses"); + QDBusMessage ret = mDBusConnection.call(message); + + if (ret.type() != QDBusMessage::ReplyMessage) { + qDebug() << "Error occured in getListMainSourceClasses"; + return false; + } + + QList<QVariant> result = ret.arguments(); + mLastError = result.takeFirst().toInt(); + QDBusMessage retMessage; + retMessage.setArguments(result); + + if (mLastError == am::am_Error_e::E_OK) { + QDBusReply<QList<SourceClasses>> reply(retMessage); + mMainSourceClassList = reply.value(); + log(QString("CLASS SOURCE RECEIVE SUCCESS : ") + QString::number(mMainSourceClassList.size())); + + for (int i = 0; i < mMainSourceClassList.size(); i++) { + log(QString("SOURCE CLASSES : ") + mMainSourceClassList.at(i).name); + } + } else { + return false; + } + + return true; +} + +bool AudioManagerDBusInterface::getListMainSinkClasses() +{ + mMainSinkClassList.clear(); + + QDBusMessage message = getDBusMessage("GetListSinkClasses"); + QDBusMessage ret = mDBusConnection.call(message); + if (ret.type() != QDBusMessage::ReplyMessage) { + qDebug() << "Error occured in getListMainSinkClasses()"; + return false; + } + + QList<QVariant> result = ret.arguments(); + mLastError = result.takeFirst().toInt(); + QDBusMessage retMessage; + retMessage.setArguments(result); + + if (mLastError == am::am_Error_e::E_OK) { + QDBusReply<QList<SinkClasses>> reply(retMessage); + mMainSinkClassList = reply.value(); + + qDebug() << QString("CLASS SINK RECEIVE SUCCESS : ") + QString::number(mMainSinkClassList.size()); + for (int i = 0; i < mMainSinkClassList.size(); i++) { + + qDebug() << QString("SINK CLASSES : ") << mMainSinkClassList.at(i).name; + } + } else { + return false; + } + + return true; +} + +bool AudioManagerDBusInterface::getListSystemProperties() +{ + mSystemPropList.clear(); + + QDBusMessage message = getDBusMessage("GetListSystemProperties"); + QDBusMessage ret = mDBusConnection.call(message); + + if (ret.type() != QDBusMessage::ReplyMessage) { + qDebug() << "Error occured in getListSystemProperties()"; + return false; + } + + QList<QVariant> result = ret.arguments(); + mLastError = result.takeFirst().toInt(); + QDBusMessage retMessage; + retMessage.setArguments(result); + + if (mLastError == am::am_Error_e::E_OK) { + QDBusReply<QList<SystemProperty>> reply(retMessage); + + mSystemPropList = reply.value(); + qDebug() << QString("GET SYSTEM PROPERTY LIST SUCCESS ") << mSystemPropList.size(); + + for (int i = 0; i < mSystemPropList.size(); i++) { + qDebug() << QString("System Prop :[") + QString::number(mSystemPropList.at(i).type) + " , " + QString::number(mSystemPropList.at(i).value); + } + + } else { + return false; + } + + return true; +} + + + +QList<SinkClasses> AudioManagerDBusInterface::getMainSinkClassesList() +{ + return mMainSinkClassList; +} + +QList<SourceClasses> AudioManagerDBusInterface::getMainSourceClassesList() +{ + return mMainSourceClassList; +} + +QString AudioManagerDBusInterface::getConnectionResultString(short connectionState) +{ + switch(connectionState) { + case am::CS_CONNECTED: + return "Connected"; + case am::CS_CONNECTING: + return "Connecting"; + case am::CS_DISCONNECTED: + return "Disconnected"; + case am::CS_DISCONNECTING: + return "Disconnecting"; + case am::CS_MAX: + return "Connection MAX"; + case am::CS_SUSPENDED: + return "Suspended"; + default: + return "Unknown"; + } + + return "Unknown"; // Maybe not reached +} + +QDBusArgument &operator << (QDBusArgument &dest, const Availability &source) +{ + dest.beginStructure(); + dest << source.available + << source.reason; + dest.endStructure(); + return dest; +} + +const QDBusArgument &operator>>(const QDBusArgument &argument, Availability &theStruct) +{ + argument.beginStructure(); + argument >> theStruct.available + >> theStruct.reason; + argument.endStructure(); + return argument; +} + +QDBusArgument &operator << (QDBusArgument& dest, const MainConnectionType& source) +{ + dest.beginStructure(); + dest << source.mainConnectionID + << source.sourceID + << source.sinkID + << source.delay + << source.connectionState; + dest.endStructure(); + return dest; +} +const QDBusArgument &operator >> (const QDBusArgument& source, MainConnectionType& dest) +{ + source.beginStructure(); + source >> dest.mainConnectionID + >> dest.sourceID + >> dest.sinkID + >> dest.delay + >> dest.connectionState; + source.endStructure(); + return source; +} + +QDBusArgument &operator << (QDBusArgument& dest, const SoundProperty& source) +{ + dest.beginStructure(); + dest << source.type + << source.value; + dest.endStructure(); + return dest; +} + +const QDBusArgument &operator >> (const QDBusArgument& source, SoundProperty& dest) +{ + source.beginStructure(); + source >> dest.type + >> dest.value; + source.endStructure(); + return source; +} + + +QDBusArgument &operator << (QDBusArgument& dest, const SourceClasses& source) +{ + dest.beginStructure(); + dest << source.sourceClassID + << source.name + << source.listClassProperties; + dest.endStructure(); + return dest; +} + +const QDBusArgument &operator >> (const QDBusArgument& source, SourceClasses& dest) +{ + source.beginStructure(); + source >> dest.sourceClassID + >> dest.name + >> dest.listClassProperties; + source.endStructure(); + return source; +} + +QDBusArgument &operator << (QDBusArgument& dest, const SinkClasses& source) +{ + dest.beginStructure(); + dest << source.sinkClassID + << source.name + << source.listClassProperties; + dest.endStructure(); + return dest; +} + +const QDBusArgument &operator >> (const QDBusArgument& source, SinkClasses& dest) +{ + source.beginStructure(); + source >> dest.sinkClassID + >> dest.name + >> dest.listClassProperties; + source.endStructure(); + return source; +} + +QDBusArgument &operator << (QDBusArgument& dest, const ClassProperty& source) +{ + dest.beginStructure(); + dest << source.classProperty + << source.value; + dest.endStructure(); + return dest; +} + +const QDBusArgument &operator >> (const QDBusArgument& source, ClassProperty& dest) +{ + source.beginStructure(); + source >> dest.classProperty + >> dest.value; + source.endStructure(); + return source; +} + + +QDBusArgument &operator << (QDBusArgument& dest, const SinkType& source) +{ + dest.beginStructure(); + dest << source.sinkID + << source.name + << source.availability + << source.volume + << source.muteState + << source.sinkClassID; + dest.endStructure(); + return dest; +} + +const QDBusArgument &operator >> (const QDBusArgument& source, SinkType& dest) +{ + source.beginStructure(); + source >> dest.sinkID + >> dest.name + >> dest.availability + >> dest.volume + >> dest.muteState + >> dest.sinkClassID; + source.endStructure(); + return source; +} + +QDBusArgument &operator << (QDBusArgument& dest, const SourceType& source) +{ + dest.beginStructure(); + dest << source.sourceID + << source.name + << source.availability + << source.sourceClassID; + dest.endStructure(); + + return dest; +} + +const QDBusArgument &operator >> (const QDBusArgument& source, SourceType& dest) +{ + source.beginStructure(); + source >> dest.sourceID + >> dest.name + >> dest.availability + >> dest.sourceClassID; + source.endStructure(); + + return source; +} |