Flutter插件开发问题：无法解析startActivityForResult方法

嘿，我明白你遇到的问题了！你现在的插件类只实现了FlutterPlugin和MethodCallHandler，但startActivityForResult是Activity类的方法，你的插件目前没有持有Activity的引用，而且onActivityResult也不是FlutterPlugin的回调方法，所以才会报错。

要解决这个问题，咱们需要让插件实现ActivityAware接口，通过这个接口获取到Activity的实例，同时正确处理Activity的生命周期，还要注意避免内存泄漏。下面是完整的修正方案：

步骤1：修改插件类实现ActivityAware接口 #

首先，让你的MyPlugin类实现ActivityAware接口，这个接口会提供绑定/解绑Activity的回调方法，咱们可以在这些方法里保存/释放Activity的引用。

步骤2：使用WeakReference保存Activity和Result #

为了避免内存泄漏，咱们用WeakReference来持有Activity和Result的引用，这样当Activity被销毁时，插件不会阻止它被GC回收。

完整修正后的代码 #

import android.app.Activity;
import android.content.Intent;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import io.flutter.embedding.engine.plugins.FlutterPlugin;
import io.flutter.embedding.engine.plugins.activity.ActivityAware;
import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding;
import io.flutter.plugin.common.MethodCall;
import io.flutter.plugin.common.MethodChannel;
import io.flutter.plugin.common.MethodChannel.Result;
import java.lang.ref.WeakReference;

public class MyPlugin implements FlutterPlugin, MethodCallHandler, ActivityAware {
    private static final int REQUEST_CODE = 1;
    private static final String TAG = "MyPlugin";
    private MethodChannel channel;
    private WeakReference<Activity> activityWeakRef;
    private WeakReference<Result> resultWeakRef;

    @Override
    public void onAttachedToEngine(@NonNull FlutterPluginBinding flutterPluginBinding) {
        channel = new MethodChannel(flutterPluginBinding.getBinaryMessenger(), "my_plugin");
        channel.setMethodCallHandler(this);
    }

    @Override
    public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) {
        channel.setMethodCallHandler(null);
        channel = null;
    }

    @Override
    public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
        resultWeakRef = new WeakReference<>(result);
        if (call.method.equals("myMethod")) {
            myMethod();
        } else {
            result.notImplemented();
        }
    }

    private void myMethod() {
        Activity activity = activityWeakRef != null ? activityWeakRef.get() : null;
        if (activity != null) {
            // 这里替换成你的Intent实例
            Intent intent = new Intent();
            // 使用Activity实例调用startActivityForResult
            activity.startActivityForResult(intent, REQUEST_CODE);
        } else {
            Result result = resultWeakRef != null ? resultWeakRef.get() : null;
            if (result != null) {
                result.error("NO_ACTIVITY", "No activity attached to plugin", null);
            }
        }
    }

    // ---------------------- ActivityAware 接口实现 ----------------------
    @Override
    public void onAttachedToActivity(@NonNull ActivityPluginBinding binding) {
        activityWeakRef = new WeakReference<>(binding.getActivity());
        // 注册ActivityResult回调
        binding.addActivityResultListener((requestCode, resultCode, data) -> {
            handleActivityResult(requestCode, resultCode, data);
            return false;
        });
    }

    @Override
    public void onDetachedFromActivityForConfigChanges() {
        onDetachedFromActivity();
    }

    @Override
    public void onReattachedToActivityForConfigChanges(@NonNull ActivityPluginBinding binding) {
        onAttachedToActivity(binding);
    }

    @Override
    public void onDetachedFromActivity() {
        activityWeakRef = null;
        resultWeakRef = null; // 清空Result引用，避免内存泄漏
    }

    // 处理ActivityResult
    private void handleActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        Result result = resultWeakRef != null ? resultWeakRef.get() : null;
        if (result == null) {
            Log.w(TAG, "Result reference has been garbage collected");
            return;
        }
        try {
            if (requestCode == REQUEST_CODE) {
                if (resultCode == Activity.RESULT_OK) {
                    // 这里可以处理返回的数据，比如从data中获取结果
                    result.success("done");
                } else {
                    result.error("CANCELLED", "Activity result was cancelled", null);
                }
            } else {
                result.error("UNKNOWN_REQUEST", "Unknown request code", null);
            }
        } catch (Exception e) {
            Log.e(TAG, "Exception handling activity result: " + e.toString());
            result.error("EXCEPTION", e.getMessage(), null);
        } finally {
            resultWeakRef = null; // 使用后清空Result引用
        }
    }
}

关键说明 #

• ActivityAware接口：通过这个接口，插件可以在Activity绑定的时候获取到Activity实例，并且注册ActivityResult的监听器（用binding.addActivityResultListener）。
• WeakReference：用它来持有Activity和Result，防止插件持有强引用导致内存泄漏，特别是当Activity被销毁或者配置变化（比如旋转屏幕）时。
• Result的生命周期：在处理完ActivityResult后要清空Result的引用，避免它被长时间持有导致内存泄漏。
• 错误处理：在没有Activity绑定的情况下调用方法时，要返回明确的错误信息，避免崩溃。

这样修改后，你的插件就能正确调用startActivityForResult并处理返回结果啦！

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