<!-- Required for discovery and connection -->
<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />

<!-- Required for device discovery -->
<!-- For better location results, use FINE. COARSE is the minimum. -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<!-- Required to scan for nearby devices -->
<uses-permission android:name="android.permission.BLUETOOTH_SCAN" />

<!-- Required to connect to paired devices -->
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

<!-- Required to make the device discoverable (act as a server) -->
<uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />

import android.bluetooth.BluetoothManager
import android.content.Context

// Get the BluetoothManager
val bluetoothManager: BluetoothManager = getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager

// Get the BluetoothAdapter
val bluetoothAdapter: BluetoothAdapter? = bluetoothManager.adapter

if (bluetoothAdapter == null) {
    // Device doesn't support Bluetooth
    // Handle this case appropriately
}

// Check if Bluetooth is enabled
if (bluetoothAdapter?.isEnabled == false) {
    // Bluetooth is not enabled, request to enable it
    val enableBtIntent = Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE)
    
    // Use the ActivityResultLauncher for a modern approach
    // Requires BLUETOOTH_CONNECT permission on API 31+
    startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT)
}

// Requires BLUETOOTH_CONNECT permission on API 31+
val pairedDevices: Set<BluetoothDevice>? = bluetoothAdapter?.bondedDevices

if (pairedDevices?.isNotEmpty() == true) {
    Log.d("PairedDevices", "Found ${pairedDevices.size} paired devices.")
    pairedDevices.forEach { device ->
        val deviceName = device.name
        val deviceHardwareAddress = device.address // MAC address
        Log.d("PairedDevices", "Device: $deviceName, Address: $deviceHardwareAddress")
    }
} else {
    Log.d("PairedDevices", "No paired devices found.")
}

private val receiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        when(intent.action) {
            BluetoothDevice.ACTION_FOUND -> {
                // A new device was found
                val device: BluetoothDevice? =
                    intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
                
                device?.let {
                    // Requires BLUETOOTH_CONNECT permission for device.name
                    val deviceName = it.name ?: "Unknown Device"
                    val deviceAddress = it.address
                    Log.d("Discovery", "Found device: $deviceName at $deviceAddress")
                    // Add the device to a list/adapter
                }
            }
            BluetoothAdapter.ACTION_DISCOVERY_FINISHED -> {
                // Discovery has finished
                Log.d("Discovery", "Discovery finished.")
            }
        }
    }
}

// In your Activity or Fragment's onResume or onCreate
val filter = IntentFilter(BluetoothDevice.ACTION_FOUND)
filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)
registerReceiver(receiver, filter)

// In your onPause or onDestroy, ALWAYS unregister the receiver
override fun onDestroy() {
    super.onDestroy()
    unregisterReceiver(receiver)
}

// To start discovery (requires BLUETOOTH_SCAN permission on API 31+)
if (bluetoothAdapter.isDiscovering) {
    bluetoothAdapter.cancelDiscovery() // Cancel any ongoing discovery
}
bluetoothAdapter.startDiscovery()
Log.d("Discovery", "Starting discovery...")

// To stop discovery
// You should always call this as soon as you have found the device you need
bluetoothAdapter.cancelDiscovery()

<!-- Allows the app to request companion device associations -->
<uses-permission android:name="android.permission.REQUEST_COMPANION_PROFILE_WATCH" />

<!-- Optional: Allows the app to run in the background when the companion device is nearby -->
<uses-permission android:name="android.permission.REQUEST_COMPANION_RUN_IN_BACKGROUND" />

<!-- Optional: Allows the app to use data in the background -->
<uses-permission android:name="android.permission.REQUEST_COMPANION_USE_DATA_IN_BACKGROUND" />

val deviceManager: CompanionDeviceManager by lazy {
    getSystemService(Context.COMPANION_DEVICE_SERVICE) as CompanionDeviceManager
}

// Example filter for Wi-Fi devices with a specific SSID prefix
val wifiDeviceFilter = WifiDeviceFilter.Builder()
    .setNamePattern(Pattern.compile("SmartBulb-.*")) // Regex for SSID
    .build()

// You can also filter by Bluetooth devices
val btDeviceFilter = BluetoothDeviceFilter.Builder()
    .setNamePattern(Pattern.compile("MySmartWatch.*"))
    .build()

// Create the association request
val associationRequest = AssociationRequest.Builder()
    // Add one or more filters. The system will search for devices matching any filter.
    .addDeviceFilter(wifiDeviceFilter)
    .addDeviceFilter(btDeviceFilter)
    // Set whether this is a single-device association
    .setSingleDevice(true)
    .build()

// Modern approach using ActivityResultLauncher
private val associationResultLauncher = 
    registerForActivityResult(ActivityResultContracts.StartIntentSenderForResult()) { result ->
    if (result.resultCode == Activity.RESULT_OK) {
        val device: ScanResult? = result.data?.getParcelableExtra(CompanionDeviceManager.EXTRA_DEVICE)
        device?.let {
            // Association successful! The system has paired with the device.
            // You can now proceed to connect and configure it.
            // The MAC address of the device is stored in deviceManager.associations
            val macAddress = device.macAddress
            Log.d("CompanionPairing", "Successfully associated with ${macAddress}")
            // Now you can use WifiManager or other APIs to connect to it.
        }
    } else {
        // Association failed or was cancelled by the user.
        Log.e("CompanionPairing", "Association failed.")
    }
}

// Function to start the association
private fun startAssociation() {
    deviceManager.associate(
        associationRequest,
        object : CompanionDeviceManager.Callback() {
            // Called when a suitable device is found and the confirmation UI is shown to the user.
            override fun onDeviceFound(chooserLauncher: IntentSender) {
                try {
                    val intentSenderRequest = IntentSenderRequest.Builder(chooserLauncher).build()
                    associationResultLauncher.launch(intentSenderRequest)
                } catch (e: IntentSender.SendIntentException) {
                    Log.e("CompanionPairing", "Failed to launch chooser", e)
                }
            }

            // Called when the association fails.
            override fun onFailure(error: CharSequence?) {
                Log.e("CompanionPairing", "Association failed: $error")
            }
        },
        null // Handler (optional)
    )
}

private lateinit var sensorManager: SensorManager
private var lightSensor: Sensor? = null

// In onCreate() or a similar setup method
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)

if (lightSensor == null) {
    // Device does not have a light sensor. Handle this.
    Toast.makeText(this, "Light sensor not available!", Toast.LENGTH_SHORT).show()
}

class MySensorActivity : AppCompatActivity(), SensorEventListener {
    
    // ... setup code from Step 1 ...

    override fun onSensorChanged(event: SensorEvent?) {
        // This method is called when sensor values have changed.
        if (event?.sensor?.type == Sensor.TYPE_LIGHT) {
            val lightValue = event.values[0]
            // The light sensor provides a single value in lux.
            Log.d("Sensor", "Light level: $lightValue lux")
            // Update UI or perform logic here
        }
    }

    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
        // Called when the accuracy of a sensor has changed.
        // You might want to log this or notify the user.
        Log.d("Sensor", "Accuracy for ${sensor?.name} changed to: $accuracy")
    }
    
    // ... lifecycle methods from Step 3 ...
}

override fun onResume() {
    super.onResume()
    // Register the listener when the activity is resumed.
    lightSensor?.let {
        sensorManager.registerListener(this, it, SensorManager.SENSOR_DELAY_NORMAL)
    }
}

override fun onPause() {
    super.onPause()
    // Unregister the listener when the activity is paused to save battery.
    sensorManager.unregisterListener(this)
}