Ta strona została przetłumaczona przez Cloud Translation API.

Konfigurowanie pakietu IMA SDK na potrzeby DAI

Pakiety IMA SDK ułatwiają integrację reklam multimedialnych z witrynami i aplikacjami. Pakiety IMA SDK mogą żądać reklam z dowolnego serwera reklam zgodnego z VAST i zarządzać odtwarzaniem reklam w aplikacjach. Dzięki pakietom IMA DAI SDK aplikacje wysyłają żądanie strumienia reklamy i treści wideo (VOD lub treści na żywo). Pakiet SDK zwraca połączony strumień wideo, dzięki czemu nie musisz zarządzać przełączaniem się między reklamą a filmem z treściami w aplikacji.

Wybierz interesujące Cię rozwiązanie DAI

Wyświetlanie bloków reklamowych w ramach dynamicznego wstawiania reklam

Ten przewodnik pokazuje, jak zintegrować pakiet IMA DAI SDK z prostym odtwarzaczem wideo. Jeśli chcesz zobaczyć lub prześledzić przykładową integrację, pobierz z GitHub pakiet PodServingExample.

Omówienie dynamicznego wstawiania reklam w IMA

Wdrożenie interfejsu IMA DAI wymaga 4 głównych komponentów pakietu SDK, jak opisano w tym przewodniku:

IMAAdDisplayContainer – obiekt kontenera, który znajduje się nad elementem odtwarzania filmu i zawiera elementy interfejsu reklamy.
IMAAdsLoader – obiekt, który żąda strumieni i obsługuje zdarzenia wywoływane przez obiekty odpowiedzi żądania strumienia. Należy utworzyć tylko 1 ładowarkę reklam, którą można ponownie wykorzystać w trakcie działania aplikacji.
IMAStreamRequest – IMAPodVODStreamRequest lub IMAPodStreamRequest.
IMAStreamManager – obiekt obsługujący strumienie dynamicznego wstawiania reklam i interakcje z backendem DAI. Menedżer strumienia obsługuje też pingi śledzenia i przekazuje wydawcy zdarzenia związane z reklamą i strumieniem.

Dodatkowo, aby odtwarzać strumienie pod, musisz zaimplementować niestandardowy moduł obsługi VTP. Ten niestandardowy moduł obsługi VTP wysyła identyfikator strumienia do Twojego partnera technicznego ds. wideo (VTP) wraz z innymi informacjami, których potrzebuje, aby zwrócić plik manifestu strumienia zawierający zarówno treści, jak i zszyte reklamy. Twój dostawca VTP przekaże Ci instrukcje implementacji niestandardowego modułu obsługi VTP.

Wymagania wstępne

Zanim zaczniesz, musisz mieć:

Xcode 13 lub nowsza
CocoaPods (preferowane), menedżer pakietów Swift lub pobrana kopia pakietu IMA DAI SDK na iOS.

Potrzebujesz też parametrów używanych do żądania strumienia z pakietu IMA SDK.

Parametry transmisji na żywo
Kod sieci	Kod sieci na koncie Ad Managera 360. Przykład: `51636543`
Niestandardowy klucz pliku	Niestandardowy klucz zasobu, który identyfikuje zdarzenie wyświetlania w podgrupie w usłudze Campaign Manager 360. Możesz utworzyć go za pomocą manipulatora pliku manifestu lub zewnętrznego partnera obsługującego bloki reklamowe. Przykład: `google-sample`
Parametry strumienia VOD
Kod sieci	Kod sieci na koncie Ad Managera 360. Przykład: `51636543`

Tworzenie nowego projektu Xcode

W Xcode utwórz nowy projekt na iOS w języku Objective-C o nazwie „PodawaniePlikówZPoduPrzykład”.

Dodawanie pakietu IMA DAI SDK do projektu Xcode

Aby zainstalować pakiet IMA DAI SDK, użyj jednej z tych 3 metod.

Zainstaluj pakiet SDK za pomocą CocoaPods (zalecane).

CocoaPods to menedżer zależności dla projektów Xcode i zalecana metoda instalowania pakietu IMA DAI SDK. Więcej informacji o instalowaniu i używaniu CocoaPods znajdziesz w dokumentacji CocoaPods. Po zainstalowaniu CocoaPods wykonaj te instrukcje, aby zainstalować pakiet IMA DAI SDK:

W tym samym katalogu, w którym znajduje się plik PodServingExample.xcodeproj, utwórz plik tekstowy o nazwie Podfile i dodaj tę konfigurację:

Podfile
```
source 'https://github.com/CocoaPods/Specs.git'

platform :ios, '14'

target 'PodServingExample' do
  pod 'GoogleAds-IMA-iOS-SDK'
end
Podfile
```
W katalogu, który zawiera plik Podfile, uruchom:
```
pod install --repo-update
```

Zainstaluj pakiet SDK za pomocą menedżera pakietów Swift

Pakiet SDK do wyświetlania interaktywnych reklam medialnych obsługuje Swift Package Manager od wersji 3.18.4. Aby zaimportować pakiet Swift, wykonaj te czynności.

W Xcode zainstaluj pakiet Swift IMA DAI SDK, wybierając Plik > Dodaj pakiety.

W wyświetlonym promptzie wyszukaj repozytorium GitHub IMA DAI SDK Swift Package:

https://github.com/googleads/swift-package-manager-google-interactive-media-ads-ios

Wybierz wersję pakietu IMA DAI SDK Swift, której chcesz używać. W przypadku nowych projektów zalecamy użycie opcji Aktualizuj do następnej głównej wersji.

Gdy skończysz, Xcode zweryfikuje zależności pakietu i pobierze je w tle. Więcej informacji o dodawaniu zależności pakietu znajdziesz w artykule Apple.

Ręczne pobieranie i instalowanie pakietu SDK

Jeśli nie chcesz używać menedżera pakietów Swift ani CocoaPods, możesz pobrać pakiet IMA DAI SDK i ręcznie dodać go do projektu.

Pokaż instrukcje

Na stronie pobierania pakietu IMA na iOS pobierz i rozpakuj najnowszą wersję pakietu IMA DAI SDK.
Otwórz BasicExample.xcodeproj.
W panelu po lewej stronie kliknij nazwę projektu.
W panelu środkowym kliknij Etapy kompilacji.
Rozwiń sekcję Połącz plik binarny z bibliotekami.
U dołu listy bibliotek kliknij ikonę plusa [+].
Kliknij Dodaj inne.
W katalogu, w którym rozpakowałeś/aś pobrany pakiet SDK, wybierz GoogleInteractiveMediaAds.framework i kliknij Otwórz.
U dołu listy bibliotek ponownie kliknij ikonę plusa [+].
W kolumnie Stan sprawdź, czy parametr GoogleInteractiveMediaAds.framework jest ustawiony na Required.
Uwzględnij w ustawieniach kompilacji flagę linkera -ObjC. Więcej informacji znajdziesz w Apple QA1490.

Tworzenie prostego odtwarzacza wideo

W głównym kontrolerze widoku zaimplementuj odtwarzacz wideo, korzystając z odtwarzacza AV ujętego w ramy widoku interfejsu użytkownika. Pakiet IMA SDK używa widoku interfejsu użytkownika do wyświetlania elementów interfejsu reklamy.

Objective-CSwift

ViewController.m

#import "ViewController.h"

#import <AVKit/AVKit.h>

/// Content URL.
static NSString *const kBackupContentUrl =
    @"http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8";

@interface ViewController ()
/// Play button.
@property(nonatomic, weak) IBOutlet UIButton *playButton;

@property(nonatomic, weak) IBOutlet UIView *videoView;
/// Video player.
@property(nonatomic, strong) AVPlayer *videoPlayer;
@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];
  self.view.backgroundColor = [UIColor blackColor];

  // Load AVPlayer with the path to your content.
  NSURL *contentURL = [NSURL URLWithString:kBackupContentUrl];
  self.videoPlayer = [AVPlayer playerWithURL:contentURL];

  // Create a player layer for the player.
  AVPlayerLayer *playerLayer = [AVPlayerLayer playerLayerWithPlayer:self.videoPlayer];

  // Size, position, and display the AVPlayer.
  playerLayer.frame = self.videoView.layer.bounds;
  [self.videoView.layer addSublayer:playerLayer];
}

- (IBAction)onPlayButtonTouch:(id)sender {
  [self.videoPlayer play];
  self.playButton.hidden = YES;
}

@end
ViewController.m

ViewController.swift

// Copyright 2024 Google LLC. All rights reserved.
//
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
// file except in compliance with the License. You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under
// the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
// ANY KIND, either express or implied. See the License for the specific language governing
// permissions and limitations under the License.

import AVFoundation
import UIKit

class ViewController: UIViewController {

  /// Content URL.
  static let backupStreamURLString =
    "http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8"

  /// Play button.
  @IBOutlet private weak var playButton: UIButton!

  @IBOutlet private weak var videoView: UIView!
  /// Video player.
  private var videoPlayer: AVPlayer?

  override func viewDidLoad() {
    super.viewDidLoad()

    playButton.layer.zPosition = CGFloat(MAXFLOAT)

    // Load AVPlayer with path to our content.
    // note: this unwrap is safe because the URL is a constant string.
    let contentURL = URL(string: ViewController.backupStreamURLString)!
    videoPlayer = AVPlayer(url: contentURL)

    // Create a player layer for the player.
    let playerLayer = AVPlayerLayer(player: videoPlayer)

    // Size, position, and display the AVPlayer.
    playerLayer.frame = videoView.layer.bounds
    videoView.layer.addSublayer(playerLayer)
  }

  @IBAction func onPlayButtonTouch(_ sender: Any) {
    videoPlayer?.play()
    playButton.isHidden = true
  }
}
ViewController.swift

Inicjowanie ładowarki reklam

Zaimportuj pakiet IMA SDK do kontrolera widoku i zaimplementuj protokoły IMAAdsLoaderDelegate i IMAStreamManagerDelegate, aby obsługiwać zdarzenia ładowarki reklam i menedżera strumienia.

Dodaj te prywatne właściwości, aby przechowywać kluczowe komponenty pakietu IMA SDK:

IMAAdsLoader – zarządza żądaniami strumieniowania przez cały czas działania aplikacji.
IMAAdDisplayContainer – odpowiada za wstawianie elementów interfejsu użytkownika reklamy i zarządzanie nimi.
IMAAVPlayerVideoDisplay – umożliwia komunikację między pakietem IMA SDK a odtwarzaczem multimediów oraz obsługuje otagowane metadanymi treści.
IMAStreamManager – zarządza odtwarzaniem strumienia i uruchamia zdarzenia związane z reklamami.

Po załadowaniu widoku zainicjuj ładowarkę reklam, kontener wyświetlania reklam i wyświetlanie filmu.

Objective-CSwift

ViewController.m

@import GoogleInteractiveMediaAds;

// ...

@interface ViewController () <IMAAdsLoaderDelegate, IMAStreamManagerDelegate>
/// The entry point for the IMA DAI SDK to make DAI stream requests.
@property(nonatomic, strong) IMAAdsLoader *adsLoader;
/// The container where the SDK renders each ad's user interface elements and companion slots.
@property(nonatomic, strong) IMAAdDisplayContainer *adDisplayContainer;
/// The reference of your video player for the IMA DAI SDK to monitor playback and handle timed
/// metadata.
@property(nonatomic, strong) IMAAVPlayerVideoDisplay *imaVideoDisplay;
/// References the stream manager from the IMA DAI SDK after successful stream loading.
@property(nonatomic, strong) IMAStreamManager *streamManager;

// ...

@end

@implementation ViewController

- (void)viewDidLoad {
  [super viewDidLoad];

  // ...

  self.adsLoader = [[IMAAdsLoader alloc] initWithSettings:nil];
  self.adsLoader.delegate = self;

  // Create an ad display container for rendering each ad's user interface elements and companion
  // slots.
  self.adDisplayContainer =
      [[IMAAdDisplayContainer alloc] initWithAdContainer:self.videoView
                                          viewController:self
                                          companionSlots:nil];

  // Create an IMAAVPlayerVideoDisplay to give the SDK access to your video player.
  self.imaVideoDisplay = [[IMAAVPlayerVideoDisplay alloc] initWithAVPlayer:self.videoPlayer];
}ViewController.m

ViewController.swift

import GoogleInteractiveMediaAds
// ...

class ViewController: UIViewController, IMAAdsLoaderDelegate, IMAStreamManagerDelegate {
  // ...

  /// The entry point for the IMA DAI SDK to make DAI stream requests.
  private var adsLoader: IMAAdsLoader?
  /// The container where the SDK renders each ad's user interface elements and companion slots.
  private var adDisplayContainer: IMAAdDisplayContainer?
  /// The reference of your video player for the IMA DAI SDK to monitor playback and handle timed
  /// metadata.
  private var imaVideoDisplay: IMAAVPlayerVideoDisplay!
  /// References the stream manager from the IMA DAI SDK after successfully loading the DAI stream.
  private var streamManager: IMAStreamManager?

  // ...

  override func viewDidLoad() {
    super.viewDidLoad()

    // ...

    adsLoader = IMAAdsLoader(settings: nil)
    adsLoader?.delegate = self

    // Create an ad display container for rendering each ad's user interface elements and companion
    // slots.
    adDisplayContainer = IMAAdDisplayContainer(
      adContainer: videoView,
      viewController: self,
      companionSlots: nil)

    // Create an IMAAVPlayerVideoDisplay to give the SDK access to your video player.
    imaVideoDisplay = IMAAVPlayerVideoDisplay(avPlayer: videoPlayer)
  }ViewController.swift

Przesyłanie żądania strumienia

Gdy użytkownik naciśnie przycisk odtwarzania, prześlij nowe żądanie strumienia. Użyj klasy IMAPodStreamRequest do transmisji na żywo. W przypadku strumieni VOD użyj klasy IMAPodVODStreamRequest.

Żądanie strumienia wymaga parametrów strumienia, a także odniesienia do kontenera wyświetlania reklamy i wyświetlania filmu.

Objective-CSwift

ViewController.m

- (IBAction)onPlayButtonTouch:(id)sender {
  [self requestStream];
  self.playButton.hidden = YES;
}

- (void)requestStream {
  // Create a stream request.
  IMAStreamRequest *request;
  if (kStreamType == StreamTypeLive) {
    // Live stream request. Replace the network code and custom asset key with your values.
    request = [[IMAPodStreamRequest alloc] initWithNetworkCode:kNetworkCode
                                                customAssetKey:kCustomAssetKey
                                            adDisplayContainer:adDisplayContainer
                                                  videoDisplay:self.videoDisplay
                                         pictureInPictureProxy:nil
                                                   userContext:nil];
  } else {
    // VOD request. Replace the network code with your value.
    request = [[IMAPodVODStreamRequest alloc] initWithNetworkCode:@kNetworkCode
                                               adDisplayContainer:adDisplayContainer
                                                     videoDisplay:self.videoDisplay
                                            pictureInPictureProxy:nil
                                                      userContext:nil];
  }
  [self.adsLoader requestStreamWithRequest:request];
}ViewController.m

ViewController.swift

@IBAction func onPlayButtonTouch(_ sender: Any) {
  requestStream()
  playButton.isHidden = true
}

func requestStream() {
  // Create a stream request. Use one of "Livestream request" or "VOD request".
  if ViewController.requestType == StreamType.live {
    // Livestream request.
    let request = IMAPodStreamRequest(
      networkCode: ViewController.networkCode,
      customAssetKey: ViewController.customAssetKey,
      adDisplayContainer: adDisplayContainer!,
      videoDisplay: self.imaVideoDisplay,
      pictureInPictureProxy: nil,
      userContext: nil)
    adsLoader?.requestStream(with: request)
  } else {
    // VOD stream request.
    let request = IMAPodVODStreamRequest(
      networkCode: ViewController.networkCode,
      adDisplayContainer: adDisplayContainer!,
      videoDisplay: self.imaVideoDisplay,
      pictureInPictureProxy: nil,
      userContext: nil)
    adsLoader?.requestStream(with: request)
  }
}ViewController.swift

Nasłuchiwanie zdarzeń wczytywania strumienia

Klasa IMAAdsLoader wywołuje metody IMAAdsLoaderDelegate w przypadku udanego zainicjowania lub nieudanego wysłania żądania strumienia.

W metodzie zastępczej adsLoadedWithData ustaw zmienną IMAStreamManagerDelegate. Przekaż identyfikator strumienia do niestandardowego modułu obsługi VTP i pobierz adres URL pliku manifestu strumienia. W przypadku transmisji na żywo załaduj adres URL pliku manifestu do wyświetlacza wideo i rozpocznij odtwarzanie. W przypadku strumieni VOD przekaż adres URL pliku manifestu do metody loadThirdPartyStream menedżera strumieni. Ta metoda wysyła żądanie danych zdarzeń reklamy do Ad Managera 360, a potem wczytuje adres URL pliku manifestu i rozpoczyna odtwarzanie.

W metodzie delegowanej failedWithErrorData zapisz błąd. Opcjonalnie odtwórz strumień zapasowy. Zapoznaj się ze sprawdzonymi metodami dotyczącymi automatycznego wyświetlania reklam.

Objective-CSwift

ViewController.m

- (void)adsLoader:(IMAAdsLoader *)loader adsLoadedWithData:(IMAAdsLoadedData *)adsLoadedData {
  NSLog(@"Stream created with: %@.", adsLoadedData.streamManager.streamId);
  self.streamManager = adsLoadedData.streamManager;
  self.streamManager.delegate = self;

  // Build the Pod serving Stream URL.
  NSString *streamID = adsLoadedData.streamManager.streamId;
  // Your custom VTP handler takes the stream ID and returns the stream manifest URL.
  NSString *urlString = gCustomVTPHandler(streamID);
  NSURL *streamUrl = [NSURL URLWithString:urlString];
  if (kStreamType == StreamTypeLive) {
    // Load live streams directly into the AVPlayer.
    [self.videoDisplay loadStream:streamUrl withSubtitles:@[]];
    [self.videoDisplay play];
  } else {
    // Load VOD streams using the `loadThirdPartyStream` method in IMA SDK's stream manager.
    // The stream manager loads the stream, requests metadata, and starts playback.
    [self.streamManager loadThirdPartyStream:streamUrl streamSubtitles:@[]];
  }
}

- (void)adsLoader:(IMAAdsLoader *)loader failedWithErrorData:(IMAAdLoadingErrorData *)adErrorData {
  // Log the error and play the backup content.
  NSLog(@"AdsLoader error, code:%ld, message: %@", adErrorData.adError.code,
        adErrorData.adError.message);
  [self.videoPlayer play];
}ViewController.m

ViewController.swift

func adsLoader(_ loader: IMAAdsLoader, adsLoadedWith adsLoadedData: IMAAdsLoadedData) {
  print("DAI stream loaded. Stream session ID: \(adsLoadedData.streamManager!.streamId!)")
  streamManager = adsLoadedData.streamManager!
  streamManager!.delegate = self

  // Build the Pod serving Stream URL.
  let streamID = streamManager!.streamId
  // Your custom VTP handler takes the stream ID and returns the stream manifest URL.
  let urlString = ViewController.customVTPParser(streamID!)
  let streamUrl = URL(string: urlString)
  if ViewController.requestType == StreamType.live {
    // Live streams can be loaded directly into the AVPlayer.
    imaVideoDisplay.loadStream(streamUrl!, withSubtitles: [])
    imaVideoDisplay.play()
  } else {
    // VOD streams are loaded using the IMA SDK's stream manager.
    // The stream manager loads the stream, requests metadata, and starts playback.
    streamManager!.loadThirdPartyStream(streamUrl!, streamSubtitles: [])
  }
}

func adsLoader(_ loader: IMAAdsLoader, failedWith adErrorData: IMAAdLoadingErrorData) {
  print("Error loading DAI stream. Error message: \(adErrorData.adError.message!)")
  // Play the backup stream.
  videoPlayer.play()
}ViewController.swift

Wdrażanie niestandardowego modułu obsługi VTP

Niestandardowy handler VTP wysyła identyfikator strumienia widza do technicznego partnera wideo (VTP) wraz z innymi informacjami, których potrzebuje VTP, aby zwrócić manifest strumienia zawierający zarówno treści, jak i zszyte reklamy. Twój dostawca VTP udostępni Ci szczegółowe instrukcje implementacji niestandardowego modułu obsługi VTP.

Przykładowo plik VTP może zawierać URL szablonu pliku manifestu zawierający makro [[STREAMID]]. W tym przykładzie w miejsce makra wstawia identyfikator strumienia i zwraca uzyskany adres URL pliku manifestu.

Objective-CSwift

ViewController.m

/// Custom VTP Handler.
///
/// Returns the stream manifest URL from the video technical partner or manifest manipulator.
static NSString *(^gCustomVTPHandler)(NSString *) = ^(NSString *streamID) {
  // Insert synchronous code here to retrieve a stream manifest URL from your video tech partner
  // or manifest manipulation server.
  // This example uses a hardcoded URL template, containing a placeholder for the stream
  // ID and replaces the placeholder with the stream ID.
  NSString *manifestUrl = @"YOUR_MANIFEST_URL_TEMPLATE";
  return [manifestUrl stringByReplacingOccurrencesOfString:@"[[STREAMID]]"
                                                withString:streamID];
};ViewController.m

ViewController.swift

/// Custom VTP Handler.
///
/// Returns the stream manifest URL from the video technical partner or manifest manipulator.
static let customVTPParser = { (streamID: String) -> (String) in
  // Insert synchronous code here to retrieve a stream manifest URL from your video tech partner
  // or manifest manipulation server.
  // This example uses a hardcoded URL template, containing a placeholder for the stream
  // ID and replaces the placeholder with the stream ID.
  let manifestURL = "YOUR_MANIFEST_URL_TEMPLATE"
  return manifestURL.replacingOccurrences(of: "[[STREAMID]]", with: streamID)
}ViewController.swift

Nasłuchiwanie zdarzeń reklamowych

IMAStreamManagerwywołuje metody IMAStreamManagerDelegate, aby przekazywać zdarzenia i błędy strumienia do aplikacji.

W tym przykładzie rejestruj w konsoli podstawowe zdarzenia reklamy:

Objective-CSwift

ViewController.m

- (void)streamManager:(IMAStreamManager *)streamManager didReceiveAdEvent:(IMAAdEvent *)event {
  NSLog(@"Ad event (%@).", event.typeString);
  switch (event.type) {
    case kIMAAdEvent_STARTED: {
      // Log extended data.
      NSString *extendedAdPodInfo = [[NSString alloc]
          initWithFormat:@"Showing ad %ld/%ld, bumper: %@, title: %@, description: %@, contentType:"
                         @"%@, pod index: %ld, time offset: %lf, max duration: %lf.",
                         (long)event.ad.adPodInfo.adPosition, (long)event.ad.adPodInfo.totalAds,
                         event.ad.adPodInfo.isBumper ? @"YES" : @"NO", event.ad.adTitle,
                         event.ad.adDescription, event.ad.contentType,
                         (long)event.ad.adPodInfo.podIndex, event.ad.adPodInfo.timeOffset,
                         event.ad.adPodInfo.maxDuration];

      NSLog(@"%@", extendedAdPodInfo);
      break;
    }
    case kIMAAdEvent_AD_BREAK_STARTED: {
      NSLog(@"Ad break started");
      break;
    }
    case kIMAAdEvent_AD_BREAK_ENDED: {
      NSLog(@"Ad break ended");
      break;
    }
    case kIMAAdEvent_AD_PERIOD_STARTED: {
      NSLog(@"Ad period started");
      break;
    }
    case kIMAAdEvent_AD_PERIOD_ENDED: {
      NSLog(@"Ad period ended");
      break;
    }
    default:
      break;
  }
}

- (void)streamManager:(IMAStreamManager *)streamManager didReceiveAdError:(IMAAdError *)error {
  NSLog(@"StreamManager error with type: %ld\ncode: %ld\nmessage: %@", error.type, error.code,
        error.message);
  [self.videoPlayer play];
}ViewController.m

ViewController.swift

func streamManager(_ streamManager: IMAStreamManager, didReceive event: IMAAdEvent) {
  print("Ad event \(event.typeString).")
  switch event.type {
  case IMAAdEventType.STARTED:
    // Log extended data.
    if let ad = event.ad {
      let extendedAdPodInfo = String(
        format: "Showing ad %zd/%zd, bumper: %@, title: %@, "
          + "description: %@, contentType:%@, pod index: %zd, "
          + "time offset: %lf, max duration: %lf.",
        ad.adPodInfo.adPosition,
        ad.adPodInfo.totalAds,
        ad.adPodInfo.isBumper ? "YES" : "NO",
        ad.adTitle,
        ad.adDescription,
        ad.contentType,
        ad.adPodInfo.podIndex,
        ad.adPodInfo.timeOffset,
        ad.adPodInfo.maxDuration)

      print("\(extendedAdPodInfo)")
    }
    break
  case IMAAdEventType.AD_BREAK_STARTED:
    print("Ad break started.")
    break
  case IMAAdEventType.AD_BREAK_ENDED:
    print("Ad break ended.")
    break
  case IMAAdEventType.AD_PERIOD_STARTED:
    print("Ad period started.")
    break
  case IMAAdEventType.AD_PERIOD_ENDED:
    print("Ad period ended.")
    break
  default:
    break
  }
}

func streamManager(_ streamManager: IMAStreamManager, didReceive error: IMAAdError) {
  print("StreamManager error with type: \(error.type)")
  print("code: \(error.code)")
  print("message: \(error.message ?? "Unknown Error")")
}ViewController.swift

Czyszczenie komponentów IMA DAI

Aby zatrzymać odtwarzanie strumienia, zatrzymać śledzenie reklam i zwolnić wszystkie załadowane zasoby strumienia, wywołaj funkcję IMAStreamManager.destroy().

Uruchom aplikację. Jeśli się uda, możesz poprosić o odtworzenie strumienia Google DAI i odtworzyć go za pomocą pakietu IMA SDK. Więcej informacji o zaawansowanych funkcjach pakietu SDK znajdziesz w innych przewodnikach wymienionych na pasku bocznym po lewej stronie lub w przykładach na GitHubie.