Android Studio Kotlin：处理通过蓝牙接收的数据时遇到问题

因此，我目前正在根据使用输入缓冲区从蓝牙模块接收到的数据完成某些任务。目前，我正在尝试使用MediaPlayer.Create根据输入播放声音，但只有当我插入设备并点击“应用更改并重新启动活动”时，声音似乎才起作用。如果我只是打开应用程序并进行测试，只有在完成前面所述的过程后，声音似乎才起作用。有没有更好的方法读取输入流并处理该数据？是否还有更好的方法来说明如何在ConnectedThread线程的run（）函数中播放声音

package com.example.airboard

import android.app.ProgressDialog
import android.bluetooth.BluetoothAdapter
import android.bluetooth.BluetoothDevice
import android.bluetooth.BluetoothSocket
import android.content.Context
import android.media.MediaPlayer
import android.os.AsyncTask
import android.os.Bundle
import android.os.Handler
import android.util.Log
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.control_layout.*
import org.jetbrains.anko.toast
import java.io.IOException
import java.util.*

class ControlActivity: AppCompatActivity() {

    companion object {
        var m_myUUID: UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
        var m_bluetoothSocket: BluetoothSocket? = null
        lateinit var m_progress: ProgressDialog
        lateinit var m_bluetoothAdapater: BluetoothAdapter
        var m_isConnected: Boolean = false
        lateinit var  m_address: String
        private const val TAG = "MY_APP_DEBUG_TAG"
        const val MESSAGE_READ: Int = 0
        const val MESSAGE_WRITE: Int = 1
        const val MESSAGE_TOAST: Int = 2
        private lateinit var handler: Handler
    }
    var mMediaPlayer: MediaPlayer? = null
    override fun onCreate(savedInstanceState: Bundle?) {

        super.onCreate(savedInstanceState)
        setContentView(R.layout.control_layout)
        m_address = intent.getStringExtra(SettingsActivity.EXTRA_ADDRESS)!!
        ConnectToDevice(this).execute()

        control_led_on.setOnClickListener { sendCommand("1") }
        control_led_off.setOnClickListener { sendCommand("0") }
        control_led_disconnect.setOnClickListener { disconnect() }
    }

   private fun sendCommand(input: String){
        if (m_bluetoothSocket != null){
            try {
                m_bluetoothSocket!!.outputStream.write(input.toByteArray())
                Log.i("data", "sending..")
            } catch (e: IOException) {
                e.printStackTrace()
                Log.i("data", "couldn't send")
                }
                return

            }

    }
    private fun disconnect(){
        if (m_bluetoothSocket != null){
            try {
                m_bluetoothSocket!!.close()
                m_bluetoothSocket = null
                m_isConnected = false
            } catch (e: IOException) {
                e.printStackTrace()
            }
        }
        finish()
    }

    private class ConnectedThread(private val mmSocket: BluetoothSocket?, c : Context) : Thread() {
        private val mmBuffer: ByteArray = ByteArray(10) // mmBuffer store for the stream
        var mMediaPlayer: MediaPlayer? = null
        var context: Context
        init{
            this.context = c
        }
        override fun run() {
            var numBytes: Int = 0// bytes returned from read()
            //var begin: Int = 0
            // Keep listening to the InputStream until an exception occurs.
            while (true) {
                // Read from the InputStream.
                try {
                    numBytes =
                        mmSocket!!.inputStream.read(mmBuffer, numBytes, mmBuffer.size - numBytes)
 

                } catch (e: IOException) {
                    Log.d(TAG, "Input stream was disconnected", e)
                    break
                }

                playNote(context)

                println(numBytes)
                println(String(mmBuffer))





            }
        }
        fun playNote(c: Context) {
            if (mMediaPlayer == null) {
                mMediaPlayer = MediaPlayer.create(c, R.raw.c3)
                mMediaPlayer!!.start()
            } else if (mMediaPlayer != null) {
                mMediaPlayer!!.stop()
                mMediaPlayer!!.release()
                mMediaPlayer = null
            } else mMediaPlayer!!.start()
        }

    }




    private class ConnectToDevice(c: Context) : AsyncTask<Void, Void, String>(){
        private var connectSuccess: Boolean = true
        private val context: Context

        init {
            this.context = c
        }
        override fun onPreExecute() {
            super.onPreExecute()
            m_progress = ProgressDialog.show(context, "Connecting...", "please wait")
        }
        override fun doInBackground(vararg p0: Void?) : String? {
            try {
                if (m_bluetoothSocket == null || !m_isConnected){
                    m_bluetoothAdapater = BluetoothAdapter.getDefaultAdapter()
                    val device: BluetoothDevice = m_bluetoothAdapater.getRemoteDevice(m_address)
                    m_bluetoothSocket = device.createInsecureRfcommSocketToServiceRecord(m_myUUID)
                    BluetoothAdapter.getDefaultAdapter().cancelDiscovery()
                    m_bluetoothSocket!!.connect()

                }
            } catch (e: IOException){
                connectSuccess = false
                e.printStackTrace()
            }
            return null
        }
        override fun onPostExecute(result: String?) {
            super.onPostExecute(result)
            if(!connectSuccess){
                Log.i("data", "couldn't connect")
            } else {
                m_isConnected = true
                var connectedthread= ConnectedThread(m_bluetoothSocket, context)
                connectedthread.start()
                Log.i("data", "connected")
            }
            m_progress.dismiss()


        }

    }
}

package com.example.airboard
导入android.app.ProgressDialog
导入android.bluetooth.BluetoothAdapter
导入android.bluetooth.bluetooth设备
导入android.bluetooth.BluetoothSocket
导入android.content.Context
导入android.media.MediaPlayer
导入android.os.AsyncTask
导入android.os.Bundle
导入android.os.Handler
导入android.util.Log
导入android.view.view
导入android.widget.Toast
导入androidx.appcompat.app.appcompat活动
导入kotlinx.android.synthetic.main.control\u布局*
导入org.jetbrains.anko.toast
导入java.io.IOException
导入java.util*
类ControlActivity:AppCompatActivity（）{
伴星{
var m_myUUID:UUID=UUID.fromString（“00001101-0000-1000-8000-00805F9B34FB”）
var m_bluetoothSocket:bluetoothSocket？=null
lateinit var m_进度：ProgressDialog
lateinit var m_Bluetooth适配器：Bluetooth适配器
变量m_已连接：布尔值=false
lateinit var m_地址：字符串
private const val TAG=“我的应用程序调试标签”
const val MESSAGE_READ:Int=0
const val MESSAGE_WRITE:Int=1
const val MESSAGE_TOAST:Int=2
私有lateinit变量处理程序：处理程序
}
变量mMediaPlayer:MediaPlayer？=null
重写创建时的乐趣（savedInstanceState:Bundle？）{
super.onCreate（savedInstanceState）
setContentView（R.layout.control\u布局）
m_地址=intent.getStringExtra（设置活动.额外地址）！！
ConnectToDevice（this.execute（））
控件在.setOnClickListener{sendCommand（“1”）}上显示
control_led_off.setOnClickListener{sendCommand（“0”）}
control_led_disconnect.setOnClickListener{disconnect（）}
}
私有命令（输入：字符串）{
如果（m_bluetoothSocket！=null）{
试一试{
m_bluetoothSocket！！.outputStream.write（input.toByteArray（））
Log.i（“数据”、“发送…”）
}捕获（e:IOException）{
e、 printStackTrace（）
Log.i（“数据”，“无法发送”）
}
返回
}
}
私人娱乐{
如果（m_bluetoothSocket！=null）{
试一试{
m_bluetoothSocket！！.close（）
m_bluetoothSocket=null
m_已断开连接=错误
}捕获（e:IOException）{
e、 printStackTrace（）
}
}
完成（）
}
私有类ConnectedThread（私有val mmSocket:BluetoothSocket？，c:Context）：Thread（）{
private val mmBuffer:ByteArray=ByteArray（10）//流的mmBuffer存储
变量mMediaPlayer:MediaPlayer？=null
变量上下文：上下文
初始化{
this.context=c
}
覆盖趣味跑（）{
var numBytes:Int=0//read（）返回的字节
//变量开始：Int=0
//继续侦听InputStream，直到发生异常。
while（true）{
//从输入流读取。
试一试{
麻木=
mmSocket！！.inputStream.read（mmBuffer，numBytes，mmBuffer.size-numBytes）
}捕获（e:IOException）{
Log.d（标记“输入流已断开连接”，e）
打破
}
playNote（上下文）
println（单位：字节）
println（字符串（mmBuffer））
}
}
趣味游戏笔记（c：上下文）{
if（mmediplayer==null）{
mMediaPlayer=MediaPlayer.create（c，R.raw.c3）
mmediplayer！！.start（）
}否则如果（mmedimplayer！=null）{
mmediplayer！！.stop（）
mmediplayer！！.release（）
mmediplayer=null
}否则，请选择图层！！.start（）
}
}
私有类ConnectToDevice（c:Context）：AsyncTask（）{
private-var-connectSuccess:Boolean=true
私有val上下文：上下文
初始化{
this.context=c
}
覆盖乐趣onPreExecute（）{
super.onPreExecute（）
m_progress=ProgressDialog.show（上下文“正在连接…”，“请稍候”）
}
覆盖有趣的背景（vararg p0:Void？）：字符串{
试一试{
如果（m|u bluetoothSocket==null | |！m|u已连接）{
m_BluetoothAdapter=BluetoothAdapter.getDefaultAdapter（）
val设备：BluetoothDevice=m_bluetoothAdapater.getRemoteDevice（m_地址）
m_bluetoothSocket=device.createInsurerCommsocketToServiceRecord（m_myUUID）
BluetoothAdapter.getDefaultAdapter（）.cancelDiscovery（）
m_bluetoothSocket！！.connect（）
}
}捕获（e:IOException）{
connectSuccess=false
e、 printStackTrace（）
}
返回空
}
重写onPostExecute（结果：字符串？）{
super.onPostExecute（结果）
如果（！连接成功）{
Log.i（“数据”，“无法连接”）
}否则{
m_已断开连接=真
var connectedthread=ConnectedThr