mapbox_ad_flutter 0.0.6

mapbox_ad_flutter: ^0.0.6 copied to clipboard

example/lib/main.dart

import 'package:flutter/material.dart';

import 'dart:math' as math;

import 'package:flutter/services.dart';
import 'package:logger/logger.dart';
import 'package:mapbox_maps_flutter/mapbox_maps_flutter.dart' as mbx;
import 'package:mapbox_ad_flutter/mapbox_ad_flutter.dart' as ad;
import 'package:url_launcher/url_launcher.dart';

class MapboxAdApp extends StatefulWidget {
  const MapboxAdApp({super.key});

  @override
  State<MapboxAdApp> createState() => _MapboxAdAppState();
}

class _MapboxAdAppState extends State<MapboxAdApp>
    with WidgetsBindingObserver
    implements ad.MapboxAdCallback {

  /// Server environment
  static const environment = ad.AdsEnvironment.develop;
  static const String accessToken = "MAPBOX_ACCESS_TOKEN";
  static final center =
  mbx.Point(coordinates: mbx.Position(139.776606, 35.682400)).toJson();
  static const zoom = 14.281;
  static const styleUrl =
      "mapbox://styles/mapbox-ads/ckt3mhrk4088z18ponqip6fi6";
  static const platform =
  MethodChannel('com.mapbox.ad.flutter.mapboxAdFlutterExample');

  BuildContext? _context;
  final _adManager = ad.MapboxAdManager();
  mbx.MapWidget? _mapView;
  ad.MapboxAdConfiguration? _config;
  final _logger = Logger();

  _onMapCreated(mbx.MapboxMap mapboxMap) {
    _adManager.onMapCreated(mapboxMap);
  }

  _onStyleLoadedListener(mbx.StyleLoadedEventData? data) {
    _adManager.onStyleLoadedCallback();

    // Load ads
    _loadAds();
  }

  _onMapIdle(mbx.CameraChangedEventData? data) {
    _adManager.onMapIdle();
  }

  _onCameraIdle(mbx.MapIdleEventData? data) {
    _adManager.onCameraIdle();
  }

  _onMapClick(mbx.ScreenCoordinate coordinate) {
    _adManager.onMapClick(math.Point(coordinate.x, coordinate.y));
  }

  _loadAds() {
    if (_context == null || _config == null) return;
    final mediaQueryData = MediaQuery.of(_context!);
    _adManager.loadAds(_mapView, null, mediaQueryData, configuration: _config);
    _adManager.callback = this;
  }

  Future<String> _getMapboxAccessToken() async {
    String token = '';
    try {
      token = await platform.invokeMethod('getMapboxAccessToken');
    } on PlatformException catch (e) {
      _logger.d("Failed to get mapbox access token: '${e.message}'.");
    }
    return token;
  }

  _getConfiguration(String accessToken) {
    final rootConfig = ad.MapboxAdRootConfiguration();
    rootConfig.sdk.adServer = ad.MapboxAdServerConfiguration.init(environment);
    rootConfig.sdk.eventTrack =
        ad.MapboxEventTrackConfiguration.init(environment);
    rootConfig.sdk.token = accessToken;
    final config = ad.MapboxAdConfiguration(rootConfig);
    config.mediaID = "12x-dev-media";
    return config;
  }

  _buildMapboxMap(String token) {
    if (_context == null) return;
    var accessToken = token.isEmpty ? _MapboxAdAppState.accessToken : token;
    // var accessToken = _MapboxAdAppState.accessToken;
    _config = _getConfiguration(accessToken);
    final mbx.MapWidget mapWidget = mbx.MapWidget(
        key: const ValueKey("mapWidget"),
        resourceOptions: mbx.ResourceOptions(accessToken: accessToken),
        cameraOptions:
        mbx.CameraOptions(center: center, zoom: zoom),
        styleUri: styleUrl,
        onMapCreated: _onMapCreated,
        onStyleLoadedListener: _onStyleLoadedListener,
        onCameraChangeListener: _onMapIdle,
        onMapIdleListener: _onCameraIdle,
        onTapListener: _onMapClick);
    _mapView = mapWidget;
  }

  @override
  onAdDidSelect(ad.MapboxAdMBPCardView view, ad.MapboxAd mapboxAd) {
    if (_context != null) view.attach(_context!);
    _logger.d("onAdDidSelect");
  }

  @override
  onAdDidDeselect(ad.MapboxAdMBPCardView view) {
    if (_context != null) view.detach(_context!);
    _logger.d("onAdDidDeselect");
  }

  @override
  onAdShowAttribution(ad.MapboxAdAttributionView view) {
    if (_context != null) view.attach(_context!);
    _logger.d("onAdShowAttribution");
  }

  @override
  onAdCloseAttribution(ad.MapboxAdAttributionView view) {
    _logger.d("onAdCloseAttribution");
  }

  _showAlert(String title, String message) {
    return showDialog<void>(
      context: context,
      builder: (BuildContext context) {
        return AlertDialog(
          title: Text(title),
          content: Text(message),
          actions: <Widget>[
            TextButton(
              style: TextButton.styleFrom(
                textStyle: Theme.of(context).textTheme.labelLarge,
              ),
              child: const Text('OK'),
              onPressed: () {
                Navigator.of(context).pop();
              },
            ),
          ],
        );
      },
    );
  }

  Future<void> _launchUrl(String url) async {
    try {
      final uri = Uri.parse(url);
      await launchUrl(uri);
    } catch (e) {
      _logger.e(e);
    }
  }

  @override
  onAdDidTapCardAction(ad.MapboxAdMBPCardTapAction action, ad.MapboxAd mapboxAd,
      {String url = ''}) async {
    switch (action) {
      case ad.MapboxAdMBPCardTapAction.navigation:
        _showAlert("Open navigation", "name:${mapboxAd.name}");
        break;
      case ad.MapboxAdMBPCardTapAction.route:
        _showAlert("Open route", "name:${mapboxAd.name}");
        break;
      case ad.MapboxAdMBPCardTapAction.businessHours:
        _logger.d("Taped business hours: ${mapboxAd.name}");
        break;
      case ad.MapboxAdMBPCardTapAction.address:
        _showAlert("Open address", "name:${mapboxAd.address}");
        break;
      case ad.MapboxAdMBPCardTapAction.externalLinkBanner:
        await _launchUrl(mapboxAd.url.toString());
        break;
      case ad.MapboxAdMBPCardTapAction.externalLinkDetailSite:
        await _launchUrl(url);
        break;
      case ad.MapboxAdMBPCardTapAction.externalLinkCall:
        await _launchUrl(url);
        break;
      case ad.MapboxAdMBPCardTapAction.externalLinkCallAttributionLink:
        await _launchUrl(url);
        break;
    }
  }

  @override
  onAdDidTransitionCard(ad.MapboxAdMBPCardTransition state) {
    switch (state) {
      case ad.MapboxAdMBPCardTransition.collapsed:
        _logger.d("collapsed");
        break;
      case ad.MapboxAdMBPCardTransition.expanded:
        _logger.d("expanded");
        break;
      case ad.MapboxAdMBPCardTransition.closed:
        _logger.d("closed");
        break;
    }
  }

  /// App Lifecycle
  @override
  void initState() {
    WidgetsBinding.instance.addObserver(this);
    super.initState();
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    switch (state) {
      case AppLifecycleState.resumed:
        _adManager.onResume();
        break;
      case AppLifecycleState.inactive:
        break;
      case AppLifecycleState.paused:
        _adManager.onPause();
        break;
      case AppLifecycleState.detached:
        break;
    }
  }

  @override
  Widget build(BuildContext context) {
    _context = context;
    return Scaffold(
        body: FutureBuilder<String>(
          future: _getMapboxAccessToken(),
          builder: (context, snapshot) {
            _context = context;
            if (snapshot.hasData) {
              _buildMapboxMap(snapshot.data!);
              return Scaffold(body: _mapView);
            } else if (snapshot.hasError) {
              return Text('${snapshot.error}');
            }
            return const Center(
              child: CircularProgressIndicator(),
            );
          },
        ));
  }
}

void main() {
  runApp(const MaterialApp(home: MapboxAdApp()));
}