Android非startActivity实现前台跨应用单向通信方案咨询

嘿，这个问题我太有共鸣了！用startActivity()来做进程间通信确实会踩坑——它的核心作用是启动/切换Activity，哪怕目标应用已经在前台，多窗口场景下也可能触发Activity的重建（比如Task栈的状态不符合预期时），直接导致onCreate()被意外调用，完全不是我们要的“静默传值”效果。

给你几个针对这种简单布尔/整型值单向传递的靠谱方案，按需选就行：

这是最轻量化的方案，适合单次通知类的传值需求。

接收端（it.tux.gcs）操作： #

1. 定义一个自定义BroadcastReceiver：

public class MyDataReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        // 接收传递的布尔值
        boolean backwardFlag = intent.getBooleanExtra("BACKWARD_FLAG", false);
        // 这里直接修改应用行为，比如更新UI或状态
        // 注意：onReceive是在主线程执行的，耗时操作要开子线程
    }
}

2. 动态注册广播（推荐在前台Activity的onResume()里注册，onPause()里注销，避免不必要的耗电）：

private MyDataReceiver receiver;

@Override
protected void onResume() {
    super.onResume();
    receiver = new MyDataReceiver();
    IntentFilter filter = new IntentFilter("com.your.package.ACTION_TRANSMIT_DATA");
    registerReceiver(receiver, filter);
}

@Override
protected void onPause() {
    super.onPause();
    if (receiver != null) {
        unregisterReceiver(receiver);
    }
}

发送端操作： #

直接发送显式广播（避免Android 8.0+的隐式广播限制）：

Intent intent = new Intent("com.your.package.ACTION_TRANSMIT_DATA");
// 指定接收端的包名，确保只有目标应用能收到
intent.setPackage("it.tux.gcs");
intent.putExtra("BACKWARD_FLAG", camera.backward);
sendBroadcast(intent);

如果需要接收端能主动监听数据变化（比如持续传值的场景），这个方案更稳定。

接收端（it.tux.gcs）操作： #

1. 自定义ContentProvider，暴露一个Uri用来传递数据：

public class DataProvider extends ContentProvider {
    public static final Uri CONTENT_URI = Uri.parse("content://it.tux.gcs.dataprovider/flag");

    @Override
    public boolean onCreate() {
        return true;
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        // 这里可以把数据存在本地（比如SQLite），或者直接通知观察者
        getContext().getContentResolver().notifyChange(uri, null);
        return uri;
    }

    // 实现其他必要的方法（query/update/delete），按需简化
}

2. 在AndroidManifest.xml里注册Provider：

<provider
    android:name=".DataProvider"
    android:authorities="it.tux.gcs.dataprovider"
    android:exported="true" />

3. 在前台Activity里注册ContentObserver监听数据变化：

private ContentObserver observer;

@Override
protected void onResume() {
    super.onResume();
    observer = new ContentObserver(new Handler(Looper.getMainLooper())) {
        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);
            // 查询最新的布尔值
            Cursor cursor = getContentResolver().query(DataProvider.CONTENT_URI, null, null, null, null);
            if (cursor != null && cursor.moveToFirst()) {
                boolean backwardFlag = cursor.getInt(cursor.getColumnIndex("BACKWARD_FLAG")) == 1;
                // 更新应用行为
                cursor.close();
            }
        }
    };
    getContentResolver().registerContentObserver(DataProvider.CONTENT_URI, true, observer);
}

@Override
protected void onPause() {
    super.onPause();
    if (observer != null) {
        getContentResolver().unregisterContentObserver(observer);
    }
}

发送端操作： #

通过ContentResolver插入数据：

ContentValues values = new ContentValues();
values.put("BACKWARD_FLAG", camera.backward ? 1 : 0);
getContentResolver().insert(Uri.parse("content://it.tux.gcs.dataprovider/flag"), values);

如果后续可能扩展更多传值需求，AIDL是最规范的跨进程通信方式，虽然稍显繁琐，但稳定性拉满。

接收端（it.tux.gcs）操作： #

1. 创建AIDL文件IDataTransmit.aidl：

package it.tux.gcs;

interface IDataTransmit {
    void setBackwardFlag(boolean flag);
}

2. 实现AIDL接口的Service：

public class TransmitService extends Service {
    private final IDataTransmit.Stub binder = new IDataTransmit.Stub() {
        @Override
        public void setBackwardFlag(boolean flag) throws RemoteException {
            // 这里直接处理传过来的布尔值，更新应用状态
            // 注意：这个方法是在Binder线程池执行的，更新UI要切主线程
            runOnUiThread(() -> {
                // 比如修改全局变量或UI元素
            });
        }
    };

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return binder;
    }
}

3. 在AndroidManifest.xml里注册Service：

<service
    android:name=".TransmitService"
    android:exported="true">
    <intent-filter>
        <action android:name="it.tux.gcs.action.DATA_TRANSMIT" />
    </intent-filter>
</service>

发送端操作： #

绑定服务并调用方法：

private IDataTransmit dataTransmit;
private ServiceConnection connection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        dataTransmit = IDataTransmit.Stub.asInterface(service);
        try {
            dataTransmit.setBackwardFlag(camera.backward);
            // 传值完成后可以解绑服务，避免长期绑定
            unbindService(this);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        dataTransmit = null;
    }
};

// 绑定服务的代码，比如在按钮点击或需要传值时调用
Intent intent = new Intent();
intent.setAction("it.tux.gcs.action.DATA_TRANSMIT");
intent.setPackage("it.tux.gcs");
bindService(intent, connection, Context.BIND_AUTO_CREATE);

• 别用SharedPreferences跨进程传值：虽然可以设置MODE_MULTI_PROCESS，但这个模式在API 23后就被废弃了，而且跨进程读写SP很容易出现数据不一致的问题，不推荐。
• 广播要慎用隐式：Android 8.0+对隐式广播做了严格限制，除非是系统广播，否则一定要用显式广播（指定包名或ComponentName），否则接收端收不到。

内容的提问来源于stack exchange，提问作者weirdgyn