Beispiel #1
0
        public async override Task <DeviceConnectionResult> ConnectAsync(CancellationToken token)
        {
            using (await _asyncLock.LockAsync())
            {
                if (_bleDevice != null || DeviceState != DeviceState.Disconnected)
                {
                    return(DeviceConnectionResult.Error);
                }

                try
                {
                    _bleDevice = _bleService.GetKnownDevice(Address);
                    if (_bleDevice == null)
                    {
                        return(DeviceConnectionResult.Error);
                    }

                    _bleDevice.Disconnected += OnDeviceDisconnected;

                    await SetStateAsync(DeviceState.Connecting, false);

                    var services = await _bleDevice.ConnectAndDiscoverServicesAsync(token);

                    token.ThrowIfCancellationRequested();

                    if (ProcessServices(services))
                    {
                        await StartOutputTaskAsync();

                        token.ThrowIfCancellationRequested();


                        await SetStateAsync(DeviceState.Connected, false);

                        return(DeviceConnectionResult.Ok);
                    }
                }
                catch (OperationCanceledException)
                {
                    await DisconnectInternalAsync(false);

                    return(DeviceConnectionResult.Canceled);
                }
                catch (Exception)
                {
                }

                await DisconnectInternalAsync(true);

                return(DeviceConnectionResult.Error);
            }
        }
Beispiel #2
0
        public async override Task <DeviceConnectionResult> ConnectAsync(
            bool reconnect,
            Action <Device> onDeviceDisconnected,
            IEnumerable <ChannelConfiguration> channelConfigurations,
            bool startOutputProcessing,
            bool requestDeviceInformation,
            CancellationToken token)
        {
            using (await _asyncLock.LockAsync())
            {
                if (_bleDevice != null || DeviceState != DeviceState.Disconnected)
                {
                    return(DeviceConnectionResult.Error);
                }

                _onDeviceDisconnected = onDeviceDisconnected;

                try
                {
                    _bleDevice = _bleService.GetKnownDevice(Address);
                    if (_bleDevice == null)
                    {
                        return(DeviceConnectionResult.Error);
                    }

                    DeviceState = DeviceState.Connecting;
                    var services = await _bleDevice.ConnectAndDiscoverServicesAsync(
                        reconnect || AutoConnectOnFirstConnect,
                        OnCharacteristicChanged,
                        OnDeviceDisconnected,
                        token);

                    token.ThrowIfCancellationRequested();

                    if (await ValidateServicesAsync(services, token) &&
                        await AfterConnectSetupAsync(requestDeviceInformation, token))
                    {
                        if (startOutputProcessing)
                        {
                            await StartOutputTaskAsync();
                        }

                        token.ThrowIfCancellationRequested();

                        DeviceState = DeviceState.Connected;
                        return(DeviceConnectionResult.Ok);
                    }
                }
                catch (OperationCanceledException)
                {
                    await DisconnectInternalAsync();

                    return(DeviceConnectionResult.Canceled);
                }
                catch (Exception)
                {
                }

                await DisconnectInternalAsync();

                return(DeviceConnectionResult.Error);
            }
        }