Menggunakan banner adaptif inline untuk banner yang dapat di-scroll

Banner adaptif adalah generasi iklan responsif berikutnya, yang memaksimalkan performa dengan mengoptimalkan ukuran iklan untuk setiap perangkat. Demi menyempurnakan banner ukuran tetap, yang hanya mendukung tinggi tetap, banner adaptif membebaskan developer menentukan lebar iklan sehingga mereka dapat menentukan ukuran iklan yang optimal.

Untuk memilih ukuran iklan terbaik, banner adaptif inline menggunakan tinggi maksimum, bukan tinggi tetap. Hal ini akan memberikan peluang untuk meningkatkan performa.

Kapan harus menggunakan banner adaptif inline

Banner adaptif inline adalah banner yang lebih besar dan lebih tinggi dibandingkan dengan banner adaptif anchor. Tingginya variabel, dan dapat setinggi layar perangkat.

Banner ini dimaksudkan untuk ditempatkan dalam konten yang dapat di-scroll, misalnya:

Prasyarat

Sebelum memulai

Saat menerapkan banner adaptif di aplikasi Anda, perhatikan poin-poin berikut:

  • Pastikan Anda menggunakan versi terbaru Google Mobile Ads Flutter Plugin, dan jika menggunakan mediasi, gunakan adaptor mediasi versi terbaru.

  • Ukuran banner adaptif inline dirancang agar berfungsi optimal saat menggunakan lebar penuh yang tersedia. Dalam kebanyakan kasus, ukurannya adalah lebar penuh layar perangkat yang digunakan. Pastikan untuk mempertimbangkan area aman yang berlaku.

  • Anda mungkin perlu memperbarui atau membuat item baris baru agar dapat menggunakan ukuran adaptif. Pelajari lebih lanjut.

  • Metode untuk mendapatkan ukuran iklan adalah

    • AdSize.getCurrentOrientationInlineAdaptiveBannerAdSize(int width)
    • AdSize.getLandscapeInlineAdaptiveBannerAdSize(int width)
    • AdSize.getPortraitInlineAdaptiveBannerAdSize(int width)
    • AdSize.getInlineAdaptiveBannerAdSize(int width, int maxHeight)
  • Saat menggunakan API banner adaptif inline, Google Mobile Ads Flutter Plugin akan menampilkan AdSize dengan lebar yang diberikan dan flag inline. Tingginya adalah nol atau maxHeight, bergantung pada API yang Anda gunakan. Tinggi iklan yang sebenarnya akan tersedia saat iklan ditampilkan.

  • Banner adaptif inline dirancang untuk ditempatkan dalam konten yang dapat di-scroll. Tinggi banner dapat setinggi layar perangkat atau dibatasi oleh tinggi maksimum, bergantung pada API.

Penerapan

Ikuti langkah-langkah di bawah untuk menerapkan banner adaptif inline sederhana.

  1. Dapatkan ukuran iklan banner adaptif inline. Ukuran yang Anda dapatkan akan digunakan untuk meminta banner adaptif. Untuk mendapatkan ukuran iklan adaptif, pastikan Anda:
    1. Mendapatkan lebar layar perangkat yang digunakan dalam piksel independen kepadatan, atau menetapkan lebar Anda sendiri jika tidak ingin menggunakan lebar maksimal layar perangkat. Anda dapat menggunakan MediaQuery.of(context) untuk mendapatkan lebar layar.
    2. Menggunakan metode statis yang sesuai terkait class ukuran iklan, seperti AdSize.getCurrentOrientationInlineAdaptiveBannerAdSize(int width) guna mendapatkan objek adaptif inline AdSize untuk orientasi saat ini.
    3. Jika ingin membatasi tinggi banner, Anda dapat menggunakan metode statis AdSize.getInlineAdaptiveBannerAdSize(int width, int maxHeight).
  2. Buat objek AdManagerBannerAd dengan ID unit iklan, ukuran iklan adaptif, dan objek permintaan iklan.
  3. Muat iklan.
  4. Dalam callback onAdLoaded, gunakan AdManagerBannerAd.getPlatformAdSize() untuk mendapatkan ukuran iklan platform yang diperbarui dan memperbarui tinggi penampung AdWidget.

Contoh kode

Berikut adalah contoh widget yang memuat banner adaptif inline agar sesuai dengan lebar layar, dengan mempertimbangkan inset:

import 'package:flutter/material.dart';
import 'package:google_mobile_ads/google_mobile_ads.dart';

/// This example demonstrates inline adaptive banner ads.
///
/// Loads and shows an inline adaptive banner ad in a scrolling view,
/// and reloads the ad when the orientation changes.
class InlineAdaptiveExample extends StatefulWidget {
  @override
  _InlineAdaptiveExampleState createState() => _InlineAdaptiveExampleState();
}

class _InlineAdaptiveExampleState extends State<InlineAdaptiveExample> {
  static const _insets = 16.0;
  AdManagerBannerAd? _inlineAdaptiveAd;
  bool _isLoaded = false;
  AdSize? _adSize;
  late Orientation _currentOrientation;

  double get _adWidth => MediaQuery.of(context).size.width - (2 * _insets);

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    _currentOrientation = MediaQuery.of(context).orientation;
    _loadAd();
  }

  void _loadAd() async {
    await _inlineAdaptiveAd?.dispose();
    setState(() {
      _inlineAdaptiveAd = null;
      _isLoaded = false;
    });

    // Get an inline adaptive size for the current orientation.
    AdSize size = AdSize.getCurrentOrientationInlineAdaptiveBannerAdSize(
        _adWidth.truncate());

    _inlineAdaptiveAd = AdManagerBannerAd(
      // TODO: replace with your own ad unit.
      adUnitId: '/21775744923/example/adaptive-banner',
      size: size,
      request: AdManagerAdRequest(),
      listener: AdManagerBannerAdListener(
        onAdLoaded: (Ad ad) async {
          print('Inline adaptive banner loaded: ${ad.responseInfo}');

          // After the ad is loaded, get the platform ad size and use it to
          // update the height of the container. This is necessary because the
          // height can change after the ad is loaded.
          AdManagerBannerAd bannerAd = (ad as AdManagerBannerAd);
          final AdSize? size = await bannerAd.getPlatformAdSize();
          if (size == null) {
            print('Error: getPlatformAdSize() returned null for $bannerAd');
            return;
          }

          setState(() {
            _inlineAdaptiveAd = bannerAd;
            _isLoaded = true;
            _adSize = size;
          });
        },
        onAdFailedToLoad: (Ad ad, LoadAdError error) {
          print('Inline adaptive banner failedToLoad: $error');
          ad.dispose();
        },
      ),
    );
    await _inlineAdaptiveAd!.load();
  }

  /// Gets a widget containing the ad, if one is loaded.
  ///
  /// Returns an empty container if no ad is loaded, or the orientation
  /// has changed. Also loads a new ad if the orientation changes.
  Widget _getAdWidget() {
    return OrientationBuilder(
      builder: (context, orientation) {
        if (_currentOrientation == orientation &&
            _inlineAdaptiveAd != null &&
            _isLoaded &&
            _adSize != null) {
          return Align(
              child: Container(
            width: _adWidth,
            height: _adSize!.height.toDouble(),
            child: AdWidget(
              ad: _inlineAdaptiveAd!,
            ),
          ));
        }
        // Reload the ad if the orientation changes.
        if (_currentOrientation != orientation) {
          _currentOrientation = orientation;
          _loadAd();
        }
        return Container();
      },
    );
  }

  @override
  Widget build(BuildContext context) => Scaffold(
      appBar: AppBar(
        title: Text('Inline adaptive banner example'),
      ),
      body: Center(
        child: Padding(
          padding: const EdgeInsets.symmetric(horizontal: _insets),
          child: ListView.separated(
            itemCount: 20,
            separatorBuilder: (BuildContext context, int index) {
              return Container(
                height: 40,
              );
            },
            itemBuilder: (BuildContext context, int index) {
              if (index == 10) {
                return _getAdWidget();
              }
              return Text(
                'Placeholder text',
                style: TextStyle(fontSize: 24),
              );
            },
          ),
        ),
      ));

  @override
  void dispose() {
    super.dispose();
    _inlineAdaptiveAd?.dispose();
  }
}