Visit the free getting started tutorials on nativescript.org for JavaScript or Angular.
Kindly note that we filter out plugins that:
package.json
$ tns plugin add nativescript-bluetooth
From the command prompt go to your app's root folder and execute:
tns plugin add nativescript-bluetooth
And do yourself a favor by adding TypeScript support to your nativeScript app:
tns install typescript
Want to dive in quickly? Check out the demo app! Otherwise, mix and match these functions as you see fit:
Reports if bluetooth is enabled.
// require the plugin var bluetooth = require("nativescript-bluetooth"); bluetooth.isBluetoothEnabled().then( function(enabled) { console.log("Enabled? " + enabled); } );
Since plugin version 1.2.0 the startScanning function will handle this internally so it's no longer mandatory to add permission checks to your code.
startScanning
On Android 6 you need to request permission to be able to interact with a Bluetooth peripheral (when the app is in the background) when targeting API level 23+. Even if the uses-permission tag for ACCESS_COARSE_LOCATION is present in AndroidManifest.xml.
uses-permission
ACCESS_COARSE_LOCATION
AndroidManifest.xml
Note that for BLUETOOTH and BLUETOOTH_ADMIN you don't require runtime permission; adding those to AndroidManifest.xml suffices (which the plugin does for you).
BLUETOOTH
BLUETOOTH_ADMIN
Note that hasCoarseLocationPermission will return true when:
hasCoarseLocationPermission
bluetooth.hasCoarseLocationPermission().then( function(granted) { // if this is 'false' you probably want to call 'requestCoarseLocationPermission' now console.log("Has Location Permission? " + granted); } );
// if no permission was granted previously this will open a user consent screen bluetooth.requestCoarseLocationPermission().then( function(granted) { console.log("Location permission requested, user granted? " + granted); } );
The promise will be rejected on iOS
// This turns bluetooth on, will return false if the user denied the request. bluetooth.enable().then( function(enabled) { // use Bluetooth features if enabled is true } );
A few of the optional params require a bit of explanation:
Scanning for peripherals drains the battery quickly, so you better not scan any longer than necessary. If a peripheral is in range and not engaged in another connection it usually pops up in under a second. If you don't pass in a number of seconds you will need to manually call stopScanning.
stopScanning
Set this to true if you don't want the plugin to check (and request) the required Bluetooth permissions. Particularly useful if you're running this function on a non-UI thread (ie. a Worker). Relevant on Android only.
It's inefficient to scan for all available Bluetooth peripherals and have them report all services they offer.
If you're only interested in finding a heartrate peripheral for instance, pass in service UUID '180d' like this: serviceUUIDs: ['180d']. If you add 2 or more (comma separated) services then only peripherals supporting ALL those services will match.
'180d'
Note that UUID's are ALWAYS strings; don't pass integers.
While scanning the plugin will immediately report back uniquely discovered peripherals.
This function will receive an object representing the peripheral which contains these properties (and types):
UUID: string
name: string
RSSI: number
services?:
manufacturerId?: number
manufacturerData?: ArrayBuffer
bluetooth.startScanning({ serviceUUIDs: [], seconds: 4, onDiscovered: function (peripheral) { console.log("Periperhal found with UUID: " + peripheral.UUID); }, skipPermissionCheck: false, }).then(function() { console.log("scanning complete"); }, function (err) { console.log("error while scanning: " + err); });
At any time during a scan, being one where you passed in a number or seconds or not, you can stop the scan by calling this function.
You may for instance want to stop scanning when the peripheral you found in startScanning's onDiscovered callback matches your criteria.
onDiscovered
bluetooth.stopScanning().then(function() { console.log("scanning stopped"); });
Pass in the UUID of the peripheral you want to connect to and once a connection has been established the onConnected callback function will be invoked. This callback will received the peripheral object as before, but it's now enriched with a services property. An example of the returned peripheral object could be:
onConnected
services
peripheral: { UUID: '3424-542-4534-53454', name: 'Polar P7 Heartrate Monitor', RSSI: '-57', services: [{ UUID: '180d', name: 'Heartrate service', characteristics: [{ UUID: '34534-54353-234324-343', name: 'Heartrate characteristic', properties: { read: true, write: false, writeWithoutResponse: false, notify: true } }] }] }
Here's the connect function in action with an implementation of onConnected that simply dumps the entire peripheral object to the console:
connect
bluetooth.connect({ UUID: '04343-23445-45243-423434', onConnected: function (peripheral) { console.log("Periperhal connected with UUID: " + peripheral.UUID); // the peripheral object now has a list of available services: peripheral.services.forEach(function(service) { console.log("service found: " + JSON.stringify(service)); }); }, onDisconnected: function (peripheral) { console.log("Periperhal disconnected with UUID: " + peripheral.UUID); } });
Also note that onDisconnected function: if you try to interact with the peripheral after this event you risk crashing your app.
onDisconnected
Once done interacting with the peripheral be a good citizen and disconnect. This will allow other applications establishing a connection.
bluetooth.disconnect({ UUID: '34234-5453-4453-54545' }).then(function() { console.log("disconnected successfully"); }, function (err) { // in this case you're probably best off treating this as a disconnected peripheral though console.log("disconnection error: " + err); });
If a peripheral has a service that has a characteristic where properties.read is true then you can call the read function to retrieve the current state (value) of the characteristic.
properties.read
true
read
The promise will receive an object like this:
{ value: <ArrayBuffer>, // an ArrayBuffer which you can use to decode (see example below) valueRaw: <72>, // the platform-specific binary value of the characteristic: NSData (iOS), byte[] (Android) characteristicUUID: '434234-234234-234234-434' }
Armed with this knowledge, let's invoke the read function:
bluetooth.read({ peripheralUUID: '34234-5453-4453-54545', serviceUUID: '180d', characteristicUUID: '3434-45234-34324-2343' }).then(function(result) { // fi. a heartrate monitor value (Uint8) can be retrieved like this: var data = new Uint8Array(result.value); console.log("Your heartrate is: " + data[1] + " bpm"); }, function (err) { console.log("read error: " + err); });
If a peripheral has a service that has a characteristic where properties.write is true then you can call the write function to update the current state (value) of the characteristic.
properties.write
write
The value must be hexadecimal, so if you want to send a 1, send 0x01. If you want to send multiple bytes add a comma: "0x007F,0x006E".
1
0x01
"0x007F,0x006E"
bluetooth.write({ peripheralUUID: '34134-5453-4453-54545', serviceUUID: '180e', characteristicUUID: '3424-45234-34324-2343', value: '0x01' // a hex 1 }).then(function(result) { console.log("value written"); }, function (err) { console.log("write error: " + err); });
Same API as write, except that when the promise is invoked the value has not been written yet; it has only been requested to be written an no response will be received when it has.
If a peripheral has a service that has a characteristic where properties.notify is true then you can call the startNotifying function to retrieve the value changes of the characteristic.
properties.notify
startNotifying
Usage is very much like read, but the result won't be sent to the promise, but to the onNotify callback function you pass in. This is because multiple notifications can be received and a promise can only resolve once. The value of the object sent to onNotify is the same as the one you get in the promise of read.
onNotify
bluetooth.startNotifying({ peripheralUUID: '34234-5453-4453-54545', serviceUUID: '180d', characteristicUUID: '3434-45234-34324-2343', onNotify: function (result) { // see the read example for how to decode ArrayBuffers console.log("read: " + JSON.stringify(result)); } }).then(function() { console.log("subscribed for notifications"); });
Enough is enough. When you're no longer interested in the values the peripheral is sending you do this:
bluetooth.stopNotifying({ peripheralUUID: '34234-5453-4453-54545', serviceUUID: '180d', characteristicUUID: '3434-45234-34324-2343' }).then(function() { console.log("unsubscribed for notifications"); }, function (err) { console.log("unsubscribe error: " + err); });
The app using bluetooth can generate many console.log messages - one for each characteristic read, write, change. This can be reduced by calling bluetooth.setCharacteristicLogging(false).
bluetooth.setCharacteristicLogging(false)
manufacturerId
manufacturerData
enable
setCharacteristicLogging
notify
ArrayBuffer
Get a merge issue in AndroidManifest.xml? Remove the platforms/android folder and rebuild.
Popularity metric based on:
Quality metric based on:
Maintenance metric based on: