ButtonConfig.h

/*
MIT License

Copyright (c) 2018 Brian T. Park

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

#ifndef ACE_BUTTON_BUTTON_CONFIG_H
#define ACE_BUTTON_BUTTON_CONFIG_H

#include <Arduino.h>

// TODO: Verify if this is actually needed. The program size seems to be
// identical with or without it on the Arduino IDE (which uses gcc).
#define ACE_BUTTON_INLINE __attribute__((always_inline))

namespace ace_button {

class AceButton;
class TimingStats;

class ButtonConfig {
  public:
    // Various timing constants, in milliseconds.
    //
    // Note that the timing constants are stored as uint16_t (2
    // bytes) instead of unsigned long (4 bytes) which is the type returned by
    // the millis() system method. It turns out that we can store and perform
    // all timing calculations using uint16_t without ill effect, as long as the
    // polling of AceButton::check() happens more frequently than the rollover
    // time of a uint16_t (i.e. 65.536 seconds) and certain precautions (e.g.
    // AceButton::checkOrphanedClick()) are taken before a uint16_t rollover
    // happens. In theory, these additional precautions would be needed even if
    // an 'unsigned long' is used but almost no one does them because they
    // assume that their code won't be running continuously for the rollover
    // time of an 'unsigned long' (i.e. 49.7 days).

    static const uint16_t kDebounceDelay = 20;

    static const uint16_t kClickDelay = 200;

    static const uint16_t kDoubleClickDelay = 400;

    static const uint16_t kLongPressDelay = 1000;

    static const uint16_t kRepeatPressDelay = 1000;

    static const uint16_t kRepeatPressInterval = 200;

    // Various features controlled by feature flags.

    typedef uint16_t FeatureFlagType;

    static const FeatureFlagType kFeatureClick = 0x01;

    static const FeatureFlagType kFeatureDoubleClick = 0x02;

    static const FeatureFlagType kFeatureLongPress = 0x04;

    static const FeatureFlagType kFeatureRepeatPress = 0x08;

    static const FeatureFlagType kFeatureSuppressAfterClick = 0x10;

    static const FeatureFlagType kFeatureSuppressAfterDoubleClick = 0x20;

    static const FeatureFlagType kFeatureSuppressAfterLongPress = 0x40;

    static const FeatureFlagType kFeatureSuppressAfterRepeatPress = 0x80;

    static const FeatureFlagType kFeatureSuppressClickBeforeDoubleClick = 0x100;

    static const FeatureFlagType kFeatureSuppressAll =
        (kFeatureSuppressAfterClick |
        kFeatureSuppressAfterDoubleClick |
        kFeatureSuppressAfterLongPress |
        kFeatureSuppressAfterRepeatPress |
        kFeatureSuppressClickBeforeDoubleClick);

    typedef void (*EventHandler)(AceButton* button, uint8_t eventType,
        uint8_t buttonState);

    ButtonConfig() {}

    // These configuration methods are virtual so that they can be overriddden.
    // Subclasses can override at the class-level by defining a new virtual
    // function in the subclass, or by defining an instance variable and storing
    // the parameter with each instance of this class.

    uint16_t getDebounceDelay() { return mDebounceDelay; }

    uint16_t getClickDelay() { return mClickDelay; }

    uint16_t getDoubleClickDelay() {
      return mDoubleClickDelay;
    }

    uint16_t getLongPressDelay() {
      return mLongPressDelay;
    }

    uint16_t getRepeatPressDelay() {
      return mRepeatPressDelay;
    }

    uint16_t getRepeatPressInterval() {
      return mRepeatPressInterval;
    }

    void setDebounceDelay(uint16_t debounceDelay) {
      mDebounceDelay = debounceDelay;
    }

    void setClickDelay(uint16_t clickDelay) {
      mClickDelay = clickDelay;
    }

    void setDoubleClickDelay(uint16_t doubleClickDelay) {
      mDoubleClickDelay = doubleClickDelay;
    }

    void setLongPressDelay(uint16_t longPressDelay) {
      mLongPressDelay = longPressDelay;
    }

    void setRepeatPressDelay(uint16_t repeatPressDelay) {
      mRepeatPressDelay = repeatPressDelay;
    }

    void setRepeatPressInterval(uint16_t repeatPressInterval) {
      mRepeatPressInterval = repeatPressInterval;
    }

    // The getClock() and readButton() are external dependencies that normally
    // would be injected using separate classes, but in the interest of saving
    // RAM in an embedded environment, we expose them in this class instead.

    virtual unsigned long getClock() { return millis(); }

    virtual unsigned long getClockMicros() { return micros(); }

    virtual int readButton(uint8_t pin) {
      return digitalRead(pin);
    }

    // These methods return the various feature flags that control the
    // functionality of the AceButton.

    bool isFeature(FeatureFlagType features) ACE_BUTTON_INLINE {
      return mFeatureFlags & features;
    }

    void setFeature(FeatureFlagType features) ACE_BUTTON_INLINE {
      mFeatureFlags |= features;
    }

    void clearFeature(FeatureFlagType features) ACE_BUTTON_INLINE {
      mFeatureFlags &= ~features;
    }

    // EventHandler

    EventHandler getEventHandler() ACE_BUTTON_INLINE {
      return mEventHandler;
    }

    void setEventHandler(EventHandler eventHandler) ACE_BUTTON_INLINE {
      mEventHandler = eventHandler;
    }

    // TimingStats

    void setTimingStats(TimingStats* timingStats) {
      mTimingStats = timingStats;
    }

    TimingStats* getTimingStats() { return mTimingStats; }

    static ButtonConfig* getSystemButtonConfig() ACE_BUTTON_INLINE {
      return &sSystemButtonConfig;
    }

  protected:
    virtual void init() {
      mFeatureFlags = 0;
      mTimingStats = nullptr;
    }

  private:
    static ButtonConfig sSystemButtonConfig;

    // Disable copy-constructor and assignment operator
    ButtonConfig(const ButtonConfig&) = delete;
    ButtonConfig& operator=(const ButtonConfig&) = delete;

    EventHandler mEventHandler = nullptr;

    FeatureFlagType mFeatureFlags = 0;

    TimingStats* mTimingStats = nullptr;

    uint16_t mDebounceDelay = kDebounceDelay;
    uint16_t mClickDelay = kClickDelay;
    uint16_t mDoubleClickDelay = kDoubleClickDelay;
    uint16_t mLongPressDelay = kLongPressDelay;
    uint16_t mRepeatPressDelay = kRepeatPressDelay;
    uint16_t mRepeatPressInterval = kRepeatPressInterval;
};

}
#endif