BlackBerry类是否等效于AsyncTask？

Question

我的要求是拥有一个线程，该线程可以维护BlackBerry设备与服务器之间的套接字连接并交换命令，类似于请求和响应。

我的问题是，我需要这个线程在后台运行 所有的时间
，并保持提供给用户的UI。因此，当服务器发出命令时，此线程将对其进行解析并更新UI，并且如果BlackBerry用户发出了操作，则该线程会将其发送到服务器，然后服务器将对其进行处理。

我在Android中使用开发了相同的应用程序，AsyncTask并且运行良好。但是在BlackBerry中，因为没有这样的类，所以我使用了invokeLater（）选项。服务器与BB设备之间的通信正常，但是UI在BlackBerry上冻结。

任何人都知道如何正确解决这个问题吗？

Answer 1

Vishal处在正确的轨道上，但要与Android的版本相匹配还需要更多AsyncTask。由于BlackBerry上Java
1.3无法提供枚举和泛型，因此您无法完美匹配Android API。

但是，您可以执行以下操作（未经测试……这只是您的起点）：

import net.rim.device.api.ui.UiApplication;

public abstract class AsyncTask {

    public static final int FINISHED = 0;
    public static final int PENDING = 1;
    public static final int RUNNING = 2;

    private int _status = PENDING;
    private boolean _cancelled = false;
    private Thread _worker;

    /** subclasses MUST implement this method */
    public abstract Object doInBackground(Object[] params);

    protected void onPreExecute() {
        // default implementation does nothing
    }
    protected void onPostExecute(Object result) {
        // default implementation does nothing
    }
    protected void onProgressUpdate(Object[] values) {
        // default implementation does nothing
    }
    protected void onCancelled() {
        // default implementation does nothing
    }
    protected void onCancelled(Object result) {
        onCancelled();
    }

    public final int getStatus() {
        return _status;
    }

    public final boolean isCancelled() {
        return _cancelled;
    }

    public final boolean cancel(boolean mayInterruptIfRunning) {
        if (_status == FINISHED || _cancelled) {
            return false;
        } else {
            _cancelled = true;
            if (mayInterruptIfRunning && _status == RUNNING) {
                // NOTE: calling Thread.interrupt() usually doesn't work
                //   well, unless you don't care what state the background
                //   processing is left in.  I'm not 100% sure that this is how
                //   Android's AsyncTask implements cancel(true), but I 
                //   normally just cancel background tasks by letting the
                //   doInBackground() method check isCancelled() at multiple
                //   points in its processing.
                _worker.interrupt();
            }
            return true;
        }
    }

    protected final void publishProgress(final Object[] values) {
        // call back onProgressUpdate on the UI thread
        UiApplication.getUiApplication().invokeLater(new Runnable() {
            public void run() {
                onProgressUpdate(values);
            }
        });
    }

    private void completeTask(final Object result) {
        // transmit the result back to the UI thread
        UiApplication.getUiApplication().invokeLater(new Runnable() {
            public void run() {
                if (isCancelled()) {
                    onCancelled(result);
                } else {
                    onPostExecute(result);
                }
                // TODO: not sure if status should be FINISHED before or after onPostExecute()
                _status = FINISHED;
            }
        }); 
    }

    public AsyncTask execute(final Object[] params) throws IllegalStateException {
        if (getStatus() != PENDING) {
            throw new IllegalStateException("An AsyncTask can only be executed once!");
        } else {
            try {
                onPreExecute();

                _worker = new Thread(new Runnable() {
                    public void run() {
                        try {
                            // run background work on this worker thread
                            final Object result = doInBackground(params);
                            completeTask(result);
                        } catch (Exception e) {
                            // I believe if Thread.interrupt() is called, we'll arrive here
                            completeTask(null);
                        }
                    }
                });
                _status = RUNNING;
                _worker.start();
            } catch (Exception e) {
                // TODO: handle this exception
            }
        }

        return this;
    }

}

另外，请务必牢记适用于上述实现的Android AsyncTask线程规则：

线程规则 为了使此类正常工作，必须遵循一些线程规则：

• 必须在UI线程上加载AsyncTask类。从JELLY_BEAN开始，这是自动完成的。

• 必须在UI线程上创建任务实例。

• 必须在UI线程上调用execute（Params …）。

• 不要手动调用onPreExecute（），onPostExecute（Result），doInBackground（Params
  …），onProgressUpdate（Progress …）。
  

• 该任务只能执行一次（如果尝试第二次执行，则将引发异常。）