Filed under Junction
A few weeks ago, we demonstrated a few social applications running between two Android phones, using NFC and Junction to make the setup as easy as possible. Now, we’ve put together a few more demonstrations showing how NFC-equipped phones and televisions can work together.
Unfortunately, we don’t yet have an NFC-equipped television. Instead, we’ve stuck an NFC tag on the back of our TV’s remote control, storing the configuration details of a service running on our settop box. We use a basic HTTP proxy to handle our NFC NDEF messages. Our system has been designed so that no prior setup is required for a phone and TV to interact, just a simple touch between devices.
We modified Android’s built-in Gallery3D application to add support for NFC. We can browse to any photo in our gallery, and by touching the phone to our TV remote, the image is displayed on our big screen.
Next, we demonstrate our whiteboard application running between two phones and a TV. One phone launches the whiteboard application and begins drawing. By touching the phone to another, the application (and application session) are sent to the second device. Touching either phone to the TV remote presents the whiteboard on the TV screen for a shared display.
Here, we show how a phone can be used to control a slideshow presentation on a large display. The phone runs a slideshow program which stores the user’s presentations. Touching the phone and remote sends the presentation to the TV. Once the slides are visible on screen, the phone becomes a remote control for the presentation.
Next, we show a game of Texas Hold’em poker called weHold’Em, played between phones and a TV. Each phone acts as a game controller, showing the player’s private cards. One phone launches the weHold’Em application to begin the game. Touching phones sends the session information to another device, and the new player joins. Touching either phone to the TV remote brings up the game’s public display, and the game begins.
Finally, we show how to use the phone to select video content to play on our TV. We wrote a custom application to browse Netflix streamable movies. We browse the collection of movies on the phone, and touch our phone to the TV remote to beam the content over. Our phone can keep account credentials for a cloud-based media provider, and the NFC transaction allows our TV to access the movie.
As mentioned, we do not have an NFC-equipped television, and so we wrote a simple socket server to handle our NFC messages. We store the configuration information of this proxy in an NFC tag stuck to the back of our TV’s remote. When the phone detects this tag, it hands the NFC connection over to our proxy server, sending the NDEF messages to the listening socket.
A real-world implementation of an NFC-equipped remote control could work in one of two ways. First, the remote control could have an active NFC chip in it, forwarding messages to the TV or settop box. Second, the remote control could have a passive NFC tag in exactly the same way as we’ve done, storing configuration information for a listening service. This would keep the price of the remote lower, and an NFC sticker could be put on the back of an existing remote as we’ve shown. However, this would require that the phone’s operating system supports the connection handover protocol specified by the NFC Forum. Furthermore, the latter would not support scanning passive NFC tags.
Our settop box is capable of loading web content in full screen. The photo and video display applications simply transmit a URL to our settop box, which is loaded on screen. For our other applications (whiteboard, slideshow, and poker) we use the Junction platform to make the development of our device-spanning programs easy. The Slideshow application, for example, took about 45 minutes to write.
Rather than sharing a simple URL, we send a small file with a MIME type we’ve developed called the Application Manifest. This format allows us to represent our application differently for different platforms. This way, a phone can launch an application using native Android code, and our TV can render web content. The Application Manifest also allows us to encode application arguments, which we use to share a unique application session. Supporting this MIME type (and therefore supporting all of the applications we’ve demonstrated) is simple, requiring a hundred or so lines of code.