如何仅在Android平台调用特定方法（无需创建单实现接口）

Absolutely! You don’t need to build out a full interface just for a single Android-specific method—there are several simpler, more lightweight ways to handle this, depending on your project’s tech stack. Let’s break down the most common approaches:

1. Direct expect/actual Functions (Kotlin Multiplatform) #

If you’re using Kotlin Multiplatform, this is the cleanest solution for single-platform methods. Instead of defining an interface with multiple implementations, you can declare a lightweight function pair:

• In your shared code, add an expect function (no body, just the signature):

  expect fun triggerAndroidOnlyAction(context: Context)
  

• In your Android module, provide the actual implementation directly:

  actual fun triggerAndroidOnlyAction(context: Context) {
      // Your Android-specific logic goes here—e.g., show a system toast, access a hardware API
      Toast.makeText(context, "Android-only action triggered!", Toast.LENGTH_SHORT).show()
  }
  

This keeps things tight—no interface bloat, just a direct mapping between shared code and Android-specific logic.

2. Inline Platform Channel Calls (Cross-Platform Frameworks) #

For frameworks like Flutter or React Native, you can call Android methods directly without any interface setup:

Flutter Example #

• On the Android side, register a MethodChannel in your MainActivity and handle the method call inline:

  class MainActivity : FlutterActivity() {
      override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
          super.configureFlutterEngine(flutterEngine)
          MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.myapp/android-actions")
              .setMethodCallHandler { call, result ->
                  if (call.method == "doAndroidThing") {
                      // Execute your Android logic here
                      result.success("Action completed!")
                  } else {
                      result.notImplemented()
                  }
              }
      }
  }
  

• Call it directly from Dart without any interface:

  const platform = MethodChannel('com.myapp/android-actions');
  await platform.invokeMethod('doAndroidThing');
  

React Native Example #

• Create a simple native module (no interface needed) in Android:

  class AndroidActionsModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
      override fun getName() = "AndroidActionsModule"
  
      @ReactMethod
      fun doAndroidThing() {
          // Your Android-specific code here
      }
  }
  

• Invoke it directly from JavaScript:

  import { NativeModules } from 'react-native';
  NativeModules.AndroidActionsModule.doAndroidThing();
  

3. Conditional Compilation & Singleton Objects (Android-Only Projects with Shared Code) #

If you’re working in an Android project that shares some code but this method is strictly Android-exclusive, you can skip interfaces entirely:

Conditional Compilation #

Use compile-time checks to wrap Android-specific logic directly in shared code:

fun sharedBusinessLogic() {
    // Shared code here
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        // Directly call Android-only functionality
        launchAndroidSpecificFeature()
    }
}

@TargetApi(Build.VERSION_CODES.O)
private fun launchAndroidSpecificFeature() {
    // Android-only implementation
}

Singleton Utility Object #

For a set of related Android-only functions, create a singleton object instead of an interface:

object AndroidUtils {
    fun showSystemNotification(context: Context, title: String, message: String) {
        // Android-specific notification logic here
    }
}

// Call it directly wherever you need it:
AndroidUtils.showSystemNotification(requireContext(), "Hello", "Android-only notification!")

This keeps your code organized without the overhead of an interface when you don’t need multiple implementations.

Wrapping Up #

All these approaches let you avoid creating an interface for a single platform implementation. The best fit depends on your project setup, but expect/actual (for KMP) or direct platform channel calls (for cross-platform frameworks) are the go-to solutions for this exact scenario.

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