Android两Activity间通过互引用实现方法调用的通信方案咨询

针对你的场景——两个独立Activity需要互相调用方法，且B作为蓝牙P2P组件不能被startActivityForResult终止，同时无法通过Intent传递实例，我推荐以下几种Java实现方案：

方案1：静态弱引用管理类（直接持有实例引用） #

这个方案最直接，通过一个单例类来持有两个Activity的弱引用，避免强引用导致的内存泄漏，同时能直接调用对方的方法。

步骤1：创建实例管理类 #

public class ActivityInstanceManager {
    private static ActivityInstanceManager instance;
    // 用弱引用避免内存泄漏
    private WeakReference<MapsActivity> mapsActivityRef;
    private WeakReference<myBluetoothActivity> bluetoothActivityRef;

    private ActivityInstanceManager() {}

    public static ActivityInstanceManager getInstance() {
        if (instance == null) {
            instance = new ActivityInstanceManager();
        }
        return instance;
    }

    // 保存MapsActivity实例
    public void setMapsActivity(MapsActivity activity) {
        mapsActivityRef = new WeakReference<>(activity);
    }

    // 获取MapsActivity实例（使用前判空）
    public MapsActivity getMapsActivity() {
        return mapsActivityRef != null ? mapsActivityRef.get() : null;
    }

    // 保存蓝牙Activity实例
    public void setBluetoothActivity(myBluetoothActivity activity) {
        bluetoothActivityRef = new WeakReference<>(activity);
    }

    // 获取蓝牙Activity实例（使用前判空）
    public myBluetoothActivity getBluetoothActivity() {
        return bluetoothActivityRef != null ? bluetoothActivityRef.get() : null;
    }
}

步骤2：在两个Activity中注册实例 #

• 在MapsActivity的onCreate中注册：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_maps);
    // 注册自身实例
    ActivityInstanceManager.getInstance().setMapsActivity(this);
    // ... 其他初始化代码
}

// 在onDestroy中清除引用，避免泄漏
@Override
protected void onDestroy() {
    super.onDestroy();
    ActivityInstanceManager.getInstance().setMapsActivity(null);
}

• 在myBluetoothActivity的onCreate中注册：

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_bluetooth);
    // 注册自身实例
    ActivityInstanceManager.getInstance().setBluetoothActivity(this);
    // ... 其他蓝牙初始化代码
}

@Override
protected void onDestroy() {
    super.onDestroy();
    ActivityInstanceManager.getInstance().setBluetoothActivity(null);
}

步骤3：互相调用方法 #

• 从A启动B后，调用B的方法：

// 在MapsActivity中启动B后
myBluetoothActivity bluetoothActivity = ActivityInstanceManager.getInstance().getBluetoothActivity();
if (bluetoothActivity != null && !bluetoothActivity.isFinishing()) {
    bluetoothActivity.yourBluetoothMethod(parameter);
}

• 从B多次调用A的方法：

// 在myBluetoothActivity中需要调用A时
MapsActivity mapsActivity = ActivityInstanceManager.getInstance().getMapsActivity();
if (mapsActivity != null && !mapsActivity.isFinishing()) {
    mapsActivity.updateMapUI(parameter);
}

注意：每次调用前必须判空，因为弱引用可能被GC回收，或者Activity已经处于销毁状态。

方案2：LocalBroadcastManager（基于消息通信，无直接实例引用） #

如果担心直接持有实例带来的内存泄漏风险，推荐用本地广播来传递事件，在目标Activity中接收广播后执行对应方法，这种方式更符合Android的组件通信规范。

步骤1：定义广播Action常量 #

public class BroadcastConstants {
    public static final String ACTION_FROM_A_TO_B = "com.yourpackage.action.A_TO_B";
    public static final String ACTION_FROM_B_TO_A = "com.yourpackage.action.B_TO_A";
    public static final String EXTRA_PARAM = "extra_param";
}

步骤2：在MapsActivity中注册接收B的广播，并发送给B的广播 #

private BroadcastReceiver bReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (BroadcastConstants.ACTION_FROM_B_TO_A.equals(intent.getAction())) {
            String param = intent.getStringExtra(BroadcastConstants.EXTRA_PARAM);
            // 调用A的方法处理
            updateMapUI(param);
        }
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 注册广播接收器
    LocalBroadcastManager.getInstance(this).registerReceiver(bReceiver,
            new IntentFilter(BroadcastConstants.ACTION_FROM_B_TO_A));
}

// 向B发送消息的方法
private void sendMessageToB(String param) {
    Intent intent = new Intent(BroadcastConstants.ACTION_FROM_A_TO_B);
    intent.putExtra(BroadcastConstants.EXTRA_PARAM, param);
    LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    // 注销广播接收器
    LocalBroadcastManager.getInstance(this).unregisterReceiver(bReceiver);
}

步骤3：在myBluetoothActivity中注册接收A的广播，并发送给A的广播 #

private BroadcastReceiver aReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if (BroadcastConstants.ACTION_FROM_A_TO_B.equals(intent.getAction())) {
            String param = intent.getStringExtra(BroadcastConstants.EXTRA_PARAM);
            // 调用B的方法处理
            handleFromAMessage(param);
        }
    }
};

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 注册广播接收器
    LocalBroadcastManager.getInstance(this).registerReceiver(aReceiver,
            new IntentFilter(BroadcastConstants.ACTION_FROM_A_TO_B));
}

// 向A发送消息的方法
private void sendMessageToA(String param) {
    Intent intent = new Intent(BroadcastConstants.ACTION_FROM_B_TO_A);
    intent.putExtra(BroadcastConstants.EXTRA_PARAM, param);
    LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    // 注销广播接收器
    LocalBroadcastManager.getInstance(this).unregisterReceiver(aReceiver);
}

优点：完全避免了直接持有Activity实例，不会有内存泄漏风险；缺点是需要通过Intent传递参数，不能直接访问成员变量，适合方法调用参数简单的场景。

方案3：共享ViewModel（Jetpack架构推荐方案） #

如果你的项目已经引入Jetpack组件，用共享ViewModel是最优雅的方式，通过Application作为ViewModel的Owner，让两个Activity共享同一个ViewModel实例，利用LiveData传递事件触发方法调用。

步骤1：添加Jetpack依赖（build.gradle） #

dependencies {
    def lifecycle_version = "2.6.2"
    implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
    implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
}

步骤2：创建共享ViewModel #

import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;

public class SharedViewModel extends ViewModel {
    // 从A到B的消息
    private MutableLiveData<String> aToBMessage = new MutableLiveData<>();
    // 从B到A的消息
    private MutableLiveData<String> bToAMessage = new MutableLiveData<>();

    // 发送A到B的消息
    public void sendAToB(String message) {
        aToBMessage.setValue(message);
    }

    // 观察A到B的消息
    public LiveData<String> getAToBMessage() {
        return aToBMessage;
    }

    // 发送B到A的消息
    public void sendBToA(String message) {
        bToAMessage.setValue(message);
    }

    // 观察B到A的消息
    public LiveData<String> getBToAMessage() {
        return bToAMessage;
    }
}

步骤3：在MapsActivity中使用ViewModel #

import androidx.lifecycle.ViewModelProvider;

public class MapsActivity extends AppCompatActivity {
    private SharedViewModel sharedViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_maps);
        // 获取共享ViewModel（用Application作为Owner）
        sharedViewModel = new ViewModelProvider(this.getApplication()).get(SharedViewModel.class);

        // 观察B发送的消息，触发A的方法
        sharedViewModel.getBToAMessage().observe(this, message -> {
            updateMapUI(message);
        });

        // 向B发送消息的示例
        // sharedViewModel.sendAToB("初始化蓝牙参数");
    }

    private void updateMapUI(String message) {
        // 处理地图UI更新
    }
}

步骤4：在myBluetoothActivity中使用ViewModel #

import androidx.lifecycle.ViewModelProvider;

public class myBluetoothActivity extends AppCompatActivity {
    private SharedViewModel sharedViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_bluetooth);
        // 获取共享ViewModel
        sharedViewModel = new ViewModelProvider(this.getApplication()).get(SharedViewModel.class);

        // 观察A发送的消息，触发B的方法
        sharedViewModel.getAToBMessage().observe(this, message -> {
            handleFromAMessage(message);
        });

        // 向A发送消息的示例（比如蓝牙数据更新时）
        // sharedViewModel.sendBToA("蓝牙数据：XXX");
    }

    private void handleFromAMessage(String message) {
        // 处理来自A的指令
    }
}

优点：完全符合Android架构最佳实践，无内存泄漏，生命周期安全；缺点是需要引入Jetpack组件，适合中大型项目。

方案选择建议 #

• 如果需要直接访问成员变量、调用复杂方法，优先选方案1，但务必注意判空和在onDestroy中清除引用；
• 如果追求组件解耦、避免内存泄漏，优先选方案2或方案3，其中方案3是Google推荐的现代化方案。

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