Detect user’s activity using Activity Recognition Transition API

Transition API can tell if your users are walking, running, cycling, or in a vehicle and you can use it to improve your app experience.

Transition API combine various signals like location and sensor data to determine when the user has started or ended an activity like walking or driving.

1.Add Dependencies

Declare a dependency to the API, add a reference to the Google maven repository and add an implementation entry to to the dependencies section of your app build.gradle file.

2.Add Permission

Specify the permission in the app manifest.

3.Register for activity transition updates

To start receiving notifications about activity transitions, you must implement, An ActivityTransitionRequest object that specifies the type of activity and transition.PendingIntent callback where your app receives notifications.


You must create a list of ActivityTransition objects, which represent the transition that you want to receive notifications about. An ActivityTransition object includes the 1.An activity type  IN_VEHICLE,ON_BICYCLE,RUNNING,STILL,WALKING

2.A transition type of ACTIVITY_TRANSITION_ENTER or ACTIVITY_TRANSITION_EXIT. For more information, refer to theActivityTransition class.

The following code shows how to create a list of ActivityTransition objects:


When using the API, a common use case is that an application wants to monitor activity in the background and perform an action when a specific activity is detected.The application specifies a pending intent callback typically an intent service, which will be called with an intent when activities are detected.So there’s no need to keep the service always running in the background.

After successfully registering for activity transition updates, your app receives notifications in the registered PendingIntent.

4.Receive activity transition events

When the requested activity transition occurs, you app receives an Intent callback.The events are ordered in chronological order, for example, if an app requests for the IN_VEHICLE activity type on the ACTIVITY_TRANSITION_ENTER and ACTIVITY_TRANSITION_EXIT transitions, then it receives an ActivityTransitionEvent object when the user starts driving, and another one when the user transitions to any other activity.

Your application will receive callbacks with extras containing an activity recognition result.This contains a list of activities that the user may be doing at the particular time.

5.Deregister for activity transition updates

Deregister for activity transition updates by calling the removeActivityTransitionUpdates() method of the ActivityRecognitionClient and passing your PendingIntent object as a parameter.


Download this project from GitHub



Nearby Connections API 2.0

House advertise the availability and rates of their driveways, So your phone could scan for them and query all of them and book the one that makes more sense for you in a completely offline fashion.Taking it one step further, if you are late getting back, why can’t these houses then query your car, which will tell them that you are just a block away, so I can avoid being penalized or towed.Because implementing these features entails dealing with the vagaries of Bluetooth and Wi-Fi across the product, the range of Android os version out there and the variety of hardware out there.What these apps back then needed was a reliable performance proximity platform that abstracts away all this complexity and leaves them free so they can focus on just adding the features that matter to their users.

Nearby Connections API

Nearby Connections enables advertising and discovery of nearby devices, as well as high-bandwidth low-latency encrypted data transfers between these devices in a fully-offline P2P manner.It achieves this by using a combination of classic Bluetooth, BLE, and Wi-Fi hotspots.It leverages the strengths of each while supplementing their respective weaknesses.For instance, Bluetooth has low connection latency but also provides low bandwidth Wi-Fi hotspots have slightly higher connection latency, but also provide much higher bandwidth. So what it does is connect over Bluetooth and start transferring data instantly but in the background, it also brings up a Wi-Fi hotspot and when that’s ready, it seamlessly transfers your connection from Bluetooth to WiFi with absolutely no work required by the app developer.

Nearby API Flow

Nearby API Flow

1.An advertiser calls startAdvertising(), and sometime later, a discover calls startDiscovery(). Soon enough, the discovery is alerted to the advertiser’s presence by means of the onEndpointFound() callback. If the discoverer is interested, they can call requestConnection().This is the end of the asymmetric part of the API and from here on everything is completely symmetric.

2.Both sides get an onConnectionInitiated() callback that gives them an authentication token they can use to verify they are indeed talking to each other.Upon out-of-band verification, they can both either call acceptConnection() or rejectConnection().When each side gets the other’s response, it invokes the ConnectionLifecycleCallback.onConnectionResult() callback.At this point, the connection is either established or it’s not.

3.From here, either side can send payload by calling the sendPayload()method.This leads to the other side getting the PayloadCallback.onPayloadReceived()callback, followed by both sides getting a series of PayloadCallback.onPayloadTransferUpdate() callbacks up until the transfer reaches the final state of success or failure.

4.Finally, either side can disconnect at any time, and that leads to the other side getting the ConnectionLifecycleCallback.onDisconnected() callback.


Nearby API support three kinds of payloads 1.Bytes, these are byte arrays of up to 32k, and they are typically used for sending metadata control messages.
2.Files, these represent files of the device’s storage and Nearby API make sure that it transfer from the application to the network interface with a minimal amount of copying across process boundaries.
3.Streams, this is good for when you need to generate data on the fly, and you don’t know the final size up front, as is the case with recorded audio or video.


As I mentioned earlier, Nearby API uses multiple radio techniques to advertise, discover, and establish connections.The combinations of interactions of these techniques are qualified in its strategies.Strategies are named for how far they’ll cause their net to try and find a nearby device and what kind of connection topology they will enable.Right now, it has two of them, P2P_STAR and P2P_CLUSTER.

Nearby API Strategies
As the name might suggest, P2P_STAR makes sense for when you want to enforce a star network with a 1-to-N connection topology.And P2P_CLUSTER make sense when you want to allow for slightly looser M-to-M connection topologies.For example, a classroom app where the teacher wants to host a quiz for all the students, that would probably be best mounted over P2P_STAR with the teacher as the one advertiser and the students at the end discovers and the same classroom app could have a mode that allows students to break out into ephemeral project groups.This mode,where students want to drift in and out of multiple groups,would be best served with P2P_CLUSTER.

Now let’s see how all this can be put together in an undoubtedly harmless mock application.

Get Started

Before you start to code using the Nearby Connections API:

Request Permissions

Before using Nearby Connections, your app must request the appropriate permissions for the Strategy you plan to use.

For example, in order to use the P2P_STAR Strategy, add the specified permissions to your AndroidManifest.xml:

Since ACCESS_COARSE_LOCATION is considered to be a dangerous system permission, in addition to adding it to your manifest, you must request the permission at runtime, as described in Requesting Permissions.

Advertise and Discover

Your app needs to begin to advertise and discover in order to find nearby devices.

1.On devices that will advertise, call startAdvertising() with the desired Strategy and a serviceIdparameter that identifies your app.

2.On devices that will discover nearby advertisers, call startDiscovery() with the same Strategy and serviceId.

The serviceId value must uniquely identify your app. As a best practice, use the package name of your app (for example, com.example.myapp).

The following example shows how to advertise:

The ConnectionLifecycleCallback parameter is the callback that will be invoked when discoverers request to connect to the advertiser.

The following example shows how to discover:

Call stopAdvertising() when you no longer need to advertise.

CallstopDiscovery() when you no longer need to discover.

Initiate a connection

When nearby devices are found, the discoverer can initiate connections. The following example shows initiating a connection with a discovered device.

Depending on your use case, you may wish to instead display a list of discovered devices to the user, allowing them to choose which devices to connect to.

Accept or reject a connection

After the discoverer has requested a connection to an advertiser, both sides are notified of the connection initiation process via the onConnectionInitiated() method of the ConnectionLifecycleCallbackcallback. Note that this callback is passed in to startAdvertising() on the advertiser and requestConnection() on the discoverer, but from this point forward, the API is symmetric.

Now both sides must choose whether to accept or reject the connection via a call to acceptConnection()or rejectConnection(), respectively. The connection is fully established only when both sides have accepted. If one or both reject, the connection is discarded. Either way, the result is delivered toonConnectionResult().

The following code snippet shows how to implement this callback:

Exchange Data

Once connections are established between devices, you can exchange data by sending and receiving Payload objects. A Payload can represent a simple byte array, such as a short text message; a file, such as a photo or video; or a stream, such as the audio stream from the device’s microphone.

Payloads of the same type are guaranteed to arrive in the order they were sent, but there is no guarantee of preserving the ordering amongst payloads of different types. For example, if a sender sends a FILE payload followed by a BYTE payload, the receiver could get the BYTE payload first, followed by the FILE payload.

Send and Receive

To send payloads to a connected endpoint, call sendPayload().To receive payloads, implement the onPayloadReceived() method of the PayloadCallback that was passed to acceptConnection().


Here are the slightly less bone-chilling uses of nearby Connections spotted in the wild.

The Weather channel is using Nearby Connections to build a pretty darn cool offline mesh to help spread urgent weather updates and warnings, especially in the wake of natural disasters.


Sendanywhere is a South Korean app that allows sharing files intelligently in the most efficient manner possible, regardless of whether you’re online or not.They’re using Nearby Connections for their offline modality.


Pocket Casts have been a great partner for Nearby Messages.They now want to enable people sharing and discovering podcasts in a completely offline manner. For example, when you’re stuck in an aircraft and are looking to cloud so what’s your options for entertainment?

GameInsight is a leading game developer, and they’re using Nearby Connections to not only find nearby players but also to run their games completely offline. Again, being stuck in the inside of an aircraft comes to mind.


Hotstar is India’s fastest growing streaming network.They’re using nearby connections to allow offline sharing of downloaded movies and TV shows.So you don’t need to have access to the internet.You only need access to friend who does.


Android TV is about to launch a new remote control app where they use Nearby Connections to not only set up your new Android TV and configure it to be on your Wi-Fi network, but also to serve interactive second stream content in a streaming fashion.


Related Post

Bluetooth Low Energy



Bluetooth Low Energy

BLE is wireless technology.It gives context to the environment around you.It perfect for devices that run for long periods on power sources, such as coin cell batteries.

Key Benefit

  • low power consumption.
  • small size.
  • connectivity to mobile phones.
  • low cost,robust,efficient.
  • multi-vendor interoperability.
  • global availability, license free.


BLE device remains in sleep mode constantly except for when a connection is initiated. The actual connection times are only a few ms, while Bluetooth takes ~100ms. The reason the connections are short is that the data rates are high at 1 Mb/s.

  • keeping the radio off.
  • Lower standby time, Faster connection, Lower peak power.
  • BLE technology uses only 3 advertising channels.

Bluetooth Low Energy example

In the example, the Android app running on an Android device is the GATT client. The app gets data from the GATT server, which is a BLE Battery Level Detector that supports the Battery Level Service.

BLE Permissions

You need BLUETOOTH permission to perform requesting a connection, accepting a connection, and transferring data.You must also declare the BLUETOOTH_ADMIN permission for device discovery or manipulate Bluetooth settings.

Android 6.0+ (API level 23+), users grant permissions to apps while the app is running, not when they install the app.

Get the BluetoothAdapter

The BluetoothAdapter represents the device’s Bluetooth adapter.There’s one Bluetooth adapter for the entire system, and your application can interact with it using this object.

Enable Bluetooth

If Bluetooth but disabled, then you can request that the user enable Bluetooth without leaving your application.

Scan BLE Devices

To scan BLE devices, you use the startScan() method.Scanning is battery-intensive, you should observe the following guidelines:

  • After finding the desired device, stop scanning.
  • Set a time limit on your scan. A device that was previously available may have moved out of range, and continuing to scan drains the battery.

startScan() method takes a ScanCallback as a parameter. You must implement this callback for results are returned.

The following snippet shows how to start and stop a scan

In this example, app provides an activity BluetoothDetectorActivity to connect and display data and display GATT services and characteristics supported by the device.

Ble Client
Battery Level Detector

Connecting to a GATT Server(BLE Device)

Based on user input, Activity communicates with a Service called BluetoothLEService, which interacts with the BLE device via the Android BLE API

BluetoothGattCallback: Used to deliver results to the client, such as connection status, as well as any further GATT client operations. 

The first step in interacting with a BLE device is connecting to the GATT server on the device. To connect to a GATT server on a BLE device, you use the connectGatt() method.

When a particular callback is triggered, it calls the broadcastUpdate() helper method and passes it an action. Data parsing in this section is performed in accordance with the Bluetooth Battery Service Measurement profile specifications

To enable or disable notifications for a given characteristic setCharacteristicNotification to
BluetoothGatt.Reads the requested characteristic from the associated remote device set

In BatteryDetectorActivity, these events are handled by a BroadcastReceiver.

The Following snippet show display Gatt connected service

Connect Bluetooth service

Closing the Client App

Once your app has finished using a BLE device, it should call close() so the app can release resources appropriately.

How to test BLE Client?

The BLE Peripheral Simulator is an Android app that allows developers to try out new features of app Bluetooth without the need for a BLE Peripheral Device.

BLE Peripheral with one of three services:

  • Battery Service
  • Heart Rate Service
  • Health Thermometer Service

Use the  Bluetooth features to connect to the app to Read and Write Characteristics, Subscribe to Notifications for when the Characteristics change, and Read and Write Descriptors.

The device in the central role scans, looking for advertisement of Battery Level Detector.

The device in the peripheral role makes the advertisement of Battery Level.

Download this project from GitHub.



Android MQTT Client

MQTT is a machine-to-machine /Internet of Things connectivity protocol. It’s designed to following use case.

  1. Lightweight publish-subscribe based messaging protocol for use on top of the TCP/IP protocol.
  2. Connections to remote locations where a small code is required or the network bandwidth are limited.

MQTT Broker

The publish-subscribe messaging pattern requires a message broker. The broker is responsible for distributing messages to interested clients based on the topic of a message.It also holds the session of all persisted clients including subscriptions and missed messages.

There is a publically accessible sandbox server for the Eclipse IoT projects available at

MQTT Client

Eclipse Paho project provides open-source client implementations of MQTT.Paho Android Service is an MQTT client library written in Java for developing applications on Android.

The MQTT connection is encapsulated within an Android Service that runs in the background of the Android application, keeping it alive when the Android application is switching between different Activities.The Paho Android Service is an interface to the Paho Java MQTT Client library for the Android Platform.


Download  Paho Android Service and Android MQTT Client library.Go to your libs folder inside app folder and paste all your .jar

To add the Paho Android Service as a dependency to you app add the following parts to your gradle file.


The Paho Android Service needs the following permissions to work.

To be able to create a binding to the Paho Android Service, the service needs to be declared in the AndroidManifest.xml. Add the following within the <application> tag

MQTT Connection Option

MqttAndroidClient will connect with MQTT 3.1.1 by default. To intentionally connect with MQTT 3.1  MqttConnectOptions object can be supplied to the connect method

Clean session

On connection, a client sets the “clean session” flag.If the clean session is set to false, means when the client disconnects, any subscriptions it has will remain and any subsequent QoS 1 or 2 messages will be stored until it connects again in the future. If the clean session is true, then all subscriptions will be removed from the client when it disconnects.

Automatic Reconnect

Sets whether the client will automatically attempt to reconnect to the server if the connection is lost.It will initially wait 1 second before it attempts to reconnect, for every failed to reconnect attempt, the delay will double until it is at 2 minutes at which point the delay will stay at 2 minutes.


When a client connects to a broker, it may inform the broker that it has a will. This is a message that it wishes the broker to send when the client disconnects unexpectedly. The will message has a topic, QoS and retains status just the same as any other message.

Receive MQTT Message

Disconnect Options

Messages published to the topic if the connection is available, but if it disconnects and connects again offline messages send.Holds the set of options that govern the behavior of Offline (or Disconnected) buffering of messages.

Create MQTT Client

Creates an instance of an Android MQTT client, that will bind to the Paho Android Service. By calling the connect method of the MqttAndroidClient the client will asynchronously try to connect to the MQTT broker and return a token. That token can be used to register callbacks, to get notified when either the MQTT-connection gets connected or an error occurs

Publish Message

The MqttAndroidClient allows messages to be published via its publish method.


Subscriptions can be created via the MqttAndroidClient.subscribe method, which takes the topic and the QOS as parameters and returns a IMqttToken.


Disconnect MQTT Client

Download this project from GitHub.


MQTTBox enables you to create MQTT clients to publish or subscript topics, create MQTT virtual device networks, load test MQTT devices or brokers.

Config MQTT Client

1.Create MQTT client

2.Config MQTT client

Host :

Protocol : mqtt/tcp

MQTT Protocol