Android as Bluetooth Low Energy Peripheral (GATT server).

  I demonstrate how to write a simple BLE peripheral application in Android here. I am bad in Android development, The UI would be very ugly, but the code work:

  Currently(5/25/2015), the code could be running in Nexus 6 or Nexus 9 only based on my test. The other phones or tablets DO NOT support to be a BLE peripheral.  So, if you really interested in the issue of Android as BLE Peripheral , please open your wallet or swipe your card, to buy a GOOGLE official device, thank you.


 To add a characteristic as notification is little bit complicated, In here I just add read and write characteristics.
  About the notification, I put code in the last part of this post.

You should add

 <uses-permission android:name="android.permission.BLUETOOTH" />
 <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

The 2 lines in your AndroidManifest.xml, like this :

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.gaiger.simplebleperipheral"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="21"
        android:targetSdkVersion="21" />

    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />    

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

The kernal code are below , note the AdvertiseCallback is callback of BluetoothLeAdvertiser ::startAdvertising, and BluetoothGattServerCallback is callback function of ALL BluetoothGattCharacteristic.


BLEPeripheral.java: (that is what you want)

package com.gaiger.simplebleperipheral;


import java.util.List;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattServer;
import android.bluetooth.BluetoothGattServerCallback;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.le.AdvertiseCallback;
import android.bluetooth.le.AdvertiseData;
import android.bluetooth.le.AdvertiseSettings;
import android.bluetooth.le.BluetoothLeAdvertiser;
import android.content.Context;
import android.content.pm.PackageManager;
import android.os.Handler;
import android.util.Log;


public class BLEPeripheral{

 public interface ConnectionCallback {
     void onConnectionStateChange(BluetoothDevice device, int newState);
 }

 
 BluetoothManager mManager;
 BluetoothAdapter mAdapter;
 
 BluetoothLeAdvertiser  mLeAdvertiser;
 
 AdvertiseSettings.Builder settingBuilder;
 AdvertiseData.Builder advBuilder;        
 
 BluetoothGattServer  mGattServer;  
 
 ConnectionCallback mConnectionCallback;
 
 public interface WriteCallback {
     void onWrite(byte[] data);
 }

 WriteCallback mWriteCallback;
 
 public static boolean isEnableBluetooth(){
  return BluetoothAdapter.getDefaultAdapter().isEnabled();
 }
 
 public int init(Context context){
  
  if(null == mManager)
  {
   mManager = (BluetoothManager)context.getSystemService(Context.BLUETOOTH_SERVICE);
  
   if(null == mManager)
    return -1;
  
   if(false == context.getPackageManager().
     hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE))
    return -2;          
  }      
  
  if(null == mAdapter)
  {
   mAdapter = mManager.getAdapter();
  
   if(false == mAdapter.isMultipleAdvertisementSupported())
    return -3; 
  }
  
  if(null == settingBuilder)
  {
   settingBuilder = new AdvertiseSettings.Builder();
   settingBuilder.setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY);
   settingBuilder.setConnectable(true);   
   settingBuilder.setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_HIGH);  
  } 
  
  if(null == advBuilder)
  {
   advBuilder = new AdvertiseData.Builder();                                         
   mAdapter.setName("SimplePeripheral");        
   advBuilder.setIncludeDeviceName(true);
  }
  
  
        if(null == mGattServer)
        {
         mGattServer = mManager.openGattServer(context, mGattServerCallback);
        
         if(null == mGattServer)
          return -4;        
     
         addDeviceInfoService();              
        }
        
  return 0;
 }
 
 public void setConnectionCallback(ConnectionCallback callback)
 {
  mConnectionCallback = callback;
 }
 
 public void close()
 {
  if(null != mLeAdvertiser)
   stopAdvertise();
  
  if(null != mGattServer)
   mGattServer.close();
  mGattServer = null;
  
  if(null != advBuilder)
   advBuilder = null;
  
  if(null != settingBuilder)
        settingBuilder = null;
  
  if(null != mAdapter)
        mAdapter = null;
  
  if(null != mManager)
        mManager = null;   
 }
 

 public static String getAddress(){return BluetoothAdapter.getDefaultAdapter().getAddress();}
 
 private AdvertiseCallback mAdvCallback = new AdvertiseCallback() {
  
  @Override
  public void onStartFailure(int errorCode){
   Log.d("advertise","onStartFailure");
  }
  
  @Override
  public void onStartSuccess(AdvertiseSettings settingsInEffect){
   Log.d("advertise","onStartSuccess");
  };
 };
 
  private final BluetoothGattServerCallback mGattServerCallback 
   = new BluetoothGattServerCallback(){
   
  @Override
        public void onConnectionStateChange(BluetoothDevice device, int status, int newState){
   Log.d("GattServer", "Our gatt server connection state changed, new state ");
         Log.d("GattServer", Integer.toString(newState));      
                  
         if(null != mConnectionCallback && BluetoothGatt.GATT_SUCCESS == status)
          mConnectionCallback.onConnectionStateChange(device, newState);
          
            super.onConnectionStateChange(device, status, newState);
        }
   
  @Override
        public void onServiceAdded(int status, BluetoothGattService service) {
            Log.d("GattServer", "Our gatt server service was added.");
            super.onServiceAdded(status, service);
        }

        @Override
        public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattCharacteristic characteristic) {
            Log.d("GattServer", "Our gatt characteristic was read.");
            super.onCharacteristicReadRequest(device, requestId, offset, characteristic);
            mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, 
              characteristic.getValue());
        }

        @Override
        public void onCharacteristicWriteRequest(BluetoothDevice device, int requestId, BluetoothGattCharacteristic characteristic, boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
            Log.d("GattServer", "We have received a write request for one of our hosted characteristics");
            //Log.d("GattServer", "data = "+ value.toString()); 
            super.onCharacteristicWriteRequest(device, requestId, characteristic, preparedWrite, responseNeeded, offset, value);
            
            if(null != mWriteCallback)
             mWriteCallback.onWrite(value);
            
        }

        @Override
        public void onNotificationSent(BluetoothDevice device, int status)
        {
         Log.d("GattServer", "onNotificationSent");          
         super.onNotificationSent(device, status);                  
        }
        
        @Override
        public void onDescriptorReadRequest(BluetoothDevice device, int requestId, int offset, BluetoothGattDescriptor descriptor) {
            Log.d("GattServer", "Our gatt server descriptor was read.");
            super.onDescriptorReadRequest(device, requestId, offset, descriptor);
            
        }

        @Override
        public void onDescriptorWriteRequest(BluetoothDevice device, int requestId, BluetoothGattDescriptor descriptor, boolean preparedWrite, boolean responseNeeded, int offset, byte[] value) {
            Log.d("GattServer", "Our gatt server descriptor was written.");
            super.onDescriptorWriteRequest(device, requestId, descriptor, preparedWrite, responseNeeded, offset, value);
        }

        @Override
        public void onExecuteWrite(BluetoothDevice device, int requestId, boolean execute) {
            Log.d("GattServer", "Our gatt server on execute write.");
            super.onExecuteWrite(device, requestId, execute);
        }
   
 };
 
 private void addDeviceInfoService()
 {  
  if(null == mGattServer)
   return;  
  
  final String SERVICE_DEVICE_INFORMATION = "0000180a-0000-1000-8000-00805f9b34fb";
        final String SOFTWARE_REVISION_STRING = "00002A28-0000-1000-8000-00805f9b34fb";
        
        
  BluetoothGattService previousService =
           mGattServer.getService( UUID.fromString(SERVICE_DEVICE_INFORMATION));
                 
     if(null != previousService)        
         mGattServer.removeService(previousService);
      
        
        BluetoothGattCharacteristic softwareVerCharacteristic = new BluetoothGattCharacteristic(
          UUID.fromString(SOFTWARE_REVISION_STRING), 
          BluetoothGattCharacteristic.PROPERTY_READ,
          BluetoothGattCharacteristic.PERMISSION_READ
          );
        
        BluetoothGattService deviceInfoService = new BluetoothGattService(
          UUID.fromString(SERVICE_DEVICE_INFORMATION), 
          BluetoothGattService.SERVICE_TYPE_PRIMARY);
        
        
        softwareVerCharacteristic.setValue(new String("0.0.0").getBytes());
        
        deviceInfoService.addCharacteristic(softwareVerCharacteristic);
        mGattServer.addService(deviceInfoService);
 }
 
 
 
 
 public void setService(String read1Data, String read2Data, WriteCallback
   writeCallBack)
 {  
         
  if(null == mGattServer)
   return ;
  
  stopAdvertise();
  
        final String  SERVICE_A = "0000fff0-0000-1000-8000-00805f9b34fb";
        final String  CHAR_READ1 = "0000fff1-0000-1000-8000-00805f9b34fb";
        final String  CHAR_READ2 = "0000fff2-0000-1000-8000-00805f9b34fb";
        final String  CHAR_WRITE = "0000fff3-0000-1000-8000-00805f9b34fb";       
        final String  CHAR_NOTIFY = "0000fff4-0000-1000-8000-00805f9b34fb";       
        
        
        
        BluetoothGattService previousService =
          mGattServer.getService( UUID.fromString(SERVICE_A));
                
     if(null != previousService)        
         mGattServer.removeService(previousService);
        
               
        
        BluetoothGattCharacteristic read1Characteristic = new BluetoothGattCharacteristic(
          UUID.fromString(CHAR_READ1), 
          BluetoothGattCharacteristic.PROPERTY_READ,
          BluetoothGattCharacteristic.PERMISSION_READ
          );                 
        
        BluetoothGattCharacteristic read2Characteristic = new BluetoothGattCharacteristic(
          UUID.fromString(CHAR_READ2), 
          BluetoothGattCharacteristic.PROPERTY_READ,
          BluetoothGattCharacteristic.PERMISSION_READ
          );
                
        BluetoothGattCharacteristic writeCharacteristic = new BluetoothGattCharacteristic(
             UUID.fromString(CHAR_WRITE), 
             BluetoothGattCharacteristic.PROPERTY_WRITE,
             BluetoothGattCharacteristic.PERMISSION_WRITE
             );
        
       
       
                               
        read1Characteristic.setValue(read1Data.getBytes());
        read2Characteristic.setValue(read2Data.getBytes());
        mWriteCallback = writeCallBack;
       
        
        BluetoothGattService AService = new BluetoothGattService(
          UUID.fromString(SERVICE_A), 
          BluetoothGattService.SERVICE_TYPE_PRIMARY);
                         
        
        AService.addCharacteristic(read1Characteristic);
        AService.addCharacteristic(read2Characteristic);
        AService.addCharacteristic(writeCharacteristic); 
        
        

        final BluetoothGattCharacteristic notifyCharacteristic = new BluetoothGattCharacteristic(
             UUID.fromString(CHAR_NOTIFY), 
             BluetoothGattCharacteristic.PROPERTY_NOTIFY,
             BluetoothGattCharacteristic.PERMISSION_READ
             );
           
        
        notifyCharacteristic.setValue(new String("0"));
        AService.addCharacteristic(notifyCharacteristic);  
        
        final Handler handler = new Handler();
        
        Thread thread = new Thread() {
         int i = 0;         
         
            @Override
            public void run() {             
               
                    while(true) {
                     
                        try {
       sleep(1500);
      } catch (InterruptedException e) {}
                        
                        handler.post(this);
                        
                        List<BluetoothDevice> connectedDevices 
                         = mManager.getConnectedDevices(BluetoothProfile.GATT);
                        
                        if(null != connectedDevices)
                        {
                         notifyCharacteristic.setValue(String.valueOf(i).getBytes());
                                                 
                         if(0 != connectedDevices.size())
                          mGattServer.notifyCharacteristicChanged(connectedDevices.get(0),
                            notifyCharacteristic, false);
                        }                       
                        i++;
                    }               
            }
        };

        thread.start();
           
        
        mGattServer.addService(AService);
 }
  
 
 public void startAdvertise(String scanRespenseName)
 {  
  mAdapter.setName(scanRespenseName);        
        advBuilder.setIncludeDeviceName(true);
        
        startAdvertise();
 }
 
 public void startAdvertise()
 {
  if(null == mAdapter)
   return;
  
  if (null == mLeAdvertiser) 
   mLeAdvertiser = mAdapter.getBluetoothLeAdvertiser();
        
  if(null == mLeAdvertiser)
   return;
                     
         mLeAdvertiser.startAdvertising(settingBuilder.build(), 
           advBuilder.build(), mAdvCallback);         
 }
 
 public void stopAdvertise()
 {
  if(null != mLeAdvertiser)
   mLeAdvertiser.stopAdvertising(mAdvCallback);
  
  mLeAdvertiser = null;  
 }
  
}

There is a callback interface WriteCallback to hold tthe data which the BLE has written.

MainActivity.java : (UI part)

package com.gaiger.simplebleperipheral;

import java.io.UnsupportedEncodingException;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.CheckBox;
import android.widget.TextView;
import android.widget.Toast;


public class MainActivity extends Activity {

 private BLEPeripheral blePeri; 
 private CheckBox  adverstiseCheckBox;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        adverstiseCheckBox = (CheckBox) findViewById(R.id.advertise_checkBox);
        
        blePeri = new BLEPeripheral();                        
        
        adverstiseCheckBox.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
             
             if(true == adverstiseCheckBox.isChecked())
             {              
            
              TextView textView;
              textView = (TextView)findViewById(R.id.status_textView);
              textView.setText("advertising");              
              
              blePeri.setService(new String("GAIGER"),
                new String("AndroidBLE"),
                mWrittenCallback
                );    
              
              blePeri.startAdvertise();
             }
             else
             {
              TextView textView;
              textView = (TextView)findViewById(R.id.status_text);
              textView.setText("disable");
              blePeri.stopAdvertise();              
             }
            }
        });
        
        adverstiseCheckBox.setEnabled(false);
        
     if(false == BLEPeripheral.isEnableBluetooth())
     {
      
      Intent intentBtEnabled = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); 
            // The REQUEST_ENABLE_BT constant passed to startActivityForResult() is a locally defined integer (which must be greater than 0), that the system passes back to you in your onActivityResult() 
            // implementation as the requestCode parameter. 
            int REQUEST_ENABLE_BT = 1;
            startActivityForResult(intentBtEnabled, REQUEST_ENABLE_BT);
            
            Toast.makeText(this, "Please enable bluetooth and execute the application agagin.",
     Toast.LENGTH_LONG).show();
     }          
     
    }

    
    byte[]  writtenByte;
    BLEPeripheral.WriteCallback mWrittenCallback = new BLEPeripheral.WriteCallback()
    {
      @Override
  public        
      void onWrite(byte[] data)
      {
       writtenByte = data.clone();
      
       Thread timer = new Thread(){
              public void run() {
                  
                  runOnUiThread(new Runnable() {
                   @Override
                   public void run() {
                     TextView textView;
                     textView = (TextView)findViewById(R.id.written_textView);
                  try {
          textView.setText(new String(writtenByte, "UTF-8"));
         } catch (UnsupportedEncodingException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
         }
                   }
                      });
              }
              
          };
          
          timer.start();
       
       
        }            
          
   };
    
   
 
    
    Runnable mCleanTextRunnable = new Runnable() {
        public void run() {
         TextView textView;
       textView = (TextView)findViewById(R.id.connected_textView);
       textView.setText("no connection");             
        }
    };
    
    Handler mConnectTextHandler = new Handler() {  
        
        @Override                  
        public void handleMessage(Message msg) {  
            super.handleMessage(msg);
            String data = (String)msg.obj;  
            
            
            switch (msg.what) {
            
            case 0:
             data += new String(" disconnected");
             this.postDelayed(mCleanTextRunnable, 3000);
             break;
             
            case 2: 
             data += new String(" connected");                                                          
                break;                  
            default:  
                break;  
            }
            
            TextView textView;
      textView = (TextView)findViewById(R.id.connected_textView);
      textView.setText(data);              
        }  
  
    }; 
    
    
    @Override
    public void onResume(){
     
        super.onResume();
                       
        int sts;
        sts = blePeri.init(this);
       
//        blePeri.mConnectionCallback = new BLEPeripheral.ConnectionCallback (){
//         @Override
//      public void onConnectionStateChange(BluetoothDevice device, int newState){
//       Log.d("main","onConnectionStateChange");
//      }
//        };
//       
        blePeri.setConnectionCallback( new BLEPeripheral.ConnectionCallback (){
             @Override
          public void onConnectionStateChange(BluetoothDevice device, int newState){           
                                          
              Message msg = new Message();    
              
              msg.what = newState;                      
              msg.obj = new String( device.getName() +" "+ device.getAddress() );
              
              mConnectTextHandler.sendMessage(msg);                                       
          }
            }
           
         );
        
         
        
        if(0  > sts)
     {
      if(-1 == sts)
       Toast.makeText(this, "this device is without bluetooth module",
         Toast.LENGTH_LONG).show();
      
      if(-2 == sts)
       Toast.makeText(this, "this device do not support Bluetooth low energy", 
         Toast.LENGTH_LONG).show();
      
      if(-3 == sts)
       Toast.makeText(this, "this device do not support to be a BLE peripheral, " +
         "please buy nexus 6 or 9 then try again", 
         Toast.LENGTH_LONG).show();
      
      finish();
     }   
        
        TextView textView;
     textView = (TextView)findViewById(R.id.mac_textView);
     
     textView.setText(BLEPeripheral.getAddress());
     
     
     adverstiseCheckBox.setEnabled(true);            
          
     
    }
    
    
    
    @Override
    protected void onStop() {
        super.onStop();      
    }

        
    
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    
    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

activity_main.xml: (layout, very ugly)

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.awind.presentsenseperipheral.MainActivity" >

    <TextView
        android:id="@+id/mac_textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignTop="@+id/status_text"
        android:layout_marginLeft="18dp"
        android:layout_toRightOf="@+id/status_text"
        android:text="00:11:22:AA:BB:CC"
        android:textAppearance="?android:attr/textAppearanceLarge" />

    <CheckBox
        android:id="@+id/advertise_checkBox"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_below="@+id/mac_text"
        android:layout_marginLeft="34dp"
        android:layout_marginTop="41dp"
        android:text="Advertise" />

    <TextView
        android:id="@+id/status_textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/advertise_checkBox"
        android:layout_alignParentTop="true"
        android:layout_marginTop="124dp"
        android:text="Disable"
        android:textAppearance="?android:attr/textAppearanceMedium" />

    <TextView
        android:id="@+id/connected_textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/mac_text"
        android:layout_centerVertical="true"
        android:text="no connection"
        android:textAppearance="?android:attr/textAppearanceLarge" />

    <TextView
        android:id="@+id/written_textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/mac_text"
        android:layout_alignParentBottom="true"
        android:text="WrittenText"
        android:textAppearance="?android:attr/textAppearanceLarge" />

</RelativeLayout>

    I do not like to write too much explanation in here, One said: if you could implement, you understand it; if you could not, you know about nothing of it .

    Notice the part of notifyCharacteristic ,I create a thread, which updates value and send a signal to BluetoothGattServer, to inform the BLE central the value has changed.

  There is a bug in written text update: once WriteCallback::onWrite been called, the runOnUiThread for updating  R.id.written_textView should be executed once. But in my code, the update would not work. That is very minior for the purpose of demonstration BLE on Android, So, please ignore it.