Google TV review and tutorial

  1. Google TV
  2. Developing on a Google TV

Google TV

The Device

Google TV is a multimedia centre that takes in an HDMI feed and overlays it with the Android operating system. It attempts to connect to and communicate with a settop box (cable box) through the connecting HDMI cable. It reads channel information and controls the box by changing channels. Some Google TV devices, such as the Logitech Revue, have the ability to control your television as well. By integrating Google TV into a home theatre system, you have the ability to host native android applications and experience Chrome through your television. To interact with the device, users are given a keyboard and mouse in one controller. The controller is a standard keyboard which has had the arrow keys and numerical pad replaced with a digital arrow pad and a laptop-styled touch-pad mouse.

User experience and interface (UX/UI)

Most of the interfacing is done through the digital arrow keys as they seem to be the most intuitive. The standard approach to android design is still available as the keyboards have the standard back, home, menu and search buttons that all android phones and devices are equipped with. The user experience for veteran android users will not change much. The addition of the 3.x android SDK provides a more intuitive approach to large screen space utilization. This is accomplished through the Fragment class (more on that below) which allows users to hit the back key and retrieve previous states of the same screen. This is contradictory to previous SDK versions as they emphasized retrieving the entire previous screen instead.

Capabilities and Features

The device is connected to a settop box and can provide a cable feed. The feed cannot be changed, added to or interfered with, except through alert messages (Toasts). This is due to agreements between individual channels, cable distributors and third parties over real estate within the video feed. The feed can also be viewed in Picture in Picture mode (PIP). Applications can not call up the video feed to full screen or PIP on their own, only the user has control through the device.

Settop box connection is a neat feature but provides little satisfaction. Through this connection, developers are given the opportunity to read the channel listing information provided by the box/cable provider and ask the Google TV box to change the channel. (This may allow the settop box feed to be brought into focus but I was unable to test this due to lack of equipment)

The main feature that the box provides is a more comprehensive list of supported video streams, specifically VP6 (*.flv or flash), WMV9/VC-1 and MPEG-2 formats are specifically available with the device and not the SDK (supported formats).

Google TV has the ability to act as a server (OTA and within a closed network) and listen to connections without being concerned with battery power. Google has provided sample code that allows decelopers to build Android phone applications that can replace the physical keyboard. (Sample Code).

Mobile and Social Implications

Home theatre systems are communal devices, which make profiling the users somewhat difficult. Consider mutiple individuals having access to one market account or credit card, or a person logging into Facebook and forgetting to log out. The operating system and all of the currently available Android apps were designed for personal devices. This paradigm is no longer relevant, creating a need for innovation within social media. A "user" must be redefined and targetted as groups.


The addition of internet browsing and native application browsing through the TV experience is not something new. Apple has been in this market, with little growth. Technology enthusiasts have been connecting and running their home theatres via computers for years, but the general population does not have this capability. With Google TV, everything is brought to one device. This solves many of the complex problems such as connectivity, accessibility, UI/UX comfort, smart connection to a TV feed and hardware device / operating system developer support. This results in a rich environment powerful enough for simple as well as complex applications.

Google is the first to launch and app market for smart TVs. Apple TV 2 was recently released, with very few apps, no market and poor UX/UI. Boxee is another big name and is gaining speed, but the large number of already existing apps in the the Android market, that just made their way to Google TV, will most likely overwhelm the competition. Finally, it looks like Sony has been describing their Google TV initiative as one of their prized projects. This means that there will likely be some strong devices coming out to support Google TV.


Although the UX/UI is well designed, there has been little innovation in terms of providing new features for developers. The most appealing feature that Google has demonstrated at Google I/O is its ability to interact and add content to the cable feed. However, this is not currently available and likey will not be in the near future.

I have yet to see a device that is fast enough to offer a UX that is as good as its smaller tablet counterparts. The devices are slow, so non-native apps tend to offer poor experiences. The devices currently being distributed are about a year old and some are still awaiting the new SDK. It is yet to be seen whether these devices will show improvement with the new release.

Developing on a Google TV


Honeycomb introduced the Fragment class. This allows developers to change parts of their screen without it affecting others. Fragments live their own life cycle, which is similar to that of an Activity. This is relevant to Google TV, as the screen real estate is very large and Fragments allow for the creation of stronger user flow. This is done by creating 'viewing sections' on the screen, interchanging them with relevant information and allowing for interaction between them and the user.

In the example below, the fragment tag can be replaced by any instantiation of the Fragment class. the FrameLayout can act in the same way. The FrameLayout is the best way to use Fragments, due to some issues or unavailable documentation concerning natively inflated fragments.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=""
	<fragment class="com.classes.example"
		android:id="@+id/fragment" />
		android:id="@+id/list" />

The example below shows how to replace/create fragments.

SampleFragment f = SampleFragment.initialize(object);
FragmentTransaction tr = getFragmentManager().beginTransaction();
tr.replace(, f);

The example below shows the initialization function that passes the relevant information into the Fragment's parameters.

public static SampleFragment initialize(Object serializableObject) {
	Bundle bundle = new Bundle();
	bundle.putSerializable(“Object”, serializableObject);
	SampleFragment sampleFragment = new SampleFragment();
	return sampleFragment;


Although Flash and HTML5 is now available for integration into native applications on tablets (other honeycomb devices), Google TV has not yet provided that feature. Flash and HTML5 (video) are strictly available through chrome. For example, embedding a YouTube video in a native application (using a WebView) will not work on Google TV. The only video solution is the native VideoView (supported formats).

The example below will start a video feed (including flv's).

VideoView videoView = (VideoView) findViewById(;

Open Source

Click here to see some of the Google TV work that I have done. It uses APIs and Bing image APIs to bring Canadians a TV guide.