← Back to branch summary

~ubuntu-branches/ubuntu/trusty/telephony-service/trusty

« back to all changes in this revision

Viewing changes to handler/texthandler.cpp

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release, Tiago Salem Herrmann
  • Date: 2014-02-17 13:44:49 UTC
  • mfrom: (1.1.15)
  • Revision ID: package-import@ubuntu.com-20140217134449-t9y4av0f5f6dk4w1
Tags: 0.1+14.04.20140217.1-0ubuntu1
[ Tiago Salem Herrmann ]
Add group chat support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
handler/texthandler.cpp
27
27
#include <TelepathyQt/ContactManager>
28
28
#include <TelepathyQt/PendingContacts>
29
29
 
 
30
template<> bool qMapLessThanKey<QStringList>(const QStringList &key1, const QStringList &key2) 
 
31
{ 
 
32
    return key1.size() > key2.size();  // sort by operator> !
 
33
}
 
34
 
30
35
TextHandler::TextHandler(QObject *parent)
31
36
: QObject(parent)
32
37
{
43
48
    }
44
49
 
45
50
    // create text channels to send the pending messages
46
 
    Q_FOREACH(const QString &number, mPendingMessages.keys()) {
47
 
        startChat(number);
 
51
    Q_FOREACH(const QStringList& phoneNumbers, mPendingMessages.keys()) {
 
52
        startChat(phoneNumbers);
48
53
    }
49
54
}
50
55
 
54
59
    return handler;
55
60
}
56
61
 
57
 
void TextHandler::startChat(const QString &phoneNumber)
 
62
void TextHandler::startChat(const QStringList &phoneNumbers)
58
63
{
59
64
    // Request the contact to start chatting to
60
65
    Tp::AccountPtr account = TelepathyHelper::instance()->account();
61
 
    connect(account->connection()->contactManager()->contactsForIdentifiers(QStringList() << phoneNumber),
 
66
    connect(account->connection()->contactManager()->contactsForIdentifiers(phoneNumbers),
62
67
            SIGNAL(finished(Tp::PendingOperation*)),
63
68
            SLOT(onContactsAvailable(Tp::PendingOperation*)));
64
69
}
65
70
 
66
 
void TextHandler::sendMessage(const QString &phoneNumber, const QString &message)
 
71
void TextHandler::startChat(const Tp::Contacts &contacts)
 
72
{
 
73
    Tp::AccountPtr account = TelepathyHelper::instance()->account();
 
74
 
 
75
    if (contacts.size() == 1) {
 
76
        account->ensureTextChat(contacts.values()[0], QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
 
77
    } else {
 
78
        account->createConferenceTextChat(QList<Tp::ChannelPtr>(), contacts.toList(), QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
 
79
    }
 
80
    // start chatting to the contacts
 
81
    Q_FOREACH(Tp::ContactPtr contact, contacts) {
 
82
        // hold the ContactPtr to make sure its refcounting stays bigger than 0
 
83
        mContacts[contact->id()] = contact;
 
84
    }
 
85
}
 
86
 
 
87
void TextHandler::sendMessage(const QStringList &phoneNumbers, const QString &message)
67
88
{
68
89
    if (!TelepathyHelper::instance()->connected()) {
69
 
        mPendingMessages[phoneNumber].append(message);
 
90
        mPendingMessages[phoneNumbers].append(message);
70
91
        return;
71
92
    }
72
93
 
73
 
    Tp::TextChannelPtr channel = existingChat(phoneNumber);
 
94
    Tp::TextChannelPtr channel = existingChat(phoneNumbers);
74
95
    if (channel.isNull()) {
75
 
        mPendingMessages[phoneNumber].append(message);
76
 
        startChat(phoneNumber);
 
96
        mPendingMessages[phoneNumbers].append(message);
 
97
        startChat(phoneNumbers);
77
98
        return;
78
99
    }
79
100
 
82
103
            SLOT(onMessageSent(Tp::PendingOperation*)));
83
104
}
84
105
 
85
 
void TextHandler::acknowledgeMessages(const QString &phoneNumber, const QStringList &messageIds)
 
106
void TextHandler::acknowledgeMessages(const QStringList &phoneNumbers, const QStringList &messageIds)
86
107
{
87
 
    Tp::TextChannelPtr channel = existingChat(phoneNumber);
 
108
    Tp::TextChannelPtr channel = existingChat(phoneNumbers);
88
109
    if (channel.isNull()) {
89
110
        return;
90
111
    }
101
122
 
102
123
void TextHandler::onTextChannelAvailable(Tp::TextChannelPtr channel)
103
124
{
104
 
    QString id = channel->targetContact()->id();
105
 
    mChannels[id] = channel;
 
125
    mChannels.append(channel);
106
126
 
107
127
    // check for pending messages for this channel
108
 
    QMap<QString, QStringList>::iterator it = mPendingMessages.begin();
109
 
    while (it != mPendingMessages.end()) {
110
 
        if (PhoneUtils::comparePhoneNumbers(it.key(), id)) {
111
 
            Q_FOREACH(const QString &message, it.value()) {
112
 
                connect(channel->send(message),
113
 
                        SIGNAL(finished(Tp::PendingOperation*)),
114
 
                        SLOT(onMessageSent(Tp::PendingOperation*)));
 
128
    Q_FOREACH(const Tp::TextChannelPtr &channel, mChannels) {
 
129
        QMap<QStringList, QStringList>::iterator it = mPendingMessages.begin();
 
130
        while (it != mPendingMessages.end()) {
 
131
            if (existingChat(it.key()) == channel) {
 
132
                Q_FOREACH(const QString &message, it.value()) {
 
133
                    connect(channel->send(message),
 
134
                            SIGNAL(finished(Tp::PendingOperation*)),
 
135
                            SLOT(onMessageSent(Tp::PendingOperation*)));
 
136
                }
 
137
                it = mPendingMessages.erase(it);
 
138
            } else {
 
139
                ++it;
115
140
            }
116
 
            it = mPendingMessages.erase(it);
117
 
        } else {
118
 
            ++it;
119
141
        }
120
142
    }
121
143
}
134
156
    }
135
157
}
136
158
 
137
 
Tp::TextChannelPtr TextHandler::existingChat(const QString &phoneNumber)
 
159
Tp::TextChannelPtr TextHandler::existingChat(const QStringList &phoneNumbers)
138
160
{
139
161
    Tp::TextChannelPtr channel;
140
 
    QMap<QString, Tp::TextChannelPtr>::iterator it = mChannels.begin();
141
 
    while (it != mChannels.end()) {
142
 
        if (PhoneUtils::comparePhoneNumbers(it.key(), phoneNumber)) {
143
 
            channel = it.value();
144
 
            break;
145
 
        }
146
 
        ++it;
 
162
 
 
163
    Q_FOREACH(const Tp::TextChannelPtr &channel, mChannels) {
 
164
        int count = 0;
 
165
        if (channel->groupContacts(false).size() != phoneNumbers.size()) {
 
166
            continue;
 
167
        }
 
168
        Q_FOREACH(const QString &phoneNumberNew, phoneNumbers) {
 
169
            Q_FOREACH(const Tp::ContactPtr &phoneNumberOld, channel->groupContacts(false)) {
 
170
                if (PhoneUtils::comparePhoneNumbers(phoneNumberOld->id(), phoneNumberNew)) {
 
171
                    count++;
 
172
                }
 
173
            }
 
174
        }
 
175
        if (count == phoneNumbers.size()) {
 
176
            return channel;
 
177
        }
147
178
    }
148
 
 
149
179
    return channel;
150
180
}
151
181
 
157
187
        qCritical() << "The pending object is not a Tp::PendingContacts";
158
188
        return;
159
189
    }
160
 
 
161
 
    Tp::AccountPtr account = TelepathyHelper::instance()->account();
162
 
 
163
 
    // start chatting to the contacts
164
 
    Q_FOREACH(Tp::ContactPtr contact, pc->contacts()) {
165
 
        account->ensureTextChat(contact, QDateTime::currentDateTime(), TP_QT_IFACE_CLIENT + ".TelephonyServiceHandler");
166
 
 
167
 
        // hold the ContactPtr to make sure its refcounting stays bigger than 0
168
 
        mContacts[contact->id()] = contact;
169
 
    }
 
190
    startChat(pc->contacts().toSet());
170
191
}
 
192
 
 
193