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>
 
#include "src/modes/include/colors/utils.hpp"
 
//
// 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
          if (not manager.jump_to_favorite(manager.state.lastFavoriteStep, false))
          {
            manager.exit_favorite_group(manager.state.beforeFavoriteActiveIndex);
          }
        }
        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)
        {
          // return to previous state
          manager.exit_favorite_group(manager.state.beforeFavoriteActiveIndex);
        }
        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
          manager.jump_to_favorite(manager.state.lastFavoriteStep, true);
        }
#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 {
 
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)
  {
    bsp::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)
  {
    bsp::lampda_print("Cannot find the bluetooth group and modes");
    return;
  }
 
  const auto availableModes = manager.get_modes_count();
  if (availableModes <= patternIndex)
  {
    bsp::lampda_print("Unimplemented pattern id %d", patternIndex);
    return;
  }
 
  manager.exit_favorite_group(manager.state.beforeFavoriteActiveIndex);
  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>();
 
    // Convert color to compressed color
    const uint16_t compressedColor = modes::colors::get_compressed_16b_color(requestedColor);
    const uint8_t ramp = (compressedColor >> 8) & 0xFF;
    const uint8_t index = compressedColor & 0xFF;
    manager.set_active_custom_ramp(ramp);
    manager.set_active_custom_index(index);
  }
}
 
void handle_go_to_favorite_command(const uint8_t favoriteIndex)
{
  // ignore if not on
  if (not logic::behavior::is_in_output_state())
    return;
 
  auto manager = get_context();
  if (favoriteIndex >= manager.state.usedFavoriteCount)
  {
    bsp::lampda_print("Cannot jump to favorite %d, max index should be less than %d",
                      favoriteIndex,
                      manager.state.usedFavoriteCount);
    return;
  }
  // jump and save last used mode
  manager.jump_to_favorite(favoriteIndex, true);
}
 
void handle_set_favorite_command(const uint8_t favoriteIndex)
{
  // ignore if not on
  if (not logic::behavior::is_in_output_state())
    return;
 
  auto manager = get_context();
 
  // Cannot add a favorite mode to te favorite group: we are already here
  if (manager.state.isInFavoriteMockGroup)
    return;
 
  const uint8_t allowedFavorites = manager.get_number_of_allowed_favorites();
 
  // not enought favorite set
  if (favoriteIndex >= allowedFavorites)
  {
    bsp::lampda_print("Max favorites is [0; %d[, cannot add index %d", allowedFavorites, favoriteIndex);
    return;
  }
 
  // Set the favorite !
  manager.set_current_mode_as_favorite(favoriteIndex, 1000);
}
 
} // namespace __private
 
void handle_user_command(const common::UserCommand& command)
{
  // Handle default common behavior
  if (default_behaviors::handle_user_command(command))
  {
    // some event is already handled
    return;
  }
 
  switch (command.get_type())
  {
    case common::UserCommand::Type::SetBleCustomColorMode:
      {
        uint32_t color;
        if (command.parse_set_ble_custom_color_mode_command(color))
          __private::handle_pattern_select_command(0, color);
        else
          bsp::lampda_print("Failed to parse set_ble_custom_color command");
        return;
      }
    case common::UserCommand::Type::SetBleMode:
      {
        uint8_t index;
        if (command.parse_set_ble_mode_command(index))
          __private::handle_pattern_select_command(index);
        else
          bsp::lampda_print("Failed to parse set_ble_mode command");
        return;
      }
    case common::UserCommand::Type::GoToFavoriteIndex:
      {
        uint8_t index;
        if (command.parse_go_to_favorite_command(index))
          __private::handle_go_to_favorite_command(index);
        else
          bsp::lampda_print("Failed to parse go_to_favorite command");
        return;
      }
    case common::UserCommand::Type::SetFavoriteIndex:
      {
        uint8_t index;
        if (command.parse_set_favorite_command(index))
          __private::handle_set_favorite_command(index);
        else
          bsp::lampda_print("Failed to parse set_favorite command");
        return;
      }
    default:
      break;
  }
 
  bsp::lampda_print("Unsupported user command message type");
}
 
} // namespace lampda::user
 
#endif