As most of us know, Adobe is working feverishly on AIR to make it easier for developers to create multiscreen applications that run on various devices and platforms. Unfortunately, the term multiscreen is confusing people.
The common misconception is that multiscreen development means "write once, run everywhere", aka the original AIR marketing slogan. That slogan was appropriate when AIR was just desktop apps, but things have dramatically changed in the past year. Multiscreen development now means developing for multiple screens, not all-in-one.
At first, AIR was all about multi-platform development: create a single AIR application and it would run on Windows, OSX, and Linux platforms. Despite the fact that these platforms had very different operating systems and code bases, AIR enabled developers to actually "write once, run everywhere" which Adobe promoted heavily.
This fundamentally changed in AIR 2.0 with NativeProcesses. To enable apps to communicate natively, it became necessary to package AIR apps as separate file types for each platform. So in this case, "write once" was actually "per platform". This difference didn't really bubble up to tech bloggers so there wasn't anything to change or update the public's expectations.
Recently, non-AIR devs have been talking a lot about multi-device development. It works as a general phrase because that field has been device centric for a while now and the notion of developing for desktop and device from the same code base doesn't come up. In most cases, programmers will turn to web development if they need device and desktop.
But now we have tablets and televisions which begins to confuse identities. Tablets are devices, but TVs are not, so multi-device isn't really accurate. Further, smartphones and tablets are devices, but they have a major difference: screen real estate. Tablets are closer to desktops and televisions in that regard, but all three have different interfaces as well.
Which brings us to multiscreen...
Multiple screens, not all-in-one
In multi-platform and multi-device, the "multi" meant bringing together multiple targets. That's not the case in multiscreen. This is a 180˚ flip from the "multi" we used before, but it works.
Multiscreen is now about taking a single application and developing it for multiple interfaces - one for each screen type: smartphone, tablet, desktop, and television. It's not an all-in-one app, it's one app with many views. The basic app is packaged and released with templates and additional features specific to each screen. The final result can be a single app with multiple views... or many apps built from the same base app.
How this will be implemented will vary from project to project, based on the complexity of the application and the range of distribution the developer is trying to achieve.
For example, it's common for iOS developers to write "universal" apps - one app that works on iPhone and iPad. This is one app that has two layouts and relative functionality. Producing this as a single app is relatively easier because it's just two screens, mobile and tablet, with the same interaction layer. There's no need to address things like mouse clicks and window resizing for desktop or the remote-control and ten-foot experience for television.
In contrast, Christian Cantrell created iReverse, which is truly multiscreen - it runs on smartphones, tablets, desktop, and television. To make it work, he started with a core app and then created several platform-specific shell apps that loaded and configured the core app to fit. Depending on screen size and resolution, the shell would tell the core what size to be, what menu items to add, what kind of input to use, and so on.
Sounding complicated? It will be. Multiscreen apps will have varying levels of complexity so modularity is going to be fundamental. Most apps will share core functionality and add features based on the target configuration.
There's also inter-device communication and control - using devices as controllers for desktop and television apps. This is just taking off, but it's already more than that in some cases. Right now you can use your iPhone to control an AppleTV playing music from iTunes on your desktop computer. What's next? It's likely that your core apps will be fundamentally more robust and universal than you expected. How about using your universal TV remote to stream a video from your friend's smartphone to your television.
Write once, run everywhere was cool, but today multiscreen really means multiple screens and that's plenty of work for now. Maybe in a few years AIR will be powerful enough to make the slogan true again.
(image from Cnet Asia)