diff options
Diffstat (limited to 'TelepathyQt/contact-messenger.cpp')
| -rw-r--r-- | TelepathyQt/contact-messenger.cpp | 257 |
1 files changed, 257 insertions, 0 deletions
diff --git a/TelepathyQt/contact-messenger.cpp b/TelepathyQt/contact-messenger.cpp new file mode 100644 index 00000000..fdb5608c --- /dev/null +++ b/TelepathyQt/contact-messenger.cpp @@ -0,0 +1,257 @@ +/** + * This file is part of TelepathyQt + * + * @copyright Copyright (C) 2011 Collabora Ltd. <http://www.collabora.co.uk/> + * @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 <TelepathyQt/ContactMessenger> + +#include "TelepathyQt/_gen/contact-messenger.moc.hpp" + +#include "TelepathyQt/debug-internal.h" + +#include "TelepathyQt/future-internal.h" + +#include <TelepathyQt/Account> +#include <TelepathyQt/ChannelDispatcher> +#include <TelepathyQt/ClientRegistrar> +#include <TelepathyQt/MessageContentPartList> +#include <TelepathyQt/PendingSendMessage> +#include <TelepathyQt/SimpleTextObserver> +#include <TelepathyQt/TextChannel> + +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<QMap<QString, QDBusVariant> >(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 <TelepathyQt/ContactMessenger> + * + * \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<TextChannelPtr> 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 |