public ServicesConnectParameters(
     WFDSvcWrapperHandle discoveryHandle,
     WFDSvcWrapperHandle advertiserHandle,
     ServicesConnectOptions options
     )
 {
     DiscoveryHandle  = discoveryHandle;
     AdvertiserHandle = advertiserHandle;
     Options          = options;
 }
예제 #2
0
 public ServicesReconnectPreDiscoveryParameters(
     int discoveryResultIndex,
     int discoveredHandleIndex,
     WFDSvcWrapperHandle advertiserHandle,
     ServicesConnectOptions options
     )
 {
     Options = options;
     DiscoveryResultIndex  = discoveryResultIndex;
     DiscoveredHandleIndex = discoveredHandleIndex;
     AdvertiserHandle      = advertiserHandle;
 }
 public ServicesConnectPreDiscoveryParameters(
     int discoveryResultIndex,
     int discoveredHandleIndex,
     int advertisedHandleIndex,
     ServicesConnectOptions options
     )
 {
     Options = options;
     DiscoveryResultIndex  = discoveryResultIndex;
     DiscoveredHandleIndex = discoveredHandleIndex;
     AdvertisedHandleIndex = advertisedHandleIndex;
 }
예제 #4
0
        public void SimpleAutoAcceptPairingReconnect()
        {
            using (RemoteControllerLogGroup lg = new RemoteControllerLogGroup(remoteWFDController))
            {
                // Connect
                string serviceName = remoteWFDController.GenerateUniqueServiceName();
                ServicesConnectOptions connectOptions = new ServicesConnectOptions(validateData: true);
                ServicesPublishDiscoverConnectParameters connectParams = new ServicesPublishDiscoverConnectParameters(
                    serviceName,
                    connectOptions
                    );

                var pairResults = ExecutePublishDiscoverConnectScenario(connectParams);

                // Verify results before we start using them
                Verify.AreEqual(1, pairResults.PublishResults.Count);
                Verify.AreEqual(1, pairResults.ConnectResults.Count);

                // Disconnect
                ExecuteDisconnectScenario(
                    new ServicesDisconnectParameters(
                        pairResults.ConnectResults[0].SeekerSessionHandle,
                        pairResults.ConnectResults[0].AdvertiserSessionHandle
                        )
                    );

                CleanupBeforeReconnect(true);

                // Reconnect
                ServicesDiscoverConnectParameters reconnectParams = new ServicesDiscoverConnectParameters(
                    pairResults.PublishResults[0].AdvertiserHandle,
                    serviceName,
                    ServicesDiscoveryType.Watcher,
                    connectOptions
                    );

                var reconnectResults = ExecuteDiscoverConnectScenario(reconnectParams);

                Verify.AreEqual(1, reconnectResults.ConnectResults.Count);

                // Disconnect
                ExecuteDisconnectScenario(
                    new ServicesDisconnectParameters(
                        reconnectResults.ConnectResults[0].SeekerSessionHandle,
                        reconnectResults.ConnectResults[0].AdvertiserSessionHandle
                        )
                    );
            }
        }
예제 #5
0
        // TODO add general constructor that just takes the 2 lists if needed

        /// <summary>
        /// Simple version for a single discovery/connect of same service
        /// </summary>
        public ServicesDiscoverConnectParameters(
            WFDSvcWrapperHandle advertiserHandle,
            string query,
            ServicesDiscoveryType discoveryType,
            ServicesConnectOptions connectOptions
            )
        {
            DiscoveryParameters = new List <ServicesDiscoveryParameters> {
                new ServicesDiscoveryParameters(query, 1, new List <WFDSvcWrapperHandle> {
                    advertiserHandle
                }, discoveryType)
            };
            ConnectParameters = new List <ServicesReconnectPreDiscoveryParameters> {
                new ServicesReconnectPreDiscoveryParameters(0, 0, advertiserHandle, connectOptions)
            };
        }
 /// <summary>
 /// Simple version for a single publish/discovery/connect of same service
 /// </summary>
 public ServicesPublishDiscoverConnectParameters(
     string serviceName,
     ServicesConnectOptions connectOptions,
     bool autoAccept = true,
     bool preferGO   = true,
     ServicePublishConfigMethods configMethods = ServicePublishConfigMethods.PinOrDefaultDisplay,
     ServicesDiscoveryType discoveryType       = ServicesDiscoveryType.Watcher,
     string deferredSessionInfo = ""
     )
 {
     PublishDiscoverParameters = new ServicesPublishDiscoverParameters(
         new List <ServicesPublishParameters> {
         new ServicesPublishParameters(serviceName, autoAccept, preferGO, configMethods, sessionInfo: deferredSessionInfo)
     },
         new List <ServicesDiscoveryPrePublishParameters> {
         new ServicesDiscoveryPrePublishParameters(serviceName, 1, new List <int> {
             0
         }, discoveryType)
     }
         );
     ConnectParameters = new List <ServicesConnectPreDiscoveryParameters> {
         new ServicesConnectPreDiscoveryParameters(0, 0, 0, connectOptions)
     };
 }
예제 #7
0
        public void SimpleAutoAcceptMultipleSimultaneousSessions()
        {
            using (RemoteControllerLogGroup lg = new RemoteControllerLogGroup(remoteWFDController))
            {
                string serviceName1 = remoteWFDController.GenerateUniqueServiceName();
                string serviceName2 = remoteWFDController.GenerateUniqueServiceName();
                string serviceName3 = remoteWFDController.GenerateUniqueServiceName();

                ServicesConnectOptions connectOptions = new ServicesConnectOptions(validateData: true);

                // NOTE: this will do FindAllAsync while all other tests use the watcher/incremental updates
                // Publish 2 services, discover/connect to first
                ServicesPublishDiscoverConnectParameters pdcParams = new ServicesPublishDiscoverConnectParameters(
                    serviceName1,
                    connectOptions
                    );
                var pdcResults = ExecutePublishDiscoverConnectScenario(pdcParams);

                Verify.AreEqual(1, pdcResults.PublishResults.Count);
                Verify.AreEqual(1, pdcResults.ConnectResults.Count);

                // Discover/connect to second
                ServicesPublishDiscoverConnectParameters pdc2Params = new ServicesPublishDiscoverConnectParameters(
                    serviceName2,
                    connectOptions,
                    discoveryType: ServicesDiscoveryType.Watcher
                    );
                var pdc2Results = ExecutePublishDiscoverConnectScenario(pdc2Params);

                Verify.AreEqual(1, pdc2Results.PublishResults.Count);
                Verify.AreEqual(1, pdc2Results.ConnectResults.Count);

                // Publish/discover/connect third service
                ServicesPublishDiscoverConnectParameters pdc3Params = new ServicesPublishDiscoverConnectParameters(
                    serviceName3,
                    connectOptions
                    );
                var pdc3Results = ExecutePublishDiscoverConnectScenario(pdc3Params);

                Verify.AreEqual(1, pdc3Results.PublishResults.Count);
                Verify.AreEqual(1, pdc3Results.ConnectResults.Count);

                // Disconnect second service
                ExecuteDisconnectScenario(
                    new ServicesDisconnectParameters(
                        pdc2Results.ConnectResults[0].SeekerSessionHandle,
                        pdc2Results.ConnectResults[0].AdvertiserSessionHandle
                        )
                    );

                // Try to send some more data on 1st session, expect still connected
                ServicesSendDataParameters sendDataParams = new ServicesSendDataParameters(
                    pdcResults.ConnectResults[0].SeekerSessionHandle,
                    pdcResults.ConnectResults[0].SeekerSocketHandle,
                    pdcResults.ConnectResults[0].AdvertiserSessionHandle,
                    pdcResults.ConnectResults[0].AdvertiserSocketHandle,
                    65536
                    );
                var sendDataResult = ExecuteSendDataScenario(sendDataParams);

                // Disconnect first/third service
                ExecuteDisconnectScenario(
                    new ServicesDisconnectParameters(
                        pdcResults.ConnectResults[0].AdvertiserSessionHandle,
                        pdcResults.ConnectResults[0].SeekerSessionHandle
                        ),
                    false
                    );
                ExecuteDisconnectScenario(
                    new ServicesDisconnectParameters(
                        pdc3Results.ConnectResults[0].SeekerSessionHandle,
                        pdc3Results.ConnectResults[0].AdvertiserSessionHandle
                        )
                    );
            }
        }