AudioBoardStream.h

#pragma once
 
#include "AudioToolsConfig.h"
#include "AudioTools/AudioLibs/I2SCodecStream.h"
#include "AudioTools/CoreAudio/AudioActions.h"
 
namespace audio_tools {
 
class AudioBoardStream : public I2SCodecStream {
  struct AudioBoardAction : public AudioActions::Action {
    AudioBoardAction(AudioBoard &board, AudioDriverKey key) {
      this->key = key;
      this->p_board = &board;
    }
    AudioDriverKey key;
    AudioBoard *p_board;
    int id() override { return key | 0x400; }
    bool readValue() override { return p_board->isKeyPressed(key); }
  };
 
 public:
  AudioBoardStream(audio_driver::AudioBoard &board) : I2SCodecStream(board) {
    // pin mode already set up by driver library
    actions.setPinMode(false);
    // use the AudioBoard 
    actions.setReadCallback([this](int pin) { return this->digitalRead(pin); });
  }
 
  bool begin() override { return I2SCodecStream::begin(); }
 
  bool begin(I2SCodecConfig cfg) override { return I2SCodecStream::begin(cfg); }
 
  void processActions() {
    //  TRACED();
    actions.processActions();
    delay(1);
  }
 
 
  void addAction(AudioDriverKey key, void (*action)(bool, int, void *),
                 void *ref = nullptr) {
      AudioBoardAction *abo = new AudioBoardAction(board(), key);
      abo->actionOn = action;
      abo->ref = (ref == nullptr) ? this : ref; 
      actions.add(*abo);            
  }
 
  void addAction(AudioDriverKey key, void (*actionOn)(bool, int, void *),
                void (*actionOff)(bool, int, void *),
                void *ref = nullptr) {
 
      AudioBoardAction *abo = new AudioBoardAction(board(), key);
      abo->actionOn = actionOn;
      abo->actionOn = actionOff;
      abo->ref = (ref == nullptr) ? this : ref; 
      actions.add(*abo);            
    }
 
  void addAction(int pin, void (*action)(bool, int, void *),
                 void *ref = nullptr) {
    TRACEI();
    // determine logic from config
    AudioActions::ActiveLogic activeLogic = getActionLogic(pin);
    actions.add(pin, action, activeLogic, ref == nullptr ? this : ref);
  }
 
  void addAction(int pin, void (*action)(bool, int, void *),
                 AudioActions::ActiveLogic activeLogic, void *ref = nullptr) {
    TRACEI();
    actions.add(pin, action, activeLogic, ref == nullptr ? this : ref);
  }
 
  AudioActions &audioActions() { return actions; }
 
  AudioActions &getActions() { return actions; }
 
  void incrementVolume(float inc) {
    float current_volume = getVolume();
    float new_volume = current_volume + inc;
    LOGI("incrementVolume: %f -> %f", current_volume, new_volume);
    setVolume(new_volume);
  }
 
  static void actionVolumeUp(bool, int, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    self->incrementVolume(+self->actionVolumeIncrementValue());
  }
 
  static void actionVolumeDown(bool, int, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    self->incrementVolume(-self->actionVolumeIncrementValue());
  }
 
  static void actionStartStop(bool, int, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    self->active = !self->active;
    self->setActive(self->active);
  }
 
  static void actionStart(bool, int, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    self->active = true;
    self->setActive(self->active);
  }
 
  static void actionStop(bool, int, void *ref) {
    TRACEI();
    AudioBoardStream *self = (AudioBoardStream *)ref;
    self->active = false;
    self->setActive(self->active);
  }
 
  static void actionHeadphoneDetection(bool, int, void *ref) {
    AudioBoardStream *self = (AudioBoardStream *)ref;
    if (self->pinHeadphoneDetect() >= 0) {
      // detect changes
      bool isConnected = self->headphoneStatus();
      if (self->headphoneIsConnected != isConnected) {
        self->headphoneIsConnected = isConnected;
 
        // update if things have stabilized
        bool powerActive = !isConnected;
        LOGW("Headphone jack has been %s",
             isConnected ? "inserted" : "removed");
        self->setSpeakerActive(powerActive);
      }
    }
    delay(1);
  }
 
  GpioPin pinAuxin() { return getPinID(PinFunction::AUXIN_DETECT); }
 
  GpioPin pinHeadphoneDetect() {
    return getPinID(PinFunction::HEADPHONE_DETECT);
  }
 
  GpioPin pinPaEnable() { return getPinID(PinFunction::PA); }
 
  //   /**
  //    * @brief  Get the gpio number for adc detection
  //    *
  //    * @return  -1      non-existent
  //    *          Others  gpio number
  //    */
  //   GpioPin pinAdcDetect() { return getPin(AUXIN_DETECT); }
 
  GpioPin pinInputRec() { return getPinID(PinFunction::KEY, 1); }
 
  GpioPin pinInputMode() { return getPinID(PinFunction::KEY, 2); }
 
  GpioPin pinInputSet() { return getPinID(PinFunction::KEY, 4); }
 
  GpioPin pinInputPlay() { return getPinID(PinFunction::KEY, 3); }
 
  GpioPin pinVolumeUp() { return getPinID(PinFunction::KEY, 6); }
 
  GpioPin pinVolumeDown() { return getPinID(PinFunction::KEY, 5); }
 
  GpioPin pinLed(int idx) { return getPinID(PinFunction::LED, idx); }
 
  void setSpeakerActive(bool active) { setPAPower(active); }
 
  bool headphoneStatus() {
    int headphoneGpioPin = pinHeadphoneDetect();
    return headphoneGpioPin > 0 ? !digitalRead(headphoneGpioPin) : false;
  }
 
  void setActive(bool active) { setMute(!active); }
 
  void addStartStopAction() {
    // pin conflicts for pinInputMode() with the SD CS pin for AIThinker and
    // buttons
    int sd_cs = getSdCsPin();
    int input_mode = pinInputMode();
    if (input_mode != -1 && (input_mode != sd_cs || !cfg.sd_active)) {
      LOGD("actionInputMode")
      addAction(input_mode, actionStartStop);
    }
  }
 
  void addVolumeActions() {
    // pin conflicts with SD Lyrat SD CS GpioPin and buttons / Conflict on
    // Audiokit V. 2957
    int sd_cs = getSdCsPin();
    int vol_up = pinVolumeUp();
    int vol_down = pinVolumeDown();
    if ((vol_up != -1 && vol_down != -1) &&
        (!cfg.sd_active || (vol_down != sd_cs && vol_up != sd_cs))) {
      LOGD("actionVolumeDown")
      addAction(vol_down, actionVolumeDown);
      LOGD("actionVolumeUp")
      addAction(vol_up, actionVolumeUp);
    } else {
      LOGW("Volume Buttons ignored because of conflict: %d ", pinVolumeDown());
    }
  }
 
  void addHeadphoneDetectionAction() {
    // pin conflicts with AIThinker A101: key6 and headphone detection
    int head_phone = pinHeadphoneDetect();
    if (head_phone != -1 && (getPinID(PinFunction::KEY, 6) != head_phone)) {
      actions.add(head_phone, actionHeadphoneDetection,
                  AudioActions::ActiveChange, this);
    }
  }
 
  void addDefaultActions() {
    TRACEI();
    addHeadphoneDetectionAction();
    addStartStopAction();
    addVolumeActions();
  }
 
  void setActionVolumeIncrementValue(float value) {
    action_increment_value = value;
  }
 
  float actionVolumeIncrementValue() { return action_increment_value; }
 
  bool isKeyPressed(int key) {
    if (!board()) return false;
    return board().isKeyPressed(key);
  }
 
 protected:
  AudioActions actions;
  bool headphoneIsConnected = false;
  bool active = true;
  float action_increment_value = 0.02;
 
  int getSdCsPin() {
    static GpioPin sd_cs = -2;
    // execute only once
    if (sd_cs != -2) return sd_cs;
 
    auto sd_opt = getPins().getSPIPins(PinFunction::SD);
    if (sd_opt) {
      sd_cs = sd_opt.value().cs;
    } else {
      // no spi -> no sd
      LOGI("No sd defined -> sd_active=false")
      cfg.sd_active = false;
      sd_cs = -1;
    }
    return sd_cs;
  }
 
  AudioActions::ActiveLogic getActionLogic(int pin) {
    auto opt = board().getPins().getPin(pin);
    PinLogic logic = PinLogic::Input;
    if (opt) logic = opt.value().pin_logic;
    switch (logic) {
      case PinLogic::Input:
      case PinLogic::InputActiveLow:
        return AudioActions::ActiveLow;
      case PinLogic::InputActiveHigh:
        return AudioActions::ActiveHigh;
      case PinLogic::InputActiveTouch:
        return AudioActions::ActiveTouch;
      default:
        return AudioActions::ActiveLow;
    }
  }
};
 
}  // namespace audio_tools