MENU
  1. ホーム
  2. Swift
  3. Swiftでデリゲートを使って音声や動画の再生完了を検知する方法

Swiftでデリゲートを使って音声や動画の再生完了を検知する方法

Swift

Swiftで音声や動画を扱う際、再生が完了した瞬間を確実に検知することは、ユーザー体験の向上や次の処理へのスムーズな移行において非常に重要です。音楽アプリや動画再生アプリでは、再生が終了した後に次のトラックを自動で再生したり、特定のアクションをトリガーする必要があるため、この検知方法をしっかりと実装することが求められます。

本記事では、Swiftのデリゲートパターンを活用して、音声や動画の再生完了を効率よく検知する方法について詳しく解説します。AVFoundationフレームワークを使用した具体的なコード例や、再生完了後の処理例も取り上げ、実際のアプリ開発で役立つ知識を提供します。

目次

デリゲートパターンの概要

デリゲートパターンは、iOS開発において非常に一般的なデザインパターンであり、オブジェクト間の通信を効率的に行うために使われます。特定のイベントや操作に応じて処理を他のオブジェクトに委任することができるため、コードの可読性や再利用性を高めることができます。

デリゲートの基本概念

デリゲートとは、あるオブジェクトが発生させるイベントを他のオブジェクトが処理する仕組みです。デリゲートを利用することで、特定のオブジェクトが実行するべき動作を外部の別のオブジェクトに委任することができます。これにより、オブジェクト間の結合度を下げ、コードの柔軟性を向上させることが可能です。

Swiftでは、プロトコル（Protocol）を使ってデリゲートを定義し、特定のメソッドをデリゲート先に実装させることで、任意のタイミングでイベントを通知することができます。

デリゲートパターンの活用例

例えば、音声や動画の再生が完了した際、そのイベントを別のクラスに通知し、その後の処理を任せる場合にデリゲートパターンを使用します。これにより、再生管理の処理ロジックを分離し、アプリ全体の設計をシンプルに保つことが可能です。

AVFoundationフレームワークの紹介

AVFoundationは、Appleが提供する強力なマルチメディアフレームワークで、音声や動画の再生、録音、編集、トランスコードなど、幅広いメディア処理を行うためのAPIを提供しています。このフレームワークを使うことで、iOSアプリ内で高品質な音声・動画の再生機能を簡単に実装することが可能です。

AVFoundationの主な機能

AVFoundationには、音声や動画の再生、録音、編集などに関する多くの機能が含まれています。例えば、音楽プレーヤー、動画プレーヤー、ストリーミングアプリなど、多くのメディア関連アプリで利用されています。以下はその代表的な機能です。

  • 音声・動画の再生: オーディオとビデオのシームレスな再生をサポートし、細かな制御が可能。
  • メディアの録音と編集: ユーザーがオーディオやビデオをキャプチャし、後で編集できる機能を提供。
  • ストリーミング: ネットワークからリアルタイムでのメディア再生をサポート。

AVPlayerとAVPlayerItemの役割

音声や動画の再生には、AVFoundationのクラスであるAVPlayerとAVPlayerItemを使用します。AVPlayerは再生自体を担当し、AVPlayerItemは再生するメディアコンテンツの情報を保持します。これらを連携させて利用することで、メディアの再生操作を簡単に実装することができます。

AVFoundationを使用すれば、再生完了時やエラー発生時に特定の処理を行うためのデリゲートを実装し、音声や動画の操作を効率よく行うことが可能です。

再生管理クラスの作成

音声や動画の再生完了を検知するためには、再生を管理するクラスを作成し、その中でデリゲートを活用するのが一般的です。このクラスでは、AVPlayerやAVPlayerItemを用いて再生を管理し、再生完了時に特定の処理を行うデリゲートを設定します。

再生管理クラスの基本構造

まず、再生を管理するクラスを作成します。このクラスでは、AVPlayerとAVPlayerItemを用いて音声や動画の再生を管理し、再生完了やエラー発生時にデリゲートメソッドを呼び出します。

import AVFoundation

class PlaybackManager: NSObject {
    var player: AVPlayer?

    // プレーヤーの初期化と再生開始
    func startPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        // 通知を使って再生完了を検知
        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(playbackDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    // 再生完了時に呼ばれるメソッド
    @objc func playbackDidFinish(_ notification: Notification) {
        print("再生が完了しました")
        // 再生完了後の処理をここに追加
    }
}

このクラスは、音声や動画ファイルの再生を開始し、再生完了をNotificationCenterを使用して検知します。再生完了時には、指定したメソッド（playbackDidFinish）が呼ばれ、その後の処理を行うことができます。

デリゲートの導入

このPlaybackManagerクラスを強化するために、デリゲートを導入し、再生完了時に外部のクラスから処理をカスタマイズできるようにします。以下は、デリゲートパターンを使用した拡張です。

// デリゲートプロトコルの定義
protocol PlaybackManagerDelegate: AnyObject {
    func playbackDidFinish()
}

class PlaybackManager: NSObject {
    var player: AVPlayer?
    weak var delegate: PlaybackManagerDelegate?

    func startPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(playbackDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    @objc func playbackDidFinish(_ notification: Notification) {
        delegate?.playbackDidFinish()
    }
}

ここでは、PlaybackManagerDelegateというプロトコルを定義し、再生完了時にデリゲートメソッドplaybackDidFinishを呼び出す仕組みを作りました。再生完了後の処理をこのデリゲートメソッド内で自由にカスタマイズすることが可能です。

デリゲートの設定と実装例

外部のクラスでこのデリゲートを設定し、再生完了時の処理を実装する例を示します。

class ViewController: UIViewController, PlaybackManagerDelegate {
    let playbackManager = PlaybackManager()

    override func viewDidLoad() {
        super.viewDidLoad()
        playbackManager.delegate = self
        let mediaURL = URL(string: "https://example.com/audio.mp3")!
        playbackManager.startPlayback(with: mediaURL)
    }

    // デリゲートメソッドの実装
    func playbackDidFinish() {
        print("ViewControllerで再生完了が検知されました")
        // 再生完了後の処理をここに記述
    }
}

このように、PlaybackManagerのデリゲートを使うことで、再生完了を検知して適切な処理を行うことができます。

AVPlayerとAVPlayerItemの使用

音声や動画の再生には、AVFoundationフレームワークのAVPlayerとAVPlayerItemを使用します。AVPlayerは再生を行うためのコアクラスで、AVPlayerItemは再生するメディア（音声・動画）の情報を管理します。これらを使って、再生操作や再生完了の検知を行います。

AVPlayerとAVPlayerItemの役割

  • AVPlayer: メディアを再生するためのクラス。再生、停止、一時停止、シーク（再生位置の移動）などの操作を提供します。
  • AVPlayerItem: メディアの状態や情報を管理し、AVPlayerに再生するための素材を提供します。再生するURLやファイルパスを指定して、再生メディアをAVPlayerに渡す役割を持っています。

再生を行うには、まずAVPlayerItemで再生するメディアを指定し、AVPlayerにそのアイテムを渡して再生を開始します。

基本的な実装例

以下のコードでは、URLから音声または動画を再生する基本的な手順を示します。AVPlayerを使用してメディアファイルを再生する方法です。

import AVFoundation

class PlaybackManager {
    var player: AVPlayer?

    func startPlayback(with url: URL) {
        // AVPlayerItemの作成
        let playerItem = AVPlayerItem(url: url)

        // AVPlayerに再生アイテムを設定
        player = AVPlayer(playerItem: playerItem)

        // 再生開始
        player?.play()

        print("再生が開始されました")
    }
}

このstartPlaybackメソッドでは、指定されたURLからAVPlayerItemを作成し、そのアイテムをAVPlayerに設定しています。そして、play()メソッドを呼び出すことで再生が始まります。

再生中の操作

AVPlayerを使うことで、再生中の操作も簡単に行えます。例えば、再生の一時停止や停止、再開などが可能です。

class PlaybackManager {
    var player: AVPlayer?

    // 再生を一時停止
    func pausePlayback() {
        player?.pause()
        print("再生が一時停止されました")
    }

    // 再生を再開
    func resumePlayback() {
        player?.play()
        print("再生が再開されました")
    }

    // 再生を停止
    func stopPlayback() {
        player?.pause()
        player?.seek(to: CMTime.zero)
        print("再生が停止されました")
    }
}

ここでは、pause()メソッドで再生を一時停止し、play()で再生を再開しています。また、seek(to:)メソッドで再生位置を最初に戻すことで、再生を停止しています。

再生位置の変更（シーク機能）

再生中のメディアの再生位置を移動することも可能です。例えば、ユーザーがシークバーを使って任意の場所に移動する場合、この機能が役立ちます。

class PlaybackManager {
    var player: AVPlayer?

    // 再生位置を変更
    func seek(to seconds: Double) {
        let targetTime = CMTime(seconds: seconds, preferredTimescale: 600)
        player?.seek(to: targetTime, completionHandler: { completed in
            if completed {
                print("シークが完了しました")
            }
        })
    }
}

seek(to:)メソッドで指定した時間（秒単位）に再生位置を移動できます。再生位置が正しく移動したかどうかは、completionHandlerで確認できます。

再生状態の監視

再生の進捗やステータスを監視するために、KVO（Key-Value Observing）を利用することができます。これにより、再生中の状態変化をリアルタイムで取得することが可能です。

class PlaybackManager {
    var player: AVPlayer?
    var playerItem: AVPlayerItem?

    func startPlayback(with url: URL) {
        playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        // 再生のステータスを監視
        playerItem?.addObserver(self, forKeyPath: "status", options: [.new, .old], context: nil)
    }

    // KVOでステータスの変化を監視
    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        if keyPath == "status" {
            if player?.status == .readyToPlay {
                print("再生の準備が完了しました")
            } else if player?.status == .failed {
                print("再生の準備に失敗しました")
            }
        }
    }
}

ここでは、statusプロパティの変化を監視し、再生準備が完了したか、失敗したかを確認しています。これにより、再生可能な状態になったタイミングで適切な処理を行うことができます。

このように、AVPlayerとAVPlayerItemを使えば、音声や動画の再生、シーク、再生状態の監視などを細かく制御することが可能です。

デリゲートを利用した再生完了の検知

音声や動画の再生が完了した際に、そのイベントを確実に検知することは、ユーザー体験を向上させる上で非常に重要です。再生完了後に次のメディアを再生する、特定のアクションを実行するなど、さまざまな操作を行う必要がある場面で役立ちます。Swiftでは、デリゲートや通知を利用して再生完了を検知することが可能です。

NotificationCenterを使った再生完了の検知

AVPlayerでは、NotificationCenterを使って再生完了を検知することができます。AVPlayerItemDidPlayToEndTimeという通知が、再生が終了したタイミングで発信されます。この通知をキャッチすることで、再生完了時に特定の処理を実行できます。

以下は、NotificationCenterを利用した再生完了検知の実装例です。

import AVFoundation

class PlaybackManager {
    var player: AVPlayer?

    func startPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        // NotificationCenterで再生完了の通知を受け取る
        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(playbackDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    // 再生完了時に呼び出されるメソッド
    @objc func playbackDidFinish(_ notification: Notification) {
        print("再生が完了しました")
        // 再生完了後の処理をここに記述
    }
}

このコードでは、NotificationCenter.default.addObserverを使用して、AVPlayerItemDidPlayToEndTime通知を監視しています。再生が終了すると、自動的にplaybackDidFinishメソッドが呼ばれ、完了後の処理を実行できます。

デリゲートを使った再生完了のカスタマイズ

NotificationCenterを利用する方法は便利ですが、再生完了後の処理を柔軟にカスタマイズしたい場合には、デリゲートパターンが適しています。デリゲートを使えば、再生完了時に外部のクラスがその処理を自由にコントロールできます。

デリゲートを使った再生完了検知の実装例は以下の通りです。

// デリゲートプロトコルを定義
protocol PlaybackManagerDelegate: AnyObject {
    func playbackDidFinish()
}

class PlaybackManager {
    var player: AVPlayer?
    weak var delegate: PlaybackManagerDelegate?

    func startPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(playbackDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    // 再生完了時にデリゲートメソッドを呼び出す
    @objc func playbackDidFinish(_ notification: Notification) {
        delegate?.playbackDidFinish()
    }
}

このコードでは、PlaybackManagerDelegateというプロトコルを定義し、再生完了時にデリゲートメソッドplaybackDidFinishを呼び出しています。これにより、再生完了の処理を外部のクラスでカスタマイズ可能にしています。

デリゲートの実装例

外部のクラスでデリゲートを実装し、再生完了後の処理をカスタマイズする例を以下に示します。

class ViewController: UIViewController, PlaybackManagerDelegate {
    let playbackManager = PlaybackManager()

    override func viewDidLoad() {
        super.viewDidLoad()
        playbackManager.delegate = self
        let mediaURL = URL(string: "https://example.com/audio.mp3")!
        playbackManager.startPlayback(with: mediaURL)
    }

    // デリゲートメソッドの実装
    func playbackDidFinish() {
        print("再生が完了しました。次の操作を実行します。")
        // 再生完了後のカスタム処理
    }
}

このように、PlaybackManagerクラスにデリゲートを設定することで、外部のクラスで再生完了後の処理を柔軟に行うことができます。再生が完了すると、ViewControllerクラスのplaybackDidFinishメソッドが呼び出され、その後の操作を自由に定義できます。

まとめ

  • NotificationCenterを使用して再生完了を簡単に検知する方法。
  • デリゲートを使って、再生完了後の処理を外部のクラスで柔軟にカスタマイズする方法。

これらの方法を活用することで、アプリ内での再生完了後の動作を効率的に管理することができます。

再生中に状態を監視する方法

再生が完了するだけでなく、再生中の進行状況や状態を監視することも、音声や動画再生アプリを開発する上で重要な要素です。再生中にユーザーに進行状況を通知したり、特定のタイミングで別の処理を実行するために、再生状態を監視する必要があります。

AVPlayerには、再生中の状態や進行を監視するためのいくつかの仕組みが用意されています。その代表的なものが、addPeriodicTimeObserverメソッドと、KVO（Key-Value Observing）を使用した監視方法です。

進行状況を監視する：addPeriodicTimeObserver

再生中の進行状況を定期的に取得したい場合には、AVPlayerのaddPeriodicTimeObserver(forInterval:queue:using:)メソッドを使用します。このメソッドを使うことで、指定した時間間隔ごとに再生の現在位置を取得し、再生中の進行状況を更新することが可能です。

以下は、その実装例です。

import AVFoundation

class PlaybackManager {
    var player: AVPlayer?
    var timeObserverToken: Any?

    func startPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        // 1秒ごとに進行状況を監視
        let timeInterval = CMTime(seconds: 1, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
        timeObserverToken = player?.addPeriodicTimeObserver(forInterval: timeInterval, queue: .main) { [weak self] time in
            self?.updatePlaybackProgress(time: time)
        }
    }

    // 再生の進行状況を更新
    func updatePlaybackProgress(time: CMTime) {
        let seconds = CMTimeGetSeconds(time)
        print("現在の再生位置: \(seconds)秒")
        // UIの更新や処理をここに追加
    }

    // 再生停止時にタイムオブザーバーを削除
    func stopPlayback() {
        if let token = timeObserverToken {
            player?.removeTimeObserver(token)
            timeObserverToken = nil
        }
        player?.pause()
    }
}

このコードでは、再生中の時間を1秒ごとに取得し、updatePlaybackProgressメソッド内で進行状況を処理しています。これにより、ユーザーに再生の進行状況をリアルタイムで表示したり、進行に応じた操作を行うことが可能です。

再生ステータスの監視：KVOによる監視

再生中の状態変化（例えば、再生準備完了、再生エラー発生など）を検知するためには、KVO（Key-Value Observing）を使います。AVPlayerやAVPlayerItemのステータスを監視することで、状態が変わったときに適切な処理を行うことができます。

以下は、再生状態をKVOで監視する実装例です。

class PlaybackManager: NSObject {
    var player: AVPlayer?
    var playerItem: AVPlayerItem?

    func startPlayback(with url: URL) {
        playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        // KVOで再生ステータスを監視
        playerItem?.addObserver(self, forKeyPath: "status", options: [.new, .old], context: nil)
    }

    // KVOの変化を受け取るメソッド
    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        if keyPath == "status" {
            if player?.status == .readyToPlay {
                print("再生の準備が完了しました")
            } else if player?.status == .failed {
                print("再生エラーが発生しました")
            }
        }
    }

    // 再生停止時にオブザーバーを削除
    func stopPlayback() {
        playerItem?.removeObserver(self, forKeyPath: "status")
        player?.pause()
    }
}

ここでは、playerItemのstatusプロパティを監視して、再生準備が完了したときや、エラーが発生したときに対応する処理を実行しています。このようにして、再生状態に応じて適切なフィードバックやエラーハンドリングを行うことができます。

バッファリング状況の監視

ストリーミング再生を行う場合、再生中のバッファリング状況も重要なポイントです。再生がスムーズに行われるかどうかを監視するために、AVPlayerItemのloadedTimeRangesプロパティを監視することができます。このプロパティは、メディアデータがどれだけバッファリングされているかを示します。

class PlaybackManager: NSObject {
    var player: AVPlayer?
    var playerItem: AVPlayerItem?

    func startPlayback(with url: URL) {
        playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        // KVOでバッファリング状況を監視
        playerItem?.addObserver(self, forKeyPath: "loadedTimeRanges", options: [.new, .old], context: nil)
    }

    // バッファリング状況の変化を受け取る
    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
        if keyPath == "loadedTimeRanges" {
            if let timeRanges = playerItem?.loadedTimeRanges, let timeRange = timeRanges.first?.timeRangeValue {
                let bufferedTime = CMTimeGetSeconds(CMTimeAdd(timeRange.start, timeRange.duration))
                print("バッファリング済みの時間: \(bufferedTime)秒")
                // バッファリング状況に応じた処理を追加
            }
        }
    }
}

このコードでは、loadedTimeRangesを監視して、バッファリングが進んだタイミングでその情報を取得し、再生のスムーズさを判断できます。

まとめ

再生中の状態を監視するために、以下の方法を活用します。

  • addPeriodicTimeObserverで再生の進行状況を定期的に監視
  • KVOを利用して再生ステータスやバッファリング状況を監視

これらの監視方法を適切に組み合わせることで、再生中の状態に応じた柔軟な対応が可能となり、ユーザー体験を向上させることができます。

再生完了後の処理例

再生が完了した後に、どのような処理を行うかは、アプリケーションの機能に応じて異なります。例えば、次のメディアを自動的に再生したり、ユーザーに再生完了を知らせるポップアップを表示したり、再生完了の記録を保存したりするなど、さまざまな処理が考えられます。本セクションでは、再生完了後に行える処理のいくつかの具体的な例と、それらを実装する方法について解説します。

次のメディアの自動再生

再生リストを持つ音楽プレーヤーやポッドキャストアプリでは、再生が終了した後に次のトラックを自動的に再生する機能が重要です。この機能を実現するためには、再生完了を検知した際に次のメディアのURLを取得し、再度AVPlayerを設定して再生を開始します。

以下は、再生完了後に次のトラックを自動再生する例です。

import AVFoundation

class PlaybackManager {
    var player: AVPlayer?
    var currentMediaIndex: Int = 0
    let mediaURLs: [URL] = [
        URL(string: "https://example.com/audio1.mp3")!,
        URL(string: "https://example.com/audio2.mp3")!,
        URL(string: "https://example.com/audio3.mp3")!
    ]

    func startPlayback() {
        playMedia(at: currentMediaIndex)
    }

    private func playMedia(at index: Int) {
        if index < mediaURLs.count {
            let playerItem = AVPlayerItem(url: mediaURLs[index])
            player = AVPlayer(playerItem: playerItem)
            player?.play()

            // 再生完了通知を設定
            NotificationCenter.default.addObserver(self, 
                                                   selector: #selector(playbackDidFinish(_:)), 
                                                   name: .AVPlayerItemDidPlayToEndTime, 
                                                   object: playerItem)
        }
    }

    @objc func playbackDidFinish(_ notification: Notification) {
        // 次のトラックを再生
        currentMediaIndex += 1
        if currentMediaIndex < mediaURLs.count {
            playMedia(at: currentMediaIndex)
        } else {
            print("すべてのメディアが再生されました")
        }
    }
}

このコードでは、mediaURLsという配列に複数のメディアのURLが格納されており、再生完了時に次のトラックを自動で再生します。すべてのメディアが再生されると、再生が終了します。

再生完了後のポップアップ通知

再生が完了したことをユーザーに視覚的に知らせたい場合、ポップアップやアラートを表示するのが効果的です。UIAlertControllerを使って簡単にポップアップ通知を実装できます。

import AVFoundation
import UIKit

class PlaybackManager {
    var player: AVPlayer?
    weak var viewController: UIViewController?

    func startPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(playbackDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    @objc func playbackDidFinish(_ notification: Notification) {
        showPlaybackFinishedAlert()
    }

    // 再生完了後にポップアップを表示
    func showPlaybackFinishedAlert() {
        let alert = UIAlertController(title: "再生完了", message: "メディアの再生が完了しました", preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "OK", style: .default, handler: nil))
        viewController?.present(alert, animated: true, completion: nil)
    }
}

この例では、UIAlertControllerを使って「再生完了」のポップアップを表示します。再生が完了すると、ユーザーに完了を知らせるためのアラートが画面に表示されます。

再生完了の記録を保存

再生が完了したことを記録し、後で分析や履歴表示に利用することもできます。例えば、ポッドキャストアプリでは、どのエピソードが再生されたかを記録して、次にアプリを開いたときにユーザーに履歴を表示することができます。

以下は、再生完了を記録する例です。

class PlaybackManager {
    var player: AVPlayer?
    var completedMedia: [URL] = []

    func startPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(playbackDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    @objc func playbackDidFinish(_ notification: Notification) {
        if let playerItem = notification.object as? AVPlayerItem, let url = (playerItem.asset as? AVURLAsset)?.url {
            completedMedia.append(url)
            print("再生完了: \(url)")
        }
    }
}

このコードでは、再生が完了したメディアのURLをcompletedMedia配列に保存しています。この配列を使って、後から再生履歴を確認することが可能です。

まとめ

再生完了後の処理は、アプリの目的に応じてさまざまです。

  • 次のメディアを自動再生する方法
  • ポップアップ通知を表示する方法
  • 再生完了を記録して履歴を保存する方法

これらの処理を組み合わせることで、ユーザー体験を向上させ、アプリの機能を強化することができます。

トラブルシューティング：再生検知の失敗原因と対策

再生完了を検知する機能が正しく動作しない場合、いくつかの原因が考えられます。再生完了イベントが発生しない、通知が正しく受信できない、デリゲートが動作しないといった問題は、開発中によく遭遇するトラブルです。本セクションでは、再生完了検知の失敗原因を探り、それに対する解決策を紹介します。

原因1：NotificationCenterの監視設定が正しくない

NotificationCenterを使って再生完了を検知する場合、通知の設定に問題があるとイベントが正しく発火しません。特に、AVPlayerItemと通知の紐付けが適切に行われていない場合、再生完了をキャッチできなくなります。

対策
通知を設定する際には、AVPlayerItemが正しく指定されているか確認します。また、NotificationCenterへのオブザーバー登録が正常に行われているかどうかも重要です。以下のポイントに注意して実装を確認しましょう。

  • NotificationCenterのaddObserverメソッドで、正しいAVPlayerItemオブジェクトを渡しているか。
  • メソッドのselectorが正しく設定されているか（例：#selector(playbackDidFinish)）。
  • 通知のタイミングが、再生開始の直後に行われているか。

例:

NotificationCenter.default.addObserver(self, 
                                       selector: #selector(playbackDidFinish(_:)), 
                                       name: .AVPlayerItemDidPlayToEndTime, 
                                       object: playerItem)

デバッグ方法

  • 再生が完了した際に、手動でログを出力して通知が届いているか確認します。
  • NotificationCenterの監視を複数の場所で設定していないか、コード全体を確認します。誤って複数回設定している場合、通知が正しく動作しない可能性があります。

原因2：デリゲートの設定が正しくない

デリゲートパターンを使って再生完了を検知する場合、デリゲートの設定が間違っていると、期待した結果が得られません。特に、デリゲートのプロトコルを実装しているクラスが正しく設定されていない場合、通知が無視されます。

対策

  • デリゲートプロパティがweakで宣言されているか確認します。循環参照を防ぐために、デリゲートはweak varとして宣言します。
  • デリゲートが正しいオブジェクトに設定されているか確認します。デリゲートが設定されていない、もしくはnilになっている場合、メソッドが呼び出されません。

例:

playbackManager.delegate = self  // ViewControllerにデリゲートを設定

デバッグ方法

  • デリゲートが正しく設定されているかを確認するため、デリゲートのメソッド呼び出し前にprint文などでdelegateがnilになっていないかを確認します。
  • デリゲートメソッド内でログを出力して、メソッドが呼び出されているかどうかを確認します。

原因3：AVPlayerやAVPlayerItemの破棄

AVPlayerやAVPlayerItemが予期せず破棄されてしまうと、再生完了の検知が失敗します。特に、スコープの範囲外でplayerオブジェクトが解放されると、再生中でも通知が発生しなくなります。

対策
AVPlayerやAVPlayerItemは、クラスのプロパティとして保持し、再生が完了するまで保持されるようにします。特に、メソッドのローカル変数としてAVPlayerを作成すると、スコープを抜けた瞬間にオブジェクトが解放されてしまうため、再生完了が検知できません。

デバッグ方法

  • AVPlayerやAVPlayerItemが正しく保持されているか確認します。再生中にオブジェクトが解放されていないことを確認するため、deinitメソッドが呼ばれていないか調べます。

原因4：ストリーミングコンテンツの中断

インターネットからのストリーミング再生では、ネットワークの問題により途中で再生が停止したり、中断したりすることがあります。この場合、再生完了の通知が発生せず、正しく検知できないことがあります。

対策
ストリーミング再生中のバッファリング状況を監視し、ネットワークの問題で再生が中断した場合に適切に対応するようにします。AVPlayerItemのloadedTimeRangesプロパティを使って、再生データのバッファリング状況を定期的にチェックします。

例:

if let timeRange = playerItem.loadedTimeRanges.first?.timeRangeValue {
    let bufferedTime = CMTimeGetSeconds(timeRange.start) + CMTimeGetSeconds(timeRange.duration)
    print("バッファリング済みの時間: \(bufferedTime)")
}

デバッグ方法

  • ネットワーク環境をシミュレーションし、低速回線や接続切れなど、再生が中断する状況で再生完了が正常に検知できるか確認します。

原因5：非同期処理の競合

非同期で行われる再生処理に対して、他の処理が干渉すると、再生完了の検知が失敗することがあります。特に、再生中に他の非同期処理（ファイルアクセスやリモートリクエストなど）が重なると、予期しないタイミングで再生が中断されることがあります。

対策
非同期処理の優先度を適切に設定し、再生中に他の処理が干渉しないようにします。特に、UIスレッド上での重い処理やネットワーク要求が再生中に影響を与えないよう注意が必要です。

デバッグ方法

  • 再生中に他の非同期処理が走っている場合、その処理が再生に影響していないか確認します。

まとめ

再生完了が正しく検知できない場合の原因として、NotificationCenterやデリゲートの設定ミス、オブジェクトの解放、ネットワークの問題、非同期処理の競合などが考えられます。これらの原因を一つずつ確認し、正しく検知できるように対策を講じましょう。

実際のアプリへの応用例

再生完了の検知は、様々なアプリケーションで実際に応用することができます。音楽プレーヤー、動画ストリーミングサービス、ポッドキャストアプリ、さらには教育アプリでも、再生完了のイベントをトリガーにして次の操作を実行したり、ユーザーにフィードバックを提供することが求められます。このセクションでは、再生完了検知を活用した実際のアプリケーション例を紹介し、どのようにして実装が役立つかを解説します。

応用例1：音楽プレーヤーでの連続再生機能

音楽プレーヤーアプリでは、ユーザーが再生リストを作成し、曲が終了すると次のトラックを自動で再生する機能が求められます。この機能は、再生完了イベントを利用して、次のメディアを再生リストから取得し、自動で再生を開始するという流れで実装できます。

以下は、再生完了後に次のトラックを自動再生する音楽プレーヤーの例です。

class MusicPlayer: NSObject {
    var player: AVPlayer?
    var currentTrackIndex = 0
    let trackList: [URL] = [
        URL(string: "https://example.com/song1.mp3")!,
        URL(string: "https://example.com/song2.mp3")!,
        URL(string: "https://example.com/song3.mp3")!
    ]

    func startPlayback() {
        playTrack(at: currentTrackIndex)
    }

    private func playTrack(at index: Int) {
        guard index < trackList.count else {
            print("すべてのトラックが再生されました")
            return
        }
        let playerItem = AVPlayerItem(url: trackList[index])
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(trackDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    @objc private func trackDidFinish(_ notification: Notification) {
        currentTrackIndex += 1
        playTrack(at: currentTrackIndex)
    }
}

この実装では、再生完了を検知し、次の曲を自動で再生します。ユーザーがアプリを操作することなく、シームレスにトラックが切り替わるため、快適な音楽体験が提供されます。

応用例2：動画ストリーミングアプリでのエピソード連続再生

動画ストリーミングアプリでは、再生完了時に次のエピソードを自動で再生する「連続再生機能」が重要です。ユーザーがシリーズを一気に視聴できるように、エピソードの自動再生を実装します。

以下の例は、動画ストリーミングアプリにおけるエピソードの自動再生機能です。

class VideoPlayer: NSObject {
    var player: AVPlayer?
    var currentEpisodeIndex = 0
    let episodeList: [URL] = [
        URL(string: "https://example.com/episode1.mp4")!,
        URL(string: "https://example.com/episode2.mp4")!,
        URL(string: "https://example.com/episode3.mp4")!
    ]

    func startEpisodePlayback() {
        playEpisode(at: currentEpisodeIndex)
    }

    private func playEpisode(at index: Int) {
        guard index < episodeList.count else {
            print("すべてのエピソードが再生されました")
            return
        }
        let playerItem = AVPlayerItem(url: episodeList[index])
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(episodeDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    @objc private func episodeDidFinish(_ notification: Notification) {
        currentEpisodeIndex += 1
        playEpisode(at: currentEpisodeIndex)
    }
}

このコードは、ユーザーが次のエピソードを手動で選択する必要がないため、使い勝手の良い視聴体験を提供します。

応用例3：教育アプリでの学習進捗管理

教育アプリでは、ユーザーが学習ビデオやオーディオ教材を終了すると、進捗を記録し、次の学習ステップを提供する機能が求められます。再生完了をトリガーとして、ユーザーの学習履歴を更新し、次のコンテンツを提供することができます。

以下は、教育アプリにおける再生完了後の進捗管理の例です。

class EducationApp: NSObject {
    var player: AVPlayer?
    var completedLessons: [URL] = []

    func startLessonPlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(lessonDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    @objc private func lessonDidFinish(_ notification: Notification) {
        if let playerItem = notification.object as? AVPlayerItem, let url = (playerItem.asset as? AVURLAsset)?.url {
            completedLessons.append(url)
            print("学習完了: \(url)")
            // 次のレッスンを提供するなどの処理
        }
    }
}

このコードでは、学習コンテンツが終了した際に進捗を記録し、ユーザーが完了した教材を追跡することができます。また、完了後に次のレッスンを自動的に表示することも可能です。

応用例4：ポッドキャストアプリでの履歴管理

ポッドキャストアプリでは、再生が完了したエピソードをリストに保存しておき、次回アプリを開いた際にリスナーがどのエピソードを聴いたかを簡単に確認できる機能が求められます。この機能を利用して、再生履歴を管理し、再生完了後に次のエピソードを提案することができます。

以下は、ポッドキャストアプリでの履歴管理の例です。

class PodcastPlayer: NSObject {
    var player: AVPlayer?
    var completedEpisodes: [URL] = []

    func startEpisodePlayback(with url: URL) {
        let playerItem = AVPlayerItem(url: url)
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(episodeDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    @objc private func episodeDidFinish(_ notification: Notification) {
        if let playerItem = notification.object as? AVPlayerItem, let url = (playerItem.asset as? AVURLAsset)?.url {
            completedEpisodes.append(url)
            print("エピソード完了: \(url)")
            // 履歴に保存するなどの処理
        }
    }
}

再生完了後に、エピソードの履歴を記録し、次のエピソードを提案することで、リスナーの利便性を向上させます。

まとめ

再生完了の検知は、多くのアプリで役立つ機能です。音楽プレーヤーの連続再生、動画ストリーミングアプリのエピソード再生、教育アプリでの進捗管理、ポッドキャストアプリでの履歴保存など、さまざまな場面で応用できます。これらの例を基に、実際のアプリケーション開発で再生完了イベントを効果的に活用し、ユーザーにとって使いやすい機能を提供しましょう。

演習問題：再生完了後に次の音声を自動再生する機能の実装

ここでは、再生完了後に次の音声を自動的に再生する機能を実装するための演習問題を用意しました。この演習では、再生完了イベントを活用し、複数の音声ファイルを順次再生するアプリケーションを作成します。これにより、再生完了イベントを効果的に活用し、実際のアプリケーションに応用できるスキルを身に付けることができます。

課題の概要

あなたは、音声プレーヤーアプリを開発しています。ユーザーが選択した複数の音声ファイルを連続して再生する機能を実装してください。具体的には、次のような手順を踏んでください。

  1. 複数の音声ファイル（URLの配列）を用意する。
  2. 最初の音声を再生し、再生が完了したら自動的に次の音声を再生する。
  3. すべての音声ファイルが再生されるまで繰り返す。
  4. すべての音声が再生完了したら、適切なメッセージを表示する。

実装ステップ

ステップ1：音声ファイルのリストを作成する
まず、複数の音声ファイルをリストとして管理します。これは、URLの配列で保持します。

let audioFiles: [URL] = [
    URL(string: "https://example.com/audio1.mp3")!,
    URL(string: "https://example.com/audio2.mp3")!,
    URL(string: "https://example.com/audio3.mp3")!
]

ステップ2：AVPlayerを使って再生する
次に、AVPlayerを使って音声ファイルを再生します。最初の音声ファイルをAVPlayerItemに設定し、AVPlayerで再生を開始します。

var player: AVPlayer?
var currentIndex = 0

func playAudio(at index: Int) {
    guard index < audioFiles.count else {
        print("すべての音声ファイルが再生されました")
        return
    }

    let playerItem = AVPlayerItem(url: audioFiles[index])
    player = AVPlayer(playerItem: playerItem)
    player?.play()

    NotificationCenter.default.addObserver(self, 
                                           selector: #selector(audioDidFinish(_:)), 
                                           name: .AVPlayerItemDidPlayToEndTime, 
                                           object: playerItem)
}

ステップ3：再生完了を検知して次の音声を再生
再生が完了したら、次の音声ファイルを自動的に再生するために、NotificationCenterを利用します。AVPlayerItemDidPlayToEndTimeの通知を受け取り、次のトラックを再生するロジックを実装します。

@objc func audioDidFinish(_ notification: Notification) {
    currentIndex += 1
    playAudio(at: currentIndex)
}

ステップ4：すべての音声が再生された後の処理
すべての音声ファイルが再生されたら、適切なメッセージを表示します。すべてのトラックが終了したことをユーザーに知らせるためのメッセージを追加します。

func playAudio(at index: Int) {
    guard index < audioFiles.count else {
        print("すべての音声ファイルが再生されました")
        return
    }

    let playerItem = AVPlayerItem(url: audioFiles[index])
    player = AVPlayer(playerItem: playerItem)
    player?.play()

    NotificationCenter.default.addObserver(self, 
                                           selector: #selector(audioDidFinish(_:)), 
                                           name: .AVPlayerItemDidPlayToEndTime, 
                                           object: playerItem)
}

演習の最終形態

全体のコードを以下にまとめます。

import AVFoundation

class AudioPlayerManager {
    var player: AVPlayer?
    var currentIndex = 0
    let audioFiles: [URL] = [
        URL(string: "https://example.com/audio1.mp3")!,
        URL(string: "https://example.com/audio2.mp3")!,
        URL(string: "https://example.com/audio3.mp3")!
    ]

    // 音声を再生するメソッド
    func playAudio(at index: Int) {
        guard index < audioFiles.count else {
            print("すべての音声ファイルが再生されました")
            return
        }

        let playerItem = AVPlayerItem(url: audioFiles[index])
        player = AVPlayer(playerItem: playerItem)
        player?.play()

        NotificationCenter.default.addObserver(self, 
                                               selector: #selector(audioDidFinish(_:)), 
                                               name: .AVPlayerItemDidPlayToEndTime, 
                                               object: playerItem)
    }

    // 再生完了時に呼ばれるメソッド
    @objc func audioDidFinish(_ notification: Notification) {
        currentIndex += 1
        playAudio(at: currentIndex)
    }

    // 再生開始
    func startPlayback() {
        playAudio(at: currentIndex)
    }
}

// 使用例
let audioPlayer = AudioPlayerManager()
audioPlayer.startPlayback()

まとめ

この演習では、複数の音声ファイルを自動的に連続再生する機能を実装しました。再生完了イベントを利用して次の音声を再生し、すべてのトラックが再生されるまで繰り返す機能を実現しました。この機能は、音楽プレーヤーやポッドキャストアプリなどでよく使われるものです。

このような課題を通じて、再生完了の検知と自動的な次の操作を実装するスキルを身に付け、実際のアプリケーションに応用できるようにしましょう。

まとめ

本記事では、SwiftでデリゲートやNotificationCenterを利用して音声や動画の再生完了を検知する方法を詳しく解説しました。また、再生完了後の処理として、次のメディアを自動で再生する方法や、アプリへの応用例、トラブルシューティングの方法も紹介しました。

再生完了イベントを適切に活用することで、音楽プレーヤー、動画ストリーミングアプリ、教育アプリなどでユーザー体験を向上させることが可能です。これらの知識を実際のプロジェクトに活かし、より魅力的なアプリケーションを作成しましょう。

Swift
動画再生 アプリ開発 デリゲート Swift 音声再生

コメント

コメントする

目次