Although the J2ME API is relatively easy to learn, it is misleading to suggest that mobile Java language game development is somehow simpler than developing console or PC games. In fact, in terms of the percentage share of the total revenue, the development and engineering cost for mobile games could be much larger than those for console or PC games. Most of the speakers at the Austin conference agreed that the biggest (and most expensive) challenge in mobile game development is the support of these many different devices in a fragmented market.
The J2ME platform makes the Java programming language and a standard set of APIs available across all the Java-compatible devices from multiple vendors. Ideally, a J2ME application developed for one Java handset should run without modification on all other handsets supporting the same APIs. However, Java's "Write Once, Run Anywhere" vision has yet to be realized, thanks to the fragmentation of the device market. Meanwhile, there are several reasons why there are so many phone models:
• Because mobile devices are highly personal, each one is designed for a very specific usage pattern. For example, enterprise users, consumers, messaging teenagers, price-conscious users, and hardcore gamers all get different phones with different combinations of functions and UI styles.
• Mobile phone manufacturers need to differentiate their product offerings. Different manufacturers adopt different CPUs, memory sizes, base operation systems, and UI features. They also provide proprietary Java extension APIs.
• Operators need to differentiate their service offerings, such as by customizing the device hardware and software. They can also decide to enable or disable certain data service on the device. For example, NexTel would not permit a third-party J2ME application download to general consumer phones on their network.
• Mobile phones are evolving faster than Moore's law, with hundreds of new device models on the market every year. Those devices support different versions of the J2ME standard and different sets of the optional API packages. Right now, the low-end MIDP 1 devices have the largest installed base. But many new MIDP 2 smart phones, including advanced devices that support the J2ME 3D, Bluetooth, and Web services APIs, are starting to take over the high-end market.
Supporting all the popular devices on the market maximizes the J2ME game's chance of reaching the critical mass for commercial success. A Java application needs to be ported, optimized, and tested for each target device it is intended to run on, which is a complicated challenge. For example, even among Nokia products, Series 60 and Series 40 devices have very different screen sizes, memory sizes, and CPU speeds. Furthermore, the quality control of the Java Runtime Environment (JRE) on devices has been weak. Different devices could have different bugs, particularly in their thread or memory management implementations. You have to work around those problems one device at a time. This can be extremely expensive and requires extensive technical know-how to optimize for more than 70-80 devices in house.
According to J2ME game developer Oliver Miao, CEO of Centerscore, today's J2ME game industry has original application developers and specialized porting houses. The original application developer typically develops a generic version of the J2ME game for a representative mass market device (or one version each for the high-end and low-end devices). If the operator is interested in the game, the operator arranges for a porting house to optimize and test the game for all Java handsets it carries.
For beginning developers, Mr. Miao suggests starting from a high-end device with the least amount of computational and API constraints. Those devices allow the developer to focus on the correct API usage and game design instead of advanced CPU and memory optimizations. A Nokia Series 60 MIDP 2 device would be a good device to start with. Then, as you gain experience as a developer, it's a good idea to move toward more restrictive mass market devices. For example, most Nokia Series 40 devices only support 64 KB Java Archive (JAR) file size and 200 KB heap memory size limits. To port a graphic-intensive application from Series 60 to Series 40 requires reworking the graphics and even changing the game play. This step is absolutely essential, though, for the commercial success of the game. As discussed here, the great strength of mobile games lies in the large volume it occupies in the mass market. The low-end devices have by far the largest volume in the mass market. For instance, the Nokia Series 40 devices -- the most widely adopted Java phone ever -- have sold 10 times more units than fSeries 60 devices. The skill to understand the low-end devices and optimize applications for them is what separates novice developers from seasoned ones.
The Nokia Series 40 was the most frequently mentioned line of devices at the conference. Developers love it for its huge market share, but hate it for the amount of optimization work needed to port applications to it. For mobile game developers, it is important to master the skills to scale applications up from or down to Series 40 devices.