indexable_behavior.hpp

Go to the documentation of this file.

 
#ifndef INDEXABLE_BEHAVIOR_MANAGER_H
#define INDEXABLE_BEHAVIOR_MANAGER_H
 
#include <src/system/utils/assert.h>
 
//
// note: this code is included as-is by:
//  - user/indexable_functions.h
//
 
#include <cstdint>
namespace lampda::user {
 
void button_clicked_default(const uint8_t clicks)
{
  // Handle default common behavior
  if (default_behaviors::button_clicked(clicks))
  {
    // some event is already handled
    return;
  }
 
  auto manager = get_context();
 
  switch (clicks)
  {
    case 2: // 2 clicks: next mode
      if (manager.state.isInFavoriteMockGroup)
      {
        // if in favorite, next favorite
        manager.state.lastFavoriteStep += 1;
        // sanity check, if it fails, quit favorites
        manager.state.isInFavoriteMockGroup = manager.jump_to_favorite(manager.state.lastFavoriteStep, false);
      }
      else
      {
        if (manager.state.isLastScrollAGroupChange and manager.lamp.now - manager.state.lastScrollStopped < 2000)
        {
          // last action was a group change & timer did not run out yet:
          // change group
          manager.next_group();
 
          // prevent further jumps
          manager.state.isLastScrollAGroupChange = false;
        }
        else
        {
          // else: just change mode
          manager.next_mode();
        }
      }
      break;
 
    case 3: // 3 clicks: next group or quit favorite group
      if (manager.state.isInFavoriteMockGroup)
      {
#ifdef LMBD_SIMULATION
        fprintf(stderr, "Exit fake favorite group\n");
#endif
        // reset favorite indicator
        manager.state.isInFavoriteMockGroup = false;
        // return to previous state
        manager.set_active_group(manager.state.beforeFavoriteGroupIndex);
        manager.set_active_mode(manager.state.beforeFavoriteModeIndex);
 
        // blip to indicate favorite mode exit
        manager.blip(250);
      }
      else
      {
        // true next group
        manager.next_group();
      }
      break;
 
    case 4: // 4 clicks: jump to favorite
 
      if (not manager.state.isInFavoriteMockGroup)
      {
        // jump and save last used mode
        if (manager.jump_to_favorite(manager.state.lastFavoriteStep, true))
        {
          manager.state.isInFavoriteMockGroup = true;
          // blip to indicate favorite mode enter
          manager.blip(250);
        }
      }
      break;
  }
 
#ifdef LMBD_SIMULATION
  {
    int _groupId = manager.get_active_group();
    int _modeId = manager.get_active_mode();
    fprintf(stderr, "group %d *mode %d\n", _groupId, _modeId);
    if (manager.everySunsetCallback[_groupId][_modeId])
      fprintf(stderr, " - hasSunsetAnimation\n");
    if (manager.everyBrightCallback[_groupId][_modeId])
      fprintf(stderr, " - hasBrightCallback\n");
    if (manager.everyCustomRamp[_groupId][_modeId])
      fprintf(stderr, " - hasCustomRamp\n");
    if (manager.state.rampHandler.animEffect)
      fprintf(stderr, " - has anim effect\n");
    if (manager.everyRequireUserThread[_groupId][_modeId])
      fprintf(stderr, " - requireUserThread\n");
    if (manager.everySystemCallbacks[_groupId][_modeId])
      fprintf(stderr, " - hasSystemCallbacks\n");
    if (manager.everyButtonCustomUI[_groupId][_modeId])
      fprintf(stderr, " - hasButtonCustomUI\n");
  }
#endif
}
 
void button_hold_default(const uint8_t clicks, const bool isEndOfHoldEvent, const uint32_t holdDuration)
{
  // Handle default common behavior
  if (default_behaviors::button_hold(clicks, isEndOfHoldEvent, holdDuration))
  {
    // some event is already handled
    return;
  }
 
  auto manager = get_context();
  auto& rampHandler = manager.state.rampHandler;
 
  switch (clicks)
  {
    case 4: // 4 click+hold: configure favorite
      if (not isEndOfHoldEvent)
      {
        // lock to prevent addition of favorite from favorite & if we are deleting favorites
        // the second case can happen when the user delete all favorites
        if (not manager.state.isInFavoriteMockGroup && not manager.state.isInDeleteFavorite)
        {
          // no new favorite in favorite
          manager.animate_favorite_pick(holdDuration, 1500);
        }
        else
        {
          // remove current favorite
          manager.animate_favorite_delete(holdDuration, 2000);
        }
      }
      else
      {
        manager.state.isInDeleteFavorite = false;
      }
      break;
 
    case 6: // 6 click+hold: scroll across modes and group
      // no scroll in favorite
      if (not manager.state.isInFavoriteMockGroup)
      {
        // register end of scroll
        if (isEndOfHoldEvent)
        {
          // update release time
          manager.state.lastScrollStopped = manager.lamp.now;
        }
        else
        {
          manager.handle_scroll_modes(holdDuration);
        }
      }
      break;
 
    default:
      break;
  }
}
 
namespace __private_elk {
 
void handle_pattern_select_command(const uint8_t patternIndex, const uint32_t requestedColor = 0)
{
  // ignore if not on
  if (not logic::behavior::is_in_output_state())
    return;
 
  // get manager and execute a mode or group change
  auto manager = get_context();
  if (manager.get_hidden_groups_count() <= 0)
  {
    platform::lampda_print("Cannot use bluetooth control without an hidden bluetooth group");
    return;
  }
 
  const auto bluetoothGroup = manager.template get_group_id_of_mode<modes::bluetooth::ColorControlMode>();
  if (bluetoothGroup < 0)
  {
    platform::lampda_print("Cannot find the bluetooth group and modes");
    return;
  }
 
  const auto availableModes = manager.get_modes_count();
  if (availableModes <= patternIndex)
  {
    platform::lampda_print("Unimplemented pattern id %d", patternIndex);
    return;
  }
 
  manager.set_active_group(bluetoothGroup);
  manager.set_active_mode(patternIndex);
 
  // sanity check
  const int trueIndex = manager.template get_mode_id<modes::bluetooth::ColorControlMode>();
  assert(trueIndex == 0 && "Bluetooth group should have the programmable color output as the first group index");
 
  // handle special programmable group mode
  if (patternIndex == 0)
  {
    auto& modeState = manager.template get_state_of_mode<modes::bluetooth::ColorControlMode>();
    modeState.color = requestedColor;
  }
}
 
} // namespace __private_elk
 
void handle_elk_command(const utils::ELK::Package& elkControlCommand)
{
  // Handle default common behavior
  if (default_behaviors::handle_elk_command(elkControlCommand))
  {
    // some event is already handled
    return;
  }
 
  switch (elkControlCommand.type)
  {
    case utils::ELK::Type::COLOR_SELECT:
      {
        const uint32_t color =
                elkControlCommand.data[0] << 16 | elkControlCommand.data[1] << 8 | elkControlCommand.data[2];
        __private_elk::handle_pattern_select_command(0, color);
        break;
      }
    case utils::ELK::Type::PATTERN_SELECT:
      {
        __private_elk::handle_pattern_select_command(elkControlCommand.data[0] + 1);
        break;
      }
    // unhandled
    default:
      {
        platform::lampda_print("Unsupported ELK message type");
        break;
      }
  }
}
 
} // namespace lampda::user
 
#endif