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>
#include "IEventHandler.h"
 
// https://stackoverflow.com/questions/295120
#if defined(__GNUC__) || defined(__clang__)
  #define ACE_BUTTON_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
  #define ACE_BUTTON_DEPRECATED __declspec(deprecated)
#else
  #pragma message("WARNING: Implement ACE_BUTTON_DEPRECATED for this compiler")
  #define ACE_BUTTON_DEPRECATED
#endif
 
namespace ace_button {
 
class AceButton;
 
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;
 
    static const uint16_t kHeartBeatInterval = 5000;
 
    // 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 kFeatureHeartBeat = 0x200;
 
    static const FeatureFlagType kInternalFeatureIEventHandler = 0x8000;
 
    static const FeatureFlagType kFeatureSuppressAll = (
        kFeatureSuppressAfterClick
        | kFeatureSuppressAfterDoubleClick
        | kFeatureSuppressAfterLongPress
        | kFeatureSuppressAfterRepeatPress
        | kFeatureSuppressClickBeforeDoubleClick);
 
    typedef void (*EventHandler)(AceButton* button, uint8_t eventType,
        uint8_t buttonState);
 
    ButtonConfig() = default;
 
    #if ! defined(ARDUINO_ARCH_AVR)
      virtual ~ButtonConfig() = default;
    #endif
 
    uint16_t getDebounceDelay() const { return mDebounceDelay; }
 
    uint16_t getClickDelay() const { return mClickDelay; }
 
    uint16_t getDoubleClickDelay() const {
      return mDoubleClickDelay;
    }
 
    uint16_t getLongPressDelay() const {
      return mLongPressDelay;
    }
 
    uint16_t getRepeatPressDelay() const {
      return mRepeatPressDelay;
    }
 
    uint16_t getRepeatPressInterval() const {
      return mRepeatPressInterval;
    }
 
    uint16_t getHeartBeatInterval() const {
      return mHeartBeatInterval;
    }
 
    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;
    }
 
    void setHeartBeatInterval(uint16_t heartBeatInterval) {
      mHeartBeatInterval = heartBeatInterval;
    }
 
    // 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 int readButton(uint8_t pin) {
      return digitalRead(pin);
    }
 
    // These methods provide access to various feature flags that control the
    // functionality of the AceButton.
 
    bool isFeature(FeatureFlagType features) const {
      return mFeatureFlags & features;
    }
 
    void setFeature(FeatureFlagType features) {
      mFeatureFlags |= features;
    }
 
    void clearFeature(FeatureFlagType features) {
      mFeatureFlags &= ~features;
    }
 
    void resetFeatures() {
      // NOTE: If any additional kInternalFeatureXxx flag is added, it must be
      // added here like this:
      // mFeatureFlags &= (kInternalFeatureIEventHandler | kInternalFeatureXxx)
      mFeatureFlags &= kInternalFeatureIEventHandler;
    }
 
    // EventHandler
 
    EventHandler getEventHandler() const ACE_BUTTON_DEPRECATED {
      return reinterpret_cast<EventHandler>(mEventHandler);
    }
 
    void dispatchEvent(AceButton* button, uint8_t eventType,
        uint8_t buttonState) const {
 
      if (! mEventHandler) return;
 
      if (isFeature(kInternalFeatureIEventHandler)) {
        IEventHandler* eventHandler =
            reinterpret_cast<IEventHandler*>(mEventHandler);
        eventHandler->handleEvent(button, eventType, buttonState);
      } else {
        EventHandler eventHandler =
            reinterpret_cast<EventHandler>(mEventHandler);
        eventHandler(button, eventType, buttonState);
      }
    }
 
    void setEventHandler(EventHandler eventHandler) {
      mEventHandler = reinterpret_cast<void*>(eventHandler);
      clearFeature(kInternalFeatureIEventHandler);
    }
 
    void setIEventHandler(IEventHandler* eventHandler) {
      mEventHandler = eventHandler;
      setFeature(kInternalFeatureIEventHandler);
    }
 
    static ButtonConfig* getSystemButtonConfig() {
      return &sSystemButtonConfig;
    }
 
  private:
    static ButtonConfig sSystemButtonConfig;
 
    // Disable copy-constructor and assignment operator
    ButtonConfig(const ButtonConfig&) = delete;
    ButtonConfig& operator=(const ButtonConfig&) = delete;
 
    void* mEventHandler = nullptr;
 
    FeatureFlagType mFeatureFlags = 0;
 
    uint16_t mDebounceDelay = kDebounceDelay;
    uint16_t mClickDelay = kClickDelay;
    uint16_t mDoubleClickDelay = kDoubleClickDelay;
    uint16_t mLongPressDelay = kLongPressDelay;
    uint16_t mRepeatPressDelay = kRepeatPressDelay;
    uint16_t mRepeatPressInterval = kRepeatPressInterval;
    uint16_t mHeartBeatInterval = kHeartBeatInterval;
};
 
}
#endif