/**
* This file is part of TelepathyQt
*
* @copyright Copyright (C) 2011 Collabora Ltd.
* @copyright Copyright (C) 2011 Nokia Corporation
* @license LGPL 2.1
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include
#include "TelepathyQt/_gen/contact-messenger.moc.hpp"
#include "TelepathyQt/debug-internal.h"
#include "TelepathyQt/future-internal.h"
#include
#include
#include
#include
#include
#include
#include
namespace Tp
{
struct TP_QT_NO_EXPORT ContactMessenger::Private
{
Private(ContactMessenger *parent, const AccountPtr &account, const QString &contactIdentifier)
: parent(parent),
account(account),
contactIdentifier(contactIdentifier),
cdMessagesInterface(0)
{
}
PendingSendMessage *sendMessage(const Message &message, MessageSendingFlags flags);
ContactMessenger *parent;
AccountPtr account;
QString contactIdentifier;
SimpleTextObserverPtr observer;
TpFuture::Client::ChannelDispatcherInterfaceMessagesInterface *cdMessagesInterface;
};
PendingSendMessage *ContactMessenger::Private::sendMessage(const Message &message,
MessageSendingFlags flags)
{
if (!cdMessagesInterface) {
cdMessagesInterface = new TpFuture::Client::ChannelDispatcherInterfaceMessagesInterface(
account->dbusConnection(),
TP_QT_CHANNEL_DISPATCHER_BUS_NAME, TP_QT_CHANNEL_DISPATCHER_OBJECT_PATH, parent);
}
PendingSendMessage *op = new PendingSendMessage(ContactMessengerPtr(parent), message);
// TODO: is there a way to avoid this? Ideally TpFuture classes should use Tp types.
TpFuture::MessagePartList parts;
foreach (const Tp::MessagePart &part, message.parts()) {
parts << static_cast >(part);
}
connect(new QDBusPendingCallWatcher(
cdMessagesInterface->SendMessage(QDBusObjectPath(account->objectPath()),
contactIdentifier, parts, (uint) flags)),
SIGNAL(finished(QDBusPendingCallWatcher*)),
op,
SLOT(onCDMessageSent(QDBusPendingCallWatcher*)));
return op;
}
/**
* \class ContactMessenger
* \ingroup clientaccount
* \headerfile TelepathyQt/contact-messenger.h
*
* \brief The ContactMessenger class provides an easy way to send text messages to a contact
* and also track sent/receive text messages from the same contact.
*/
/**
* Create a new ContactMessenger object.
*
* \param account The account this messenger is communicating with.
* \param contact The contact this messenger is communicating with.
* \return An ContactMessengerPtr object pointing to the newly created ContactMessenger object,
* or a null ContactMessengerPtr if \a contact is null.
*/
ContactMessengerPtr ContactMessenger::create(const AccountPtr &account,
const ContactPtr &contact)
{
if (!contact) {
warning() << "Contact used to create a ContactMessenger object must be "
"valid";
return ContactMessengerPtr();
}
return ContactMessengerPtr(new ContactMessenger(account, contact->id()));
}
/**
* Create a new ContactMessenger object.
*
* \param account The account this messenger is communicating with.
* \param contactIdentifier The identifier of the contact this messenger is communicating with.
* \return An ContactMessengerPtr object pointing to the newly created ContactMessenger object,
* or a null ContactMessengerPtr if \a contact is null.
*/
ContactMessengerPtr ContactMessenger::create(const AccountPtr &account,
const QString &contactIdentifier)
{
if (contactIdentifier.isEmpty()) {
warning() << "Contact identifier used to create a ContactMessenger object must be "
"non-empty";
return ContactMessengerPtr();
}
return ContactMessengerPtr(new ContactMessenger(account, contactIdentifier));
}
/**
* Construct a new ContactMessenger object.
*
* \param account The account this messenger is communicating with.
* \param contactIdentifier The identifier of the contact this messenger is communicating with.
*/
ContactMessenger::ContactMessenger(const AccountPtr &account, const QString &contactIdentifier)
: mPriv(new Private(this, account, contactIdentifier))
{
mPriv->observer = SimpleTextObserver::create(account, contactIdentifier);
connect(mPriv->observer.data(),
SIGNAL(messageSent(Tp::Message,Tp::MessageSendingFlags,QString,Tp::TextChannelPtr)),
SIGNAL(messageSent(Tp::Message,Tp::MessageSendingFlags,QString,Tp::TextChannelPtr)));
connect(mPriv->observer.data(),
SIGNAL(messageReceived(Tp::ReceivedMessage,Tp::TextChannelPtr)),
SIGNAL(messageReceived(Tp::ReceivedMessage,Tp::TextChannelPtr)));
}
/**
* Class destructor.
*/
ContactMessenger::~ContactMessenger()
{
delete mPriv;
}
/**
* Return the account this messenger is communicating with.
*
* \return A pointer to the Account object.
*/
AccountPtr ContactMessenger::account() const
{
return mPriv->account;
}
/**
* Return the identifier of the contact this messenger is communicating with.
*
* \return The identifier of the contact.
*/
QString ContactMessenger::contactIdentifier() const
{
return mPriv->contactIdentifier;
}
/**
* Return the list of text chats currently being observed.
*
* \return A list of pointers to TextChannel objects.
*/
QList ContactMessenger::textChats() const
{
return mPriv->observer->textChats();
}
/**
* Send a message to the contact identified by contactIdentifier() using account().
*
* Note that the return from this method isn't ordered in any sane way, meaning that
* messageSent() can be signalled either before or after the returned PendingSendMessage object
* finishes.
*
* \param text The message text.
* \param type The message type.
* \param flags The message flags.
* \return A PendingSendMessage which will emit PendingSendMessage::finished
* once the reply is received and that can be used to check whether sending the
* message succeeded or not.
*/
PendingSendMessage *ContactMessenger::sendMessage(const QString &text,
ChannelTextMessageType type,
MessageSendingFlags flags)
{
Message message(type, text);
return mPriv->sendMessage(message, flags);
}
/**
* Send a message to the contact identified by contactIdentifier() using account().
*
* Note that the return from this method isn't ordered in any sane way, meaning that
* messageSent() can be signalled either before or after the returned PendingSendMessage object
* finishes.
*
* \param parts The message parts.
* \param flags The message flags.
* \return A PendingSendMessage which will emit PendingSendMessage::finished
* once the reply is received and that can be used to check whether sending the
* message succeeded or not.
*/
PendingSendMessage *ContactMessenger::sendMessage(const MessageContentPartList &parts,
MessageSendingFlags flags)
{
Message message(parts.bareParts());
return mPriv->sendMessage(message, flags);
}
/**
* \fn void ContactMessenger::messageSent(const Tp::Message &message,
* Tp::MessageSendingFlags flags, const QString &sentMessageToken,
* const Tp::TextChannelPtr &channel);
*
* Emitted whenever a text message on account() is sent to the contact
* identified by contactIdentifier().
*
* \param message The message sent.
* \param flags The flags of the message that was sent.
* \param sentMessageToken The token of the message that was sent.
* \param channel The channel from which the message was sent.
*/
/**
* \fn void ContactMessenger::messageReceived(const Tp::ReceivedMessage &message,
* const Tp::TextChannelPtr &channel);
*
* Emitted whenever a text message on account() is received from the contact
* identified by contactIdentifier().
*
* \param message The message received.
* \param channel The channel from which the message was received.
*/
} // Tp