public void Start(Context context, TracingInformation tracingInformation)
{
if (!Initialized)
{
_logger.LogError("Advertiser - Starting failed - not initialized.");
return;
}
_tracingInformation = tracingInformation;
try
{
_logger.LogDebug("Advertiser - starting.");
var serviceUuid = ParcelUuid.FromString(_tracingInformation.ServiceId);
var characteristicUuid = ParcelUuid.FromString(_tracingInformation.CharacteristicId);
_logger.LogDebug($"Advertiser - initializing. ServiceId: {_tracingInformation.ServiceId}. CharacteristicId: {_tracingInformation.CharacteristicId}");
BtGattServerCallback bluetoothGattServerCallback = new BtGattServerCallback(_tracingInformation);
_gattServer = _bluetoothManager.OpenGattServer(context, bluetoothGattServerCallback);
bluetoothGattServerCallback._gattServer = _gattServer;
BluetoothGattService service = new BluetoothGattService(serviceUuid.Uuid, GattServiceType.Primary);
BluetoothGattCharacteristic characteristic = new BluetoothGattCharacteristic(characteristicUuid.Uuid, GattProperty.Read, GattPermission.Read);
service.AddCharacteristic(characteristic);
_gattServer.AddService(service);
_logger.LogDebug("Advertiser - started.");
}
catch (Exception ex)
{
_logger.LogError(ex, "Advertiser - failed advertising initialization.");
}
}
public DroidBluetoothDriver(Guid[] filter)
: this(null, null)
{
ScanSettings.Builder scanSettingsBuilder = null;
scanSettingsBuilder = new ScanSettings.Builder();
scanSettingsBuilder.SetMatchMode(BluetoothScanMatchMode.Aggressive);
scanSettingsBuilder.SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency);
this.scanSettings = scanSettingsBuilder.Build();
this.scanfiltersList = new List <ScanFilter>();
if (filter != null && filter.Length > 0)
{
foreach (Guid selectedFilter in filter)
{
ParcelUuid parcelUuid = null;
ScanFilter.Builder filterBuilder = new ScanFilter.Builder();
ScanFilter currentFilter = null;
try
{
parcelUuid = ParcelUuid.FromString(selectedFilter.ToString());
filterBuilder.SetServiceUuid(parcelUuid);
currentFilter = filterBuilder.Build();
this.scanfiltersList.Add(currentFilter);
}
catch (Exception)
{
}
}
}
}
public override void OnReceive(Context context, Intent intent)
{
string action = intent.Action;
if (BluetoothDevice.ActionUuid == action)
{
IParcelable[] parcelUuids = intent.GetParcelableArrayExtra(BluetoothDevice.ExtraUuid);
List <Guid> guids = new List <Guid>();
if (parcelUuids != null && parcelUuids.Length > 0)
{
foreach (IParcelable parcel in parcelUuids)
{
ParcelUuid parcelUuid = parcel as ParcelUuid;
if (parcelUuid != null)
{
guids.Add(Guid.Parse(parcelUuid.Uuid.ToString()));
}
}
}
Application.Context.UnregisterReceiver(this);
_DeviceWrapper.IsFetchingUuids = false;
_DeviceWrapper.LastestFetchedUuids = guids.ToArray();
_DeviceWrapper.OnUuidsFetched?.Invoke(_DeviceWrapper, guids.ToArray());
}
}
public void Advertise()
{
try
{
bluetoothLeAdvertiser = BluetoothAdapter.DefaultAdapter.BluetoothLeAdvertiser;
AdvertiseSettings settings = new AdvertiseSettings.Builder()
.SetAdvertiseMode(AdvertiseMode.LowLatency)
.SetTxPowerLevel(AdvertiseTx.PowerHigh)
.SetTimeout(0)
.SetConnectable(true)
.Build();
ParcelUuid pUuid = new ParcelUuid(MY_UUID);
AdvertiseData data = new AdvertiseData.Builder()
.SetIncludeDeviceName(true)
.AddServiceUuid(pUuid)
.AddServiceData(pUuid, Encoding.UTF8.GetBytes("Data send"))
.Build();
myAdvertiseCallback = new MyAdvertiseCallback();
bluetoothLeAdvertiser.StartAdvertising(settings, data, myAdvertiseCallback);
}
catch (System.Exception ex)
{
}
}
public void InitFilter(Guid[] filter)
{
if (filter != null && filter.Length > 0)
{
foreach (Guid selectedFilter in filter)
{
ParcelUuid parcelUuid = null;
ScanFilter.Builder filterBuilder = new ScanFilter.Builder();
ScanFilter currentFilter = null;
try
{
parcelUuid = ParcelUuid.FromString(selectedFilter.ToString());
filterBuilder.SetServiceUuid(parcelUuid);
currentFilter = filterBuilder.Build();
this.scanfiltersList.Add(currentFilter);
}
catch (Exception)
{
}
this.Filter = filter;
}
}
}
protected virtual void StartAdvertising(AdvertisementData adData)
{
var settings = new AdvertiseSettings.Builder()
.SetAdvertiseMode(AdvertiseMode.Balanced)
.SetConnectable(true);
var data = new AdvertiseData.Builder()
.SetIncludeDeviceName(true)
.SetIncludeTxPowerLevel(true);
if (adData.ManufacturerData != null)
{
data.AddManufacturerData(adData.ManufacturerData.CompanyId, adData.ManufacturerData.Data);
}
foreach (var serviceUuid in adData.ServiceUuids)
{
var uuid = ParcelUuid.FromString(serviceUuid.ToString());
data.AddServiceUuid(uuid);
}
this.manager
.Adapter
.BluetoothLeAdvertiser
.StartAdvertising(
settings.Build(),
data.Build(),
this.adCallbacks
);
}
void IAdvertiseAndDiscoverBluetoothDevice.Advertise()
{
try
{
Analytics.TrackEvent(Build.Model + " Advertise method called.");
bluetoothLeAdvertiser = BluetoothAdapter.DefaultAdapter.BluetoothLeAdvertiser;
AdvertiseSettings settings = new AdvertiseSettings.Builder()
.SetAdvertiseMode(AdvertiseMode.LowLatency)
.SetTxPowerLevel(AdvertiseTx.PowerHigh)
.SetTimeout(0)
.SetConnectable(true)
.Build();
ParcelUuid pUuid = new ParcelUuid(MY_UUID);
AdvertiseData data = new AdvertiseData.Builder()
.SetIncludeDeviceName(true)
.AddServiceUuid(pUuid)
.AddServiceData(pUuid, Encoding.UTF8.GetBytes("222"))
.Build();
myAdvertiseCallback = new MyAdvertiseCallback();
bluetoothLeAdvertiser.StartAdvertising(settings, data, myAdvertiseCallback);
}
catch (System.Exception ex)
{
Analytics.TrackEvent(Build.Model + " Something went wrong in Advertise method.");
}
}
private void StartScanningNew(Guid[] serviceUuids)
{
var hasFilter = serviceUuids?.Any() ?? false;
List <ScanFilter> scanFilters = null;
if (hasFilter)
{
scanFilters = new List <ScanFilter>();
foreach (var serviceUuid in serviceUuids)
{
var sfb = new ScanFilter.Builder();
sfb.SetServiceUuid(ParcelUuid.FromString(serviceUuid.ToString()));
scanFilters.Add(sfb.Build());
}
}
var ssb = new ScanSettings.Builder();
ssb.SetScanMode(ScanMode.ToNative());
//ssb.SetCallbackType(ScanCallbackType.AllMatches);
if (_bluetoothAdapter.BluetoothLeScanner != null)
{
Trace.Message($"Adapter >=21: Starting a scan for devices. ScanMode: {ScanMode}");
if (hasFilter)
{
Trace.Message($"ScanFilters: {string.Join(", ", serviceUuids)}");
}
_bluetoothAdapter.BluetoothLeScanner.StartScan(scanFilters, ssb.Build(), _api21ScanCallback);
}
else
{
Trace.Message("Adapter >= 21: Scan failed. Bluetooth is probably off");
}
}
private async void RunAction()
{
var settings = new ScanSettings.Builder().SetScanMode(ScanMode.LowPower).Build();
var filters = GetScanFilters();
//var intent = new Intent(ApplicationContext, typeof(BackgroundService));
//intent.PutExtra("o-scan", true);
//var pendingIntent =
// PendingIntent.GetBroadcast(ApplicationContext, 0, intent, PendingIntentFlags.UpdateCurrent);
//_bluetoothAdapter.BluetoothLeScanner.StartScan(filters, settings,new AppScanCallBack());
var advSettings = new AdvertiseSettings.Builder().SetAdvertiseMode(AdvertiseMode.LowPower)
.SetConnectable(false).SetTimeout(1000).Build();
var advData = new AdvertiseData.Builder()
.AddServiceUuid(ParcelUuid.FromString("FC51BA92-74D5-4972-B2D9-9ECBC62ACFC9")).Build();
_bluetoothAdapter.BluetoothLeAdvertiser.StartAdvertising(advSettings, advData, new AppAdvertisingCallBack());
//Log.Info(TAG, $"Service is still running, near devices: {devices.Count}");
//if (!devices.Any()) Log.Info(TAG, $"Device NOt MATCH");
//foreach (var device in devices)
// Log.Info(TAG,
// $"Service is still running, DEVICE: id({device.BondState}) adress({string.Join(",", device.Address)})) ");
Toast.MakeText(this, $"Service is still running, near devices: NA", ToastLength.Long).Show();
handler.PostDelayed(runnable, 10000);
}
public Task StartAdvertising(string localName, List <IService> services)
{
var settings = new AdvertiseSettings.Builder()
.SetAdvertiseMode(AdvertiseMode.LowLatency)
.SetTxPowerLevel(AdvertiseTx.PowerHigh)
.SetTimeout(0)
.SetConnectable(true)
.Build();
if (localName != null)
{
_adapter.SetName(localName);
}
var advertiseDataBuilder = new AdvertiseData.Builder()
.SetIncludeTxPowerLevel(false)
.SetIncludeDeviceName(false);
if (services != null)
{
foreach (Service service in services)
{
var serviceUuid = service.Uuid;
var uuid = UUID.FromString(serviceUuid);
var parcelUuid = new ParcelUuid(uuid);
advertiseDataBuilder.AddServiceUuid(parcelUuid);
}
}
var advertiseData = advertiseDataBuilder.Build();
_adapter.BluetoothLeAdvertiser.StartAdvertising(settings, advertiseData, _advertiseCallback);
return(Task.FromResult(true));
}
static async Task <IReadOnlyCollection <BluetoothDevice> > PlatformScanForDevices(RequestDeviceOptions options)
{
List <ScanFilter> filters = new List <ScanFilter>();
foreach (var f in options.Filters)
{
foreach (var u in f.Services)
{
ScanFilter.Builder b = new ScanFilter.Builder();
b.SetServiceUuid(ParcelUuid.FromString(u.Value.ToString()));
filters.Add(b.Build());
}
}
ScanSettings.Builder sb = new ScanSettings.Builder();
sb.SetScanMode(Android.Bluetooth.LE.ScanMode.Balanced);
var settings = sb.Build();
var callback = new DevicesCallback();
_manager.Adapter.BluetoothLeScanner.StartScan(callback);
await Task.Delay(30000);
return(callback.Devices.AsReadOnly());
}
public void StartAdvertising(string localName)
{
var settings = new AdvertiseSettings.Builder()
.SetAdvertiseMode(AdvertiseMode.Balanced)
.SetTxPowerLevel(AdvertiseTx.PowerHigh)
.SetConnectable(true)
.Build();
_adapter.SetName(localName);
var advertiseDataBuilder = new AdvertiseData.Builder()
.SetIncludeDeviceName(true);
foreach (var service in _server.Services)
{
var parcelUuid = new ParcelUuid(UUID.FromString("1234".ToGuid().ToString()));
advertiseDataBuilder.AddServiceUuid(parcelUuid);
}
var advertiseData = advertiseDataBuilder.Build();
_adapter.BluetoothLeAdvertiser.StartAdvertising(settings, advertiseData, _advertiseCallback);
}
public override void StartScan()
{
_scanner.StartScan(new[] {
new ScanFilter.Builder().SetServiceUuid(ParcelUuid.FromString(ServiceUuid)).Build()
},
new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency).Build(),
_scanCallback);
}
protected AdvertiseData BuildAdvertiseData(TracingInformation tracingInformation)
{
AdvertiseData.Builder dataBuilder = new AdvertiseData.Builder();
var uuid = ParcelUuid.FromString(tracingInformation.ServiceId);
dataBuilder.AddServiceUuid(uuid);
return(dataBuilder.Build());
}
private void StartBluetoothScan()
{
var scanFilter = new ScanFilter.Builder()
.SetServiceUuid(ParcelUuid.FromString(BluetoothConstants.ServiceUuid.ToString()))
.Build();
BluetoothLEScanner.Current.StartScan(new[] { scanFilter }, new ScanSettings.Builder().Build());
}
private IList <ScanFilter> BuildScanFilters(TracingInformation tracingInformation)
{
var scanFilters = new List <ScanFilter>();
var builder = new ScanFilter.Builder();
var serviceUuid = ParcelUuid.FromString(tracingInformation.ServiceId);
builder.SetServiceUuid(serviceUuid);
scanFilters.Add(builder.Build());
return(scanFilters);
}
//private void logBroadCastResult(IBleAdvertisement adv)
//{
// Log.Info(TAG, $"BrodCastResult");
// try
// {
// Log.Info(TAG, adv.DeviceName);
// Log.Info(TAG, adv.Services.Select(x => x.ToString()).Join(","));
// Log.Info(TAG, adv.ManufacturerSpecificData.FirstOrDefault().CompanyName());
// Log.Info(TAG, adv.ServiceData.ToString());
// }
// catch (Exception ex)
// {
// Log.Info(TAG, $"BrodCastResult Error:{ex.Message}");
// }
// finally
// {
// Log.Info(TAG, $"BrodCastResultEnd ");
// }
//}
private List <ScanFilter> GetScanFilters()
{
var result = new List <ScanFilter>();
var uuid = ParcelUuid.FromString("FC51BA92-74D5-4972-B2D9-9ECBC62ACFC9");
var newScanFilter = new ScanFilter.Builder().SetServiceUuid(uuid).Build();
result.Add(newScanFilter);
return(result);
}
public override void OnServicesDiscovered(BluetoothGatt gatt, GattStatus status)
{
System.Threading.Tasks.Task.Run(() =>
{
base.OnServicesDiscovered(gatt, status);
if (gatt != null)
{
try
{
var serviceUuid = ParcelUuid.FromString(_tracingInformation.ServiceId);
BluetoothGattService service = gatt.GetService(serviceUuid.Uuid);
if (service != null)
{
_deviceManager.HandleDeviceCommunicationDiscoveredService(_descriptor, (d) =>
{
var characteristicUuid = ParcelUuid.FromString(_tracingInformation.CharacteristicId);
BluetoothGattCharacteristic characteristic = service.GetCharacteristic(characteristicUuid.Uuid);
if (characteristic != null)
{
_deviceManager.HandleDeviceCommunicationDiscoveredCharacteristic(_descriptor, (d) =>
{
gatt.ReadCharacteristic(characteristic);
});
}
else
{
_deviceManager.HandleIncorrectDevice(_descriptor, (d) =>
{
gatt.Disconnect();
});
}
});
}
else
{
_deviceManager.HandleIncorrectDevice(_descriptor, (d) =>
{
gatt.Disconnect();
});
}
}
catch (Exception ex)
{
_deviceManager.HandleDeviceCommunicationDiscoveryServiceError(_descriptor, ex.Message, (d) =>
{
gatt.Disconnect();
});
}
}
}).FireAndForget();
}
public async void Connect(object sender, EventArgs args)
{
BluetoothAdapter adapterbt = BluetoothAdapter.DefaultAdapter;
BluetoothDevice device = (from bd in adapterbt.BondedDevices
where bd.Name == list.SelectedItem.ToString()
select bd).FirstOrDefault();
Android.App.AlertDialog.Builder dialog = new AlertDialog.Builder(this);
AlertDialog alert = dialog.Create();
alert.SetTitle("Title");
ParcelUuid[] uuids = device.GetUuids();
if ((uuids != null) && (uuids.Length > 0))
{
foreach (var uuid in uuids)
{
try
{
btSocket = device.CreateRfcommSocketToServiceRecord(uuid.Uuid);
if (!btSocket.IsConnected)
{
await btSocket.ConnectAsync();
}
if (btSocket.IsConnected)
{
Mutex mut = new Mutex();
byte[] Login =
{ 0x01, 0x30, 0x30, 0x32, 0x3A, 0x20, 0x30, 0x30, 0x34, 0x3A, 0x05, 0x30, 0x31, 0x3B, 0x3F, 0x03 };
byte[] RapX = { 0x01, 0x30, 0x30, 0x32, 0x3C, 0x2E, 0x30, 0x30, 0x34, 0x35, 0x58, 0x09, 0x05, 0x30, 0x32, 0x32, 0x3B, 0x03 };
DevUID = uuid;
Console.WriteLine("conected to:" + uuid.Uuid.ToString());
Talk2BTsocket(btSocket, Login, mut);
break;
}
}
catch (Exception ex)
{
Toast.MakeText(this, ex.Message, ToastLength.Short);
}
//var _socket = device.CreateRfcommSocketToServiceRecord(UUID.FromString(device.GetUuids().ToString()));
//await _socket.ConnectAsync();
}
}
}
private void StartScanningNew(Guid[] serviceUuids, ManufacturerData[] manufacturerDataFilters)
{
var hasFilter = serviceUuids?.Any() ?? false;
List <ScanFilter> scanFilters = null;
if (hasFilter)
{
scanFilters = new List <ScanFilter>();
foreach (var serviceUuid in serviceUuids)
{
var sfb = new ScanFilter.Builder();
sfb.SetServiceUuid(ParcelUuid.FromString(serviceUuid.ToString()));
scanFilters.Add(sfb.Build());
}
foreach (var manufacturerData in manufacturerDataFilters)
{
var sfb = new ScanFilter.Builder();
sfb.SetManufacturerData(manufacturerData.Id, manufacturerData.Data);
scanFilters.Add(sfb.Build());
}
}
var ssb = new ScanSettings.Builder();
ssb.SetScanMode(ScanMode.ToNative());
if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
{
// enable Bluetooth 5 Advertisement Extensions on Android 8.0 and above
ssb.SetLegacy(false);
}
//ssb.SetCallbackType(ScanCallbackType.AllMatches);
if (_bluetoothAdapter.BluetoothLeScanner != null)
{
Trace.Message($"Adapter >=21: Starting a scan for devices. ScanMode: {ScanMode}");
if (hasFilter)
{
Trace.Message($"ScanFilters: {string.Join(", ", serviceUuids)}");
}
_bluetoothAdapter.BluetoothLeScanner.StartScan(scanFilters, ssb.Build(), _api21ScanCallback);
}
else
{
Trace.Message("Adapter >= 21: Scan failed. Bluetooth is probably off");
}
}
public async void StartScanningForDevices(int timeOutSeconds = 10, string serviceUuid = null)
{
Console.WriteLine("Adapter: Starting a scan for devices.");
// clear out the list
this._discoveredDevices = new List <IDevice> ();
// start scanning
this._isScanning = true;
var scanFilterBuilder = new ScanFilter.Builder();
if (!string.IsNullOrWhiteSpace(serviceUuid))
{
scanFilterBuilder.SetServiceUuid(ParcelUuid.FromString(serviceUuid));
}
var filter = scanFilterBuilder.Build();
var filterList = new List <ScanFilter>()
{
filter
};
var scanSettingBuilder = new ScanSettings.Builder();
scanSettingBuilder.SetScanMode(ScanMode.Balanced);
var scanSettings = scanSettingBuilder.Build();
this._adapter.BluetoothLeScanner.StartScan(filterList, scanSettings, _scanCallback);
//this._adapter.StartLeScan (this);
// in 10 seconds, stop the scan
await Task.Delay(TimeSpan.FromSeconds(timeOutSeconds));
// if we're still scanning
if (this._isScanning)
{
Console.WriteLine("BluetoothLEManager: Scan timeout has elapsed.");
// Use the method, because it also updates the _isScanning portion.
StopScanningForDevices();
this.ScanTimeoutElapsed(this, new EventArgs());
}
}
public bool StartScan(int timeoutMs, bool filtered)
{
try
{
if (!BleEnabled)
{
BLE_ERR("can't start scan, ble not enabled");
return(false);
}
if (!Init())
{
return(false);
}
_Timeout = new Timer((obj) =>
{
StopScan();
}, null, timeoutMs, Timeout.Infinite);
BLE("start scan");
_Devices.Clear();
if (filtered)
{
var filter = new ScanFilter.Builder().SetServiceUuid(ParcelUuid.FromString(BleConstants.BLE_SERVER_SERVICE_UUID)).Build();
var settings = new ScanSettings.Builder().SetScanMode(Android.Bluetooth.LE.ScanMode.LowLatency).Build();
_CentralManager.Adapter.BluetoothLeScanner.StartScan(new List <ScanFilter> {
filter
}, settings, this);
}
else
{
_CentralManager.Adapter.BluetoothLeScanner.StartScan(this);
}
return(true);
}
catch (Exception ex)
{
BLE_ERR("start scan error", ex);
return(false);
}
}
public IObservable <ScanResult> Scan(ScanConfig config) => Observable.Create <ScanResult>(ob =>
{
this.devices.Clear();
this.callbacks = new LollipopScanCallback(
sr =>
{
var scanResult = this.ToScanResult(sr.Device, sr.Rssi, new AdvertisementData(sr));
ob.OnNext(scanResult);
},
errorCode => ob.OnError(new BleException("Error during scan: " + errorCode.ToString()))
);
var builder = new ScanSettings.Builder();
var scanMode = this.ToNative(config.ScanType);
builder.SetScanMode(scanMode);
var scanFilters = new List <ScanFilter>();
if (config.ServiceUuids != null && config.ServiceUuids.Count > 0)
{
foreach (var uuid in config.ServiceUuids)
{
var parcel = new ParcelUuid(UUID.FromString(uuid));
scanFilters.Add(new ScanFilter.Builder()
.SetServiceUuid(parcel)
.Build()
);
}
}
if (config.AndroidUseScanBatching && this.Manager.Adapter.IsOffloadedScanBatchingSupported)
{
builder.SetReportDelay(100);
}
this.Manager.Adapter.BluetoothLeScanner.StartScan(
scanFilters,
builder.Build(),
this.callbacks
);
return(() => this.Manager.Adapter.BluetoothLeScanner?.StopScan(this.callbacks));
});
public string onBluetooth()
{
if (adapter == null)
{
throw new Exception("No Bluetooth adapter found.");
}
ICollection <BluetoothDevice> pairedDevices = new List <BluetoothDevice>(); //List de stockage des devices appairés
pairedDevices = adapter.BondedDevices; //Appareils déjà appairés
if (pairedDevices.Count > 0) //Si on a des appareils appairés
{
foreach (BluetoothDevice device in pairedDevices) //Pour chaque pareil appairé
{
string deviceName = device.Name; //Nom de l'appareil
string deviceHardwareAddress = device.Address; // MAC address
ParcelUuid deviceUUID = device.GetUuids().ElementAt(0); // On récupère le UUID de l'appareil
if (device.Name == "HC-06") //Si l'appareil correspond, ici le Arduino
{
try
{
bluetoothSocket = device.CreateRfcommSocketToServiceRecord(deviceUUID.Uuid); //On crée un socket avec en paramètre l'UUID du téléphone
bluetoothSocket.Connect(); // On se connecte
}
catch (Java.IO.IOException e)
{
return("connexionKO");
}
if (bluetoothSocket.IsConnected)
{
return("connexionOK"); //Retourne ok si la connexion s'est établie
}
}
}
}
return("connexionKO");
}
public override void OnReceive(Context context, Intent intent)
{
string action = intent.Action;
if (Android.Bluetooth.BluetoothDevice.ActionUuid == action)
{
IParcelable[] parcelUuids = intent.GetParcelableArrayExtra(Android.Bluetooth.BluetoothDevice.ExtraUuid);
List <Guid> guids = new List <Guid>();
if (parcelUuids != null && parcelUuids.Length > 0)
{
foreach (IParcelable parcel in parcelUuids)
{
ParcelUuid parcelUuid = parcel as ParcelUuid;
if (parcelUuid != null)
{
guids.Add(parcelUuid.Uuid.ToGuid());
}
}
}
Application.Context.UnregisterReceiver(this);
List <IRfcommDeviceService> serviceList = new List <IRfcommDeviceService>();
foreach (var guid in guids)
{
var service = _DeviceWrapper.GetRXServiceFromDroidService(guid);
serviceList.Add(service);
}
RfcommDeviceServiceResult = new RfcommDeviceServiceResult()
{
Error = BluetoothError.Success,
Services = serviceList.ToArray()
};
if (_DeviceWrapper.FetchingUuidThread != null)
{
_DeviceWrapper.FetchingUuidThread.Interrupt();
}
}
}
private async void Imprimir()
{
try
{
IsEnabled = false;
IsRunning = true;
var mBluetoothAdapter = BluetoothAdapter.DefaultAdapter;
if (mBluetoothAdapter == null)
{
IsRunning = false;
IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
"Bluetooth",
"No se encuentra adaptador bluetooth",
"Aceptar");
return;
}
if (!mBluetoothAdapter.IsEnabled)
{
mBluetoothAdapter.Enable();
}
BluetoothDevice device = (from bd in mBluetoothAdapter.BondedDevices
where bd.Name.StartsWith("PT200")
select bd).FirstOrDefault();
if (device == null)
{
throw new Exception("Dispositivo no encontrado");
}
ParcelUuid uuid = device.GetUuids().ElementAt(0);
BluetoothSocket mmsSocket = device.CreateRfcommSocketToServiceRecord(uuid.Uuid);
await mmsSocket.ConnectAsync();
var Detalle = App.Data.GetCompraDetalle(Compra.IdCompra);
string Reporte = string.Empty;
Reporte += "\n";
Reporte += "====NEXPIRION====" + "\n";
Reporte += "Compra # " + Compra.Codigo + "\n";
Reporte += "Fecha # " + DateTime.Now.ToString() + "\n";
Reporte += "Recolector: " + Compra.IdUsuario + "\n";
Reporte += "Equipo: " + CrossDeviceInfo.Current.Id + "\n";
Reporte += "Proveedor: " + Compra.ProvNombre + "\n";
Reporte += "Producto: " + Compra.prDescripcion + "\n";
foreach (var item in Detalle)
{
Reporte += item.Descripcion + ": " + item.Valor.ToString("n2") + "\n";
}
Reporte += "Calificacion: " + Compra.Calificacion.ToString("n2") + "\n";
Reporte += "\n";
Reporte += "Cantidad: " + Compra.Cantidad.ToString("n2") + "\n";
Reporte += "Precio: " + _Compra.Precio.ToString("n2") + "\n";
Reporte += "Total: " + _Compra.Total.ToString("n2") + "\n";
Reporte += "\n";
Reporte += "\n";
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(Reporte);
mmsSocket.OutputStream.Write(buffer, 0, buffer.Length);
mmsSocket.Close();
IsEnabled = true;
IsRunning = false;
}
catch (Exception ex)
{
IsRunning = false;
IsEnabled = true;
await Application.Current.MainPage.DisplayAlert(
"Alerta",
ex.Message,
"Aceptar");
return;
}
}
public static ParcelUuid ToParcelUuid(this Guid guid) => ParcelUuid.FromString(guid.ToString());
protected override Task StartScanningForDevicesNativeAsync(Guid[] serviceUuids, CancellationToken scanCancellationToken)
{
// clear out the list
DiscoveredDevices.Clear();
if (serviceUuids == null || !serviceUuids.Any())
{
if (Build.VERSION.SdkInt < BuildVersionCodes.Lollipop)
{
Trace.Message("Adapter < 21: Starting a scan for devices.");
//without filter
#pragma warning disable 618
_bluetoothAdapter.StartLeScan(_api18ScanCallback);
#pragma warning restore 618
}
else
{
Trace.Message("Adapter >= 21: Starting a scan for devices.");
if (_bluetoothAdapter.BluetoothLeScanner != null)
{
_bluetoothAdapter.BluetoothLeScanner.StartScan(_api21ScanCallback);
}
else
{
Trace.Message("Adapter >= 21: Scan failed. Bluetooth is probably off");
}
}
}
else
{
if (Build.VERSION.SdkInt < BuildVersionCodes.Lollipop)
{
var uuids = serviceUuids.Select(u => UUID.FromString(u.ToString())).ToArray();
Trace.Message("Adapter < 21: Starting a scan for devices.");
#pragma warning disable 618
_bluetoothAdapter.StartLeScan(uuids, _api18ScanCallback);
#pragma warning restore 618
}
else
{
Trace.Message("Adapter >=21: Starting a scan for devices with service Id {0}.", serviceUuids.First());
var scanFilters = new List <ScanFilter>();
foreach (var serviceUuid in serviceUuids)
{
var sfb = new ScanFilter.Builder();
sfb.SetServiceUuid(ParcelUuid.FromString(serviceUuid.ToString()));
scanFilters.Add(sfb.Build());
}
var ssb = new ScanSettings.Builder();
//ssb.SetCallbackType(ScanCallbackType.AllMatches);
if (_bluetoothAdapter.BluetoothLeScanner != null)
{
_bluetoothAdapter.BluetoothLeScanner.StartScan(scanFilters, ssb.Build(), _api21ScanCallback);
}
else
{
Trace.Message("Adapter >= 21: Scan failed. Bluetooth is probably off");
}
}
}
return(Task.FromResult(true));
}
public static ParcelUuid ToJavaParcelUuid(this Guid self)
{
return(ParcelUuid.FromString(self.ToString()));
}
private void ProbeConnection()
{
ParcelUuid[] parcelUuids;
parcelUuids = Device.GetUuids();
bool isConnected = false;
if (parcelUuids == null)
{
parcelUuids = new ParcelUuid[1];
parcelUuids[0] = new ParcelUuid(UUID.FromString("00001101-0000-1000-8000-00805f9b34fb"));
}
foreach (var parcelUuid in parcelUuids)
{
mBluetoothAdapter.CancelDiscovery();
//METHOD A
try
{
var method = Device.GetType().GetMethod("createRfcommSocket");
mmSocket = (BluetoothSocket)method.Invoke(Device, new object[] { Port });
mmSocket.Connect();
isConnected = true;
DoDeviceConnected();
break;
}
catch (Exception)
{
}
//METHOD B
try
{
var method = Device.GetType().GetMethod("createInsecureRfcommSocket");
mmSocket = (BluetoothSocket)method.Invoke(Device, new object[] { Port });
mmSocket.Connect();
isConnected = true;
DoDeviceConnected();
break;
}
catch (Exception)
{
}
}
if (!isConnected)
{
//METHOD C
try
{
IntPtr createRfcommSocket = JNIEnv.GetMethodID(Device.Class.Handle, "createRfcommSocket", "(I)Landroid/bluetooth/BluetoothSocket;");
IntPtr _socket = JNIEnv.CallObjectMethod(Device.Handle, createRfcommSocket, new global::Android.Runtime.JValue(Port));
mmSocket = Java.Lang.Object.GetObject <BluetoothSocket>(_socket, JniHandleOwnership.TransferLocalRef);
mmSocket.Connect();
DoDeviceConnected();
}
catch (IOException connectException)
{
// Unable to connect; close the socket and get out
try
{
mmSocket.Close();
}
catch (IOException closeException)
{
}
DoDeviceConnectionFailed();
}
}
}
