我有一个 Observer Design pattern它使用线程发送我自己的 Events。有时调用的类是 Android Activity ，有时是常规类。线程中的代码不是 Activity 。

我收到这个错误:

Can't create handler inside thread that has not called Looper.prepare()

为了避免运行时错误，我必须在 Thread 中添加 Looper.prepare()。我知道这篇文章:Can't create handler inside thread that has not called Looper.prepare()它包含此类问题的最佳信息，但我仍然不知道如何通过 mjosh 整合答案进入我的主题。

问题

从线程到 Activity 的调用永远不会发生。此代码单独运行时有效，但在 Activity 等待调用时无效。

这个类会向其他类发送事件。这个与线程一起运行。

public class EventBus
{
    // Non essential code here.
    ...
    // Thread code.
    private class MyThread implements Runnable
    {
        @Override
        public void run()
        {
            while(true)
            {
               synchronized(list)
               {
                   for(Observer o : list)
                       // Execution transfers to Activity here.
                      o.handleEvent(event);                   
               }
            }
         } 
     }
}

在 Activity 中。

public class FirstActivity extends Activity implements Observer
{
    public void handleEvent()
    {
      // Never gets here.
    }
}

那么如何解决这个问题呢？我的整个应用程序将有很多 Activity 和许多常规类(class)。

解决我的问题

我需要一种方法来使我的线程保持 Activity 状态并调用 Activity 。这可能是向线程添加一些代码的混合，以便它可以成功地将我的调用发送到 Activity 。

最佳答案

虽然我不为 Android 编程，但我认为在这里做您想做的事情不会那么困难。从您的链接问题中给出的答案来看，问题是您将拥有可能是也可能不是 Activity 的观察者。由于 Activity 线程模型的性质，您不能简单地处理 Activity 上的事件。对于 Activity ，您需要在 UI 线程上完成操作。这听起来很简单。使用 POJO，我在下面组合了一个 SSCCE。唯一真正令人感兴趣的部分是发生在 EventBus 循环中的转换。

public class Test {

    public static void main(String[] args) throws InterruptedException {
        //create the thread to demonstrate execution
        MyThread t = new MyThread();
        //add a non activity observer
        t.addObserver(new NonActivityObserver());
        //add an activity observer
        t.addObserver(new ActivityDecendent());
        //fire off the thread
        new Thread(t).start();
        //give us time to read the output
        Thread.sleep(Long.MAX_VALUE);       
    }


    public static class MyThread implements Runnable
    {
        private ArrayList<Observer> list = new ArrayList<Observer>();

        public void addObserver(Observer arg0) {
            synchronized (list) {
                list.add(arg0);
            }
        }
        @Override
        public void run()
        {
            //no loop just doing this once for example
           synchronized(list)
           {
               for(final Observer o : list) {
                   //first try to cast to an Activity
                   try {
                       Activity act = (Activity)o;
                       //if we get here, its an activity 
                       //so invoke on its UiThread
                       act.runOnUiThread(new Runnable() {

                        @Override
                        public void run() {
                            Event event = new Event("From the activity's runOnUiThread method");
                            o.handleEvent(event);
                        }

                       });
                   }
                   catch (Exception e) {
                       //if we got here, the class is not an activity
                       //so it should be safe to just handle the event
                       //on this thread
                       Event event = new Event("From observers handle event method");
                       o.handleEvent(event);
                   }   
               }                      
           }
         } 
     }

    //your observer interface
    public static interface Observer {
        public void handleEvent(Event e);
    }

    //Your Event class
    public static class Event {
        private String message;
        public Event(String message) {
            this.message = message;
        }
        public void talk() {
            System.out.println(message);
        }
    }

    //An observer which isnt an activity
    public static class NonActivityObserver implements Observer {

        @Override
        public void handleEvent(Event e) {
            e.talk();
        }

    }

    //An activity which implements Observer
    public static class ActivityDecendent extends Activity implements Observer {
        @Override
        public void handleEvent(Event e) {
            e.talk();
        }
    }

    //An Activity 
    public static class Activity {
        //pretend this is the Android activity executing this runnable
        //on the UI thread
        public void runOnUiThread(Runnable r) {
            new Thread(r).start();
        }
    }
}

输出:

From observers handle event method
From the activity's runOnUiThread method

此解决方案有点特定于您的情况，这很糟糕......但我认为这应该可行。

关于java - 如何从非 Activity 线程调用 Activity ？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/25945504/