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 {
 
bool button_clicked_default(const uint8_t clicks)
{
  // Handle default common behavior
  if (default_behaviors::button_clicked(clicks))
  {
    // some event is already handled
    return true;
  }
 
  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();
          }
        }
#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
 
        return true;
      }
 
    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();
        }
 
#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
        return true;
      }
 
    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);
          }
        }
#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
        return true;
      }
  }
 
  return false;
}
 
bool 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 true;
  }
 
  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;
        }
        return true;
      }
 
    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);
          }
        }
        return true;
      }
 
    default:
      break;
  }
  return false;
}
 
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