[konheko] Add sending files, video and audio

meson.build

 project('harbour-konheko', 'cpp', default_options: ['cpp_std=c++17', 'b_pie=true'])
 
 qt5 = import('qt5')
-qt5_dep = dependency('qt5', modules: ['Core', 'Qml', 'Quick', 'DBus'], include_type: 'system')
+qt5_dep = dependency('qt5', modules: ['Core', 'Qml', 'Quick', 'DBus', 'Multimedia'], include_type: 'system')
 inc = include_directories('src')
 
 cmake_pref = get_option('cget_prefix')

qml/pages/ChatPage.qml

@@ -229,17 +229,17 @@ Page {
 
             MenuItem {
                 text: qsTr("Send video")
-                onClicked: console.log("Clicked option 1")
+                onClicked: pageStack.push(multiVideoPickerDialog)
             }
 
             MenuItem {
                 text: qsTr("Send audio")
-                onClicked: console.log("Clicked option 1")
+                onClicked: pageStack.push(multiMusicPickerDialog)
             }
 
             MenuItem {
                 text: qsTr("Send file")
-                onClicked: console.log("Clicked option 1")
+                onClicked: pageStack.push(multiFilePickerDialog)
             }
 
         }
@@ -264,6 +264,60 @@ Page {
 
     }
 
+    Component {
+        id: multiVideoPickerDialog
+
+        MultiVideoPickerDialog {
+            onAccepted: {
+                var urls = [];
+                var mimetypes = [];
+                for (var i = 0; i < selectedContent.count; ++i) {
+                    urls.push(selectedContent.get(i).url);
+                    mimetypes.push(selectedContent.get(i).mimeType);
+                }
+                room.sendVideos(urls, mimetypes);
+            }
+            onRejected: selectedFiles = ""
+        }
+
+    }
+
+    Component {
+        id: multiMusicPickerDialog
+
+        MultiMusicPickerDialog {
+            onAccepted: {
+                var urls = [];
+                var mimetypes = [];
+                for (var i = 0; i < selectedContent.count; ++i) {
+                    urls.push(selectedContent.get(i).url);
+                    mimetypes.push(selectedContent.get(i).mimeType);
+                }
+                room.sendAudio(urls, mimetypes);
+            }
+            onRejected: selectedFiles = ""
+        }
+
+    }
+
+    Component {
+        id: multiFilePickerDialog
+
+        MultiFilePickerDialog {
+            onAccepted: {
+                var urls = [];
+                var mimetypes = [];
+                for (var i = 0; i < selectedContent.count; ++i) {
+                    urls.push(selectedContent.get(i).url);
+                    mimetypes.push(selectedContent.get(i).mimeType);
+                }
+                room.sendFiles(urls, mimetypes);
+            }
+            onRejected: selectedFiles = ""
+        }
+
+    }
+
     Component {
         id: messageMenu
 

src/harbour-konheko.cpp

@@ -106,7 +106,8 @@ int main(int argc, char *argv[]) {
     QObject::connect(konheko::login, &Login::loggedOut, konheko::rooms, &RoomListModel::clear,
                      Qt::BlockingQueuedConnection);
     QObject::connect(konheko::sync, &Sync::newRoom, konheko::rooms, &RoomListModel::addRoom, Qt::QueuedConnection);
-    QObject::connect(konheko::sync, &Sync::roomUpdated, konheko::rooms, &RoomListModel::updateRoom, Qt::QueuedConnection);
+    QObject::connect(konheko::sync, &Sync::roomUpdated, konheko::rooms, &RoomListModel::updateRoom,
+                     Qt::QueuedConnection);
     QObject::connect(konheko::sync, &Sync::invalidToken, konheko::login, &Login::logout, Qt::QueuedConnection);
     QObject::connect(app.data(), &QGuiApplication::aboutToQuit, konheko::sync, &Sync::exitSync, Qt::QueuedConnection);
 

src/models/roommodel.cpp

@@ -4,6 +4,8 @@
 
 #include <QFile>
 #include <QImageReader>
+#include <QMediaMetaData>
+#include <QMediaPlayer>
 #include <QMetaType>
 #include <QSharedPointer>
 #include <QtMath>
@@ -434,6 +436,7 @@ void Room::sendImages(QList<QUrl> images, QList<QString> mimetypes) {
                                   img.url = uri.content_uri;
                                   img.info.h = size.height();
                                   img.info.w = size.width();
+                                  img.info.size = filesize;
 
                                   http::client().send_room_message<msg::Image, mtx::events::EventType::RoomMessage>(
                                       this->id, http::client().generate_txn_id(), img,
@@ -450,6 +453,168 @@ void Room::sendImages(QList<QUrl> images, QList<QString> mimetypes) {
     }
 }
 
+void Room::sendAudio(QList<QUrl> files, QList<QString> mimetypes) {
+    for (int i = 0; i < files.size(); i++) {
+        QMediaPlayer *player = new QMediaPlayer(this);
+
+        connect(player, &QMediaPlayer::metaDataAvailableChanged, this,
+                [this, player, mimeType = mimetypes.at(i).toStdString(),
+                 filename = files.at(i).fileName().toStdString(),
+                 localFile = files.at(i).toLocalFile()](bool available) {
+                    player->deleteLater();
+                    if (!available)
+                        return;
+
+                    auto file = QFile(localFile);
+                    if (!file.open(QIODevice::ReadOnly)) {
+                        qCritical() << "Failed to open file" << localFile;
+                        return;
+                    }
+                    auto temp = file.readAll();
+                    std::string data(temp.data(), temp.size());
+
+                    mtx::events::msg::Audio audio = {};
+                    audio.msgtype = "m.audio";
+                    audio.body = filename;
+                    audio.info.mimetype = mimeType;
+                    audio.info.size = temp.size();
+                    audio.info.duration = player->metaData(QMediaMetaData::Duration).value<qint64>();
+
+                    http::client().upload(
+                        data, mimeType, filename,
+                        [this, audio](const mtx::responses::ContentURI &uri, mtx::http::RequestErr err) {
+                            if (err) {
+                                qDebug() << "failed to upload audio: " << *err;
+                                return;
+                            }
+
+                            auto audio2 = audio;
+                            audio2.url = uri.content_uri;
+
+                            http::client().send_room_message<msg::Audio, mtx::events::EventType::RoomMessage>(
+                                this->id, http::client().generate_txn_id(), audio2,
+                                [this](const mtx::responses::EventId &res, mtx::http::RequestErr err) {
+                                    if (err) {
+                                        qDebug() << "failed to send message: " << *err;
+                                        return;
+                                    }
+
+                                    qDebug() << "send event as: $" << QString::fromStdString(res.event_id.to_string());
+                                });
+                        });
+                });
+
+        player->setMedia(files[i]);
+    }
+}
+
+void Room::sendVideos(QList<QUrl> files, QList<QString> mimetypes) {
+    for (int i = 0; i < files.size(); i++) {
+        QMediaPlayer *player = new QMediaPlayer(this);
+
+        connect(player, &QMediaPlayer::metaDataAvailableChanged, this,
+                [this, player, mimeType = mimetypes.at(i).toStdString(),
+                 filename = files.at(i).fileName().toStdString(),
+                 localFile = files.at(i).toLocalFile()](bool available) {
+                    player->deleteLater();
+                    if (!available)
+                        return;
+
+                    auto file = QFile(localFile);
+                    if (!file.open(QIODevice::ReadOnly)) {
+                        qCritical() << "Failed to open file" << localFile;
+                        return;
+                    }
+                    auto temp = file.readAll();
+                    std::string data(temp.data(), temp.size());
+
+                    mtx::events::msg::Video video = {};
+                    video.msgtype = "m.video";
+                    video.body = filename;
+                    video.info.mimetype = mimeType;
+                    video.info.size = temp.size();
+                    video.info.duration = player->metaData(QMediaMetaData::Duration).value<qint64>();
+                    video.info.h = player->metaData(QMediaMetaData::Resolution).value<QSize>().height();
+                    video.info.w = player->metaData(QMediaMetaData::Resolution).value<QSize>().width();
+
+                    // TODO: also upload thumbnail
+
+                    http::client().upload(
+                        data, mimeType, filename,
+                        [this, video](const mtx::responses::ContentURI &uri, mtx::http::RequestErr err) {
+                            if (err) {
+                                qDebug() << "failed to upload video: " << *err;
+                                return;
+                            }
+
+                            auto video2 = video;
+                            video2.url = uri.content_uri;
+
+                            http::client().send_room_message<msg::Video, mtx::events::EventType::RoomMessage>(
+                                this->id, http::client().generate_txn_id(), video2,
+                                [this](const mtx::responses::EventId &res, mtx::http::RequestErr err) {
+                                    if (err) {
+                                        qDebug() << "failed to send message: " << *err;
+                                        return;
+                                    }
+
+                                    qDebug() << "send event as: $" << QString::fromStdString(res.event_id.to_string());
+                                });
+                        });
+                });
+
+        player->setMedia(files[i]);
+    }
+}
+
+void Room::sendFiles(QList<QUrl> files, QList<QString> mimetypes) {
+    for (int i = 0; i < files.size(); i++) {
+        if (mimetypes.at(i).startsWith("audio/")) {
+            sendAudio({files.at(i)}, {mimetypes.at(i)});
+            continue;
+        } else if (mimetypes.at(i).startsWith("video/")) {
+            sendVideos({files.at(i)}, {mimetypes.at(i)});
+            continue;
+        } else {
+            auto file = QFile(files.at(i).toLocalFile());
+            if (!file.open(QIODevice::ReadOnly)) {
+                qCritical() << "Failed to open file" << files.at(i).toLocalFile();
+                return;
+            }
+            auto temp = file.readAll();
+            std::string data(temp.data(), temp.size());
+
+            mtx::events::msg::File fileEv = {};
+            fileEv.body = files.at(i).fileName().toStdString();
+            fileEv.info.size = temp.size();
+            fileEv.info.mimetype = mimetypes.at(i).toStdString();
+
+            http::client().upload(data, mimetypes.at(i).toStdString(), files.at(i).fileName().toStdString(),
+                                  [this, fileEv](const mtx::responses::ContentURI &uri, mtx::http::RequestErr err) {
+                                      if (err) {
+                                          qDebug() << "failed to upload file: " << *err;
+                                          return;
+                                      }
+
+                                      auto file = fileEv;
+                                      file.url = uri.content_uri;
+
+                                      http::client().send_room_message<msg::File, mtx::events::EventType::RoomMessage>(
+                                          this->id, http::client().generate_txn_id(), file,
+                                          [this](const mtx::responses::EventId &res, mtx::http::RequestErr err) {
+                                              if (err) {
+                                                  qDebug() << "failed to send message: " << *err;
+                                                  return;
+                                              }
+
+                                              qDebug() << "send event as: $"
+                                                       << QString::fromStdString(res.event_id.to_string());
+                                          });
+                                  });
+        }
+    }
+}
+
 QHash<int, QByteArray> Room::roleNames() const {
     QHash<int, QByteArray> roles;
     roles[Type] = "Type";

src/models/roommodel.h

@@ -171,6 +171,9 @@ struct Room : public QAbstractListModel {
     void fetchOlderMessages();
     void sendTextMessage(QString message);
     void sendImages(QList<QUrl> images, QList<QString> mimetypes);
+    void sendAudio(QList<QUrl> images, QList<QString> mimetypes);
+    void sendVideos(QList<QUrl> images, QList<QString> mimetypes);
+    void sendFiles(QList<QUrl> images, QList<QString> mimetypes);
     void markRead(int index);
     int lastRead();