Hubbry Logo
Java Platform, Micro EditionJava Platform, Micro EditionMain
Open search
Java Platform, Micro Edition
Community hub
Java Platform, Micro Edition
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Java Platform, Micro Edition
Java Platform, Micro Edition
Java Platform, Micro Edition
View on Wikipedia
from Wikipedia

Java Platform, Micro Edition
Player softwareJava
Programming language(s)Java
Application(s)Embedded systems, mobile devices
StatusInactive
LicenseProprietary licence by Oracle
Websitewww.oracle.com/java/technologies/javameoverview.html
Java platform editions

Java Platform, Micro Edition or Java ME is a computing platform for development and deployment of portable code for embedded and mobile devices (micro-controllers, sensors, gateways, mobile phones, personal digital assistants, TV set-top boxes, printers).[1] Java ME was formerly known as Java 2 Platform, Micro Edition or J2ME.

The platform uses the object-oriented Java programming language, and is part of the Java software-platform family. It was designed by Sun Microsystems (now Oracle Corporation) and replaced a similar technology, PersonalJava.

In 2013, with more than 3 billion Java ME enabled mobile phones in the market,[2] the platform was in continued decline as smartphones have overtaken feature phones.[3]

History

[edit]

The platform used to be popular in feature phones, such as Nokia's Series 40 models. It was also supported on the Bada operating system and on Symbian OS along with native software. Users of Windows CE, Windows Mobile, Maemo, MeeGo and Android could download Java ME for their respective environments ("proof-of-concept" for Android).[4][5]

Originally developed under the Java Community Process as JSR 68, the different flavors of Java ME have evolved in separate JSRs. Java ME devices implement a profile. The most common of these are the Mobile Information Device Profile aimed at mobile devices such as cell phones, and the Personal Profile aimed at consumer products and embedded devices like set-top boxes and PDAs. Profiles are subsets of configurations, of which there are currently two: the Connected Limited Device Configuration (CLDC) and the Connected Device Configuration (CDC).[6]

In 2008, Java ME platforms were restricted to JRE 1.3 features and use that version of the class file format (internally known as version 47.0).

Implementations

[edit]
MicroEmulator screenshot

Oracle provides a reference implementation of the specification, and some configurations and profiles for MIDP and CDC. Starting with the JavaME 3.0 SDK, a NetBeans-based IDE supported them in a single IDE.

In contrast to the numerous binary implementations of the Java Platform built by Sun for servers and workstations, Sun tended not to provide binaries for the platforms of Java ME targets, and instead relied on third parties to provide their own.

The exception was an MIDP 1.0 JRE (JVM) for Palm OS.[7] Sun provides no J2ME JRE for the Microsoft Windows Mobile (Pocket PC) based devices, despite an open-letter campaign to Sun to release a rumored internal implementation of PersonalJava known by the code name "Captain America".[8] Third party implementations are widely used by Windows Mobile vendors.

At some point, Sun released a now-abandoned reference implementation under the name phoneME.

Operating systems targeting Java ME have been implemented by DoCoMo in the form of DoJa, and by SavaJe as SavaJe OS. The latter company was purchased by Sun in April 2007 and now forms the basis of Sun's JavaFX Mobile.

The open-source Mika VM aims to implement JavaME CDC/FP, but is not certified as such (certified implementations are required to charge royalties, which is impractical for an open-source project). Consequently, devices which use this implementation are not allowed to claim JavaME CDC compatibility.

The Linux-based Android operating system uses a proprietary version of Java that is similar in intent, but very different in many ways from Java ME.[9]

Emulators

[edit]
  • Sun Java Wireless Toolkit (WTK, for short) — is a proprietary Java ME emulator, originally provided by Sun Microsystems, and later by Oracle.
  • MicroEmulator (MicroEMU, for short) — is an open-source Java ME emulator.

There are other emulators, including emulators provided as part of development kits by phone manufacturers, such as Nokia, Sony-Ericsson, Siemens Mobile, etc.

Connected Limited Device Configuration

[edit]
Main article: Connected Limited Device Configuration

The Connected Limited Device Configuration (CLDC) contains a strict subset of the Java-class libraries, and is the minimum amount needed for a Java virtual machine to operate. CLDC is basically used for classifying myriad devices into a fixed configuration.

A configuration provides the most basic set of libraries and virtual-machine features that must be present in each implementation of a J2ME environment. When coupled with one or more profiles, the Connected Limited Device Configuration gives developers a solid Java platform for creating applications for consumer and embedded devices. The configuration is designed for devices with 160KB to 512KB total memory, which has a minimum of 160KB of ROM and 32KB of RAM available for the Java platform.

Mobile Information Device Profile

[edit]

Designed for mobile phones, the Mobile Information Device Profile includes a GUI, and a data storage API, and MIDP 2.0 includes a basic 2D gaming API. Applications written for this profile are called MIDlets.

JSR 271: Mobile Information Device Profile 3 (Final release on Dec 9, 2009) specified the 3rd generation Mobile Information Device Profile (MIDP3), expanding upon the functionality in all areas as well as improving interoperability across devices. A key design goal of MIDP3 is backward compatibility with MIDP2 content.

Information Module Profile

[edit]

The Information Module Profile (IMP) is a profile for embedded, "headless" devices such as vending machines, industrial embedded applications, security systems, and similar devices with either simple or no display and with some limited network connectivity.

Originally introduced by Siemens Mobile and Nokia as JSR-195, IMP 1.0 is a strict subset of MIDP 1.0 except that it does not include user interface APIs — in other words, it does not include support for the Java package javax.microedition.lcdui. JSR-228, also known as IMP-NG, is IMP's next generation that is based on MIDP 2.0, leveraging MIDP 2.0's new security and networking types and APIs, and other APIs such as PushRegistry and platformRequest(), but again it does not include UI APIs, nor the game API.

Connected Device Configuration

[edit]
Main article: Connected Device Configuration

The Connected Device Configuration is a subset of Java SE, containing almost all the libraries that are not GUI related. It is richer than CLDC.

Foundation Profile

[edit]

The Foundation Profile is a Java ME Connected Device Configuration (CDC) profile. This profile is intended to be used by devices requiring a complete implementation of the Java virtual machine up to and including the entire Java Platform, Standard Edition API. Typical implementations will use some subset of that API set depending on the additional profiles supported. This specification was developed under the Java Community Process.

Personal Basis Profile

[edit]

The Personal Basis Profile extends the Foundation Profile to include lightweight GUI support in the form of an AWT subset. This is the platform that BD-J is built upon.

JSRs (Java Specification Requests)

[edit]

Foundation

[edit]
JSR # Name Description
68 J2ME Platform Specification
30 CLDC 1.x
37 MIDP 1.0
118 MIDP 2.x
139 CLDC 1.1
271 MIDP 3.0 Java ME 3.4 and earlier only, Last Specification for Mobile Phones, Java Language features as Java SE 1.3
360 CLDC 8 New in Java ME 8
361 MEEP 8 New in Java ME 8, Language feature as Java SE 8, for Internet of Everything devices

Main extensions

[edit]
JSR # Name Description MSA
75 File Connection and PIM API File system, contacts, calendar, to-do Yes
82 Bluetooth Bluetooth serial port communications and file exchanges (OBEX) Yes
120 Wireless Messaging API (WMA)
135 Mobile Media API (MMAPI) Audio, video, multimedia Yes
172 Web Services API XML parsers and RPC Yes
177 Security and Trust Services API (SATSA) APDU, Java Card RMI (JCRMI), Public Key Infrastructure (PKI) and cryptography Yes
179 Location API GPS coordinates, street addresses, orientation sensors, landmark stores Yes
180 SIP API Yes
184 Mobile 3D Graphics (M3G) High level 3D graphics Yes
185 Java Technology for the Wireless Industry (JTWI) General
205 Wireless Messaging API (WMA) 2.0 Sending and receiving SMS and MMS
211 Content Handler API (CHAPI) Yes
226 Scalable 2D Vector Graphics API for J2ME (M2G) Handling SVG Tiny Yes
228 Information Module Profile – Next Generation (IMP NG)
229 Payment API Yes
234 Advanced Multimedia Supplements (AMMS) MMAPI extensions Yes
238 Mobile Internationalization API Localized resources, locale date and number formatting, locale comparison of strings Yes
239 Java Bindings for the OpenGL ES API
248 Mobile Service Architecture (MSA) Yes
253 Mobile Telephony API
256 Mobile Sensor API Reading values from accelerometers, gyroscopes, compasses, thermometers, barometers, and some more
257 Contactless Communication API
258 Mobile User Interface Customization API
272 Mobile Broadcast Service API for Handheld Terminals
280 XML API for Java ME
281 IMS Services API
287 Scalable 2D Vector Graphics API 2.0 for Java ME
293 Location API 2.0
298 Telematics API for Java ME
300 DRM API for Java ME
325 IMS Communication Enablers

Future

[edit]
JSR # Name Description
297 Mobile 3D Graphics API (M3G) 2.0 Proposed Final Draft for 14 Apr, 2009

ESR

[edit]

The ESR consortium is devoted to Standards for embedded Java. Especially cost effective Standards. Typical applications domains are industrial control, machine-to-machine, medical, e-metering, home automation, consumer, human-to-machine-interface, ...

ESR # Name Description
001 B-ON (Beyond CLDC) B-ON serves as a very robust foundation for implementing embedded Java software. It specifies a reliable initialization phase of the Java device, and 3 kind of objects: immutable, immortal and regular (mortal) objects.
002 MicroUI MicroUI defines an enhanced architecture to enable an open, third-party, application development environment for embedded HMI devices. Such devices typically have some form of display, some input sensors and potentially some sound rendering capabilities. This specification spans a potentially wide set of devices.
011 MWT MWT defines three distinct roles: Widget Designers, Look and Feel Designers, and Application Designers. MWT allows a binary HMI application to run the same on all devices that provide a compliant MWT framework (embedded devices, cellphones, set-top box TV's, PC's, etc...) allowing for true consistency and ubiquity of applications across product lines (ME, SE, EE).
015 ECLASSPATH ECLASSPATH unifies CLDC, CDC, Foundation, SE, and EE execution environments with a set of around 300 classes API. Compiling against CLDC1.1/ECLASSPATH makes binary code portable across all Java execution environments.

See also

[edit]

References

[edit]

Bibliography

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Java Platform, Micro Edition

View on Grokipedia
from Grokipedia
Java Platform, Micro Edition (Java ME) is a set of Java virtual machines and APIs designed to support the development and deployment of applications on resource-constrained devices, including mobile phones, personal digital assistants (PDAs), embedded systems, and (IoT) devices such as sensors and gateways. Originally introduced by in June 1999 as Java 2 Platform, Micro Edition (J2ME) to address the needs of and embedded markets, it was later renamed Java ME around 2006 to align with the simplified naming conventions adopted for other Java editions. The platform has been maintained by since its acquisition of Sun in 2010 and remains deployed on over three billion devices worldwide, particularly in mobile and IoT applications. The architecture of Java ME is modular, consisting of a (JVM) tailored for limited resources, core Java libraries, configurations that define the minimal runtime environment for device families, and profiles that provide device- or industry-specific APIs. Configurations include the Connected Limited Device Configuration (CLDC), optimized for low-memory mobile devices with 160–512 KB of total memory and intermittent connectivity, and the Connected Device Configuration (CDC), suited for more capable connected devices with at least 2 MB of memory supporting a full-featured JVM. Profiles build atop these configurations; for example, the Mobile Information Device Profile (MIDP) on CLDC enables user interfaces, networking, and persistence for mobile applications like MIDlets, while the Foundation Profile on CDC offers a subset of Java SE APIs without graphical user interfaces for server-like embedded uses. Other profiles, such as Personal Profile for web applets or Java TV for set-top boxes, extend functionality for specific vertical markets. Java ME supports key features like flexible user interfaces, robust security models, standard network protocols, and offline data storage, making it suitable for applications in , automotive systems, and smart devices. In the IoT domain, the current Java ME Embedded 8.3 release (from 2018) incorporates enhancements like the CLDC 8 configuration for core runtime and APIs, enabling efficient operation on microcontrollers and gateways with tools like the Java ME SDK for emulation and development. Despite the rise of modern platforms like Android, Java ME continues to power legacy mobile ecosystems and new IoT deployments due to its maturity, portability, and vast existing codebase.

Overview

Definition and Purpose

Java Platform, Micro Edition (Java ME) is a subset of the Java platform designed specifically for resource-constrained environments, such as embedded systems, mobile devices, and (IoT) applications, where memory is typically limited to 128–512 KB and processing power is minimal. This platform enables developers to create and run Java-based applications on devices like sensors, microcontrollers, and early mobile phones that cannot support the full Java Standard Edition (Java SE). By providing a streamlined runtime, Java ME ensures compatibility across diverse hardware while maintaining core Java principles of portability and . The core purpose of Java ME is to facilitate the development of secure, efficient applications that can operate in networked or offline modes on low-resource devices, upholding the write-once-run-anywhere model adapted for constrained settings. It allows for dynamic downloading and execution of applications, leveraging built-in network protocols and flexible user interfaces to support real-world use cases in mobile and embedded . This focus on resource efficiency makes Java ME suitable for environments where full capabilities would be impractical due to hardware limitations. To achieve these goals, Java ME incorporates key technical constraints, including a reduced set of class libraries that omit advanced features available in larger Java platforms. Early implementations lacked support for floating-point data types (float and double) to align with the absence of such hardware in target devices. Rather than the standard , it employs the Kilobyte Virtual Machine (KVM), a compact runtime optimized for minimal usage, requiring as little as 128 KB total budget including the VM, libraries, and heap. Sun Microsystems originally designed Java ME in 1999, targeting emerging consumer devices such as pagers and personal digital assistants (PDAs) to extend 's reach beyond desktops. This initiative addressed the growing need for portable code in the nascent mobile and embedded markets.

Relation to Other Java Platforms

The Java Platform, Micro Edition (Java ME) forms one of the three primary editions of the Java platform family, distinct from Java SE (Standard Edition), which targets desktop and general-purpose computing environments, and (formerly Java EE; Enterprise Edition), which is optimized for large-scale, server-side enterprise applications. Java ME is specifically engineered for resource-constrained devices such as embedded systems, mobile phones, and IoT modules, providing a lightweight runtime that supports portable, secure applications while inheriting core language features from the broader ecosystem. This positioning allows Java ME to leverage the extensive Java developer community—estimated at over 9 million—while addressing hardware limitations not relevant to Java SE or . Architecturally, Java ME diverges from Java SE by employing a layered model of configurations and profiles for device-specific customization, rather than relying on the full, monolithic standard libraries of Java SE. The Connected Limited Device Configuration (CLDC) targets low-end devices with minimal resources (e.g., 160 KB non-volatile memory and intermittent connectivity), offering a of Java Virtual Machine (JVM) features and basic APIs, while the Connected Device Configuration (CDC) supports more capable hardware (e.g., 2 MB RAM) with closer alignment to Java SE subsets, including support for profiles like the Foundation Profile. In contrast, Java SE provides comprehensive class libraries for unrestricted environments, without the need for such modular tailoring to memory and processing constraints. Java ME also incorporates optimizations like just-in-time () compilation and generational garbage collection to enhance performance on limited hardware, further differentiating it from the resource-rich assumptions of Java SE and . Originally designated as J2ME (Java 2 Platform, Micro Edition), Java ME was renamed in June 2005 as part of ' (later 's) effort to streamline branding across editions, dropping the "2" to signify platform maturity and eliminate version confusion—mirroring changes like J2SE to Java SE. While Java ME maintains bytecode compatibility with Java SE, enabling ME-compiled class files to execute on SE-compatible JVMs under certain conditions, there is no straightforward migration path for applications due to API subsets and environmental differences; Java ME serves as a specialized subset rather than a precursor to the fuller-featured SE or platforms. Under Oracle's stewardship since acquiring in 2010, ME operates as a platform, with Oracle licensing runtimes and tools directly to device manufacturers and providers, often requiring commercial agreements for deployment. This contrasts with Java SE, which benefits from the open-source project under GPLv2 with Exception, allowing community-driven development and free distribution, though Oracle's JDK variant imposes subscription-based licensing for production use. ME lacks a comparable fully open-source , emphasizing Oracle's controlled to ensure consistency in constrained ecosystems.

History

Origins and Early Development

The Java Platform, Micro Edition (Java ME), originally known as Java 2 Platform, Micro Edition (J2ME), was developed by to extend the Java programming model to resource-constrained devices in emerging mobile and embedded markets, moving beyond the initial focus on desktop applets and web applications. Conceptualized in the late amid the rise of consumer electronics like personal digital assistants (PDAs) and early cellular phones, J2ME aimed to provide a lightweight runtime environment that maintained Java's "write once, run anywhere" portability while accommodating limited memory, processing power, and battery life. Sun unveiled J2ME at the JavaOne conference in 1999, demonstrating its potential through a prototype application on a Palm V PDA, targeting devices such as pagers, PDAs, and entry-level mobile phones that required compact, secure code execution without full (JVM) overhead. A key component of this early development was the K Virtual Machine (KVM), a stripped-down JVM designed for 16-bit or 32-bit processors with as little as 128 KB of memory. Originating from the Spotless project in Sun Laboratories, KVM was introduced in 1999 as the reference virtual machine for J2ME, enabling dynamic class loading and garbage collection tailored to embedded constraints while ensuring compatibility with core APIs. This innovation addressed the need for a minimal , allowing Java applications to run on devices previously limited to native code. Formal standardization began through the Java Community Process (JCP). In August 1999, the expert group for JSR 30 approved the initial draft of the Connected Limited Device Configuration (CLDC), a foundational configuration for low-end devices with intermittent connectivity and limited resources. The specification reached final release in May 2000, defining subsets of essential Java libraries like java.lang and java.io, along with security features such as sandboxing for untrusted code. Concurrently, JSR 68, proposed in early 2000, outlined the overarching J2ME platform architecture, introducing the concepts of configurations and profiles to modularize support for diverse device classes. These milestones established J2ME as a flexible framework for consumer electronics, emphasizing portability across heterogeneous hardware. In 2005, Sun renamed J2ME to Java ME to streamline branding and align it with the Java SE (Standard Edition) and Java EE (Enterprise Edition) platforms, removing the "2" prefix while preserving the platform's focus on micro-embedded systems. This rebranding reflected evolving industry needs without altering the underlying specifications.

Adoption and Peak Usage

Java Platform, Micro Edition (Java ME) experienced significant market growth during the early , driven by its suitability for resource-constrained mobile devices. By April 2004, approximately 250 million mobile phones worldwide supported Java technology, marking a substantial increase from earlier years and reflecting the platform's expanding footprint in consumer handsets. Projections at the time estimated that the number of Java-enabled devices would surpass 1 billion by 2006, fueled by widespread integration in entry-level and mid-range phones. The platform achieved peak adoption around 2013, with over 3 billion Java ME-enabled mobile phones in circulation, representing a dominant presence in the feature phone segment that accounted for the majority of global mobile device shipments prior to the smartphone surge. This scale underscored Java ME's role as the de facto standard for mobile applications on non-smartphone devices, enabling consistent software experiences across diverse hardware. Key partnerships with major manufacturers accelerated this adoption. Nokia extensively integrated Java ME into its Series 40 and Series 60 platforms, which powered millions of devices and supported J2ME applications natively. Sony Ericsson developed dedicated Java platforms, such as the Sony Ericsson Java Platform (SJP) for Symbian-based devices and JP for non-Symbian models, ensuring robust MIDlet compatibility. Motorola similarly embedded Java ME support in its feature phones, contributing to cross-vendor application portability. Integration extended to operating systems like Symbian OS, where Java ME formed a core component for app execution, and BlackBerry, which incorporated Java 2 Micro Edition (J2ME) as part of its foundational runtime for secure, open development. During its peak, Java ME facilitated a vibrant ecosystem of applications, particularly through the Mobile Information Device Profile (MIDP), which enabled the deployment of MIDlets—lightweight, portable apps. Popular examples included games like Snake, a simple yet iconic title that demonstrated the platform's graphics capabilities on early Nokia devices. MMS clients, such as those for sending multimedia messages, leveraged MIDP's networking APIs to enhance mobile communication beyond basic SMS. Early web browsers, including versions of Opera Mini, operated as MIDlets to deliver lightweight internet access on low-bandwidth connections, bypassing hardware limitations. These applications highlighted Java ME's versatility in enabling interactive content distribution via over-the-air updates. The (JCP) played a pivotal role in this success by overseeing the development of Java Specification Requests (JSRs) that standardized configurations and profiles, ensuring among devices from different vendors. Notable JSRs, such as JSR 30 for Connected Limited Device Configuration (CLDC) and JSR 37 for MIDP, promoted consistent APIs and runtime environments, reducing fragmentation and encouraging developer adoption across ecosystems. This collaborative standardization effort, involving industry stakeholders, solidified Java ME's position as a reliable platform for mobile innovation during the .

Decline in Mobile and Shift to Embedded Systems

The introduction of Apple's iPhone in 2007 and Google's Android platform in 2008 marked the beginning of a rapid shift in the mobile ecosystem, where advanced smartphones with native app development frameworks overshadowed Java ME's role in feature phones and basic mobile devices. By 2010, smartphone shipments had surged to nearly 300 million units globally, capturing a significant market share from traditional Java ME-dependent platforms, as developers migrated to more capable and integrated environments like iOS and Android SDKs. This transition sidelined Java ME, which had peaked in adoption during the early 2000s with widespread use on devices from Nokia, Sony Ericsson, and others. The decline accelerated with the end of support for major Java ME platforms; for instance, Nokia terminated developer support for , a key Java ME host, effective January 1, 2014, halting new app submissions and updates. Market data reflects this erosion: global shipments, heavily reliant on Java ME, peaked at approximately 1.4 billion units in 2010 but plummeted to under 300 million by 2020, with lingering legacy use primarily in developing markets where affordable basic phones persisted. As penetration exceeded 80% worldwide by the mid-2010s, Java ME's mobile footprint contracted sharply, prompting to de-emphasize consumer mobile development in favor of more sustainable applications. Post-2011, Oracle redirected Java ME efforts toward embedded systems and the (IoT), launching Java ME Embedded as a dedicated platform for resource-constrained devices. This initiative targeted IoT growth, providing a Java SE 8-compatible runtime for low-power environments like microcontrollers and networked sensors. The latest major release, Java ME 8.3 in 2018, specifically optimized for sensors, gateways, and evaluation boards such as and , enabling secure, modular applications with features like the Device Access API for peripheral integration. Java ME's ongoing relevance lies in its maintenance for legacy embedded systems, where it supports billions of deployed devices, and its compatibility with modern IoT ecosystems, including integration via IoT projects that extend Java tools for device connectivity and cloud backends. This shift has sustained Java ME as a bridge between historical mobile codebases and contemporary IoT standards, avoiding in industrial and machine-to-machine contexts.

Configurations and Profiles

Connected Limited Device Configuration (CLDC)

The Connected Limited Device Configuration (CLDC) serves as the foundational configuration within the Platform, Micro Edition ( ME), providing a minimal runtime environment tailored for highly resource-constrained, connected devices such as early mobile phones, pagers, and embedded systems. It defines a subset of features, core libraries, and APIs that enable the execution of small Java applications while accommodating limited processing power, memory, and intermittent network access. CLDC was initially specified in version 1.0 through Java Specification Request (JSR) 30, finalized in May 2000, which established the baseline for devices with severe limitations by excluding advanced Java features to fit within tight footprints. This version targeted the deployment of Java on platforms like two-way pagers and personal digital assistants (PDAs), emphasizing portability across diverse hardware without requiring floating-point hardware support. CLDC 1.1, defined in JSR 139 and finalized in March 2003, refined the configuration with enhancements such as improved internationalization support and the addition of implemented in software, allowing developers to perform basic numerical computations without dedicated hardware. Core features of CLDC include the K Virtual Machine (KVM), a compact optimized for low-memory environments, along with basic input/output (I/O) capabilities through a subset of the java.io package for stream-based data handling. The Java language subset omits advanced constructs like finalizers for object cleanup, imposes restrictions on error handling (e.g., no support for certain reflective operations), and limits multithreading to basic synchronization primitives, ensuring efficient operation on constrained systems. Networking is facilitated via the Generic Connection Framework (GCF), which provides a unified interface for intermittent, low-bandwidth connections like those over cellular or short-range networks. Hardware requirements for CLDC focus on to support widespread adoption: a 16-bit or 32-bit CPU with a clock speed of at least 16 MHz, total memory ranging from 128 KB to 512 KB (with at least 128 KB allocatable as heap space and the remainder for ROM/Flash storage of libraries and the VM), and support for battery-operated, low-power scenarios. These specifications ensure CLDC can run on devices with intermittent connectivity, typically limited to speeds below 9600 bps, without demanding persistent high-speed links. Over time, CLDC evolved significantly with version 8 under JSR 360, finalized in , which aligned the platform more closely with SE 8 by incorporating language features like generics, annotations, enumerations, and try-with-resources statements, while maintaining and the core for modern embedded applications. This update enhanced developer productivity by enabling more expressive code without expanding the runtime footprint substantially.

Mobile Information Device Profile (MIDP)

The Mobile Information Device Profile (MIDP) is a Java specification that extends the Connected Limited Device Configuration (CLDC) to provide a standardized runtime environment for developing and deploying applications on resource-constrained mobile information devices, such as cellular phones and personal digital assistants. It targets devices with limited memory (typically 512 KB total), battery power, and variable user interfaces, enabling mass-market applications like games, , and information services. MIDP defines core APIs for user interfaces, data persistence, networking, and application management, while maintaining across versions. MIDP 1.0, specified under JSR 37 and released on September 19, 2000, introduced the foundational application model for mobile Java, including support for over-the-air (OTA) provisioning to allow users to discover, download, and install applications via wireless networks using HTTP and JAD/ files. Key APIs in this version include the Low-Level (LCDUI) package (javax.microedition.lcdui), which provides a simple, device-agnostic toolkit for building graphical user interfaces with components like forms, lists, and canvases suitable for small screens and limited input methods such as buttons or keypads. Additionally, the Record Management System (RMS) API (javax.microedition.rms) enables persistent through record stores, allowing MIDlets to save and retrieve small amounts of user data locally. MIDP applications, known as MIDlets, follow a defined lifecycle managed by the (AMS): the startApp() method initializes the application, pauseApp() suspends it during inactivity (e.g., incoming calls), and destroyApp(boolean unconditional) terminates it, ensuring resource cleanup. For security, untrusted MIDlet suites operate within a sandbox that restricts access to sensitive APIs (e.g., networking or file I/O), requiring explicit user permissions or digital signatures for trusted code to mitigate risks in unverified downloads. MIDP 2.0, under JSR 118 and released on November 20, 2002, enhanced these foundations with improved OTA status reporting, better persistence options, and optional integration of the Mobile Media API (MMAPI, JSR 135) for basic multimedia playback like tones and simple video. MIDP 3.0, specified in JSR 271 and approved on December 9, 2009, introduced support for modern mobile capabilities while preserving compatibility with prior versions, including gesture handling in LCDUI for interactions, support for concurrent MIDlets, and inter-MIDlet communication. These additions addressed evolving device diversity, enabling more expressive user interfaces and richer applications without requiring full Java SE subsets.

Connected Device Configuration (CDC)

The Connected Device Configuration (CDC) is a configuration within the Platform, Micro Edition ( ME) designed for resource-rich, connected devices that require a more robust runtime environment than those supported by CLDC. It defines a minimal of the SE platform, including core class libraries, APIs, and a tailored for devices with enhanced processing and memory capabilities, enabling the development of sophisticated applications. CDC version 1.0 was specified through JSR 36, approved in 2001, while version 1.1 followed via JSR 218, finalized in 2005, incorporating updates aligned with SE 1.4 features such as assertions and improved support while maintaining . At its core, CDC employs the C Virtual Machine (CVM), a high-performance implementation of the (JVM) specification written in C to optimize execution on embedded hardware without sacrificing full Java 2 compatibility. This includes support for , either natively or via software emulation, allowing numerical computations that are absent in lighter configurations. Networking capabilities are expanded to include full TCP and UDP protocols through the java.net package, facilitating robust, always-on connectivity for data exchange in networked environments. CDC targets devices equipped with a 32-bit CPU and at least 2 MB of total RAM (with approximately 2.5 MB ROM), providing around 1 MB for the Java heap to accommodate larger applications and data sets. This configuration suits non-mobile embedded systems such as TV set-top boxes, car navigation units, and printers, where persistent connectivity and higher computational demands are essential. CDC serves as the foundational runtime for personal profiles, enabling layered extensions for user-facing applications on these platforms.

Foundation Profile and Personal Basis Profile

The Foundation Profile, defined in JSR 46 and revised in JSR 219, is a headless profile built on the Connected Device Configuration (CDC) for ME, providing core non-graphical APIs from Java SE for resource-constrained, network-connected devices. It includes essential packages such as java.io for input/output operations, java.net for networking, java.util for utilities like collections and date handling, and java.lang.reflect for reflection capabilities, enabling server-side or gateway applications without support. Targeted at devices with at least 512 KB of RAM and 1 MB of ROM, the profile's libraries typically occupy 512 KB to 2 MB, supporting headless environments like embedded servers or data processing units. The Personal Basis Profile, specified in JSR 129 and updated in JSR 217, extends the Foundation Profile by adding a subset of the (AWT) for basic graphical user interfaces, along with support for printing via java.awt.print and limited sound capabilities through javax.sound.midi. This profile focuses on lightweight components, such as single-frame windows and simple event handling, without heavyweight widgets, making it suitable for consumer devices requiring minimal GUI functionality like personal digital assistants (PDAs), interactive televisions, and set-top boxes. With library sizes ranging from 2 MB to 16 MB and minimum device requirements of 1 MB RAM and 2 MB ROM, it accommodates applications in environments like Blu-ray players, where applications leverage its APIs for interactive media playback. Key differences between the profiles lie in their scope and resource demands: the Foundation Profile is strictly non-graphical and optimized for minimal footprints in server or gateway roles, while the Personal Basis Profile introduces GUI elements for end-user devices, increasing complexity and size accordingly. Both profiles ensure compatibility with features up to version 1.1 for core language elements and 1.3 for select APIs, facilitating porting of legacy Java applications to embedded systems while adhering to CDC's specifications.

Implementations and Tools

Reference Implementations

Oracle's primary for Java ME development is the Java ME SDK 8.3, released in 2018, with a maintenance update 8.3.1, which provides a comprehensive environment for building and testing applications with built-in emulators, runtimes, and libraries. This SDK ensures full compliance with key Java Specification Requests (JSRs), including support for configurations such as Connected Limited Device Configuration (CLDC) and Connected Device Configuration (CDC), along with debugging tools, device skin emulators, and utilities for on Windows and host systems. It also integrates emulation for embedded scenarios, enabling developers to simulate resource-constrained devices without physical hardware. No major updates have been released since 2018, as has directed efforts toward Java SE embedded solutions. Complementing the SDK, ME Embedded 8.3 serves as the runtime for embedded and IoT applications, targeting / architectures and specific boards like Model B and Galileo Gen 2. This implementation extends to platforms such as IoE (/BREW MP), providing a lightweight optimized for low-power devices with features like headless operation and secure file systems. Up to ME 8, it maintains JSR compliance for profiles including Foundation Profile and Personal Basis Profile, facilitating deployment on IoT hardware with minimal footprint. From ' legacy efforts, the Wireless Toolkit (WTK) 2.5.2_01 offered essential tools for MIDP-based development, including build utilities, OTA emulation, MIDlet signing, and a device emulator compliant with MIDP 2.0 (JSR 118) and CLDC 1.1 (JSR 139). It supported Windows and hosts, with features like push registry emulation and optional package integration for (JSR 82) and location APIs (JSR 179), aiding early mobile application testing. Sun also developed phoneME as an open-source of CLDC and CDC, launched in 2007 to promote Java ME adoption in mobile and embedded markets through customizable virtual machines and libraries under GPLv2 licensing. Active until around 2011, phoneME Feature targeted feature phones with MIDP support, while phoneME Advanced addressed higher-end devices, emphasizing reduced implementation variance and community contributions for JSR-compliant builds.

Third-Party Implementations and Emulators

Third-party implementations of the Java Platform, Micro Edition (Java ME) have extended its reach beyond official reference versions, often tailoring the platform for specific hardware constraints, cross-platform compatibility, or emulation purposes. These efforts include open-source projects that provide alternative runtimes and tools, as well as vendor-specific adaptations that optimized Java ME for proprietary device ecosystems. While these implementations vary in compliance with (JCP) standards, they have preserved legacy applications and enabled development in niche areas like embedded systems and retro gaming. Open-source projects have been instrumental in maintaining Java ME's accessibility. MicroEmulator, a pure Java implementation of Java ME, serves as a CLDC/MIDP emulator that runs MIDlets in web browser applets or as standalone applications, licensed under LGPL with major components under the . It supports demonstration and testing of J2ME applications without requiring physical devices. Similarly, phoneME Advanced offers an open-source runtime based on the Connected Device Configuration (CDC), targeting advanced phone categories and desktops with support for related profiles and optional packages like the Foundation Profile. This implementation leverages OS features such as and multi-tasking for higher-performance embedded scenarios. Codename One, another open-source tool, transpiles MIDlets written in Java to native code for cross-platform deployment on , Android, and the web, building on Java ME's lightweight UI libraries like LWUIT to bridge legacy mobile development to modern ecosystems. Vendor adaptations have customized ME for specific platforms, enhancing device-specific features while adhering to core configurations. Nokia's implementation for the platform integrated ME (J2ME) to support MIDP-based applications and games on feature phones, including extensions for UI and hardware access via the Nokia UI , enabling widespread deployment of apps on over a billion devices historically. IBM's J9 provided an embedded runtime compliant with ME profiles like CLDC and CDC, offering a configurable layer for resource-constrained systems with optimizations for compact, predictable performance on processors like NXP. Android's Dalvik , while and not fully compliant with ME standards, drew inspiration from ME's model but used a DEX format optimized for mobile, allowing partial portability of ME code to early Android environments through conversion tools. Emulators from third-party sources have facilitated testing and preservation of Java ME applications on contemporary hardware. FreeJ2ME, an open-source emulator focused on J2ME games, runs on Windows, , and , supporting 2D titles from legacy phones with libretro and SDL2 frontends for retro gaming communities. These tools contrast with reference implementations by emphasizing compatibility for archival purposes over full development suites.

Standards and Specifications

Java Specification Requests (JSRs)

The development of the Java Platform, Micro Edition (Java ME) is governed by the (JCP), a collaborative framework that facilitates the creation of Java specifications through Java Specification Requests (JSRs). These JSRs define the core components, APIs, and standards for Java ME, ensuring consistency and portability across diverse embedded and mobile devices. The JCP process involves expert groups comprising industry stakeholders who review proposals, draft specifications, and approve final releases, promoting open participation while maintaining technical rigor. A pivotal early JSR was JSR 68, approved on May 27, 2000, which outlined the architecture for what was then known as the 2 Platform, Micro Edition (J2ME). This JSR introduced key concepts such as configurations (minimal runtime environments tailored to device capabilities) and profiles (higher-level APIs built atop configurations), providing a flexible model for subsetting Java features to suit resource-limited hardware. Although withdrawn in 2011 as its architectural guidelines were integrated into subsequent specifications, JSR 68 laid the groundwork for Java ME's evolution and interoperability. By 2014, over 50 JSRs had been completed for ME, with the total reaching 85 as of the latest JCP records, encompassing foundational elements and optional extensions. These specifications have enabled a robust by standardizing APIs for networking, , and user interfaces, allowing vendors to build compatible implementations without proprietary lock-in. Among the core JSRs defining Java ME's foundational configurations and profiles are those for the Connected Limited Device Configuration (CLDC) and Mobile Information Device Profile (MIDP). JSR 30 (2000) specified CLDC 1.0 for small, connected devices with limited resources, while JSR 139 (2003) updated it to CLDC 1.1 with enhancements like improved networking and . For MIDP, JSR 37 (2000) defined version 1.0 to support mobile applications on CLDC devices; JSR 118 (2002) advanced it to version 2.0 with multimedia and over-the-air updates; and JSR 271 (2009) introduced MIDP 3.0 for richer interactions on advanced handsets. Similarly, the Connected Device Configuration (CDC) and related profiles form another pillar. JSR 36 (2000) established CDC 1.0 for devices with more capable processors and memory, and JSR 218 (2005) revised it to CDC 1.1, aligning with Java SE 1.4 APIs for better compatibility. The Foundation Profile, intended for non-graphical, network-connected applications on CDC, was defined in JSR 46 (2001) and updated in JSR 219 (2006) to incorporate Java SE 1.4 features. The Personal Basis Profile, adding basic graphical support, originated in JSR 129 (2002) and was refined in JSR 217 (2006) for enhanced subsetting from Java SE. These core JSRs play a crucial role in ensuring by mandating compatible runtime behaviors and subsets, allowing developers to target multiple device classes with a single codebase. Post-2018, following Oracle's de-emphasis on ME in favor of SE for embedded systems, many of these JSRs entered maintenance or archived status, with no new major revisions but ongoing availability of specifications and reference implementations for legacy and specialized uses. This has sustained Java ME's adoption in billions of devices, fostering an ecosystem of tools and applications despite evolving market shifts.

Embedded Systems Reference (ESR) Specifications

The E-S-R was formed in late as a non-profit organization registered in to develop and promote the adoption, use, and improvement of embedded Java technologies through the creation of cost-effective specifications. The consortium focused on providing a lightweight alternative to full Java Specification Requests (JSRs) for resource-constrained environments, aiming for compatibility with Java SE Embedded features within Java ME contexts to support seamless application development across embedded and mobile ecosystems. Over time, it produced several specifications tailored to industrial control, machine-to-machine communication, and other embedded domains, emphasizing low overhead and . Key specifications include B-ON (associated with JSR 361, approved in 2014), which forms the foundation for the ME Embedded Profile (MEEP 8) by defining a reliable initialization phase and extending CLDC capabilities for robust execution. MicroUI provides essential graphical user interfaces for embedded devices, supporting 2D APIs and character LCD displays suitable for microcontrollers with limited resources. The Micro Widget Toolkit (MWT) offers media widgets and a framework for building interactive components in constrained systems, while eClasspath introduces a module system to manage dependencies and class loading in low-memory environments. These APIs prioritize minimal footprint and real-time performance, enabling developers to implement device-specific features without the full overhead of standard Java libraries. The ESR specifications target real-time, low-power devices such as sensors, actuators, and gateways, integrating directly with Java ME 8 to facilitate connected applications in IoT scenarios. They emphasize and efficient resource utilization, allowing Java code to interface with peripherals like GPIO and displays while maintaining compatibility with broader Java ecosystems. As of 2025, the ESR specifications, though from a now-inactive , remain relevant for legacy embedded deployments, particularly in industrial and automotive sectors, and continue to influence modern IoT frameworks by providing foundational patterns for lightweight Java runtimes in .

Current Use Cases

Legacy Mobile Applications

Java Platform, Micro Edition (Java ME) continues to power applications on feature phones, particularly in developing markets where low-cost devices remain prevalent. Devices such as the 200 series support Java ME through MIDP 2.1, enabling the execution of lightweight applications including basic games, clients, and MMS handlers that leverage device-specific APIs for messaging and . These phones facilitate simple and communication tools tailored to limited hardware resources, with apps often sideloaded via USB or . In legacy platforms, ME was integral to operating systems like and prior to 2013, providing a standardized runtime for third-party applications on early smartphones. OS incorporated ME as a core component, supporting MIDlets for diverse functionalities across and other vendor devices. Similarly, versions up to 7.1 natively ran ME applications, including clients and productivity tools, before the shift to BlackBerry 10. Sony Ericsson devices also integrated Java ME, supporting MIDlets for various applications on their pre-smartphone handsets. Today, retro emulation allows these applications to run on modern Android devices using tools like J2ME Loader, which emulates the Java ME environment for 2D and limited 3D games. Notable examples of Java ME applications include operator portals such as , which delivered downloadable Java clients for services like unlimited texting and content access, integrated with the carrier's network. Simple browsers, exemplified by early versions of , utilized Java ME to provide web access on constrained devices with compressed data rendering. Security in these applications relies on sandboxed MIDlets, where each suite operates in an isolated environment to prevent unauthorized access to device resources, as defined in the MIDP specification. Despite its enduring presence, Java ME faces significant challenges in legacy mobile contexts, with no active development for modern smartphones due to the dominance of native platforms like Android and . Maintenance efforts focus on sustaining compatibility for millions of active feature phones and emulated legacy devices in regions with limited infrastructure upgrades, addressing issues like deprecation and patching without broader ecosystem support.

Embedded Systems and IoT Applications

Java Platform, Micro Edition (Java ME) has found significant adoption in embedded systems and (IoT) applications, where its lightweight runtime and support for resource-constrained environments enable reliable operation on devices with limited memory and processing power. Optimized profiles such as Java ME Embedded provide essential APIs for hardware access, including (GPIO), inter-integrated circuit (I2C), and (SPI), facilitating integration with sensors and actuators in IoT ecosystems. These capabilities allow developers to deploy portable, secure applications that support over-the-air updates and remote management, extending device lifecycles in dynamic environments. In IoT deployments, Java ME powers sensors and gateways that collect, process, and transmit data in real-time scenarios. For instance, on platforms like the Raspberry Pi, Java ME Embedded enables GPIO interfacing with sensors for environmental monitoring, such as temperature and pressure readings, forming the basis for edge gateways that aggregate data from multiple sources before cloud forwarding. Smart meters in smart grid infrastructure leverage Java ME for secure metering and communication in machine-to-machine (M2M) networks, ensuring compliance with utility standards while handling low-power operations. Industrial automation systems use Java ME to control machinery and monitor processes, with its modular profiles supporting protocols like Modbus for interoperability in factory settings. Across industries, Java ME Embedded specifications, including the Embedded Systems Reference (ESR), enable tailored applications in automotive electronic control units (ECUs) for functions like diagnostics and integration. In consumer electronics, it drives user interfaces and content delivery on Blu-ray Disc players and printers, where Java TV APIs support bonus features and device management. Healthcare applications benefit from low-power profiles in wearables, powering devices such as wristbands for activity tracking and infant monitors that transmit biometric data via secure channels. Notable demonstrations include set-top boxes utilizing Java TV for electronic program guides (EPGs) and video-on-demand (VOD) services, enabling interactive media experiences on embedded hardware. Integration with Eclipse tools, such as plugins in the Java ME SDK, supports development for edge computing in IoT, allowing seamless deployment on gateways like Raspberry Pi within open-source frameworks. As of 2025, Java ME technologies remain deployed on over three billion devices worldwide, with ongoing maintenance through Oracle's SDK 8.3 releases ensuring compatibility for low-end IoT endpoints.

References

  1. https://www.oracle.com/java/technologies/javameoverview.html
  2. https://dl.acm.org/doi/10.5555/381473.381610
  3. https://visualstudiomagazine.com/articles/2006/04/17/get-creative-on-the-java-me-platform.aspx
  4. https://www.oracle.com/technetwork/java/0130449148-159103.pdf
  5. https://www.oracle.com/docs/tech/java/kvmwp.pdf
  6. https://phoenixnap.com/glossary/java-me
  7. https://barrgroup.com/blog/kvm-small-java-virtual-machine-j2me
  8. https://www.oreilly.com/library/view/wireless-java/0596002432/ch01.html
  9. https://jakarta.ee/
  10. https://docs.oracle.com/javame/dev-tools/jme-sdk-3.3/nb/html/platforms.htm
  11. https://www.oracle.com/java/technologies/javase/javanaming.html
  12. https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-0-preface7.html
  13. https://www.oracle.com/java/technologies/javase/jdk-faqs.html
  14. https://www.infoworld.com/article/2164089/the-palm-v-meets-j2me.html
  15. https://www.oracle.com/technetwork/java/cldc-hi-whitepaper-150012.pdf
  16. https://jcp.org/en/jsr/detail?id=30
  17. https://jcp.org/en/jsr/detail?id=68
  18. https://www.medien.ifi.lmu.de/diamd05/slides/j2me.pdf
  19. https://www.infoworld.com/article/2164054/the-fragmentation-effect.html
  20. https://www.zdnet.com/article/three-billion-devices-run-java-yeah-but-do-they-like-it/
  21. https://www.researchgate.net/publication/350630406_The_Java_Platform_Micro_Edition_Java_ME
  22. https://lpcwiki.miraheze.org/wiki/Series_40
  23. https://www.oreilly.com/library/view/java-me-on/9780470743188/ch05.html
  24. https://www.blackberry.com/news/connection/200201.shtml
  25. https://github.com/anasrar/java-me-snake
  26. https://www.jcp.org/en/jsr/detail?id=30
  27. https://www.jcp.org/en/jsr/detail?id=37
  28. https://jcp.org/aboutJava/communityprocess/JCPOverview_March2014.pdf
  29. https://www.datamation.com/mobile/oracle-positions-java-for-the-new-mobile-world/
  30. https://www.siliconrepublic.com/comms/global-mobile-sales-totalled-1-6bn-in-2010
  31. https://www.eweek.com/enterprise-apps/oracle-aims-java-me-embedded-at-the-internet-of-things/
  32. https://www.oracle.com/technical-resources/articles/java/java-me-embedded-iot.html
  33. https://newsroom.eclipse.org/news/announcements/eclipse-simplifies-development-internet-things-iot-solutions-open-iot-stack-java
  34. https://jcp.org/en/jsr/detail?id=139
  35. https://jcp.org/en/jsr/detail?id=360
  36. https://jcp.org/en/jsr/detail?id=37
  37. https://jcp.org/en/jsr/detail?id=118
  38. https://www.oracle.com/technical-resources/articles/javame/ota.html
  39. https://docs.oracle.com/javame/config/cldc/ref-impl/midp2.0/jsr118/javax/microedition/lcdui/package-summary.html
  40. https://docs.oracle.com/javame/config/cldc/ref-impl/midp2.0/jsr118/javax/microedition/midlet/doc-files/Authorization.html
  41. https://jcp.org/en/jsr/detail?id=271
  42. https://jcp.org/en/jsr/detail?id=36
  43. https://jcp.org/en/jsr/detail?id=218
  44. https://www.oracle.com/technical-resources/articles/java/java-and-c-virtual-machine.html
  45. https://docs.oracle.com/javame/config/cdc/cdc-opt-impl/1.1.2/porting.pdf
  46. https://jcp.org/en/jsr/detail?id=46
  47. https://jcp.org/en/jsr/detail?id=219
  48. https://www.oracle.com/technical-resources/articles/javame/mobility-java-technology.html
  49. https://jcp.org/en/jsr/detail?id=129
  50. https://jcp.org/en/jsr/detail?id=217
  51. https://docs.oracle.com/javame/config/cdc/ref-impl/pbp1.1.2/jsr217/index.html
  52. https://docs.oracle.com/javame/8.3/release-notes-sdk/
  53. https://docs.oracle.com/javame/8.3/sdk-dev-guide/oracle-java-me-sdk.htm
  54. https://www.oracle.com/java/technologies/java-embedded-java-me-downloads.html
  55. https://docs.oracle.com/javame/8.3/release-notes-rpi/toc.htm
  56. https://www.oracle.com/java/technologies/sun-java-wireless-toolkit.html
  57. https://phonej2me.github.io/
  58. https://phonej2me.github.io/phone_me_faq.html
  59. https://sourceforge.net/projects/microemulator/
  60. https://code.google.com/archive/p/microemu/
  61. https://phonej2me.github.io/content/phoneme_advanced_r1.html
  62. https://www.codenameone.com/
  63. https://github.com/codenameone/CodenameOne
  64. https://www.cin.ufpe.br/~mlearning/intranet/chi_guidelines/Nokia_Series_40_J2ME_Game_Usability_Guidelines_and_Implementation_Model_v1_0.pdf
  65. https://nikita36078.github.io/J2ME_Docs/docs/nokiaapi2/
  66. https://www.ac6-tools.com/en/IBM/J9.php
  67. https://axmasoft.com/comparing-android-and-java-me/
  68. https://sourceforge.net/projects/freej2me/
  69. https://github.com/hex007/freej2me
  70. https://jcp.org/en/jsr/platform
  71. https://blog.eisele.net/2012/11/java-specification-requests-in-numbers.html
  72. https://www.oracle.com/java/technologies/java-archive-downloads-javame-downloads.html
  73. https://www.embedded.com/build-small-footprint-guis-for-arm-cortex-m-designs-using-java/
  74. https://repository.microej.com/packages/devdevguide-4.1-A/TLT-0784-MAN-DeviceDevGuide-1.1.0.pdf
  75. https://jcp.org/en/jsr/detail?id=361
  76. https://www.oracle.com/java/technologies/javame-embedded/javame-embedded-getstarted.html
  77. https://www.azul.com/blog/a-fresh-look-at-embedded-java/
  78. https://www.gsmarena.com/nokia_asha_200-4281.php
  79. https://www.infoworld.com/article/2161565/mobile-java-develop-state-of-the-art-mobile-games.html
  80. http://www.oracle.com/technetwork/java/javameasia-352165.pdf
  81. https://mobileoperatingsystems.home.blog/blackberry/
  82. https://play.google.com/store/apps/details?id=ru.playsoftware.j2meloader
  83. https://www.vodafone.com/news/technology-news/mobile_advertising_markets
  84. https://www.codenameone.com/blog/j2me-feature-phones-nokia-devices.html
  85. https://www.oracle.com/java/technologies/java-embedded.html
  86. https://www.oracle.com/technical-resources/articles/java/cruz-gpio.html
  87. https://www.oracle.com/docs/tech/java/me-e-otn-faq-1852008.pdf
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.