| /* |
| * |
| * Copyright (c) 2025 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 <AppMainLoop.h> |
| #include <AppRootNode.h> |
| #include <DeviceFactoryPlatformOverride.h> |
| #include <LinuxCommissionableDataProvider.h> |
| #include <PosixAudioManager.h> |
| #include <TracingCommandLineArgument.h> |
| #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED |
| #include <TraceDecoder.h> |
| #include <TraceHandlers.h> |
| #endif |
| #include <app/DefaultSafeAttributePersistenceProvider.h> |
| #include <app/DeviceLoadStatusProvider.h> |
| #include <app/InteractionModelEngine.h> |
| #include <app/SafeAttributePersistenceProvider.h> |
| #include <app/TestEventTriggerDelegate.h> |
| #include <app/persistence/DefaultAttributePersistenceProvider.h> |
| #include <app/server-cluster/ServerClusterInterfaceRegistry.h> |
| #include <app/server/Dnssd.h> |
| #include <app/server/Server.h> |
| #include <providers/AllDevicesExampleDeviceInfoProviderImpl.h> |
| #include <providers/AllDevicesExampleDeviceInstanceInfoProviderImpl.h> |
| |
| #include <app_options/AppOptions.h> |
| #include <app_options/DeviceTypeParser.h> |
| #include <credentials/examples/DeviceAttestationCredsExample.h> |
| #include <device-factory/DeviceFactory.h> |
| #include <device/api/allocator/DynamicEndpointIdAllocator.h> |
| #include <oob-accessors/OOBAccessor.h> |
| #include <oob-accessors/OOBAccessorRegistry.h> |
| #include <platform/CommissionableDataProvider.h> |
| #include <platform/DeviceInstanceInfoProvider.h> |
| #include <platform/DiagnosticDataProvider.h> |
| #include <platform/PlatformManager.h> |
| #include <setup_payload/OnboardingCodesUtil.h> |
| #include <system/SystemLayer.h> |
| |
| #include <AppCommandDelegate.h> |
| #include <BleInit.h> |
| #include <TermHandling.h> |
| #if PW_RPC_ENABLED |
| #include <Rpc.h> |
| #include <oob-accessors/pigweed/PigweedAttributeAccessor.h> |
| #include <pigweed/rpc_services/AccessInterceptorRegistry.h> |
| #endif // PW_RPC_ENABLED |
| #include <device/api/SingleEndpoint.h> |
| #include <device/types/boolean-state-sensor/BooleanStateSensor.h> |
| #include <device/types/occupancy-sensor/OccupancySensor.h> |
| #include <device/types/on-off-light/impl/LoggingOnOffLight.h> |
| |
| using namespace chip; |
| using namespace chip::app; |
| using namespace chip::Platform; |
| using namespace chip::DeviceLayer; |
| using namespace chip::app::Clusters; |
| using namespace chip::ArgParser; |
| |
| void ApplicationShutdown(); |
| |
| namespace { |
| AppMainLoopImplementation * gMainLoopImplementation = nullptr; |
| |
| Credentials::GroupDataProviderImpl gGroupDataProvider; |
| chip::app::DefaultSafeAttributePersistenceProvider gSafeAttributePersistenceProvider; |
| DefaultTimerDelegate gTimerDelegate; |
| chip::app::PosixAudioManager gAudioManager; |
| |
| // To hold SPAKE2+ verifier, discriminator, passcode |
| LinuxCommissionableDataProvider gCommissionableDataProvider; |
| |
| AllDevicesAppCommandDelegate gAllDevicesAppCommandDelegate; |
| NamedPipeCommands gNamedPipeCommands; |
| |
| void StopSignalHandler(int /* signal */) |
| { |
| if (gMainLoopImplementation != nullptr) |
| { |
| gMainLoopImplementation->SignalSafeStopMainLoop(); |
| } |
| else |
| { |
| Server::GetInstance().GenerateShutDownEvent(); |
| // Usage of VerifyOrDie in the nested lambda instead of SuccessOrDie is intentional: |
| // The SuccessOrDie macro uses a `__err` assignment and some compilers complain about |
| // variable shadowing. |
| SuccessOrDie(SystemLayer().ScheduleLambda([]() { VerifyOrDie(PlatformMgr().StopEventLoopTask() == CHIP_NO_ERROR); })); |
| } |
| } |
| |
| class CodeDrivenDataModelDevices |
| { |
| public: |
| struct Context |
| { |
| chip::PersistentStorageDelegate & storageDelegate; |
| CommissioningWindowManager & commissioningWindowManager; |
| DeviceLayer::ConfigurationManager & configurationManager; |
| DeviceLayer::DeviceControlServer & deviceControlServer; |
| FabricTable & fabricTable; |
| Access::AccessControl & accessControl; |
| PersistentStorageDelegate & persistentStorage; |
| FailSafeContext & failSafeContext; |
| DeviceLayer::DeviceInstanceInfoProvider & deviceInstanceInfoProvider; |
| DeviceLayer::PlatformManager & platformManager; |
| Credentials::GroupDataProvider & groupDataProvider; |
| SessionManager & sessionManager; |
| DnssdServer & dnssdServer; |
| DeviceLoadStatusProvider & deviceLoadStatusProvider; |
| DeviceLayer::DiagnosticDataProvider & diagnosticDataProvider; |
| TestEventTriggerDelegate * testEventTriggerDelegate; |
| Credentials::DeviceAttestationCredentialsProvider & dacProvider; |
| EventManagement & eventManagement; |
| TimerDelegate & timerDelegate; |
| #if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED |
| TermsAndConditionsProvider & termsAndConditionsProvider; |
| #endif // CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED |
| }; |
| |
| CodeDrivenDataModelDevices(const Context & context) : |
| mContext(context), mDataModelProvider(mContext.storageDelegate, mAttributePersistence), |
| mRootNode( |
| { |
| .commissioningWindowManager = mContext.commissioningWindowManager, // |
| .configurationManager = mContext.configurationManager, // |
| .deviceControlServer = mContext.deviceControlServer, // |
| .fabricTable = mContext.fabricTable, // |
| .accessControl = mContext.accessControl, // |
| .persistentStorage = mContext.persistentStorage, // |
| .failSafeContext = mContext.failSafeContext, // |
| .deviceInstanceInfoProvider = mContext.deviceInstanceInfoProvider, // |
| .platformManager = mContext.platformManager, // |
| .groupDataProvider = mContext.groupDataProvider, // |
| .sessionManager = mContext.sessionManager, // |
| .dnssdServer = mContext.dnssdServer, // |
| .deviceLoadStatusProvider = mContext.deviceLoadStatusProvider, // |
| .diagnosticDataProvider = mContext.diagnosticDataProvider, // |
| .testEventTriggerDelegate = mContext.testEventTriggerDelegate, // |
| .dacProvider = mContext.dacProvider, // |
| .eventManagement = mContext.eventManagement, // |
| .timerDelegate = mContext.timerDelegate, // |
| #if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED |
| .termsAndConditionsProvider = mContext.termsAndConditionsProvider, |
| #endif // CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED |
| }, |
| []() { |
| BitFlags<AppRootNode::EnabledFeatures> features; |
| #if CHIP_DEVICE_CONFIG_ENABLE_WIFI |
| features.Set(AppRootNode::EnabledFeatures::kWiFi, AppOptions::GetConfig().enableWiFi); |
| #endif |
| return features; |
| }()) |
| {} |
| |
| std::set<EndpointId> GetReservedEndpointIds() const |
| { |
| std::set<EndpointId> usedIds; |
| usedIds.insert(kRootEndpointId); |
| |
| for (const auto & entry : AppOptions::GetDeviceTypeEntries()) |
| { |
| if (entry.endpoint != kInvalidEndpointId) |
| { |
| usedIds.insert(entry.endpoint); |
| } |
| } |
| return usedIds; |
| } |
| |
| CHIP_ERROR Startup() |
| { |
| ReturnErrorOnFailure(mAttributePersistence.Init(&mContext.storageDelegate)); |
| |
| DynamicEndpointIdAllocator endpointIdAllocator(GetReservedEndpointIds()); |
| endpointIdAllocator.ForceNext(kRootEndpointId); |
| ReturnErrorOnFailure(mRootNode.RootDevice().Register(endpointIdAllocator, mDataModelProvider)); |
| |
| for (const auto & entry : AppOptions::GetDeviceTypeEntries()) |
| { |
| auto device = DeviceFactory::GetInstance().Create(entry.type, entry.label); |
| |
| VerifyOrReturnError(device, CHIP_ERROR_NO_MEMORY); |
| ChipLogProgress(AppServer, "Registering device %s on endpoint %u with parent 0x%04X", entry.type.c_str(), |
| entry.endpoint, entry.parentId); |
| if (entry.endpoint != kInvalidEndpointId) |
| { |
| endpointIdAllocator.ForceNext(entry.endpoint); |
| } |
| ReturnErrorOnFailure( |
| device->Register(endpointIdAllocator, mDataModelProvider, EndpointComposition::WithParent(entry.parentId))); |
| auto oobAccessor = DeviceFactory::GetInstance().CreateAccessor(entry.type, *device); |
| if (oobAccessor) |
| { |
| OOBAccessorRegistry::Instance().Register(*oobAccessor); |
| mConstructedAccessors.push_back(std::move(oobAccessor)); |
| } |
| mConstructedDevices.push_back(std::move(device)); |
| } |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| void Shutdown() |
| { |
| mConstructedAccessors.clear(); |
| for (auto & device : mConstructedDevices) |
| { |
| device->Unregister(mDataModelProvider); |
| } |
| mConstructedDevices.clear(); |
| mRootNode.RootDevice().Unregister(mDataModelProvider); |
| } |
| |
| chip::app::CodeDrivenDataModelProvider & DataModelProvider() { return mDataModelProvider; } |
| |
| AppRootNode & RootNode() { return mRootNode; } |
| |
| const std::vector<std::unique_ptr<DeviceInterface>> & GetConstructedDevices() const { return mConstructedDevices; } |
| |
| private: |
| Context mContext; |
| chip::app::DefaultAttributePersistenceProvider mAttributePersistence; |
| chip::app::CodeDrivenDataModelProvider mDataModelProvider; |
| |
| AppRootNode mRootNode; |
| std::vector<std::unique_ptr<DeviceInterface>> mConstructedDevices; |
| |
| std::vector<std::unique_ptr<chip::app::OOBAccessor>> mConstructedAccessors; |
| }; |
| |
| void SetupNamedPipe(CodeDrivenDataModelDevices & devices, const char * namedPipePath) |
| { |
| auto deviceConfigs = AppOptions::GetDeviceTypeEntries(); |
| const auto & constructedDevices = devices.GetConstructedDevices(); |
| |
| // Calling code already checked that deviceConfigs.size() == constructedDevices.size(). |
| VerifyOrDie(deviceConfigs.size() == constructedDevices.size()); |
| |
| // TODO(#72638): The hardcoded type references to specific device implementations below prevent those |
| // classes from being selectively compiled out or stripped by LTO when they are disabled. |
| // A more generic and pluggable registration mechanism (e.g., via DeviceFactory or an interface) |
| // should be developed to allow true conditional compilation of devices. |
| for (size_t i = 0; i < deviceConfigs.size(); i++) |
| { |
| const auto & config = deviceConfigs[i]; |
| auto * device = constructedDevices[i].get(); |
| |
| if (config.type == "occupancy-sensor") |
| { |
| auto * occupancyDevice = static_cast<OccupancySensor *>(device); |
| gAllDevicesAppCommandDelegate.GetClusterImplementationRegistry() |
| .RegisterClusterInstance<chip::app::Clusters::OccupancySensingCluster>(&occupancyDevice->OccupancySensingCluster()); |
| } |
| else if (config.type == "contact-sensor" || config.type == "water-leak-detector") |
| { |
| auto * booleanStateDevice = static_cast<BooleanStateSensor *>(device); |
| gAllDevicesAppCommandDelegate.GetClusterImplementationRegistry() |
| .RegisterClusterInstance<chip::app::Clusters::BooleanStateCluster>(&booleanStateDevice->BooleanState()); |
| } |
| else if (config.type == "on-off-light") |
| { |
| auto * lightDevice = static_cast<LoggingOnOffLight *>(device); |
| gAllDevicesAppCommandDelegate.GetClusterImplementationRegistry() |
| .RegisterClusterInstance<chip::app::Clusters::OnOffCluster>(&lightDevice->OnOffCluster()); |
| } |
| else if (config.type == "ambient-context-sensor") |
| { |
| auto * ambientContextSensorDevice = static_cast<AmbientContextSensor *>(device); |
| gAllDevicesAppCommandDelegate.GetClusterImplementationRegistry() |
| .RegisterClusterInstance<chip::app::Clusters::AmbientContextSensingCluster>( |
| &ambientContextSensorDevice->AmbientContextSensingCluster()); |
| } |
| } |
| |
| gAllDevicesAppCommandDelegate.GetClusterImplementationRegistry() |
| .RegisterClusterInstance<chip::app::Clusters::BasicInformationCluster>( |
| &devices.RootNode().GetRootNode().BasicInformation()); |
| gAllDevicesAppCommandDelegate.RegisterCommandHandlers(); |
| |
| CHIP_ERROR err = gNamedPipeCommands.Start(namedPipePath, &gAllDevicesAppCommandDelegate); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(AppServer, "Failed to start named pipe at %s: %" CHIP_ERROR_FORMAT, namedPipePath, err.Format()); |
| LogErrorOnFailure(gNamedPipeCommands.Stop()); |
| } |
| } |
| |
| void RunApplication(AppMainLoopImplementation * mainLoop = nullptr) |
| { |
| gMainLoopImplementation = mainLoop; |
| |
| static chip::CommonCaseDeviceServerInitParams initParams; |
| SuccessOrDie(initParams.InitializeStaticResourcesBeforeServerInit()); |
| |
| DeviceFactory::GetInstance().Init(DeviceFactory::Context{ |
| .groupDataProvider = gGroupDataProvider, // |
| .fabricTable = Server::GetInstance().GetFabricTable(), // |
| .timerDelegate = gTimerDelegate, // |
| .storageDelegate = *initParams.persistentStorageDelegate, // |
| }); |
| |
| RegisterDeviceFactoryOverrides(gTimerDelegate, initParams.persistentStorageDelegate, gAudioManager); |
| |
| #if CHIP_CONFIG_ENABLE_GROUPCAST |
| // TODO(#72056): Once groupcast is enabled by default, this should not be dependent on the app argument. |
| if (AppOptions::GetConfig().enableGroupcast) |
| { |
| static chip::Access::Examples::GroupAuxiliaryAccessControlDelegateImpl groupAuxDelegate; |
| SuccessOrDie(groupAuxDelegate.Initialize(&gGroupDataProvider, &Server::GetInstance().GetFabricTable())); |
| initParams.groupAuxiliaryAccessControlDelegate = &groupAuxDelegate; |
| gGroupDataProvider.SetGroupcastEnabled(true); |
| } |
| #endif // CHIP_CONFIG_ENABLE_GROUPCAST |
| |
| gGroupDataProvider.SetStorageDelegate(initParams.persistentStorageDelegate); |
| gGroupDataProvider.SetSessionKeystore(initParams.sessionKeystore); |
| SuccessOrDie(gGroupDataProvider.Init()); |
| Credentials::SetGroupDataProvider(&gGroupDataProvider); |
| |
| DeviceLayer::DeviceInstanceInfoProvider * provider = DeviceLayer::GetDeviceInstanceInfoProvider(); |
| if (provider == nullptr) |
| { |
| ChipLogError(AppServer, "Failed to get the DeviceInstanceInfoProvider."); |
| chipDie(); |
| } |
| |
| // Initialize the safe attribute persistence provider |
| SuccessOrDie(gSafeAttributePersistenceProvider.Init(initParams.persistentStorageDelegate)); |
| SetSafeAttributePersistenceProvider(&gSafeAttributePersistenceProvider); |
| |
| // Set the global DAC provider before server/cluster init so any integration path that |
| // snapshots the provider during construction sees a valid implementation. |
| SetDeviceAttestationCredentialsProvider(Credentials::Examples::GetExampleDACProvider()); |
| |
| static CodeDrivenDataModelDevices devices({ |
| .storageDelegate = *initParams.persistentStorageDelegate, // |
| .commissioningWindowManager = Server::GetInstance().GetCommissioningWindowManager(), // |
| .configurationManager = DeviceLayer::ConfigurationMgr(), // |
| .deviceControlServer = DeviceLayer::DeviceControlServer::DeviceControlSvr(), // |
| .fabricTable = Server::GetInstance().GetFabricTable(), // |
| .accessControl = Server::GetInstance().GetAccessControl(), // |
| .persistentStorage = Server::GetInstance().GetPersistentStorage(), // |
| .failSafeContext = Server::GetInstance().GetFailSafeContext(), // |
| .deviceInstanceInfoProvider = *provider, // |
| .platformManager = DeviceLayer::PlatformMgr(), // |
| .groupDataProvider = gGroupDataProvider, // |
| .sessionManager = Server::GetInstance().GetSecureSessionManager(), // |
| .dnssdServer = DnssdServer::Instance(), // |
| .deviceLoadStatusProvider = *InteractionModelEngine::GetInstance(), // |
| .diagnosticDataProvider = DeviceLayer::GetDiagnosticDataProvider(), // |
| .testEventTriggerDelegate = initParams.testEventTriggerDelegate, // |
| .dacProvider = *Credentials::GetDeviceAttestationCredentialsProvider(), // |
| .eventManagement = EventManagement::GetInstance(), // |
| .timerDelegate = gTimerDelegate, // |
| |
| #if CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED |
| .termsAndConditionsProvider = TermsAndConditionsManager::GetInstance(), |
| #endif // CHIP_CONFIG_TERMS_AND_CONDITIONS_REQUIRED |
| }); |
| |
| SuccessOrDie(devices.Startup()); |
| |
| if (AppOptions::GetDeviceTypeEntries().size() != devices.GetConstructedDevices().size()) |
| { |
| ChipLogError(AppServer, "Failed to initialize some of the --device entries on command line. Cannot proceed."); |
| chipDie(); |
| } |
| |
| // Set up named pipe command handlers against the registered devices. |
| const std::string & namedPipePath = AppOptions::GetConfig().appPipePath; |
| if (!namedPipePath.empty()) |
| { |
| SetupNamedPipe(devices, namedPipePath.c_str()); |
| } |
| |
| initParams.dataModelProvider = &devices.DataModelProvider(); |
| initParams.groupDataProvider = &gGroupDataProvider; |
| initParams.operationalServicePort = AppOptions::GetConfig().port.value_or(CHIP_PORT); |
| ChipLogProgress(AppServer, "Using operationalServicePort %u\n", initParams.operationalServicePort); |
| initParams.userDirectedCommissioningPort = CHIP_UDC_PORT; |
| |
| if (AppOptions::GetConfig().interfaceId.has_value()) |
| { |
| initParams.interfaceId = |
| Inet::InterfaceId(static_cast<Inet::InterfaceId::PlatformType>(AppOptions::GetConfig().interfaceId.value())); |
| } |
| else |
| { |
| initParams.interfaceId = Inet::InterfaceId::Null(); |
| } |
| |
| #if defined(ENABLE_TRACING) && ENABLE_TRACING |
| chip::CommandLineApp::TracingSetup tracing_setup; |
| for (const auto & trace_destination : AppOptions::GetConfig().traceTo) |
| { |
| tracing_setup.EnableTracingFor(trace_destination.c_str()); |
| } |
| #endif |
| |
| #if CHIP_CONFIG_TRANSPORT_TRACE_ENABLED |
| // Note: Transport tracing options are currently not supported via the custom AppOptions parser. |
| // If transport tracing is required in the future, corresponding options should be added to AppOptions. |
| // See examples/platform/linux/Options.cpp and examples/platform/linux/AppMain.cpp for examples |
| // of how to parse transport tracing options from the command line. |
| #endif // CHIP_CONFIG_TRANSPORT_TRACE_ENABLED |
| |
| #if PW_RPC_ENABLED |
| static chip::app::PigweedAttributeAccessor sPwOobAccessor; |
| chip::rpc::PigweedDebugAccessInterceptorRegistry::Instance().Register(&sPwOobAccessor); |
| |
| chip::rpc::Init(33000); // TODO: Add an arg for Pw port. |
| ChipLogProgress(AppServer, "PW_RPC initialized."); |
| #endif // PW_RPC_ENABLED |
| |
| // Init ZCL Data Model and CHIP App Server |
| CHIP_ERROR err = Server::GetInstance().Init(initParams); |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(AppServer, "Server init failed: %" CHIP_ERROR_FORMAT, err.Format()); |
| chipDie(); |
| } |
| |
| // Now that the server has started and we are done with our startup logging, |
| // log our discovery/onboarding information again so it's not lost in the |
| // noise. |
| ConfigurationMgr().LogDeviceConfig(); |
| |
| chip::PayloadContents payload; |
| |
| payload.version = 0; |
| payload.rendezvousInformation.SetValue(RendezvousInformationFlag::kBLE); |
| |
| if (GetCommissionableDataProvider()->GetSetupPasscode(payload.setUpPINCode) != CHIP_NO_ERROR) |
| { |
| payload.setUpPINCode = CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE; |
| } |
| |
| uint16_t discriminator = 0; |
| SuccessOrDie(GetCommissionableDataProvider()->GetSetupDiscriminator(discriminator)); |
| payload.discriminator.SetLongValue(discriminator); |
| |
| SuccessOrDie(chip::DeviceLayer::GetDeviceInstanceInfoProvider()->GetVendorId(payload.vendorID)); |
| SuccessOrDie(chip::DeviceLayer::GetDeviceInstanceInfoProvider()->GetProductId(payload.productID)); |
| PrintOnboardingCodes(payload); |
| |
| chip::app::SetTerminateHandler(StopSignalHandler); |
| |
| // This message is used as a marker for when the application process has started. |
| // See: scripts/tests/chiptest/test_definition.py |
| // TODO: A cleaner and more generic mechanism needs to be developed as a follow-up. |
| // Currently other places (OTA, TV) also scrape logs for information and a better way should be |
| // possible. |
| ChipLogProgress(DeviceLayer, "===== APP STATUS: Starting event loop ====="); |
| |
| if (mainLoop != nullptr) |
| { |
| mainLoop->RunMainLoop(); |
| } |
| else |
| { |
| DeviceLayer::PlatformMgr().RunEventLoop(); |
| } |
| gMainLoopImplementation = nullptr; |
| |
| LogErrorOnFailure(gNamedPipeCommands.Stop()); |
| devices.Shutdown(); |
| Server::GetInstance().Shutdown(); |
| DeviceLayer::PlatformMgr().Shutdown(); |
| |
| #if defined(ENABLE_TRACING) && ENABLE_TRACING |
| tracing_setup.StopTracing(); |
| #endif |
| |
| ApplicationShutdown(); |
| } |
| |
| void EventHandler(const DeviceLayer::ChipDeviceEvent * event, intptr_t arg) |
| { |
| (void) arg; |
| if (event->Type == DeviceLayer::DeviceEventType::kCHIPoBLEConnectionEstablished) |
| { |
| ChipLogProgress(DeviceLayer, "Receive kCHIPoBLEConnectionEstablished"); |
| } |
| else if ((event->Type == chip::DeviceLayer::DeviceEventType::kInternetConnectivityChange)) |
| { |
| // Restart the server on connectivity change |
| DnssdServer::Instance().StartServer(); |
| } |
| } |
| |
| CHIP_ERROR InitCommissionableDataProvider(LinuxCommissionableDataProvider & provider, const AppOptions::AppConfig & config) |
| { |
| auto discriminator = config.discriminator.value_or(static_cast<uint16_t>(CHIP_DEVICE_CONFIG_USE_TEST_SETUP_DISCRIMINATOR)); |
| |
| const auto setupPasscode = MakeOptional(static_cast<uint32_t>(CHIP_DEVICE_CONFIG_USE_TEST_SETUP_PIN_CODE)); |
| const uint32_t spake2pIterationCount = Crypto::kSpake2p_Min_PBKDF_Iterations; |
| |
| Optional<std::vector<uint8_t>> serializedSpake2pVerifier = NullOptional; |
| Optional<std::vector<uint8_t>> spake2pSalt = NullOptional; |
| |
| return provider.Init( // |
| serializedSpake2pVerifier, // |
| spake2pSalt, // |
| spake2pIterationCount, // |
| setupPasscode, // |
| discriminator // |
| ); |
| } |
| |
| CHIP_ERROR Initialize(int argc, char * argv[]) |
| { |
| ChipLogProgress(AppServer, "Initializing..."); |
| ReturnErrorOnFailure(Platform::MemoryInit()); |
| |
| static HelpOptions sHelpOptions(argv[0], "Usage: all-devices-app [options]", "1.0"); |
| static OptionSet * sAppOptionSets[] = { AppOptions::GetOptions(), &sHelpOptions, nullptr }; |
| if (!ArgParser::ParseArgs(argv[0], argc, argv, sAppOptionSets)) |
| { |
| return CHIP_ERROR_INVALID_ARGUMENT; |
| } |
| |
| ReturnErrorOnFailure(AppOptions::ValidateConfig()); |
| |
| const char * kvsPath = AppOptions::GetConfig().kvsPath.empty() ? CHIP_CONFIG_KVS_PATH : AppOptions::GetConfig().kvsPath.c_str(); |
| ReturnErrorOnFailure(DeviceLayer::PersistedStorage::KeyValueStoreMgrImpl().Init(kvsPath)); |
| ReturnErrorOnFailure(DeviceLayer::PlatformMgr().InitChipStack()); |
| |
| ReturnErrorOnFailure(InitCommissionableDataProvider(gCommissionableDataProvider, AppOptions::GetConfig())); |
| DeviceLayer::SetCommissionableDataProvider(&gCommissionableDataProvider); |
| |
| static AllDevicesExampleDeviceInfoProviderImpl sExampleDeviceInfoProvider; |
| DeviceLayer::SetDeviceInfoProvider(&sExampleDeviceInfoProvider); |
| |
| const auto & config = AppOptions::GetConfig(); |
| auto vendorId = config.vendorId.has_value() ? config.vendorId : std::nullopt; |
| auto productId = config.productId.has_value() ? config.productId : std::nullopt; |
| static AllDevicesExampleDeviceInstanceInfoProviderImpl sAppDeviceInstanceInfoProvider( |
| DeviceLayer::GetDeviceInstanceInfoProvider(), vendorId, productId); |
| DeviceLayer::SetDeviceInstanceInfoProvider(&sAppDeviceInstanceInfoProvider); |
| |
| ConfigurationMgr().LogDeviceConfig(); |
| |
| ReturnErrorOnFailure(DeviceLayer::PlatformMgrImpl().AddEventHandler(EventHandler, 0)); |
| |
| ReturnErrorOnFailure(chip::app::InitBle(AppOptions::GetConfig().bleController)); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| } // namespace |
| |
| void ApplicationShutdown() |
| { |
| gAudioManager.Shutdown(); |
| } |
| |
| int main(int argc, char * argv[]) |
| { |
| ChipLogProgress(AppServer, "Initializing"); |
| |
| if (CHIP_ERROR err = Initialize(argc, argv); err != CHIP_NO_ERROR) |
| { |
| ChipLogError(AppServer, "Initialize() failed: %" CHIP_ERROR_FORMAT, err.Format()); |
| chipDie(); |
| } |
| |
| ChipLogProgress(AppServer, "Hello from all-devices-app!"); |
| RunApplication(); |
| |
| return 0; |
| } |
