com.google.android.gms.cast.framework.CastState Java Examples

public void showIntroductoryOverlay(@NonNull Activity activity, @Nullable final MenuItem mediaRouteMenuItem) {
    if (castContext.getCastState() != CastState.NO_DEVICES_AVAILABLE) {
        if (introductoryOverlay != null) {
            introductoryOverlay.remove();
        }
        if (mediaRouteMenuItem != null && mediaRouteMenuItem.isVisible()) {
            new Handler().post(() -> {
                introductoryOverlay = new IntroductoryOverlay.Builder(
                        activity, mediaRouteMenuItem)
                        .setTitleText(context.getString(R.string.introducing_cast_text))
                        .setSingleTime()
                        .setOnOverlayDismissedListener(
                                () -> introductoryOverlay = null)
                        .build();
                introductoryOverlay.show();
            });
        }
    }
}
 

@Override
public void onCastStateChanged(int newState) {
    Log.e("Tuts+", "onCastStateChanged");

    switch( newState ) {
        case CastState.CONNECTED: {

            break;
        } case CastState.CONNECTING: {

            break;
        } case CastState.NOT_CONNECTED: {

            break;
        } case CastState.NO_DEVICES_AVAILABLE: {

        }
    }

    if (newState != CastState.NO_DEVICES_AVAILABLE) {
        showIntroductoryOverlay();
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.video_browser);
    setupActionBar();

    mCastStateListener = new CastStateListener() {
        @Override
        public void onCastStateChanged(int newState) {
            if (newState != CastState.NO_DEVICES_AVAILABLE) {
                showIntroductoryOverlay();
            }
        }
    };

    mCastContext = CastContext.getSharedInstance(this);
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    setContentView(R.layout.video_browser);
    setupActionBar();

    mCastStateListener = new CastStateListener() {
        @Override
        public void onCastStateChanged(int newState) {
            if (newState != CastState.NO_DEVICES_AVAILABLE) {
                showIntroductoryOverlay();
            }
        }
    };
    mCastContext = CastContext.getSharedInstance(this);
}
 

@Override
public void onCastStateChanged(int i) {
    switch (i) {
        case CastState.CONNECTED:
            CastSession session = mCastContext != null ? mCastContext.getSessionManager().getCurrentCastSession() : null;
            if (session == null) break;
            castingTextView.setText(getString(R.string.stream_chromecast_playing, session.getCastDevice().getFriendlyName()));
            break;

        case CastState.CONNECTING:
            castingTextView.setText(getString(R.string.stream_chromecast_connecting));
            break;

        default:
            break;
    }
}
 

@NonNull
private CastStateListener createCastStateListener() {
    return new CastStateListener() {
        @Override
        public void onCastStateChanged(int state) {
            if (state != CastState.NO_DEVICES_AVAILABLE && introductionOverlay != null) {
                showIntroductionOverlay();
            }
        }
    };
}
 

private void updateButtonState(MediaRouteButton button, int state) {
  // hide the button when no device available (default behavior is show it
  // disabled)
  if (CastState.NO_DEVICES_AVAILABLE == state) {
    button.setVisibility(View.GONE);
  } else {
    button.setVisibility(View.VISIBLE);
  }
}
 

public void onSessionStarting(SessionImpl session) {
    this.setCastState(CastState.CONNECTING);
    for (ISessionManagerListener listener : this.sessionManagerListeners) {
        try {
            listener.onSessionStarting(session.getSessionProxy().getWrappedSession());
        } catch (RemoteException e) {
            Log.d(TAG, "Remote exception calling onSessionStarting: " + e.getMessage());
        }
    }
}
 

public void onSessionStartFailed(SessionImpl session, int error) {
    this.currentSession = null;
    this.setCastState(CastState.NOT_CONNECTED);
    for (ISessionManagerListener listener : this.sessionManagerListeners) {
        try {
            listener.onSessionStartFailed(session.getSessionProxy().getWrappedSession(), error);
        } catch (RemoteException e) {
            Log.d(TAG, "Remote exception calling onSessionStartFailed: " + e.getMessage());
        }
    }
}
 

public void onSessionStarted(SessionImpl session, String sessionId) {
    this.currentSession = session;
    this.setCastState(CastState.CONNECTED);
    for (ISessionManagerListener listener : this.sessionManagerListeners) {
        try {
            listener.onSessionStarted(session.getSessionProxy().getWrappedSession(), sessionId);
        } catch (RemoteException e) {
            Log.d(TAG, "Remote exception calling onSessionStarted: " + e.getMessage());
        }
    }
}
 

public void onSessionResumed(SessionImpl session, boolean wasSuspended) {
    this.setCastState(CastState.CONNECTED);
    for (ISessionManagerListener listener : this.sessionManagerListeners) {
        try {
            listener.onSessionResumed(session.getSessionProxy().getWrappedSession(), wasSuspended);
        } catch (RemoteException e) {
            Log.d(TAG, "Remote exception calling onSessionResumed: " + e.getMessage());
        }
    }
}
 

public void onSessionEnded(SessionImpl session, int error) {
    this.currentSession = null;
    this.setCastState(CastState.NOT_CONNECTED);
    for (ISessionManagerListener listener : this.sessionManagerListeners) {
        try {
            listener.onSessionEnded(session.getSessionProxy().getWrappedSession(), error);
        } catch (RemoteException e) {
            Log.d(TAG, "Remote exception calling onSessionEnded: " + e.getMessage());
        }
    }
}
 

public void onSessionResumeFailed(SessionImpl session, int error) {
    this.currentSession = null;
    this.setCastState(CastState.NOT_CONNECTED);
    for (ISessionManagerListener listener : this.sessionManagerListeners) {
        try {
            listener.onSessionResumeFailed(session.getSessionProxy().getWrappedSession(), error);
        } catch (RemoteException e) {
            Log.d(TAG, "Remote exception calling onSessionResumeFailed: " + e.getMessage());
        }
    }
}
 

public void onSessionSuspended(SessionImpl session, int reason) {
    this.setCastState(CastState.NOT_CONNECTED);
    for (ISessionManagerListener listener : this.sessionManagerListeners) {
        try {
            listener.onSessionSuspended(session.getSessionProxy().getWrappedSession(), reason);
        } catch (RemoteException e) {
            Log.d(TAG, "Remote exception calling onSessionSuspended: " + e.getMessage());
        }
    }
}
 

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);

    ((AppCompatActivity) getActivity()).setSupportActionBar(toolbar);

    final ActionBar ab = ((AppCompatActivity) getActivity()).getSupportActionBar();
    if(ab != null){
        ab.setHomeAsUpIndicator(R.drawable.ic_menu_light);
        ab.setDisplayHomeAsUpEnabled(true);
        ab.setTitle(TrestleUtility.getFormattedText(getString(R.string.watch_later), font));
    }

    castStateListener = new CastStateListener() {
        @Override
        public void onCastStateChanged(int newState) {
            if (newState != CastState.NO_DEVICES_AVAILABLE) {
                showIntroductoryOverlay();
            }
        }
    };

    setUpRxBusSubscription();

    layoutManager = new LinearLayoutManager(getActivity());
    recyclerView.setLayoutManager(layoutManager);
    videosAdapter = new VideosAdapter();
    videosAdapter.setOnItemClickListener(this);
    videosAdapter.setOnReloadClickListener(this);

    recyclerView.setItemAnimator(new SlideInUpAnimator());
    recyclerView.setAdapter(videosAdapter);

    // Pagination
    recyclerView.addOnScrollListener(recyclerViewOnScrollListener);

    Call findWatchLaterVideosCall = vimeoService.findWatchLaterVideos(null,
            sortByValue,
            sortOrderValue,
            currentPage,
            PAGE_SIZE);
    calls.add(findWatchLaterVideosCall);
    findWatchLaterVideosCall.enqueue(findVideosFirstFetchCallback);
}
 

private void registerRemoteCallback() {
    if (castContext.getCastState() == CastState.CONNECTED) {
        castSession.getRemoteMediaClient().registerCallback(this);
    }
}
 

private void onCastMediaPlaying() {
    onCastStateChanged(CastState.CONNECTED);
}
 

/**
 * Sends the URL to a chromecast (Or android TV) if it is connected.
 *
 * @param videoURL
 */
private void playOnCast(String videoURL) {
    //ToDo: We probably need to make a custom Cast receiver to play a link from Twitch. As Twitch doesnt allow third party receivers to play link from another origin
    // Use https://www.udacity.com/course/progress#!/c-ud875B and
    // https://github.com/googlecast/CastReferencePlayer
    try {
        String logoImageUrl = mChannelInfo.getLogoURLString();
        String streamerName = mChannelInfo.getDisplayName();
        if (mCastContext != null && mCastContext.getCastState() == CastState.CONNECTED) {
            MediaMetadata mediaMetadata = new MediaMetadata();
            mediaMetadata.putString(getString(R.string.stream_fragment_vod_id), vodId);
            mediaMetadata.putInt(getString(R.string.stream_fragment_vod_length), vodLength);
            mediaMetadata.putString(getString(R.string.stream_fragment_streamerInfo), new Gson().toJson(mChannelInfo));
            mediaMetadata.putString(MediaMetadata.KEY_TITLE, streamerName);
            if (logoImageUrl != null) {
                mediaMetadata.addImage(new WebImage(Uri.parse(logoImageUrl)));
            }

            MediaInfo.Builder mediaBuilder = new MediaInfo.Builder(videoURL)
                    .setMetadata(mediaMetadata)
                    .setContentType("application/x-mpegURL");


            if (vodId == null) {
                mediaBuilder
                        .setStreamType(MediaInfo.STREAM_TYPE_LIVE)
                        .setStreamDuration(MediaInfo.UNKNOWN_DURATION);
            } else {
                mediaBuilder
                        .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED)
                        .setStreamDuration(vodLength / 1000);
            }


            CastSession session = mCastContext.getSessionManager().getCurrentCastSession();
            if (session != null) {
                checkChromecastConnection();
                session.getRemoteMediaClient().load(mediaBuilder.build(), true, 0);
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}