context_type.hpp

Go to the documentation of this file.

#ifndef CONTEXT_TYPE_H
#define CONTEXT_TYPE_H
 
#include <cstdint>
#include <type_traits>
 
#include "src/system/bsp/text_out.h"
 
#include "src/modes/include/hardware/keystore.hpp"
#include "src/modes/include/hardware/lamp_type.hpp"
#include "src/modes/include/tools.hpp"
#include "src/modes/include/default_config.hpp"
 
namespace lampda::modes {
 
template<typename NewLocalMode> static auto context_as(auto& ctx) { return ctx.template context_as<NewLocalMode>(); }
 
template<typename LocalBasicMode, typename ModeManager> struct ContextTy
{
  friend ModeManager;
 
  using SelfTy = ContextTy<LocalBasicMode, ModeManager>;
  using ModeManagerTy = ModeManager;
  using LocalModeTy = LocalBasicMode;
  using StateTy = StateTyOf<LocalModeTy>;
 
  static constexpr bool isMode = is_mode<LocalModeTy>;
 
  static constexpr bool isModeManager = std::is_same_v<LocalModeTy, ModeManagerTy>;
  static constexpr bool isGroupManager = false;
 
  // useful proxies (exposes mode properties)
  static constexpr bool hasSunsetAnimation = LocalModeTy::hasSunsetAnimation; 
  static constexpr bool hasBrightCallback = LocalModeTy::hasBrightCallback;   
  static constexpr bool hasSystemCallbacks = LocalModeTy::hasSystemCallbacks; 
  static constexpr bool requireUserThread = LocalModeTy::requireUserThread;   
  static constexpr bool hasCustomRamp = LocalModeTy::hasCustomRamp;           
  static constexpr bool hasButtonCustomUI = LocalModeTy::hasButtonCustomUI;   
 
  // more proxies (exposes tables of mode properties)
  static constexpr auto everySunsetCallback = LocalModeTy::everySunsetCallback;       
  static constexpr auto everyBrightCallback = LocalModeTy::everyBrightCallback;       
  static constexpr auto everySystemCallbacks = LocalModeTy::everySystemCallbacks;     
  static constexpr auto everyRequireUserThread = LocalModeTy::everyRequireUserThread; 
  static constexpr auto everyCustomRamp = LocalModeTy::everyCustomRamp;               
  static constexpr auto everyButtonCustomUI = LocalModeTy::everyButtonCustomUI;       
 
  //
  // constructors
  //
 
  template<typename NewLocalMode> auto LMBD_INLINE context_as()
  {
    return ContextTy<NewLocalMode, ModeManagerTy>(modeManager);
  }
 
  ContextTy(ModeManagerTy& modeManager) :
    state {modeManager.template getStateOf<LocalModeTy>()},
    lamp {modeManager.lamp},
    modeManager {modeManager}
  {
  }
 
  ContextTy() = delete;                            
  ContextTy(const ContextTy&) = delete;            
  ContextTy& operator=(const ContextTy&) = delete; 
 
  //
  // manager calls
  //
 
  auto LMBD_INLINE next_group()
  {
    if constexpr (LocalModeTy::isGroupManager)
    {
      LocalModeTy::next_group(*this);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.next_group();
    }
  }
 
  auto LMBD_INLINE next_mode()
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      LocalModeTy::next_mode(*this);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.next_mode();
    }
  }
 
  bool LMBD_INLINE jump_to_favorite(uint8_t which_one, bool shouldSaveLastActiveIndex)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return LocalModeTy::jump_to_favorite(*this, which_one, shouldSaveLastActiveIndex);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.jump_to_favorite(which_one, shouldSaveLastActiveIndex);
    }
  }
 
  bool LMBD_INLINE exit_favorite_group(auto nextActiveIndex)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return LocalModeTy::exit_favorite_group(*this, nextActiveIndex);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.exit_favorite_group(nextActiveIndex);
    }
  }
 
  auto LMBD_INLINE set_favorite_now(uint8_t which_one = 0)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return LocalModeTy::set_favorite_now(*this, which_one);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.set_favorite_now(which_one);
    }
  }
 
  auto LMBD_INLINE delete_favorite_now()
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return LocalModeTy::delete_favorite_now(*this);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.delete_favorite_now();
    }
  }
 
  auto LMBD_INLINE handle_scroll_modes(const uint32_t holdDuration)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return LocalModeTy::handle_scroll_modes(*this, holdDuration);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.handle_scroll_modes(holdDuration);
    }
  }
 
  auto LMBD_INLINE enter_hidden_group(const uint8_t hiddenGroupIndex)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return LocalModeTy::enter_hidden_group(*this, hiddenGroupIndex);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.enter_hidden_group(hiddenGroupIndex);
    }
  }
 
  auto LMBD_INLINE overlay_animate_ramp(float holdDuration,
                                        float stepSize,
                                        const colors::PaletteTy& palette,
                                        const uint32_t timeout = 0)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return modeManager.overlay_animate_ramp(*this, holdDuration, stepSize, palette, timeout);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.overlay_animate_ramp(holdDuration, stepSize, palette, timeout);
    }
  }
 
  auto LMBD_INLINE overlay_animate_ramp(uint8_t progress, const colors::PaletteTy& palette, const uint32_t timeout = 0)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return modeManager.overlay_animate_ramp(*this, progress, palette, timeout);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.overlay_animate_ramp(progress, palette, timeout);
    }
  }
 
  auto LMBD_INLINE get_groups_count() { return modeManager.nbGroupsTotal; }
  auto LMBD_INLINE get_accessible_groups_count() { return modeManager.nbAccessibleGroups; }
  auto LMBD_INLINE get_hidden_groups_count() { return modeManager.hiddenGroupCount; }
 
  auto LMBD_INLINE get_modes_count()
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return modeManager.get_modes_count(*this);
    }
    else
    {
      auto manager = modeManager.get_context();
      return manager.get_modes_count();
    }
  }
 
  //
  // getters / setters for activeIndex
  //
 
  uint8_t LMBD_INLINE get_active_group(uint8_t maxValueWrap = 255) const
  {
    uint8_t groupIndex = modeManager.activeIndex.groupIndex;
    return (groupIndex + 1) > maxValueWrap ? 0 : groupIndex;
  }
 
  uint8_t LMBD_INLINE set_active_group(uint8_t value, uint8_t maxValueWrap = 255)
  {
    if (value + 1 > maxValueWrap)
      value = 0;
 
    // signal that we are quitting the group
    quit_group();
    // enter a new group
    enter_group(value);
    return value;
  }
 
  uint8_t LMBD_INLINE get_active_mode(uint8_t maxValueWrap = 255) const
  {
    uint8_t modeIndex = modeManager.activeIndex.modeIndex;
    return (modeIndex + 1) > maxValueWrap ? 0 : modeIndex;
  }
 
  uint8_t LMBD_INLINE set_active_mode(uint8_t value, uint8_t maxValueWrap = 255)
  {
    if (value + 1 > maxValueWrap)
      value = 0;
 
    auto manager = modeManager.get_context();
 
    // cancel any blip
    // TODO: this should be in quit_mode
    manager.cancel_blip();
 
    // if next mode is the same as current one, add a blip to help user differenciate
    if (modeManager.activeIndex.modeIndex == value)
    {
      // This is not complete, there is no group check, so the blip will be visible sometimes on modes with the same
      // modeIndex in different groups
 
      // blip to indicate a mode change to the same mode
      manager.blip(100);
    }
 
    // signal that we are quitting the mode
    modeManager.quit_mode(manager);
    // switch mode
    modeManager.activeIndex.modeIndex = value;
    // signal that we entered a new mode
    modeManager.enter_mode(manager);
    return value;
  }
 
  uint8_t LMBD_INLINE get_active_custom_ramp() const { return modeManager.activeIndex.rampIndex; }
 
  uint8_t LMBD_INLINE set_active_custom_ramp(uint8_t value)
  {
    modeManager.activeIndex.rampIndex = value;
    return value;
  }
 
  uint8_t LMBD_INLINE get_active_custom_index() const { return modeManager.activeIndex.customIndex; }
 
  uint8_t LMBD_INLINE set_active_custom_index(uint8_t value)
  {
    modeManager.activeIndex.customIndex = value;
    return value;
  }
 
  //
  // store
  //
 
  template<typename Mode> StateTyOf<Mode>& get_state_of_mode() { return modeManager.template getStateOf<Mode>(); }
 
  template<typename Mode> static constexpr int get_group_id_of_mode()
  {
    return details::GroupIdFrom<Mode, typename ModeManagerTy::AllGroupsTy>;
  }
 
  template<typename Mode> static constexpr int get_mode_id()
  {
    return details::ModeIdFrom<Mode, typename ModeManagerTy::AllGroupsTy, get_group_id_of_mode<Mode>()>;
  }
 
  static constexpr int groupId = get_group_id_of_mode<LocalModeTy>();
 
  static constexpr int modeId = get_mode_id<LocalModeTy>();
 
  static constexpr auto prefix =
          (isModeManager ? store::PrefixValues::managerKeys :
                           (isMode ? store::PrefixValues::generalKeys : store::PrefixValues::privateKeys));
 
  using StoreEnum = StoreEnumOf<LocalModeTy>;
 
  using LocalStore = store::KeyStore<StoreEnum, groupId, modeId, prefix>;
 
  static constexpr bool hasStore = not std::is_same_v<StoreEnum, NoStoreHere>;
 
  template<StoreEnum _key, typename T> struct KeyProxy
  {
    static_assert(std::is_same_v<T, std::conditional_t<hasStore, T, NoStoreId>>,
                  "KeyProxy can not be used when no storeId has been defined!");
 
    static constexpr StoreEnum key = _key;
 
    T& local;
 
    inline void LMBD_INLINE setValue(T value)
    {
      local = value;
      LocalStore::template setValue<key, T>(value);
    };
 
    inline bool LMBD_INLINE getValue() { return LocalStore::template getValue<key, T>(local); }
 
    inline void LMBD_INLINE getValue(T defVal) { LocalStore::template getValue<key, T>(local, defVal); }
 
    inline bool LMBD_INLINE hasValue() { return LocalStore::template hasValue<key, T>(); }
 
    //
    // private API
    //
 
    inline void LMBD_INLINE forceSave() { LocalStore::template setValue<key, T>(local); }
 
    //
    // constructors
    //
 
    KeyProxy(T& local) : local {local} { getValue(); }
 
    KeyProxy() = delete;                           
    KeyProxy(const KeyProxy&) = delete;            
    KeyProxy& operator=(const KeyProxy&) = delete; 
 
    ~KeyProxy() { forceSave(); }
  };
 
  template<StoreEnum key, typename T = uint32_t>
  static auto LMBD_INLINE storageFor(LMBD_USED T& local) // requires storeId :)
  {
    if constexpr (hasStore)
    {
      return KeyProxy<key, T> {local};
    }
    else
    {
      return NoStoreId {};
    }
  }
 
  template<StoreEnum key, typename T = uint32_t> static bool LMBD_INLINE storageLoadOnly(LMBD_USED T& local)
  {
    return LocalStore::template getValue<key, T>(local);
  }
 
  template<StoreEnum key, typename T = uint32_t>
  static void LMBD_INLINE storageLoadOnly(LMBD_USED T& local, const T defaultValue)
  {
    LocalStore::template getValue<key, T>(local, defaultValue);
  }
 
  template<StoreEnum key, typename T = uint32_t> static void LMBD_INLINE storageSaveOnly(LMBD_USED T& local)
  {
    return LocalStore::template setValue<key, T>(local);
  }
 
  //
  // manager config
  //
 
  template<ConfigKeys key> void LMBD_INLINE set_config_bool(bool value)
  {
    auto ctx = modeManager.get_context();
    switch (key)
    {
      case ConfigKeys::rampSaturates:
        ctx.state.rampHandler.rampSaturates = value;
        break;
      case ConfigKeys::clearStripOnModeChange:
        ctx.state.clearStripOnModeChange = value;
        break;
      case ConfigKeys::customRampAnimEffect:
        ctx.state.rampHandler.animEffect = value;
        break;
      default:
        assert(false && "unsupported config key for booleans!");
        break;
    }
  }
 
  template<ConfigKeys key> void LMBD_INLINE set_config_u32(uint32_t value)
  {
    auto ctx = modeManager.get_context();
    switch (key)
    {
      case ConfigKeys::customRampStepSpeedMs:
        ctx.state.rampHandler.stepSpeed = value;
        break;
      case ConfigKeys::customRampAnimChoice:
        ctx.state.rampHandler.animChoice = value;
        break;
      default:
        assert(false && "unsupported config key for u32!");
        break;
    }
  }
 
  //
  // special effects
  //
 
  void blip(const uint32_t duration)
  {
    auto ctx = modeManager.get_context();
    // skip the next frames
    ctx.state.skipNextFrameEffect = ceil(duration / static_cast<float>(ctx.lamp.frameDurationMs));
    // turn off the output
    ctx.lamp.blip(duration);
  }
 
  void cancel_blip() const
  {
    auto ctx = modeManager.get_context();
    // cancel skip
    ctx.state.skipNextFrameEffect = 0;
    ctx.lamp.cancel_blip();
  }
 
  bool is_bliping() const
  {
    auto ctx = modeManager.get_context();
    return ctx.lamp.is_bliping();
  }
 
  void LMBD_INLINE skipFirstLedsForFrames(uint8_t amount, uint8_t count = 1)
  {
    auto ctx = modeManager.get_context();
    ctx.lamp.config.skipFirstLedsForAmount = amount;
    ctx.lamp.config.skipFirstLedsForEffect = count;
  }
 
  //
  // Binder for group and mode enter/quit
  //
 
  void LMBD_INLINE enter_group(const uint8_t value)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      LocalModeTy::enter_group(*this, value);
    }
    else
    {
      auto& manager = modeManager.get_context();
      return manager.enter_group(value);
    }
  }
 
  void LMBD_INLINE quit_group()
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      LocalModeTy::quit_group(*this);
    }
    else
    {
      auto& manager = modeManager.get_context();
      return manager.quit_group();
    }
  }
 
  void LMBD_INLINE enter_mode()
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      LocalModeTy::enter_mode(*this);
    }
    else
    {
      auto& manager = modeManager.get_context();
      return manager.enter_mode();
    }
  }
 
  void LMBD_INLINE quit_mode()
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      LocalModeTy::quit_mode(*this);
    }
    else
    {
      auto& manager = modeManager.get_context();
      return manager.quit_mode();
    }
  }
 
  //
  // quick bindings to \p LocalModeTy
  //
 
  void LMBD_INLINE loop() { LocalModeTy::loop(*this); }
 
  void LMBD_INLINE on_enter_mode()
  {
    if (hasStore)
    {
      LocalStore::template migrateStoreIfNeeded<LocalModeTy::storeId>();
    }
    LocalModeTy::on_enter_mode(*this);
  }
 
  void LMBD_INLINE on_exit_mode()
  {
    //
    LocalModeTy::on_exit_mode(*this);
  }
 
  void LMBD_INLINE sunset_update(LMBD_USED float progress)
  {
    if constexpr (LocalModeTy::hasSunsetAnimation)
    {
      LocalModeTy::sunset_update(*this, progress);
    }
  }
 
  void LMBD_INLINE brightness_update(LMBD_USED brightness_t brightness)
  {
    if constexpr (LocalModeTy::hasBrightCallback)
    {
      LocalModeTy::brightness_update(*this, brightness);
    }
  }
 
  void LMBD_INLINE custom_ramp_update(LMBD_USED uint8_t rampValue, uint32_t timeout = 0)
  {
    if constexpr (LocalModeTy::isGroupManager)
    {
      LocalModeTy::custom_ramp_update(*this, rampValue, timeout);
    }
    else if constexpr (LocalModeTy::hasCustomRamp)
    {
      LocalModeTy::custom_ramp_update(*this, rampValue);
    }
  }
 
  bool LMBD_INLINE custom_click(LMBD_USED uint8_t nbClick)
  {
    if constexpr (LocalModeTy::hasButtonCustomUI)
    {
      return LocalModeTy::custom_click(*this, nbClick);
    }
 
    return false;
  }
 
  bool LMBD_INLINE custom_hold(LMBD_USED uint8_t nbClickAndHold,
                               LMBD_USED bool isEndOfHoldEvent,
                               LMBD_USED uint32_t holdDuration)
  {
    if constexpr (LocalModeTy::hasButtonCustomUI)
    {
      return LocalModeTy::custom_hold(*this, nbClickAndHold, isEndOfHoldEvent, holdDuration);
    }
 
    return false;
  }
 
  void display_favorite_number_ramp(const uint8_t favoriteIndex,
                                    const uint8_t maxFavoriteIndex,
                                    const bool display = false,
                                    const uint32_t timeout = 0)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      modeManager.template display_favorite_number_ramp(*this, favoriteIndex, maxFavoriteIndex, display, timeout);
    }
    else
    {
      auto& manager = modeManager.get_context();
      manager.display_favorite_number_ramp(favoriteIndex, maxFavoriteIndex, display, timeout);
    }
  }
 
  template<bool displayFavoriteNumber = true>
  auto set_current_mode_as_favorite(uint8_t favoriteIndex, uint32_t displayTimeout_s = 0)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      modeManager.template set_current_mode_as_favorite<displayFavoriteNumber>(*this, favoriteIndex, displayTimeout_s);
    }
    else
    {
      auto& manager = modeManager.get_context();
      manager.set_current_mode_as_favorite<displayFavoriteNumber>(favoriteIndex, displayTimeout_s);
    }
  }
 
  auto get_number_of_allowed_favorites()
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return modeManager.template get_number_of_allowed_favorites(*this);
    }
    else
    {
      auto& manager = modeManager.get_context();
      return manager.get_number_of_allowed_favorites(*this);
    }
  }
 
  template<bool displayFavoriteNumber = true> auto LMBD_INLINE animate_favorite_pick(float holdDuration, float stepSize)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return modeManager.template animate_favorite_pick<displayFavoriteNumber>(*this, holdDuration, stepSize);
    }
    else
    {
      auto& manager = modeManager.get_context();
      return manager.template animate_favorite_pick<displayFavoriteNumber>(holdDuration, stepSize);
    }
  }
 
  template<bool displayFavoriteNumber = true>
  auto LMBD_INLINE animate_favorite_delete(float holdDuration, float stepSize)
  {
    if constexpr (LocalModeTy::isModeManager)
    {
      return modeManager.template animate_favorite_delete<displayFavoriteNumber>(*this, holdDuration, stepSize);
    }
    else
    {
      auto& manager = modeManager.get_context();
      return manager.template animate_favorite_delete<displayFavoriteNumber>(holdDuration, stepSize);
    }
  }
 
  auto LMBD_INLINE get_custom_ramp_default_value() { return LocalModeTy::get_custom_ramp_default_value(*this); }
 
  void LMBD_INLINE power_on_sequence()
  {
    if constexpr (LocalModeTy::hasSystemCallbacks)
    {
      LocalModeTy::power_on_sequence(*this);
    }
  }
 
  void LMBD_INLINE power_off_sequence()
  {
    if constexpr (LocalModeTy::hasSystemCallbacks)
    {
      LocalModeTy::power_off_sequence(*this);
    }
  }
 
  void LMBD_INLINE write_parameters()
  {
    if constexpr (LocalModeTy::hasSystemCallbacks)
    {
      LocalModeTy::write_parameters(*this);
    }
  }
 
  void LMBD_INLINE read_parameters()
  {
    if constexpr (LocalModeTy::hasSystemCallbacks)
    {
      LocalModeTy::read_parameters(*this);
    }
  }
 
  bool LMBD_INLINE should_spawn_thread() { return LocalModeTy::requireUserThread; }
 
  void LMBD_INLINE user_thread()
  {
    if constexpr (LocalModeTy::requireUserThread)
    {
      LocalModeTy::user_thread(*this);
    }
  }
 
  //
  // context members for direct access
  //
 
  hardware::LampTy& lamp; 
  StateTy& state;         
 
private:
  ModeManagerTy& modeManager;
};
 
} // namespace lampda::modes
 
#endif