bluetooth

This file will teach you about connecting mobile's bluetooth and arduino or to other devices

https://developer.android.com/develop/connectivity/bluetooth
Refer the above for complete documentation 

My purpose is to build an app to communicate with arduino

1)A discovery process happens and both devices exchange security keys and after pairing and bonding both start exchanging information

2)Using bluetooth's api 

*permissions 

-------------------------------------------------------------------------------------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

for android 12 or higher (my phone 9 only)

declare bluetooth_scan -> for scanning
        bluetooth_advertise -> makes your phone discoverable     . these are runtime permissions and should get from user
        bluetooth_connect -> if communicates with already paired bluetooth devices

also set max_sdkVersion = 30 , so that this applies only for android 12 and higher


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

for android 11 or lower

declare bluetooth_admin -> only for discovering bt devices
        bluetooth        ->enough for all communications

also declare uses-feature android.hardware.bluetooth and required = true

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

------------------------------------------------------------------------------------------------------------------------------------------------------

*checking and getting bluetoothadapter and then do 1)find devices 2)connect to a device 3)transfer data with connected device

*bluetooth api's in android.bluetooth package



3) Now let us start :

  1)get bluetooth adapter:

first get bluetooth adapter . bluetooth adapter is required for all bluetooth functions and represents the device's bluetooth radio or adapter .
get it from bluetoothmanager systemservice's refernce and then create a bluetooth adapter object

code:
<<<<<<<<<<<<<

val bluetoothManager: BluetoothManager = getSystemService(BluetoothManager::class.java)
val bluetoothAdapter: BluetoothAdapter? = bluetoothManager.getAdapter()
if (bluetoothAdapter == null) {
  // Device doesn't support Bluetooth
}


>>>>>>>>>>>>>>>>>>

  2)enable bluetooth

code:
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

if (bluetoothAdapter?.isEnabled == false) {
            val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
            startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT)
        }
else{
    Toast.makeText(this, "bluetooth is on", Toast.LENGTH_SHORT).show()
}

private val REQUEST_ENABLE_BT = 1

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == REQUEST_ENABLE_BT) {
            if (resultCode == RESULT_OK) {
                // User enabled Bluetooth
                Toast.makeText(this, "bluetooth enabled ok", Toast.LENGTH_SHORT).show()
            }
            if(resultCode== RESULT_CANCELED){
                // User declined to enable Bluetooth
                Toast.makeText(this, "bluetooth why not enable", Toast.LENGTH_SHORT).show()
                finish()
            }
        }
    }


//all in the main activity



>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.


        3)Finding Bluetooth devices and discoverability

discoverable devices tells about user location .
pairing -> means two devices are aware of each other and then have a shared key
connected -> devices has RFCOMM channel and then use it to communicate

to see all paired devies use getBondedDevices . 

Code : 
<<<<<<<<<<<<<<<<<<<<

val pairedDevices: Set<BluetoothDevice>? = bluetoothAdapter?.bondedDevices
        pairedDevices?.forEach { device ->
            val deviceName = device.name
            val deviceHardwareAddress = device.address

>>>>>>>>>>>>>>>>>>>

Separate code exists to make your own mobile discoverable


        4)Making a connection

To make a connection should put both sides sockets . Each obtain bluetoothsocket in different ways

The server and client are considered connected to each other when they each have a 
connected BluetoothSocket on the same RFCOMM channel

One should act as server socket
UUID is like cryptography . connection happens when client also sends request with same uuid

here arduino gives well known uuid

private val NAME = "HC-05"
private val KNOWN_SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");

-----------------------------------

we assume , that the arduino is the server. and we try to communicate as client
we create a socket and then connect and get outputstream and write data to it

code:

<<<<<<<<<<<<<<<<<<<<<<<<<<<

fun connectbtdevice(bluetoothAdapter: BluetoothAdapter?){
        val device: BluetoothDevice = bluetoothAdapter!!.getRemoteDevice("58:56:00:00:F3:A1")   //tells bluetooth adapter not null at this pt .address is of HC-05
        try {
            Log.d("try","yes rfcomm proces started")
            bluetoothSocket = device!!.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"))
            bluetoothSocket.connect()
            Log.d("try","yes rfcomm connection done")
            outputStream = bluetoothSocket.outputStream
            outputStream.write("k".toByteArray())
        } catch (e: IOException) {
            Log.d("try","rf comm failed exception $e")   //here socket closed is the problem
            // Handle connection error
            return
        }
    }

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

---------------------------------


FULL CODE:






package com.example.bluetooth_app

import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothManager
import android.bluetooth.BluetoothSocket
import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import java.io.IOException
import java.io.OutputStream
import java.util.UUID

class MainActivity : AppCompatActivity() {

    private val REQUEST_ENABLE_BT = 1
    private lateinit var bluetoothSocket: BluetoothSocket
    private lateinit var outputStream: OutputStream

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == REQUEST_ENABLE_BT) {
            if (resultCode == RESULT_OK) {
                // User enabled Bluetooth
                Toast.makeText(this, "bluetooth enabled ok", Toast.LENGTH_SHORT).show()
            }
            if(resultCode== RESULT_CANCELED){
                // User declined to enable Bluetooth
                Toast.makeText(this, "bluetooth why not enable", Toast.LENGTH_SHORT).show()
                finish()
            }
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //getting bluetooth adapter
        val btadapter : BluetoothAdapter? = getbluetoothadapter()
        if(btadapter==null){
            finish()    //finish the current activity
        }

        //enabling bluetooth
        enablebluetooth(btadapter)

        getalreadypairedbluetoothdevices(btadapter)

        connectbtdevice(btadapter)



    }

    fun getbluetoothadapter() : BluetoothAdapter?{
        val bluetoothManager: BluetoothManager = getSystemService(BluetoothManager::class.java)
        val bluetoothAdapter: BluetoothAdapter? = bluetoothManager.getAdapter()
        if (bluetoothAdapter == null) {
            // Device doesn't support Bluetooth
            Toast.makeText(this, "no bluetoth", Toast.LENGTH_SHORT).show()

        }
        else{
            Toast.makeText(this, "bluetooth compatible device", Toast.LENGTH_LONG).show()
        }
        return bluetoothAdapter


    }

    fun enablebluetooth(bluetoothAdapter:BluetoothAdapter?){
        if (bluetoothAdapter?.isEnabled == false) {
            val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
            startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT)
        }
        else{
            Toast.makeText(this, "bluetooth is on", Toast.LENGTH_SHORT).show()

        }
    }

    fun getalreadypairedbluetoothdevices(bluetoothAdapter: BluetoothAdapter?){
        Log.d("working","till here")
        val pairedDevices: Set<BluetoothDevice>? = bluetoothAdapter?.bondedDevices
        pairedDevices?.forEach { device ->
            val deviceName = device.name
            val deviceHardwareAddress = device.address // MAC address

            Log.d("success","name = $deviceName")
            Log.d("success","add = $deviceHardwareAddress")
        }
    }

    fun connectbtdevice(bluetoothAdapter: BluetoothAdapter?){
        val device: BluetoothDevice = bluetoothAdapter!!.getRemoteDevice("58:56:00:00:F3:A1")   //tells bluetooth adapter not null at this pt
        try {
            Log.d("try","yes rfcomm proces started")
            bluetoothSocket = device!!.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"))
            bluetoothSocket.connect()
            Log.d("try","yes rfcomm connection done")
            outputStream = bluetoothSocket.outputStream
            outputStream.write("k".toByteArray())
        } catch (e: IOException) {
            Log.d("try","rf comm failed exception $e")   //here socket closed is the problem
            // Handle connection error
            return
        }
    }

}