services/inputflinger/reader/controller/PeripheralController.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright (C) 2021 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <locale>
 #include <regex>
 #include <sstream>
 #include <string>

 #include <android/sysprop/InputProperties.sysprop.h>
 #include <ftl/enum.h>

 #include "../Macros.h"
 #include "PeripheralController.h"

 namespace android {

 static inline int32_t getAlpha(int32_t color) {
     return (color >> 24) & 0xff;
 }

 static inline int32_t getRed(int32_t color) {
     return (color >> 16) & 0xff;
 }

 static inline int32_t getGreen(int32_t color) {
     return (color >> 8) & 0xff;
 }

 static inline int32_t getBlue(int32_t color) {
     return color & 0xff;
 }

 static inline int32_t toArgb(int32_t brightness, int32_t red, int32_t green, int32_t blue) {
     return (brightness & 0xff) << 24 | (red & 0xff) << 16 | (green & 0xff) << 8 | (blue & 0xff);
 }

 /**
  * Input controller owned by InputReader device, implements the native API for querying input
  * lights, getting and setting the lights brightness and color, by interacting with EventHub
  * devices.
  */
 PeripheralController::PeripheralController(InputDeviceContext& deviceContext)
       : mDeviceContext(deviceContext) {
     configureBattries();
     configureLights();
 }

 PeripheralController::~PeripheralController() {}

 std::optional<std::int32_t> PeripheralController::Light::getRawLightBrightness(int32_t rawLightId) {
     std::optional<RawLightInfo> rawInfoOpt = context.getRawLightInfo(rawLightId);
     if (!rawInfoOpt.has_value()) {
         return std::nullopt;
     }
     std::optional<int32_t> brightnessOpt = context.getLightBrightness(rawLightId);
     if (!brightnessOpt.has_value()) {
         return std::nullopt;
     }
     int brightness = brightnessOpt.value();

     // If the light node doesn't have max brightness, use the default max brightness.
     int rawMaxBrightness = rawInfoOpt->maxBrightness.value_or(MAX_BRIGHTNESS);
     float ratio = static_cast<float>(MAX_BRIGHTNESS) / rawMaxBrightness;
     // Scale the returned brightness in [0, rawMaxBrightness] to [0, 255]
     if (rawMaxBrightness != MAX_BRIGHTNESS) {
         brightness = brightness * ratio;
     }
     if (DEBUG_LIGHT_DETAILS) {
         ALOGD("getRawLightBrightness rawLightId %d brightness 0x%x ratio %.2f", rawLightId,
               brightness, ratio);
     }
     return brightness;
 }

 void PeripheralController::Light::setRawLightBrightness(int32_t rawLightId, int32_t brightness) {
     std::optional<RawLightInfo> rawInfo = context.getRawLightInfo(rawLightId);
     if (!rawInfo.has_value()) {
         return;
     }
     // If the light node doesn't have max brightness, use the default max brightness.
     int rawMaxBrightness = rawInfo->maxBrightness.value_or(MAX_BRIGHTNESS);
     float ratio = static_cast<float>(MAX_BRIGHTNESS) / rawMaxBrightness;
     // Scale the requested brightness in [0, 255] to [0, rawMaxBrightness]
     if (rawMaxBrightness != MAX_BRIGHTNESS) {
         brightness = ceil(brightness / ratio);
     }
     if (DEBUG_LIGHT_DETAILS) {
         ALOGD("setRawLightBrightness rawLightId %d brightness 0x%x ratio %.2f", rawLightId,
               brightness, ratio);
     }
     context.setLightBrightness(rawLightId, brightness);
 }

 bool PeripheralController::MonoLight::setLightColor(int32_t color) {
     int32_t brightness = getAlpha(color);
     setRawLightBrightness(rawId, brightness);

     return true;
 }

 bool PeripheralController::RgbLight::setLightColor(int32_t color) {
     // Compose color value as per:
     // https://developer.android.com/reference/android/graphics/Color?hl=en
     // int color = (A & 0xff) << 24 | (R & 0xff) << 16 | (G & 0xff) << 8 | (B & 0xff);
     // The alpha component is used to scale the R,G,B leds brightness, with the ratio to
     // MAX_BRIGHTNESS.
     brightness = getAlpha(color);
     int32_t red = 0;
     int32_t green = 0;
     int32_t blue = 0;
     if (brightness > 0) {
         float ratio = MAX_BRIGHTNESS / brightness;
         red = ceil(getRed(color) / ratio);
         green = ceil(getGreen(color) / ratio);
         blue = ceil(getBlue(color) / ratio);
     }
     setRawLightBrightness(rawRgbIds.at(LightColor::RED), red);
     setRawLightBrightness(rawRgbIds.at(LightColor::GREEN), green);
     setRawLightBrightness(rawRgbIds.at(LightColor::BLUE), blue);
     if (rawGlobalId.has_value()) {
         setRawLightBrightness(rawGlobalId.value(), brightness);
     }

     return true;
 }

 bool PeripheralController::MultiColorLight::setLightColor(int32_t color) {
     std::unordered_map<LightColor, int32_t> intensities;
     intensities.emplace(LightColor::RED, getRed(color));
     intensities.emplace(LightColor::GREEN, getGreen(color));
     intensities.emplace(LightColor::BLUE, getBlue(color));

     context.setLightIntensities(rawId, intensities);
     setRawLightBrightness(rawId, getAlpha(color));
     return true;
 }

 std::optional<int32_t> PeripheralController::MonoLight::getLightColor() {
     std::optional<int32_t> brightness = getRawLightBrightness(rawId);
     if (!brightness.has_value()) {
         return std::nullopt;
     }

     return toArgb(brightness.value(), /*red=*/0, /*green=*/0, /*blue=*/0);
 }

 std::optional<int32_t> PeripheralController::RgbLight::getLightColor() {
     // If the Alpha component is zero, then return color 0.
     if (brightness == 0) {
         return 0;
     }
     // Compose color value as per:
     // https://developer.android.com/reference/android/graphics/Color?hl=en
     // int color = (A & 0xff) << 24 | (R & 0xff) << 16 | (G & 0xff) << 8 | (B & 0xff);
     std::optional<int32_t> redOr = getRawLightBrightness(rawRgbIds.at(LightColor::RED));
     std::optional<int32_t> greenOr = getRawLightBrightness(rawRgbIds.at(LightColor::GREEN));
     std::optional<int32_t> blueOr = getRawLightBrightness(rawRgbIds.at(LightColor::BLUE));
     // If we can't get brightness for any of the RGB light
     if (!redOr.has_value() || !greenOr.has_value() || !blueOr.has_value()) {
         return std::nullopt;
     }

     // Compose the ARGB format color. As the R,G,B color led brightness is scaled by Alpha
     // value, scale it back to return the nominal color value.
     float ratio = MAX_BRIGHTNESS / brightness;
     int32_t red = round(redOr.value() * ratio);
     int32_t green = round(greenOr.value() * ratio);
     int32_t blue = round(blueOr.value() * ratio);

     if (red > MAX_BRIGHTNESS || green > MAX_BRIGHTNESS || blue > MAX_BRIGHTNESS) {
         // Previously stored brightness isn't valid for current LED values, so just reset to max
         // brightness since an app couldn't have provided these values in the first place.
         red = redOr.value();
         green = greenOr.value();
         blue = blueOr.value();
         brightness = MAX_BRIGHTNESS;
     }

     return toArgb(brightness, red, green, blue);
 }

 std::optional<int32_t> PeripheralController::MultiColorLight::getLightColor() {
     auto ret = context.getLightIntensities(rawId);
     if (!ret.has_value()) {
         return std::nullopt;
     }
     std::unordered_map<LightColor, int32_t> intensities = ret.value();
     // Get red, green, blue colors
     int32_t color = toArgb(/*brightness=*/0, intensities.at(LightColor::RED),
                            intensities.at(LightColor::GREEN), intensities.at(LightColor::BLUE));
     // Get brightness
     std::optional<int32_t> brightness = getRawLightBrightness(rawId);
     if (brightness.has_value()) {
         return toArgb(/*brightness=*/brightness.value(), 0, 0, 0) | color;
     }
     return std::nullopt;
 }

 bool PeripheralController::PlayerIdLight::setLightPlayerId(int32_t playerId) {
     if (rawLightIds.find(playerId) == rawLightIds.end()) {
         return false;
     }
     for (const auto& [id, rawId] : rawLightIds) {
         if (playerId == id) {
             setRawLightBrightness(rawId, MAX_BRIGHTNESS);
         } else {
             setRawLightBrightness(rawId, 0);
         }
     }
     return true;
 }

 std::optional<int32_t> PeripheralController::PlayerIdLight::getLightPlayerId() {
     for (const auto& [id, rawId] : rawLightIds) {
         std::optional<int32_t> brightness = getRawLightBrightness(rawId);
         if (brightness.has_value() && brightness.value() > 0) {
             return id;
         }
     }
     return std::nullopt;
 }

 void PeripheralController::MonoLight::dump(std::string& dump) {
     dump += StringPrintf(INDENT4 "Color: 0x%x\n", getLightColor().value_or(0));
 }

 void PeripheralController::PlayerIdLight::dump(std::string& dump) {
     dump += StringPrintf(INDENT4 "PlayerId: %d\n", getLightPlayerId().value_or(-1));
     dump += StringPrintf(INDENT4 "Raw Player ID LEDs:");
     for (const auto& [id, rawId] : rawLightIds) {
         dump += StringPrintf("id %d -> %d ", id, rawId);
     }
     dump += "\n";
 }

 void PeripheralController::RgbLight::dump(std::string& dump) {
     dump += StringPrintf(INDENT4 "Color: 0x%x\n", getLightColor().value_or(0));
     dump += StringPrintf(INDENT4 "Raw RGB LEDs: [%d, %d, %d] ", rawRgbIds.at(LightColor::RED),
                          rawRgbIds.at(LightColor::GREEN), rawRgbIds.at(LightColor::BLUE));
     if (rawGlobalId.has_value()) {
         dump += StringPrintf(INDENT4 "Raw Global LED: [%d] ", rawGlobalId.value());
     }
     dump += "\n";
 }

 void PeripheralController::MultiColorLight::dump(std::string& dump) {
     dump += StringPrintf(INDENT4 "Color: 0x%x\n", getLightColor().value_or(0));
 }

 void PeripheralController::populateDeviceInfo(InputDeviceInfo* deviceInfo) {
     // TODO: b/180733860 Remove this after enabling multi-battery
     if (!mBatteries.empty()) {
         deviceInfo->setHasBattery(true);
     }

     for (const auto& [batteryId, battery] : mBatteries) {
         InputDeviceBatteryInfo batteryInfo(battery->name, battery->id);
         deviceInfo->addBatteryInfo(batteryInfo);
     }

     for (const auto& [lightId, light] : mLights) {
         // Input device light doesn't support ordinal, always pass 1.
         InputDeviceLightInfo lightInfo(light->name, light->id, light->type, light->capabilityFlags,
                                        /*ordinal=*/1, getPreferredBrightnessLevels(light.get()));
         deviceInfo->addLightInfo(lightInfo);
     }
 }

 // TODO(b/281822656): Move to constructor and add as a parameter to avoid parsing repeatedly.
 // Need to change lifecycle of Peripheral controller so that Input device configuration map is
 // available at construction time before moving this logic to constructor.
 std::set<BrightnessLevel> PeripheralController::getPreferredBrightnessLevels(
         const Light* light) const {
     std::set<BrightnessLevel> levels;
     if (light->type != InputDeviceLightType::KEYBOARD_BACKLIGHT) {
         return levels;
     }
     std::optional<std::string> keyboardBacklightLevels =
             mDeviceContext.getConfiguration().getString("keyboard.backlight.brightnessLevels");
     if (!keyboardBacklightLevels) {
         return levels;
     }
     std::stringstream ss(*keyboardBacklightLevels);
     while (ss.good()) {
         std::string substr;
         std::getline(ss, substr, ',');
         char* end;
         int32_t value = static_cast<int32_t>(strtol(substr.c_str(), &end, 10));
         if (*end != '\0' || value < 0 || value > 255) {
             ALOGE("Error parsing keyboard backlight brightness levels, provided levels = %s",
                   keyboardBacklightLevels->c_str());
             levels.clear();
             break;
         }
         levels.insert(BrightnessLevel(value));
     }
     return levels;
 }

 void PeripheralController::dump(std::string& dump) {
     dump += INDENT2 "Input Controller:\n";
     if (!mLights.empty()) {
         dump += INDENT3 "Lights:\n";
         for (const auto& [lightId, light] : mLights) {
             dump += StringPrintf(INDENT4 "Id: %d", lightId);
             dump += StringPrintf(INDENT4 "Name: %s", light->name.c_str());
             dump += StringPrintf(INDENT4 "Type: %s", ftl::enum_string(light->type).c_str());
             dump += StringPrintf(INDENT4 "Capability flags: %s",
                                  light->capabilityFlags.string().c_str());
             light->dump(dump);
         }
     }
     // Dump raw lights
     dump += INDENT3 "RawLights:\n";
     dump += INDENT4 "Id:\t Name:\t Flags:\t Max brightness:\t Brightness\n";
     const std::vector<int32_t> rawLightIds = getDeviceContext().getRawLightIds();
     // Map from raw light id to raw light info
     std::unordered_map<int32_t, RawLightInfo> rawInfos;
     for (const auto& rawId : rawLightIds) {
         std::optional<RawLightInfo> rawInfo = getDeviceContext().getRawLightInfo(rawId);
         if (!rawInfo.has_value()) {
             continue;
         }
         dump += StringPrintf(INDENT4 "%d", rawId);
         dump += StringPrintf(INDENT4 "%s", rawInfo->name.c_str());
         dump += StringPrintf(INDENT4 "%s", rawInfo->flags.string().c_str());
         dump += StringPrintf(INDENT4 "%d", rawInfo->maxBrightness.value_or(MAX_BRIGHTNESS));
         dump += StringPrintf(INDENT4 "%d\n",
                              getDeviceContext().getLightBrightness(rawId).value_or(-1));
     }

     if (!mBatteries.empty()) {
         dump += INDENT3 "Batteries:\n";
         for (const auto& [batteryId, battery] : mBatteries) {
             dump += StringPrintf(INDENT4 "Id: %d", batteryId);
             dump += StringPrintf(INDENT4 "Name: %s", battery->name.c_str());
             dump += getBatteryCapacity(batteryId).has_value()
                     ? StringPrintf(INDENT3 "Capacity: %d\n", getBatteryCapacity(batteryId).value())
                     : StringPrintf(INDENT3 "Capacity: Unknown");

             std::string status;
             switch (getBatteryStatus(batteryId).value_or(BATTERY_STATUS_UNKNOWN)) {
                 case BATTERY_STATUS_CHARGING:
                     status = "Charging";
                     break;
                 case BATTERY_STATUS_DISCHARGING:
                     status = "Discharging";
                     break;
                 case BATTERY_STATUS_NOT_CHARGING:
                     status = "Not charging";
                     break;
                 case BATTERY_STATUS_FULL:
                     status = "Full";
                     break;
                 default:
                     status = "Unknown";
             }
             dump += StringPrintf(INDENT3 "Status: %s\n", status.c_str());
         }
     }
 }

 void PeripheralController::configureBattries() {
     // Check raw batteries
     const std::vector<int32_t> rawBatteryIds = getDeviceContext().getRawBatteryIds();

     for (const auto& rawId : rawBatteryIds) {
         std::optional<RawBatteryInfo> rawInfo = getDeviceContext().getRawBatteryInfo(rawId);
         if (!rawInfo.has_value()) {
             continue;
         }
         std::unique_ptr<Battery> battery =
                 std::make_unique<Battery>(getDeviceContext(), rawInfo->name, rawInfo->id);
         mBatteries.insert_or_assign(rawId, std::move(battery));
     }
 }

 void PeripheralController::configureLights() {
     bool hasRedLed = false;
     bool hasGreenLed = false;
     bool hasBlueLed = false;
     std::optional<int32_t> rawGlobalId = std::nullopt;
     // Player ID light common name string
     std::string playerIdName;
     // Raw RGB color to raw light ID
     std::unordered_map<LightColor, int32_t /* rawLightId */> rawRgbIds;
     // Map from player Id to raw light Id
     std::unordered_map<int32_t, int32_t> playerIdLightIds;
     // Set of Keyboard backlights
     std::set<int32_t> keyboardBacklightIds;

     // Check raw lights
     const std::vector<int32_t> rawLightIds = getDeviceContext().getRawLightIds();
     // Map from raw light id to raw light info
     std::unordered_map<int32_t, RawLightInfo> rawInfos;
     for (const auto& rawId : rawLightIds) {
         std::optional<RawLightInfo> rawInfo = getDeviceContext().getRawLightInfo(rawId);
         if (!rawInfo.has_value()) {
             continue;
         }
         rawInfos.insert_or_assign(rawId, rawInfo.value());
         // Check if this is a group LEDs for player ID
         // The name for the light has already been parsed and is the `function`
         // value; for player ID lights the function is expected to be `player-#`.
         // However, the Sony driver will use `sony#` instead on SIXAXIS
         // gamepads.
         std::regex lightPattern("(player|sony)-?([0-9]+)");
         std::smatch results;
         if (std::regex_match(rawInfo->name, results, lightPattern)) {
             std::string commonName = results[1].str();
             int32_t playerId = std::stoi(results[2]);
             if (playerIdLightIds.empty()) {
                 playerIdName = commonName;
                 playerIdLightIds.insert_or_assign(playerId, rawId);
             } else {
                 // Make sure the player ID leds have common string name
                 if (playerIdName.compare(commonName) == 0 &&
                     playerIdLightIds.find(playerId) == playerIdLightIds.end()) {
                     playerIdLightIds.insert_or_assign(playerId, rawId);
                 }
             }
         }
         // Check if this is a Keyboard backlight
         if (rawInfo->flags.test(InputLightClass::KEYBOARD_BACKLIGHT)) {
             keyboardBacklightIds.insert(rawId);
         }
         // Check if this is an LED of RGB light
         if (rawInfo->flags.test(InputLightClass::RED)) {
             hasRedLed = true;
             rawRgbIds.emplace(LightColor::RED, rawId);
         }
         if (rawInfo->flags.test(InputLightClass::GREEN)) {
             hasGreenLed = true;
             rawRgbIds.emplace(LightColor::GREEN, rawId);
         }
         if (rawInfo->flags.test(InputLightClass::BLUE)) {
             hasBlueLed = true;
             rawRgbIds.emplace(LightColor::BLUE, rawId);
         }
         if (rawInfo->flags.test(InputLightClass::GLOBAL)) {
             rawGlobalId = rawId;
         }
         if (DEBUG_LIGHT_DETAILS) {
             ALOGD("Light rawId %d name %s max %d flags %s \n", rawInfo->id, rawInfo->name.c_str(),
                   rawInfo->maxBrightness.value_or(MAX_BRIGHTNESS), rawInfo->flags.string().c_str());
         }
     }

     // Construct a player ID light
     if (playerIdLightIds.size() > 1) {
         std::unique_ptr<Light> light =
                 std::make_unique<PlayerIdLight>(getDeviceContext(), playerIdName, ++mNextId,
                                                 playerIdLightIds);
         mLights.insert_or_assign(light->id, std::move(light));
         // Remove these raw lights from raw light info as they've been used to compose a
         // Player ID light, so we do not expose these raw lights as mono lights.
         for (const auto& [playerId, rawId] : playerIdLightIds) {
             rawInfos.erase(rawId);
         }
     }
     // Construct a RGB light for composed RGB light
     if (hasRedLed && hasGreenLed && hasBlueLed) {
         if (DEBUG_LIGHT_DETAILS) {
             ALOGD("Rgb light ids [%d, %d, %d] \n", rawRgbIds.at(LightColor::RED),
                   rawRgbIds.at(LightColor::GREEN), rawRgbIds.at(LightColor::BLUE));
         }
         bool isKeyboardBacklight = keyboardBacklightIds.find(rawRgbIds.at(LightColor::RED)) !=
                         keyboardBacklightIds.end() &&
                 keyboardBacklightIds.find(rawRgbIds.at(LightColor::GREEN)) !=
                         keyboardBacklightIds.end() &&
                 keyboardBacklightIds.find(rawRgbIds.at(LightColor::BLUE)) !=
                         keyboardBacklightIds.end() &&
                 (!rawGlobalId.has_value() ||
                  keyboardBacklightIds.find(rawGlobalId.value()) != keyboardBacklightIds.end());

         std::unique_ptr<Light> light =
                 std::make_unique<RgbLight>(getDeviceContext(), ++mNextId,
                                            isKeyboardBacklight
                                                    ? InputDeviceLightType::KEYBOARD_BACKLIGHT
                                                    : InputDeviceLightType::INPUT,
                                            rawRgbIds, rawGlobalId);
         mLights.insert_or_assign(light->id, std::move(light));
         // Remove from raw light info as they've been composed a RBG light.
         rawInfos.erase(rawRgbIds.at(LightColor::RED));
         rawInfos.erase(rawRgbIds.at(LightColor::GREEN));
         rawInfos.erase(rawRgbIds.at(LightColor::BLUE));
         if (rawGlobalId.has_value()) {
             rawInfos.erase(rawGlobalId.value());
         }
     }

     // Check the rest of raw light infos
     for (const auto& [rawId, rawInfo] : rawInfos) {
         InputDeviceLightType type;
         if (keyboardBacklightIds.find(rawId) != keyboardBacklightIds.end()) {
             type = InputDeviceLightType::KEYBOARD_BACKLIGHT;
         } else if (rawInfo.flags.test(InputLightClass::KEYBOARD_MIC_MUTE)) {
             type = InputDeviceLightType::KEYBOARD_MIC_MUTE;
         } else if (rawInfo.flags.test(InputLightClass::KEYBOARD_VOLUME_MUTE)) {
             type = InputDeviceLightType::KEYBOARD_VOLUME_MUTE;
         } else {
             type = InputDeviceLightType::INPUT;
         }

         // If the node is multi-color led, construct a MULTI_COLOR light
         if (rawInfo.flags.test(InputLightClass::MULTI_INDEX) &&
             rawInfo.flags.test(InputLightClass::MULTI_INTENSITY)) {
             if (DEBUG_LIGHT_DETAILS) {
                 ALOGD("Multicolor light Id %d name %s \n", rawInfo.id, rawInfo.name.c_str());
             }
             std::unique_ptr<Light> light =
                     std::make_unique<MultiColorLight>(getDeviceContext(), rawInfo.name, ++mNextId,
                                                       type, rawInfo.id);
             mLights.insert_or_assign(light->id, std::move(light));
             continue;
         }
         // Construct a Mono LED light
         if (DEBUG_LIGHT_DETAILS) {
             ALOGD("Mono light Id %d name %s \n", rawInfo.id, rawInfo.name.c_str());
         }
         std::unique_ptr<Light> light = std::make_unique<MonoLight>(getDeviceContext(), rawInfo.name,
                                                                    ++mNextId, type, rawInfo.id);

         mLights.insert_or_assign(light->id, std::move(light));
     }
 }

 std::optional<int32_t> PeripheralController::getBatteryCapacity(int batteryId) {
     return getDeviceContext().getBatteryCapacity(batteryId);
 }

 std::optional<int32_t> PeripheralController::getBatteryStatus(int batteryId) {
     return getDeviceContext().getBatteryStatus(batteryId);
 }

 bool PeripheralController::setLightColor(int32_t lightId, int32_t color) {
     auto it = mLights.find(lightId);
     if (it == mLights.end()) {
         return false;
     }
     auto& light = it->second;
     if (DEBUG_LIGHT_DETAILS) {
         ALOGD("setLightColor lightId %d type %s color 0x%x", lightId,
               ftl::enum_string(light->type).c_str(), color);
     }
     return light->setLightColor(color);
 }

 std::optional<int32_t> PeripheralController::getLightColor(int32_t lightId) {
     auto it = mLights.find(lightId);
     if (it == mLights.end()) {
         return std::nullopt;
     }
     auto& light = it->second;
     std::optional<int32_t> color = light->getLightColor();
     if (DEBUG_LIGHT_DETAILS) {
         ALOGD("getLightColor lightId %d type %s color 0x%x", lightId,
               ftl::enum_string(light->type).c_str(), color.value_or(0));
     }
     return color;
 }

 bool PeripheralController::setLightPlayerId(int32_t lightId, int32_t playerId) {
     auto it = mLights.find(lightId);
     if (it == mLights.end()) {
         return false;
     }
     auto& light = it->second;
     return light->setLightPlayerId(playerId);
 }

 std::optional<int32_t> PeripheralController::getLightPlayerId(int32_t lightId) {
     auto it = mLights.find(lightId);
     if (it == mLights.end()) {
         return std::nullopt;
     }
     auto& light = it->second;
     return light->getLightPlayerId();
 }

 int32_t PeripheralController::getEventHubId() const {
     return getDeviceContext().getEventHubId();
 }
 } // namespace android
	/*
	* Copyright (C) 2021 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <locale>
	#include <regex>
	#include <sstream>
	#include <string>

	#include <android/sysprop/InputProperties.sysprop.h>
	#include <ftl/enum.h>

	#include "../Macros.h"
	#include "PeripheralController.h"

	namespace android {

	static inline int32_t getAlpha(int32_t color) {
	return (color >> 24) & 0xff;
	}

	static inline int32_t getRed(int32_t color) {
	return (color >> 16) & 0xff;
	}

	static inline int32_t getGreen(int32_t color) {
	return (color >> 8) & 0xff;
	}

	static inline int32_t getBlue(int32_t color) {
	return color & 0xff;
	}

	static inline int32_t toArgb(int32_t brightness, int32_t red, int32_t green, int32_t blue) {
	return (brightness & 0xff) << 24 \| (red & 0xff) << 16 \| (green & 0xff) << 8 \| (blue & 0xff);
	}

	/**
	* Input controller owned by InputReader device, implements the native API for querying input
	* lights, getting and setting the lights brightness and color, by interacting with EventHub
	* devices.
	*/
	PeripheralController::PeripheralController(InputDeviceContext& deviceContext)
	: mDeviceContext(deviceContext) {
	configureBattries();
	configureLights();
	}

	PeripheralController::~PeripheralController() {}

	std::optional<std::int32_t> PeripheralController::Light::getRawLightBrightness(int32_t rawLightId) {
	std::optional<RawLightInfo> rawInfoOpt = context.getRawLightInfo(rawLightId);
	if (!rawInfoOpt.has_value()) {
	return std::nullopt;
	}
	std::optional<int32_t> brightnessOpt = context.getLightBrightness(rawLightId);
	if (!brightnessOpt.has_value()) {
	return std::nullopt;
	}
	int brightness = brightnessOpt.value();

	// If the light node doesn't have max brightness, use the default max brightness.
	int rawMaxBrightness = rawInfoOpt->maxBrightness.value_or(MAX_BRIGHTNESS);
	float ratio = static_cast<float>(MAX_BRIGHTNESS) / rawMaxBrightness;
	// Scale the returned brightness in [0, rawMaxBrightness] to [0, 255]
	if (rawMaxBrightness != MAX_BRIGHTNESS) {
	brightness = brightness * ratio;
	}
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("getRawLightBrightness rawLightId %d brightness 0x%x ratio %.2f", rawLightId,
	brightness, ratio);
	}
	return brightness;
	}

	void PeripheralController::Light::setRawLightBrightness(int32_t rawLightId, int32_t brightness) {
	std::optional<RawLightInfo> rawInfo = context.getRawLightInfo(rawLightId);
	if (!rawInfo.has_value()) {
	return;
	}
	// If the light node doesn't have max brightness, use the default max brightness.
	int rawMaxBrightness = rawInfo->maxBrightness.value_or(MAX_BRIGHTNESS);
	float ratio = static_cast<float>(MAX_BRIGHTNESS) / rawMaxBrightness;
	// Scale the requested brightness in [0, 255] to [0, rawMaxBrightness]
	if (rawMaxBrightness != MAX_BRIGHTNESS) {
	brightness = ceil(brightness / ratio);
	}
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("setRawLightBrightness rawLightId %d brightness 0x%x ratio %.2f", rawLightId,
	brightness, ratio);
	}
	context.setLightBrightness(rawLightId, brightness);
	}

	bool PeripheralController::MonoLight::setLightColor(int32_t color) {
	int32_t brightness = getAlpha(color);
	setRawLightBrightness(rawId, brightness);

	return true;
	}

	bool PeripheralController::RgbLight::setLightColor(int32_t color) {
	// Compose color value as per:
	// https://developer.android.com/reference/android/graphics/Color?hl=en
	// int color = (A & 0xff) << 24 \| (R & 0xff) << 16 \| (G & 0xff) << 8 \| (B & 0xff);
	// The alpha component is used to scale the R,G,B leds brightness, with the ratio to
	// MAX_BRIGHTNESS.
	brightness = getAlpha(color);
	int32_t red = 0;
	int32_t green = 0;
	int32_t blue = 0;
	if (brightness > 0) {
	float ratio = MAX_BRIGHTNESS / brightness;
	red = ceil(getRed(color) / ratio);
	green = ceil(getGreen(color) / ratio);
	blue = ceil(getBlue(color) / ratio);
	}
	setRawLightBrightness(rawRgbIds.at(LightColor::RED), red);
	setRawLightBrightness(rawRgbIds.at(LightColor::GREEN), green);
	setRawLightBrightness(rawRgbIds.at(LightColor::BLUE), blue);
	if (rawGlobalId.has_value()) {
	setRawLightBrightness(rawGlobalId.value(), brightness);
	}

	return true;
	}

	bool PeripheralController::MultiColorLight::setLightColor(int32_t color) {
	std::unordered_map<LightColor, int32_t> intensities;
	intensities.emplace(LightColor::RED, getRed(color));
	intensities.emplace(LightColor::GREEN, getGreen(color));
	intensities.emplace(LightColor::BLUE, getBlue(color));

	context.setLightIntensities(rawId, intensities);
	setRawLightBrightness(rawId, getAlpha(color));
	return true;
	}

	std::optional<int32_t> PeripheralController::MonoLight::getLightColor() {
	std::optional<int32_t> brightness = getRawLightBrightness(rawId);
	if (!brightness.has_value()) {
	return std::nullopt;
	}

	return toArgb(brightness.value(), /red=/0, /green=/0, /blue=/0);
	}

	std::optional<int32_t> PeripheralController::RgbLight::getLightColor() {
	// If the Alpha component is zero, then return color 0.
	if (brightness == 0) {
	return 0;
	}
	// Compose color value as per:
	// https://developer.android.com/reference/android/graphics/Color?hl=en
	// int color = (A & 0xff) << 24 \| (R & 0xff) << 16 \| (G & 0xff) << 8 \| (B & 0xff);
	std::optional<int32_t> redOr = getRawLightBrightness(rawRgbIds.at(LightColor::RED));
	std::optional<int32_t> greenOr = getRawLightBrightness(rawRgbIds.at(LightColor::GREEN));
	std::optional<int32_t> blueOr = getRawLightBrightness(rawRgbIds.at(LightColor::BLUE));
	// If we can't get brightness for any of the RGB light
	if (!redOr.has_value() \|\| !greenOr.has_value() \|\| !blueOr.has_value()) {
	return std::nullopt;
	}

	// Compose the ARGB format color. As the R,G,B color led brightness is scaled by Alpha
	// value, scale it back to return the nominal color value.
	float ratio = MAX_BRIGHTNESS / brightness;
	int32_t red = round(redOr.value() * ratio);
	int32_t green = round(greenOr.value() * ratio);
	int32_t blue = round(blueOr.value() * ratio);

	if (red > MAX_BRIGHTNESS \|\| green > MAX_BRIGHTNESS \|\| blue > MAX_BRIGHTNESS) {
	// Previously stored brightness isn't valid for current LED values, so just reset to max
	// brightness since an app couldn't have provided these values in the first place.
	red = redOr.value();
	green = greenOr.value();
	blue = blueOr.value();
	brightness = MAX_BRIGHTNESS;
	}

	return toArgb(brightness, red, green, blue);
	}

	std::optional<int32_t> PeripheralController::MultiColorLight::getLightColor() {
	auto ret = context.getLightIntensities(rawId);
	if (!ret.has_value()) {
	return std::nullopt;
	}
	std::unordered_map<LightColor, int32_t> intensities = ret.value();
	// Get red, green, blue colors
	int32_t color = toArgb(/brightness=/0, intensities.at(LightColor::RED),
	intensities.at(LightColor::GREEN), intensities.at(LightColor::BLUE));
	// Get brightness
	std::optional<int32_t> brightness = getRawLightBrightness(rawId);
	if (brightness.has_value()) {
	return toArgb(/brightness=/brightness.value(), 0, 0, 0) \| color;
	}
	return std::nullopt;
	}

	bool PeripheralController::PlayerIdLight::setLightPlayerId(int32_t playerId) {
	if (rawLightIds.find(playerId) == rawLightIds.end()) {
	return false;
	}
	for (const auto& [id, rawId] : rawLightIds) {
	if (playerId == id) {
	setRawLightBrightness(rawId, MAX_BRIGHTNESS);
	} else {
	setRawLightBrightness(rawId, 0);
	}
	}
	return true;
	}

	std::optional<int32_t> PeripheralController::PlayerIdLight::getLightPlayerId() {
	for (const auto& [id, rawId] : rawLightIds) {
	std::optional<int32_t> brightness = getRawLightBrightness(rawId);
	if (brightness.has_value() && brightness.value() > 0) {
	return id;
	}
	}
	return std::nullopt;
	}

	void PeripheralController::MonoLight::dump(std::string& dump) {
	dump += StringPrintf(INDENT4 "Color: 0x%x\n", getLightColor().value_or(0));
	}

	void PeripheralController::PlayerIdLight::dump(std::string& dump) {
	dump += StringPrintf(INDENT4 "PlayerId: %d\n", getLightPlayerId().value_or(-1));
	dump += StringPrintf(INDENT4 "Raw Player ID LEDs:");
	for (const auto& [id, rawId] : rawLightIds) {
	dump += StringPrintf("id %d -> %d ", id, rawId);
	}
	dump += "\n";
	}

	void PeripheralController::RgbLight::dump(std::string& dump) {
	dump += StringPrintf(INDENT4 "Color: 0x%x\n", getLightColor().value_or(0));
	dump += StringPrintf(INDENT4 "Raw RGB LEDs: [%d, %d, %d] ", rawRgbIds.at(LightColor::RED),
	rawRgbIds.at(LightColor::GREEN), rawRgbIds.at(LightColor::BLUE));
	if (rawGlobalId.has_value()) {
	dump += StringPrintf(INDENT4 "Raw Global LED: [%d] ", rawGlobalId.value());
	}
	dump += "\n";
	}

	void PeripheralController::MultiColorLight::dump(std::string& dump) {
	dump += StringPrintf(INDENT4 "Color: 0x%x\n", getLightColor().value_or(0));
	}

	void PeripheralController::populateDeviceInfo(InputDeviceInfo* deviceInfo) {
	// TODO: b/180733860 Remove this after enabling multi-battery
	if (!mBatteries.empty()) {
	deviceInfo->setHasBattery(true);
	}

	for (const auto& [batteryId, battery] : mBatteries) {
	InputDeviceBatteryInfo batteryInfo(battery->name, battery->id);
	deviceInfo->addBatteryInfo(batteryInfo);
	}

	for (const auto& [lightId, light] : mLights) {
	// Input device light doesn't support ordinal, always pass 1.
	InputDeviceLightInfo lightInfo(light->name, light->id, light->type, light->capabilityFlags,
	/ordinal=/1, getPreferredBrightnessLevels(light.get()));
	deviceInfo->addLightInfo(lightInfo);
	}
	}

	// TODO(b/281822656): Move to constructor and add as a parameter to avoid parsing repeatedly.
	// Need to change lifecycle of Peripheral controller so that Input device configuration map is
	// available at construction time before moving this logic to constructor.
	std::set<BrightnessLevel> PeripheralController::getPreferredBrightnessLevels(
	const Light* light) const {
	std::set<BrightnessLevel> levels;
	if (light->type != InputDeviceLightType::KEYBOARD_BACKLIGHT) {
	return levels;
	}
	std::optional<std::string> keyboardBacklightLevels =
	mDeviceContext.getConfiguration().getString("keyboard.backlight.brightnessLevels");
	if (!keyboardBacklightLevels) {
	return levels;
	}
	std::stringstream ss(*keyboardBacklightLevels);
	while (ss.good()) {
	std::string substr;
	std::getline(ss, substr, ',');
	char* end;
	int32_t value = static_cast<int32_t>(strtol(substr.c_str(), &end, 10));
	if (*end != '\0' \|\| value < 0 \|\| value > 255) {
	ALOGE("Error parsing keyboard backlight brightness levels, provided levels = %s",
	keyboardBacklightLevels->c_str());
	levels.clear();
	break;
	}
	levels.insert(BrightnessLevel(value));
	}
	return levels;
	}

	void PeripheralController::dump(std::string& dump) {
	dump += INDENT2 "Input Controller:\n";
	if (!mLights.empty()) {
	dump += INDENT3 "Lights:\n";
	for (const auto& [lightId, light] : mLights) {
	dump += StringPrintf(INDENT4 "Id: %d", lightId);
	dump += StringPrintf(INDENT4 "Name: %s", light->name.c_str());
	dump += StringPrintf(INDENT4 "Type: %s", ftl::enum_string(light->type).c_str());
	dump += StringPrintf(INDENT4 "Capability flags: %s",
	light->capabilityFlags.string().c_str());
	light->dump(dump);
	}
	}
	// Dump raw lights
	dump += INDENT3 "RawLights:\n";
	dump += INDENT4 "Id:\t Name:\t Flags:\t Max brightness:\t Brightness\n";
	const std::vector<int32_t> rawLightIds = getDeviceContext().getRawLightIds();
	// Map from raw light id to raw light info
	std::unordered_map<int32_t, RawLightInfo> rawInfos;
	for (const auto& rawId : rawLightIds) {
	std::optional<RawLightInfo> rawInfo = getDeviceContext().getRawLightInfo(rawId);
	if (!rawInfo.has_value()) {
	continue;
	}
	dump += StringPrintf(INDENT4 "%d", rawId);
	dump += StringPrintf(INDENT4 "%s", rawInfo->name.c_str());
	dump += StringPrintf(INDENT4 "%s", rawInfo->flags.string().c_str());
	dump += StringPrintf(INDENT4 "%d", rawInfo->maxBrightness.value_or(MAX_BRIGHTNESS));
	dump += StringPrintf(INDENT4 "%d\n",
	getDeviceContext().getLightBrightness(rawId).value_or(-1));
	}

	if (!mBatteries.empty()) {
	dump += INDENT3 "Batteries:\n";
	for (const auto& [batteryId, battery] : mBatteries) {
	dump += StringPrintf(INDENT4 "Id: %d", batteryId);
	dump += StringPrintf(INDENT4 "Name: %s", battery->name.c_str());
	dump += getBatteryCapacity(batteryId).has_value()
	? StringPrintf(INDENT3 "Capacity: %d\n", getBatteryCapacity(batteryId).value())
	: StringPrintf(INDENT3 "Capacity: Unknown");

	std::string status;
	switch (getBatteryStatus(batteryId).value_or(BATTERY_STATUS_UNKNOWN)) {
	case BATTERY_STATUS_CHARGING:
	status = "Charging";
	break;
	case BATTERY_STATUS_DISCHARGING:
	status = "Discharging";
	break;
	case BATTERY_STATUS_NOT_CHARGING:
	status = "Not charging";
	break;
	case BATTERY_STATUS_FULL:
	status = "Full";
	break;
	default:
	status = "Unknown";
	}
	dump += StringPrintf(INDENT3 "Status: %s\n", status.c_str());
	}
	}
	}

	void PeripheralController::configureBattries() {
	// Check raw batteries
	const std::vector<int32_t> rawBatteryIds = getDeviceContext().getRawBatteryIds();

	for (const auto& rawId : rawBatteryIds) {
	std::optional<RawBatteryInfo> rawInfo = getDeviceContext().getRawBatteryInfo(rawId);
	if (!rawInfo.has_value()) {
	continue;
	}
	std::unique_ptr<Battery> battery =
	std::make_unique<Battery>(getDeviceContext(), rawInfo->name, rawInfo->id);
	mBatteries.insert_or_assign(rawId, std::move(battery));
	}
	}

	void PeripheralController::configureLights() {
	bool hasRedLed = false;
	bool hasGreenLed = false;
	bool hasBlueLed = false;
	std::optional<int32_t> rawGlobalId = std::nullopt;
	// Player ID light common name string
	std::string playerIdName;
	// Raw RGB color to raw light ID
	std::unordered_map<LightColor, int32_t /* rawLightId */> rawRgbIds;
	// Map from player Id to raw light Id
	std::unordered_map<int32_t, int32_t> playerIdLightIds;
	// Set of Keyboard backlights
	std::set<int32_t> keyboardBacklightIds;

	// Check raw lights
	const std::vector<int32_t> rawLightIds = getDeviceContext().getRawLightIds();
	// Map from raw light id to raw light info
	std::unordered_map<int32_t, RawLightInfo> rawInfos;
	for (const auto& rawId : rawLightIds) {
	std::optional<RawLightInfo> rawInfo = getDeviceContext().getRawLightInfo(rawId);
	if (!rawInfo.has_value()) {
	continue;
	}
	rawInfos.insert_or_assign(rawId, rawInfo.value());
	// Check if this is a group LEDs for player ID
	// The name for the light has already been parsed and is the `function`
	// value; for player ID lights the function is expected to be `player-#`.
	// However, the Sony driver will use `sony#` instead on SIXAXIS
	// gamepads.
	std::regex lightPattern("(player\|sony)-?([0-9]+)");
	std::smatch results;
	if (std::regex_match(rawInfo->name, results, lightPattern)) {
	std::string commonName = results[1].str();
	int32_t playerId = std::stoi(results[2]);
	if (playerIdLightIds.empty()) {
	playerIdName = commonName;
	playerIdLightIds.insert_or_assign(playerId, rawId);
	} else {
	// Make sure the player ID leds have common string name
	if (playerIdName.compare(commonName) == 0 &&
	playerIdLightIds.find(playerId) == playerIdLightIds.end()) {
	playerIdLightIds.insert_or_assign(playerId, rawId);
	}
	}
	}
	// Check if this is a Keyboard backlight
	if (rawInfo->flags.test(InputLightClass::KEYBOARD_BACKLIGHT)) {
	keyboardBacklightIds.insert(rawId);
	}
	// Check if this is an LED of RGB light
	if (rawInfo->flags.test(InputLightClass::RED)) {
	hasRedLed = true;
	rawRgbIds.emplace(LightColor::RED, rawId);
	}
	if (rawInfo->flags.test(InputLightClass::GREEN)) {
	hasGreenLed = true;
	rawRgbIds.emplace(LightColor::GREEN, rawId);
	}
	if (rawInfo->flags.test(InputLightClass::BLUE)) {
	hasBlueLed = true;
	rawRgbIds.emplace(LightColor::BLUE, rawId);
	}
	if (rawInfo->flags.test(InputLightClass::GLOBAL)) {
	rawGlobalId = rawId;
	}
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("Light rawId %d name %s max %d flags %s \n", rawInfo->id, rawInfo->name.c_str(),
	rawInfo->maxBrightness.value_or(MAX_BRIGHTNESS), rawInfo->flags.string().c_str());
	}
	}

	// Construct a player ID light
	if (playerIdLightIds.size() > 1) {
	std::unique_ptr<Light> light =
	std::make_unique<PlayerIdLight>(getDeviceContext(), playerIdName, ++mNextId,
	playerIdLightIds);
	mLights.insert_or_assign(light->id, std::move(light));
	// Remove these raw lights from raw light info as they've been used to compose a
	// Player ID light, so we do not expose these raw lights as mono lights.
	for (const auto& [playerId, rawId] : playerIdLightIds) {
	rawInfos.erase(rawId);
	}
	}
	// Construct a RGB light for composed RGB light
	if (hasRedLed && hasGreenLed && hasBlueLed) {
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("Rgb light ids [%d, %d, %d] \n", rawRgbIds.at(LightColor::RED),
	rawRgbIds.at(LightColor::GREEN), rawRgbIds.at(LightColor::BLUE));
	}
	bool isKeyboardBacklight = keyboardBacklightIds.find(rawRgbIds.at(LightColor::RED)) !=
	keyboardBacklightIds.end() &&
	keyboardBacklightIds.find(rawRgbIds.at(LightColor::GREEN)) !=
	keyboardBacklightIds.end() &&
	keyboardBacklightIds.find(rawRgbIds.at(LightColor::BLUE)) !=
	keyboardBacklightIds.end() &&
	(!rawGlobalId.has_value() \|\|
	keyboardBacklightIds.find(rawGlobalId.value()) != keyboardBacklightIds.end());

	std::unique_ptr<Light> light =
	std::make_unique<RgbLight>(getDeviceContext(), ++mNextId,
	isKeyboardBacklight
	? InputDeviceLightType::KEYBOARD_BACKLIGHT
	: InputDeviceLightType::INPUT,
	rawRgbIds, rawGlobalId);
	mLights.insert_or_assign(light->id, std::move(light));
	// Remove from raw light info as they've been composed a RBG light.
	rawInfos.erase(rawRgbIds.at(LightColor::RED));
	rawInfos.erase(rawRgbIds.at(LightColor::GREEN));
	rawInfos.erase(rawRgbIds.at(LightColor::BLUE));
	if (rawGlobalId.has_value()) {
	rawInfos.erase(rawGlobalId.value());
	}
	}

	// Check the rest of raw light infos
	for (const auto& [rawId, rawInfo] : rawInfos) {
	InputDeviceLightType type;
	if (keyboardBacklightIds.find(rawId) != keyboardBacklightIds.end()) {
	type = InputDeviceLightType::KEYBOARD_BACKLIGHT;
	} else if (rawInfo.flags.test(InputLightClass::KEYBOARD_MIC_MUTE)) {
	type = InputDeviceLightType::KEYBOARD_MIC_MUTE;
	} else if (rawInfo.flags.test(InputLightClass::KEYBOARD_VOLUME_MUTE)) {
	type = InputDeviceLightType::KEYBOARD_VOLUME_MUTE;
	} else {
	type = InputDeviceLightType::INPUT;
	}

	// If the node is multi-color led, construct a MULTI_COLOR light
	if (rawInfo.flags.test(InputLightClass::MULTI_INDEX) &&
	rawInfo.flags.test(InputLightClass::MULTI_INTENSITY)) {
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("Multicolor light Id %d name %s \n", rawInfo.id, rawInfo.name.c_str());
	}
	std::unique_ptr<Light> light =
	std::make_unique<MultiColorLight>(getDeviceContext(), rawInfo.name, ++mNextId,
	type, rawInfo.id);
	mLights.insert_or_assign(light->id, std::move(light));
	continue;
	}
	// Construct a Mono LED light
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("Mono light Id %d name %s \n", rawInfo.id, rawInfo.name.c_str());
	}
	std::unique_ptr<Light> light = std::make_unique<MonoLight>(getDeviceContext(), rawInfo.name,
	++mNextId, type, rawInfo.id);

	mLights.insert_or_assign(light->id, std::move(light));
	}
	}

	std::optional<int32_t> PeripheralController::getBatteryCapacity(int batteryId) {
	return getDeviceContext().getBatteryCapacity(batteryId);
	}

	std::optional<int32_t> PeripheralController::getBatteryStatus(int batteryId) {
	return getDeviceContext().getBatteryStatus(batteryId);
	}

	bool PeripheralController::setLightColor(int32_t lightId, int32_t color) {
	auto it = mLights.find(lightId);
	if (it == mLights.end()) {
	return false;
	}
	auto& light = it->second;
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("setLightColor lightId %d type %s color 0x%x", lightId,
	ftl::enum_string(light->type).c_str(), color);
	}
	return light->setLightColor(color);
	}

	std::optional<int32_t> PeripheralController::getLightColor(int32_t lightId) {
	auto it = mLights.find(lightId);
	if (it == mLights.end()) {
	return std::nullopt;
	}
	auto& light = it->second;
	std::optional<int32_t> color = light->getLightColor();
	if (DEBUG_LIGHT_DETAILS) {
	ALOGD("getLightColor lightId %d type %s color 0x%x", lightId,
	ftl::enum_string(light->type).c_str(), color.value_or(0));
	}
	return color;
	}

	bool PeripheralController::setLightPlayerId(int32_t lightId, int32_t playerId) {
	auto it = mLights.find(lightId);
	if (it == mLights.end()) {
	return false;
	}
	auto& light = it->second;
	return light->setLightPlayerId(playerId);
	}

	std::optional<int32_t> PeripheralController::getLightPlayerId(int32_t lightId) {
	auto it = mLights.find(lightId);
	if (it == mLights.end()) {
	return std::nullopt;
	}
	auto& light = it->second;
	return light->getLightPlayerId();
	}

	int32_t PeripheralController::getEventHubId() const {
	return getDeviceContext().getEventHubId();
	}
	} // namespace android