NotificationManager.h

/***************************************************************************
 *   Copyright (C) 2023 by Stefan Kebekus                                  *
 *   stefan.kebekus@gmail.com                                              *
 *                                                                         *
 *   This program 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; either version 3 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#pragma once
 
#include <QFuture>
#include <QQmlEngine>
#include <QTextToSpeech>
#include <QTimer>
 
#include "GlobalObject.h"
#include "Notification.h"
 
 
namespace Notifications {

 
class NotificationManager : public GlobalObject
{
    Q_OBJECT
    QML_ELEMENT
    QML_SINGLETON
 
public:
    //
    // Constructors and destructors
    //

    explicit NotificationManager(QObject* parent = nullptr);
 
    // deferred initialization
    void deferredInitialization() override;
 
    // No default constructor, important for QML singleton
    explicit NotificationManager() = delete;

    ~NotificationManager() override = default;
 
    // factory function for QML singleton
    static Notifications::NotificationManager* create(QQmlEngine* /*unused*/, QJSEngine* /*unused*/)
    {
        return GlobalObject::notificationManager();
    }
 
 
    //
    // PROPERTIES
    //

    Q_PROPERTY(Notifications::Notification* currentVisualNotification READ currentVisualNotification NOTIFY currentVisualNotificationChanged)
 
    
    Q_PROPERTY(QTextToSpeech* speaker READ speaker NOTIFY speakerChanged)
 
 
    //
    // Getter Methods
    //

    [[nodiscard]] Notifications::Notification* currentVisualNotification() const;

    [[nodiscard]] QTextToSpeech* speaker() const
    {
        return m_speaker;
    }
 
 
    //
    // Methods
    //

    Q_INVOKABLE void addTestNotification();

    Q_INVOKABLE void voiceTest();

    void waitForSpeechEngine();
 
signals:
    void currentVisualNotificationChanged();

    void speakerChanged();

    void toastPosted(QString text);
 
private:
    Q_DISABLE_COPY_MOVE(NotificationManager)
 
 
    // Adds a notification to m_notifications and rearranges the list. Removes
    // nullptrs and sorts list by importance.
    void addNotification(Notifications::Notification* notification);
 
 
 
    //
    // Members used for visual notifications
    //
 
    // This method clears all nullptrs from m_notifications, sorts the elements
    // by importance and emits currentNotificationChanged() whenever the first
    // element the list changes.
    void showNext();
 
    // List of Notifications, sorted so that the most important notification
    // comes first.
    QVector<QPointer<Notifications::Notification>> m_visualNotifications;
 
    // Stores pointer to last current visual notification. This is used to
    // determine when the signal currentVisualNotificationChanged should be
    // emitted.
    Notifications::Notification* currentVisualNotificationCache {nullptr};
 
 
 
    //
    // Members used for voice notifications
    //
 
 
    // If the speaker is finished, start m_speechBreakTimer, in order to call
    // speakNext() after a one-second break.
    void onSpeakerStateChanged(QTextToSpeech::State state);
 
    // Constructs the speaker and moves it to the given thread. Under Linux,
    // the constructor of QTextToSpeech is very slow, so this runs on a worker
    // thread. The object is then handed over to the GUI thread by
    // adoptSpeaker(). This method touches nothing but the new object.
    static QTextToSpeech* createSpeaker(QThread* thread);
 
    // Takes over a speaker constructed by createSpeaker(): makes it a child of
    // this, wires it up, publishes it through the property speaker and starts
    // speaking pending notifications. Must be called in the GUI thread.
    void adoptSpeaker(QTextToSpeech* speaker);
 
 
    // This method cleans the list m_spokenNotifications and sorts it by
    // importance. If a notification is in the list, it speaks the notication
    // test.
    void speakNext();
 
    // List of Notifications, sorted so that the most important notification
    // comes first.
    QVector<QPointer<Notifications::Notification>> m_voiceNotifications;
 
    // Pointer to the speaker. This is the nullpointer until adoptSpeaker() has
    // run. Written and read in the GUI thread only.
    QTextToSpeech* m_speaker {nullptr};
 
    // Future for the worker that constructs QTextToSpeech under Linux in a
    // different thread
    QFuture<QTextToSpeech*> m_speakerFuture;
 
 
    // This timer is used to stop for one second between two spoken texts. The
    // slot start() is called when m_speaker is done speaking. The signal
    // timeout() is connected to speakNext().
    QTimer m_speechBreakTimer;
 
 
 
    //
    // Members used to watch other app components, and to generate notifications
    // when necessary
    //
 
    // Called whenever map and data updates become (un)available
    void onMapAndDataUpdateSizeChanged();
 
    // Called whenever the position provider finds that pressure altitude and
    // geometric altitude differ by implausible amounts, or clears that status.
    void onPressureAltitudeImplausible();
    
    // Called whenever the list of oversized aviation maps changes
    void onOversizedMapsChanged();
 
    // Called whenever the traffic receiver reports a runtime error, or clears
    // the error status.
    void onTrafficReceiverRuntimeError();
 
    // Called whenever the traffic receiver reports a self test error, or clears
    // the error status.
    void onTrafficReceiverSelfTestError();
 
    // When notifications for maps and data are temporarily not possible, then
    // use this timer to notify again.
    QTimer mapsAndDataNotificationTimer;
 
    // Notification for oversized aviation maps; this pointer guards against
    // showing the notification more than once.
    QPointer<Notifications::Notification> m_oversizedMapNotification;
};
 
 
} // namespace Notifications