示例#1
0
        /// <summary>
        /// Connect and manage connection as well as hook into your required characterisitcs with all proper cleanups necessary
        /// </summary>
        /// <param name="peripheral"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public static IObservable <CharacteristicGattResult> ConnectHook(this IPeripheral peripheral, ConnectHookArgs args)
        => Observable.Create <CharacteristicGattResult>(ob =>
        {
            var sub = peripheral
                      .WhenConnected()
                      .Select(_ => peripheral.WhenKnownCharacteristicsDiscovered(args.ServiceUuid, args.CharacteristicUuids))
                      .Switch()
                      .Select(x => x.Notify(false))
                      .Merge()
                      .Subscribe(
                ob.OnNext,
                ob.OnError
                );

            var connSub = peripheral
                          .WhenConnectionFailed()
                          .Subscribe(ob.OnError);

            peripheral.ConnectIf(args.Config);

            return(() =>
            {
                peripheral.CancelConnection();
                sub?.Dispose();
                connSub?.Dispose();
            });
        });
示例#2
0
        /// <summary>
        /// Connect and manage connection as well as hook into your required characterisitcs with all proper cleanups necessary
        /// </summary>
        /// <param name="device"></param>
        /// <param name="serviceUuid"></param>
        /// <param name="characteristicUuids"></param>
        /// <returns></returns>
        public static IObservable <CharacteristicGattResult> ConnectHook(this IPeripheral device, Guid serviceUuid, params Guid[] characteristicUuids)
        => Observable.Create <CharacteristicGattResult>(ob =>
        {
            var sub = device
                      .WhenConnected()
                      .Select(_ => device.WhenKnownCharacteristicsDiscovered(serviceUuid, characteristicUuids))
                      .Switch()
                      .Select(x => x.Notify(false))
                      .Merge()
                      .Subscribe(
                ob.OnNext,
                ob.OnError
                );

            var connSub = device
                          .WhenConnectionFailed()
                          .Subscribe(ob.OnError);

            // TODO: connectconfig - pass args object
            device.ConnectIf();

            return(() =>
            {
                device.CancelConnection();
                sub?.Dispose();
                connSub?.Dispose();
            });
        });
        /// <summary>
        /// Waits for connection to actually happen
        /// </summary>
        /// <param name="peripheral"></param>
        /// <returns></returns>
        public static IObservable <IPeripheral> ConnectWait(this IPeripheral peripheral)
        => Observable.Create <IPeripheral>(ob =>
        {
            var sub1 = peripheral
                       .WhenConnected()
                       .Take(1)
                       .Subscribe(_ => ob.Respond(peripheral));

            var sub2 = peripheral
                       .WhenConnectionFailed()
                       .Subscribe(ob.OnError);

            peripheral.ConnectIf();
            return(() =>
            {
                sub1.Dispose();
                sub2.Dispose();
                if (peripheral.Status != ConnectionState.Connected)
                {
                    peripheral.CancelConnection();
                }
            });
        });