Add push to talk support to homescreen

Reworked version of Alexa specific changes from ICS to add push to
talk button for voice services to homescreen media area.

v2: change config.xml to audiomixer

v3: reworked to not be Alexa specific:
- Now use the default voiceagent if available, instead of hard-coding
  Alexa usage
- The Alexa logo for the button has been replaced with a generic
  microphone icon derived from the radio application's launcher icon.
  This is a placeholder until a new icon is provided by LF graphics
  team. Meeting any Amazon requirements around Alexa chrome is now
  envisioned as being provided for with a TBD voiceagent API
  enhancement.
- The QML for the PTT button has been moved to MediaAreaBlank.qml,
  which seems a more logical location for it ATM.  It is likely that
  the MediaArea QML should be simplified in a future change, as it
  currently contains a signficant amount of unused code.
- The PTT button has been moved to the left hand side of the media
  area, as this seems more sensible if demonstrating driver usage.
- The delay on fade-out of the master volume slider has been lowered
  to 3 seconds from 5, with the PTT button present it started seeming
  excessive during testing.
- Some extra debug messages have been added to make tracking the
  voiceagent state more straightforward.

Bug-AGL: SPEC-2764,

Change-Id: I2052e345baaf4306e8e3f27a01bc6940f4d27d88
Signed-off-by: Naveen Bobbili <nbobbili@amazon.com>
Signed-off-by: Jan-Simon Moeller <jsmoeller@linuxfoundation.org>
Signed-off-by: Scott Murray <scott.murray@konsulko.com>

6 files changed, 372 insertions, 0 deletions

diff --git a/homescreen/src/aglsocketwrapper.cpp b/homescreen/src/aglsocketwrapper.cpp
new file mode 100644
index 0000000..8352660
--- /dev/null
+++ b/homescreen/src/aglsocketwrapper.cpp
@@ -0,0 +1,90 @@
+#include "aglsocketwrapper.h"
+#include "constants.h"
+
+#include <QWebSocket>
+#include <QUuid>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QJsonDocument>
+
+#include <QDebug>
+
+namespace {
+enum MessageTypes {
+    Call = 2,
+    Success = 3,
+    Error = 4,
+    Event = 5
+};
+}
+
+AglSocketWrapper::AglSocketWrapper(QObject *parent) :
+    QObject(parent)
+  , m_socket(new QWebSocket(QString(), QWebSocketProtocol::VersionLatest, this))
+{
+    connect(m_socket, &QWebSocket::connected, this, &AglSocketWrapper::connected);
+    connect(m_socket, &QWebSocket::disconnected, this, &AglSocketWrapper::disconnected);
+    connect(m_socket, QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error),
+            [](QAbstractSocket::SocketError error) -> void {
+        qWarning() << "AglSocketWrapper internal socket error" << error;
+    });
+    connect(m_socket, &QWebSocket::textMessageReceived,
+            this, [this](const QString &msg) -> void {
+        const QJsonDocument doc = QJsonDocument::fromJson(msg.toUtf8());
+        if (doc.isArray()) {
+            const QJsonArray msgArray = doc.array();
+            if (msgArray.count() >= 3) {
+                const int msgType = msgArray.at(0).toInt();
+                switch (msgType) {
+                case Success:
+                case Error: {
+                    auto callbackIt = m_callbacks.find( msgArray.at(1).toString());
+                    if (callbackIt != m_callbacks.constEnd()) {
+                        (*callbackIt)(msgType == Success, msgArray.at(2));
+                        m_callbacks.erase(callbackIt);
+                    }
+                }
+                    break;
+                case Event: {
+                    const QJsonObject eventObj = msgArray.at(2).toObject();
+                    emit eventReceived(msgArray.at(1).toString(), eventObj.value(vshl::DATA_TAG));
+                }
+                    break;
+                default:
+                    break;
+                }
+                return;
+            }
+        }
+        qWarning() << "Unsupported message format:" << msg;
+    });
+}
+
+void AglSocketWrapper::open(const QUrl &url)
+{
+    m_socket->open(url);
+}
+
+void AglSocketWrapper::close()
+{
+    m_socket->close();
+}
+
+void AglSocketWrapper::apiCall(const QString &api, const QString &verb, const QJsonValue &args,
+                               AglSocketWrapper::ApiCallback callback)
+{
+    const QString id = QUuid::createUuid().toString();
+    if (callback)
+        m_callbacks.insert(id, callback);
+
+    QJsonArray callData;
+    callData.append(Call);
+    callData.append(id);
+    callData.append(api + QLatin1String("/") + verb);
+    callData.append(args);
+
+    const QString msg = QLatin1String(QJsonDocument(callData).toJson(QJsonDocument::Compact));
+    m_socket->sendTextMessage(msg);
+
+    qDebug() << Q_FUNC_INFO << "Data sent:" << msg;
+}
diff --git a/homescreen/src/aglsocketwrapper.h b/homescreen/src/aglsocketwrapper.h
new file mode 100644
index 0000000..4807cd5
--- /dev/null
+++ b/homescreen/src/aglsocketwrapper.h
@@ -0,0 +1,35 @@
+#ifndef AGLSOCKETWRAPPER_H
+#define AGLSOCKETWRAPPER_H
+
+#include <QUrl>
+#include <QMap>
+#include <QObject>
+#include <QJsonValue>
+
+#include <functional>
+
+class QWebSocket;
+class AglSocketWrapper : public QObject
+{
+    Q_OBJECT
+public:
+    explicit AglSocketWrapper(QObject *parent = nullptr);
+
+    void open(const QUrl &url);
+    void close();
+
+    using ApiCallback = std::function<void(bool, const QJsonValue&)>;
+    void apiCall(const QString &api, const QString &verb, const QJsonValue &args = QJsonValue(),
+                 ApiCallback callback = nullptr);
+
+signals:
+    void connected();
+    void disconnected();
+    void eventReceived(const QString &eventName, const QJsonValue &data);
+
+private:
+    QWebSocket *m_socket;
+    QMap<QString, ApiCallback> m_callbacks;
+};
+
+#endif // AGLSOCKETWRAPPER_H
diff --git a/homescreen/src/chromecontroller.cpp b/homescreen/src/chromecontroller.cpp
new file mode 100644
index 0000000..b604dae
--- /dev/null
+++ b/homescreen/src/chromecontroller.cpp
@@ -0,0 +1,159 @@
+#include "chromecontroller.h"
+#include "aglsocketwrapper.h"
+#include "constants.h"
+
+#include <QTimer>
+#include <QDebug>
+#include <QJsonDocument>
+
+ChromeController::ChromeController(const QUrl &bindingUrl, QObject *parent) :
+    QObject(parent)
+  , m_aglSocket(new AglSocketWrapper(this))
+{
+    //Alexa voice agent subscription----------------------------------------------------------------
+    {
+    connect(m_aglSocket, &AglSocketWrapper::connected,
+            this, [this]() -> void {
+                m_aglSocket->apiCall(vshl::API, vshl::VOICE_AGENT_ENUMERATION_VERB, QJsonValue(),
+                [this](bool result, const QJsonValue &data) -> void {
+                    qDebug() << (vshl::API + QLatin1String(":") + vshl::VOICE_AGENT_ENUMERATION_VERB)
+                             << "result: " << result << " val: " << data;
+                    if (!result) {
+                        qWarning() << "Failed to enumerate voice agents";
+                        return;
+                    }
+
+                    QJsonObject dataObj = data.toObject();
+                    auto objIt = dataObj.find(vshl::RESPONSE_TAG);
+                    if (objIt == dataObj.constEnd()) {
+                        qWarning() << "Voice agent enumeration response tag missing."
+                                   << dataObj;
+                        return;
+                    }
+
+                    // Get default voice agent
+                    dataObj = objIt.value().toObject();
+                    QJsonObject responseObj = dataObj;
+                    objIt = dataObj.find(vshl::DEFAULT_TAG);
+                    if (objIt == dataObj.constEnd()) {
+                        qWarning() << "Voice agent enumeration default agent tag missing."
+                                   << dataObj;
+                        return;
+                    }
+                    QString agentId = objIt.value().toString();
+                    if (agentId.isEmpty()) {
+                        qWarning() << "Default voice agent not found";
+                        return;
+                    }
+                    qDebug() << (vshl::API + QLatin1String(":") + vshl::VOICE_AGENT_ENUMERATION_VERB) << "default: " << agentId;
+
+                    objIt = dataObj.find(vshl::AGENTS_TAG);
+                    if (objIt == dataObj.constEnd()) {
+                        qWarning() << "Voice agent enumeration agents tag missing."
+                                   << dataObj;
+                        return;
+                    }
+
+                    // Sanity check that the default agent is actually listed
+                    bool agentFound = false;
+                    const QJsonArray agents = objIt.value().toArray();
+                    for (const QJsonValue &agent : agents) {
+                        const QJsonObject agentObj = agent.toObject();
+                        auto agentIt = agentObj.find(vshl::ID_TAG);
+                        if (agentIt == agentObj.constEnd())
+                            continue;
+                        if (agentId.compare(agentIt.value().toString()) == 0) {
+                            agentFound = true;
+                            break;
+                        }
+                    }
+                    if (!agentFound) {
+                        qWarning() << "Default voice agent configuration not found";
+                        return;
+                    }
+                    m_agentPresent = true;
+                    emit agentPresentChanged();
+
+                    //Voice agent subscription------------------------------------------------------
+                    {
+                        m_voiceAgentId = agentId;
+                        const QJsonObject args {
+                            { vshl::VOICE_AGENT_ID_ARG, agentId },
+                            { vshl::VOICE_AGENT_EVENTS_ARG, vshl::VOICE_AGENT_EVENTS_ARRAY }
+                        };
+                        m_aglSocket->apiCall(vshl::API, vshl::SUBSCRIBE_VERB, args,
+                        [](bool result, const QJsonValue &data) -> void {
+                            qDebug() << (vshl::API + QLatin1String(":") + vshl::SUBSCRIBE_VERB)
+                                     << "result: " << result << " val: " << data;
+                        });
+                    }
+                    //------------------------------------------------------------------------------
+                });
+            });
+    }
+    //----------------------------------------------------------------------------------------------<
+
+    //Socket connection management------------------------------------------------------------------
+    {
+    auto connectToBinding = [bindingUrl, this]() -> void {
+        m_aglSocket->open(bindingUrl);
+        qDebug() << "Connecting to:" << bindingUrl;
+    };
+    connect(m_aglSocket, &AglSocketWrapper::disconnected, this, [connectToBinding]() -> void {
+                QTimer::singleShot(2500, connectToBinding);
+            });
+    connectToBinding();
+    }
+    //----------------------------------------------------------------------------------------------
+
+    //Speech chrome state change event handling-----------------------------------------------------
+    {
+    connect(m_aglSocket, &AglSocketWrapper::eventReceived,
+            this, [this](const QString &eventName, const QJsonValue &data) -> void {
+        if (eventName.compare(vshl::VOICE_DIALOG_STATE_EVENT + m_voiceAgentId) == 0) {
+            const QJsonObject dataObj = QJsonDocument::fromJson(data.toString().toUtf8()).object();
+            auto objIt = dataObj.find(vshl::STATE_TAG);
+            if (objIt == dataObj.constEnd()) {
+                qWarning() << "Voice dialog state event state missing.";
+                return;
+            }
+            const QString stateStr = objIt.value().toString();
+            if (stateStr.compare(vshl::VOICE_DIALOG_IDLE) == 0) {
+                setChromeState(Idle);
+            } else if (stateStr.compare(vshl::VOICE_DIALOG_LISTENING) == 0) {
+                setChromeState(Listening);
+            } else if (stateStr.compare(vshl::VOICE_DIALOG_THINKING) == 0) {
+                setChromeState(Thinking);
+            } else if (stateStr.compare(vshl::VOICE_DIALOG_SPEAKING) == 0) {
+                setChromeState(Speaking);
+            } else if (stateStr.compare(vshl::VOICE_DIALOG_MICROPHONEOFF) == 0) {
+                setChromeState(MicrophoneOff);
+            }
+        }
+    });
+    }
+    //----------------------------------------------------------------------------------------------
+}
+
+void ChromeController::pushToTalk()
+{
+    m_aglSocket->apiCall(vshl::API, vshl::TAP_TO_TALK_VERB, QJsonValue(),
+                         [](bool result, const QJsonValue &data) -> void {
+        qDebug() << (vshl::API + QLatin1String(":") + vshl::TAP_TO_TALK_VERB)
+                 << "result: " << result << " val: " << data;
+    });
+}
+
+void ChromeController::setChromeState(ChromeController::ChromeState state)
+{
+    const char* ChromeStateNames[MicrophoneOff + 1] = { "Idle", "Listening", "Thinking", "Speaking", "MicrophoneOff" };
+
+    if (m_chromeState != state) {
+        m_chromeState = state;
+        emit chromeStateChanged();
+        if(state <= MicrophoneOff)
+            qDebug() << "new state = " << ChromeStateNames[state];
+	else
+            qDebug() << "new state = " << state;
+    }
+}
diff --git a/homescreen/src/chromecontroller.h b/homescreen/src/chromecontroller.h
new file mode 100644
index 0000000..2a76002
--- /dev/null
+++ b/homescreen/src/chromecontroller.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <QObject>
+#include <QUrl>
+
+class AglSocketWrapper;
+class ChromeController : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY(bool agentPresent READ agentPresent NOTIFY agentPresentChanged)
+    Q_PROPERTY(int chromeState READ chromeState NOTIFY chromeStateChanged)
+
+public:
+    enum ChromeState {
+        Idle = 0,
+        Listening,
+        Thinking,
+        Speaking,
+        MicrophoneOff
+    };
+    Q_ENUM(ChromeState)
+
+    explicit ChromeController(const QUrl &bindingUrl, QObject *parent = nullptr);
+    bool agentPresent() const { return m_agentPresent; }
+    int chromeState() const { return m_chromeState; }
+
+public slots:
+    void pushToTalk();
+
+signals:
+    void agentPresentChanged();
+    void chromeStateChanged();
+
+private:
+    void setChromeState(ChromeState state);
+
+    AglSocketWrapper *m_aglSocket;
+    QString m_voiceAgentId;
+    bool m_agentPresent = false;
+    ChromeState m_chromeState = Idle;
+};
diff --git a/homescreen/src/constants.h b/homescreen/src/constants.h
new file mode 100644
index 0000000..a43bf6d
--- /dev/null
+++ b/homescreen/src/constants.h
@@ -0,0 +1,42 @@
+#ifndef CONSTANTS_H
+#define CONSTANTS_H
+
+#include <QString>
+#include <QJsonArray>
+#include <QJsonObject>
+
+namespace vshl {
+const QString API = QLatin1String("vshl-core");
+const QString VOICE_AGENT_ENUMERATION_VERB = QLatin1String("enumerateVoiceAgents");
+const QString SUBSCRIBE_VERB = QLatin1String("subscribe");
+const QString TAP_TO_TALK_VERB = QLatin1String("startListening");
+
+const QString ALEXA_AGENT_NAME = QLatin1String("Alexa");
+
+const QString DATA_TAG = QLatin1String("data");
+const QString RESPONSE_TAG = QLatin1String("response");
+const QString AGENTS_TAG = QLatin1String("agents");
+const QString DEFAULT_TAG = QLatin1String("default");
+const QString NAME_TAG = QLatin1String("name");
+const QString ID_TAG = QLatin1String("id");
+const QString STATE_TAG = QLatin1String("state");
+
+const QString VOICE_AGENT_ID_ARG = QLatin1String("va_id");
+const QString VOICE_AGENT_EVENTS_ARG = QLatin1String("events");
+const QString VOICE_AGENT_ACTIONS_ARG = QLatin1String("actions");
+
+const QJsonArray VOICE_AGENT_EVENTS_ARRAY = {
+    QLatin1String("voice_authstate_event"),
+    QLatin1String("voice_dialogstate_event"),
+    QLatin1String("voice_connectionstate_event")
+};
+
+const QString VOICE_DIALOG_STATE_EVENT = QLatin1String("vshl-core/voice_dialogstate_event#");
+const QString VOICE_DIALOG_IDLE = QLatin1String("IDLE");
+const QString VOICE_DIALOG_LISTENING = QLatin1String("LISTENING");
+const QString VOICE_DIALOG_THINKING = QLatin1String("THINKING");
+const QString VOICE_DIALOG_SPEAKING = QLatin1String("SPEAKING");
+const QString VOICE_DIALOG_MICROPHONEOFF = QLatin1String("MICROPHONEOFF");
+}
+
+#endif // CONSTANTS_H
diff --git a/homescreen/src/main.cpp b/homescreen/src/main.cpp
index 5f283fb..5c819f9 100644
--- a/homescreen/src/main.cpp
+++ b/homescreen/src/main.cpp
@@ -32,6 +32,7 @@
 #include "mastervolume.h"
 #include "homescreenhandler.h"
 #include "hmi-debug.h"
+#include "chromecontroller.h"
 
 // XXX: We want this DBus connection to be shared across the different
 // QML objects, is there another way to do this, a nice way, perhaps?
@@ -91,6 +92,8 @@ int main(int argc, char *argv[])
     // qmlRegisterType<ApplicationLauncher>("HomeScreen", 1, 0, "ApplicationLauncher");
     qmlRegisterType<StatusBarModel>("HomeScreen", 1, 0, "StatusBarModel");
     qmlRegisterType<MasterVolume>("MasterVolume", 1, 0, "MasterVolume");
+    qmlRegisterUncreatableType<ChromeController>("SpeechChrome", 1, 0, "SpeechChromeController",
+                                                 QLatin1String("SpeechChromeController is uncreatable."));
 
     ApplicationLauncher *launcher = new ApplicationLauncher();
     QLibWindowmanager* layoutHandler = new QLibWindowmanager();
@@ -140,6 +143,7 @@ int main(int argc, char *argv[])
     engine.rootContext()->setContextProperty("launcher", launcher);
     engine.rootContext()->setContextProperty("weather", new Weather(bindingAddress));
     engine.rootContext()->setContextProperty("bluetooth", new Bluetooth(bindingAddress, engine.rootContext()));
+    engine.rootContext()->setContextProperty("speechChromeController", new ChromeController(bindingAddress, &engine));
     engine.rootContext()->setContextProperty("screenInfo", &screenInfo);
     engine.load(QUrl(QStringLiteral("qrc:/main.qml")));