void Awake()
{
if (FindObjectsOfType(typeof(BluetoothManager)).Length > 1)
{
Destroy(this.gameObject);
return;
}
_instance = this;
DontDestroyOnLoad(this.gameObject);
initResult = BluetoothMultiplayerAndroid.Init("8ce255c0-200a-11e0-ac64-0800200c9a66");
BluetoothMultiplayerAndroid.SetVerboseLog(true);
// Registering the event delegates
BluetoothMultiplayerAndroidManager.onBluetoothListeningStartedEvent += onBluetoothListeningStarted;
BluetoothMultiplayerAndroidManager.onBluetoothListeningCanceledEvent += onBluetoothListeningCanceled;
BluetoothMultiplayerAndroidManager.onBluetoothAdapterEnabledEvent += onBluetoothAdapterEnabled;
BluetoothMultiplayerAndroidManager.onBluetoothAdapterEnableFailedEvent += onBluetoothAdapterEnableFailed;
BluetoothMultiplayerAndroidManager.onBluetoothAdapterDisabledEvent += onBluetoothAdapterDisabled;
BluetoothMultiplayerAndroidManager.onBluetoothConnectedToServerEvent += onBluetoothConnectedToServer;
BluetoothMultiplayerAndroidManager.onBluetoothConnectToServerFailedEvent += onBluetoothConnectToServerFailed;
BluetoothMultiplayerAndroidManager.onBluetoothDisconnectedFromServerEvent += onBluetoothDisconnectedFromServer;
BluetoothMultiplayerAndroidManager.onBluetoothClientConnectedEvent += onBluetoothClientConnected;
BluetoothMultiplayerAndroidManager.onBluetoothClientDisconnectedEvent += onBluetoothClientDisconnected;
BluetoothMultiplayerAndroidManager.onBluetoothDevicePickedEvent += onBluetoothDevicePicked;
}
public BLEDevice(BluetoothDevice nativeDevice)
{
_bluetoothManager = (BluetoothManager)Application.Context.GetSystemService(Context.BluetoothService);
_nativeDevice = nativeDevice;
Name = _nativeDevice.Name;
MacAddress = _nativeDevice.Address;
Guid = DeviceIdFromAddress(_nativeDevice.Address);
}
public CommunicationSDK()
{
dtmfVoip = new VOIPConfigurationManager(nc);
ncm = new NetworkConfigurationManager(nc);
webCloud = new CloudSettingsManager(nc);
bluetooth = new BluetoothManager(nc);
wum = new WebURLManager(nc);
//ncm = new NetworkConfigurationManager(nc);
}
public BluetoothScanner(Context context, Activity activity, MainActivity mainActivity)
{
this.context = context;
this.activity = activity;
this.mainActivity = mainActivity;
mLeDevices = new List <BluetoothDevice>();
bluetoothManager = (BluetoothManager)context.GetSystemService(Context.BluetoothService);
mBluetoothAdapter = bluetoothManager.Adapter;
}
private static void DoGetRadiosAsync(List <Radio> radios)
{
BluetoothManager manager = (BluetoothManager)Android.App.Application.Context.GetSystemService(Android.Content.Context.BluetoothService);
if (manager != null)
{
radios.Add(new Radio(manager));
}
}
protected BluetoothLEManager()
{
var appContext = Android.App.Application.Context;
manager = (BluetoothManager)appContext.GetSystemService(Context.BluetoothService);
adapter = manager.Adapter;
gattCallback = new GattaCallback(this);
}
public Device(BluetoothManager manager,
BluetoothDevice native,
GattCallbacks callbacks) : base(native.Name, ToDeviceId(native.Address))
{
this.context = new GattContext(native, callbacks);
this.manager = manager;
this.connSubject = new Subject <ConnectionStatus>();
}
protected override void OnStart()
{
base.OnStart();
_bluetoothManager = (BluetoothManager)GetSystemService(BluetoothService);
_bluetoothAdapter = _bluetoothManager.Adapter;
_bluetoothLeScanner = _bluetoothAdapter?.BluetoothLeScanner;
}
public MainPage()
{
this.InitializeComponent();
BluetoothManager bluetoothManager = BluetoothManager.Instance;
GattScanner gattScanner = bluetoothManager.GattScanner;
gattScanner.OnReceived += GattScanner_OnReceived;
gattScanner.StartScan();
}
private PumpManager()
{
_bluetoothManager = BluetoothManager.Instance;
_bluetoothManager.PumpDiscovered += _bluetoothManager_PumpDiscovered;
_bluetoothManager.PumpConnected += _bluetoothManager_PumpConnected;
_bluetoothManager.PumpDisconnected += _bluetoothManager_PumpDisconnected;
_bluetoothManager.LogUpdated += _bluetoothManager_LogUpdated;
}
public Advertiser()
{
this.manager = (BluetoothManager)Application.Context.GetSystemService(Context.BluetoothService);
this.adCallbacks = new AdvertisementCallbacks
{
Failed = e => throw e,
Started = () => IsStarted = true
};
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.activity_blood_pressure_device);
InitUi();
InitEvents();
IEnumerable <BluetoothDeviceRecords> list;
string data = Intent.GetStringExtra("Data");
Log.Error("Imei", data);
if (data != null)
{
if (Utils.isJson(data))
{
Log.Error("Imei", "data is json");
_imei = new JSONObject(data).GetString("deviceId");
}
else
{
Log.Error("Imei", "data is not json");
var decrypted = Encryption.Decrypt(data);
Log.Error("Imei decrypted", decrypted);
if (!string.IsNullOrEmpty(decrypted) && Utils.isJson(decrypted))
{
Log.Error("Imei", "tring to parse decrypted");
_imei = new JSONObject(decrypted).GetString("imei");
}
else
{
Log.Error("Imei", "imei is data");
_imei = data;
}
}
}
if (string.IsNullOrEmpty(_imei))
{
_imei = Utils.GetDeviceIdentificator(this);
}
Task.Run(async() => {
_bleDevicesDataRecords = await SqlHelper <DevicesRecords> .CreateAsync();
var bleDevicesRecords = await SqlHelper <BluetoothDeviceRecords> .CreateAsync();
list = await bleDevicesRecords.QueryValuations("select * from BluetoothDeviceRecords");
RunOnUiThread(() => {
_bluetoothManager = (BluetoothManager)GetSystemService(BluetoothService);
var listOfSavedDevices = list.ToList();
ScanCallback = new BloodPressureScanCallback(this, listOfSavedDevices);
GattCallback = new BloodPressureGattCallBack(this, listOfSavedDevices);
AnimationView.PlayAnimation();
});
}).Wait();
}
public BluetoothLEManager()
{
var appContext = Android.App.Application.Context;
// get a reference to the bluetooth system service
this._manager = (BluetoothManager)appContext.GetSystemService("bluetooth");
this._adapter = this._manager.Adapter;
this._gattCallback = new GattCallback(this);
}
public DroidToothReactive()
{
var appContext = Android.App.Application.Context;
// get a reference to the bluetooth system service
this.Manager = (BluetoothManager)appContext.GetSystemService("bluetooth");
this.Adapter = this.Manager.Adapter;
BroodSubject = new Subject <BroodtoothDevice> ();
}
//// ---------------------------------------------------------------------
#region CONSTRUCTION
/// <summary>
/// Initializes a new instance of the <see cref="MainPage"/> class.
/// </summary>
public MainPage()
{
this.InitializeComponent();
this.bluetoothManager = new BluetoothManager();
this.bluetoothManager.OutputHandler = this.OutputText;
this.bluetoothManager.MessageBoxReporter = ShowMessageBox;
this.EnablePanoramaPages(false);
} // MainPage()
public Device(BluetoothManager manager,
BluetoothDevice native,
GattCallbacks callbacks) : base(native.Name, ToDeviceId(native.Address))
{
this.connSubject = new Subject <ConnectionStatus>();
this.connFailSubject = new Subject <GattStatus>();
this.context = new DeviceContext(native, callbacks);
this.manager = manager;
this.InitStatusChangedObservable();
}
internal GattServer(BluetoothManager bluetoothManager)
{
_GattServices = new List <GattServerService>();
_ServerCallback = new ServerCallback(this);
_AdvertiserCallback = new AdvertiserCallback();
BluetoothManager = bluetoothManager;
DroidGattServer = BluetoothManager.DroidBluetoothManager.OpenGattServer(Application.Context, _ServerCallback);
//AddService(new DeviceInfomationService());
//AddService(new BatteryService());
}
internal BLEDevice(BluetoothManager manager, BluetoothDevice device)
: this()
{
_manager = manager;
_device = device;
_callback = new BLEGATTCallback();
_callback.ConnectionStateChanged += OnConnectionStateChanged;
_callback.ReadRemoteRSSI += OnReadRemoteRSSI;
_callback.ServicesDiscovered += OnServicesDiscovered;
}
public Device(BluetoothManager manager,
BluetoothDevice native,
GattCallbacks callbacks,
TaskScheduler scheduler) : base(native.Name, ToDeviceId(native.Address))
{
this.context = new GattContext(native, callbacks);
this.manager = manager;
this.scheduler = scheduler; // this is the thread that the device was scanned on (required by some devices)
this.connSubject = new Subject <ConnectionStatus>();
}
public MainPage()
{
this.InitializeComponent();
myBluetooth = new BluetoothManager();
myBluetooth.DiagnosticsChangedNotification += new BluetoothManager.DiagnosticsMessageDelegate(diagnosticsStringReceived);
myBluetooth.StatusChangedNotification += new BluetoothManager.StatusChangedDelegate(bluetoothStatusChanged);
this.navigationHelper = new NavigationHelper(this);
this.navigationHelper.LoadState += this.NavigationHelper_LoadState;
this.navigationHelper.SaveState += this.NavigationHelper_SaveState;
}
public bool OpenBluetoothSettings()
{
BluetoothManager bluetoothManager = (BluetoothManager)Plugin.CurrentActivity.CrossCurrentActivity.Current.AppContext.GetSystemService(Context.BluetoothService);
if (!bluetoothManager.Adapter.IsEnabled)
{
Intent bluSettingIntent = new Intent(Android.Provider.Settings.ActionBluetoothSettings);
CrossCurrentActivity.Current.AppContext.StartActivity(bluSettingIntent);
}
return(true);
}
public BluetoothConnector()
{
this.context = Android.App.Application.Context;
bluetoothManager = (BluetoothManager)context.GetSystemService(Context.BluetoothService);
bluetoothAdapter = bluetoothManager.Adapter;
bluetoothScanner = bluetoothManager.Adapter.BluetoothLeScanner;
bluetoothReceiver = new BluetoothReceiver(devicesResults, macAddressMapping);
context.RegisterReceiver(bluetoothReceiver, new IntentFilter(BluetoothDevice.ActionFound));
context.RegisterReceiver(bluetoothReceiver, new IntentFilter(BluetoothDevice.ExtraRssi));
this.scanThread = new Thread(Scan);
this.scanCallback = new BluetoothScanCallback(devicesResults, macAddressMapping);
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
public MainPageVM()
{
AppSettings = AppSettings.Instance;
var localFolder = Windows.Storage.ApplicationData.Current.LocalFolder.Path;
BlueMuseLogFolder = Path.Combine(localFolder, "Logs");
LSLBridgeLogFolder = BlueMuseLogFolder.Replace("LocalState", "LocalCache\\Local");
museManager = BluetoothManager.Instance;
Muses = museManager.Muses;
museManager.FindMuses();
searchTextAnimateTimer = new Timer(SearchTextAnimate, null, 0, 600); // Start the Searching for Muses... animation.
}
private void setupBluetooth()
{
if (manager != null)
{
return;
}
manager = new BluetoothManager();
manager.StatusChangedNotification += new BluetoothManager.StatusChangedDelegate(statusChanged);
manager.Initialise("PRINTER");
}
public OWBLE()
{
//_sdkInt = BuildVersionCodes.JellyBeanMr1;
/*
* _broadcastReceiver = new OWBLE_BroadcastReceiver(this);
* IntentFilter filter = new IntentFilter(BluetoothAdapter.ActionStateChanged);
* Xamarin.Essentials.Platform.AppContext.RegisterReceiver(_broadcastReceiver, filter);
*/
BluetoothManager manager = Xamarin.Essentials.Platform.CurrentActivity.GetSystemService(Context.BluetoothService) as BluetoothManager;
_adapter = manager.Adapter;
}
private async Task UpdateDevicesAsync()
{
IsBusy = true;
Devices.Clear();
foreach (var device in await BluetoothManager.GetDevicesAsync())
{
Devices.Add(device);
}
IsBusy = false;
}
/// <summary>
/// Initializes a new instance of the <see cref="BluetoothLE.Droid.Adapter"/> class.
/// </summary>
public Adapter()
{
var appContext = Android.App.Application.Context;
_manager = (BluetoothManager)appContext.GetSystemService("bluetooth");
_adapter = _manager.Adapter;
_callback = new GattCallback();
_callback.DeviceConnected += BluetoothGatt_DeviceConnected;
_callback.DeviceDisconnected += BluetoothGatt_DeviceDisconnected;
ConnectedDevices = new List <IDevice>();
}
public AndroidBluetooth()
{
bluetoothManager = Xamarin.Forms.Forms.Context.GetSystemService(Context.BluetoothService) as BluetoothManager;
bluetoothLeScanner = bluetoothManager.Adapter.BluetoothLeScanner;
gattServerCallback = new LeServerCallback();
gattServerCallback.OnDeviceAdded += GattServerCallback_OnDeviceAdded;
gattServerCallback.OnReadRequest += GattServerCallback_OnReadRequest;
scanCallback = new LeScanCallback();
scanCallback.OnScanFinished += Callback_OnScanFinished;
}
private void StartBluetoothService()
{
BluetoothManager manager = (BluetoothManager)GetSystemService(Context.BluetoothService);
BluetoothService bService = new BluetoothService(manager);
if (!bService.IsEnabled)
{
Intent enableBtIntent = new Intent(BluetoothAdapter.ActionRequestEnable);
StartActivityForResult(enableBtIntent, 1);
}
bService.StartScanning();
}
/// <summary>
/// Initiation of all application-modules
/// </summary>
private void initAppComponents()
{
restMng = new RestMng(Global.restAd);
dataBase = new Database();
bluetoothManager = new BluetoothManager();
appCore = AppCore.Instance;
appCore.SetDatabase(dataBase);
appCore.SetRestMng(restMng);
synchMng = new SynchronizationManager(appCore, dataBase, restMng);
wifiMng = new WifiConnectionManager(appCore, synchMng);
}
//--------------------------------------------------------------
// CONSTRUCTORS
//--------------------------------------------------------------
public AcceptThread(BluetoothManager service)
{
_service = service;
BluetoothServerSocket temp = null;
// Create a new listening server socket
try
{
temp = _service.BluetoothAdapter.ListenUsingRfcommWithServiceRecord(Name, BluetoothManager.MyUUID);
}
catch(Java.IO.IOException e)
{
Log.Error(BluetoothManager.Tag, "Listen() failed", e);
}
_serverSocket = temp;
}
//--------------------------------------------------------------
// CONSTRUCTORS
//--------------------------------------------------------------
public ConnectThread(BluetoothDevice device, BluetoothManager service)
{
_device = device;
_service = service;
BluetoothSocket tmp = null;
// Get a BluetoothSocket for a connection with the
// given BluetoothDevice
try
{
tmp = device.CreateRfcommSocketToServiceRecord(BluetoothManager.MyUUID);
}
catch(Java.IO.IOException e)
{
Log.Error(BluetoothManager.Tag, "create() failed", e);
}
_socket = tmp;
}
//--------------------------------------------------------------
// CONSTRUCTORS
//--------------------------------------------------------------
public ConnectedThread(BluetoothSocket socket, BluetoothManager service)
{
Log.Debug(BluetoothManager.Tag, "Create ConnectedThread: ");
_socket = socket;
_service = service;
Stream tempIn = null;
Stream tempOut = null;
// Get the BluetoothSocket input and output streams
try
{
tempIn = socket.InputStream;
tempOut = socket.OutputStream;
}
catch(Java.IO.IOException e)
{
Log.Error(BluetoothManager.Tag, "Temp sockets not created", e);
}
_inStream = tempIn;
_outStream = tempOut;
}
/* Activate the bluetooth to allow connection with an other device*/
public void EnableBluetooth()
{
_communicationWay = new BluetoothManager();
}
/* Stop all buetooth activities */
public void DisableBluetooth()
{
if(_communicationWay != null)
{
_communicationWay.Stop();
}
_communicationWay = null;
}
