AirPods.h

//
// AirPodsWindows - AirPods Desktop User Experience Enhancement Program.
// Copyright (C) 2021-2022 SpriteOvO
//
// 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, see <https://www.gnu.org/licenses/>.
//

#pragma once

#include <optional>
#include <functional>

#include "Bluetooth.h"
#include "AppleCP.h"
#include "AAP.h"
#include "AAPManager.h"

namespace Core::AirPods {

//
// Structures
//

namespace Details {

struct BasicState {
    Battery battery;
    bool isCharging{false};

    bool operator==(const BasicState &rhs) const = default;
};
} // namespace Details

struct PodState : Details::BasicState {
    bool isInEar{false};

    bool operator==(const PodState &rhs) const = default;
};

struct CaseState : Details::BasicState {
    bool isBothPodsInCase{false};
    bool isLidOpened{false};

    bool operator==(const CaseState &rhs) const = default;
};

struct PodsState {
    PodState left, right;

    bool operator==(const PodsState &rhs) const = default;
};

struct State {
    Model model{Model::Unknown};
    PodsState pods;
    CaseState caseBox;
    QString displayName;
    
    // AAP Protocol states (for AirPods Pro and Max with ANC support)
    std::optional<AAP::NoiseControlMode> noiseControlMode;
    std::optional<AAP::ConversationalAwarenessState> conversationalAwareness;
    std::optional<AAP::PersonalizedVolumeState> personalizedVolume;
    std::optional<AAP::LoudSoundReductionState> loudSoundReduction;
    std::optional<bool> automaticEarDetectionEnabled;
    std::optional<uint8_t> adaptiveTransparencyLevel;

    bool operator==(const State &rhs) const = default;
};

//
// Classes
//

namespace Details {

class Advertisement
{
public:
    using AddressType = decltype(Bluetooth::AdvertisementWatcher::ReceivedData::address);

    struct AdvState : AirPods::State {
        Side side;
    };

    static bool IsDesiredAdv(const Bluetooth::AdvertisementWatcher::ReceivedData &data);

    Advertisement(const Bluetooth::AdvertisementWatcher::ReceivedData &data);

    int16_t GetRssi() const;
    const auto &GetTimestamp() const;
    AddressType GetAddress() const;
    std::vector<uint8_t> GetDesensitizedData() const;
    const AdvState &GetAdvState() const;

private:
    Bluetooth::AdvertisementWatcher::ReceivedData _data;
    AppleCP::AirPods _protocol;
    AdvState _state;

    const std::vector<uint8_t> &GetMfrData() const;
};

// AirPods use Random Non-resolvable device addresses for privacy reasons. This means we
// can't "Remember" the user's AirPods by any device property. Here we track our desired
// devices in some non-elegant ways, but obviously it is sometimes unreliable.
//
class StateManager
{
public:
    struct UpdateEvent {
        std::optional<State> oldState;
        State newState;
    };

    StateManager();

    std::optional<State> GetCurrentState() const;

    std::optional<UpdateEvent> OnAdvReceived(Advertisement adv);
    void Disconnect();

    void OnRssiMinChanged(int16_t rssiMin);

private:
    using Clock = std::chrono::steady_clock;
    using Timestamp = std::chrono::time_point<Clock>;

    mutable std::mutex _mutex;

    Helper::Timer _lostTimer;
    Helper::Sides<Helper::Timer> _stateResetTimer;
    Helper::Sides<std::optional<std::pair<Advertisement, Timestamp>>> _adv;
    std::optional<State> _cachedState;
    int16_t _rssiMin{std::numeric_limits<int16_t>::max()};

    bool IsPossibleDesiredAdv(const Advertisement &adv) const;
    void UpdateAdv(Advertisement adv);
    std::optional<UpdateEvent> UpdateState();
    void ResetAll();

    void DoLost();
    void DoStateReset(Side side);
};
} // namespace Details

class Manager
{
public:
    Manager();

    void StartScanner();
    void StopScanner();

    void OnRssiMinChanged(int16_t rssiMin);
    void OnAutomaticEarDetectionChanged(bool enable);
    void OnBoundDeviceAddressChanged(uint64_t address);
    void OnConversationalAwarenessChanged(bool enable);
    void OnConversationalAwarenessVolumePercentChanged(uint8_t percent);
    void OnPersonalizedVolumeChanged(bool enable);
    void OnLoudSoundReductionChanged(bool enable);
    void OnAdaptiveTransparencyLevelChanged(uint8_t level);
    void OnNoiseControlModeChanged(AAP::NoiseControlMode mode);

    // AAP Protocol features
    bool SetNoiseControlMode(AAP::NoiseControlMode mode);
    std::optional<AAP::NoiseControlMode> GetNoiseControlMode() const;
    bool SetConversationalAwareness(bool enable);
    std::optional<AAP::ConversationalAwarenessState> GetConversationalAwarenessState() const;
    bool SetPersonalizedVolume(bool enable);
    std::optional<AAP::PersonalizedVolumeState> GetPersonalizedVolumeState() const;
    bool SetLoudSoundReduction(bool enable);
    std::optional<AAP::LoudSoundReductionState> GetLoudSoundReductionState() const;
    bool SetAdaptiveTransparencyLevel(uint8_t level);
    std::optional<uint8_t> GetAdaptiveTransparencyLevel() const;
    bool SetAdaptiveNoiseLevel(uint8_t level);
    bool IsAAPConnected() const;

    // Head tracking
    bool StartHeadTracking();
    bool StopHeadTracking();
    bool IsHeadTrackingActive() const;

    // Check if the model supports ANC features
    static bool SupportsANC(Model model);

private:
    std::mutex _mutex;
    Bluetooth::AdvertisementWatcher _adWatcher;
    Details::StateManager _stateMgr;
    std::optional<Bluetooth::Device> _boundDevice;
    std::optional<Model> _modelOverride;
    QString _deviceName;
    bool _deviceConnected{false};
    bool _automaticEarDetection{false};
    bool _conversationalAwarenessEnabled{false};
    uint8_t _conversationalAwarenessVolumePercent{40};
    bool _personalizedVolumeEnabled{false};
    bool _loudSoundReductionEnabled{false};
    uint8_t _adaptiveTransparencyLevel{25};
    std::optional<AAP::NoiseControlMode> _currentNoiseControlMode;
    
    // AAP Manager for L2CAP protocol communication
    AAP::Manager _aapMgr;

    void OnBoundDeviceConnectionStateChanged(Bluetooth::DeviceState state);
    void OnStateChanged(Details::StateManager::UpdateEvent updateEvent);
    void OnLidOpened(bool opened);
    void OnBothInEar(bool isBothInEar);
    bool OnAdvertisementReceived(const Bluetooth::AdvertisementWatcher::ReceivedData &data);
    void OnAdvWatcherStateChanged(
        Bluetooth::AdvertisementWatcher::State state, const std::optional<std::string> &optError);
    
    // AAP callbacks
    void OnNoiseControlModeNotification(AAP::NoiseControlMode mode);
    void OnConversationalAwarenessStateChanged(AAP::ConversationalAwarenessState state);
    void OnPersonalizedVolumeStateChanged(AAP::PersonalizedVolumeState state);
    void OnLoudSoundReductionStateChanged(AAP::LoudSoundReductionState state);
    void OnAdaptiveTransparencyLevelNotification(uint8_t level);
    void OnSpeakingLevelChanged(AAP::SpeakingLevel level);
    void OnEarDetectionChanged(AAP::EarStatus primary, AAP::EarStatus secondary);
    void OnHeadTrackingData(AAP::HeadTrackingData data);
    void OnAAPConnected();
    void OnAAPDisconnected();
    void SetupAAPCallbacks();
    void ConnectAAP();
};

std::vector<Core::Bluetooth::Device> GetDevices();

} // namespace Core::AirPods