File indexing completed on 2024-06-16 05:22:24

 /*
  * Copyright 2020 Han Young <hanyoung@protonmail.com>
  * Copyright 2020-2022 Devin Lin <devin@kde.org>
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #pragma once
 
 #include "alarmmodel.h"
 #include "alarmplayer.h"
 #include "alarmwaitworker.h"
 
 #include <KLocalizedString>
 #include <KNotification>
 
 #include <QDebug>
 #include <QFileDialog>
 #include <QMediaPlayer>
 #include <QObject>
 #include <QStandardPaths>
 #include <QString>
 #include <QThread>
 #include <QTime>
 #include <QTimer>
 #include <QUrl>
 #include <QUuid>
 
 const QString ALARM_CFG_GROUP = QStringLiteral("Alarms");
 
 class AlarmModel;
 
 class Alarm : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kclock.Alarm")
     Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
     Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
     Q_PROPERTY(int hours READ hours WRITE setHours NOTIFY hoursChanged)
     Q_PROPERTY(int minutes READ minutes WRITE setMinutes NOTIFY minutesChanged)
     Q_PROPERTY(int daysOfWeek READ daysOfWeek WRITE setDaysOfWeek NOTIFY daysOfWeekChanged)
     Q_PROPERTY(QString audioPath READ audioPath WRITE setAudioPath NOTIFY audioPathChanged)
     Q_PROPERTY(int ringDuration READ ringDuration WRITE setRingDuration NOTIFY ringDurationChanged)
     Q_PROPERTY(int snoozeDuration READ snoozeDuration WRITE setSnoozeDuration NOTIFY snoozeDurationChanged)
     Q_PROPERTY(int snoozedLength READ snoozedLength NOTIFY snoozedLengthChanged)
     Q_PROPERTY(bool ringing READ ringing NOTIFY ringingChanged)
     Q_PROPERTY(quint64 nextRingTime READ nextRingTime NOTIFY nextRingTimeChanged)
 
 public:
     explicit Alarm(const QString &serialized, AlarmModel *parent = nullptr);
     explicit Alarm(const QString &name = i18n("Alarm"),
                    int hours = 0,
                    int minutes = 0,
                    int daysOfWeek = 0,
                    QString audioPath = QString{},
                    int ringDuration = 5,
                    int snoozeDuration = 5,
                    AlarmModel *parent = nullptr);
 
     void init(AlarmModel *parent);
 
     ~Alarm();
 
     // serialize this alarm to json
     QString serialize();
 
     Q_SCRIPTABLE QString uuid() const;
 
     QString name() const;
     void setName(const QString &name);
 
     bool enabled() const;
     void setEnabled(bool enabled);
 
     int hours() const;
     void setHours(int hours);
 
     int minutes() const;
     void setMinutes(int minutes);
 
     int daysOfWeek() const;
     void setDaysOfWeek(int daysOfWeek);
 
     QString audioPath() const;
     void setAudioPath(QString path);
 
     int ringDuration() const;
     void setRingDuration(int ringDuration);
 
     int snoozeDuration() const;
     void setSnoozeDuration(int snoozeDuration);
 
     int snoozedLength() const;
 
     bool ringing() const;
 
     // ring the alarm now
     void ring();
 
     // get the next time the alarm will ring (unix time), or 0 if it will never ring
     quint64 nextRingTime();
 
 public Q_SLOTS:
     Q_SCRIPTABLE void dismiss();
     Q_SCRIPTABLE void snooze();
     Q_SCRIPTABLE void save(); // serialize and save to config
 
 Q_SIGNALS:
     Q_SCRIPTABLE void nameChanged();
     Q_SCRIPTABLE void enabledChanged();
     Q_SCRIPTABLE void hoursChanged();
     Q_SCRIPTABLE void minutesChanged();
     Q_SCRIPTABLE void daysOfWeekChanged();
     Q_SCRIPTABLE void audioPathChanged();
     Q_SCRIPTABLE void ringDurationChanged();
     Q_SCRIPTABLE void snoozeDurationChanged();
 
     Q_SCRIPTABLE void snoozedLengthChanged();
     Q_SCRIPTABLE void ringingChanged();
     Q_SCRIPTABLE void nextRingTimeChanged();
 
     // the time that the alarm is going to ring has changed
     Q_SCRIPTABLE void rescheduleRequested();
 
 private:
     void setSnoozedLength(int snoozedLength);
     void setRinging(bool ringing);
     void setNextRingTime(quint64 nextRingTime);
     void calculateNextRingTime();
 
     QUuid m_uuid;
 
     // -- properties that persist to storage: --
 
     // name of the alarm
     QString m_name;
 
     // whether the alarm is enabled
     bool m_enabled;
 
     // hour of the day the alarm rings at
     int m_hours;
 
     // minute of the hour the alarm rings at
     int m_minutes;
 
     // bitmask of the days of the week that the alarm rings (if zero, it rings once)
     int m_daysOfWeek;
 
     // the path to the audio file to ring
     QUrl m_audioPath;
 
     // the amount of time the alarm rings for, in minutes
     int m_ringDuration;
 
     // the amount of time the alarm adds when snoozed, in minutes
     int m_snoozeDuration;
 
     // the amount of time snoozing has added to the current ring, in seconds
     int m_snoozedLength = 0;
 
     // -- properties only relevant for the current state of the alarm (not persisted): --
 
     // whether the alarm is ringing
     bool m_ringing = false;
 
     // cache calculated next ring time (unix time)
     quint64 m_nextRingTime = 0;
 
     // saves the original ring time (without snoozing applied to it)
     quint64 m_originalRingTime = 0;
 
     // whether snooze just occurred
     bool m_justSnoozed;
 
     KNotification *m_notification = new KNotification{QStringLiteral("alarm"), KNotification::NotificationFlag::Persistent, this};
 
     QTimer *m_ringTimer = new QTimer(this);
 };