void Connection::processIncomingMessage(MessageID messageID, PassOwnPtr<ArgumentDecoder> arguments)
{
// Check if this is a sync reply.
if (messageID == MessageID(CoreIPCMessage::SyncMessageReply)) {
MutexLocker locker(m_syncReplyStateMutex);
ASSERT(!m_pendingSyncReplies.isEmpty());
PendingSyncReply& pendingSyncReply = m_pendingSyncReplies.last();
ASSERT(pendingSyncReply.syncRequestID == arguments->destinationID());
pendingSyncReply.replyDecoder = arguments.leakPtr();
pendingSyncReply.didReceiveReply = true;
m_waitForSyncReplySemaphore.signal();
return;
}
// Check if this is a sync message. If it is, and we're waiting for a sync reply this message
// needs to be dispatched. If we don't we'll end up with a deadlock where both sync message senders are
// stuck waiting for a reply.
if (messageID.isSync()) {
MutexLocker locker(m_syncReplyStateMutex);
if (!m_pendingSyncReplies.isEmpty()) {
m_syncMessagesReceivedWhileWaitingForSyncReply.append(IncomingMessage(messageID, arguments));
// The message has been added, now wake up the client thread.
m_waitForSyncReplySemaphore.signal();
return;
}
}
// Check if we're waiting for this message.
{
MutexLocker locker(m_waitForMessageMutex);
HashMap<std::pair<unsigned, uint64_t>, ArgumentDecoder*>::iterator it = m_waitForMessageMap.find(std::make_pair(messageID.toInt(), arguments->destinationID()));
if (it != m_waitForMessageMap.end()) {
it->second = arguments.leakPtr();
m_waitForMessageCondition.signal();
return;
}
}
MutexLocker locker(m_incomingMessagesLock);
m_incomingMessages.append(IncomingMessage(messageID, arguments));
m_clientRunLoop->scheduleWork(WorkItem::create(this, &Connection::dispatchMessages));
}
void Connection::processIncomingMessage(MessageID messageID, std::auto_ptr<ArgumentDecoder> arguments)
{
// First, check if we're waiting for this message.
{
MutexLocker locker(m_waitForMessageMutex);
HashMap<std::pair<unsigned, uint64_t>, ArgumentDecoder*>::iterator it = m_waitForMessageMap.find(std::make_pair(messageID.toInt(), arguments->destinationID()));
if (it != m_waitForMessageMap.end()) {
it->second = arguments.release();
m_waitForMessageCondition.signal();
return;
}
}
if (messageID == MessageID(CoreIPCMessage::SyncMessageReply)) {
// FIXME: We got a reply for another sync message someone sent, handle this.
ASSERT_NOT_REACHED();
}
MutexLocker locker(m_incomingMessagesLock);
m_incomingMessages.append(IncomingMessage(messageID, arguments));
m_clientRunLoop->scheduleWork(WorkItem::create(this, &Connection::dispatchMessages));
}
void Connection::processIncomingMessage(MessageID messageID, PassOwnPtr<ArgumentDecoder> arguments)
{
// Check if this is a sync reply.
if (messageID == MessageID(CoreIPCMessage::SyncMessageReply)) {
MutexLocker locker(m_pendingSyncRepliesMutex);
ASSERT(!m_pendingSyncReplies.isEmpty());
PendingSyncReply& pendingSyncReply = m_pendingSyncReplies.last();
ASSERT(pendingSyncReply.syncRequestID == arguments->destinationID());
pendingSyncReply.replyDecoder = arguments.leakPtr();
pendingSyncReply.didReceiveReply = true;
m_waitForSyncReplySemaphore.signal();
return;
}
// Check if we're waiting for this message.
{
MutexLocker locker(m_waitForMessageMutex);
HashMap<std::pair<unsigned, uint64_t>, ArgumentDecoder*>::iterator it = m_waitForMessageMap.find(std::make_pair(messageID.toInt(), arguments->destinationID()));
if (it != m_waitForMessageMap.end()) {
it->second = arguments.leakPtr();
m_waitForMessageCondition.signal();
return;
}
}
MutexLocker locker(m_incomingMessagesLock);
m_incomingMessages.append(IncomingMessage(messageID, arguments));
m_clientRunLoop->scheduleWork(WorkItem::create(this, &Connection::dispatchMessages));
}
void QOfonoMessageManager::setModemPath(const QString &path)
{
if (path == d_ptr->modemPath ||
path.isEmpty())
return;
if (path != modemPath()) {
if (d_ptr->messageManager) {
delete d_ptr->messageManager;
d_ptr->messageManager = 0;
d_ptr->properties.clear();
}
d_ptr->messageManager = new OfonoMessageManager("org.ofono", path, QDBusConnection::systemBus(),this);
if (d_ptr->messageManager->isValid()) {
d_ptr->modemPath = path;
connect(d_ptr->messageManager,SIGNAL(PropertyChanged(QString,QDBusVariant)),
this,SLOT(propertyChanged(QString,QDBusVariant)));
connect(d_ptr->messageManager,SIGNAL(ImmediateMessage(QString,QVariantMap)),
this,SIGNAL(immediateMessage(QString,QVariantMap)));
connect(d_ptr->messageManager,SIGNAL(IncomingMessage(QString,QVariantMap)),
this,SIGNAL(incomingMessage(QString,QVariantMap)));
QDBusPendingReply<QVariantMap> reply;
reply = d_ptr->messageManager->GetProperties();
reply.waitForFinished();
d_ptr->properties = reply.value();
QDBusMessage request = QDBusMessage::createMethodCall("org.ofono",
path,
"org.ofono.MessageManager",
"GetMessages");
QDBusConnection::systemBus().callWithCallback(request,
this,
SLOT(getMessagesFinished(ObjectPathPropertiesList)),
SLOT(messagesError(QDBusError)));
}
}
}
