src/com/android/tv/util/PipInputManager.java - platform/packages/apps/TV - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.tv.util;

 import android.content.Context;
 import android.media.tv.TvInputInfo;
 import android.media.tv.TvInputManager;
 import android.media.tv.TvInputManager.TvInputCallback;
 import android.util.ArraySet;
 import android.util.Log;

 import com.android.tv.ChannelTuner;
 import com.android.tv.R;
 import com.android.tv.data.Channel;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * A class that manages inputs for PIP. All tuner inputs are represented to one tuner input for PIP.
  * Hidden inputs should not be visible to the users.
  */
 public class PipInputManager {
     private static final String TAG = "PipInputManager";

     // Tuner inputs aren't distinguished each other in PipInput. They are handled as one input.
     // Therefore, we define a fake input id for the unified input.
     private static final String TUNER_INPUT_ID = "tuner_input_id";

     private final Context mContext;
     private final TvInputManagerHelper mInputManager;
     private final ChannelTuner mChannelTuner;
     private boolean mStarted;
     private final Map<String, PipInput> mPipInputMap = new HashMap<>();  // inputId -> PipInput
     private final Set<Listener> mListeners = new ArraySet<>();

     private final TvInputCallback mTvInputCallback = new TvInputCallback() {
         @Override
         public void onInputAdded(String inputId) {
             TvInputInfo input = mInputManager.getTvInputInfo(inputId);
             if (input.isPassthroughInput()) {
                 boolean available = mInputManager.getInputState(input)
                         == TvInputManager.INPUT_STATE_CONNECTED;
                 mPipInputMap.put(inputId, new PipInput(inputId, available));
             } else if (!mPipInputMap.containsKey(TUNER_INPUT_ID)) {
                 boolean available = mChannelTuner.getBrowsableChannelCount() != 0;
                 mPipInputMap.put(TUNER_INPUT_ID, new PipInput(TUNER_INPUT_ID, available));
             } else {
                 return;
             }
             for (Listener l : mListeners) {
                 l.onPipInputListUpdated();
             }
         }

         @Override
         public void onInputRemoved(String inputId) {
             PipInput pipInput = mPipInputMap.remove(inputId);
             if (pipInput == null) {
                 if (!mPipInputMap.containsKey(TUNER_INPUT_ID)) {
                     Log.w(TAG, "A TV input (" + inputId + ") isn't tracked in PipInputManager");
                     return;
                 }
                 if (mInputManager.getTunerTvInputSize() > 0) {
                     return;
                 }
                 mPipInputMap.remove(TUNER_INPUT_ID);
             }
             for (Listener l : mListeners) {
                 l.onPipInputListUpdated();
             }
         }

         @Override
         public void onInputStateChanged(String inputId, int state) {
             PipInput pipInput = mPipInputMap.get(inputId);
             if (pipInput == null) {
                 // For tuner input, state change is handled in mChannelTunerListener.
                 return;
             }
             pipInput.updateAvailability();
         }
     };

     private final ChannelTuner.Listener mChannelTunerListener = new ChannelTuner.Listener() {
         @Override
         public void onLoadFinished() { }

         @Override
         public void onCurrentChannelUnavailable(Channel channel) { }

         @Override
         public void onBrowsableChannelListChanged() {
             PipInput tunerInput = mPipInputMap.get(TUNER_INPUT_ID);
             if (tunerInput == null) {
                 return;
             }
             tunerInput.updateAvailability();
         }

         @Override
         public void onChannelChanged(Channel previousChannel, Channel currentChannel) {
             if (previousChannel != null && currentChannel != null
                     && !previousChannel.isPassthrough() && !currentChannel.isPassthrough()) {
                 // Channel change between channels for tuner inputs.
                 return;
             }
             PipInput previousMainInput = getPipInput(previousChannel);
             if (previousMainInput != null) {
                 previousMainInput.updateAvailability();
             }
             PipInput currentMainInput = getPipInput(currentChannel);
             if (currentMainInput != null) {
                 currentMainInput.updateAvailability();
             }
         }
     };

     public PipInputManager(Context context, TvInputManagerHelper inputManager,
             ChannelTuner channelTuner) {
         mContext = context;
         mInputManager = inputManager;
         mChannelTuner = channelTuner;
     }

     /**
      * Starts {@link PipInputManager}.
      */
     public void start() {
         if (mStarted) {
             return;
         }
         mInputManager.addCallback(mTvInputCallback);
         mChannelTuner.addListener(mChannelTunerListener);
         initializePipInputList();
     }

     /**
      * Stops {@link PipInputManager}.
      */
     public void stop() {
         if (!mStarted) {
             return;
         }
         mInputManager.removeCallback(mTvInputCallback);
         mChannelTuner.removeListener(mChannelTunerListener);
         mPipInputMap.clear();
     }

     /**
      * Adds a {@link PipInputManager.Listener}.
      */
     public void addListener(Listener listener) {
         mListeners.add(listener);
     }

     /**
      * Removes a {@link PipInputManager.Listener}.
      */
     public void removeListener(Listener listener) {
         mListeners.remove(listener);
     }

     /**
      * Gets the size of inputs for PIP.
      *
      * <p>The hidden inputs are not counted.
      *
      * @param availableOnly If {@code true}, it counts only available PIP inputs. Please see {@link
      *        PipInput#isAvailable()} for the details of availability.
      */
     public int getPipInputSize(boolean availableOnly) {
         int count = 0;
         for (PipInput pipInput : mPipInputMap.values()) {
             if (!pipInput.isHidden() && (!availableOnly || pipInput.mAvailable)) {
                 ++count;
             }
             if (pipInput.isPassthrough()) {
                 TvInputInfo info = pipInput.getInputInfo();
                 // Do not count HDMI ports if a CEC device is directly connected to the port.
                 if (info.getParentId() != null && !info.isConnectedToHdmiSwitch()) {
                     --count;
                 }
             }
         }
         return count;
     }

     /**
      * Gets the list of inputs for PIP..
      *
      * <p>The hidden inputs are excluded.
      *
      * @param availableOnly If true, it returns only available PIP inputs. Please see {@link
      *        PipInput#isAvailable()} for the details of availability.
      */
     public List<PipInput> getPipInputList(boolean availableOnly) {
         List<PipInput> pipInputs = new ArrayList<>();
         List<PipInput> removeInputs = new ArrayList<>();
         for (PipInput pipInput : mPipInputMap.values()) {
             if (!pipInput.isHidden() && (!availableOnly || pipInput.mAvailable)) {
                 pipInputs.add(pipInput);
             }
             if (pipInput.isPassthrough()) {
                 TvInputInfo info = pipInput.getInputInfo();
                 // Do not show HDMI ports if a CEC device is directly connected to the port.
                 if (info.getParentId() != null && !info.isConnectedToHdmiSwitch()) {
                     removeInputs.add(mPipInputMap.get(info.getParentId()));
                 }
             }
         }
         if (!removeInputs.isEmpty()) {
             pipInputs.removeAll(removeInputs);
         }
         Collections.sort(pipInputs, new Comparator<PipInput>() {
             @Override
             public int compare(PipInput lhs, PipInput rhs) {
                 if (!lhs.mIsPassthrough) {
                     return -1;
                 }
                 if (!rhs.mIsPassthrough) {
                     return 1;
                 }
                 String a = lhs.getLabel();
                 String b = rhs.getLabel();
                 return a.compareTo(b);
             }
         });
         return pipInputs;
     }

     /**
      * Returns an PIP input corresponding to {@code channel}.
      */
     public PipInput getPipInput(Channel channel) {
         if (channel == null) {
             return null;
         }
         if (channel.isPassthrough()) {
             return mPipInputMap.get(channel.getInputId());
         } else {
             return mPipInputMap.get(TUNER_INPUT_ID);
         }
     }

     /**
      * Returns true, if {@code channel1} and {@code channel2} belong to the same input. For example,
      * two channels from different tuner inputs are also in the same input "Tuner" from PIP
      * point of view.
      */
     public boolean areInSamePipInput(Channel channel1, Channel channel2) {
         PipInput input1 = getPipInput(channel1);
         PipInput input2 = getPipInput(channel2);
         return input1 != null && input2 != null
                 && getPipInput(channel1).equals(getPipInput(channel2));
     }

     private void initializePipInputList() {
         boolean hasTunerInput = false;
         for (TvInputInfo input : mInputManager.getTvInputInfos(false, false)) {
             if (input.isPassthroughInput()) {
                 boolean available = mInputManager.getInputState(input)
                         == TvInputManager.INPUT_STATE_CONNECTED;
                 mPipInputMap.put(input.getId(), new PipInput(input.getId(), available));
             } else if (!hasTunerInput) {
                 hasTunerInput = true;
                 boolean available = mChannelTuner.getBrowsableChannelCount() != 0;
                 mPipInputMap.put(TUNER_INPUT_ID, new PipInput(TUNER_INPUT_ID, available));
             }
         }
         PipInput input = getPipInput(mChannelTuner.getCurrentChannel());
         if (input != null) {
             input.updateAvailability();
         }
         for (Listener l : mListeners) {
             l.onPipInputListUpdated();
         }
     }

     /**
      * Listeners to notify PIP input state changes.
      */
     public interface Listener {
         /**
          * Called when the state (availability) of PIP inputs is changed.
          */
         void onPipInputStateUpdated();

         /**
          * Called when the list of PIP inputs is changed.
          */
         void onPipInputListUpdated();
     }

     /**
      * Input class for PIP. It has useful methods for PIP handling.
      */
     public class PipInput {
         private final String mInputId;
         private final boolean mIsPassthrough;
         private final TvInputInfo mInputInfo;
         private boolean mAvailable;

         private PipInput(String inputId, boolean available) {
             mInputId = inputId;
             mIsPassthrough = !mInputId.equals(TUNER_INPUT_ID);
             if (mIsPassthrough) {
                 mInputInfo = mInputManager.getTvInputInfo(mInputId);
             } else {
                 mInputInfo = null;
             }
             mAvailable = available;
         }

         /**
          * Returns the {@link TvInputInfo} object that matches to this PIP input.
          */
         public TvInputInfo getInputInfo() {
             return mInputInfo;
         }

         /**
          * Returns {@code true}, if the input is available for PIP. If a channel of an input is
          * already played or an input is not connected state or there is no browsable channel, the
          * input is unavailable.
          */
         public boolean isAvailable() {
             return mAvailable;
         }

         /**
          * Returns true, if the input is a passthrough TV input.
          */
         public boolean isPassthrough() {
             return mIsPassthrough;
         }

         /**
          * Gets a channel to play in a PIP view.
          */
         public Channel getChannel() {
             if (mIsPassthrough) {
                 return Channel.createPassthroughChannel(mInputId);
             } else {
                 return mChannelTuner.findNearestBrowsableChannel(
                         Utils.getLastWatchedChannelId(mContext));
             }
         }

         /**
          * Gets a label of the input.
          */
         public String getLabel() {
             if (mIsPassthrough) {
                 return mInputInfo.loadLabel(mContext).toString();
             } else {
                 return mContext.getString(R.string.input_selector_tuner_label);
             }
         }

         /**
          * Gets a long label including a customized label.
          */
         public String getLongLabel() {
             if (mIsPassthrough) {
                 String customizedLabel = Utils.loadLabel(mContext, mInputInfo);
                 String label = getLabel();
                 if (label.equals(customizedLabel)) {
                     return customizedLabel;
                 }
                 return customizedLabel + " (" + label + ")";
             } else {
                 return mContext.getString(R.string.input_long_label_for_tuner);
             }
         }

         /**
          * Updates availability. It returns true, if availability is changed.
          */
         private void updateAvailability() {
             boolean available;
             // current playing input cannot be available for PIP.
             Channel currentChannel = mChannelTuner.getCurrentChannel();
             if (mIsPassthrough) {
                 if (currentChannel != null && currentChannel.getInputId().equals(mInputId)) {
                     available = false;
                 } else {
                     available = mInputManager.getInputState(mInputId)
                             == TvInputManager.INPUT_STATE_CONNECTED;
                 }
             } else {
                 if (currentChannel != null && !currentChannel.isPassthrough()) {
                     available = false;
                 } else {
                     available = mChannelTuner.getBrowsableChannelCount() > 0;
                 }
             }
             if (mAvailable != available) {
                 mAvailable = available;
                 for (Listener l : mListeners) {
                     l.onPipInputStateUpdated();
                 }
             }
         }

         private boolean isHidden() {
             // mInputInfo is null for the tuner input and it's always visible.
             return mInputInfo != null && mInputInfo.isHidden(mContext);
         }
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.tv.util;

	import android.content.Context;
	import android.media.tv.TvInputInfo;
	import android.media.tv.TvInputManager;
	import android.media.tv.TvInputManager.TvInputCallback;
	import android.util.ArraySet;
	import android.util.Log;

	import com.android.tv.ChannelTuner;
	import com.android.tv.R;
	import com.android.tv.data.Channel;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* A class that manages inputs for PIP. All tuner inputs are represented to one tuner input for PIP.
	* Hidden inputs should not be visible to the users.
	*/
	public class PipInputManager {
	private static final String TAG = "PipInputManager";

	// Tuner inputs aren't distinguished each other in PipInput. They are handled as one input.
	// Therefore, we define a fake input id for the unified input.
	private static final String TUNER_INPUT_ID = "tuner_input_id";

	private final Context mContext;
	private final TvInputManagerHelper mInputManager;
	private final ChannelTuner mChannelTuner;
	private boolean mStarted;
	private final Map<String, PipInput> mPipInputMap = new HashMap<>(); // inputId -> PipInput
	private final Set<Listener> mListeners = new ArraySet<>();

	private final TvInputCallback mTvInputCallback = new TvInputCallback() {
	@Override
	public void onInputAdded(String inputId) {
	TvInputInfo input = mInputManager.getTvInputInfo(inputId);
	if (input.isPassthroughInput()) {
	boolean available = mInputManager.getInputState(input)
	== TvInputManager.INPUT_STATE_CONNECTED;
	mPipInputMap.put(inputId, new PipInput(inputId, available));
	} else if (!mPipInputMap.containsKey(TUNER_INPUT_ID)) {
	boolean available = mChannelTuner.getBrowsableChannelCount() != 0;
	mPipInputMap.put(TUNER_INPUT_ID, new PipInput(TUNER_INPUT_ID, available));
	} else {
	return;
	}
	for (Listener l : mListeners) {
	l.onPipInputListUpdated();
	}
	}

	@Override
	public void onInputRemoved(String inputId) {
	PipInput pipInput = mPipInputMap.remove(inputId);
	if (pipInput == null) {
	if (!mPipInputMap.containsKey(TUNER_INPUT_ID)) {
	Log.w(TAG, "A TV input (" + inputId + ") isn't tracked in PipInputManager");
	return;
	}
	if (mInputManager.getTunerTvInputSize() > 0) {
	return;
	}
	mPipInputMap.remove(TUNER_INPUT_ID);
	}
	for (Listener l : mListeners) {
	l.onPipInputListUpdated();
	}
	}

	@Override
	public void onInputStateChanged(String inputId, int state) {
	PipInput pipInput = mPipInputMap.get(inputId);
	if (pipInput == null) {
	// For tuner input, state change is handled in mChannelTunerListener.
	return;
	}
	pipInput.updateAvailability();
	}
	};

	private final ChannelTuner.Listener mChannelTunerListener = new ChannelTuner.Listener() {
	@Override
	public void onLoadFinished() { }

	@Override
	public void onCurrentChannelUnavailable(Channel channel) { }

	@Override
	public void onBrowsableChannelListChanged() {
	PipInput tunerInput = mPipInputMap.get(TUNER_INPUT_ID);
	if (tunerInput == null) {
	return;
	}
	tunerInput.updateAvailability();
	}

	@Override
	public void onChannelChanged(Channel previousChannel, Channel currentChannel) {
	if (previousChannel != null && currentChannel != null
	&& !previousChannel.isPassthrough() && !currentChannel.isPassthrough()) {
	// Channel change between channels for tuner inputs.
	return;
	}
	PipInput previousMainInput = getPipInput(previousChannel);
	if (previousMainInput != null) {
	previousMainInput.updateAvailability();
	}
	PipInput currentMainInput = getPipInput(currentChannel);
	if (currentMainInput != null) {
	currentMainInput.updateAvailability();
	}
	}
	};

	public PipInputManager(Context context, TvInputManagerHelper inputManager,
	ChannelTuner channelTuner) {
	mContext = context;
	mInputManager = inputManager;
	mChannelTuner = channelTuner;
	}

	/**
	* Starts {@link PipInputManager}.
	*/
	public void start() {
	if (mStarted) {
	return;
	}
	mInputManager.addCallback(mTvInputCallback);
	mChannelTuner.addListener(mChannelTunerListener);
	initializePipInputList();
	}

	/**
	* Stops {@link PipInputManager}.
	*/
	public void stop() {
	if (!mStarted) {
	return;
	}
	mInputManager.removeCallback(mTvInputCallback);
	mChannelTuner.removeListener(mChannelTunerListener);
	mPipInputMap.clear();
	}

	/**
	* Adds a {@link PipInputManager.Listener}.
	*/
	public void addListener(Listener listener) {
	mListeners.add(listener);
	}

	/**
	* Removes a {@link PipInputManager.Listener}.
	*/
	public void removeListener(Listener listener) {
	mListeners.remove(listener);
	}

	/**
	* Gets the size of inputs for PIP.
	*
	* <p>The hidden inputs are not counted.
	*
	* @param availableOnly If {@code true}, it counts only available PIP inputs. Please see {@link
	* PipInput#isAvailable()} for the details of availability.
	*/
	public int getPipInputSize(boolean availableOnly) {
	int count = 0;
	for (PipInput pipInput : mPipInputMap.values()) {
	if (!pipInput.isHidden() && (!availableOnly \|\| pipInput.mAvailable)) {
	++count;
	}
	if (pipInput.isPassthrough()) {
	TvInputInfo info = pipInput.getInputInfo();
	// Do not count HDMI ports if a CEC device is directly connected to the port.
	if (info.getParentId() != null && !info.isConnectedToHdmiSwitch()) {
	--count;
	}
	}
	}
	return count;
	}

	/**
	* Gets the list of inputs for PIP..
	*
	* <p>The hidden inputs are excluded.
	*
	* @param availableOnly If true, it returns only available PIP inputs. Please see {@link
	* PipInput#isAvailable()} for the details of availability.
	*/
	public List<PipInput> getPipInputList(boolean availableOnly) {
	List<PipInput> pipInputs = new ArrayList<>();
	List<PipInput> removeInputs = new ArrayList<>();
	for (PipInput pipInput : mPipInputMap.values()) {
	if (!pipInput.isHidden() && (!availableOnly \|\| pipInput.mAvailable)) {
	pipInputs.add(pipInput);
	}
	if (pipInput.isPassthrough()) {
	TvInputInfo info = pipInput.getInputInfo();
	// Do not show HDMI ports if a CEC device is directly connected to the port.
	if (info.getParentId() != null && !info.isConnectedToHdmiSwitch()) {
	removeInputs.add(mPipInputMap.get(info.getParentId()));
	}
	}
	}
	if (!removeInputs.isEmpty()) {
	pipInputs.removeAll(removeInputs);
	}
	Collections.sort(pipInputs, new Comparator<PipInput>() {
	@Override
	public int compare(PipInput lhs, PipInput rhs) {
	if (!lhs.mIsPassthrough) {
	return -1;
	}
	if (!rhs.mIsPassthrough) {
	return 1;
	}
	String a = lhs.getLabel();
	String b = rhs.getLabel();
	return a.compareTo(b);
	}
	});
	return pipInputs;
	}

	/**
	* Returns an PIP input corresponding to {@code channel}.
	*/
	public PipInput getPipInput(Channel channel) {
	if (channel == null) {
	return null;
	}
	if (channel.isPassthrough()) {
	return mPipInputMap.get(channel.getInputId());
	} else {
	return mPipInputMap.get(TUNER_INPUT_ID);
	}
	}

	/**
	* Returns true, if {@code channel1} and {@code channel2} belong to the same input. For example,
	* two channels from different tuner inputs are also in the same input "Tuner" from PIP
	* point of view.
	*/
	public boolean areInSamePipInput(Channel channel1, Channel channel2) {
	PipInput input1 = getPipInput(channel1);
	PipInput input2 = getPipInput(channel2);
	return input1 != null && input2 != null
	&& getPipInput(channel1).equals(getPipInput(channel2));
	}

	private void initializePipInputList() {
	boolean hasTunerInput = false;
	for (TvInputInfo input : mInputManager.getTvInputInfos(false, false)) {
	if (input.isPassthroughInput()) {
	boolean available = mInputManager.getInputState(input)
	== TvInputManager.INPUT_STATE_CONNECTED;
	mPipInputMap.put(input.getId(), new PipInput(input.getId(), available));
	} else if (!hasTunerInput) {
	hasTunerInput = true;
	boolean available = mChannelTuner.getBrowsableChannelCount() != 0;
	mPipInputMap.put(TUNER_INPUT_ID, new PipInput(TUNER_INPUT_ID, available));
	}
	}
	PipInput input = getPipInput(mChannelTuner.getCurrentChannel());
	if (input != null) {
	input.updateAvailability();
	}
	for (Listener l : mListeners) {
	l.onPipInputListUpdated();
	}
	}

	/**
	* Listeners to notify PIP input state changes.
	*/
	public interface Listener {
	/**
	* Called when the state (availability) of PIP inputs is changed.
	*/
	void onPipInputStateUpdated();

	/**
	* Called when the list of PIP inputs is changed.
	*/
	void onPipInputListUpdated();
	}

	/**
	* Input class for PIP. It has useful methods for PIP handling.
	*/
	public class PipInput {
	private final String mInputId;
	private final boolean mIsPassthrough;
	private final TvInputInfo mInputInfo;
	private boolean mAvailable;

	private PipInput(String inputId, boolean available) {
	mInputId = inputId;
	mIsPassthrough = !mInputId.equals(TUNER_INPUT_ID);
	if (mIsPassthrough) {
	mInputInfo = mInputManager.getTvInputInfo(mInputId);
	} else {
	mInputInfo = null;
	}
	mAvailable = available;
	}

	/**
	* Returns the {@link TvInputInfo} object that matches to this PIP input.
	*/
	public TvInputInfo getInputInfo() {
	return mInputInfo;
	}

	/**
	* Returns {@code true}, if the input is available for PIP. If a channel of an input is
	* already played or an input is not connected state or there is no browsable channel, the
	* input is unavailable.
	*/
	public boolean isAvailable() {
	return mAvailable;
	}

	/**
	* Returns true, if the input is a passthrough TV input.
	*/
	public boolean isPassthrough() {
	return mIsPassthrough;
	}

	/**
	* Gets a channel to play in a PIP view.
	*/
	public Channel getChannel() {
	if (mIsPassthrough) {
	return Channel.createPassthroughChannel(mInputId);
	} else {
	return mChannelTuner.findNearestBrowsableChannel(
	Utils.getLastWatchedChannelId(mContext));
	}
	}

	/**
	* Gets a label of the input.
	*/
	public String getLabel() {
	if (mIsPassthrough) {
	return mInputInfo.loadLabel(mContext).toString();
	} else {
	return mContext.getString(R.string.input_selector_tuner_label);
	}
	}

	/**
	* Gets a long label including a customized label.
	*/
	public String getLongLabel() {
	if (mIsPassthrough) {
	String customizedLabel = Utils.loadLabel(mContext, mInputInfo);
	String label = getLabel();
	if (label.equals(customizedLabel)) {
	return customizedLabel;
	}
	return customizedLabel + " (" + label + ")";
	} else {
	return mContext.getString(R.string.input_long_label_for_tuner);
	}
	}

	/**
	* Updates availability. It returns true, if availability is changed.
	*/
	private void updateAvailability() {
	boolean available;
	// current playing input cannot be available for PIP.
	Channel currentChannel = mChannelTuner.getCurrentChannel();
	if (mIsPassthrough) {
	if (currentChannel != null && currentChannel.getInputId().equals(mInputId)) {
	available = false;
	} else {
	available = mInputManager.getInputState(mInputId)
	== TvInputManager.INPUT_STATE_CONNECTED;
	}
	} else {
	if (currentChannel != null && !currentChannel.isPassthrough()) {
	available = false;
	} else {
	available = mChannelTuner.getBrowsableChannelCount() > 0;
	}
	}
	if (mAvailable != available) {
	mAvailable = available;
	for (Listener l : mListeners) {
	l.onPipInputStateUpdated();
	}
	}
	}

	private boolean isHidden() {
	// mInputInfo is null for the tuner input and it's always visible.
	return mInputInfo != null && mInputInfo.isHidden(mContext);
	}
	}
	}