iOS TvCasting app: Implemented commissioner discovery and UDC requests (

#19491)

* iOS TvCasting app: Implemented commissioner discovery and UDC requests

* Addressing review comments, adding Discover button to Commissioner Discovery UI, using optional Bools to denote the state of the CommissioningView

config/ios/CHIPProjectConfig.h

@@ -40,6 +40,8 @@
 
 #define CHIP_CONFIG_MAX_SOFTWARE_VERSION_LENGTH 128
 
+#ifndef CHIP_CONFIG_KVS_PATH
 #define CHIP_CONFIG_KVS_PATH "chip.store"
+#endif
 
 #endif /* CHIPPROJECTCONFIG_H */

examples/tv-casting-app/darwin/TvCasting/MatterBridge/CastingServerBridge.h

@@ -15,17 +15,28 @@
  * limitations under the License.
  */
 
+#import "DiscoveredNodeData.h"
 #import <Foundation/Foundation.h>
 
 #ifndef CastingServerBridge_h
 #define CastingServerBridge_h
 
 @interface CastingServerBridge : NSObject
 
-+ (CastingServerBridge *)getSharedInstance;
++ (CastingServerBridge * _Nullable)getSharedInstance;
 
-// TBD: placeholder will be replaced with true CastingServer functions
-- (int)add:(int)a secondNum:(int)b;
+- (void)discoverCommissioners:(dispatch_queue_t _Nonnull)clientQueue
+ discoveryRequestSentHandler:(nullable void (^)(bool))discoveryRequestSentHandler;
+
+- (void)getDiscoveredCommissioner:(int)index
+ clientQueue:(dispatch_queue_t _Nonnull)clientQueue
+ discoveredCommissionerHandler:(nullable void (^)(DiscoveredNodeData * _Nullable))discoveredCommissionerHandler;
+
+- (void)sendUserDirectedCommissioningRequest:(NSString * _Nonnull)commissionerIpAddress
+ commissionerPort:(uint16_t)commissionerPort
+ platformInterface:(unsigned int)platformInterface
+ clientQueue:(dispatch_queue_t _Nonnull)clientQueue
+ udcRequestSentHandler:(nullable void (^)(bool))udcRequestSentHandler;
 
 @end
 

examples/tv-casting-app/darwin/TvCasting/MatterBridge/CastingServerBridge.mm

@@ -18,12 +18,21 @@
 #import "CastingServerBridge.h"
 #import "CastingServer.h"
 
+#import "DiscoveredNodeDataConverter.hpp"
+
 #include <lib/support/CHIPMem.h>
 #include <platform/PlatformManager.h>
 
+@interface CastingServerBridge ()
+
+// queue used to serialize all work performed by the CastingServerBridge
+@property (atomic, readonly) dispatch_queue_t chipWorkQueue;
+
+@end
+
 @implementation CastingServerBridge
 
-+ (CastingServerBridge *)getSharedInstance
++ (CastingServerBridge * _Nullable)getSharedInstance
 {
  static CastingServerBridge * instance = nil;
  static dispatch_once_t onceToken;
@@ -48,15 +57,100 @@ - (instancetype)init
  return nil;
  }
 
+ // init app Server
+ static chip::CommonCaseDeviceServerInitParams initParams;
+ err = initParams.InitializeStaticResourcesBeforeServerInit();
+ if (err != CHIP_NO_ERROR) {
+ ChipLogError(AppServer, "InitializeStaticResourcesBeforeServerInit failed: %s", ErrorStr(err));
+ return nil;
+ }
+ err = chip::Server::GetInstance().Init(initParams);
+ if (err != CHIP_NO_ERROR) {
+ ChipLogError(AppServer, "chip::Server init failed: %s", ErrorStr(err));
+ return nil;
+ }
+
+ _chipWorkQueue = chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue();
+
+ chip::DeviceLayer::PlatformMgrImpl().StartEventLoopTask();
+
  CastingServer::GetInstance()->Init();
  }
  return self;
 }
 
-// TBD: placeholder will be replaced with true CastingServer functions
-- (int)add:(int)a secondNum:(int)b
+- (void)discoverCommissioners:(dispatch_queue_t _Nonnull)clientQueue
+ discoveryRequestSentHandler:(nullable void (^)(bool))discoveryRequestSentHandler
 {
- return a + b;
+ ChipLogProgress(AppServer, "CastingServerBridge().discoverCommissioners() called");
+ dispatch_async(_chipWorkQueue, ^{
+ bool discoveryRequestStatus = true;
+ CHIP_ERROR err = CastingServer::GetInstance()->DiscoverCommissioners();
+ if (err != CHIP_NO_ERROR) {
+ ChipLogError(AppServer, "CastingServerBridge().discoverCommissioners() failed: %" CHIP_ERROR_FORMAT, err.Format());
+ discoveryRequestStatus = false;
+ }
+
+ dispatch_async(clientQueue, ^{
+ discoveryRequestSentHandler(discoveryRequestStatus);
+ });
+ });
+}
+
+- (void)getDiscoveredCommissioner:(int)index
+ clientQueue:(dispatch_queue_t _Nonnull)clientQueue
+ discoveredCommissionerHandler:(nullable void (^)(DiscoveredNodeData * _Nullable))discoveredCommissionerHandler
+{
+ ChipLogProgress(AppServer, "CastingServerBridge().getDiscoveredCommissioner() called");
+
+ dispatch_async(_chipWorkQueue, ^{
+ DiscoveredNodeData * commissioner = nil;
+ const chip::Dnssd::DiscoveredNodeData * chipDiscoveredNodeData
+ = CastingServer::GetInstance()->GetDiscoveredCommissioner(index);
+ if (chipDiscoveredNodeData != nullptr) {
+ commissioner = [DiscoveredNodeDataConverter convertToObjC:chipDiscoveredNodeData];
+ }
+
+ dispatch_async(clientQueue, ^{
+ discoveredCommissionerHandler(commissioner);
+ });
+ });
 }
 
+- (void)sendUserDirectedCommissioningRequest:(NSString * _Nonnull)commissionerIpAddress
+ commissionerPort:(uint16_t)commissionerPort
+ platformInterface:(unsigned int)platformInterface
+ clientQueue:(dispatch_queue_t _Nonnull)clientQueue
+ udcRequestSentHandler:(nullable void (^)(bool))udcRequestSentHandler
+{
+ ChipLogProgress(
+ AppServer, "CastingServerBridge().sendUserDirectedCommissioningRequest() called with port %d", commissionerPort);
+
+ dispatch_async(chip::DeviceLayer::PlatformMgrImpl().GetWorkQueue(), ^{
+ bool udcRequestStatus;
+ chip::Inet::IPAddress commissionerAddrInet;
+ if (chip::Inet::IPAddress::FromString([commissionerIpAddress UTF8String], commissionerAddrInet) == false) {
+ ChipLogError(AppServer, "CastingServerBridge().sendUserDirectedCommissioningRequest() failed to parse IP address");
+ udcRequestStatus = false;
+ } else {
+ chip::Inet::InterfaceId interfaceId = chip::Inet::InterfaceId(platformInterface);
+
+ chip::Transport::PeerAddress commissionerPeerAddress
+ = chip::Transport::PeerAddress::UDP(commissionerAddrInet, commissionerPort, interfaceId);
+
+ CHIP_ERROR err = CastingServer::GetInstance()->SendUserDirectedCommissioningRequest(commissionerPeerAddress);
+ if (err != CHIP_NO_ERROR) {
+ ChipLogError(AppServer, "CastingServerBridge().sendUserDirectedCommissioningRequest() failed: %" CHIP_ERROR_FORMAT,
+ err.Format());
+ udcRequestStatus = false;
+ } else {
+ udcRequestStatus = true;
+ }
+ }
+
+ dispatch_async(clientQueue, ^{
+ udcRequestSentHandler(udcRequestStatus);
+ });
+ });
+}
 @end

examples/tv-casting-app/darwin/TvCasting/MatterBridge/DiscoveredNodeData.h

@@ -0,0 +1,59 @@
+/**
+ *
+ * Copyright (c) 2020-2022 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#ifndef DiscoveredNodeData_h
+#define DiscoveredNodeData_h
+
+@interface DiscoveredNodeData : NSObject
+
+@property NSString * deviceName;
+
+@property uint16_t vendorId;
+
+@property uint16_t productId;
+
+@property uint16_t deviceType;
+
+@property uint16_t longDiscriminator;
+
+@property uint8_t commissioningMode;
+
+@property uint16_t pairingHint;
+
+@property const uint8_t * rotatingId;
+
+@property size_t rotatingIdLen;
+
+@property NSString * instanceName;
+
+@property uint16_t port;
+
+@property NSString * hostName;
+
+@property unsigned int platformInterface;
+
+@property NSMutableArray * ipAddresses;
+
+@property size_t numIPs;
+
+- (DiscoveredNodeData *)initWithDeviceName:(NSString *)deviceName vendorId:(uint16_t)vendorId productId:(uint16_t)productId;
+
+@end
+
+#endif /* DiscoveredNodeData_h */

examples/tv-casting-app/darwin/TvCasting/MatterBridge/DiscoveredNodeData.mm

@@ -0,0 +1,73 @@
+/**
+ *
+ * Copyright (c) 2020-2022 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "DiscoveredNodeData.h"
+#include <lib/dnssd/Resolver.h>
+
+@implementation DiscoveredNodeData
+
+- (DiscoveredNodeData *)initWithDeviceName:(NSString *)deviceName vendorId:(uint16_t)vendorId productId:(uint16_t)productId
+{
+ self = [super init];
+ if (self) {
+ _deviceName = deviceName;
+ _vendorId = vendorId;
+ _productId = productId;
+ }
+ return self;
+}
+
+- (NSString *)description
+{
+ return [NSString stringWithFormat:@"%@ with Product ID: %d and Vendor ID: %d", _deviceName, _productId, _vendorId];
+}
+
+- (BOOL)isEqualToDiscoveredNodeData:(DiscoveredNodeData *)other
+{
+ return [self.instanceName isEqualToString:other.instanceName];
+}
+
+- (BOOL)isEqual:(id)other
+{
+ if (other == nil) {
+ return NO;
+ }
+
+ if (self == other) {
+ return YES;
+ }
+
+ if (![other isKindOfClass:[DiscoveredNodeData class]]) {
+ return NO;
+ }
+
+ return [self isEqualToDiscoveredNodeData:(DiscoveredNodeData *) other];
+}
+
+- (NSUInteger)hash
+{
+ const NSUInteger prime = 31;
+ NSUInteger result = 1;
+
+ result = prime * result + [self.instanceName hash];
+
+ return result;
+}
+
+@end

examples/tv-casting-app/darwin/TvCasting/MatterBridge/DiscoveredNodeDataConverter.hpp

@@ -0,0 +1,32 @@
+/**
+ *
+ * Copyright (c) 2020-2022 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#import "DiscoveredNodeData.h"
+#include <lib/dnssd/Resolver.h>
+
+#ifndef DiscoveredNodeDataConverter_h
+#define DiscoveredNodeDataConverter_h
+
+@interface DiscoveredNodeDataConverter : NSObject
+
++ (DiscoveredNodeData *)convertToObjC:(const chip::Dnssd::DiscoveredNodeData *)chipDiscoveredNodedata;
+
+@end
+
+#endif /* DiscoveredNodeDataConverter_h */

examples/tv-casting-app/darwin/TvCasting/MatterBridge/DiscoveredNodeDataConverter.mm

@@ -0,0 +1,58 @@
+/**
+ *
+ * Copyright (c) 2020-2022 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.
+ */
+#import <Foundation/Foundation.h>
+
+#import "DiscoveredNodeDataConverter.hpp"
+
+@implementation DiscoveredNodeDataConverter
+
++ (DiscoveredNodeData *)convertToObjC:(const chip::Dnssd::DiscoveredNodeData *)chipDiscoveredNodeData
+{
+ DiscoveredNodeData * objCDiscoveredNodeData = [DiscoveredNodeData new];
+
+ // from CommissionNodeData
+ objCDiscoveredNodeData.deviceType = chipDiscoveredNodeData->commissionData.deviceType;
+ objCDiscoveredNodeData.vendorId = chipDiscoveredNodeData->commissionData.vendorId;
+ objCDiscoveredNodeData.productId = chipDiscoveredNodeData->commissionData.productId;
+ objCDiscoveredNodeData.longDiscriminator = chipDiscoveredNodeData->commissionData.longDiscriminator;
+ objCDiscoveredNodeData.commissioningMode = chipDiscoveredNodeData->commissionData.commissioningMode;
+ objCDiscoveredNodeData.pairingHint = chipDiscoveredNodeData->commissionData.pairingHint;
+ objCDiscoveredNodeData.deviceName = [NSString stringWithCString:chipDiscoveredNodeData->commissionData.deviceName
+ encoding:NSASCIIStringEncoding];
+ objCDiscoveredNodeData.rotatingIdLen = chipDiscoveredNodeData->commissionData.rotatingIdLen;
+ objCDiscoveredNodeData.rotatingId = chipDiscoveredNodeData->commissionData.rotatingId;
+ objCDiscoveredNodeData.instanceName = [NSString stringWithCString:chipDiscoveredNodeData->commissionData.instanceName
+ encoding:NSASCIIStringEncoding];
+
+ // from CommonResolutionData
+ objCDiscoveredNodeData.port = chipDiscoveredNodeData->resolutionData.port;
+ objCDiscoveredNodeData.hostName = [NSString stringWithCString:chipDiscoveredNodeData->resolutionData.hostName
+ encoding:NSASCIIStringEncoding];
+ objCDiscoveredNodeData.platformInterface = chipDiscoveredNodeData->resolutionData.interfaceId.GetPlatformInterface();
+ objCDiscoveredNodeData.numIPs = chipDiscoveredNodeData->resolutionData.numIPs;
+ if (chipDiscoveredNodeData->resolutionData.numIPs > 0) {
+ objCDiscoveredNodeData.ipAddresses = [NSMutableArray new];
+ }
+ for (int i = 0; i < chipDiscoveredNodeData->resolutionData.numIPs; i++) {
+ char addrCString[chip::Inet::IPAddress::kMaxStringLength];
+ chipDiscoveredNodeData->resolutionData.ipAddress->ToString(addrCString, chip::Inet::IPAddress::kMaxStringLength);
+ objCDiscoveredNodeData.ipAddresses[i] = [NSString stringWithCString:addrCString encoding:NSASCIIStringEncoding];
+ }
+ return objCDiscoveredNodeData;
+}
+
+@end