Android UI线程停止从其他线程更新

Question

我正在编写一个Android应用程序，它连接到蓝牙设备，读取设备发送的数据，将其添加到AChartEngine图形中，并在文本视图中显示数据。

我的Bluetooth代码与BluetoothChat示例代码中的线程实现非常相似(它与SDK一起提供)。我可以在LogCat中看到< code>ConnectedThread循环正在执行并因此获得新数据，但我的TextView在7行之后停止更新，图形间歇暂停(更不用说它只是间歇地响应交互)。LogCat中没有显示任何错误。此外，如果我删除图形，文本视图的问题仍然存在。

为什么从我的其他线程更新时，我的UI线程不工作？

下面是我的代码的相关部分。通过蓝牙发送的每个字符串都在ConnectedThread中接收并发送到BluetoothController.addToGraph（），然后运行NewPointAsyncTask来自查看器类。

private class ConnectedThread extends Thread {
    public ConnectedThread(BluetoothSocket socket, String socketType) { ... } // Initialize input and output streams here

    public void run() {
        while (true) {
            Log.i(TAG, "READ mConnectedThread");
            // Read from the InputStream
            byte[] buffer = new byte[1024];
            bytes = mmInStream.read(buffer);

            // Send the obtained bytes to the UI Activity
            mHandler.obtainMessage(BluetoothController.MESSAGE_READ, bytes, -1, buffer)
                    .sendToTarget();
            Log.i(TAG, "LOOPEND mConnectedThread");
        }
    }
}
public class BluetoothController extends Activity {
    private viewer plotter;
    public static final int MESSAGE_READ = 2;
    // The Handler that gets information back from the BluetoothClass
    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_READ:
                    byte[] readBuf = (byte[]) msg.obj;
                    // construct a string from the valid bytes in the buffer
                    String readMessage = new String(readBuf, 0, msg.arg1);
                    addToGraph(readMessage);
                    break;
            }
        }
    };

    protected void addToGraph(String result) {
        // process the string, create doubles x and y that correspond to a point (x,y)
        plotter.new NewPoints().execute(x, y);
    }
}
public class viewer extends Activity {
    // initialize graph, etc.

    @Override
    protected void onResume() {
        // Create handlers for textview
        textHandler = new Handler();

        // Set scrolling for textview
        myTextView.setMovementMethod(new ScrollingMovementMethod());

    protected class NewPoints extends AsyncTask<Double, Void, Void> {
        @Override
        protected Void doInBackground(Double... values) {
            mCurrentSeries.add(values[0], values[1]); // x, y

            if (mChartView != null) {
                mChartView.repaint();
            }

            final Double[] messages = values;
            textHandler.post(new Runnable() {
                @Override
                public void run() {
                    myTextView.append("(" + messages[0].toString() + ", " + messages[1].toString() + ") \n");
                }
            });

            return null;
        }
    }
}

什么原因？如果需要更多代码，请告诉我。

Answer 1

我也在使用achatengine和AsynkTask编写类似的应用程序。您应该在 doInBackground 中管理蓝牙，并在收到新的数据调用 publishProgress 时更新您的 UI（TextView 和 Achartengine）onProgressUpdate 方法。doInBackground应该永远不会更新UI，奇怪的是它实际上适合你！如果您使用“低”刷新来绘制实时数据，则可以使用。如果没有，我建议将蓝牙部分实现为服务，并将您的数据广播到管理和更新UI的活动。如果您收到大量数据，您会发现通过广播发送数据会限制您的吞吐量，因为您必须使数据类可包裹，这非常慢，并且您很快就会遇到Android的绑定器算法的限制，该算法用于“Localmanager.sendbroadcast”。我发现与服务通信的最有效方法是通过使用处理程序。

如果您打算使用achartEngine进行快速实时绘图，您应该首先检查我在此处提出的关于稍后会发现的问题的一个问题：achartEngine准备好进行实时绘图了吗？

Answer 2

当然，这里有一个来自Dropbox api的，展示了如何在任务在后台执行通信工作时实现进度条。您必须出于自己的恶意目的对其进行修改，但这是后台任务的一个很好的例子。

 /**
 * Here we show uploading a file in a background thread, trying to show
 * typical exception handling and flow of control for an app that uploads a
 * file
 */
public class UploadFile extends AsyncTask<Void, Long, Boolean> {

    private DropboxAPI<?> mApi;
    private File mFile;

    private long mFileLen;
    private UploadRequest mRequest;
    private Context mContext;
    private final ProgressDialog mDialog;

    private String mErrorMsg;



public UploadFile(Context context, DropboxAPI<?> api, File file) {
    // We set the context this way so we don't accidentally leak activities
    mContext = context.getApplicationContext();

    mFileLen = file.length();
    mApi = api;
    mFile = file;

    mDialog = new ProgressDialog(context);
    mDialog.setMax(100);
    mDialog.setMessage("Uploading " + file.getName());
    mDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
    mDialog.setProgress(0);
    mDialog.setButton(Dialog.BUTTON_POSITIVE ,(CharSequence) "Cancel", new Dialog.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            // This will cancel the putFile operation
            mRequest.abort();
        }
    });
    mDialog.show();
}

@Override
protected Boolean doInBackground(Void... params) {
    try {
        // By creating a request, we get a handle to the putFile operation,
        // so we can cancel it later if we want to
        FileInputStream fis = new FileInputStream(mFile);
        String path = mFile.getName();
        mRequest = mApi.putFileOverwriteRequest(path, fis, mFile.length(),
                new ProgressListener() {
            @Override
            public long progressInterval() {
                // Update the progress bar every half-second or so
                return 500;
            }

            @Override
            public void onProgress(long bytes, long total) {
                publishProgress(bytes);
            }
        });

        if (mRequest != null) {
            mRequest.upload();
            return true;
        }

    } catch (DropboxUnlinkedException e) {
        // This session wasn't authenticated properly or user unlinked
        mErrorMsg = "This app wasn't authenticated properly.";
    } catch (DropboxFileSizeException e) {
        // File size too big to upload via the API
        mErrorMsg = "This file is too big to upload";
    } catch (DropboxPartialFileException e) {
        // We canceled the operation
        mErrorMsg = "Upload canceled";
    } catch (DropboxServerException e) {
        // Server-side exception.  These are examples of what could happen,
        // but we don't do anything special with them here.
        if (e.error == DropboxServerException._401_UNAUTHORIZED) {
            // Unauthorized, so we should unlink them.  You may want to
            // automatically log the user out in this case.
        } else if (e.error == DropboxServerException._403_FORBIDDEN) {
            // Not allowed to access this
        } else if (e.error == DropboxServerException._404_NOT_FOUND) {
            // path not found (or if it was the thumbnail, can't be
            // thumbnailed)
        } else if (e.error == DropboxServerException._507_INSUFFICIENT_STORAGE) {
            // user is over quota
        } else {
            // Something else
        }
        // This gets the Dropbox error, translated into the user's language
        mErrorMsg = e.body.userError;
        if (mErrorMsg == null) {
            mErrorMsg = e.body.error;
        }
    } catch (DropboxIOException e) {
        // Happens all the time, probably want to retry automatically.
        mErrorMsg = "Network error.  Try again.";
    } catch (DropboxParseException e) {
        // Probably due to Dropbox server restarting, should retry
        mErrorMsg = "Dropbox error.  Try again.";
    } catch (DropboxException e) {
        // Unknown error
        mErrorMsg = "Unknown error.  Try again.";
    } catch (FileNotFoundException e) {
    }
    return false;
}

@Override
protected void onProgressUpdate(Long... progress) {
    int percent = (int)(100.0*(double)progress[0]/mFileLen + 0.5);
    mDialog.setProgress(percent);
}

@Override
protected void onPostExecute(Boolean result) {
    mDialog.dismiss();
    if (result) {
        showToast("File successfully uploaded");
    } else {
        showToast(mErrorMsg);
    }
}

Answer 3

对我来说似乎倒退了...您的 AsyncTask 正在更新文本视图和当前系列，但 AsyncTask 应该用于长时间运行的任务，例如与其他设备/网络通信。你的UI线程应该执行文本视图的更新，而你已经反过来了

doInbackground应该包含与您的BlueT设备对话的代码