Merge lp:~boiko/telephony-service/history_messaging_menu into lp:telephony-service

[Gustavo Pichorim Boiko]

Use the history service to populate the messaging menu.

Use the history service to populate the messaging menu.

[lp:~boiko/telephony-service/history_messaging_menu]

760. By Gustavo Pichorim Boiko on 2013-12-11

Merge latest changes from trunk.

Unmerged revisions

760. By Gustavo Pichorim Boiko on 2013-12-11

Merge latest changes from trunk.

759. By Gustavo Pichorim Boiko on 2013-10-30

Start implementing the messaging menu populating using the history service.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-10-09 21:59:42 +0000
+++ CMakeLists.txt	2013-12-11 13:06:39 +0000
@@ -61,6 +61,7 @@
 pkg_check_modules(MESSAGING_MENU REQUIRED messaging-menu)
 pkg_check_modules(GSETTINGS REQUIRED gsettings-qt)
 pkg_check_modules(UserMetrics REQUIRED libusermetricsinput-1)
+pkg_check_modules(HISTORY REQUIRED history-service)
 
 add_definitions(-DQT_NO_KEYWORDS)
 

=== modified file 'indicator/CMakeLists.txt'
--- indicator/CMakeLists.txt	2013-09-25 21:18:46 +0000
+++ indicator/CMakeLists.txt	2013-12-11 13:06:39 +0000
@@ -1,9 +1,10 @@
 
 set(qt_SRCS
     callchannelobserver.cpp
+    historyloader.cpp
     messagingmenu.cpp
     metrics.cpp
-    textchannelobserver.cpp
+    notifications.cpp
     voicemailindicator.cpp
     )
 
@@ -17,6 +18,7 @@
     ${CMAKE_SOURCE_DIR}/libtelephonyservice
     ${CMAKE_CURRENT_BINARY_DIR}
     ${UserMetrics_INCLUDE_DIRS}
+    ${HISTORY_INCLUDE_DIRS}
     )
 
 link_directories(${MESSAGING_MENU_LIBRARY_DIRS})
@@ -30,6 +32,7 @@
     ${MESSAGING_MENU_LIBRARIES}
     ${GSETTINGS_LIBRARIES}
     ${UserMetrics_LIBRARIES}
+    ${HISTORY_LIBRARIES}
     telephonyservice
     )
 

=== added file 'indicator/historyloader.cpp'
--- indicator/historyloader.cpp	1970-01-01 00:00:00 +0000
+++ indicator/historyloader.cpp	2013-12-11 13:06:39 +0000
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "historyloader.h"
+#include "messagingmenu.h"
+#include "metrics.h"
+#include "notifications.h"
+#include <History/EventView>
+#include <History/IntersectionFilter>
+#include <History/Manager>
+#include <History/TextEvent>
+#include <History/VoiceEvent>
+
+HistoryLoader::HistoryLoader(QObject *parent) :
+    QObject(parent)
+{
+    loadMessages();
+    loadCalls();
+}
+
+HistoryLoader *HistoryLoader::instance()
+{
+    static HistoryLoader *self = new HistoryLoader();
+    return self;
+}
+
+void HistoryLoader::loadMessages()
+{
+    if (!mTextEventView.isNull()) {
+        mTextEventView->deleteLater();
+    }
+
+    if (!mSentTextEventView.isNull()) {
+        mSentTextEventView->deleteLater();
+    }
+
+    History::IntersectionFilter filter;
+    // FIXME: maybe we should not hardcode the accountId?
+    filter.append(History::Filter(History::FieldAccountId, "ofono/ofono/account0"));
+    filter.append(History::Filter(History::FieldNewEvent, true));
+
+    mTextEventView = History::Manager::instance()->queryEvents(History::EventTypeText, History::Sort(), filter);
+    connect(mTextEventView.data(),
+            SIGNAL(eventsAdded(History::Events)),
+            SLOT(onTextEventsAdded(History::Events)));
+    connect(mTextEventView.data(),
+            SIGNAL(eventsModified(History::Events)),
+            SLOT(onTextEventsModified(History::Events)));
+    connect(mTextEventView.data(),
+            SIGNAL(eventsRemoved(History::Events)),
+            SLOT(onTextEventsRemoved(History::Events)));
+    connect(mTextEventView.data(),
+            SIGNAL(invalidated()),
+            SLOT(loadMessages()));
+
+    History::Events events = mTextEventView->nextPage();
+    while (!events.isEmpty()) {
+        // add the events to the messaging menu
+        Q_FOREACH(const History::Event &event, events) {
+            History::TextEvent textEvent(event);
+
+            // add the message to the messaging menu (use hex format to avoid invalid characters)
+            QByteArray token(textEvent.eventId().toUtf8());
+            MessagingMenu::instance()->addMessage(textEvent.senderId(), token.toHex(), textEvent.timestamp(), textEvent.message());
+        }
+        events = mTextEventView->nextPage();
+    }
+
+    // create a view just to get signals of sent messages
+    filter.clear();
+    filter.append(History::Filter(History::FieldAccountId, "ofono/ofono/account0"));
+    filter.append(History::Filter(History::FieldSenderId, "self"));
+    mSentTextEventView = History::Manager::instance()->queryEvents(History::EventTypeText, History::Sort(), filter);
+    connect(mSentTextEventView.data(),
+            SIGNAL(eventsAdded(History::Events)),
+            SLOT(onTextEventsSent(History::Events)));
+    connect(mSentTextEventView.data(),
+            SIGNAL(invalidated()),
+            SLOT(loadMessages()));
+}
+
+void HistoryLoader::loadCalls()
+{
+    if (!mVoiceEventView.isNull()) {
+        mVoiceEventView->deleteLater();
+    }
+
+    History::IntersectionFilter filter;
+    // FIXME: maybe we should not hardcode the accountId?
+    filter.append(History::Filter(History::FieldAccountId, "ofono/ofono/account0"));
+    filter.append(History::Filter(History::FieldNewEvent, true));
+    filter.append(History::Filter(History::FieldMissed, true));
+    mVoiceEventView = History::Manager::instance()->queryEvents(History::EventTypeVoice, History::Sort(), filter);
+    connect(mVoiceEventView.data(),
+            SIGNAL(eventsAdded(History::Events)),
+            SLOT(onVoiceEventsAdded(History::Events)));
+    connect(mVoiceEventView.data(),
+            SIGNAL(invalidated()),
+            SLOT(loadCalls()));
+
+    History::Events events = mVoiceEventView->nextPage();
+    while (!events.isEmpty()) {
+        Q_FOREACH(const History::Event &event, events) {
+            History::VoiceEvent voiceEvent(event);
+            MessagingMenu::instance()->addCall(voiceEvent.senderId(), voiceEvent.timestamp());
+        }
+    }
+}
+
+void HistoryLoader::onTextEventsAdded(const History::Events &events)
+{
+    Q_FOREACH(const History::Event &event, events) {
+        History::TextEvent textEvent(event);
+
+        // add the message to the messaging menu (use hex format to avoid invalid characters)
+        QByteArray token(textEvent.eventId().toUtf8());
+        MessagingMenu::instance()->addMessage(textEvent.senderId(), token.toHex(), textEvent.timestamp(), textEvent.message());
+
+        // and show the notify OSD notification
+        Notifications::instance()->showNotificationForMessage(textEvent.senderId(), textEvent.message());
+
+        // update the metrics
+        Metrics::instance()->increment(Metrics::ReceivedMessages);
+    }
+}
+
+void HistoryLoader::onTextEventsSent(const History::Events &events)
+{
+    // just increase the metrics
+    Metrics::instance()->increment(Metrics::SentMessages, events.count());
+}
+
+void HistoryLoader::onTextEventsModified(const History::Events &events)
+{
+    Q_FOREACH(const History::Event &event, events) {
+        // we only support removing events from the menu
+        if (!event.newEvent()) {
+            MessagingMenu::instance()->removeMessage(event.eventId());
+        }
+    }
+}
+
+void HistoryLoader::onTextEventsRemoved(const History::Events &events)
+{
+    Q_FOREACH(const History::Event &event, events) {
+        // we only support removing events from the menu
+        MessagingMenu::instance()->removeMessage(event.eventId());
+    }
+}
+
+void HistoryLoader::onVoiceEventsAdded(const History::Events &events)
+{
+    Q_FOREACH(const History::Event &event, events) {
+        History::VoiceEvent voiceEvent(event);
+        if (voiceEvent.missed()) {
+            MessagingMenu::instance()->addCall(voiceEvent.senderId(), voiceEvent.timestamp());
+        } else {
+            Metrics::instance()->increment(Metrics::CallDurations, QTime(0,0,0).secsTo(voiceEvent.duration()));
+        }
+
+        if (voiceEvent.senderId() != "self") {
+            Metrics::instance()->increment(Metrics::IncomingCalls);
+        } else {
+            Metrics::instance()->increment(Metrics::OutgoingCalls);
+        }
+    }
+}
+
+void HistoryLoader::onMessageRead(const QString &phoneNumber, const QString &messageId)
+{
+    History::Thread thread = History::Manager::instance()->threadForParticipants("ofono/ofono/account0",
+                                                                                 History::EventTypeText,
+                                                                                 QStringList() << phoneNumber,
+                                                                                 History::MatchPhoneNumber);
+    if (thread.isNull()) {
+        return;
+    }
+
+    History::TextEvent event = History::Manager::instance()->getSingleEvent(History::EventTypeText,
+                                                                            "ofono/ofono/account0",
+                                                                            thread.threadId(),
+                                                                            messageId);
+    if (event.isNull() || !event.newEvent()) {
+        return;
+    }
+
+    event.setNewEvent(false);
+    History::Manager::instance()->writeEvents(History::Events() << event);
+}

=== added file 'indicator/historyloader.h'
--- indicator/historyloader.h	1970-01-01 00:00:00 +0000
+++ indicator/historyloader.h	2013-12-11 13:06:39 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2013 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * telephony-service 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HISTORYLOADER_H
+#define HISTORYLOADER_H
+
+#include <QObject>
+#include <History/Types>
+#include <History/Event>
+
+class HistoryLoader : public QObject
+{
+    Q_OBJECT
+public:
+    static HistoryLoader *instance();
+
+public Q_SLOTS:
+    void loadMessages();
+    void loadCalls();
+
+private Q_SLOTS:
+    void onTextEventsAdded(const History::Events &events);
+    void onTextEventsSent(const History::Events &events);
+    void onTextEventsModified(const History::Events &events);
+    void onTextEventsRemoved(const History::Events &events);
+    void onVoiceEventsAdded(const History::Events &events);
+    void onMessageRead(const QString &phoneNumber, const QString &messageId);
+
+private:
+    explicit HistoryLoader(QObject *parent = 0);
+
+    History::EventViewPtr mTextEventView;
+    History::EventViewPtr mSentTextEventView;
+    History::EventViewPtr mVoiceEventView;
+
+    
+};
+
+#endif // HISTORYLOADER_H

=== modified file 'indicator/main.cpp'
--- indicator/main.cpp	2013-09-25 21:18:46 +0000
+++ indicator/main.cpp	2013-12-11 13:06:39 +0000
@@ -23,10 +23,12 @@
 #include <libnotify/notify.h>
 
 #include "applicationutils.h"
+#include "chatmanager.h"
 #include "callchannelobserver.h"
+#include "historyloader.h"
 #include "metrics.h"
 #include "telepathyhelper.h"
-#include "textchannelobserver.h"
+#include "messagingmenu.h"
 #include "voicemailindicator.h"
 #include <QCoreApplication>
 #include <TelepathyQt/ClientRegistrar>
@@ -60,9 +62,6 @@
 
     // Connect the textObserver and the callObserver to the channel observer in TelepathyHelper
     CallChannelObserver *callObserver = new CallChannelObserver();
-    TextChannelObserver *textObserver = new TextChannelObserver();
-    QObject::connect(TelepathyHelper::instance()->channelObserver(), SIGNAL(textChannelAvailable(Tp::TextChannelPtr)),
-                     textObserver, SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
     QObject::connect(TelepathyHelper::instance()->channelObserver(), SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
                      callObserver, SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
 
@@ -70,8 +69,16 @@
     VoiceMailIndicator voiceMailIndicator;
     Q_UNUSED(voiceMailIndicator);
 
-    // instanciate the metrics helper
+    // instanciate the singletons
+    HistoryLoader::instance();
     Metrics::instance();
 
+    // forward the replies from messaging menu to the chat manager
+    QObject::connect(MessagingMenu::instance(), SIGNAL(replyReceived(QString,QString)),
+                     ChatManager::instance(), SLOT(sendMessage(QString,QString)));
+
+    // just to make sure, ack the message on the telepathy level
+    QObject::connect(MessagingMenu::instance(), SIGNAL(messageRead(QString,QString)),
+                     ChatManager::instance(), SLOT(acknowledgeMessage(QString,QString)));
     return app.exec();
 }

=== modified file 'indicator/messagingmenu.h'
--- indicator/messagingmenu.h	2013-10-11 21:08:18 +0000
+++ indicator/messagingmenu.h	2013-12-11 13:06:39 +0000
@@ -25,6 +25,7 @@
 #include <QObject>
 #include <QMap>
 #include <QDBusInterface>
+#include <QUrl>
 #include <messaging-menu.h>
 
 class Call

=== renamed file 'indicator/textchannelobserver.cpp' => 'indicator/notifications.cpp'
--- indicator/textchannelobserver.cpp	2013-10-07 19:20:02 +0000
+++ indicator/notifications.cpp	2013-12-11 13:06:39 +0000
@@ -21,16 +21,10 @@
 
 #include <libnotify/notify.h>
 #include "applicationutils.h"
-#include "textchannelobserver.h"
-#include "messagingmenu.h"
-#include "metrics.h"
-#include "chatmanager.h"
+#include "notifications.h"
 #include "config.h"
 #include "contactutils.h"
 #include "ringtone.h"
-#include <TelepathyQt/AvatarData>
-#include <TelepathyQt/TextChannel>
-#include <TelepathyQt/ReceivedMessage>
 #include <QContactAvatar>
 #include <QContactFetchRequest>
 #include <QContactPhoneNumber>
@@ -69,31 +63,25 @@
     }
 }
 
-TextChannelObserver::TextChannelObserver(QObject *parent) :
+Notifications::Notifications(QObject *parent) :
     QObject(parent)
 {
-    connect(MessagingMenu::instance(),
-            SIGNAL(replyReceived(QString,QString)),
-            SLOT(onReplyReceived(QString,QString)));
-    connect(MessagingMenu::instance(),
-            SIGNAL(messageRead(QString,QString)),
-            SLOT(onMessageRead(QString,QString)));
-}
-
-void TextChannelObserver::showNotificationForMessage(const Tp::ReceivedMessage &message)
-{
-    Tp::ContactPtr contact = message.sender();
-
+}
+
+Notifications *Notifications::instance()
+{
+    static Notifications *self = new Notifications();
+    return self;
+}
+
+void Notifications::showNotificationForMessage(const QString &sender, const QString &message)
+{
     // try to match the contact info
     QContactFetchRequest *request = new QContactFetchRequest(this);
-    request->setFilter(QContactPhoneNumber::match(contact->id()));
-
-    // add the message to the messaging menu (use hex format to avoid invalid characters)
-    QByteArray token(message.messageToken().toUtf8());
-    MessagingMenu::instance()->addMessage(contact->id(), token.toHex(), message.received(), message.text());
+    request->setFilter(QContactPhoneNumber::match(sender));
 
     // place the notify-notification item only after the contact fetch request is finished, as we can´t simply update
-    QObject::connect(request, &QContactAbstractRequest::stateChanged, [request, message, contact]() {
+    QObject::connect(request, &QContactAbstractRequest::stateChanged, [request, message, sender]() {
         // only process the results after the finished state is reached
         if (request->state() != QContactAbstractRequest::FinishedState) {
             return;
@@ -108,7 +96,7 @@
             avatar = contact.detail<QContactAvatar>().imageUrl().toEncoded();
         }
 
-        QString title = QString::fromUtf8(C::gettext("SMS from %1")).arg(displayLabel.isEmpty() ? contact->alias() : displayLabel);
+        QString title = QString::fromUtf8(C::gettext("SMS from %1")).arg(displayLabel.isEmpty() ? sender : displayLabel);
 
         if (avatar.isEmpty()) {
             avatar = QUrl(telephonyServiceDir() + "assets/[e-mail]").toEncoded();
@@ -117,12 +105,12 @@
         qDebug() << title << avatar;
         // show the notification
         NotifyNotification *notification = notify_notification_new(title.toStdString().c_str(),
-                                                                   message.text().toStdString().c_str(),
+                                                                   message.toStdString().c_str(),
                                                                    avatar.toStdString().c_str());
 
         // add the callback action
         NotificationData *data = new NotificationData();
-        data->phoneNumber = contact->id();
+        data->phoneNumber = sender;
         notify_notification_add_action (notification,
                                         "notification_action",
                                         C::gettext("View message"),
@@ -146,73 +134,3 @@
     request->setManager(ContactUtils::sharedManager());
     request->start();
 }
-
-Tp::TextChannelPtr TextChannelObserver::channelFromPath(const QString &path)
-{
-    Q_FOREACH(Tp::TextChannelPtr channel, mChannels) {
-        if (channel->objectPath() == path) {
-            return channel;
-        }
-    }
-
-    return Tp::TextChannelPtr(0);
-}
-
-void TextChannelObserver::onTextChannelAvailable(Tp::TextChannelPtr textChannel)
-{
-    connect(textChannel.data(),
-            SIGNAL(invalidated(Tp::DBusProxy*,const QString&, const QString&)),
-            SLOT(onTextChannelInvalidated()));
-    connect(textChannel.data(),
-            SIGNAL(messageReceived(const Tp::ReceivedMessage&)),
-            SLOT(onMessageReceived(const Tp::ReceivedMessage&)));
-    connect(textChannel.data(),
-            SIGNAL(pendingMessageRemoved(const Tp::ReceivedMessage&)),
-            SLOT(onPendingMessageRemoved(const Tp::ReceivedMessage&)));
-    connect(textChannel.data(),
-            SIGNAL(messageSent(Tp::Message,Tp::MessageSendingFlags,QString)),
-            SLOT(onMessageSent(Tp::Message,Tp::MessageSendingFlags,QString)));
-
-    mChannels.append(textChannel);
-
-    // notify all the messages from the channel
-    Q_FOREACH(Tp::ReceivedMessage message, textChannel->messageQueue()) {
-        onMessageReceived(message);
-    }
-}
-
-void TextChannelObserver::onTextChannelInvalidated()
-{
-    Tp::TextChannelPtr textChannel(qobject_cast<Tp::TextChannel*>(sender()));
-    mChannels.removeAll(textChannel);
-}
-
-void TextChannelObserver::onMessageReceived(const Tp::ReceivedMessage &message)
-{
-    // do not place notification items for scrollback messages
-    if (!message.isScrollback() && !message.isDeliveryReport() && !message.isRescued()) {
-        showNotificationForMessage(message);
-        Metrics::instance()->increment(Metrics::ReceivedMessages);
-    }
-}
-
-void TextChannelObserver::onPendingMessageRemoved(const Tp::ReceivedMessage &message)
-{
-    MessagingMenu::instance()->removeMessage(message.messageToken());
-}
-
-void TextChannelObserver::onReplyReceived(const QString &phoneNumber, const QString &reply)
-{
-    ChatManager::instance()->sendMessage(phoneNumber, reply);
-}
-
-void TextChannelObserver::onMessageRead(const QString &phoneNumber, const QString &encodedMessageId)
-{
-    QString messageId(QByteArray::fromHex(encodedMessageId.toUtf8()));
-    ChatManager::instance()->acknowledgeMessage(phoneNumber, messageId);
-}
-
-void TextChannelObserver::onMessageSent(Tp::Message, Tp::MessageSendingFlags, QString)
-{
-    Metrics::instance()->increment(Metrics::SentMessages);
-}

=== renamed file 'indicator/textchannelobserver.h' => 'indicator/notifications.h'
--- indicator/textchannelobserver.h	2013-09-25 21:18:46 +0000
+++ indicator/notifications.h	2013-12-11 13:06:39 +0000
@@ -19,36 +19,20 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef TEXTCHANNELOBSERVER_H
-#define TEXTCHANNELOBSERVER_H
+#ifndef NOTIFICATIONS_H
+#define NOTIFICATIONS_H
 
 #include <QObject>
-#include <TelepathyQt/TextChannel>
-#include <TelepathyQt/ReceivedMessage>
 
-class TextChannelObserver : public QObject
+class Notifications : public QObject
 {
     Q_OBJECT
 public:
-    explicit TextChannelObserver(QObject *parent = 0);
-
-public Q_SLOTS:
-    void onTextChannelAvailable(Tp::TextChannelPtr textChannel);
-
-protected:
-    void showNotificationForMessage(const Tp::ReceivedMessage &message);
-    Tp::TextChannelPtr channelFromPath(const QString &path);
-
-protected Q_SLOTS:
-    void onTextChannelInvalidated();
-    void onMessageReceived(const Tp::ReceivedMessage &message);
-    void onPendingMessageRemoved(const Tp::ReceivedMessage &message);
-    void onReplyReceived(const QString &phoneNumber, const QString &reply);
-    void onMessageRead(const QString &phoneNumber, const QString &encodedMessageId);
-    void onMessageSent(Tp::Message, Tp::MessageSendingFlags, QString);
+    static Notifications *instance();
+    void showNotificationForMessage(const QString &sender, const QString &message);
 
 private:
-    QList<Tp::TextChannelPtr> mChannels;
+    explicit Notifications(QObject *parent = 0);
 };
 
-#endif // TEXTCHANNELOBSERVER_H
+#endif // NOTIFICATIONS_H

=== modified file 'libtelephonyservice/chatmanager.h'
--- libtelephonyservice/chatmanager.h	2013-07-18 17:02:10 +0000
+++ libtelephonyservice/chatmanager.h	2013-12-11 13:06:39 +0000
@@ -34,8 +34,6 @@
 public:
     static ChatManager *instance();
 
-    Q_INVOKABLE void sendMessage(const QString &phoneNumber, const QString &message);
-
     int unreadMessagesCount() const;
     int unreadMessages(const QString &phoneNumber);
 
@@ -51,6 +49,7 @@
     void onMessageSent(const Tp::Message &sentMessage, const Tp::MessageSendingFlags flags, const QString &message);
 
     void acknowledgeMessage(const QString &phoneNumber, const QString &messageId);
+    void sendMessage(const QString &phoneNumber, const QString &message);
 
 protected:
     Tp::TextChannelPtr existingChat(const QString &phoneNumber);