android.os.Process#THREAD_PRIORITY_AUDIO源码实例Demo

public ExoPlayerImplInternal(Handler eventHandler, boolean playWhenReady,
    boolean[] rendererEnabledFlags, int minBufferMs, int minRebufferMs) {
  this.eventHandler = eventHandler;
  this.playWhenReady = playWhenReady;
  this.rendererEnabledFlags = new boolean[rendererEnabledFlags.length];
  this.minBufferUs = minBufferMs * 1000L;
  this.minRebufferUs = minRebufferMs * 1000L;
  for (int i = 0; i < rendererEnabledFlags.length; i++) {
    this.rendererEnabledFlags[i] = rendererEnabledFlags[i];
  }

  this.state = ExoPlayer.STATE_IDLE;
  this.durationUs = TrackRenderer.UNKNOWN_TIME_US;
  this.bufferedPositionUs = TrackRenderer.UNKNOWN_TIME_US;

  mediaClock = new MediaClock();
  enabledRenderers = new ArrayList<TrackRenderer>(rendererEnabledFlags.length);
  // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
  // not normally change to this priority" is incorrect.
  internalPlaybackThread = new PriorityHandlerThread(getClass().getSimpleName() + ":Handler",
      Process.THREAD_PRIORITY_AUDIO);
  internalPlaybackThread.start();
  handler = new Handler(internalPlaybackThread.getLooper(), this);
}
 

public PlaybackThread() {
    // Give this thread a high priority for more precise event timing
    super(TAG + "#" + PlaybackThread.class.getSimpleName(), Process.THREAD_PRIORITY_AUDIO);

    // Init fields
    mPaused = true;
    mReleasing = false;
    mRenderModeApi21 = mVideoRenderTimingMode.isRenderModeApi21();
    mRenderingStarted = true;
    mAVLocked = false;
    mLastBufferingUpdateTime = 0;
    mLastCueEventTime = 0;
    mOnTimelineCueListener = new Timeline.OnCueListener() {
        @Override
        public void onCue(Cue cue) {
            mEventHandler.sendMessage(mEventHandler.obtainMessage(MEDIA_CUE, cue));
        }
    };
}
 

public void init(Activity activity, GLSurfaceView glView) {
    try {
        audioHandlerThread = new HandlerThread("AudioHandlerThread", Process.THREAD_PRIORITY_AUDIO);
        audioHandlerThread.start();
        audioHandler = new AudioHandler(audioHandlerThread.getLooper());
        mCameraHandler = new CameraHandler(this);
        this.context = activity;

        // Define a handler that receives camera-control messages from other threads.  All calls
        // to Camera must be made on the same thread.  Note we create this before the renderer
        // thread, so we know the fully-constructed object will be visible.
        mRenderer = new CameraSurfaceRenderer(mCameraHandler, sVideoEncoder);
        mGLView = glView;
        mGLView.setRenderer(mRenderer);
        mGLView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);

        mRtmpHandlerThread = new HandlerThread("RtmpStreamerThread"); //, Process.THREAD_PRIORITY_BACKGROUND);
        mRtmpHandlerThread.start();
        mRtmpStreamer = new RTMPStreamer(mRtmpHandlerThread.getLooper());

        connectivityManager = (ConnectivityManager) this.getSystemService(
                Context.CONNECTIVITY_SERVICE);
    }
    catch (Exception e) {
        e.printStackTrace();
    }
}
 

public ExoPlayerImplInternal(Renderer[] renderers, TrackSelector trackSelector,
    LoadControl loadControl, boolean playWhenReady, Handler eventHandler,
    PlaybackInfo playbackInfo, ExoPlayer player) {
  this.renderers = renderers;
  this.trackSelector = trackSelector;
  this.loadControl = loadControl;
  this.playWhenReady = playWhenReady;
  this.eventHandler = eventHandler;
  this.state = ExoPlayer.STATE_IDLE;
  this.playbackInfo = playbackInfo;
  this.player = player;

  rendererCapabilities = new RendererCapabilities[renderers.length];
  for (int i = 0; i < renderers.length; i++) {
    renderers[i].setIndex(i);
    rendererCapabilities[i] = renderers[i].getCapabilities();
  }
  standaloneMediaClock = new StandaloneMediaClock();
  enabledRenderers = new Renderer[0];
  window = new Timeline.Window();
  period = new Timeline.Period();
  trackSelector.init(this);

  // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
  // not normally change to this priority" is incorrect.
  internalPlaybackThread = new PriorityHandlerThread("ExoPlayerImplInternal:Handler",
      Process.THREAD_PRIORITY_AUDIO);
  internalPlaybackThread.start();
  handler = new Handler(internalPlaybackThread.getLooper(), this);
}
 

public ExoPlayerImplInternal(
    Renderer[] renderers,
    TrackSelector trackSelector,
    TrackSelectorResult emptyTrackSelectorResult,
    LoadControl loadControl,
    BandwidthMeter bandwidthMeter,
    boolean playWhenReady,
    @Player.RepeatMode int repeatMode,
    boolean shuffleModeEnabled,
    Handler eventHandler,
    Clock clock) {
  this.renderers = renderers;
  this.trackSelector = trackSelector;
  this.emptyTrackSelectorResult = emptyTrackSelectorResult;
  this.loadControl = loadControl;
  this.bandwidthMeter = bandwidthMeter;
  this.playWhenReady = playWhenReady;
  this.repeatMode = repeatMode;
  this.shuffleModeEnabled = shuffleModeEnabled;
  this.eventHandler = eventHandler;
  this.clock = clock;
  this.queue = new MediaPeriodQueue();

  backBufferDurationUs = loadControl.getBackBufferDurationUs();
  retainBackBufferFromKeyframe = loadControl.retainBackBufferFromKeyframe();

  seekParameters = SeekParameters.DEFAULT;
  playbackInfo =
      PlaybackInfo.createDummy(/* startPositionUs= */ C.TIME_UNSET, emptyTrackSelectorResult);
  playbackInfoUpdate = new PlaybackInfoUpdate();
  rendererCapabilities = new RendererCapabilities[renderers.length];
  for (int i = 0; i < renderers.length; i++) {
    renderers[i].setIndex(i);
    rendererCapabilities[i] = renderers[i].getCapabilities();
  }
  mediaClock = new DefaultMediaClock(this, clock);
  pendingMessages = new ArrayList<>();
  enabledRenderers = new Renderer[0];
  window = new Timeline.Window();
  period = new Timeline.Period();
  trackSelector.init(/* listener= */ this, bandwidthMeter);

  // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
  // not normally change to this priority" is incorrect.
  internalPlaybackThread =
      new HandlerThread("ExoPlayerImplInternal:Handler", Process.THREAD_PRIORITY_AUDIO);
  internalPlaybackThread.start();
  handler = clock.createHandler(internalPlaybackThread.getLooper(), this);
  deliverPendingMessageAtStartPositionRequired = true;
}
 

public ExoPlayerImplInternal(
    Renderer[] renderers,
    TrackSelector trackSelector,
    TrackSelectorResult emptyTrackSelectorResult,
    LoadControl loadControl,
    BandwidthMeter bandwidthMeter,
    boolean playWhenReady,
    @Player.RepeatMode int repeatMode,
    boolean shuffleModeEnabled,
    Handler eventHandler,
    ExoPlayer player,
    Clock clock) {
  this.renderers = renderers;
  this.trackSelector = trackSelector;
  this.emptyTrackSelectorResult = emptyTrackSelectorResult;
  this.loadControl = loadControl;
  this.bandwidthMeter = bandwidthMeter;
  this.playWhenReady = playWhenReady;
  this.repeatMode = repeatMode;
  this.shuffleModeEnabled = shuffleModeEnabled;
  this.eventHandler = eventHandler;
  this.player = player;
  this.clock = clock;
  this.queue = new MediaPeriodQueue();

  backBufferDurationUs = loadControl.getBackBufferDurationUs();
  retainBackBufferFromKeyframe = loadControl.retainBackBufferFromKeyframe();

  seekParameters = SeekParameters.DEFAULT;
  playbackInfo =
      PlaybackInfo.createDummy(/* startPositionUs= */ C.TIME_UNSET, emptyTrackSelectorResult);
  playbackInfoUpdate = new PlaybackInfoUpdate();
  rendererCapabilities = new RendererCapabilities[renderers.length];
  for (int i = 0; i < renderers.length; i++) {
    renderers[i].setIndex(i);
    rendererCapabilities[i] = renderers[i].getCapabilities();
  }
  mediaClock = new DefaultMediaClock(this, clock);
  pendingMessages = new ArrayList<>();
  enabledRenderers = new Renderer[0];
  window = new Timeline.Window();
  period = new Timeline.Period();
  trackSelector.init(/* listener= */ this, bandwidthMeter);

  // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
  // not normally change to this priority" is incorrect.
  internalPlaybackThread = new HandlerThread("ExoPlayerImplInternal:Handler",
      Process.THREAD_PRIORITY_AUDIO);
  internalPlaybackThread.start();
  handler = clock.createHandler(internalPlaybackThread.getLooper(), this);
}
 

public ExoPlayerImplInternal(
    Renderer[] renderers,
    TrackSelector trackSelector,
    TrackSelectorResult emptyTrackSelectorResult,
    LoadControl loadControl,
    BandwidthMeter bandwidthMeter,
    boolean playWhenReady,
    @Player.RepeatMode int repeatMode,
    boolean shuffleModeEnabled,
    Handler eventHandler,
    ExoPlayer player,
    Clock clock) {
  this.renderers = renderers;
  this.trackSelector = trackSelector;
  this.emptyTrackSelectorResult = emptyTrackSelectorResult;
  this.loadControl = loadControl;
  this.bandwidthMeter = bandwidthMeter;
  this.playWhenReady = playWhenReady;
  this.repeatMode = repeatMode;
  this.shuffleModeEnabled = shuffleModeEnabled;
  this.eventHandler = eventHandler;
  this.player = player;
  this.clock = clock;
  this.queue = new MediaPeriodQueue();

  backBufferDurationUs = loadControl.getBackBufferDurationUs();
  retainBackBufferFromKeyframe = loadControl.retainBackBufferFromKeyframe();

  seekParameters = SeekParameters.DEFAULT;
  playbackInfo =
      PlaybackInfo.createDummy(/* startPositionUs= */ C.TIME_UNSET, emptyTrackSelectorResult);
  playbackInfoUpdate = new PlaybackInfoUpdate();
  rendererCapabilities = new RendererCapabilities[renderers.length];
  for (int i = 0; i < renderers.length; i++) {
    renderers[i].setIndex(i);
    rendererCapabilities[i] = renderers[i].getCapabilities();
  }
  mediaClock = new DefaultMediaClock(this, clock);
  pendingMessages = new ArrayList<>();
  enabledRenderers = new Renderer[0];
  window = new Timeline.Window();
  period = new Timeline.Period();
  trackSelector.init(/* listener= */ this, bandwidthMeter);

  // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
  // not normally change to this priority" is incorrect.
  internalPlaybackThread = new HandlerThread("ExoPlayerImplInternal:Handler",
      Process.THREAD_PRIORITY_AUDIO);
  internalPlaybackThread.start();
  handler = clock.createHandler(internalPlaybackThread.getLooper(), this);
}
 

public ExoPlayerImplInternal(
    Renderer[] renderers,
    TrackSelector trackSelector,
    TrackSelectorResult emptyTrackSelectorResult,
    LoadControl loadControl,
    BandwidthMeter bandwidthMeter,
    boolean playWhenReady,
    @Player.RepeatMode int repeatMode,
    boolean shuffleModeEnabled,
    Handler eventHandler,
    Clock clock) {
  this.renderers = renderers;
  this.trackSelector = trackSelector;
  this.emptyTrackSelectorResult = emptyTrackSelectorResult;
  this.loadControl = loadControl;
  this.bandwidthMeter = bandwidthMeter;
  this.playWhenReady = playWhenReady;
  this.repeatMode = repeatMode;
  this.shuffleModeEnabled = shuffleModeEnabled;
  this.eventHandler = eventHandler;
  this.clock = clock;
  this.queue = new MediaPeriodQueue();

  backBufferDurationUs = loadControl.getBackBufferDurationUs();
  retainBackBufferFromKeyframe = loadControl.retainBackBufferFromKeyframe();

  seekParameters = SeekParameters.DEFAULT;
  playbackInfo =
      PlaybackInfo.createDummy(/* startPositionUs= */ C.TIME_UNSET, emptyTrackSelectorResult);
  playbackInfoUpdate = new PlaybackInfoUpdate();
  rendererCapabilities = new RendererCapabilities[renderers.length];
  for (int i = 0; i < renderers.length; i++) {
    renderers[i].setIndex(i);
    rendererCapabilities[i] = renderers[i].getCapabilities();
  }
  mediaClock = new DefaultMediaClock(this, clock);
  pendingMessages = new ArrayList<>();
  enabledRenderers = new Renderer[0];
  window = new Timeline.Window();
  period = new Timeline.Period();
  trackSelector.init(/* listener= */ this, bandwidthMeter);

  // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
  // not normally change to this priority" is incorrect.
  internalPlaybackThread = new HandlerThread("ExoPlayerImplInternal:Handler",
      Process.THREAD_PRIORITY_AUDIO);
  internalPlaybackThread.start();
  handler = clock.createHandler(internalPlaybackThread.getLooper(), this);
}
 

public AudioEncoderThread(String name) {
    super(name, Process.THREAD_PRIORITY_AUDIO);
}
 

public ExoPlayerImplInternal(
    Renderer[] renderers,
    TrackSelector trackSelector,
    TrackSelectorResult emptyTrackSelectorResult,
    LoadControl loadControl,
    BandwidthMeter bandwidthMeter,
    boolean playWhenReady,
    @Player.RepeatMode int repeatMode,
    boolean shuffleModeEnabled,
    Handler eventHandler,
    Clock clock) {
  this.renderers = renderers;
  this.trackSelector = trackSelector;
  this.emptyTrackSelectorResult = emptyTrackSelectorResult;
  this.loadControl = loadControl;
  this.bandwidthMeter = bandwidthMeter;
  this.playWhenReady = playWhenReady;
  this.repeatMode = repeatMode;
  this.shuffleModeEnabled = shuffleModeEnabled;
  this.eventHandler = eventHandler;
  this.clock = clock;
  this.queue = new MediaPeriodQueue();

  backBufferDurationUs = loadControl.getBackBufferDurationUs();
  retainBackBufferFromKeyframe = loadControl.retainBackBufferFromKeyframe();

  seekParameters = SeekParameters.DEFAULT;
  playbackInfo =
      PlaybackInfo.createDummy(/* startPositionUs= */ C.TIME_UNSET, emptyTrackSelectorResult);
  playbackInfoUpdate = new PlaybackInfoUpdate();
  rendererCapabilities = new RendererCapabilities[renderers.length];
  for (int i = 0; i < renderers.length; i++) {
    renderers[i].setIndex(i);
    rendererCapabilities[i] = renderers[i].getCapabilities();
  }
  mediaClock = new DefaultMediaClock(this, clock);
  pendingMessages = new ArrayList<>();
  enabledRenderers = new Renderer[0];
  window = new Timeline.Window();
  period = new Timeline.Period();
  trackSelector.init(/* listener= */ this, bandwidthMeter);

  // Note: The documentation for Process.THREAD_PRIORITY_AUDIO that states "Applications can
  // not normally change to this priority" is incorrect.
  internalPlaybackThread = new HandlerThread("ExoPlayerImplInternal:Handler",
      Process.THREAD_PRIORITY_AUDIO);
  internalPlaybackThread.start();
  handler = clock.createHandler(internalPlaybackThread.getLooper(), this);
}
 

@Override
public void onCreate() {
    super.onCreate();
    mHandlerThread = new HandlerThread(THREAD_NAME, Process.THREAD_PRIORITY_AUDIO);
    mHandlerThread.start();

    mPlayerHandler = new PlayerHandler(mHandlerThread.getLooper());
    mMediaPlayer = new MediaPlayer();

    initializeMediaPlayer();
    mStopServiceHandler = new StopHandler(mHandlerThread.getLooper());

    // instantiate target used to load track artwork.
    mMediaSessionArtworkTarget = new MediaSessionArtworkTarget();

    // create handler on the main thread to avoid throwing error
    // with picasso when bitmap is retrieved and loaded in notification.
    mMainThreadHandler = new Handler(getApplicationContext().getMainLooper());

    mWifiLock = ((WifiManager) getBaseContext().getSystemService(Context.WIFI_SERVICE))
            .createWifiLock(WifiManager.WIFI_MODE_FULL, WIFI_LOCK_TAG);

    mLocalBroadcastManager = LocalBroadcastManager.getInstance(getApplicationContext());

    mNotificationManager = NotificationManager.getInstance(this);

    mPlayerPlaylist = PlayerPlaylist.getInstance();

    mHasAlreadyPlayed = false;

    mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);

    mMediaSession = new MediaSessionWrapper(this, new MediaSessionCallback(), mAudioManager);
}
 

/**
 * Checks whether Thread priority is THREAD_PRIORITY_AUDIO or not.
 * @param tid Thread id.
 * @return true for THREAD_PRIORITY_AUDIO and false otherwise.
 */
@CalledByNative
private static boolean isThreadPriorityAudio(int tid) {
    return Process.getThreadPriority(tid) == Process.THREAD_PRIORITY_AUDIO;
}
 

/**
 * Checks whether Thread priority is THREAD_PRIORITY_AUDIO or not.
 * @param tid Thread id.
 * @return true for THREAD_PRIORITY_AUDIO and false otherwise.
 */
@CalledByNative
private static boolean isThreadPriorityAudio(int tid) {
    return Process.getThreadPriority(tid) == Process.THREAD_PRIORITY_AUDIO;
}