1. 包列表
  2. 类列表
  3. android.media.tv.TvTrackInfo

Java 类android.media.tv.TvTrackInfo 实例源码

项目：androidtv-sample    文件：RichTvInputService.java    
@Override
public boolean onSelectTrack(int type, String trackId) {
    if (trackId == null) {
        return true;
    }

    int trackIndex = getIndexFromTrackId(trackId);
    if (mPlayer != null) {
        if (type == TvTrackInfo.TYPE_SUBTITLE) {
            if (!mCaptionEnabled) {
                return false;
            }
            mSelectedSubtitleTrackIndex = trackIndex;
        }

        mPlayer.setSelectedTrack(type, trackIndex);
        notifyTrackSelected(type, trackId);
        return true;
    }
    return false;
}
项目：androidtv-sample    文件：RichTvInputService.java    
@Override
public void onStateChanged(boolean playWhenReady, int playbackState) {
    if (playWhenReady && playbackState == ExoPlayer.STATE_READY) {
        notifyTracksChanged(getAllTracks());
        String audioId = getTrackId(TvTrackInfo.TYPE_AUDIO,
                mPlayer.getSelectedTrack(TvTrackInfo.TYPE_AUDIO));
        String videoId = getTrackId(TvTrackInfo.TYPE_VIDEO,
                mPlayer.getSelectedTrack(TvTrackInfo.TYPE_VIDEO));
        String textId = getTrackId(TvTrackInfo.TYPE_SUBTITLE,
                mPlayer.getSelectedTrack(TvTrackInfo.TYPE_SUBTITLE));

        notifyTrackSelected(TvTrackInfo.TYPE_AUDIO, audioId);
        notifyTrackSelected(TvTrackInfo.TYPE_VIDEO, videoId);
        notifyTrackSelected(TvTrackInfo.TYPE_SUBTITLE, textId);
        notifyVideoAvailable();
    }
}
项目：android_packages_apps_tv    文件：MainActivity.java    
private void applyMultiAudio() {
    List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_AUDIO);
    if (tracks == null) {
        mTvOptionsManager.onMultiAudioChanged(null);
        return;
    }

    String id = TvSettings.getMultiAudioId(this);
    String language = TvSettings.getMultiAudioLanguage(this);
    int channelCount = TvSettings.getMultiAudioChannelCount(this);
    TvTrackInfo bestTrack = TvTrackInfoUtils
            .getBestTrackInfo(tracks, id, language, channelCount);
    if (bestTrack != null) {
        String selectedTrack = getSelectedTrack(TvTrackInfo.TYPE_AUDIO);
        if (!bestTrack.getId().equals(selectedTrack)) {
            selectTrack(TvTrackInfo.TYPE_AUDIO, bestTrack);
        } else {
            mTvOptionsManager.onMultiAudioChanged(
                    Utils.getMultiAudioString(this, bestTrack, false));
        }
        return;
    }
    mTvOptionsManager.onMultiAudioChanged(null);
}
项目：android_packages_apps_tv    文件：MainActivity.java    
private void saveMultiAudioSetting(String trackId) {
    List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_AUDIO);
    if (tracks != null) {
        for (TvTrackInfo track : tracks) {
            if (track.getId().equals(trackId)) {
                TvSettings.setMultiAudioId(this, track.getId());
                TvSettings.setMultiAudioLanguage(this, track.getLanguage());
                TvSettings.setMultiAudioChannelCount(this, track.getAudioChannelCount());
                return;
            }
        }
    }
    TvSettings.setMultiAudioId(this, null);
    TvSettings.setMultiAudioLanguage(this, null);
    TvSettings.setMultiAudioChannelCount(this, 0);
}
项目：android_packages_apps_tv    文件：MultiAudioFragment.java    
@Override
protected List<Item> getItemList() {
    List<TvTrackInfo> tracks = getMainActivity().getTracks(TvTrackInfo.TYPE_AUDIO);
    mSelectedTrackId = getMainActivity().getSelectedTrack(TvTrackInfo.TYPE_AUDIO);

    List<Item> items = new ArrayList<>();
    if (tracks != null) {
        boolean needToShowSampleRate = Utils.needToShowSampleRate(getActivity(), tracks);
        int pos = 0;
        for (final TvTrackInfo track : tracks) {
            RadioButtonItem item = new MultiAudioOptionItem(
                    Utils.getMultiAudioString(getActivity(), track, needToShowSampleRate),
                    track.getId());
            if (track.getId().equals(mSelectedTrackId)) {
                item.setChecked(true);
                mInitialSelectedPosition = pos;
                mSelectedTrackId = mFocusedTrackId = track.getId();
            }
            items.add(item);
            ++pos;
        }
    }
    return items;
}
项目：android_packages_apps_tv    文件：TunerSessionWorker.java    
private void updateCaptionTracks(List<AtscCaptionTrack> captionTracks) {
    if (DEBUG) {
        Log.d(TAG, "Update CaptionTrack " + captionTracks);
    }
    removeTvTracks(TvTrackInfo.TYPE_SUBTITLE);
    mCaptionTrackMap.clear();
    if (captionTracks != null) {
        for (AtscCaptionTrack captionTrack : captionTracks) {
            if (mCaptionTrackMap.indexOfKey(captionTrack.serviceNumber) >= 0) {
                continue;
            }
            String language = captionTrack.language;

            // The service number of the caption service is used for track id of a subtitle.
            // Later, when a subtitle is chosen, track id will be passed on to TsParser.
            TvTrackInfo.Builder builder =
                    new TvTrackInfo.Builder(TvTrackInfo.TYPE_SUBTITLE,
                            SUBTITLE_TRACK_PREFIX + captionTrack.serviceNumber);
            builder.setLanguage(language);
            mTvTracks.add(builder.build());
            mCaptionTrackMap.put(captionTrack.serviceNumber, captionTrack);
        }
    }
    mSession.notifyTracksChanged(mTvTracks);
}
项目：android_packages_apps_tv    文件：TvTrackInfoUtilsTest.java    
public void testComparator() {
    Comparator<TvTrackInfo> comparator = TvTrackInfoUtils.createComparator("1", "en", 1);
    ComparatorTester.withoutEqualsTest(comparator)
            // lang not match
            .addComparableGroup(create("1", "kr", 1), create("2", "kr", 2),
                    create("1", "ja", 1),
                    create("1", "ch", 1))
             // lang match not count match
            .addComparableGroup(create("2", "en", 2), create("3", "en", 3),
                    create("1", "en", 2))
             // lang and count match
            .addComparableGroup(create("2", "en", 1), create("3", "en", 1))
             // all match
            .addComparableGroup(create("1", "en", 1), create("1", "en", 1))
            .test();
}
项目：android_packages_apps_tv    文件：TvOptionsRowAdapterTest.java    
private void waitUntilAudioTracksHaveSize(int expected) {
    long start = SystemClock.elapsedRealtime();
    int size = -1;
    while (SystemClock.elapsedRealtime() < start + WAIT_TRACK_SIZE_TIMEOUT_MS) {
        getInstrumentation().waitForIdleSync();
        List<TvTrackInfo> tracks = mActivity.getTracks(TvTrackInfo.TYPE_AUDIO);
        if (tracks != null) {
            size = tracks.size();
            if (size == expected) {
                return;
            }
        }
        SystemClock.sleep(TRACK_SIZE_CHECK_INTERVAL_MS);
    }
    fail("Waited for " + WAIT_TRACK_SIZE_TIMEOUT_MS + " milliseconds for track size to be "
            + expected + " but was " + size);
}
项目：danish-media-license    文件：DmlTvInputService.java    
private List<TvTrackInfo> getAllTracks() {
  List<TvTrackInfo> tracks = new ArrayList<>();
  for (int i = 0, n = exoPlayerToTvTrackTypeMap.size(); i < n; i++) {
    int exoPlayerTrackType = exoPlayerToTvTrackTypeMap.keyAt(i);
    int tvTrackType = exoPlayerToTvTrackTypeMap.valueAt(i);
    for (int j = 0, m = player.getTrackCount(exoPlayerTrackType); j < m; j++) {
      MediaFormat trackFormat = player.getTrackFormat(exoPlayerTrackType, j);
      String trackId = getTrackId(tvTrackType, j);
      TvTrackInfo.Builder builder = new TvTrackInfo.Builder(tvTrackType, trackId);
      if (tvTrackType == TvTrackInfo.TYPE_VIDEO) {
        builder.setVideoWidth(trackFormat.width);
        builder.setVideoHeight(trackFormat.height);
      } else if (tvTrackType == TvTrackInfo.TYPE_AUDIO) {
        builder.setAudioChannelCount(trackFormat.channelCount);
        builder.setAudioSampleRate(trackFormat.sampleRate);
        if (trackFormat.language != null) {
          builder.setLanguage(trackFormat.language);
        }
      }
      tracks.add(builder.build());
    }
  }
  return tracks;
}
项目：androidtv-sample-inputs    文件：RichTvInputService.java    
@Override
public boolean onSelectTrack(int type, String trackId) {
    if (trackId == null) {
        return true;
    }

    int trackIndex = getIndexFromTrackId(trackId);
    if (mPlayer != null) {
        if (type == TvTrackInfo.TYPE_SUBTITLE) {
            if (! mCaptionEnabled) {
                return false;
            }
            mSelectedSubtitleTrackIndex = trackIndex;
        }

        mPlayer.setSelectedTrack(type, trackIndex);
        notifyTrackSelected(type, trackId);
        return true;
    }
    return false;
}
项目：androidtv-sample-inputs    文件：RichTvInputService.java    
@Override
public void onStateChanged(boolean playWhenReady, int playbackState) {
    if (mPlayer == null) {
        return;
    }

    if (playWhenReady && playbackState == ExoPlayer.STATE_READY) {
        notifyTracksChanged(getAllTracks());
        String audioId = getTrackId(TvTrackInfo.TYPE_AUDIO,
                mPlayer.getSelectedTrack(TvTrackInfo.TYPE_AUDIO));
        String videoId = getTrackId(TvTrackInfo.TYPE_VIDEO,
                mPlayer.getSelectedTrack(TvTrackInfo.TYPE_VIDEO));
        String textId = getTrackId(TvTrackInfo.TYPE_SUBTITLE,
                mPlayer.getSelectedTrack(TvTrackInfo.TYPE_SUBTITLE));

        notifyTrackSelected(TvTrackInfo.TYPE_AUDIO, audioId);
        notifyTrackSelected(TvTrackInfo.TYPE_VIDEO, videoId);
        notifyTrackSelected(TvTrackInfo.TYPE_SUBTITLE, textId);
        notifyVideoAvailable();
    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
            Math.abs(mPlayer.getPlaybackSpeed() - 1) < 0.1 &&
            playWhenReady && playbackState == ExoPlayer.STATE_BUFFERING) {
        notifyVideoUnavailable(TvInputManager.VIDEO_UNAVAILABLE_REASON_BUFFERING);
    }
}
项目：androidtv-sample    文件：RichTvInputService.java    
private List<TvTrackInfo> getAllTracks() {
    String trackId;
    List<TvTrackInfo> tracks = new ArrayList<>();

    int[] trackTypes = {
            DemoPlayer.TYPE_AUDIO,
            DemoPlayer.TYPE_VIDEO,
            DemoPlayer.TYPE_TEXT
    };

    for (int trackType : trackTypes) {
        int count = mPlayer.getTrackCount(trackType);
        for (int i = 0; i < count; i++) {
            MediaFormat format = mPlayer.getTrackFormat(trackType, i);
            trackId = getTrackId(trackType, i);
            TvTrackInfo.Builder builder = new TvTrackInfo.Builder(trackType, trackId);

            if (trackType == DemoPlayer.TYPE_VIDEO) {
                builder.setVideoWidth(format.width);
                builder.setVideoHeight(format.height);
            } else if (trackType == DemoPlayer.TYPE_AUDIO) {
                builder.setAudioChannelCount(format.channelCount);
                builder.setAudioSampleRate(format.sampleRate);
                if (format.language != null) {
                    builder.setLanguage(format.language);
                }
            } else if (trackType == DemoPlayer.TYPE_TEXT) {
                if (format.language != null) {
                    builder.setLanguage(format.language);
                }
            }

            tracks.add(builder.build());
        }
    }
    return tracks;
}
项目：androidtv-sample    文件：RichTvInputService.java    
@Override
public void onSetCaptionEnabled(boolean enabled) {
    mCaptionEnabled = enabled;
    if (mPlayer != null) {
        if (mCaptionEnabled) {
            mPlayer.setSelectedTrack(TvTrackInfo.TYPE_SUBTITLE,
                    mSelectedSubtitleTrackIndex);
        } else {
            mPlayer.setSelectedTrack(TvTrackInfo.TYPE_SUBTITLE, DemoPlayer.TRACK_DISABLED);
        }
    }
}
项目：android_packages_apps_tv    文件：MainActivity.java    
private void selectTrack(int type, TvTrackInfo track) {
    mTvView.selectTrack(type, track == null ? null : track.getId());
    if (type == TvTrackInfo.TYPE_AUDIO) {
        mTvOptionsManager.onMultiAudioChanged(track == null ? null :
                Utils.getMultiAudioString(this, track, false));
    } else if (type == TvTrackInfo.TYPE_SUBTITLE) {
        mTvOptionsManager.onClosedCaptionsChanged(track);
    }
}
项目：android_packages_apps_tv    文件：MainActivity.java    
private void saveClosedCaptionSetting(int option, String trackId) {
    mCaptionSettings.setEnableOption(option);
    if (option == CaptionSettings.OPTION_ON) {
        List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_SUBTITLE);
        if (tracks != null) {
            for (TvTrackInfo track : tracks) {
                if (track.getId().equals(trackId)) {
                    mCaptionSettings.setLanguage(track.getLanguage());
                    mCaptionSettings.setTrackId(trackId);
                    return;
                }
            }
        }
    }
}
项目：android_packages_apps_tv    文件：TunableTvView.java    
@Override
public void onTracksChanged(String inputId, List<TvTrackInfo> tracks) {
    mHasClosedCaption = false;
    for (TvTrackInfo track : tracks) {
        if (track.getType() == TvTrackInfo.TYPE_SUBTITLE) {
            mHasClosedCaption = true;
            break;
        }
    }
    if (mOnTuneListener != null) {
        mOnTuneListener.onStreamInfoChanged(TunableTvView.this);
    }
}
项目：android_packages_apps_tv    文件：TvTrackInfoUtils.java    
/**
 * Selects the  best TvTrackInfo available or the first if none matches.
 *
 * @param tracks       The tracks to choose from
 * @param id           The track id to match.
 * @param language     The language to match.
 * @param channelCount The channel count to match.
 * @return the best matching track or the first one if none matches.
 */
public static TvTrackInfo getBestTrackInfo(List<TvTrackInfo> tracks, String id, String language,
        int channelCount) {
    if (tracks == null) {
        return null;
    }
    Comparator<TvTrackInfo> comparator = createComparator(id, language, channelCount);
    TvTrackInfo best = null;
    for (TvTrackInfo track : tracks) {
        if (comparator.compare(track, best) > 0) {
            best = track;
        }
    }
    return best;
}
项目：android_packages_apps_tv    文件：Utils.java    
public static boolean needToShowSampleRate(Context context, List<TvTrackInfo> tracks) {
    Set<String> multiAudioStrings = new HashSet<>();
    for (TvTrackInfo track : tracks) {
        String multiAudioString = getMultiAudioString(context, track, false);
        if (multiAudioStrings.contains(multiAudioString)) {
            return true;
        }
        multiAudioStrings.add(multiAudioString);
    }
    return false;
}
项目：android_packages_apps_tv    文件：TvOptionsRowAdapter.java    
@VisibleForTesting
boolean updateMultiAudioAction() {
    List<TvTrackInfo> audioTracks = getMainActivity().getTracks(TvTrackInfo.TYPE_AUDIO);
    boolean oldEnabled = MenuAction.SELECT_AUDIO_LANGUAGE_ACTION.isEnabled();
    boolean newEnabled = audioTracks != null && audioTracks.size() > 1;
    if (oldEnabled != newEnabled) {
        MenuAction.SELECT_AUDIO_LANGUAGE_ACTION.setEnabled(newEnabled);
        return true;
    }
    return false;
}
项目：android_packages_apps_tv    文件：TunerSessionWorker.java    
private void doSelectTrack(int type, String trackId) {
    int numTrackId = trackId != null
            ? Integer.parseInt(trackId.substring(TRACK_PREFIX_SIZE)) : -1;
    if (type == TvTrackInfo.TYPE_AUDIO) {
        if (trackId == null) {
            return;
        }
        AtscAudioTrack audioTrack = mAudioTrackMap.get(numTrackId);
        if (audioTrack == null) {
            return;
        }
        int oldAudioPid = mChannel.getAudioPid();
        mChannel.selectAudioTrack(audioTrack.index);
        int newAudioPid = mChannel.getAudioPid();
        if (oldAudioPid != newAudioPid) {
            mPlayer.setSelectedTrack(MpegTsPlayer.TRACK_TYPE_AUDIO, audioTrack.index);
        }
        mSession.notifyTrackSelected(type, trackId);
    } else if (type == TvTrackInfo.TYPE_SUBTITLE) {
        if (trackId == null) {
            mSession.notifyTrackSelected(type, null);
            mCaptionTrack = null;
            stopCaptionTrack();
            return;
        }
        for (TvTrackInfo track : mTvTracks) {
            if (track.getId().equals(trackId)) {
                // The service number of the caption service is used for track id of a
                // subtitle track. Passes the following track id on to TsParser.
                mSession.notifyTrackSelected(type, trackId);
                mCaptionTrack = mCaptionTrackMap.get(numTrackId);
                startCaptionTrack();
                return;
            }
        }
    }
}
项目：android_packages_apps_tv    文件：TunerSessionWorker.java    
private void removeTvTracks(int trackType) {
    Iterator<TvTrackInfo> iterator = mTvTracks.iterator();
    while (iterator.hasNext()) {
        TvTrackInfo tvTrackInfo = iterator.next();
        if (tvTrackInfo.getType() == trackType) {
            iterator.remove();
        }
    }
}
项目：android_packages_apps_tv    文件：TunerSessionWorker.java    
private void updateVideoTrack(int width, int height) {
    removeTvTracks(TvTrackInfo.TYPE_VIDEO);
    mTvTracks.add(new TvTrackInfo.Builder(TvTrackInfo.TYPE_VIDEO, VIDEO_TRACK_ID)
            .setVideoWidth(width).setVideoHeight(height).build());
    mSession.notifyTracksChanged(mTvTracks);
    mSession.notifyTrackSelected(TvTrackInfo.TYPE_VIDEO, VIDEO_TRACK_ID);
}
项目：android_packages_apps_tv    文件：TunerSessionWorker.java    
private void notifyAudioTracksUpdated() {
    if (mPlayer == null) {
        // Audio tracks will be updated later once player initialization is done.
        return;
    }
    int audioTrackCount = mPlayer.getTrackCount(MpegTsPlayer.TRACK_TYPE_AUDIO);
    removeTvTracks(TvTrackInfo.TYPE_AUDIO);
    for (int i = 0; i < audioTrackCount; i++) {
        AtscAudioTrack audioTrack = mAudioTrackMap.get(i);
        if (audioTrack == null) {
            continue;
        }
        String language = audioTrack.language;
        if (language == null && mChannel.getAudioTracks() != null
                && mChannel.getAudioTracks().size() == mAudioTrackMap.size()) {
            // If a language is not present, use a language field in PMT section parsed.
            language = mChannel.getAudioTracks().get(i).language;
        }
        // Save the index to the audio track.
        // Later, when an audio track is selected, both the audio pid and its audio stream
        // type reside in the selected index position of the tuner channel's audio data.
        audioTrack.index = i;
        TvTrackInfo.Builder builder = new TvTrackInfo.Builder(
                TvTrackInfo.TYPE_AUDIO, AUDIO_TRACK_PREFIX + i);
        builder.setLanguage(language);
        builder.setAudioChannelCount(audioTrack.channelCount);
        builder.setAudioSampleRate(audioTrack.sampleRate);
        TvTrackInfo track = builder.build();
        mTvTracks.add(track);
    }
    mSession.notifyTracksChanged(mTvTracks);
}
项目：android_packages_apps_tv    文件：TunerSessionWorker.java    
private void doDiscoverCaptionServiceNumber(int serviceNumber) {
    int index = mCaptionTrackMap.indexOfKey(serviceNumber);
    if (index < 0) {
        AtscCaptionTrack captionTrack = new AtscCaptionTrack();
        captionTrack.serviceNumber = serviceNumber;
        captionTrack.wideAspectRatio = false;
        captionTrack.easyReader = false;
        mCaptionTrackMap.put(serviceNumber, captionTrack);
        mTvTracks.add(new TvTrackInfo.Builder(TvTrackInfo.TYPE_SUBTITLE,
                SUBTITLE_TRACK_PREFIX + serviceNumber).build());
        mSession.notifyTracksChanged(mTvTracks);
    }
}
项目：danish-media-license    文件：DmlTvInputService.java    
@Override
public void onStateChanged(boolean playWhenReady, int playbackState) {
  if (playWhenReady && playbackState == DemoPlayer.STATE_READY) {
    notifyTracksChanged(getAllTracks());
    String videoId = getTrackId(TvTrackInfo.TYPE_VIDEO,
        player.getSelectedTrack(TvTrackInfo.TYPE_VIDEO));
    String audioId = getTrackId(TvTrackInfo.TYPE_AUDIO,
        player.getSelectedTrack(TvTrackInfo.TYPE_AUDIO));
    notifyTrackSelected(TvTrackInfo.TYPE_VIDEO, videoId);
    notifyTrackSelected(TvTrackInfo.TYPE_AUDIO, audioId);
    notifyVideoAvailable();
  }
}
项目：iWediaSimpleTvInputService    文件：TvSession.java    
private void resetTracks() {
    mTracks.clear();
    mTracksIndices.clear();
    notifyTracksChanged(mTracks);
    notifyTrackSelected(TvTrackInfo.TYPE_AUDIO, null);
    notifyTrackSelected(TvTrackInfo.TYPE_VIDEO, null);
    notifyTrackSelected(TvTrackInfo.TYPE_SUBTITLE, null);
}
项目：androidtv-sample-inputs    文件：RichTvInputService.java    
@Override
public void onSetCaptionEnabled(boolean enabled) {
    mCaptionEnabled = enabled;
    if (mPlayer != null) {
        if (mCaptionEnabled) {
            mPlayer.setSelectedTrack(TvTrackInfo.TYPE_SUBTITLE,
                    mSelectedSubtitleTrackIndex);
        } else {
            mPlayer.setSelectedTrack(TvTrackInfo.TYPE_SUBTITLE, DemoPlayer.TRACK_DISABLED);
        }
    }
}
项目：android_packages_apps_tv    文件：TvOptionsManager.java    
public void onClosedCaptionsChanged(TvTrackInfo track) {
    mClosedCaptionsLanguage = (track == null) ? null
            : (track.getLanguage() != null) ? track.getLanguage()
                    : mContext.getString(R.string.default_language);
    notifyOptionChanged(OPTION_CLOSED_CAPTIONS);
}
项目：android_packages_apps_tv    文件：MainActivity.java    
private void applyClosedCaption() {
    List<TvTrackInfo> tracks = getTracks(TvTrackInfo.TYPE_SUBTITLE);
    if (tracks == null) {
        mTvOptionsManager.onClosedCaptionsChanged(null);
        return;
    }

    boolean enabled = mCaptionSettings.isEnabled();
    mTvView.setClosedCaptionEnabled(enabled);

    String selectedTrackId = getSelectedTrack(TvTrackInfo.TYPE_SUBTITLE);
    TvTrackInfo alternativeTrack = null;
    if (enabled) {
        String language = mCaptionSettings.getLanguage();
        String trackId = mCaptionSettings.getTrackId();
        for (TvTrackInfo track : tracks) {
            if (Utils.isEqualLanguage(track.getLanguage(), language)) {
                if (track.getId().equals(trackId)) {
                    if (!track.getId().equals(selectedTrackId)) {
                        selectTrack(TvTrackInfo.TYPE_SUBTITLE, track);
                    } else {
                        // Already selected. Update the option string only.
                        mTvOptionsManager.onClosedCaptionsChanged(track);
                    }
                    if (DEBUG) {
                        Log.d(TAG, "Subtitle Track Selected {id=" + track.getId()
                                + ", language=" + track.getLanguage() + "}");
                    }
                    return;
                } else if (alternativeTrack == null) {
                    alternativeTrack = track;
                }
            }
        }
        if (alternativeTrack != null) {
            if (!alternativeTrack.getId().equals(selectedTrackId)) {
                selectTrack(TvTrackInfo.TYPE_SUBTITLE, alternativeTrack);
            } else {
                mTvOptionsManager.onClosedCaptionsChanged(alternativeTrack);
            }
            if (DEBUG) {
                Log.d(TAG, "Subtitle Track Selected {id=" + alternativeTrack.getId()
                        + ", language=" + alternativeTrack.getLanguage() + "}");
            }
            return;
        }
    }
    if (selectedTrackId != null) {
        selectTrack(TvTrackInfo.TYPE_SUBTITLE, null);
        if (DEBUG) Log.d(TAG, "Subtitle Track Unselected");
        return;
    }
    mTvOptionsManager.onClosedCaptionsChanged(null);
}
项目：android_packages_apps_tv    文件：MainActivity.java    
public List<TvTrackInfo> getTracks(int type) {
    return mTvView.getTracks(type);
}
项目：android_packages_apps_tv    文件：InputSessionManager.java    
@Override
public void onTracksChanged(String inputId, List<TvTrackInfo> tracks) {
    mDelegate.onTracksChanged(inputId, tracks);
}
项目：android_packages_apps_tv    文件：ClosedCaptionFragment.java    
private String getLabel(TvTrackInfo track) {
    if (track.getLanguage() != null) {
        return new Locale(track.getLanguage()).getDisplayName();
    }
    return getString(R.string.default_language);
}
项目：android_packages_apps_tv    文件：TunableTvView.java    
@Override
public void onTrackSelected(String inputId, int type, String trackId) {
    if (trackId == null) {
        // A track is unselected.
        if (type == TvTrackInfo.TYPE_VIDEO) {
            mVideoWidth = 0;
            mVideoHeight = 0;
            mVideoFormat = StreamInfo.VIDEO_DEFINITION_LEVEL_UNKNOWN;
            mVideoFrameRate = 0f;
            mVideoDisplayAspectRatio = 0f;
        } else if (type == TvTrackInfo.TYPE_AUDIO) {
            mAudioChannelCount = StreamInfo.AUDIO_CHANNEL_COUNT_UNKNOWN;
        }
    } else {
        List<TvTrackInfo> tracks = getTracks(type);
        boolean trackFound = false;
        if (tracks != null) {
            for (TvTrackInfo track : tracks) {
                if (track.getId().equals(trackId)) {
                    if (type == TvTrackInfo.TYPE_VIDEO) {
                        mVideoWidth = track.getVideoWidth();
                        mVideoHeight = track.getVideoHeight();
                        mVideoFormat = Utils.getVideoDefinitionLevelFromSize(
                                mVideoWidth, mVideoHeight);
                        mVideoFrameRate = track.getVideoFrameRate();
                        if (mVideoWidth <= 0 || mVideoHeight <= 0) {
                            mVideoDisplayAspectRatio = 0.0f;
                        } else {
                            float VideoPixelAspectRatio =
                                    track.getVideoPixelAspectRatio();
                            mVideoDisplayAspectRatio = VideoPixelAspectRatio
                                    * mVideoWidth / mVideoHeight;
                        }
                    } else if (type == TvTrackInfo.TYPE_AUDIO) {
                        mAudioChannelCount = track.getAudioChannelCount();
                    }
                    trackFound = true;
                    break;
                }
            }
        }
        if (!trackFound) {
            Log.w(TAG, "Invalid track ID: " + trackId);
        }
    }
    if (mOnTuneListener != null) {
        mOnTuneListener.onStreamInfoChanged(TunableTvView.this);
    }
}
项目：android_packages_apps_tv    文件：TunableTvView.java    
public List<TvTrackInfo> getTracks(int type) {
    return mTvView.getTracks(type);
}
项目：android_packages_apps_tv    文件：TvTrackInfoUtils.java    
/**
 * Compares how closely two {@link android.media.tv.TvTrackInfo}s match {@code language}, {@code
 * channelCount} and {@code id} in that precedence.
 *
 * @param id           The track id to match.
 * @param language     The language to match.
 * @param channelCount The channel count to match.
 * @return -1 if lhs is a worse match, 0 if lhs and rhs match equally and 1 if lhs is a better
 * match.
 */
public static Comparator<TvTrackInfo> createComparator(final String id, final String language,
        final int channelCount) {
    return new Comparator<TvTrackInfo>() {

        @Override
        public int compare(TvTrackInfo lhs, TvTrackInfo rhs) {
            if (lhs == rhs) {
                return 0;
            }
            if (lhs == null) {
                return -1;
            }
            if (rhs == null) {
                return 1;
            }
            // Assumes {@code null} language matches to any language since it means user hasn't
            // selected any track before or selected a track without language information.
            boolean rhsLangMatch = language == null || Utils.isEqualLanguage(rhs.getLanguage(),
                    language);
            boolean lhsLangMatch = language == null || Utils.isEqualLanguage(lhs.getLanguage(),
                    language);
            if (rhsLangMatch) {
                if (lhsLangMatch) {
                    boolean rhsCountMatch = rhs.getAudioChannelCount() == channelCount;
                    boolean lhsCountMatch = lhs.getAudioChannelCount() == channelCount;
                    if (rhsCountMatch) {
                        if (lhsCountMatch) {
                            boolean rhsIdMatch = rhs.getId().equals(id);
                            boolean lhsIdMatch = lhs.getId().equals(id);
                            if (rhsIdMatch) {
                                return lhsIdMatch ? 0 : -1;
                            } else {
                                return lhsIdMatch ? 1 : 0;
                            }

                        } else {
                            return -1;
                        }
                    } else {
                        return lhsCountMatch ? 1 : 0;
                    }
                } else {
                    return -1;
                }
            } else {
                return lhsLangMatch ? 1 : 0;
            }
        }
    };
}
项目：android_packages_apps_tv    文件：Utils.java    
public static String getMultiAudioString(Context context, TvTrackInfo track,
        boolean showSampleRate) {
    if (track.getType() != TvTrackInfo.TYPE_AUDIO) {
        throw new IllegalArgumentException("Not an audio track: " + track);
    }
    String language = context.getString(R.string.default_language);
    if (!TextUtils.isEmpty(track.getLanguage())) {
        language = new Locale(track.getLanguage()).getDisplayName();
    } else {
        Log.d(TAG, "No language information found for the audio track: " + track);
    }

    StringBuilder metadata = new StringBuilder();
    switch (track.getAudioChannelCount()) {
        case AUDIO_CHANNEL_NONE:
            break;
        case AUDIO_CHANNEL_MONO:
            metadata.append(context.getString(R.string.multi_audio_channel_mono));
            break;
        case AUDIO_CHANNEL_STEREO:
            metadata.append(context.getString(R.string.multi_audio_channel_stereo));
            break;
        case AUDIO_CHANNEL_SURROUND_6:
            metadata.append(context.getString(R.string.multi_audio_channel_surround_6));
            break;
        case AUDIO_CHANNEL_SURROUND_8:
            metadata.append(context.getString(R.string.multi_audio_channel_surround_8));
            break;
        default:
            if (track.getAudioChannelCount() > 0) {
                metadata.append(context.getString(R.string.multi_audio_channel_suffix,
                        track.getAudioChannelCount()));
            } else {
                Log.d(TAG, "Invalid audio channel count (" + track.getAudioChannelCount()
                        + ") found for the audio track: " + track);
            }
            break;
    }
    if (showSampleRate) {
        int sampleRate = track.getAudioSampleRate();
        if (sampleRate > 0) {
            if (metadata.length() > 0) {
                metadata.append(", ");
            }
            int integerPart = sampleRate / 1000;
            int tenths = (sampleRate % 1000) / 100;
            metadata.append(integerPart);
            if (tenths != 0) {
                metadata.append(".");
                metadata.append(tenths);
            }
            metadata.append("kHz");
        }
    }

    if (metadata.length() == 0) {
        return language;
    }
    return context.getString(R.string.multi_audio_display_string_with_channel, language,
            metadata.toString());
}
项目：android_packages_apps_tv    文件：TvTrackInfoUtilsTest.java    
private static TvTrackInfo create(String id, String fr, int audioChannelCount) {
    return new TvTrackInfo.Builder(TvTrackInfo.TYPE_AUDIO, id)
            .setLanguage(fr)
            .setAudioChannelCount(audioChannelCount)
            .build();
}
项目：android_packages_apps_tv    文件：TvTrackInfoUtilsTest.java    
public void testGetBestTrackInfo_empty() {
    TvTrackInfo result = getBestTrackInfo(Collections.emptyList(), UN_MATCHED_ID, "en", 1);
    assertEquals("best track ", null, result);
}
项目：android_packages_apps_tv    文件：TvTrackInfoUtilsTest.java    
public void testGetBestTrackInfo_exactMatch() {
    TvTrackInfo result = getBestTrackInfo(ALL, "1", "en", 1);
    assertEquals("best track ", INFO_1_EN_1, result);
}
项目：android_packages_apps_tv    文件：TvTrackInfoUtilsTest.java    
public void testGetBestTrackInfo_langAndChannelCountMatch() {
    TvTrackInfo result = getBestTrackInfo(ALL, UN_MATCHED_ID, "en", 5);
    assertEquals("best track ", INFO_2_EN_5, result);
}