blob: 22c83a8b9fd788aae01cb062e77653c6bbc6ea13 [file] [log] [blame]
/*
*
* Copyright (c) 2020-2024 Project CHIP Authors
*
* 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 "binding-handler.h"
#include "AppConfig.h"
#include "IdentifyCommand.h"
#include "app/CommandSender.h"
#include "app/clusters/bindings/BindingManager.h"
#include "app/server/Server.h"
#include "controller/InvokeInteraction.h"
#include "platform/CHIPDeviceLayer.h"
#include <app/clusters/bindings/bindings.h>
#include <lib/support/CodeUtils.h>
#if defined(CONFIG_CHIP_LIB_SHELL)
#include "lib/shell/Engine.h"
#include "lib/shell/commands/Help.h"
#endif // CONFIG_CHIP_LIB_SHELL
LOG_MODULE_DECLARE(app, CONFIG_CHIP_APP_LOG_LEVEL);
using namespace chip;
using namespace chip::app;
#if defined(CONFIG_CHIP_LIB_SHELL)
using Shell::Engine;
using Shell::shell_command_t;
using Shell::streamer_get;
using Shell::streamer_printf;
Engine sShellSwitchSubCommands;
Engine sShellSwitchOnOffSubCommands;
Engine sShellSwitchGroupsSubCommands;
Engine sShellSwitchGroupsOnOffSubCommands;
Engine sShellSwitchBindingSubCommands;
#endif // defined(CONFIG_CHIP_LIB_SHELL)
namespace {
void ProcessOnOffUnicastBindingCommand(CommandId commandId, const EmberBindingTableEntry & binding,
Messaging::ExchangeManager * exchangeMgr, const SessionHandle & sessionHandle)
{
auto onSuccess = [](const ConcreteCommandPath & commandPath, const StatusIB & status, const auto & dataResponse) {
ChipLogProgress(NotSpecified, "OnOff command succeeds");
};
auto onFailure = [](CHIP_ERROR error) {
ChipLogError(NotSpecified, "OnOff command failed: %" CHIP_ERROR_FORMAT, error.Format());
};
switch (commandId)
{
case Clusters::OnOff::Commands::Toggle::Id:
Clusters::OnOff::Commands::Toggle::Type toggleCommand;
Controller::InvokeCommandRequest(exchangeMgr, sessionHandle, binding.remote, toggleCommand, onSuccess, onFailure);
break;
case Clusters::OnOff::Commands::On::Id:
Clusters::OnOff::Commands::On::Type onCommand;
Controller::InvokeCommandRequest(exchangeMgr, sessionHandle, binding.remote, onCommand, onSuccess, onFailure);
break;
case Clusters::OnOff::Commands::Off::Id:
Clusters::OnOff::Commands::Off::Type offCommand;
Controller::InvokeCommandRequest(exchangeMgr, sessionHandle, binding.remote, offCommand, onSuccess, onFailure);
break;
}
}
void ProcessOnOffGroupBindingCommand(CommandId commandId, const EmberBindingTableEntry & binding)
{
Messaging::ExchangeManager & exchangeMgr = Server::GetInstance().GetExchangeManager();
switch (commandId)
{
case Clusters::OnOff::Commands::Toggle::Id:
Clusters::OnOff::Commands::Toggle::Type toggleCommand;
Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, toggleCommand);
break;
case Clusters::OnOff::Commands::On::Id:
Clusters::OnOff::Commands::On::Type onCommand;
Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, onCommand);
break;
case Clusters::OnOff::Commands::Off::Id:
Clusters::OnOff::Commands::Off::Type offCommand;
Controller::InvokeGroupCommandRequest(&exchangeMgr, binding.fabricIndex, binding.groupId, offCommand);
break;
}
}
void LightSwitchChangedHandler(const EmberBindingTableEntry & binding, OperationalDeviceProxy * peer_device, void * context)
{
VerifyOrReturn(context != nullptr, ChipLogError(NotSpecified, "OnDeviceConnectedFn: context is null"));
BindingCommandData * data = static_cast<BindingCommandData *>(context);
data->isGroup = IsGroupBound();
if (data->isReadAttribute)
{
// It should always enter here if isReadAttribute is true
if (binding.type == MATTER_UNICAST_BINDING && !data->isGroup)
{
switch (data->clusterId)
{
case Clusters::Identify::Id:
ProcessIdentifyUnicastBindingRead(data, binding, peer_device);
break;
}
}
}
else
{
if (binding.type == MATTER_MULTICAST_BINDING && data->isGroup)
{
switch (data->clusterId)
{
case Clusters::Identify::Id:
ProcessIdentifyGroupBindingCommand(data, binding);
break;
case Clusters::OnOff::Id:
ProcessOnOffGroupBindingCommand(data->commandId, binding);
break;
}
}
else if (binding.type == MATTER_UNICAST_BINDING && !data->isGroup)
{
switch (data->clusterId)
{
case Clusters::Identify::Id:
ProcessIdentifyUnicastBindingCommand(data, binding, peer_device);
break;
case Clusters::OnOff::Id:
VerifyOrDie(peer_device != nullptr && peer_device->ConnectionReady());
ProcessOnOffUnicastBindingCommand(data->commandId, binding, peer_device->GetExchangeManager(),
peer_device->GetSecureSession().Value());
break;
}
}
}
}
void LightSwitchContextReleaseHandler(void * context)
{
VerifyOrReturn(context != nullptr, ChipLogError(NotSpecified, "Invalid context for Light switch context release handler"));
Platform::Delete(static_cast<BindingCommandData *>(context));
}
#ifdef CONFIG_CHIP_LIB_SHELL
/********************************************************
* Switch shell functions
*********************************************************/
CHIP_ERROR SwitchHelpHandler(int argc, char ** argv)
{
sShellSwitchSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
return CHIP_NO_ERROR;
}
CHIP_ERROR SwitchCommandHandler(int argc, char ** argv)
{
if (argc == 0)
{
return SwitchHelpHandler(argc, argv);
}
return sShellSwitchSubCommands.ExecCommand(argc, argv);
}
/********************************************************
* OnOff switch shell functions
*********************************************************/
CHIP_ERROR OnOffHelpHandler(int argc, char ** argv)
{
sShellSwitchOnOffSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
return CHIP_NO_ERROR;
}
CHIP_ERROR OnOffSwitchCommandHandler(int argc, char ** argv)
{
if (argc == 0)
{
return OnOffHelpHandler(argc, argv);
}
return sShellSwitchOnOffSubCommands.ExecCommand(argc, argv);
}
CHIP_ERROR OnSwitchCommandHandler(int argc, char ** argv)
{
BindingCommandData * data = Platform::New<BindingCommandData>();
data->commandId = Clusters::OnOff::Commands::On::Id;
data->clusterId = Clusters::OnOff::Id;
DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
return CHIP_NO_ERROR;
}
CHIP_ERROR OffSwitchCommandHandler(int argc, char ** argv)
{
BindingCommandData * data = Platform::New<BindingCommandData>();
data->commandId = Clusters::OnOff::Commands::Off::Id;
data->clusterId = Clusters::OnOff::Id;
DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
return CHIP_NO_ERROR;
}
CHIP_ERROR ToggleSwitchCommandHandler(int argc, char ** argv)
{
BindingCommandData * data = Platform::New<BindingCommandData>();
data->commandId = Clusters::OnOff::Commands::Toggle::Id;
data->clusterId = Clusters::OnOff::Id;
DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
return CHIP_NO_ERROR;
}
/********************************************************
* bind switch shell functions
*********************************************************/
CHIP_ERROR BindingHelpHandler(int argc, char ** argv)
{
sShellSwitchBindingSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
return CHIP_NO_ERROR;
}
CHIP_ERROR BindingSwitchCommandHandler(int argc, char ** argv)
{
if (argc == 0)
{
return BindingHelpHandler(argc, argv);
}
return sShellSwitchBindingSubCommands.ExecCommand(argc, argv);
}
CHIP_ERROR BindingGroupBindCommandHandler(int argc, char ** argv)
{
VerifyOrReturnError(argc == 2, CHIP_ERROR_INVALID_ARGUMENT);
EmberBindingTableEntry * entry = Platform::New<EmberBindingTableEntry>();
entry->type = MATTER_MULTICAST_BINDING;
entry->fabricIndex = atoi(argv[0]);
entry->groupId = atoi(argv[1]);
entry->local = 1; // Hardcoded to endpoint 1 for now
entry->clusterId.emplace(6); // Hardcoded to OnOff cluster for now
DeviceLayer::PlatformMgr().ScheduleWork(BindingWorkerFunction, reinterpret_cast<intptr_t>(entry));
return CHIP_NO_ERROR;
}
CHIP_ERROR BindingUnicastBindCommandHandler(int argc, char ** argv)
{
VerifyOrReturnError(argc == 3, CHIP_ERROR_INVALID_ARGUMENT);
EmberBindingTableEntry * entry = Platform::New<EmberBindingTableEntry>();
entry->type = MATTER_UNICAST_BINDING;
entry->fabricIndex = atoi(argv[0]);
entry->nodeId = atoi(argv[1]);
entry->local = 1; // Hardcoded to endpoint 1 for now
entry->remote = atoi(argv[2]);
entry->clusterId.emplace(6); // Hardcode to OnOff cluster for now
DeviceLayer::PlatformMgr().ScheduleWork(BindingWorkerFunction, reinterpret_cast<intptr_t>(entry));
return CHIP_NO_ERROR;
}
/********************************************************
* Groups switch shell functions
*********************************************************/
CHIP_ERROR GroupsHelpHandler(int argc, char ** argv)
{
sShellSwitchGroupsSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
return CHIP_NO_ERROR;
}
CHIP_ERROR GroupsSwitchCommandHandler(int argc, char ** argv)
{
if (argc == 0)
{
return GroupsHelpHandler(argc, argv);
}
return sShellSwitchGroupsSubCommands.ExecCommand(argc, argv);
}
/********************************************************
* Groups OnOff switch shell functions
*********************************************************/
CHIP_ERROR GroupsOnOffHelpHandler(int argc, char ** argv)
{
sShellSwitchGroupsOnOffSubCommands.ForEachCommand(Shell::PrintCommandHelp, nullptr);
return CHIP_NO_ERROR;
}
CHIP_ERROR GroupsOnOffSwitchCommandHandler(int argc, char ** argv)
{
if (argc == 0)
{
return GroupsOnOffHelpHandler(argc, argv);
}
return sShellSwitchGroupsOnOffSubCommands.ExecCommand(argc, argv);
}
CHIP_ERROR GroupOnSwitchCommandHandler(int argc, char ** argv)
{
BindingCommandData * data = Platform::New<BindingCommandData>();
data->commandId = Clusters::OnOff::Commands::On::Id;
data->clusterId = Clusters::OnOff::Id;
data->isGroup = true;
DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
return CHIP_NO_ERROR;
}
CHIP_ERROR GroupOffSwitchCommandHandler(int argc, char ** argv)
{
BindingCommandData * data = Platform::New<BindingCommandData>();
data->commandId = Clusters::OnOff::Commands::Off::Id;
data->clusterId = Clusters::OnOff::Id;
data->isGroup = true;
DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
return CHIP_NO_ERROR;
}
CHIP_ERROR GroupToggleSwitchCommandHandler(int argc, char ** argv)
{
BindingCommandData * data = Platform::New<BindingCommandData>();
data->commandId = Clusters::OnOff::Commands::Toggle::Id;
data->clusterId = Clusters::OnOff::Id;
data->isGroup = true;
DeviceLayer::PlatformMgr().ScheduleWork(SwitchWorkerFunction, reinterpret_cast<intptr_t>(data));
return CHIP_NO_ERROR;
}
/**
* @brief configures switch matter shell
*
*/
static void RegisterSwitchCommands()
{
static const shell_command_t sSwitchSubCommands[] = {
{ &SwitchHelpHandler, "help", "Usage: switch <subcommand>" },
{ &IdentifySwitchCommandHandler, "identify", " Usage: switch identify <subcommand>" },
{ &OnOffSwitchCommandHandler, "onoff", " Usage: switch onoff <subcommand>" },
{ &GroupsSwitchCommandHandler, "groups", "Usage: switch groups <subcommand>" },
{ &BindingSwitchCommandHandler, "binding", "Usage: switch binding <subcommand>" }
};
static const shell_command_t sSwitchIdentifySubCommands[] = {
{ &IdentifyHelpHandler, "help", "Usage: switch identify <subcommand>" },
{ &IdentifyCommandHandler, "identify", "identify Usage: switch identify identify" },
{ &TriggerEffectSwitchCommandHandler, "triggereffect", "triggereffect Usage: switch identify triggereffect" },
{ &IdentifyRead, "read", "Usage : switch identify read <attribute>" }
};
static const shell_command_t sSwitchIdentifyReadSubCommands[] = {
{ &IdentifyReadHelpHandler, "help", "Usage : switch identify read <attribute>" },
{ &IdentifyReadAttributeList, "attlist", "Read attribute list" },
{ &IdentifyReadIdentifyTime, "identifytime", "Read identifytime attribute" },
{ &IdentifyReadIdentifyType, "identifytype", "Read identifytype attribute" },
};
static const shell_command_t sSwitchOnOffSubCommands[] = {
{ &OnOffHelpHandler, "help", "Usage : switch ononff <subcommand>" },
{ &OnSwitchCommandHandler, "on", "Sends on command to bound lighting app" },
{ &OffSwitchCommandHandler, "off", "Sends off command to bound lighting app" },
{ &ToggleSwitchCommandHandler, "toggle", "Sends toggle command to bound lighting app" }
};
static const shell_command_t sSwitchGroupsSubCommands[] = { { &GroupsHelpHandler, "help", "Usage: switch groups <subcommand>" },
{ &GroupsOnOffSwitchCommandHandler, "onoff",
"Usage: switch groups onoff <subcommand>" } };
static const shell_command_t sSwitchGroupsIdentifySubCommands[] = {
{ &GroupsIdentifyHelpHandler, "help", "Usage: switch groups onoff <subcommand>" },
{ &GroupIdentifyCommandHandler, "identify", "Sends identify command to bound group" },
{ &GroupTriggerEffectSwitchCommandHandler, "triggereffect", "Sends triggereffect command to group" },
};
static const shell_command_t sSwitchGroupsOnOffSubCommands[] = {
{ &GroupsOnOffHelpHandler, "help", "Usage: switch groups onoff <subcommand>" },
{ &GroupOnSwitchCommandHandler, "on", "Sends on command to bound group" },
{ &GroupOffSwitchCommandHandler, "off", "Sends off command to bound group" },
{ &GroupToggleSwitchCommandHandler, "toggle", "Sends toggle command to group" }
};
static const shell_command_t sSwitchBindingSubCommands[] = {
{ &BindingHelpHandler, "help", "Usage: switch binding <subcommand>" },
{ &BindingGroupBindCommandHandler, "group", "Usage: switch binding group <fabric index> <group id>" },
{ &BindingUnicastBindCommandHandler, "unicast", "Usage: switch binding group <fabric index> <node id> <endpoint>" }
};
static const shell_command_t sSwitchCommand = { &SwitchCommandHandler, "switch",
"Light-switch commands. Usage: switch <subcommand>" };
sShellSwitchGroupsIdentifySubCommands.RegisterCommands(sSwitchGroupsIdentifySubCommands,
ArraySize(sSwitchGroupsIdentifySubCommands));
sShellSwitchGroupsOnOffSubCommands.RegisterCommands(sSwitchGroupsOnOffSubCommands, ArraySize(sSwitchGroupsOnOffSubCommands));
sShellSwitchIdentifySubCommands.RegisterCommands(sSwitchIdentifySubCommands, ArraySize(sSwitchIdentifySubCommands));
sShellSwitchIdentifyReadSubCommands.RegisterCommands(sSwitchIdentifyReadSubCommands, ArraySize(sSwitchIdentifyReadSubCommands));
sShellSwitchOnOffSubCommands.RegisterCommands(sSwitchOnOffSubCommands, ArraySize(sSwitchOnOffSubCommands));
sShellSwitchGroupsSubCommands.RegisterCommands(sSwitchGroupsSubCommands, ArraySize(sSwitchGroupsSubCommands));
sShellSwitchBindingSubCommands.RegisterCommands(sSwitchBindingSubCommands, ArraySize(sSwitchBindingSubCommands));
sShellSwitchSubCommands.RegisterCommands(sSwitchSubCommands, ArraySize(sSwitchSubCommands));
Engine::Root().RegisterCommands(&sSwitchCommand, 1);
}
#endif // CONFIG_CHIP_LIB_SHELL
void InitBindingHandlerInternal(intptr_t arg)
{
auto & server = chip::Server::GetInstance();
chip::BindingManager::GetInstance().Init(
{ &server.GetFabricTable(), server.GetCASESessionManager(), &server.GetPersistentStorage() });
chip::BindingManager::GetInstance().RegisterBoundDeviceChangedHandler(LightSwitchChangedHandler);
chip::BindingManager::GetInstance().RegisterBoundDeviceContextReleaseHandler(LightSwitchContextReleaseHandler);
}
} // namespace
/********************************************************
* Switch functions
*********************************************************/
bool IsGroupBound()
{
BindingTable & bindingTable = BindingTable::GetInstance();
for (auto & entry : bindingTable)
{
if (MATTER_MULTICAST_BINDING == entry.type)
{
return true;
}
}
return false;
}
void SwitchWorkerFunction(intptr_t context)
{
VerifyOrReturn(context != 0, ChipLogError(NotSpecified, "SwitchWorkerFunction - Invalid work data"));
BindingCommandData * data = reinterpret_cast<BindingCommandData *>(context);
BindingManager::GetInstance().NotifyBoundClusterChanged(data->localEndpointId, data->clusterId, static_cast<void *>(data));
}
void BindingWorkerFunction(intptr_t context)
{
VerifyOrReturn(context != 0, ChipLogError(NotSpecified, "BindingWorkerFunction - Invalid work data"));
EmberBindingTableEntry * entry = reinterpret_cast<EmberBindingTableEntry *>(context);
AddBindingEntry(*entry);
Platform::Delete(entry);
}
CHIP_ERROR InitBindingHandler()
{
// The initialization of binding manager will try establishing connection with unicast peers
// so it requires the Server instance to be correctly initialized. Post the init function to
// the event queue so that everything is ready when initialization is conducted.
chip::DeviceLayer::PlatformMgr().ScheduleWork(InitBindingHandlerInternal);
#if defined(CONFIG_CHIP_LIB_SHELL)
RegisterSwitchCommands();
#endif
return CHIP_NO_ERROR;
}