Mediation networks may provide APIs in their own Android and iOS SDKs that allow
for further ads customization. You can call these APIs from dart code by using a
[platform channel](https://flutter.dev/docs/development/platform-integration/platform-channels).

The following sample shows you how to call privacy APIs in AppLovin's
[Android](https://developers.google.com/admob/android/mediation/applovin.md.txt#eu_consent_and_gdpr) and
[iOS](https://developers.google.com/admob/android/mediation/applovin.md.txt#eu_consent_and_gdpr) SDKs from Dart.

## Create a method channel in dart

In your dart code, create a method channel:

```dart
/// Wraps a method channel that makes calls to AppLovin privacy APIs.
class MyMethodChannel {
  final MethodChannel _methodChannel =
      MethodChannel('com.example.mediationexample/mediation-channel');

  /// Sets whether the user is age restricted in AppLovin.
  Future<void> setAppLovinIsAgeRestrictedUser(bool isAgeRestricted) async {
    return _methodChannel.invokeMethod(
      'setIsAgeRestrictedUser',
      {
        'isAgeRestricted': isAgeRestricted,
      },
    );
  }

  /// Sets whether we have user consent for the user in AppLovin.
  Future<void> setHasUserConsent(bool hasUserConsent) async {
    return _methodChannel.invokeMethod(
      'setHasUserConsent',
      {
        'hasUserConsent': hasUserConsent,
      },
    );
  }
}
```

## Modify your Android code

Set up a method channel to make API calls to the AppLovin SDK in Android:

```java
public class MainActivity extends FlutterActivity {
  private static final String CHANNEL_NAME =
    "com.example.mediationexample/mediation-channel";

  @Override
  public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
    super.configureFlutterEngine(flutterEngine);

    // Set up a method channel for calling APIs in the AppLovin SDK.
    new MethodChannel(flutterEngine.getDartExecutor().getBinaryMessenger(), CHANNEL)
        .setMethodCallHandler(
          (call, result) -> {
            switch (call.method) {
              case "setIsAgeRestrictedUser":
                AppLovinPrivacySettings.setIsAgeRestrictedUser(call.argument("isAgeRestricted"), context);
                result.success(null);
                break;
              case "setHasUserConsent":
                AppLovinPrivacySettings.setHasUserConsent(call.argument("hasUserConsent"), context);
                result.success(null);
                break;
              default:
                result.notImplemented();
                break;
            }
          }
        );
  }
}
```

## Modify your iOS code

Set up a method channel to make API calls to the AppLovin SDK in iOS:

```objective-c
@implementation AppDelegate

- (BOOL)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [GeneratedPluginRegistrant registerWithRegistry:self];

  // Set up a method channel for calling methods in 3P SDKs.
  FlutterViewController* controller = (FlutterViewController*)self.window.rootViewController;

  FlutterMethodChannel* methodChannel = [FlutterMethodChannel
                                          methodChannelWithName:@"com.example.mediationexample/mediation-channel"
                                          binaryMessenger:controller.binaryMessenger];
  [methodChannel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
    if ([call.method isEqualToString:@"setIsAgeRestrictedUser"]) {
      [ALPrivacySettings setIsAgeRestrictedUser:call.arguments[@"isAgeRestricted"]];
      result(nil);
    } else if ([call.method isEqualToString:@"setHasUserConsent"]) {
      [ALPrivacySettings setHasUserConsent:call.arguments[@"hasUserConsent"]];
      result(nil);
    } else {
      result(FlutterMethodNotImplemented);
    }
  }];
}
@end
```

## Use your MethodChannel in Dart

Now you can use your `MyMethodChannel` to call AppLovin privacy APIs from Dart:

```dart
/// An example widget for the home page of your app.
class HomePage extends StatefulWidget {
  @override
  _HomePageState createState() => _HomePageState();
}

class _HomePageState extends State<HomePage> {
  // Keep a reference to your MyMethodChannel.
static MyMethodChannel platform = MyMethodChannel();
  @override
  void initState() {
    super.initState();

    _updateAppLovinSettingsAndLoadAd();
  }
  Future\<void\> _updateAppLovinSettingsAndLoadAd() async {
// Update the AppLovin settings before loading an ad.
await platform.setAppLovinIsAgeRestrictedUser(true);
await platform.setHasUserConsent(false);
_loadAd();
}
  void _loadAd() {
    // TODO: Load an ad.
  };

  @override
  Widget build(BuildContext context) {
    // TODO: Build your widget.
  }
}
```

More details on the APIs supported by other networks can be found
in the [Android](https://developers.google.com/admob/android/choose-networks.md.txt#network_details) and
[iOS](https://developers.google.com/admob/ios/choose-networks.md.txt#network_details) documentation.