initialize method

Future<void> initialize()

Attempts to open the given url and load metadata about the video.

Implementation

Future<void> initialize() async {
  if (_isDisposed) {
    throw Exception(
        'initialize was called on a disposed VlcPlayerController');
  }
  if (value.isInitialized) {
    throw Exception('Already Initialized');
  }

  _lifeCycleObserver = VlcAppLifeCycleObserver(this);
  _lifeCycleObserver!.initialize();

  await vlcPlayerPlatform.create(
    viewId: _viewId,
    uri: dataSource,
    type: dataSourceType,
    package: package,
    hwAcc: hwAcc,
    autoPlay: autoPlay,
    options: options,
  );

  final initializingCompleter = Completer<void>();

  // listen for media events
  void mediaEventListener(VlcMediaEvent event) {
    if (_isDisposed) {
      return;
    }

    switch (event.mediaEventType) {
      case VlcMediaEventType.opening:
        value = value.copyWith(
          isPlaying: false,
          isBuffering: true,
          isEnded: false,
          playingState: PlayingState.buffering,
          errorDescription: VlcPlayerValue.noError,
        );
        break;

      case VlcMediaEventType.paused:
        value = value.copyWith(
          isPlaying: false,
          isBuffering: false,
          playingState: PlayingState.paused,
        );
        break;

      case VlcMediaEventType.stopped:
        value = value.copyWith(
          isPlaying: false,
          isBuffering: false,
          isRecording: false,
          playingState: PlayingState.stopped,
          position: Duration.zero,
        );
        break;

      case VlcMediaEventType.playing:
        value = value.copyWith(
          isEnded: false,
          isPlaying: true,
          isBuffering: false,
          playingState: PlayingState.playing,
          duration: event.duration,
          size: event.size,
          playbackSpeed: event.playbackSpeed,
          audioTracksCount: event.audioTracksCount,
          activeAudioTrack: event.activeAudioTrack,
          spuTracksCount: event.spuTracksCount,
          activeSpuTrack: event.activeSpuTrack,
          errorDescription: VlcPlayerValue.noError,
        );
        break;

      case VlcMediaEventType.ended:
        value = value.copyWith(
          isPlaying: false,
          isBuffering: false,
          isEnded: true,
          isRecording: false,
          playingState: PlayingState.ended,
          position: event.position,
        );
        break;

      case VlcMediaEventType.buffering:
      case VlcMediaEventType.timeChanged:
        value = value.copyWith(
          isEnded: false,
          isBuffering: event.mediaEventType == VlcMediaEventType.buffering,
          position: event.position,
          duration: event.duration,
          playbackSpeed: event.playbackSpeed,
          bufferPercent: event.bufferPercent,
          size: event.size,
          audioTracksCount: event.audioTracksCount,
          activeAudioTrack: event.activeAudioTrack,
          spuTracksCount: event.spuTracksCount,
          activeSpuTrack: event.activeSpuTrack,
          isPlaying: event.isPlaying,
          playingState: (event.isPlaying ?? false)
              ? PlayingState.playing
              : value.playingState,
          errorDescription: VlcPlayerValue.noError,
        );
        break;

      case VlcMediaEventType.mediaChanged:
        break;

      case VlcMediaEventType.recording:
        value = value.copyWith(
          playingState: PlayingState.recording,
          isRecording: event.isRecording,
          recordPath: event.recordPath,
        );
        break;

      case VlcMediaEventType.error:
        value = value.copyWith(
          isPlaying: false,
          isBuffering: false,
          isEnded: false,
          playingState: PlayingState.error,
          errorDescription: VlcPlayerValue.unknownError,
        );
        break;

      case VlcMediaEventType.unknown:
        break;
    }
  }

  void errorListener(Object obj) {
    final e = obj as PlatformException;
    value = VlcPlayerValue.erroneous(e.message);
    if (!initializingCompleter.isCompleted) {
      initializingCompleter.completeError(obj);
    }
  }

  vlcPlayerPlatform
      .mediaEventsFor(_viewId)
      .listen(mediaEventListener, onError: errorListener);

  // listen for renderer devices events
  void rendererEventListener(VlcRendererEvent event) {
    if (_isDisposed) {
      return;
    }
    switch (event.eventType) {
      case VlcRendererEventType.attached:
      case VlcRendererEventType.detached:
        _notifyOnRendererListeners(
          event.eventType,
          event.rendererId,
          event.rendererName,
        );
        break;
      case VlcRendererEventType.unknown:
        break;
    }
  }

  vlcPlayerPlatform.rendererEventsFor(_viewId).listen(rendererEventListener);

  if (!initializingCompleter.isCompleted) {
    initializingCompleter.complete(null);
  }
  //
  value = value.copyWith(
    isInitialized: true,
    playingState: PlayingState.initialized,
  );

  _notifyOnInitListeners();

  return initializingCompleter.future;
}