page.title=Building Live TV Apps
page.tags=tv, tif
helpoutsWidget=true
page.article=true

@jd:body

<div id="tb-wrapper">
<div id="tb">
  <h2>You should also read</h2>
  <ul>
    <li><a href="{@docRoot}reference/android/media/tv/package-summary.html">
      android.media.tv</a></li>
  </ul>
</div>
</div>

<p>
  Watching live television shows and other continuous, channel-based content is a big part of the
  TV experience. Android supports receiving and playback of live video content through the TV Input
  Framework in Android 5.0 (API level 21).
  This framework provides a unified method for receiving audio and video channel content
  from hardware sources, such as HDMI ports and built-in-tuners, and software sources, such as
  video streamed over the internet.
</p>
<p>
  The framework enables developers to define live TV input sources by implementing a TV input
  service. This service publishes a list of channels and programs to the TV Provider. The live TV
  app on a TV device gets the list of available channels and programs from the TV Provider and
  displays them to a user. When a user selects a specific channel, the live TV app creates a
  session for the associated TV input service through the TV Input Manager, and tells the TV input
  service to tune to the requested channel and play the content to a display surface provided by
  the TV app.
</p>

<img src="{@docRoot}images/tv/tv-tif-overview.png" id="figure1">
<p class="img-caption">
  <strong>Figure 1.</strong> Functional diagram of the TV Input Framework
</p>

<p>
  The TV Input Framework is designed to provide access to a wide variety of live TV input sources
  and bring them together in a single user interface for users to browse, view, and enjoy content.
  Building a TV input service for your content can help make it more accessible on TV devices.
</p>

<p>For more information about TV Input Framework, see the
<a href="{@docRoot}reference/android/media/tv/package-summary.html">android.media.tv</a>
reference.</p>
