com.google.android.youtube.player.YouTubePlayer Java Examples

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer youTubePlayer, boolean wasRestored) {
    if (!wasRestored) {
        mYouTubePlayer = youTubePlayer;
        mYouTubePlayer.setPlayerStateChangeListener(this);
        mYouTubePlayer.setPlaybackEventListener(this);
        mYouTubePlayer.setOnFullscreenListener(this);
        updateFullscreen();
        updateShowFullscreenButton();
        updateControls();

        if (mVideoId != null) loadVideo();
        else if (!mVideoIds.isEmpty()) loadVideos();
        else if (mPlaylistId != null) loadPlaylist();
    }
}
 

@Override
public void onInitializationSuccess(Provider provider, YouTubePlayer player, boolean wasRestored) {
    if (null == player) return;
    mPlayer = player;

    displayCurrentTime();

    // Start buffering
    if (!wasRestored) {
        player.cueVideo(VIDEO_ID);
    }

    player.setPlayerStyle(PlayerStyle.CHROMELESS);
    mPlayButtonLayout.setVisibility(View.VISIBLE);

    // Add listeners to YouTubePlayer instance
    player.setPlayerStateChangeListener(mPlayerStateChangeListener);
    player.setPlaybackEventListener(mPlaybackEventListener);
}
 

@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
  int controlFlags = player.getFullscreenControlFlags();
  if (isChecked) {
    // If you use the FULLSCREEN_FLAG_ALWAYS_FULLSCREEN_IN_LANDSCAPE, your activity's normal UI
    // should never be laid out in landscape mode (since the video will be fullscreen whenever the
    // activity is in landscape orientation). Therefore you should set the activity's requested
    // orientation to portrait. Typically you would do this in your AndroidManifest.xml, we do it
    // programmatically here since this activity demos fullscreen behavior both with and without
    // this flag).
    setRequestedOrientation(PORTRAIT_ORIENTATION);
    controlFlags |= YouTubePlayer.FULLSCREEN_FLAG_ALWAYS_FULLSCREEN_IN_LANDSCAPE;
  } else {
    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR);
    controlFlags &= ~YouTubePlayer.FULLSCREEN_FLAG_ALWAYS_FULLSCREEN_IN_LANDSCAPE;
  }
  player.setFullscreenControlFlags(controlFlags);
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, final YouTubePlayer player, boolean restored) {
    LogHelper.logMessage("onInitializationSuccess: " + restored + " videoId: " + videoId);
    this.player = player;
    player.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CONTROL_SYSTEM_UI);
    player.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CUSTOM_LAYOUT);
    player.setOnFullscreenListener(new YouTubePlayer.OnFullscreenListener() {

        @Override
        public void onFullscreen(boolean fullscreen) {
            YoutubeOverlayFragment.this.fullscreen = fullscreen;
        }
    });
    if (!restored && videoId != null) {
        player.loadVideo(videoId);
    }
}
 

private void setupFullscreenListener() {
  if (mPlayer == null) {
    DUtils.log("mPlayer is null inside: " + DUtils.currentMethod());
    return;
  }

  mPlayer.setOnFullscreenListener(new YouTubePlayer.OnFullscreenListener() {
    public void onFullscreen(boolean isFullscreen) {
      DUtils.log("setOnFullscreenListener: " + (isFullscreen ? "yes" : "no"));
      VideoPlayerFragment.this.mFullscreen = isFullscreen;

      mFragmentListener.onFullScreen(isFullscreen);
    }

  });
}
 

@Override
public void onInitializationFailure(
    YouTubePlayer.Provider provider, YouTubeInitializationResult errorReason) {
  if (errorReason.isUserRecoverableError()) {
    if (errorDialog == null || !errorDialog.isShowing()) {
      errorDialog = errorReason.getErrorDialog(this, RECOVERY_DIALOG_REQUEST);
      errorDialog.show();
    }
  } else {
    String errorMessage = String.format(getString(R.string.error_player), errorReason.toString());
    Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
  }
}
 

private void updateControls() {
    switch (mControls) {
        case 0:
            mYouTubePlayer.setPlayerStyle(YouTubePlayer.PlayerStyle.CHROMELESS);
            break;
        case 1:
            mYouTubePlayer.setPlayerStyle(YouTubePlayer.PlayerStyle.DEFAULT);
            break;
        case 2:
            mYouTubePlayer.setPlayerStyle(YouTubePlayer.PlayerStyle.MINIMAL);
            break;
    }
}
 

@Override
public void onError(YouTubePlayer.ErrorReason errorReason) {
    /*
     * The most common errorReason is because there is a previous player running so this sets free it
     * and reloads the fragment
     */
    if (attempts <= 3) {
        releaseYoutubePlayer();
        initializeHandler.postDelayed(CourseUnitYoutubePlayerFragment.this::initializeYoutubePlayer, 500);
        attempts++;
    } else {
        redirectToYoutubeDialog();
    }
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player,
    boolean wasRestored) {
  this.player = player;
  player.setPlaylistEventListener(playlistEventListener);
  player.setPlayerStateChangeListener(playerStateChangeListener);
  player.setPlaybackEventListener(playbackEventListener);

  if (!wasRestored) {
    playVideoAtSelection();
  }
  setControlsEnabled(true);
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player,
    boolean wasResumed) {
  VideoWallDemoActivity.this.player = player;
  player.setPlayerStyle(PlayerStyle.CHROMELESS);
  player.setPlayerStateChangeListener(new VideoListener());
  maybeStartDemo();
}
 

@Override
public void onInitializationSuccess(Provider provider,
                                    YouTubePlayer player,
                                    boolean wasRestored) {
    if (getActivity() == null) {
        return;
    }
    final int orientation = getActivity().getResources().getConfiguration().orientation;
    int currentPos = 0;
    if (videoModel != null) {
        currentPos = (int) videoModel.getLastPlayedOffset();
    }
    if (!wasRestored) {
        final Uri uri = Uri.parse(unit.getData().encodedVideos.getYoutubeVideoInfo().url);
        /*
         *  Youtube player loads the video using the video id from the url
         *  the url has the following format "https://www.youtube.com/watch?v=3_yD_cEKoCk" where v is the video id
         */
        final String videoId = uri.getQueryParameter("v");
        player.loadVideo(videoId, currentPos);
        youTubePlayer = player;
        youTubePlayer.setPlayerStateChangeListener(new StateChangeListener());
        youTubePlayer.setPlaybackEventListener(new PlaybackListener());
        youTubePlayer.setOnFullscreenListener(new FullscreenListener());
        if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
            youTubePlayer.setFullscreen(true);
        }
    }
}
 

@Override
public void onError(YouTubePlayer.ErrorReason errorReason) {
  if (errorReason == YouTubePlayer.ErrorReason.UNEXPECTED_SERVICE_DISCONNECTION) {
    // player has encountered an unrecoverable error - stop the demo
    flipDelayHandler.removeCallbacksAndMessages(null);
    state = State.UNINITIALIZED;
    thumbnailLoader.release();
    thumbnailLoader = null;
    player = null;
  } else {
    state = State.VIDEO_ENDED;
  }
}
 

@Override
public void onInitializationFailure(YouTubePlayer.Provider provider,
    YouTubeInitializationResult errorReason) {
  if (errorReason.isUserRecoverableError()) {
    errorReason.getErrorDialog(this, RECOVERY_DIALOG_REQUEST).show();
  } else {
    String errorMessage = String.format(getString(R.string.error_player), errorReason.toString());
    Toast.makeText(this, errorMessage, Toast.LENGTH_LONG).show();
  }
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player,
    boolean wasRestored) {
  if (!wasRestored) {
    player.cueVideo("wKJ9KzGQq0w");
  }
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player,
    boolean wasRestored) {
  this.player = player;
  setControlsEnabled();
  // Specify that we want to handle fullscreen behavior ourselves.
  player.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CUSTOM_LAYOUT);
  player.setOnFullscreenListener(this);
  if (!wasRestored) {
    player.cueVideo("avP5d16wEp0");
  }
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player,
    boolean wasRestored) {
  if (!wasRestored) {
    player.cueVideo("nCgQDjiotG0");
  }
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, YouTubePlayer player,
    boolean wasRestored) {
  player.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CUSTOM_LAYOUT);
  player.setOnFullscreenListener(this);

  if (!wasRestored) {
    player.cueVideo("9c6W4CCU9M4");
  }
}
 

@Override
public void onInitializationSuccess(Provider provider, YouTubePlayer player, boolean restored) {
  this.player = player;
  player.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CUSTOM_LAYOUT);
  player.setOnFullscreenListener((VideoListDemoActivity) getActivity());
  if (!restored && videoId != null) {
    player.cueVideo(videoId);
  }
}
 

@Override
public void onInitializationFailure(YouTubePlayer.Provider provider, YouTubeInitializationResult result) {
    if (result.isUserRecoverableError()) {
        result.getErrorDialog(mYouTubeView.getReactContext().getCurrentActivity(), 0).show();
    }
    mYouTubeView.receivedError(result.toString());
}
 

@Override
public void onInitializationFailure(YouTubePlayer.Provider provider, YouTubeInitializationResult result) {
    youTubePlayer = null;
    if (listener != null) {
        listener.onInitializationFailure(result.name());
    }
}
 

@Override
public void onInitializationSuccess(Provider provider, YouTubePlayer player,
                                    boolean restored) {
    
    //initialise the video player only if it is not restored or is not yet set
    if(!restored){

        //cueVideo takes video ID as argument and initialise the player with that video
        //this method just prepares the player to play the video
        //but does not download any of the video stream until play() is called
        player.cueVideo(getIntent().getStringExtra("VIDEO_ID"));
    }
}
 

@Override
public void onInitializationFailure(YouTubePlayer.Provider provider, YouTubeInitializationResult youTubeInitializationResult) {
    if (youTubeInitializationResult.isUserRecoverableError()) {
        youTubeInitializationResult.getErrorDialog(getActivity(), RECOVERY_DIALOG_REQUEST).show();
    } else {
        //Handle the failure
        Toast.makeText(getActivity(), "onInitializationFailure", Toast.LENGTH_LONG).show();
    }
}
 

@Override
public void onInitializationFailure(YouTubePlayer.Provider provider, YouTubeInitializationResult youTubeInitializationResult) {
    if (youTubeInitializationResult.isUserRecoverableError()) {
        youTubeInitializationResult.getErrorDialog(getActivity(), RECOVERY_DIALOG_REQUEST).show();
    } else {
        //Handle the failure
        Toast.makeText(getActivity(), "onInitializationFailure", Toast.LENGTH_LONG).show();
    }
}
 

@Override
public void onInitializationFailure(YouTubePlayer.Provider provider, YouTubeInitializationResult youTubeInitializationResult) {
    if (youTubeInitializationResult.isUserRecoverableError()) {
        youTubeInitializationResult.getErrorDialog(getActivity(), RECOVERY_DIALOG_REQUEST).show();
    } else {
        //Handle the failure
        Toast.makeText(getActivity(), "onInitializationFailure", Toast.LENGTH_LONG).show();
    }
}
 

private void startYoutubeVideo() {
    Intent intent = new Intent(getActivity(), YouTubePlayerActivity.class);
    String vidoeId = YouTubeUrlParser.getVideoId(youtubeUrl);
// Youtube video ID (Required, You can use YouTubeUrlParser to parse Video Id from url)
    intent.putExtra(YouTubePlayerActivity.EXTRA_VIDEO_ID, vidoeId);

// Youtube player style (DEFAULT as default)
    intent.putExtra(YouTubePlayerActivity.EXTRA_PLAYER_STYLE, YouTubePlayer.PlayerStyle.DEFAULT);

// Screen Orientation Setting (AUTO for default)
// AUTO, AUTO_START_WITH_LANDSCAPE, ONLY_LANDSCAPE, ONLY_PORTRAIT
    intent.putExtra(YouTubePlayerActivity.EXTRA_ORIENTATION, Orientation.AUTO);

// Show audio interface when user adjust volume (true for default)
    intent.putExtra(YouTubePlayerActivity.EXTRA_SHOW_AUDIO_UI, true);

// If the video is not playable, use Youtube app or Internet Browser to play it
// (true for default)
    intent.putExtra(YouTubePlayerActivity.EXTRA_HANDLE_ERROR, true);

// Animation when closing youtubeplayeractivity (none for default)
    intent.putExtra(YouTubePlayerActivity.EXTRA_ANIM_ENTER, R.anim.fade_in);
    intent.putExtra(YouTubePlayerActivity.EXTRA_ANIM_EXIT, R.anim.fade_out);

    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    startActivity(intent);
  }
 

@Override
protected YouTubePlayer.Provider getYouTubePlayerProvider() {
  return (YouTubePlayerFragment) getFragmentManager().findFragmentById(R.id.youtube_fragment);
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, final YouTubePlayer player, boolean restored) {
    youTubePlayer = player;
    youTubePlayer.setPlayerStyle(YouTubePlayer.PlayerStyle.DEFAULT);
    youTubePlayer.setShowFullscreenButton(false);

    if (listener != null) {
        listener.onReady();
    }

    youTubePlayer.setPlaybackEventListener(new YouTubePlayer.PlaybackEventListener() {
        @Override
        public void onPlaying() {
            if (listener != null && youTubePlayer != null && !PlayerStateList.PLAYING.equals(playerState)) {
                playerState = PlayerStateList.PLAYING;
                listener.onPlay(youTubePlayer.getCurrentTimeMillis());
            }
        }

        @Override
        public void onPaused() {
            handleOnPauseEvent();
        }

        @Override
        public void onStopped() {
            //since these are player stop events in case of any player error so pause event not stop.
            handleOnPauseEvent();
        }

        @Override
        public void onBuffering(boolean isBuffering) {
            if (listener != null && youTubePlayer != null) {
                listener.onBuffering((youTubePlayer.getCurrentTimeMillis()), isBuffering);
            }
        }

        @Override
        public void onSeekTo(int newPositionMillis) {
            //just to mimick the pause event before play on seek event.
            handleOnPauseEvent();
        }
    });

    youTubePlayer.setPlayerStateChangeListener(new YouTubePlayer.PlayerStateChangeListener() {
        @Override
        public void onLoading() {
            //intentionally left blank
        }

        @Override
        public void onLoaded(String s) {
            //intentionally left blank
        }

        @Override
        public void onAdStarted() {
            //intentionally left blank
        }

        @Override
        public void onVideoStarted() {
            //intentionally left blank
        }

        @Override
        public void onVideoEnded() {
            handleStopEvent();
        }

        @Override
        public void onError(YouTubePlayer.ErrorReason errorReason) {
            //intentionally left blank
        }
    });

    if (!restored) {
        //do any work here to cue video, play video, etc.
        Bundle arguments = getArguments();
        String videoId = arguments != null ? arguments.getString(ARG_VIDEO_ID) : null;
        if (!TextUtils.isEmpty(videoId)) {
            youTubePlayer.loadVideo(videoId);
        }
    }
}
 

@Override
public void onError(YouTubePlayer.ErrorReason errorReason) {
    mYouTubeView.receivedError(errorReason.toString());
}
 

@Override
protected YouTubePlayer.Provider getYouTubePlayerProvider() {
  return playerView;
}
 

@Override
public void onInitializationSuccess(YouTubePlayer.Provider provider, final YouTubePlayer player, boolean restored) {
    youTubePlayer = player;
    youTubePlayer.setPlayerStyle(YouTubePlayer.PlayerStyle.DEFAULT);
    youTubePlayer.setShowFullscreenButton(true);
    youTubePlayer.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CONTROL_ORIENTATION);
    youTubePlayer.addFullscreenControlFlag(YouTubePlayer.FULLSCREEN_FLAG_CONTROL_SYSTEM_UI);

    youTubePlayer.setPlaybackEventListener(new YouTubePlayer.PlaybackEventListener() {
        @Override
        public void onPlaying() {
            if (youTubePlayer != null && !PlayerStateList.PLAYING.equals(playerState)) {
                playerState = PlayerStateList.PLAYING;
            }
        }

        @Override
        public void onPaused() {
            handleOnPauseEvent();
        }

        @Override
        public void onStopped() {
            handleStopEvent();
        }

        @Override
        public void onBuffering(boolean isBuffering) {
            //intentionally left blank
        }

        @Override
        public void onSeekTo(int newPositionMillis) {
            handleOnPauseEvent();
        }
    });

    youTubePlayer.setPlayerStateChangeListener(new YouTubePlayer.PlayerStateChangeListener() {
        @Override
        public void onLoading() {
            //intentionally left blank
        }

        @Override
        public void onLoaded(String s) {
            //intentionally left blank
        }

        @Override
        public void onAdStarted() {
            //intentionally left blank
        }

        @Override
        public void onVideoStarted() {
            //intentionally left blank
        }

        @Override
        public void onVideoEnded() {
            handleStopEvent();
        }

        @Override
        public void onError(YouTubePlayer.ErrorReason errorReason) {
            //intentionally left blank
        }
    });

    player.setOnFullscreenListener(new YouTubePlayer.OnFullscreenListener() {
        @Override
        public void onFullscreen(boolean b) {
            handleStopEvent();
        }
    });

    if (!restored) {
        youTubePlayer.loadVideo(getVideoId());
    }
}