AlertWear-T19 Developer's Portal

Compability Versions

This SDK is compatible for Android 6.0 (Marshmello) upto Android 10.

Project Dependency

To add this Device, 'com.github.avishekmca:T19Device:1.1' is necessary to add on your project. Unless it will not work.

System Requirements

Support for Bluetooth 4.0 on the device.

CPU architecture is on of the following: arm, arm64, x86, x86_64, mips, mips64.

Implementation Steps

Step 1: Add Dependency

Add this in root build.gradle at the end of repositories:

allprojects {

    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
    

Add it to your project:

implementation 'com.github.avishekmca:T19Device:1.1'

Step 2: Register Services

Add Services to manifiest file.

Step 3: Permissions

For BBX T19 library to work in your application, you should add the following permissions to your AndroidManifest.xml:

SDK Methods

Step 1: Connect to T19

implements Activity with implements BleWrapperUiCallbacks

Step 2: Initialize variables

Conn conn;

Bluetooth Bluetooth;

private final String LIST_NAME = "NAME";

private final String LIST_UUID = "UUID";

Attributes attributes=new Attributes();

bluetooth = Bluetooth.getInstance(this, this);

conn=new Conn(this,String dvc_id,bluetooth,attributes);

Step 3: Register and Unregister Receiver

For BBX T19 library to work in your application, you should add the following permissions to your AndroidManifest.xml:

Step 4: Service Binding

Intent gattServiceIntent = new Intent (this, BluetoothLeService.class);

bindService(gattServiceIntent, mServiceConnection, BIND_AUTO_CREATE);

on uiSuccessfulWrite.

Add Receiver

Add Broadcast Receiver mGattUpdateReceiver And get Data on OnReceive()

Calling Events

int i = 1;

class MyTask extends TimerTask {

public void run() {
        if (mGattCharacteristics != null) {
            if (mGattCharacteristics.size() > 3) {
                // for(int i=1;i<4;i++) {
                if (i == 5) i = 1;
                BluetoothGattCharacteristic characteristic;
                if (i == 1) {
                    characteristic =
                            mGattCharacteristics.get(3).get(0);
                } else {
                    characteristic =
                            mGattCharacteristics.get(6).get(i-1);
                }
                Log.e("count", i + "");
                i = i + 1;
                final int charaProp = characteristic.getProperties();
                if ((charaProp | BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
                    // If there is an active notification on a characteristic, clear
                    // it first so it doesn't update the data field on the user interface.
                    if (mNotifyCharacteristic != null
                            && mBluetoothLeService != null) {
                        mBluetoothLeService.setCharacteristicNotification(
                                mNotifyCharacteristic, false);
                        mNotifyCharacteristic = null;
                    }
                    if (mBluetoothLeService != null) {
                        mBluetoothLeService.readCharacteristic(characteristic);
                    }
                }
                if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                    mNotifyCharacteristic = characteristic;
                    if (mBluetoothLeService != null) {
                        mBluetoothLeService.setCharacteristicNotification(
                                characteristic, true);
                    }
                }

            }
        }
    }

}

Data Storage

private void displayGattServices(List gattServices) {

    if (gattServices == null) return;
    String uuid = null;
    String unknownServiceString = getResources().getString(R.string.unknown_service);
    String unknownCharaString = getResources().getString(R.string.unknown_characteristic);
    ArrayList<HashMap<String, String>> gattServiceData = new ArrayList<>();
    ArrayList<ArrayList<HashMap<String, String>>> gattCharacteristicData
            = new ArrayList<ArrayList<HashMap<String, String>>>();
    mGattCharacteristics = new ArrayList<>();
    // Loops through available GATT Services.
    for (BluetoothGattService gattService : gattServices) {
        HashMap<String, String> currentServiceData = new HashMap<>();
        uuid = gattService.getUuid().toString();
        currentServiceData.put(
                LIST_NAME, SampleGattAttributes.lookup(uuid, unknownServiceString));
        currentServiceData.put(LIST_UUID, uuid);

        gattServiceData.add(currentServiceData);

        ArrayList<HashMap<String, String>> gattCharacteristicGroupData =
                new ArrayList<HashMap<String, String>>();
        List<BluetoothGattCharacteristic> gattCharacteristics =
                gattService.getCharacteristics();
        ArrayList<BluetoothGattCharacteristic> charas =
                new ArrayList<BluetoothGattCharacteristic>();

        for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
            charas.add(gattCharacteristic);
            HashMap<String, String> currentCharaData = new HashMap<String, String>();
            uuid = gattCharacteristic.getUuid().toString();
            currentCharaData.put(
                    LIST_NAME, SampleGattAttributes.lookup(uuid, unknownCharaString));
            currentCharaData.put(LIST_UUID, uuid);
            gattCharacteristicGroupData.add(currentCharaData);
        }
        mGattCharacteristics.add(charas);
        gattCharacteristicData.add(gattCharacteristicGroupData);
    }

    SimpleExpandableListAdapter gattServiceAdapter = new SimpleExpandableListAdapter(
            this,
            gattServiceData,
            android.R.layout.simple_expandable_list_item_2,
            new String[]{LIST_NAME, LIST_UUID},
            new int[]{android.R.id.text1, android.R.id.text2},
            gattCharacteristicData,
            android.R.layout.simple_expandable_list_item_2,
            new String[]{LIST_NAME, LIST_UUID},
            new int[]{android.R.id.text1, android.R.id.text2}
    );
    mGattServicesList.setAdapter(gattServiceAdapter);

}

private static IntentFilter makeGattUpdateIntentFilter() {

    final IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(BluetoothLeService.ACTION_GATT_CONNECTED);
    intentFilter.addAction(BluetoothLeService.ACTION_GATT_DISCONNECTED);
        intentFilter.addAction(BluetoothLeService.ACTION_GATT_SERVICES_DISCOVERED);
    intentFilter.addAction(BluetoothLeService.ACTION_DATA_AVAILABLE);
    return intentFilter;

}

Device Battery Status

Call this methods to get Battery Information.

attributes.getBattery() methods returns Battery Information details.

Add this after conn.display(intent.getStringExtra(BluetoothLeService.EXTRA_DATA));

Device Contact Tracing Data

Step 1: Add this piece of code

int i = 4;

class MyTask extends TimerTask {

public void run() {
    if (mGattCharacteristics != null) {
        if (mGattCharacteristics.size() > 3) {
            if (i == 78) i = 4;
            BluetoothGattCharacteristic characteristic;
            characteristic =
                    mGattCharacteristics.get(6).get(i);
            i = i + 1;
            final int charaProp = characteristic.getProperties();
            if ((charaProp | BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
                if (mNotifyCharacteristic != null
                        && mBluetoothLeService != null) {
                    mBluetoothLeService.setCharacteristicNotification(
                            mNotifyCharacteristic, false);
                    mNotifyCharacteristic = null;
                }
                if (mBluetoothLeService != null) {
                    mBluetoothLeService.readCharacteristic(characteristic);
                }
            }
            if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
                mNotifyCharacteristic = characteristic;
                if (mBluetoothLeService != null) {
                    mBluetoothLeService.setCharacteristicNotification(
                            characteristic, true);
                }
            }
        }
    }
 }

}

Step 2: Fetching Contact Tracing Data

attributes.getAlrt_wr_mac_id() & attributes.getCntct_dt() returns Contact Tracing Data.

Add this after conn.display(intent.getStringExtra(BluetoothLeService.EXTRA_DATA)); Provides Conditions
!attributes.getAlrt_wr_mac_id().matches("") && attributes.getAlrt_wr_mac_id().length() > 4.

Device Temperature Data

Call this methods to get Temparature Information.

attributes.getTemp_cen(), attributes.getTemp_frn() methods returns Temparature details.

Add this after conn.display(intent.getStringExtra(BluetoothLeService.EXTRA_DATA));

Device Disconnection

To Disconnect Alert wear, just put this piece of code

try {

unbindService(mServiceConnection);
                                
mBluetoothLeService = null;
                                
if(bluetooth != null) {
                                    
bluetooth.disconnect();
                                
}
                                
Toast.makeText(getApplicationContext(),"Device is disconnected successfully!",Toast.LENGTH_SHORT).show();                           

}

catch(IllegalArgumentException ex){

Toast.makeText(getApplicationContext(),"Device is already disconnected!",Toast.LENGTH_SHORT).show();

}

Diagonis API

1. LED Test
Add this in your activity conn.led_Diago()

2. Buzzer Test
Add this in your activity conn.buzzer_Diago()

Integration for Beacon

Step 1:
Add Dependency
Implement dependency implementation 'org.altbeacon:android-beacon-library:2.17.1' in your Gradle file.

Step 2:
Initialization of variables

 private BeaconManager beaconManager;
 BeaconService beaconService;

Step 3:
Implementation for Beacon Feature
Need to implement BeaconConsumer in your Activity class

Step 4:
Write this piece of Code within onBeaconServiceConnect() to get UUID,Major Value,Minor Value and Distance as follows

//Constructing a new Region object to be used for Ranging or Monitoring

    final Region region = new Region("myBeaons",null, null, null);

    //Specifies a class that should be called each time the BeaconService sees or stops seeing a Region of beacons.
    beaconManager.addMonitorNotifier(new MonitorNotifier() {

        /*
            This override method is runned when some beacon will come under the range of device.
        */
        @Override
        public void didEnterRegion(Region region) {
            System.out.println("ENTER ------------------->");
            try {

                //Tells the BeaconService to start looking for beacons that match the passed Region object
                // , and providing updates on the estimated mDistance every seconds while beacons in the Region
                // are visible.
                beaconManager.startRangingBeaconsInRegion(region);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        /*
             This override method is runned when beacon that comes in the range of device
             ,now been exited from the range of device.
         */
        @Override
        public void didExitRegion(Region region) {
            System.out.println("EXIT----------------------->");
            try {

                //Tells the BeaconService to stop looking for beacons
                // that match the passed Region object and providing mDistance
                // information for them.
                beaconManager.stopRangingBeaconsInRegion(region);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }


        /*
             This override method will Determine the state for the device , whether device is in range
           of beacon or not , if yes then i = 1 and if no then i = 0
        */
        @Override
        public void didDetermineStateForRegion(int state, Region region) {
            System.out.println( "I have just switched from seeing/not seeing beacons: "+state);
        }
    });



    //Specifies a class that should be called each time the BeaconService gets ranging data,
    // which is nominally once per second when beacons are detected.
    beaconManager.addRangeNotifier(new RangeNotifier() {

        /*
           This Override method tells us all the collections of beacons and their details that
           are detected within the range by device
         */
        @Override
        public void didRangeBeaconsInRegion(Collection<Beacon> beacons, Region region) {
            System.out.println( "AAAAAAAA11111: "+beacons);

                // Iterating through all Beacons from Collection of Beacons
                for (Beacon b:beacons){

                    //UUID
                    String uuid = String.valueOf(b.getId1());

                    //Major
                    long major = Long.parseLong(String.valueOf(b.getId2()));

                    long unsignedTemp = Long.parseLong(String.valueOf(major>>8));
                    // long unsignedTemp = Long.parseLong(major);
                    double temperature = unsignedTemp > 128 ?
                            unsignedTemp - 256 :
                            unsignedTemp +(Long.parseLong(String.valueOf(unsignedTemp & 0xff)))/25;
                    //Minor
                    String minor = String.valueOf(b.getId3());

                    //Distance
                    double distance1 =b.getDistance();
                    String distance = String.valueOf(Math.round(distance1*100.0)/100.0);
                }
           
        }
    });
    try {
        //Tells the BeaconService to start looking for beacons that match the passed Region object.
        beaconManager.startMonitoringBeaconsInRegion(region);
    } catch (RemoteException e) {
    }