| /* |
| * |
| * Copyright (c) 2021 Project CHIP Authors |
| * All rights reserved. |
| * |
| * 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. |
| */ |
| |
| /** |
| * @file DeviceCallbacks.cpp |
| * |
| * Implements all the callbacks to the application from the CHIP Stack |
| * |
| **/ |
| #include "DeviceCallbacks.h" |
| |
| #include "CHIPDeviceManager.h" |
| #include "LEDWidget.h" |
| #include <AppTask.h> |
| #include <NetworkCommissioningDriver.h> |
| #include <app-common/zap-generated/attribute-id.h> |
| #include <app-common/zap-generated/cluster-id.h> |
| #include <app/CommandHandler.h> |
| #include <app/clusters/identify-server/identify-server.h> |
| #include <app/server/Dnssd.h> |
| #include <app/util/basic-types.h> |
| #include <app/util/util.h> |
| #include <lib/dnssd/Advertiser.h> |
| #include <lib/support/CodeUtils.h> |
| |
| using namespace ::chip; |
| using namespace ::chip::Inet; |
| using namespace ::chip::System; |
| using namespace ::chip::DeviceLayer; |
| |
| uint32_t identifyTimerCount; |
| constexpr uint32_t kIdentifyTimerDelayMS = 250; |
| |
| static LEDWidget statusLED1; |
| // static LEDWidget statusLED2; |
| |
| void DeviceCallbacks::DeviceEventCallback(const ChipDeviceEvent * event, intptr_t arg) |
| { |
| switch (event->Type) |
| { |
| case DeviceEventType::kInternetConnectivityChange: |
| OnInternetConnectivityChange(event); |
| break; |
| |
| case DeviceEventType::kCHIPoBLEConnectionEstablished: |
| log_info("CHIPoBLE connection established\r\n"); |
| break; |
| |
| case DeviceEventType::kCHIPoBLEConnectionClosed: |
| log_info("CHIPoBLE disconnected\r\n"); |
| break; |
| |
| case DeviceEventType::kCommissioningComplete: |
| log_info("Commissioning complete\r\n"); |
| break; |
| |
| case DeviceEventType::kWiFiConnectivityChange: |
| log_info("Got ip, start advertise\r\n"); |
| // chip::app::DnssdServer::Instance().AdvertiseOperational(); |
| chip::app::DnssdServer::Instance().StartServer(); |
| GetAppTask().OtaTask(); |
| NetworkCommissioning::BLWiFiDriver::GetInstance().SaveConfiguration(); |
| break; |
| |
| case DeviceEventType::kInterfaceIpAddressChanged: |
| if ((event->InterfaceIpAddressChanged.Type == InterfaceIpChangeType::kIpV4_Assigned) || |
| (event->InterfaceIpAddressChanged.Type == InterfaceIpChangeType::kIpV6_Assigned)) |
| { |
| // MDNS server restart on any ip assignment: if link local ipv6 is configured, that |
| // will not trigger a 'internet connectivity change' as there is no internet |
| // connectivity. MDNS still wants to refresh its listening interfaces to include the |
| // newly selected address. |
| chip::app::DnssdServer::Instance().StartServer(); |
| } |
| break; |
| } |
| } |
| |
| void DeviceCallbacks::PostAttributeChangeCallback(EndpointId endpointId, ClusterId clusterId, AttributeId attributeId, uint8_t type, |
| uint16_t size, uint8_t * value) |
| { |
| log_info("PostAttributeChangeCallback - Cluster ID: '0x%04x', EndPoint ID: '0x%02x', Attribute ID: '0x%04x'\r\n", clusterId, |
| endpointId, attributeId); |
| |
| switch (clusterId) |
| { |
| case ZCL_ON_OFF_CLUSTER_ID: |
| OnOnOffPostAttributeChangeCallback(endpointId, attributeId, value); |
| break; |
| |
| case ZCL_IDENTIFY_CLUSTER_ID: |
| OnIdentifyPostAttributeChangeCallback(endpointId, attributeId, value); |
| break; |
| |
| case ZCL_LEVEL_CONTROL_CLUSTER_ID: |
| OnLevelControlAttributeChangeCallback(endpointId, attributeId, value); |
| break; |
| case ZCL_COLOR_CONTROL_CLUSTER_ID: |
| OnColorControlAttributeChangeCallback(endpointId, attributeId, value); |
| break; |
| default: |
| log_info("Unhandled cluster ID: %d\r\n", clusterId); |
| break; |
| } |
| |
| // TODO |
| // log_info("Current free heap: %u\r\n\n", static_cast<unsigned int>(heap_caps_get_free_size(MALLOC_CAP_8BIT))); |
| } |
| |
| void DeviceCallbacks::OnInternetConnectivityChange(const ChipDeviceEvent * event) |
| { |
| if (event->InternetConnectivityChange.IPv4 == kConnectivity_Established) |
| { |
| log_info("IPv4 Server ready...\r\n"); |
| // TODO |
| // wifiLED.Set(true); |
| chip::app::DnssdServer::Instance().StartServer(); |
| } |
| else if (event->InternetConnectivityChange.IPv4 == kConnectivity_Lost) |
| { |
| log_info("Lost IPv4 connectivity...\r\n"); |
| // TODO |
| // wifiLED.Set(false); |
| } |
| if (event->InternetConnectivityChange.IPv6 == kConnectivity_Established) |
| { |
| log_info("IPv6 Server ready...\r\n"); |
| chip::app::DnssdServer::Instance().StartServer(); |
| } |
| else if (event->InternetConnectivityChange.IPv6 == kConnectivity_Lost) |
| { |
| log_info("Lost IPv6 connectivity...\r\n"); |
| } |
| } |
| |
| void DeviceCallbacks::OnOnOffPostAttributeChangeCallback(EndpointId endpointId, AttributeId attributeId, uint8_t * value) |
| { |
| VerifyOrExit(attributeId == ZCL_ON_OFF_ATTRIBUTE_ID, log_info("Unhandled Attribute ID: '0x%04x\r\n", attributeId)); |
| VerifyOrExit(endpointId == 1 || endpointId == 2, log_info("Unexpected EndPoint ID: `0x%02x'\r\n", endpointId)); |
| |
| // At this point we can assume that value points to a bool value. |
| mEndpointOnOffState[endpointId - 1] = *value; |
| GetAppTask().LightStateUpdateEventHandler(); |
| |
| exit: |
| return; |
| } |
| |
| void DeviceCallbacks::OnLevelControlAttributeChangeCallback(EndpointId endpointId, AttributeId attributeId, uint8_t * value) |
| { |
| bool onOffState = mEndpointOnOffState[endpointId - 1]; |
| uint8_t brightness = onOffState ? *value : 0; |
| |
| VerifyOrExit(attributeId == ZCL_CURRENT_LEVEL_ATTRIBUTE_ID, log_info("Unhandled Attribute ID: '0x%04x\r\n", attributeId)); |
| VerifyOrExit(endpointId == 1 || endpointId == 2, log_error("Unexpected EndPoint ID: `0x%02x'\r\n", endpointId)); |
| |
| // At this point we can assume that value points to a bool value. |
| GetAppTask().LightStateUpdateEventHandler(); |
| |
| exit: |
| return; |
| } |
| |
| void DeviceCallbacks::OnColorControlAttributeChangeCallback(EndpointId endpointId, AttributeId attributeId, uint8_t * value) |
| { |
| VerifyOrExit(attributeId == ZCL_COLOR_CONTROL_CURRENT_HUE_ATTRIBUTE_ID || |
| attributeId == ZCL_COLOR_CONTROL_CURRENT_SATURATION_ATTRIBUTE_ID, |
| log_info("Unhandled AttributeId ID: '0x%04x\r\n", attributeId)); |
| VerifyOrExit(endpointId == 1 || endpointId == 2, log_error("Unexpected EndPoint ID: `0x%02x'\r\n", endpointId)); |
| if (endpointId == 1) |
| { |
| uint8_t hue, saturation; |
| if (attributeId == ZCL_COLOR_CONTROL_CURRENT_HUE_ATTRIBUTE_ID) |
| { |
| hue = *value; |
| emberAfReadServerAttribute(endpointId, ZCL_COLOR_CONTROL_CLUSTER_ID, ZCL_COLOR_CONTROL_CURRENT_SATURATION_ATTRIBUTE_ID, |
| &saturation, sizeof(uint8_t)); |
| } |
| else |
| { |
| saturation = *value; |
| emberAfReadServerAttribute(endpointId, ZCL_COLOR_CONTROL_CLUSTER_ID, ZCL_COLOR_CONTROL_CURRENT_HUE_ATTRIBUTE_ID, &hue, |
| sizeof(uint8_t)); |
| } |
| statusLED1.SetColor(hue, saturation); |
| } |
| exit: |
| return; |
| } |
| |
| void IdentifyTimerHandler(Layer * systemLayer, void * appState) |
| { |
| statusLED1.Animate(); |
| |
| if (identifyTimerCount) |
| { |
| systemLayer->StartTimer(Clock::Milliseconds32(kIdentifyTimerDelayMS), IdentifyTimerHandler, appState); |
| // Decrement the timer count. |
| identifyTimerCount--; |
| } |
| } |
| |
| void DeviceCallbacks::OnIdentifyPostAttributeChangeCallback(EndpointId endpointId, AttributeId attributeId, uint8_t * value) |
| { |
| VerifyOrExit(attributeId == ZCL_IDENTIFY_TIME_ATTRIBUTE_ID, log_info("Unhandled Attribute ID: '0x%04x\r\n", attributeId)); |
| VerifyOrExit(endpointId == 1, log_error("Unexpected EndPoint ID: `0x%02x'\r\n", endpointId)); |
| |
| statusLED1.Blink(kIdentifyTimerDelayMS * 2); |
| |
| // timerCount represents the number of callback executions before we stop the timer. |
| // value is expressed in seconds and the timer is fired every 250ms, so just multiply value by 4. |
| // Also, we want timerCount to be odd number, so the ligth state ends in the same state it starts. |
| identifyTimerCount = (*value) * 4; |
| |
| DeviceLayer::SystemLayer().CancelTimer(IdentifyTimerHandler, this); |
| DeviceLayer::SystemLayer().StartTimer(Clock::Milliseconds32(kIdentifyTimerDelayMS), IdentifyTimerHandler, this); |
| |
| exit: |
| return; |
| } |
| |
| bool emberAfBasicClusterMfgSpecificPingCallback(chip::app::CommandHandler * commandObj) |
| { |
| emberAfSendDefaultResponse(emberAfCurrentCommand(), EMBER_ZCL_STATUS_SUCCESS); |
| return true; |
| } |
| |
| void OnIdentifyStart(Identify *) |
| { |
| ChipLogProgress(Zcl, "OnIdentifyStart"); |
| } |
| |
| void OnIdentifyStop(Identify *) |
| { |
| ChipLogProgress(Zcl, "OnIdentifyStop"); |
| } |
| |
| void OnTriggerEffect(Identify * identify) |
| { |
| switch (identify->mCurrentEffectIdentifier) |
| { |
| case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK: |
| ChipLogProgress(Zcl, "EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK"); |
| break; |
| case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BREATHE: |
| ChipLogProgress(Zcl, "EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BREATHE"); |
| break; |
| case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_OKAY: |
| ChipLogProgress(Zcl, "EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_OKAY"); |
| break; |
| case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_CHANNEL_CHANGE: |
| break; |
| default: |
| ChipLogProgress(Zcl, "No identifier effect"); |
| return; |
| } |
| } |
| |
| static Identify gIdentify1 = { |
| chip::EndpointId{ 1 }, OnIdentifyStart, OnIdentifyStop, EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_VISIBLE_LED, OnTriggerEffect, |
| }; |