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