package com.thomaskuenneth.androidbuch.bluetoothscannerdemo
 
import android.Manifest.permission.ACCESS_FINE_LOCATION
import android.app.Activity
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.content.*
import android.content.pm.PackageManager.PERMISSION_GRANTED
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
 
private const val REQUEST_ENABLE_BLUETOOTH = 123
private const val REQUEST_FINE_LOCATION = 321
 
private enum class BluetoothState {
  NotAvailable, Disabled, Enabled
}
 
class BluetoothScannerDemoActivity : AppCompatActivity() {
  private val adapter = BluetoothAdapter.getDefaultAdapter()
  private val receiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent) {
      if (BluetoothDevice.ACTION_FOUND == intent.action) {
        val device = intent.getParcelableExtra<BluetoothDevice>(
              BluetoothDevice.EXTRA_DEVICE)
        tv.append(getString(R.string.template,
            device?.name,
            device?.address))
      }
    }
  }
 
  private var started = false
 
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val filter = IntentFilter(BluetoothDevice.ACTION_FOUND)
    registerReceiver(receiver, filter)
  }
 
  override fun onDestroy() {
    super.onDestroy()
    unregisterReceiver(receiver)
  }
 
  override fun onStart() {
    super.onStart()
    started = false
    if (getBluetoothState() == BluetoothState.NotAvailable) {
      tv.text = getString(R.string.not_available)
    } else {
      if (checkSelfPermission(ACCESS_FINE_LOCATION) !=
          PERMISSION_GRANTED) {
      requestPermissions(arrayOf(ACCESS_FINE_LOCATION),
                           REQUEST_FINE_LOCATION)
      } else {
        showDevices()
      }
    }
  }
 
  override fun onPause() {
    super.onPause()
    if (started) {
      adapter?.cancelDiscovery()
      started = false
    }
  }
 
  override fun onRequestPermissionsResult(requestCode: Int,
                      permissions: Array<String?>,
                      grantResults: IntArray) {
    if (requestCode == REQUEST_FINE_LOCATION &&
        grantResults.isNotEmpty() &&
        grantResults[0] == PERMISSION_GRANTED) {
      showDevices()
    }
  }
 
  override fun onActivityResult(requestCode: Int, resultCode: Int,
                                data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (resultCode == Activity.RESULT_OK &&
        requestCode == REQUEST_ENABLE_BLUETOOTH) {
      showDevices()
    }
  }
 
  private fun getBluetoothState(): BluetoothState {
    val state = if (adapter != null) {
      if (adapter.isEnabled) {
        BluetoothState.Enabled
      } else {
        BluetoothState.Disabled
      }
    } else {
      BluetoothState.NotAvailable
    }
    if (state == BluetoothState.Disabled) {
      val enableBtIntent =
              Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
      startActivityForResult(enableBtIntent,
                             REQUEST_ENABLE_BLUETOOTH)
    }
    return state
  }
 
  private fun showDevices() {
    val sb = StringBuilder()
    sb.append(getString(R.string.paired))
    adapter?.bondedDevices?.forEach {
      sb.append(getString(R.string.template,
          it.name,
          it.address))
    }
    sb.append("\n")
    if (started) {
      adapter?.cancelDiscovery()
    }
    started = adapter?.startDiscovery() ?: false
    if (started) {
      sb.append(getString(R.string.others))
    }
    tv.text = sb.toString()
  }
}

package com.thomaskuenneth.androidbuch.bluetoothchatdemo
 
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothServerSocket
import android.bluetooth.BluetoothSocket
import android.util.Log
import java.io.IOException
import java.util.*
 
private val TAG = ServerSocketThread::class.simpleName
class ServerSocketThread(
  adapter: BluetoothAdapter,
  serviceName: String?,
  uuid: UUID
) : SocketThread() {
 
  private var serverSocket: BluetoothServerSocket? = null
  private var socket: BluetoothSocket? = null
 
  init {
    name = TAG!!
    try {
      serverSocket = adapter.listenUsingRfcommWithServiceRecord(
        serviceName, uuid)
    } catch (e: IOException) {
      Log.e(TAG, "listenUsingRfcommWithServiceRecord() failed", e)
    }
  }
 
  override fun run() {
    var keepRunning = true
    while (keepRunning) {
      try {
        serverSocket?.accept().run {
          closeServerSocket()
          keepRunning = false
        }
      } catch (e: IOException) {
        Log.e(TAG, "accept() failed", e)
        keepRunning = false
      }
    }
  }
 
  override fun getSocket(): BluetoothSocket? {
    return socket
  }
 
  override fun cancel() {
    closeServerSocket()
    socket?.use {
      socket?.close()
    }
    socket = null
  }
 
  private fun closeServerSocket() {
    serverSocket?.use {
      serverSocket?.close()
    }
    serverSocket = null
  }
}

package com.thomaskuenneth.androidbuch.bluetoothchatdemo
 
import android.bluetooth.BluetoothSocket
 
abstract class SocketThread : Thread() {
    abstract fun getSocket(): BluetoothSocket?
    abstract fun cancel()
}

package com.thomaskuenneth.androidbuch.bluetoothchatdemo
 
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothSocket
import android.util.Log
import java.io.IOException
import java.util.*
 
private val TAG = ClientSocketThread::class.simpleName
class ClientSocketThread(device: BluetoothDevice, uuid: UUID) :
  SocketThread() {
 
  private var socket: BluetoothSocket? = null
 
  init {
    name = TAG!!
    try {
      socket = device.createRfcommSocketToServiceRecord(uuid)
    } catch (e: IOException) {
      Log.e(TAG, "createRfcommSocketToServiceRecord() failed", e)
    }
  }
 
  override fun run() {
    try {
      socket?.connect()
    } catch (connectException: IOException) {
      cancel()
    }
  }
 
  override fun getSocket(): BluetoothSocket? {
    return socket
  }
 
  override fun cancel() {
    socket?.use {
      socket?.close()
    }
    socket = null
  }
}

package com.thomaskuenneth.androidbuch.bluetoothchatdemo
 
import android.Manifest
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.content.pm.PackageManager
import android.os.Bundle
import android.util.Log
import android.view.KeyEvent
import android.widget.*
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
import java.io.*
import java.util.*
import kotlin.concurrent.thread
 
private const val DEVICE1 = "..."
private const val DEVICE2 = "..."
private const val REQUEST_FINE_LOCATION = 321
private val MY_UUID = UUID.fromString("dc4f9aa6-ce43-4709-bd2e-7845a3e705f1")
private val TAG = BluetoothChatDemoActivity::class.simpleName
class BluetoothChatDemoActivity : AppCompatActivity() {
  private val adapter = BluetoothAdapter.getDefaultAdapter()
 
  private var serverThread: Thread? = null
  private var clientThread: Thread? = null
 
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    input.isEnabled = false
  }
 
  override fun onStart() {
    super.onStart()
    if (checkSelfPermission(
        Manifest.permission.ACCESS_FINE_LOCATION) !=
      PackageManager.PERMISSION_GRANTED
    ) {
      requestPermissions(
        arrayOf(Manifest.permission.ACCESS_FINE_LOCATION),
        REQUEST_FINE_LOCATION
      )
    } else {
      startOrFinish()
    }
  }
 
  override fun onPause() {
    super.onPause()
    serverThread?.interrupt()
    serverThread = null
    clientThread?.interrupt()
    clientThread = null
  }
 
  override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<String?>,
    grantResults: IntArray
  ) {
    if (requestCode == REQUEST_FINE_LOCATION &&
      grantResults.isNotEmpty() &&
      grantResults[0] == PackageManager.PERMISSION_GRANTED
    ) {
      startOrFinish()
    }
  }
 
  private fun startOrFinish() {
    if (isBluetoothEnabled()) {
      connect()
    } else {
      finish()
    }
  }
 
  private fun isBluetoothEnabled(): Boolean {
    val enabled = adapter?.isEnabled ?: false
    if (!enabled) {
      Toast.makeText(this, R.string.enable_bluetooth,
                     Toast.LENGTH_LONG).show()
    }
    return enabled
  }
 
  private fun connect() {
    val myName = adapter?.name
    val otherName = if (DEVICE1 == myName) DEVICE2 else DEVICE1
    for (device in adapter?.bondedDevices ?:
                       emptyList<BluetoothDevice>()) {
      if (otherName == device.name) {
        val serverSocketThread = ServerSocketThread(adapter, TAG, MY_UUID)
        serverThread = createAndStartThread(serverSocketThread)
        val clientSocketThread = ClientSocketThread(device, MY_UUID)
        clientThread = createAndStartThread(clientSocketThread)
        input.isEnabled = true
        break
      }
    }
  }
 
  private fun createAndStartThread(t: SocketThread): Thread
          = thread {
    var keepRunning = true
    try {
      t.start()
      Log.d(TAG, "joining " + t.name)
      t.join()
      t.getSocket()?.run {
        Log.d(TAG, String.format("connection type %d for %s",
            connectionType, t.name)
        )
        input.setOnEditorActionListener { _: TextView?, _: Int,
                                          _: KeyEvent? ->
          send(outputStream, input.text.toString())
          runOnUiThread { input.setText("") }
          true
        }
        while (keepRunning) {
          receive(inputStream)?.let {
            runOnUiThread { output?.append(it) }
          }
        }
      }
    } catch (thr: Throwable) { // InterruptedException, IOException
      Log.e(TAG, thr.message, thr)
      keepRunning = false
    } finally {
      Log.d(TAG, "calling cancel() of " + t.name)
      t.cancel()
    }
  }
 
  private fun send(stream: OutputStream, text: String) {
    stream.use {
      stream.write(text.toByteArray())
    }
  }
 
  private fun receive(stream: InputStream): String? {
    stream.use {
      val num = stream.available()
      if (num > 0) {
        val buffer = ByteArray(num)
        var bytesToRead = num
        while (bytesToRead > 0) {
          val read = stream.read(buffer, num - bytesToRead, bytesToRead)
          if (read == -1) {
            break
          }
          bytesToRead -= read
        }
        return String(buffer)
      }
    }
    return null
  }
}

<uses-feature android:name="android.hardware.bluetooth_le" 
              android:required="true"/>

package com.thomaskuenneth.androidbuch.blescannerdemo
 
import android.Manifest.permission.ACCESS_FINE_LOCATION
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothGatt
import android.bluetooth.BluetoothGattCallback
import android.bluetooth.BluetoothManager
import android.bluetooth.le.ScanCallback
import android.bluetooth.le.ScanResult
import android.content.pm.PackageManager.PERMISSION_GRANTED
import android.os.Bundle
import android.util.Log
import android.widget.*
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
 
private const val REQUEST_FINE_LOCATION = 321
private val TAG = BLEScannerDemoActivity::class.simpleName
class BLEScannerDemoActivity : AppCompatActivity() {
 
  private val scanCallback = object : ScanCallback() {
    override fun onScanFailed(errorCode: Int) {
      Toast.makeText(this@BLEScannerDemoActivity,
          getString(R.string.error, errorCode), Toast.LENGTH_LONG).show()
    }
 
    override fun onScanResult(callbackType: Int, 
                              result: ScanResult?) {
      updateData(result)
    }
 
    override fun onBatchScanResults(results: List<ScanResult?>) {
      for (result in results) {
        updateData(result)
      }
    }
  }
 
  private val gattCallback = object : BluetoothGattCallback() {
    override fun onServicesDiscovered(gatt: BluetoothGatt,
                                      status: Int) {
      if (status == BluetoothGatt.GATT_SUCCESS) {
        logGattServices(gatt)
      } else {
        Log.d(TAG, "onServicesDiscovered: $status")
      }
      gatt.close()
    }
 
    override fun onConnectionStateChange(gatt: BluetoothGatt,
                       status: Int, newState: Int) {
      Log.d(TAG, "Status der Verbindung: $newState")
    }
  }
 
  private lateinit var listAdapter: ArrayAdapter<String>
  private val scanResults = HashMap<String?, ScanResult?>()
  private var adapter: BluetoothAdapter? = null
 
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    listAdapter = ArrayAdapter(this,
        android.R.layout.simple_list_item_1)
    lv.adapter = listAdapter
    lv.setOnItemClickListener { _, _, pos, _ ->
      val address = listAdapter.getItem(pos)
      val result = scanResults[address]
      info(result)
    }
  }
 
  override fun onStart() {
    super.onStart()
    adapter = null
    listAdapter.clear()
    scanResults.clear()
    tv.text = ""
    if (checkSelfPermission(ACCESS_FINE_LOCATION) !=
            PERMISSION_GRANTED) {
      requestPermissions(arrayOf(ACCESS_FINE_LOCATION),
          REQUEST_FINE_LOCATION)
    } else {
      startOrFinish()
    }
  }
 
  override fun onPause() {
    super.onPause()
    if (adapter != null) {
      scan(false)
    }
  }
 
  override fun onRequestPermissionsResult(requestCode: Int,
                      permissions: Array<String?>,
                      grantResults: IntArray) {
    if (requestCode == REQUEST_FINE_LOCATION &&
        grantResults.isNotEmpty() &&
        grantResults[0] == PERMISSION_GRANTED) {
      startOrFinish()
    } else {
      finish()
    }
  }
 
  private fun startOrFinish() {
    if (isBluetoothEnabled()) {
      scan(true)
    } else {
      finish()
    }
  }
 
  private fun isBluetoothEnabled(): Boolean {
    adapter = null
    var enabled = false
    getSystemService(BluetoothManager::class.java)?.let {
      adapter = it.adapter
      enabled = adapter?.isEnabled ?: false
    }
    if (!enabled) {
      Toast.makeText(this, R.string.enable_bluetooth, Toast.LENGTH_LONG)
          .show()
    }
    return enabled
  }
 
  private fun scan(enable: Boolean) {
    val scanner = adapter?.bluetoothLeScanner
    if (enable) {
      scanner?.startScan(scanCallback)
    } else {
      scanner?.stopScan(scanCallback)
    }
  }
 
  private fun updateData(result: ScanResult?) {
    result?.device?.address.let {
      if (!scanResults.containsKey(it)) {
        listAdapter.add(it)
        listAdapter.notifyDataSetChanged()
      }
      scanResults.put(it, result)
    }
  }
 
  private fun info(result: ScanResult?) {
    tv.text = result?.toString()
    val device = result?.device
    val gatt = device?.connectGatt(this,
        true, gattCallback)
    val started = gatt?.discoverServices()
    Log.d(TAG, "discoverServices(): $started")
  }
 
  private fun logGattServices(gatt: BluetoothGatt) {
    gatt.services.forEach {
      Log.d(TAG, "Service " + it.uuid.toString())
    }
  }
}