using acebutton in a class with a non static callback function

[patrickwasp]

I'm trying to add a button to a user interface class with a non-static callback so that UI elements can be updated on button presses. What's the best way to refactor the code below to use a non-static class method as the callback function for a button event?

#include <AceButton.h>
using namespace ace_button;

const int BUTTON_PIN = 6;
const int LED_PIN = LED_BUILTIN;
const int LED_ON = HIGH;
const int LED_OFF = LOW;


class UserInterface
{
  public:
    UserInterface();
    int button_presses;
    void NonStaticFunction();
    void Setup();
    void Update();
  private:
    AceButton *_button;
  
};

UserInterface::UserInterface()
{
  _button = new AceButton(BUTTON_PIN);
}

void UserInterface::NonStaticFunction()
{
  button_presses += 1;
}

void UserInterface::Update()
{
 _button->check(); 
}

UserInterface ui;

// An object that handles the event.
class ButtonHandler: public IEventHandler {
  public:
    void handleEvent(AceButton* /* button */, uint8_t eventType,
        uint8_t buttonState) override {

      Serial.print(F("handleEvent(): eventType: "));
      Serial.print(eventType);
      Serial.print(F("; buttonState: "));
      Serial.println(buttonState);

      switch (eventType) {
        case AceButton::kEventPressed:
          digitalWrite(LED_PIN, LED_ON);
          break;
        case AceButton::kEventReleased:
          digitalWrite(LED_PIN, LED_OFF);
          // how could this be refactored to not use a global variable
          ui.NonStaticFunction();
          Serial.println(ui.button_presses);
          break;
      }
    }
};

ButtonHandler handleEvent;

void UserInterface::Setup()
{
  ButtonConfig* buttonConfig = _button->getButtonConfig();
  buttonConfig->setIEventHandler(&handleEvent);
}

void setup() {
  delay(1000);
  Serial.begin(115200);
  while (! Serial);
  Serial.println(F("setup(): begin"));
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);

  ui.Setup();
  
  Serial.println(F("setup(): ready"));
}

void loop() {
  ui.Update();
}

[bxparks]

(Edit: Added some missing words in my initial post for clarity, inside [])

There are many ways to avoid passing ui as a global variable. The appropriate solution will depend on the complexity of the rest of the application. Here are a few off the top of my head:

1. Use constructor dependency injection to pass ui into ButtonHandler:

class ButtonHandler : public IButtonHandler {
  public:
      ButtonHandler(UserInterface* ui) : _ui(ui) {
       ...
    }

  private:
    Userinterface* _ui;
};

2. Make UserInterface implement the IButtonHandler interface directly, and use setIEventHandler() to inject itself into the AceButton:

class UserInterface : public IButtonHandler {
  public:
    void Setup() {
      _button->getButtonConfig()->setIEventHandler(this);
    }

    void handleEvent(...) override {
       ...
       NonStaticFunction();
       ....
    }
};

I'm not a huge fan of this type of design because I find code [with] circular dependencies hard to understand, maintain, and refactor in the future.

3. When using OOP, I normally like decoupling my classes as much as possible. So instead of having UserInterface create the AceButton on the heap, create the AceButton outside the UserInterface, and pass it in through dependency injection, something like this:

class UserInterface {
  public:
    UserInterface(AceButton *button) { ... }
};

class ButtonHandler : public IButtonHandler {
  public:
     ButtonHandler(UserInterface* ui) { ... }
};

AceButton button(PIN);
UserInterface ui(button);
ButtonHandler handler(ui);

void setup() {
  button->getButtonConfig()->setIButtonHandler(handler);
  ...
}

As a side-effect, this avoids creating AceButton on the heap. I just don't like creating anything on the heap on a microcontroller environment without a hardware memory manager, to avoid heap fragmentation. Although you [can] avoid the heap problem by creating the AceButton by-value, instead of calling new AceButton in UserInterface.

There are proabbly other ways of designing this, but I hope this gives you some ideas.

[bennett-dahl]

hey @bxparks I feel like my question is very close to this one, but seemingly a bit more simple. I figured posting it here would make more sense than a new question. Unfortunately, I'm struggling to use this information or other info about the right way to do this. I am trying to refactor my project into a separate classes/files primarily so that I can more easily build upon it later.

My main.cpp

#include <Lights.h>
#include <Buttons.h>
#include <AceButton.h>

Lights lights;           // declare lights object
Buttons buttons(lights); // declare button object

void setup()
{
  buttons.init(); // initialize buttons
  lights.init();  // initialize and clear all pixels/strips
}

void loop()
{
  buttons.check();
}

My Buttons.h

#ifndef BUTTONS_H
#define BUTTONS_H

#include <Arduino.h>
#include <AceButton.h>
#include <Lights.h>
using namespace ace_button;

#define buttonPin1 4
#define buttonPin2 3

class Buttons
{
private:
    ButtonConfig *_button1Config;
    AceButton *_button1;
    Lights &lights;
public:
    // Functions
    Buttons(Lights &lights); // constructor
    ~Buttons();              // destructor
    void init();                // initilizer function configure and setup pins. This will all execute in the 'setup()' on the arduino
    void check();            // check buttons, to be placed in the "loop section"
    void handleButton1Event(AceButton *button, uint8_t eventType, uint8_t buttonState);
};

#endif

And my Buttons.cpp

#include "Buttons.h"

Buttons::Buttons(Lights &lights) : lights(lights)
{
    _button1 = new AceButton(buttonPin1);
    _button1Config = _button1->getButtonConfig();
}; // constructor function

Buttons::~Buttons(){}; // destructor function

void Buttons::init()
{ 
    _button1Config->setEventHandler(handleButton1Event);
    _button1Config->setFeature(ButtonConfig::kFeatureClick);

    // setup button1
    pinMode(buttonPin1, INPUT_PULLUP);
    _button1->setButtonConfig(_button1Config);
    _button1->init(buttonPin1, HIGH);
}

void Buttons::check()
{
    _button1->check();
}

void Buttons::handleButton1Event(AceButton *button, uint8_t eventType, uint8_t buttonState)
{
    switch (eventType)
    {
    case AceButton::kEventClicked:
        lights.handleClickButton1();
        break;
    }
}

My issue is coming down to how I'm passing the handleButton1Event to the setEventHandler. I've been able to discern that because it is a non-static member function, it is a different type than I should be passing, but I'm not understanding the right way to do this. And it seems like this answer SHOULD be the one to clarify it for me...but I'm just not quite getting it.

[bxparks]

My initial impression is that you are making this more complicated than it needs to be. Most of the examples that I wrote in the examples/ directory uses the procedural EventHandler function pointer. All my personal projects use this.

But if you want to go down the road that you are on, then you need to realize the difference between EventHandler and IEventHandler. So your Buttons class needs to inherit from IEventHandler.