蓝牙流媒体技术落后于Android应用程序

我正在编写Android应用程序，通过蓝牙从另一台设备接收数据。事实上，这些数据流是不间断的。在得到大约50或70个数据后，应用程序会减慢速度并停止向我显示收到的数据。应用程序缓存已满，但清除它（删除

context.getCacheDir（）

）没有帮助。重新启动整个应用程序后，我可以再次获取下一部分数据。我能做些什么来避免这种“滞后”

我的主要活动：

public class MainActivity extends Activity {
    private BluetoothAdapter bluetoothAdapter;
    private boolean pendingRequestEnableBt = false;
    private final String SAVED_PENDING_REQUEST_ENABLE_BT = "PENDING_REQUEST_ENABLE_BT";
    private BluetoothResponseHandler mHandler;
    private static MainActivity instance;
    private DeviceConnector connector;
    private TextView console;
    private String deviceName;

    private final int REQUEST_CONNECT_DEVICE = 1;
    private final int REQUEST_ENABLE_BT = 2;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        instance = this;
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        console = (TextView) findViewById(R.id.main_text_console);
        if (savedInstanceState != null) {
            pendingRequestEnableBt = savedInstanceState.getBoolean(SAVED_PENDING_REQUEST_ENABLE_BT);
        }
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        if (bluetoothAdapter == null) {
            Toast.makeText(this, "No bluetooth available", Toast.LENGTH_LONG).show();
        }
        if (mHandler == null) {
            mHandler = new BluetoothResponseHandler(this);
        } else {
            mHandler.setTarget(this);
        }
    }

    public void setDeviceName(String deviceName) {
        this.deviceName = deviceName;
        getActionBar().setSubtitle(deviceName);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putBoolean(SAVED_PENDING_REQUEST_ENABLE_BT, pendingRequestEnableBt);
        outState.putString("device_name", deviceName);
        if (console != null) {
            final String log = console.getText().toString();
            outState.putString("AC", log);
        }
    }

    public boolean isAdapterReady() {
        return (bluetoothAdapter != null) && (bluetoothAdapter.isEnabled());
    }

    private static class BluetoothResponseHandler extends Handler {
        private WeakReference<MainActivity> mActivity;

        public BluetoothResponseHandler(MainActivity activity) {
            mActivity = new WeakReference<MainActivity>(activity);
        }

        public void setTarget(MainActivity target) {
            mActivity.clear();
            mActivity = new WeakReference<MainActivity>(target);
        }

        @Override
        public void handleMessage(Message msg) {
            MainActivity activity = mActivity.get();
            if (activity != null) {
                if (msg.what==MessageType.MESSAGE_STATE_CHANGE.getValue()) {
                    final ActionBar bar = activity.getActionBar();
                    switch (msg.arg1) {
                        case DeviceConnector.STATE_CONNECTED:
                            bar.setSubtitle("Połączono.");
                            break;
                        case DeviceConnector.STATE_CONNECTING:
                            bar.setSubtitle("Łączenie");
                            break;
                        case DeviceConnector.STATE_NONE:
                            bar.setSubtitle("Rozłączono.");
                            break;
                    }
                } else if (msg.what==MessageType.MESSAGE_READ.getValue()) {
                    if (msg.obj != null) {
                        activity.appendLog((String)msg.obj);
                    }
                } else if (msg.what==MessageType.MESSAGE_DEVICE_NAME.getValue()) {
                    activity.setDeviceName((String) msg.obj);
                }
            }
        }
    }

    private void startDeviceListActivity() {
        stopConnection();
        startActivityForResult(new Intent(this, DeviceListActivity.class), REQUEST_CONNECT_DEVICE);
    }

    private void stopConnection() {
        if (connector != null) {
            connector.stop();
            connector = null;
        }
    }

    @Override
    public boolean onSearchRequested() {
        if (isAdapterReady()) {
            startDeviceListActivity();
        }
        return false;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.device_control_activity, menu);
        return true;
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case REQUEST_CONNECT_DEVICE:
                if (resultCode == Activity.RESULT_OK) {
                    String address = data.getStringExtra(DeviceListActivity.EXTRA_DEVICE_ADDRESS);
                    BluetoothDevice device = bluetoothAdapter.getRemoteDevice(address);
                    if (isAdapterReady() && (connector == null)) setupConnector(device);
                }
                break;
            case REQUEST_ENABLE_BT:
                pendingRequestEnableBt = false;
                if (resultCode != Activity.RESULT_OK) {
                    Toast.makeText(this, "Bt not enabled", Toast.LENGTH_LONG).show();
                }
                break;
        }
    }

    private void setupConnector(BluetoothDevice connectedDevice) {
        stopConnection();
        connector = new DeviceConnector(new DeviceData(connectedDevice, getString(R.string.empty_device_name)), mHandler);
        connector.connect();
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_search:
                if (isAdapterReady()) {
                    if (isConnected()) {
                        stopConnection();
                    } else {
                        startDeviceListActivity();
                    }
                } else {
                    Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                    startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
                }
                return true;
            default:
                return super.onOptionsItemSelected(item);
        }
    }

    private void appendLog(String message) {
        String msg = message.replaceAll("[\n\t\r ]*", "");
        console.append(msg.length() + ": " + msg + "\n");
        final int scrollAmount = console.getLayout().getLineTop(console.getLineCount()) - console.getHeight();
        console.scrollTo(0, scrollAmount>0?scrollAmount:0);
        delete(getCacheDir());
    }

    private boolean isConnected() {
        return (connector != null) && (connector.getState() == DeviceConnector.STATE_CONNECTED);
    }

    public static MainActivity getInstance() {
        return instance;
    }

    public void delete(File file) {
        if (file.exists()) {
            if (file.isFile()) {
                file.delete();
            } else if (file.isDirectory()) {
                for (File f:file.listFiles()) {
                    delete(f);
                }
            }
        }
    }
}

公共类MainActivity扩展活动{
私人蓝牙适配器；
私有布尔pendingRequestEnableBt=false；
私有最终字符串已保存\u挂起\u请求\u启用\u BT=“挂起\u请求\u启用\u BT”；
私人蓝牙负责人；
私有静态活动实例；
专用设备连接器；
私有文本视图控制台；
私有字符串deviceName；
专用最终int请求\连接\设备=1；
私有最终整数请求\启用\ BT=2；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
实例=此；
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
控制台=（TextView）findViewById（R.id.main\u text\u控制台）；
如果（savedInstanceState！=null）{
pendingRequestEnableBt=savedInstanceState.getBoolean（保存的\u挂起的\u请求\u启用\u BT）；
}
bluetoothAdapter=bluetoothAdapter.getDefaultAdapter（）；
if（bluetoothAdapter==null）{
Toast.makeText（这是“没有蓝牙可用”，Toast.LENGTH_LONG.show（）；
}
if（mHandler==null）{
mHandler=新的Bluetooth响应Handler（本）；
}否则{
mHandler.setTarget（本）；
}
}
公共无效setDeviceName（字符串deviceName）{
this.deviceName=deviceName；
getActionBar（）.setSubtitle（deviceName）；
}
@凌驾
SaveInstanceState上受保护的无效（束超出状态）{
super.onSaveInstanceState（超出状态）；
outState.putBoolean（已保存的未决请求启用，未决请求启用）；
outState.putString（“设备名称”，deviceName）；
如果（控制台！=null）{
final String log=console.getText（）.toString（）；
outState.putString（“AC”，log）；
}
}
公共布尔值isAdapterReady（）{
返回（bluetoothAdapter！=null）&&（bluetoothAdapter.isEnabled（））；
}
私有静态类BluetoothResponseHandler扩展处理程序{
私人弱引用活动；
公共蓝牙响应管理员（主要活动）{
mActivity=新的WeakReference（活动）；
}
公共无效设置目标（主活动目标）{
mActivity.clear（）；
mActivity=新的WeakReference（目标）；
}
@凌驾
公共无效handleMessage（消息消息消息）{
MainActivity=mActivity.get（）；
if（活动！=null）{
if（msg.what==MessageType.MESSAGE\u STATE\u CHANGE.getValue（））{
final ActionBar=activity.getActionBar（）；
开关（消息arg1）{
机箱设备连接器.STATE_已连接：
bar.setSubtitle（“Połączono”）；
打破
机箱设备连接器.STATE_连接：
律师事务所名称（“czenie”）；
打破
案例设备连接器.STATE\u无：
bar.setSubtitle（“Rozłączono”）；
打破
}
}else if（msg.what==MessageType.MESSAGE\u READ.getValue（））{
如果（msg.obj！=null）{
activity.appendLog（（字符串）msg.obj）；
}
}else if（msg.what==MessageType.MESSAGE\u DEVICE\u NAME.getValue（））{
activity.setDeviceName（（字符串）msg.obj）；
}
}
}
}
私有void startDeviceListActivity（）{
停止连接（）；
startActivityForResult（新意图（此，DeviceListActivity.class），请求连接设备）；
}
私有void stopConnection（）{
如果（连接器！=null）{
连接器。停止（）；
连接器=空；
}
}
@凌驾
公共布尔值onSearchRequested（）{
if（isAdapterReady（））{
startDeviceListActivity（）；
}
返回false；
}
@凌驾
公共布尔onCreateOptions菜单（菜单）{
getMenuInflater（）.充气（R.menu.device\u control\u activity，menu）；
返回true；
}
@凌驾
受保护的void onActivityResult（int请求代码、int结果代码、意图数据）{
super.onActivityResult（请求代码、结果代码、数据）；
开关（请求代码）{
案例请求\u连接\u设备：
if（resultCode==Activity.RESULT\u确定）{
字符串地址=data.getStringExtra（DeviceListActivity.EXTRA_设备_地址）；
BluetoothDevice=bluetoothAdapter.getRemoteDevice（地址）；
如果（isAdapterReady（）&&（connector==null））设置连接器（设备）；
}
打破
案例请求\u启用\u BT：
pendingRequestEnableBt=false；
if（resultCode！=活动。结果\u确定）{
Toast.makeText（这个“Bt未启用”，Toast.LENGTH_LONG.show（）；
}
打破
}
}
专用void设置连接器（蓝牙设备连接设备）{
停止连接（）；
连接器=新设备连接器（新设备数据（connectedDevice，getString（R.string.empty\u device\u name）），mHandler）；
connector.connect（）；
}
@凌驾
公共布尔值onOptionsItemSelected（菜单项项）{
开关（item.getItemId（））{
案例R.id.菜单搜索：