在已显示的活动数据时刷新其数据

Question

我公司生产制造设备。该设备由PC控制，PC与运行我们的应用程序(比如:智能手机)的安卓设备在工厂的WiFi上进行通信。

大多数工业过程与活动类及其屏幕相关联。工厂工人在“电话”上选择一个，Android向PC发送请求信息，PC发送一个命令和参数，用于启动该活动，并使用意图putExtra填充参数。屏幕在关闭之前不需要从PC上更改或更新。

但是现在我需要一个可以从PC 动态更新的活动，而正在显示它。我已经有一个线程在我的应用程序，接收命令从PC不断。但是，当来自PC的更新到达时，如何从该线程更新我的活动呢？我应该注册某种类型的广播，如果是的话，我的活动应该听什么？我是否可以通过它传递参数，或者是否需要将参数放在某个全球可访问的地方？

Answer 1

您可以使用BroadcastReceiver，您应该在onStart()中注册，在Activity的onStop()中取消注册。

这样，Activity就会知道有一个传入的更新。如果传入数据的大小很小("几KB“，这样就不会在Android 7.0+上冒险使用TransactionTooLargeException )，如果它是由原始数据类型组成的，或者是某种类型的Parcelable或Serializable，那么您可以通过BroadcastReceiver将所有附加的Intent传递给Activity。

另一种可能是保存传入数据(例如，保存到内部存储或SQLite数据库)，并通过BroadcastReceiver通知Activity。然后，Activity可以获取更新。

Answer 2

我已经有一个线程在我的应用程序中，它不断地接收来自PC的命令。

由于您希望从独立的Activity中更改Thread的内容，所以需要实际更改UI-线程上的Activity的内容。您可以在Application中定义一些静态方法，这在本例中可能是有用的：

public class ApplicationLoader extends Application {

    public static volatile Handler applicationHandler;

        @Override
        public void onCreate() {
            super.onCreate();
            applicationHandler = new Handler(getApplicationContext().getMainLooper());
        }

        public static void runOnUIThread(Runnable runnable) {
            applicationHandler.post(runnable);
        }
}

使用runOnUIThread()，您可以在Activity中调用一些方法来更新内容。在你的Thread中调用这个

ApplicationLoader.runOnUIThread(new Runnable() {
    @Override
    public void run() {
        activity.updateMyActivity();
    }
});

如果可以访问Activity的实例，也可以使用内置的runOnUiThread()。上面的解决方案是针对static实例的，但不推荐使用。

编辑

我也有一些很好的观察代码从电报给你：

public class NotificationCenter {

    private static int totalEvents = 1;

    public static final int updateActivity = totalEvents++;

    private final SparseArray<ArrayList<Object>> observers = new SparseArray<>();
    private final SparseArray<ArrayList<Object>> removeAfterBroadcast = new SparseArray<>();
    private final SparseArray<ArrayList<Object>> addAfterBroadcast = new SparseArray<>();

    private int broadcasting = 0;

    public interface NotificationCenterDelegate {
        void didReceivedNotification(int id, Object... args);
    }

    private static volatile NotificationCenter Instance = null;

    public static NotificationCenter getInstance() {
        NotificationCenter localInstance = Instance;
        if (localInstance == null) {
            synchronized (NotificationCenter.class) {
                localInstance = Instance;
                if (localInstance == null) {
                    Instance = localInstance = new NotificationCenter();
                }
            }
        }
        return localInstance;
    }

    public void postNotificationName(final int id, final Object... args) {
        if (Thread.currentThread() == ApplicationLoader.applicationHandler.getLooper().getThread()) {
            postNotificationNameInternal(id, args);
        } else {
            ApplicationLoader.runOnUIThread(new Runnable() {
                @Override
                public void run() {
                    postNotificationNameInternal(id, args);
                }
            });
        }
    }

    private void postNotificationNameInternal(int id, Object... args) {
        broadcasting++;
        ArrayList<Object> objects = observers.get(id);
        if (objects != null && !objects.isEmpty()) {
            for (int a = 0; a < objects.size(); a++) {
                Object obj = objects.get(a);
                ((NotificationCenterDelegate) obj).didReceivedNotification(id, args);
            }
        }
        broadcasting--;
        if (broadcasting == 0) {
            if (removeAfterBroadcast.size() != 0) {
                for (int a = 0; a < removeAfterBroadcast.size(); a++) {
                    int key = removeAfterBroadcast.keyAt(a);
                    ArrayList<Object> arrayList = removeAfterBroadcast.get(key);
                    for (int b = 0; b < arrayList.size(); b++) {
                        removeObserver(arrayList.get(b), key);
                    }
                }
                removeAfterBroadcast.clear();
            }
            if (addAfterBroadcast.size() != 0) {
                for (int a = 0; a < addAfterBroadcast.size(); a++) {
                    int key = addAfterBroadcast.keyAt(a);
                    ArrayList<Object> arrayList = addAfterBroadcast.get(key);
                    for (int b = 0; b < arrayList.size(); b++) {
                        addObserver(arrayList.get(b), key);
                    }
                }
                addAfterBroadcast.clear();
            }
        }
    }

    public void addObserver(Object observer, int id) {
        if (broadcasting != 0) {
            ArrayList<Object> arrayList = addAfterBroadcast.get(id);
            if (arrayList == null) {
                arrayList = new ArrayList<>();
                addAfterBroadcast.put(id, arrayList);
            }
            arrayList.add(observer);
            return;
        }
        ArrayList<Object> objects = observers.get(id);
        if (objects == null) {
            observers.put(id, (objects = new ArrayList<>()));
        }
        if (objects.contains(observer)) {
            return;
        }
        objects.add(observer);
    }

    public void removeObserver(Object observer, int id) {
        if (broadcasting != 0) {
            ArrayList<Object> arrayList = removeAfterBroadcast.get(id);
            if (arrayList == null) {
                arrayList = new ArrayList<>();
                removeAfterBroadcast.put(id, arrayList);
            }
            arrayList.add(observer);
            return;
        }
        ArrayList<Object> objects = observers.get(id);
        if (objects != null) {
            objects.remove(observer);
        }
    }
}

然后让你的Activity看起来像这样：

public class ScheduleActivity implements NotificationCenter.NotificationCenterDelegate {

    @Override
    public void onPause() {
        NotificationCenter.getInstance().removeObserver(this, NotificationCenter.updateActivity);
        super.onPause();
    }

    @Override
    public void onResume() {
        NotificationCenter.getInstance().addObserver(this, NotificationCenter.updateActivity);
        super.onResume();
    }

    @Override
    public void didReceivedNotification(int id, Object... args) {
        if (id == NotificationCenter.updateActivity) {
            // update code, you can also define data in args
        }
    }
}

然后在你的Thread

NotificationCenter.getInstance().postNotificationName(NotificationCenter.updateActivity, optionalData);