dependencies {
 
    // UWB
    implementation("androidx.core.uwb:uwb:1.0.0-alpha09")
    
    // navigation compose
    implementation("androidx.navigation:navigation-compose:2.8.4")
 
    // 以下省略

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">
 
    <!-- Bluetooth Low Energy -->
    <uses-permission android:name="android.permission.BLUETOOTH" />
    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
    <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
 
    <!-- UWB -->
    <uses-permission android:name="android.permission.UWB_RANGING" />
 

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            AndroidBleAndUwbSampleTheme {
                MainScreen()
            }
        }
    }
}
 
@Composable
private fun MainScreen() {
    val navController = rememberNavController()
 
    NavHost(navController = navController, startDestination = "home") {
        composable("home") {
            HomeScreen(
                onControllerClick = { navController.navigate("controller") },
                onControleeClick = { navController.navigate("controlee") }
            )
        }
        composable("controller") {
            ControllerScreen()
        }
        composable("controlee") {
            ControleeScreen()
        }
    }
}

private val REQUIRED_PERMISSION = listOf(
    android.Manifest.permission.BLUETOOTH,
    android.Manifest.permission.BLUETOOTH_CONNECT,
    android.Manifest.permission.BLUETOOTH_SCAN,
    android.Manifest.permission.BLUETOOTH_ADVERTISE,
    android.Manifest.permission.ACCESS_COARSE_LOCATION,
    android.Manifest.permission.ACCESS_FINE_LOCATION,
    android.Manifest.permission.UWB_RANGING
)
 
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun HomeScreen(
    onControllerClick: () -> Unit,
    onControleeClick: () -> Unit
) {
    val context = LocalContext.current
    val isGranted = remember {
        mutableStateOf(REQUIRED_PERMISSION.all { ContextCompat.checkSelfPermission(context, it) == PackageManager.PERMISSION_GRANTED })
    }
 
    val permissionRequest = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestMultiplePermissions(),
        onResult = { isGranted.value = it.all { it.value } }
    )
 
    LaunchedEffect(key1 = Unit) {
        // 権限をリクエスト
        permissionRequest.launch(REQUIRED_PERMISSION.toTypedArray())
    }
 
    Scaffold(
        topBar = {
            TopAppBar(title = { Text(text = "権限ください") })
        }
    ) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {
 
            // 権限が付与されるまでボタンを出さない
            if (!isGranted.value) {
                Text(text = "権限が付与されていません")
                return@Scaffold
            }
 
            // 画面遷移用
            Button(onClick = onControllerClick) {
                Text(text = "Controller (Host)")
            }
            Button(onClick = onControleeClick) {
                Text(text = "Controlee (Guest)")
            }
        }
    }
}

/** BLE で使う UUID */
object BleUuid {
 
    /** GATT サービスの UUID */
    val GATT_SERVICE_UUID = UUID.fromString("107c9e9b-bf6d-4b64-ab30-0bd96fdd2537")
    
    /** GATT キャラクタリスティックの UUID */
    val GATT_CHARACTERISTIC_UUID = UUID.fromString("e42ba363-eeaa-4e46-b7aa-049c19341f24")
 
}

/** BLE ペリフェラル側のコード */
object BlePeripheral {
 
    /**
     * ペリフェラル側に必要な GATT サーバーとアドバタイジングを開始する。
     * コルーチンをキャンセルすると終了する。
     *
     * @param context [Context]
     * @param onCharacteristicReadRequest セントラルからキャラクタリスティックに対して read 要求された時
     * @param onCharacteristicWriteRequest セントラルからキャラクタリスティックに対して write 要求された時
     */
    suspend fun startPeripheralAndAdvertising(
        context: Context,
        onCharacteristicReadRequest: () -> ByteArray,
        onCharacteristicWriteRequest: (ByteArray) -> Unit
    ) {
        coroutineScope {
            launch {
                suspendGattServer(context, onCharacteristicReadRequest, onCharacteristicWriteRequest)
            }
            launch {
                suspendAdvertisement(context)
            }
        }
    }
 
    @SuppressLint("MissingPermission")
    private suspend fun suspendGattServer(
        context: Context,
        onCharacteristicReadRequest: () -> ByteArray,
        onCharacteristicWriteRequest: (ByteArray) -> Unit
    ) {
        val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
 
        var bleGattServer: BluetoothGattServer? = null
        bleGattServer = bluetoothManager.openGattServer(context, object : BluetoothGattServerCallback() {
            // readCharacteristic が要求されたら呼ばれる
            // セントラルへ送信する
            override fun onCharacteristicReadRequest(device: BluetoothDevice?, requestId: Int, offset: Int, characteristic: BluetoothGattCharacteristic?) {
                super.onCharacteristicReadRequest(device, requestId, offset, characteristic)
                val sendByteArray = onCharacteristicReadRequest()
                // オフセットを考慮する
                // TODO バイト数スキップするのが面倒で ByteArrayInputStream 使ってるけど多分オーバースペック
                val sendOffsetByteArray = sendByteArray.inputStream().apply { skip(offset.toLong()) }.readBytes()
                bleGattServer?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, sendOffsetByteArray)
            }
 
            // writeCharacteristic が要求されたら呼ばれる
            // セントラルから受信する
            override fun onCharacteristicWriteRequest(device: BluetoothDevice?, requestId: Int, characteristic: BluetoothGattCharacteristic?, preparedWrite: Boolean, responseNeeded: Boolean, offset: Int, value: ByteArray?) {
                super.onCharacteristicWriteRequest(device, requestId, characteristic, preparedWrite, responseNeeded, offset, value)
                value ?: return
                onCharacteristicWriteRequest(value)
                bleGattServer?.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, offset, null)
            }
        })
 
        //サービスとキャラクタリスティックを作る
        val gattService = BluetoothGattService(BleUuid.GATT_SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY)
        val gattCharacteristics = BluetoothGattCharacteristic(
            BleUuid.GATT_CHARACTERISTIC_UUID,
            BluetoothGattCharacteristic.PROPERTY_READ or BluetoothGattCharacteristic.PROPERTY_WRITE,
            BluetoothGattCharacteristic.PERMISSION_READ or BluetoothGattCharacteristic.PERMISSION_WRITE
        )
        // サービスに Characteristic を入れる
        gattService.addCharacteristic(gattCharacteristics)
        // GATT サーバーにサービスを追加
        bleGattServer?.addService(gattService)
 
        // キャンセルしたら終了
        try {
            awaitCancellation()
        } finally {
            bleGattServer?.close()
        }
    }
 
    @SuppressLint("MissingPermission")
    private suspend fun suspendAdvertisement(context: Context) {
        val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
        val bluetoothLeAdvertiser = bluetoothManager.adapter.bluetoothLeAdvertiser
 
        // アドバタイジング。これがないと見つけてもらえない
        val advertiseSettings = AdvertiseSettings.Builder().apply {
            setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_POWER)
            setTimeout(0)
        }.build()
        val advertiseData = AdvertiseData.Builder().apply {
            addServiceUuid(ParcelUuid(BleUuid.GATT_SERVICE_UUID))
        }.build()
        // アドバタイジング開始
        val advertiseCallback = object : AdvertiseCallback() {
            override fun onStartSuccess(settingsInEffect: AdvertiseSettings?) {
                super.onStartSuccess(settingsInEffect)
            }
 
            override fun onStartFailure(errorCode: Int) {
                super.onStartFailure(errorCode)
            }
        }
        bluetoothLeAdvertiser.startAdvertising(advertiseSettings, advertiseData, advertiseCallback)
 
        // キャンセルしたら終了
        try {
            awaitCancellation()
        } finally {
            bluetoothLeAdvertiser.stopAdvertising(advertiseCallback)
        }
    }
 
}

/** BLE セントラル側のコード */
class BleCentral(private val context: Context) {
 
    /** [readCharacteristic]等で使いたいので */
    private val _bluetoothGatt = MutableStateFlow<BluetoothGatt?>(null)
 
    /** コールバックの返り値をコルーチン側から受け取りたいので */
    private val _characteristicReadChannel = Channel<ByteArray>()
 
    /** BLE 通信をし、GATT サーバーへ接続しサービスを探す */
    @SuppressLint("MissingPermission")
    suspend fun connectGattServer() {
        val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
 
        // BluetoothDevice が見つかるまで一時停止
        val bluetoothDevice: BluetoothDevice? = suspendCoroutine { continuation ->
            val bluetoothLeScanner = bluetoothManager.adapter.bluetoothLeScanner
            val bleScanCallback = object : ScanCallback() {
                override fun onScanResult(callbackType: Int, result: ScanResult?) {
                    super.onScanResult(callbackType, result)
                    // 見つけたら返して、スキャンも終了させる
                    continuation.resume(result?.device)
                    bluetoothLeScanner.stopScan(this)
                }
 
                override fun onScanFailed(errorCode: Int) {
                    super.onScanFailed(errorCode)
                    continuation.resume(null)
                }
            }
 
            // GATT サーバーのサービス UUID を指定して検索を始める
            val scanFilter = ScanFilter.Builder().apply {
                setServiceUuid(ParcelUuid(BleUuid.GATT_SERVICE_UUID))
            }.build()
            bluetoothLeScanner.startScan(
                listOf(scanFilter),
                ScanSettings.Builder().build(),
                bleScanCallback
            )
        }
 
        // BLE デバイスを見つけたら、GATT サーバーへ接続
        bluetoothDevice?.connectGatt(context, false, object : BluetoothGattCallback() {
 
            // ペリフェラル側との接続
            override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
                super.onConnectionStateChange(gatt, status, newState)
                when (newState) {
                    // 接続できたらサービスを探す
                    BluetoothProfile.STATE_CONNECTED -> gatt?.discoverServices()
                    // なくなった
                    BluetoothProfile.STATE_DISCONNECTED -> _bluetoothGatt.value = null
                }
            }
 
            override fun onServicesDiscovered(gatt: BluetoothGatt?, status: Int) {
                super.onServicesDiscovered(gatt, status)
                // サービスが見つかったら GATT サーバーに対して操作ができるはず
                // サービスとキャラクタリスティックを探して、read する
                // キャラクタリスティック操作ができたら flow に入れる
                _bluetoothGatt.value = gatt
            }
 
            // onCharacteristicReadRequest で送られてきたデータを受け取る
            override fun onCharacteristicRead(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, value: ByteArray, status: Int) {
                super.onCharacteristicRead(gatt, characteristic, value, status)
                _characteristicReadChannel.trySend(value)
            }
        })
 
        // GATT サーバーへ接続できるまで一時停止する
        _bluetoothGatt.first { it != null }
    }
 
    /** 終了時に呼ぶ */
    @SuppressLint("MissingPermission")
    fun destroy() {
        _bluetoothGatt.value?.close()
        _bluetoothGatt.value = null
    }
 
    /** キャラクタリスティックから読み出す */
    @SuppressLint("MissingPermission")
    suspend fun readCharacteristic(): ByteArray {
        // GATT サーバーとの接続を待つ
        val gatt = _bluetoothGatt.filterNotNull().first()
        // GATT サーバーへ狙ったサービス内にあるキャラクタリスティックへ read を試みる
        val findService = gatt.services?.first { it.uuid == BleUuid.GATT_SERVICE_UUID }
        val findCharacteristic = findService?.characteristics?.first { it.uuid == BleUuid.GATT_CHARACTERISTIC_UUID }
        // 結果は onCharacteristicRead で
        gatt.readCharacteristic(findCharacteristic)
        return _characteristicReadChannel.receive()
    }
 
    /** キャラクタリスティックへ書き込む */
    @SuppressLint("MissingPermission")
    suspend fun writeCharacteristic(sendData: ByteArray) {
        // GATT サーバーとの接続を待つ
        val gatt = _bluetoothGatt.filterNotNull().first()
        // GATT サーバーへ狙ったサービス内にあるキャラクタリスティックへ write を試みる
        val findService = gatt.services?.first { it.uuid == BleUuid.GATT_SERVICE_UUID } ?: return
        val findCharacteristic = findService.characteristics?.first { it.uuid == BleUuid.GATT_CHARACTERISTIC_UUID } ?: return
        // 結果は onCharacteristicWriteRequest で
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            gatt.writeCharacteristic(findCharacteristic, sendData, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
        } else {
            // TODO 下位バージョン対応するなら。UWB 対応デバイスが、TIRAMISU より前に存在するかを考えるとめんどい
        }
    }
 
}

/** Controller(親)→Controlee(子) へ送るパラメーター */
data class UwbControllerParams(
    val address: ByteArray,
    val channel: Int,
    val preambleIndex: Int,
    val sessionId: Int,
    val sessionKeyInfo: ByteArray
) : Serializable {
 
    /** シリアライズ、デシリアライズ用 */
    companion object {
 
        fun encode(uwbHostParameter: UwbControllerParams): ByteArray {
            return ByteArrayOutputStream().use { byteArrayOutputStream ->
                ObjectOutputStream(byteArrayOutputStream).use { objectOutputStream ->
                    // 書き込んで ByteArray を返す
                    objectOutputStream.writeObject(uwbHostParameter)
                    byteArrayOutputStream.toByteArray()
                }
            }
        }
 
        fun decode(byteArray: ByteArray): UwbControllerParams {
            return byteArray.inputStream().use { byteArrayInputStream ->
                ObjectInputStream(byteArrayInputStream).use { objectInputStream ->
                    // キャストする
                    objectInputStream.readObject() as UwbControllerParams
                }
            }
        }
    }
}

/** Controller(Host) 側の画面 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ControllerScreen() {
    val context = LocalContext.current
    
    // controlee の位置
    val uwbPosition = remember { mutableStateOf<RangingPosition?>(null) }
 
    LaunchedEffect(key1 = Unit) {
        // controller 側として作成
        val uwbManager = UwbManager.createInstance(context)
        val controllerSession = uwbManager.controllerSessionScope()
 
        // ゲスト側へ送るパラメーターを ByteArray にして送る
        // sessionId / sessionKeyInfo はサンプルコードでも適当に作ってるので適当に作る
        // https://github.com/android/connectivity-samples/blob/777517eb2898cd48e139446246808a2106d343cc/UwbRanging/uwbranging/src/main/java/com/google/apps/uwbranging/impl/NearbyControllerConnector.kt#L69
        val sessionId = Random.nextInt()
        val sessionKeyInfo = Random.nextBytes(8)
        // Serializable な data class にして ByteArray にエンコードする
        val uwbControllerParams = UwbControllerParams(
            address = controllerSession.localAddress.address,
            channel = controllerSession.uwbComplexChannel.channel,
            preambleIndex = controllerSession.uwbComplexChannel.preambleIndex,
            sessionId = sessionId,
            sessionKeyInfo = sessionKeyInfo
        )
        // バイト配列に
        val encodeHostParameter = UwbControllerParams.encode(uwbControllerParams)
 
        // Controlee 側からアドレスが送られてきたら入れる Flow
        val controleeAddressFlow = MutableStateFlow<ByteArray?>(null)
 
        // BLE の開始
        val peripheralJob = launch {
            BlePeripheral.startPeripheralAndAdvertising(
                context = context,
                onCharacteristicReadRequest = {
                    // controlee へ送る
                    encodeHostParameter
                },
                onCharacteristicWriteRequest = {
                    // controlee から受け取る
                    controleeAddressFlow.value = it
                }
            )
        }
 
        // アドレスが送られてきたらペリフェラル終了
        val controleeAddress = controleeAddressFlow.filterNotNull().first()
        peripheralJob.cancel()
 
        // RangingParameters を作り UWB 接続を開始する
        val rangingParameters = RangingParameters(
            uwbConfigType = RangingParameters.CONFIG_MULTICAST_DS_TWR,
            complexChannel = controllerSession.uwbComplexChannel,
            peerDevices = listOf(UwbDevice.createForAddress(controleeAddress)),
            updateRateType = RangingParameters.RANGING_UPDATE_RATE_AUTOMATIC,
            sessionId = sessionId,
            sessionKeyInfo = sessionKeyInfo,
            subSessionId = 0, // SUB_SESSION_UNSET
            subSessionKeyInfo = null // 暗号化の何か
        )
        controllerSession.prepareSession(rangingParameters).collect { rangingResult ->
            when (rangingResult) {
                is RangingResult.RangingResultPosition -> {
                    uwbPosition.value = rangingResult.position
                }
 
                is RangingResult.RangingResultPeerDisconnected -> {
                    uwbPosition.value = null
                }
            }
        }
    }
 
    Scaffold(
        topBar = {
            TopAppBar(title = { Text(text = "UWB Controller") })
        }
    ) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {
            // null になりえるので注意
            Text(text = "距離 = ${uwbPosition.value?.distance?.value} m")
            Text(text = "方位角 = ${uwbPosition.value?.azimuth?.value} 度")
            Text(text = "仰角 = ${uwbPosition.value?.elevation?.value} 度")
        }
    }
}

/** Controlee(Guest) 側の画面 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ControleeScreen() {
    val context = LocalContext.current
 
    // controller の位置
    val uwbPosition = remember { mutableStateOf<RangingPosition?>(null) }
 
    LaunchedEffect(key1 = Unit) {
        val uwbManager = UwbManager.createInstance(context)
        val controleeSession = uwbManager.controleeSessionScope()
 
        // ホスト側へ送るデータ
        val addressByteArray = controleeSession.localAddress.address
 
        // BLE GATT サーバーへ接続し、UWB ホストと接続に必要なパラメーターを送受信する
        val bleCentral = BleCentral(context)
        bleCentral.connectGattServer()
        val uwbControllerParamsByteArray = bleCentral.readCharacteristic()
        val uwbControllerParams = UwbControllerParams.decode(uwbControllerParamsByteArray)
        bleCentral.writeCharacteristic(addressByteArray)
        bleCentral.destroy()
 
        // パラメーターを作成
        val rangingParameters = RangingParameters(
            uwbConfigType = RangingParameters.CONFIG_MULTICAST_DS_TWR,
            complexChannel = UwbComplexChannel(uwbControllerParams.channel, uwbControllerParams.preambleIndex),
            peerDevices = listOf(UwbDevice.createForAddress(uwbControllerParams.address)),
            updateRateType = RangingParameters.RANGING_UPDATE_RATE_AUTOMATIC,
            sessionId = uwbControllerParams.sessionId,
            sessionKeyInfo = uwbControllerParams.sessionKeyInfo,
            subSessionId = 0, // SESSION_ID_UNSET ？
            subSessionKeyInfo = null // ？
        )
 
        // Flow で UWB デバイスとの接続状況をもらえる
        controleeSession.prepareSession(rangingParameters).collect { rangingResult ->
            when (rangingResult) {
                is RangingResult.RangingResultPosition -> {
                    uwbPosition.value = rangingResult.position
                }
 
                is RangingResult.RangingResultPeerDisconnected -> {
                    uwbPosition.value = null
                }
            }
        }
    }
 
    Scaffold(
        topBar = {
            TopAppBar(title = { Text(text = "UWB Controlee") })
        }
    ) { innerPadding ->
        Column(modifier = Modifier.padding(innerPadding)) {
            // null になりえるので注意
            Text(text = "距離 = ${uwbPosition.value?.distance?.value} m")
            Text(text = "方位角 = ${uwbPosition.value?.azimuth?.value} 度")
            Text(text = "仰角 = ${uwbPosition.value?.elevation?.value} 度")
        }
    }
}

/** UWB の方角を表示する矢印 */
@Composable
fun UwbArrow(
    modifier: Modifier = Modifier,
    azimuth: Float
) {
    val animateAzimuth = animateFloatAsState(azimuth, label = "animateAzimuth")
 
    Box(
        modifier = modifier.graphicsLayer {
            rotationZ = animateAzimuth.value
        },
        contentAlignment = Alignment.Center
    ) {
        Text(
            text = "↑",
            fontSize = 100.sp
        )
    }
}

// null になりえるので注意
Text(text = "距離 = ${uwbPosition.value?.distance?.value} m")
Text(text = "方位角 = ${uwbPosition.value?.azimuth?.value} 度")
Text(text = "仰角 = ${uwbPosition.value?.elevation?.value} 度")
 
UwbArrow(
    azimuth = uwbPosition.value?.azimuth?.value ?: 0f
)

/**
 * 自分と通信相手を点で表示する Canvas
 * https://github.com/android/connectivity-samples/blob/main/UwbRanging/app/src/main/java/com/google/apps/hellouwb/ui/home/HomeScreen.kt
 *
 * @param modifier [Modifier]
 * @param distance 距離
 * @param azimuth 角度
 * @param isInvert 動かす側の場合は反転する必要があるので
 */
@Composable
fun UwbPointCanvas(
    modifier: Modifier = Modifier,
    isInvert: Boolean,
    distance: Float,
    azimuth: Float
) {
    Canvas(modifier = modifier.border(1.dp, Color.Black)) {
 
        // 自分（isInvert した場合は相手）
        drawCircle(Color.Red, radius = 15.0f)
 
        val scale = size.minDimension / 20.0f
        val angle = azimuth * PI / 180
        val x = distance * sin(angle).toFloat()
        val y = distance * cos(angle).toFloat()
 
        // UWB デバイスの位置
        drawCircle(
            center = center.plus(
                if (isInvert) {
                    Offset(-x * scale, y * scale)
                } else {
                    Offset(x * scale, -y * scale)
                }
            ),
            color = Color.Blue,
            radius = 15.0f
        )
    }
}

// null になりえるので注意
Text(text = "距離 = ${uwbPosition.value?.distance?.value} m")
Text(text = "方位角 = ${uwbPosition.value?.azimuth?.value} 度")
Text(text = "仰角 = ${uwbPosition.value?.elevation?.value} 度")
 
UwbArrow(
    azimuth = uwbPosition.value?.azimuth?.value ?: 0f
)
 
val isCanvasInvert = remember { mutableStateOf(false) }
Row {
    Text(text = "canvas を反転")
    Switch(checked = isCanvasInvert.value, onCheckedChange = { isCanvasInvert.value = it })
}
UwbPointCanvas(
    modifier = Modifier.size(300.dp),
    isInvert = isCanvasInvert.value,
    distance = uwbPosition.value?.distance?.value ?: 0f,
    azimuth = uwbPosition.value?.azimuth?.value ?: 0f
)

@Composable
fun UwbRecordPointCanvas(
    modifier: Modifier = Modifier,
    isInvert: Boolean,
    distance: Float,
    azimuth: Float
) {
    val isRecord = remember { mutableStateOf(false) }
    val recordList = remember { mutableStateOf(emptyList<PointData>()) }
 
    if (isRecord.value) {
        SideEffect {
            // 数が多いので適当に捨てる
            if (Random.nextBoolean()) {
                recordList.value += PointData(distance, azimuth)
            }
        }
    }
 
    Column {
        Row {
            Button(onClick = { isRecord.value = !isRecord.value }) {
                Text(text = if (!isRecord.value) "記録開始" else "終了")
            }
            Button(onClick = { recordList.value = emptyList() }) {
                Text(text = "クリア")
            }
        }
        Canvas(modifier = modifier.border(1.dp, Color.Black)) {
 
            // 自分（isInvert した場合は相手）
            drawCircle(Color.Red, radius = 15.0f)
 
            // 配列に入れたものを表示
            recordList.value.forEach { (distance, azimuth) ->
 
                val scale = size.minDimension / 20.0f
                val angle = azimuth * PI / 180
                val x = distance * sin(angle).toFloat()
                val y = distance * cos(angle).toFloat()
 
                // UWB デバイスの位置
                drawCircle(
                    center = center.plus(
                        if (isInvert) {
                            Offset(-x * scale, y * scale)
                        } else {
                            Offset(x * scale, -y * scale)
                        }
                    ),
                    color = Color.Blue,
                    radius = 15.0f
                )
            }
        }
    }
}