As the lead developer and shepherd of the open platform, we realize that we have a responsibility to app developers -- those who invested in the platform by adopting it and building applications specifically for Android. These developers each contribute to making the platform better -- because when developers support a platform with their applications, the platform becomes better and more attractive to consumers. As more developers build great apps for Android, more consumers are likely to buy Android devices because of the availability of great software content (app titles like Fruit Ninja or Google Maps). As more delighted consumers adopt Android phones and tablets, it creates a larger audience for app developers to sell more apps. The result is a strategy that is good for developers (they sell more apps), good for device manufacturers (they sell more devices) and good for consumers (they get more features and innovation).
In biological terms, this is sometimes referred to as an ecosystem. In economic terms, this is known as a virtuous cycle -- a set of events that reinforces itself through a feedback loop. Each iteration of the cycle positively reinforces the previous one. These cycles will continue in the direction of their momentum until an external factor intervenes and breaks the cycle.
When we first contemplated Android and formed the Open Handset Alliance, we wanted to create an open virtuous cycle where all members of the ecosystem would benefit. We thought hard about what types of external factors could intervene to weaken the ecosystem as a whole. One important external factor we knew could do this was incompatibilities between implementations of Android. Let me explain:
Imagine a hypothetical situation where the platform on each phone sold was just a little bit different. Different enough where Google Maps would run normally on one phone but run terribly slow on another. Let's say, for sake of example, that Android implemented an API that put the phone to sleep for a fraction of a second to conserve battery life when nothing was moving on the screen. The API prototype for such a function might look like SystemClock.sleep(millis) where the parameter "millis" is the number of milliseconds to put the device to sleep for.
If one phone manufacturer implemented SystemClock.sleep() incorrectly, and interpreted the parameter as Seconds instead of Milliseconds, the phone would be put to sleep a thousand times longer than intended! This manufacturer’s phone would have a terrible time running Google Maps. If apps don’t run well across devices due to incompatibilities, consumers would leave the ecosystem, followed by developers. The end of the virtuous cycle.
We have never believed in a “one size fits all” strategy, so we found a way to enable differentiation for device manufactures while protecting developers and consumers from incompatibilities by offering a free "compatibility test suite" (CTS). CTS is a set of software tools that tests and exercises the platform to make sure that (for example) SystemClock.sleep(millis) actually puts the device to sleep for only milliseconds. Like Android, the test suite is freely available to everyone under the Apache open source license: http://source.android.com/compatibility/cts-intro.html
While Android remains free for anyone to use as they would like, only Android compatible devices benefit from the full Android ecosystem. By joining the Open Handset Alliance, each member contributes to and builds one Android platform -- not a bunch of incompatible versions. We’re grateful to the over 85 Open Handset Alliance members who have helped us build the Android ecosystem and continue to drive innovation at an incredible pace. Thanks to their support the Android ecosystem now has over 500 million Android-compatible devices and counting!
Posted by Andy Rubin, Senior Vice President of Mobile and Digital Content