public Localisation()
{
InitializeComponent();
_bleService = BLEService.Instance();
_isAlarmStarted = false;
_isStarted = false;
_firstTimer = 0;
// Init player
_player = CrossSimpleAudioPlayer.Current;
_player.Load("bing.mp3");
_player.Volume = 1;
MessagingCenter.Subscribe <BLEService>(this, "deviceConnectionLost", (sender) =>
{
OnDeviceDisconnected();
});
MessagingCenter.Subscribe <BLEService, CharacteristicUpdatedEventArgs>(this, "characteristicUpdated", (sender, args) =>
{
OnCharacteristicUpdated(args);
});
}
public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
{
BLEService = new BLEService
{
OnValueAvailable = OnDataAvailable
};
Notification.Builder builder;
if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
{
builder = new Notification.Builder(this, "default");
}
else
{
builder = new Notification.Builder(this);
}
var notification = builder.SetContentTitle("Azure IoTCentral")
.SetContentText("BLE telemetry is running. Tap to return to application")
.SetSmallIcon(Resource.Drawable.ic_iotcentral_white)
.SetContentIntent(GetIntentForActivityResume())
.SetOngoing(true)
.Build();
Connect(intent).Start();
StartForeground(SERVICE_RUNNING_NOTIFICATION_ID, notification);
return(StartCommandResult.Sticky);
}
public async Task SetupNotifications(string bleDeviceId, Dictionary <string, string> telemetryMap)
{
BLEDevice = await BLEService.Connect(bleDeviceId);
TelemetryMap = telemetryMap;
foreach (var gatt in telemetryMap)
{
var telemetryField = gatt.Value;
var pair = new GattPair(gatt.Key);
var service = await BLEDevice.GetServiceAsync(pair.ServiceId);
if (service != null) // service could be null if mapping has old values related to other devices
{
var characteristic = await service.GetCharacteristicAsync(pair.CharacteristicId);
if (characteristic != null) // like above but for characteristic
{
if (telemetryField != null)
{
await BLEService.EnableNotification(characteristic);
}
else
{
await BLEService.DisableNotification(characteristic);
}
}
}
}
MessagingCenter.Send(new ResultMessage <IDevice>(BLEDevice), Constants.BLE_DEVICE_READY);
}
private IEnumerator Start()
{
yield return(new WaitForSeconds(3));
BLEService.Initialize(() =>
{
Debug.Log("### Initialized");
BLEService.StartScan(device =>
{
if (device.Name.Equals("UARTService"))
{
BLEService.ConnectToDevice(device,
characteristic =>
{
Debug.Log(characteristic.CharacteristicUuid);
if (characteristic.CharacteristicUuid.Equals(CharacteristicUuid))
{
BLEService.Subscribe(characteristic, OnDataReceived);
}
},
disconnectedAddress => { Debug.Log($"### Device Disconnected: {disconnectedAddress}"); });
}
});
},
error =>
{
Debug.Log("### Intialization error");
});
// UARTService
}
public DeviceWorker()
{
BLEService = new BLEService
{
OnValueAvailable = OnDataAvailable
};
}
public MainPageViewModel(INavigationService navigationService, BLEService bleService)
{
_navigationService = navigationService;
_bleService = bleService;
Info = "Status: Disconnected";
Color = "Gray";
ArmCommand = new DelegateCommand <string>(async(o) => await ArmMove(o));
}
public Welcome_Confirmation()
{
InitializeComponent();
_isConnected = false;
_player = CrossSimpleAudioPlayer.Current;
_player.Load("bing.mp3");
_player.Volume = 1;
var ble = CrossBluetoothLE.Current;
var adapter = CrossBluetoothLE.Current.Adapter;
NavigationPage.SetHasNavigationBar(this, false);
// Subscribe events
MessagingCenter.Subscribe <BLEService, BLEDevice>(this, "deviceDiscovered", async(sender, bleDevice) =>
{
await _bleService.ConnectDeviceAsync(bleDevice);
});
MessagingCenter.Subscribe <BLEService>(this, "deviceConnected", (sender) =>
{
OnDeviceConnected();
});
MessagingCenter.Subscribe <BLEService>(this, "deviceConnectionLost", (sender) =>
{
OnDeviceDisconnected();
});
MessagingCenter.Subscribe <BLEService>(this, "deviceDisconnected", (sender) =>
{
OnDeviceDisconnected();
});
MessagingCenter.Subscribe <BLEService, BluetoothStateChangedArgs>(this, "stateChanged", (sender, args) =>
{
OnStateChanged(args);
});
MessagingCenter.Subscribe <BLEService>(this, "scanTimeoutElapsed", (sender) =>
{
OnScanTimeoutElapsed();
});
MessagingCenter.Subscribe <BLEService, CharacteristicUpdatedEventArgs>(this, "characteristicUpdated", (sender, args) =>
{
OnCharacteristicUpdated(args);
});
// Start scan
_bleService = BLEService.Instance();
_bleService.TryStartScanning(true);
}
private void PrintAvailableDevicesList()
{
foreach (BLEService.Device device in devices)
{
if (GUILayout.Button(device.Name))
{
BLEService.ConnectToDevice(device,
characteristic => { characteristics.Add(characteristic); },
disconnectedAddress => { Debug.Log($"Device Disconnected: {disconnectedAddress}"); });
}
}
}
public BleScanViewModel(INavigationService navigation) : base(navigation)
{
Devices = new ObservableCollection <IDevice>();
BleService = new BLEService();
ScanBtn = "Stop";
ScanStop = new Command(async() =>
{
if (ScanBtn == "Scan")
{
await Scan();
}
else
{
await Stop();
}
});
}
private void OnGUI()
{
GUI.skin.button.fontSize = 40;
GUI.skin.label.fontSize = 40;
if (!BLEService.IsInitialized)
{
if (GUILayout.Button("Initialize"))
{
BLEService.Initialize(() => Debug.Log("Initialized"), error => Debug.Log($"Error: {error}"));
}
}
else
{
GUILayout.Label($"State: {BLEService.CurrentState}");
switch (BLEService.CurrentState)
{
case BLEService.State.ReadyToScan:
if (GUILayout.Button("Scan"))
{
BLEService.StartScan(device =>
{
if (!devices.Contains(device))
{
devices.Add(device);
}
Debug.Log($"Device found: {device.Name}");
});
}
break;
case BLEService.State.Disconnecting:
break;
case BLEService.State.Scanning:
PrintAvailableDevicesList();
break;
case BLEService.State.Connecting:
break;
case BLEService.State.Connected:
foreach (BLEService.Characteristic characteristic in characteristics)
{
if (GUILayout.Button($"{characteristic.Device.Name}: {characteristic.CharacteristicUuid}"))
{
BLEService.Subscribe(characteristic, OnDataReceived);
}
}
break;
case BLEService.State.Subscribing:
break;
case BLEService.State.Communicating:
GUILayout.Label($"Data: {s}");
break;
case BLEService.State.Disconnected:
PrintAvailableDevicesList();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
