| /* |
| * |
| * Copyright (c) 2020 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. |
| */ |
| |
| #include "AllClustersCommandDelegate.h" |
| #include "WindowCoveringManager.h" |
| #include "dishwasher-mode.h" |
| #include "include/tv-callbacks.h" |
| #include "laundry-washer-controls-delegate-impl.h" |
| #include "laundry-washer-mode.h" |
| #include "operational-state-delegate-impl.h" |
| #include "rvc-modes.h" |
| #include "tcc-mode.h" |
| #include <app-common/zap-generated/attributes/Accessors.h> |
| #include <app/CommandHandler.h> |
| #include <app/att-storage.h> |
| #include <app/clusters/identify-server/identify-server.h> |
| #include <app/clusters/laundry-washer-controls-server/laundry-washer-controls-server.h> |
| #include <app/clusters/mode-base-server/mode-base-server.h> |
| #include <app/server/Server.h> |
| #include <app/util/af.h> |
| #include <lib/support/CHIPMem.h> |
| #include <new> |
| #include <platform/DeviceInstanceInfoProvider.h> |
| #include <platform/DiagnosticDataProvider.h> |
| #include <platform/PlatformManager.h> |
| #include <static-supported-temperature-levels.h> |
| #include <system/SystemPacketBuffer.h> |
| #include <transport/SessionManager.h> |
| #include <transport/raw/PeerAddress.h> |
| |
| #include <Options.h> |
| |
| using namespace chip; |
| using namespace chip::app; |
| using namespace chip::DeviceLayer; |
| |
| namespace { |
| |
| constexpr const char kChipEventFifoPathPrefix[] = "/tmp/chip_all_clusters_fifo_"; |
| LowPowerManager sLowPowerManager; |
| NamedPipeCommands sChipNamedPipeCommands; |
| AllClustersCommandDelegate sAllClustersCommandDelegate; |
| Clusters::WindowCovering::WindowCoveringManager sWindowCoveringManager; |
| |
| Clusters::TemperatureControl::AppSupportedTemperatureLevelsDelegate sAppSupportedTemperatureLevelsDelegate; |
| } // namespace |
| |
| #ifdef EMBER_AF_PLUGIN_DISHWASHER_ALARM_SERVER |
| extern void MatterDishwasherAlarmServerInit(); |
| #endif |
| |
| void OnIdentifyStart(::Identify *) |
| { |
| ChipLogProgress(Zcl, "OnIdentifyStart"); |
| } |
| |
| void OnIdentifyStop(::Identify *) |
| { |
| ChipLogProgress(Zcl, "OnIdentifyStop"); |
| } |
| |
| void OnTriggerEffect(::Identify * identify) |
| { |
| switch (identify->mCurrentEffectIdentifier) |
| { |
| case Clusters::Identify::EffectIdentifierEnum::kBlink: |
| ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kBlink"); |
| break; |
| case Clusters::Identify::EffectIdentifierEnum::kBreathe: |
| ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kBreathe"); |
| break; |
| case Clusters::Identify::EffectIdentifierEnum::kOkay: |
| ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kOkay"); |
| break; |
| case Clusters::Identify::EffectIdentifierEnum::kChannelChange: |
| ChipLogProgress(Zcl, "Clusters::Identify::EffectIdentifierEnum::kChannelChange"); |
| break; |
| default: |
| ChipLogProgress(Zcl, "No identifier effect"); |
| return; |
| } |
| } |
| |
| static Identify gIdentify0 = { |
| chip::EndpointId{ 0 }, OnIdentifyStart, OnIdentifyStop, Clusters::Identify::IdentifyTypeEnum::kVisibleIndicator, |
| OnTriggerEffect, |
| }; |
| |
| static Identify gIdentify1 = { |
| chip::EndpointId{ 1 }, OnIdentifyStart, OnIdentifyStop, Clusters::Identify::IdentifyTypeEnum::kVisibleIndicator, |
| OnTriggerEffect, |
| }; |
| |
| namespace { |
| |
| class ExampleDeviceInstanceInfoProvider : public DeviceInstanceInfoProvider |
| { |
| public: |
| void Init(DeviceInstanceInfoProvider * defaultProvider) { mDefaultProvider = defaultProvider; } |
| |
| CHIP_ERROR GetVendorName(char * buf, size_t bufSize) override { return mDefaultProvider->GetVendorName(buf, bufSize); } |
| CHIP_ERROR GetVendorId(uint16_t & vendorId) override { return mDefaultProvider->GetVendorId(vendorId); } |
| CHIP_ERROR GetProductName(char * buf, size_t bufSize) override { return mDefaultProvider->GetProductName(buf, bufSize); } |
| CHIP_ERROR GetProductId(uint16_t & productId) override { return mDefaultProvider->GetProductId(productId); } |
| CHIP_ERROR GetPartNumber(char * buf, size_t bufSize) override { return mDefaultProvider->GetPartNumber(buf, bufSize); } |
| CHIP_ERROR GetProductURL(char * buf, size_t bufSize) override { return mDefaultProvider->GetPartNumber(buf, bufSize); } |
| CHIP_ERROR GetProductLabel(char * buf, size_t bufSize) override { return mDefaultProvider->GetProductLabel(buf, bufSize); } |
| CHIP_ERROR GetSerialNumber(char * buf, size_t bufSize) override { return mDefaultProvider->GetSerialNumber(buf, bufSize); } |
| CHIP_ERROR GetManufacturingDate(uint16_t & year, uint8_t & month, uint8_t & day) override |
| { |
| return mDefaultProvider->GetManufacturingDate(year, month, day); |
| } |
| CHIP_ERROR GetHardwareVersion(uint16_t & hardwareVersion) override |
| { |
| return mDefaultProvider->GetHardwareVersion(hardwareVersion); |
| } |
| CHIP_ERROR GetHardwareVersionString(char * buf, size_t bufSize) override |
| { |
| return mDefaultProvider->GetHardwareVersionString(buf, bufSize); |
| } |
| CHIP_ERROR GetRotatingDeviceIdUniqueId(MutableByteSpan & uniqueIdSpan) override |
| { |
| return mDefaultProvider->GetRotatingDeviceIdUniqueId(uniqueIdSpan); |
| } |
| CHIP_ERROR GetProductFinish(Clusters::BasicInformation::ProductFinishEnum * finish) override; |
| CHIP_ERROR GetProductPrimaryColor(Clusters::BasicInformation::ColorEnum * primaryColor) override; |
| |
| private: |
| DeviceInstanceInfoProvider * mDefaultProvider; |
| }; |
| |
| CHIP_ERROR ExampleDeviceInstanceInfoProvider::GetProductFinish(Clusters::BasicInformation::ProductFinishEnum * finish) |
| { |
| // Our example device claims to have a Satin finish for now. We can make |
| // this configurable as needed. |
| *finish = Clusters::BasicInformation::ProductFinishEnum::kSatin; |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR ExampleDeviceInstanceInfoProvider::GetProductPrimaryColor(Clusters::BasicInformation::ColorEnum * primaryColor) |
| { |
| // Our example device claims to have a nice purple color for now. We can |
| // make this configurable as needed. |
| *primaryColor = Clusters::BasicInformation::ColorEnum::kPurple; |
| return CHIP_NO_ERROR; |
| } |
| |
| ExampleDeviceInstanceInfoProvider gExampleDeviceInstanceInfoProvider; |
| |
| } // namespace |
| |
| void ApplicationInit() |
| { |
| std::string path = kChipEventFifoPathPrefix + std::to_string(getpid()); |
| |
| if (sChipNamedPipeCommands.Start(path, &sAllClustersCommandDelegate) != CHIP_NO_ERROR) |
| { |
| ChipLogError(NotSpecified, "Failed to start CHIP NamedPipeCommands"); |
| sChipNamedPipeCommands.Stop(); |
| } |
| |
| auto * defaultProvider = GetDeviceInstanceInfoProvider(); |
| if (defaultProvider != &gExampleDeviceInstanceInfoProvider) |
| { |
| gExampleDeviceInstanceInfoProvider.Init(defaultProvider); |
| SetDeviceInstanceInfoProvider(&gExampleDeviceInstanceInfoProvider); |
| } |
| |
| #ifdef EMBER_AF_PLUGIN_DISHWASHER_ALARM_SERVER |
| MatterDishwasherAlarmServerInit(); |
| #endif |
| Clusters::TemperatureControl::SetInstance(&sAppSupportedTemperatureLevelsDelegate); |
| } |
| |
| void ApplicationShutdown() |
| { |
| // These may have been initialised via the emberAfXxxClusterInitCallback methods. We need to destroy them before shutdown. |
| Clusters::DishwasherMode::Shutdown(); |
| Clusters::LaundryWasherMode::Shutdown(); |
| Clusters::RvcCleanMode::Shutdown(); |
| Clusters::RvcRunMode::Shutdown(); |
| Clusters::RefrigeratorAndTemperatureControlledCabinetMode::Shutdown(); |
| |
| Clusters::OperationalState::Shutdown(); |
| Clusters::RvcOperationalState::Shutdown(); |
| |
| if (sChipNamedPipeCommands.Stop() != CHIP_NO_ERROR) |
| { |
| ChipLogError(NotSpecified, "Failed to stop CHIP NamedPipeCommands"); |
| } |
| } |
| |
| using namespace chip::app::Clusters::LaundryWasherControls; |
| void emberAfLaundryWasherControlsClusterInitCallback(EndpointId endpoint) |
| { |
| LaundryWasherControlsServer::SetDefaultDelegate(1, &LaundryWasherControlDelegate::getLaundryWasherControlDelegate()); |
| } |
| |
| void emberAfLowPowerClusterInitCallback(EndpointId endpoint) |
| { |
| ChipLogProgress(NotSpecified, "Setting LowPower default delegate to global manager"); |
| Clusters::LowPower::SetDefaultDelegate(endpoint, &sLowPowerManager); |
| } |
| |
| void emberAfWindowCoveringClusterInitCallback(chip::EndpointId endpoint) |
| { |
| sWindowCoveringManager.Init(endpoint); |
| Clusters::WindowCovering::SetDefaultDelegate(endpoint, &sWindowCoveringManager); |
| Clusters::WindowCovering::ConfigStatusUpdateFeatures(endpoint); |
| } |