import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
private CastConfiguration(Builder builder) {
    if (builder.mDebugEnabled) {
        mCapabilities |= FEATURE_DEBUGGING;
    }
    if (builder.mLockScreenEnabled) {
        mCapabilities |= FEATURE_LOCKSCREEN;
    }
    if (builder.mNotificationEnabled) {
        mCapabilities |= FEATURE_NOTIFICATION;
    }
    if (builder.mWifiReconnectEnabled) {
        mCapabilities |= FEATURE_WIFI_RECONNECT;
    }
    if (builder.mCaptionPreferenceEnabled) {
        mCapabilities |= FEATURE_CAPTIONS_PREFERENCE;
    }
    if (builder.mAutoReconnectEnabled) {
        mCapabilities |= FEATURE_AUTO_RECONNECT;
    }
    mNotificationActions = new ArrayList<>(builder.mNotificationActions);
    mNotificationCompactActions = new ArrayList<>(builder.mNotificationCompactActions);
    mNextPrevVisibilityPolicy = builder.mNextPrevVisibilityPolicy;
    mApplicationId = builder.mApplicationId;
    mTargetActivity = builder.mTargetActivity;
    if (!builder.mNamespaces.isEmpty()) {
        mNamespaces = new ArrayList<>(builder.mNamespaces);
    }
    if (builder.mLocale != null) {
        mLaunchOptions = new LaunchOptions.Builder().setLocale(builder.mLocale)
                .setRelaunchIfRunning(builder.mRelaunchIfRunning).build();
    } else {
        mLaunchOptions = new LaunchOptions.Builder().setRelaunchIfRunning(false).build();
    }
    mCastControllerImmersive = builder.mCastControllerImmersive;
    mForwardStep = builder.mForwardStep;
    mCustomNotificationService = builder.mCustomNotificationService;
    mMediaRouteDialogFactory = builder.mMediaRouteDialogFactory;
    mDisableLaunchOnConnect = builder.mDisableLaunchOnConnect;
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
public PendingResult<ApplicationConnectionResult> launchApplication(
        GoogleApiClient mApiClient, String mediaAppId, LaunchOptions options)
        throws CastClientException {
    try {
        return Cast.CastApi.launchApplication(mApiClient, mediaAppId, options);
    } catch (RuntimeException e) {
        throw createCastClientException(e);
    }
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
private com.google.android.gms.cast.MediaInfo verifyPlayMedia(MediaInfo mediaInfo) throws CastService.CastClientException {
    setServiceConnected();
    MediaPlayer.LaunchListener listener = Mockito.mock(MediaPlayer.LaunchListener.class);
    PendingResult<Cast.ApplicationConnectionResult> pendingResult
            = Mockito.mock(PendingResult.class);
    Mockito.when(castClient.launchApplication(Mockito.any(GoogleApiClient.class),
                    Mockito.anyString(), Mockito.any(LaunchOptions.class)))
            .thenReturn(pendingResult);


    // playMedia
    service.playMedia(mediaInfo, false, listener);
    Robolectric.runUiThreadTasksIncludingDelayedTasks();

    // CastApi.launchApplication
    Mockito.verify(castClient).launchApplication(Mockito.same(googleApiClient), Mockito.anyString(), Mockito.any(LaunchOptions.class));

    // ResultCallback.setResultCallback
    ArgumentCaptor<ResultCallback> argResultCallback =
            ArgumentCaptor.forClass(ResultCallback.class);
    Mockito.verify(pendingResult).setResultCallback(argResultCallback.capture());

    // ApplicationConnectionResultCallback.onResult
    ResultCallback resultCallback = argResultCallback.getValue();
    Cast.ApplicationConnectionResult result = Mockito.mock(Cast.ApplicationConnectionResult.class);
    Status status = Mockito.mock(Status.class);
    Mockito.when(status.isSuccess()).thenReturn(Boolean.TRUE);
    Mockito.when(result.getStatus()).thenReturn(status);
    ApplicationMetadata applicationMetadata = Mockito.mock(ApplicationMetadata.class);
    Mockito.when(result.getApplicationMetadata()).thenReturn(applicationMetadata);
    resultCallback.onResult(result);
    Robolectric.runUiThreadTasksIncludingDelayedTasks();

    // loadMedia
    ArgumentCaptor<com.google.android.gms.cast.MediaInfo> argMedia =
            ArgumentCaptor.forClass(com.google.android.gms.cast.MediaInfo.class);
    Mockito.verify(mediaPlayer).load(Mockito.same(googleApiClient), argMedia.capture(), Mockito.eq(true));
    return argMedia.getValue();
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
protected void a(ecx paramecx)
{
  try
  {
    String str = this.a;
    LaunchOptions localLaunchOptions = this.b;
    paramecx.a(this);
    ((edg)paramecx.l()).a(str, localLaunchOptions);
    return;
  }
  catch (IllegalStateException localIllegalStateException)
  {
    a(2001);
  }
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
private PendingResult<Cast.ApplicationConnectionResult> launchApplication(
        GoogleApiClient apiClient,
        String appId,
        boolean relaunchIfRunning) {
    LaunchOptions.Builder builder = new LaunchOptions.Builder();
    return Cast.CastApi.launchApplication(apiClient, appId,
            builder.setRelaunchIfRunning(relaunchIfRunning)
                    .build());
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
private void connectCastDevice(boolean forceRelaunch) {
        final CastDevice selectedDevice = mCastDeviceHolder.getCastDevice();
        Timber.d("acquiring a connection to Google Play services for %s", selectedDevice);
        Cast.CastOptions.Builder apiOptionsBuilder = Cast.CastOptions.builder(selectedDevice, new CastListener())
                .setVerboseLoggingEnabled(true);
        mApiClient = new GoogleApiClient.Builder(mContext)
                .addApi(Cast.API, apiOptionsBuilder.build())
                        //XXX will deadlock, instead we repost callbacks to the handler
//                .setHandler(mCallbackHandler)
                .build();
        ConnectionResult res = mApiClient.blockingConnect();
        if (!res.isSuccess()) {
            stopWithError(res.getErrorMessage());
            return;
        }
        String applicationId = mContext.getString(R.string.cast_id);
        LaunchOptions.Builder launchOptions = new LaunchOptions.Builder()
                .setRelaunchIfRunning(forceRelaunch);
        Cast.ApplicationConnectionResult castRes;
        int retries = 0;
        do {
            Timber.d("launching cast application try %d", retries);
            castRes = Cast.CastApi.launchApplication(mApiClient, applicationId,
                    launchOptions.build()).await(30, TimeUnit.SECONDS);
            launchOptions.setRelaunchIfRunning(false);
        } while (!castRes.getStatus().isSuccess() && retries++ < 3);
        if (!castRes.getStatus().isSuccess()) {
            stopWithError(castRes.getStatus().getStatusMessage());
            mSessionId = null;
            return;
        }
        mSessionId = castRes.getSessionId();
        attachMediaChannel();
    }
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
public LaunchOptions getLaunchOptions() {
    return mLaunchOptions;
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
public efk<ebo> a(efd paramefd, String paramString, LaunchOptions paramLaunchOptions)
{
  return paramefd.b(new ebv(this, paramefd, paramString, paramLaunchOptions));
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
ebv(ebp paramebp, efd paramefd, String paramString, LaunchOptions paramLaunchOptions)
{
  this(paramefd);
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
@Override
public PendingResult<Cast.ApplicationConnectionResult> launchApplication(GoogleApiClient client, String applicationId, LaunchOptions launchOptions) {
    return null;
}
 

import com.google.android.gms.cast.LaunchOptions; //导入依赖的package包/类
public abstract void a(String paramString, LaunchOptions paramLaunchOptions);