Java Micro Edition (Java ME) is a platform for developing applications for embedded systems, mobile devices, and other resource-constrained environments. This guide covers Java ME development with a focus on embedded systems applications.
Java ME Platform Overview
Configuration and Profile Architecture
Java ME uses a layered approach:
- Configuration (CDC, CLDC) - Base functionality
- Profile (MIDP, FP) - Domain-specific APIs
- Optional Packages - Additional APIs
Development Environment Setup
Maven Configuration for Java ME
<!-- pom.xml --> <project> <modelVersion>4.0.0</modelVersion> <groupId>com.embedded</groupId> <artifactId>java-me-app</artifactId> <version>1.0.0</version> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <!-- Java ME dependencies --> <dependency> <groupId>javax.microedition</groupId> <artifactId>midp</artifactId> <version>2.0</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.microedition</groupId> <artifactId>cldc</artifactId> <version>1.1</version> <scope>provided</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.11.0</version> </plugin> <plugin> <groupId>org.me4se</groupId> <artifactId>maven-mep-plugin</artifactId> <version>1.0.0</version> </plugin> </plugins> </build> </project>
CLDC (Connected Limited Device Configuration)
Example 1: Basic CLDC Application
package com.embedded.basic;
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.StringItem;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
public class BasicMIDlet extends MIDlet implements CommandListener {
private Display display;
private Form mainForm;
private Command exitCommand;
private Command infoCommand;
private StringItem statusItem;
public BasicMIDlet() {
display = Display.getDisplay(this);
// Create main form
mainForm = new Form("Embedded System");
// Create commands
exitCommand = new Command("Exit", Command.EXIT, 0);
infoCommand = new Command("Info", Command.SCREEN, 1);
// Create status display
statusItem = new StringItem("Status: ", "Ready");
// Add components to form
mainForm.append(statusItem);
mainForm.addCommand(exitCommand);
mainForm.addCommand(infoCommand);
mainForm.setCommandListener(this);
}
public void startApp() {
display.setCurrent(mainForm);
updateStatus("Application Started");
// Initialize system monitoring
startSystemMonitor();
}
public void pauseApp() {
updateStatus("Application Paused");
}
public void destroyApp(boolean unconditional) {
updateStatus("Application Shutting Down");
cleanupResources();
}
public void commandAction(Command c, Displayable d) {
if (c == exitCommand) {
notifyDestroyed();
} else if (c == infoCommand) {
showSystemInfo();
}
}
private void updateStatus(String message) {
statusItem.setText(message);
System.out.println("Status: " + message);
}
private void startSystemMonitor() {
// Start background monitoring thread
Thread monitorThread = new Thread(new Runnable() {
public void run() {
while (true) {
try {
// Monitor system resources
monitorSystemResources();
Thread.sleep(5000); // Check every 5 seconds
} catch (InterruptedException e) {
break;
}
}
}
});
monitorThread.setPriority(Thread.MIN_PRIORITY);
monitorThread.start();
}
private void monitorSystemResources() {
// Monitor memory usage
long freeMemory = Runtime.getRuntime().freeMemory();
long totalMemory = Runtime.getRuntime().totalMemory();
String memoryInfo = "Memory: " + (freeMemory / 1024) + "KB free / " +
(totalMemory / 1024) + "KB total";
// Update status in UI thread
display.callSerially(new Runnable() {
public void run() {
StringItem memoryItem = new StringItem("", memoryInfo);
// Update display with memory info
}
});
}
private void showSystemInfo() {
Form infoForm = new Form("System Information");
// Runtime information
infoForm.append("Java ME CLDC Application\n");
infoForm.append("Free Memory: " + Runtime.getRuntime().freeMemory() + " bytes\n");
infoForm.append("Total Memory: " + Runtime.getRuntime().totalMemory() + " bytes\n");
// System properties
String platform = System.getProperty("microedition.platform");
String config = System.getProperty("microedition.configuration");
String profile = System.getProperty("microedition.profiles");
infoForm.append("Platform: " + platform + "\n");
infoForm.append("Configuration: " + config + "\n");
infoForm.append("Profile: " + profile + "\n");
Command backCommand = new Command("Back", Command.BACK, 1);
infoForm.addCommand(backCommand);
infoForm.setCommandListener(new CommandListener() {
public void commandAction(Command c, Displayable d) {
display.setCurrent(mainForm);
}
});
display.setCurrent(infoForm);
}
private void cleanupResources() {
// Clean up any resources
System.gc(); // Suggest garbage collection
}
}
Embedded Device Communication
Example 2: Serial Communication and GPIO Control
package com.embedded.communication;
import javax.microedition.midlet.MIDlet;
import javax.microedition.io.Connector;
import javax.microedition.io.CommConnection;
import java.io.InputStream;
import java.io.OutputStream;
import javax.microedition.lcdui.*;
public class SerialCommunicationMIDlet extends MIDlet implements CommandListener {
private Display display;
private Form mainForm;
private Command exitCommand;
private Command connectCommand;
private Command sendCommand;
private StringItem statusItem;
private TextField commandField;
private CommConnection serialConn;
private InputStream inputStream;
private OutputStream outputStream;
private boolean connected = false;
private static final String SERIAL_PORT = "comm:COM0;baudrate=9600";
public SerialCommunicationMIDlet() {
display = Display.getDisplay(this);
mainForm = new Form("Serial Communication");
// Create UI components
statusItem = new StringItem("Status: ", "Disconnected");
commandField = new TextField("Command:", "", 32, TextField.ANY);
// Create commands
exitCommand = new Command("Exit", Command.EXIT, 0);
connectCommand = new Command("Connect", Command.SCREEN, 1);
sendCommand = new Command("Send", Command.SCREEN, 2);
// Setup form
mainForm.append(statusItem);
mainForm.append(commandField);
mainForm.addCommand(exitCommand);
mainForm.addCommand(connectCommand);
mainForm.addCommand(sendCommand);
mainForm.setCommandListener(this);
}
public void startApp() {
display.setCurrent(mainForm);
}
public void pauseApp() {
disconnectSerial();
}
public void destroyApp(boolean unconditional) {
disconnectSerial();
}
public void commandAction(Command c, Displayable d) {
if (c == exitCommand) {
destroyApp(true);
notifyDestroyed();
} else if (c == connectCommand) {
if (!connected) {
connectSerial();
} else {
disconnectSerial();
}
} else if (c == sendCommand) {
sendSerialCommand(commandField.getString());
}
}
private void connectSerial() {
try {
// Open serial connection
serialConn = (CommConnection) Connector.open(SERIAL_PORT);
inputStream = serialConn.openInputStream();
outputStream = serialConn.openOutputStream();
connected = true;
updateStatus("Connected to " + SERIAL_PORT);
connectCommand.setLabel("Disconnect");
// Start reading thread
startSerialReader();
} catch (Exception e) {
updateStatus("Connection failed: " + e.getMessage());
connected = false;
}
}
private void disconnectSerial() {
try {
connected = false;
if (inputStream != null) {
inputStream.close();
inputStream = null;
}
if (outputStream != null) {
outputStream.close();
outputStream = null;
}
if (serialConn != null) {
serialConn.close();
serialConn = null;
}
updateStatus("Disconnected");
connectCommand.setLabel("Connect");
} catch (Exception e) {
updateStatus("Disconnect error: " + e.getMessage());
}
}
private void startSerialReader() {
Thread readerThread = new Thread(new Runnable() {
public void run() {
byte[] buffer = new byte[256];
while (connected) {
try {
int bytesRead = inputStream.read(buffer);
if (bytesRead > 0) {
String receivedData = new String(buffer, 0, bytesRead);
processReceivedData(receivedData);
}
} catch (Exception e) {
if (connected) {
updateStatus("Read error: " + e.getMessage());
}
break;
}
}
}
});
readerThread.start();
}
private void sendSerialCommand(String command) {
if (!connected) {
updateStatus("Not connected");
return;
}
try {
// Add newline terminator
String fullCommand = command + "\r\n";
outputStream.write(fullCommand.getBytes());
outputStream.flush();
updateStatus("Sent: " + command);
} catch (Exception e) {
updateStatus("Send error: " + e.getMessage());
}
}
private void processReceivedData(String data) {
// Process incoming data from embedded device
final String received = data.trim();
display.callSerially(new Runnable() {
public void run() {
// Update UI with received data
String currentText = statusItem.getText();
statusItem.setText("Received: " + received);
// Log to system out
System.out.println("Serial RX: " + received);
}
});
}
private void updateStatus(String message) {
statusItem.setText(message);
System.out.println("Status: " + message);
}
}
// GPIO Control Simulation
class GPIOManager {
private static final int MAX_PINS = 8;
private boolean[] pinStates = new boolean[MAX_PINS];
private int[] pinModes = new int[MAX_PINS]; // 0=input, 1=output
public void pinMode(int pin, int mode) {
if (pin >= 0 && pin < MAX_PINS) {
pinModes[pin] = mode;
}
}
public void digitalWrite(int pin, boolean state) {
if (pin >= 0 && pin < MAX_PINS && pinModes[pin] == 1) {
pinStates[pin] = state;
System.out.println("GPIO Pin " + pin + " set to " + state);
}
}
public boolean digitalRead(int pin) {
if (pin >= 0 && pin < MAX_PINS && pinModes[pin] == 0) {
return pinStates[pin];
}
return false;
}
public void analogWrite(int pin, int value) {
if (pin >= 0 && pin < MAX_PINS) {
System.out.println("Analog Write Pin " + pin + " value: " + value);
}
}
public int analogRead(int pin) {
// Simulate analog read
return (int) (Math.random() * 1024);
}
}
Sensor Data Processing
Example 3: Sensor Monitoring Application
package com.embedded.sensors;
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.*;
import java.util.Timer;
import java.util.TimerTask;
public class SensorMonitorMIDlet extends MIDlet implements CommandListener {
private Display display;
private Form sensorForm;
private Gauge tempGauge;
private Gauge humidityGauge;
private Gauge pressureGauge;
private StringItem tempValue;
private StringItem humidityValue;
private StringItem pressureValue;
private Command exitCommand;
private Command calibrateCommand;
private Timer sensorTimer;
private SensorSimulator sensorSimulator;
// Sensor thresholds
private static final double MIN_TEMP = -10.0;
private static final double MAX_TEMP = 50.0;
private static final double MIN_HUMIDITY = 0.0;
private static final double MAX_HUMIDITY = 100.0;
private static final double MIN_PRESSURE = 900.0;
private static final double MAX_PRESSURE = 1100.0;
public SensorMonitorMIDlet() {
display = Display.getDisplay(this);
sensorSimulator = new SensorSimulator();
setupUI();
}
private void setupUI() {
sensorForm = new Form("Sensor Monitor");
// Temperature display
tempValue = new StringItem("Temperature: ", "0.0°C");
tempGauge = new Gauge("Temp", true, 100, 50);
sensorForm.append(tempValue);
sensorForm.append(tempGauge);
// Humidity display
humidityValue = new StringItem("Humidity: ", "0.0%");
humidityGauge = new Gauge("Humidity", true, 100, 50);
sensorForm.append(humidityValue);
sensorForm.append(humidityGauge);
// Pressure display
pressureValue = new StringItem("Pressure: ", "0.0 hPa");
pressureGauge = new Gauge("Pressure", true, 100, 50);
sensorForm.append(pressureValue);
sensorForm.append(pressureGauge);
// Commands
exitCommand = new Command("Exit", Command.EXIT, 0);
calibrateCommand = new Command("Calibrate", Command.SCREEN, 1);
sensorForm.addCommand(exitCommand);
sensorForm.addCommand(calibrateCommand);
sensorForm.setCommandListener(this);
}
public void startApp() {
display.setCurrent(sensorForm);
startSensorMonitoring();
}
public void pauseApp() {
stopSensorMonitoring();
}
public void destroyApp(boolean unconditional) {
stopSensorMonitoring();
}
public void commandAction(Command c, Displayable d) {
if (c == exitCommand) {
destroyApp(true);
notifyDestroyed();
} else if (c == calibrateCommand) {
calibrateSensors();
}
}
private void startSensorMonitoring() {
sensorTimer = new Timer();
sensorTimer.scheduleAtFixedRate(new TimerTask() {
public void run() {
updateSensorReadings();
}
}, 0, 2000); // Update every 2 seconds
}
private void stopSensorMonitoring() {
if (sensorTimer != null) {
sensorTimer.cancel();
sensorTimer = null;
}
}
private void updateSensorReadings() {
// Get simulated sensor data
SensorData data = sensorSimulator.readSensors();
// Update UI in the display thread
display.callSerially(new Runnable() {
public void run() {
updateTemperatureDisplay(data.getTemperature());
updateHumidityDisplay(data.getHumidity());
updatePressureDisplay(data.getPressure());
// Check for alarm conditions
checkAlarmConditions(data);
}
});
}
private void updateTemperatureDisplay(double temperature) {
tempValue.setText(String.format("%.1f°C", temperature));
// Convert to gauge value (0-100)
int gaugeValue = (int) ((temperature - MIN_TEMP) / (MAX_TEMP - MIN_TEMP) * 100);
gaugeValue = Math.max(0, Math.min(100, gaugeValue));
tempGauge.setValue(gaugeValue);
}
private void updateHumidityDisplay(double humidity) {
humidityValue.setText(String.format("%.1f%%", humidity));
int gaugeValue = (int) ((humidity - MIN_HUMIDITY) / (MAX_HUMIDITY - MIN_HUMIDITY) * 100);
gaugeValue = Math.max(0, Math.min(100, gaugeValue));
humidityGauge.setValue(gaugeValue);
}
private void updatePressureDisplay(double pressure) {
pressureValue.setText(String.format("%.1f hPa", pressure));
int gaugeValue = (int) ((pressure - MIN_PRESSURE) / (MAX_PRESSURE - MIN_PRESSURE) * 100);
gaugeValue = Math.max(0, Math.min(100, gaugeValue));
pressureGauge.setValue(gaugeValue);
}
private void checkAlarmConditions(SensorData data) {
// Check for critical conditions
if (data.getTemperature() > 40.0) {
showAlert("HIGH TEMPERATURE", "Temperature exceeds safe limit!");
}
if (data.getHumidity() > 85.0) {
showAlert("HIGH HUMIDITY", "Humidity level critical!");
}
if (data.getPressure() < 950.0 || data.getPressure() > 1050.0) {
showAlert("PRESSURE ALERT", "Pressure out of normal range!");
}
}
private void showAlert(String title, String message) {
Alert alert = new Alert(title, message, null, AlertType.WARNING);
alert.setTimeout(Alert.FOREVER);
display.setCurrent(alert, sensorForm);
}
private void calibrateSensors() {
sensorSimulator.calibrate();
showAlert("Calibration", "Sensors calibrated successfully");
}
}
// Sensor Data Model
class SensorData {
private double temperature;
private double humidity;
private double pressure;
public SensorData(double temp, double humidity, double pressure) {
this.temperature = temp;
this.humidity = humidity;
this.pressure = pressure;
}
public double getTemperature() { return temperature; }
public double getHumidity() { return humidity; }
public double getPressure() { return pressure; }
}
// Sensor Simulator
class SensorSimulator {
private double tempOffset = 0.0;
private double humidityOffset = 0.0;
private double pressureOffset = 0.0;
public SensorData readSensors() {
// Simulate sensor readings with some noise
double temp = 20.0 + (Math.random() * 30.0) - 15.0 + tempOffset;
double humidity = 50.0 + (Math.random() * 40.0) - 20.0 + humidityOffset;
double pressure = 1013.0 + (Math.random() * 50.0) - 25.0 + pressureOffset;
return new SensorData(temp, humidity, pressure);
}
public void calibrate() {
// Reset offsets to zero (simulate calibration)
tempOffset = 0.0;
humidityOffset = 0.0;
pressureOffset = 0.0;
}
}
Data Logging and Storage
Example 4: Persistent Data Storage
package com.embedded.storage;
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.*;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordEnumeration;
import javax.microedition.rms.RecordFilter;
import javax.microedition.rms.RecordComparator;
import javax.microedition.rms.InvalidRecordIDException;
import java.io.*;
import java.util.Date;
public class DataLoggerMIDlet extends MIDlet implements CommandListener {
private Display display;
private Form mainForm;
private Command exitCommand;
private Command logCommand;
private Command viewCommand;
private Command clearCommand;
private StringItem statusItem;
private TextField logEntryField;
private static final String RECORD_STORE_NAME = "DataLoggerStore";
public DataLoggerMIDlet() {
display = Display.getDisplay(this);
setupUI();
}
private void setupUI() {
mainForm = new Form("Data Logger");
statusItem = new StringItem("Status: ", "Ready");
logEntryField = new TextField("Log Entry:", "", 50, TextField.ANY);
exitCommand = new Command("Exit", Command.EXIT, 0);
logCommand = new Command("Log Data", Command.SCREEN, 1);
viewCommand = new Command("View Logs", Command.SCREEN, 2);
clearCommand = new Command("Clear Logs", Command.SCREEN, 3);
mainForm.append(statusItem);
mainForm.append(logEntryField);
mainForm.addCommand(exitCommand);
mainForm.addCommand(logCommand);
mainForm.addCommand(viewCommand);
mainForm.addCommand(clearCommand);
mainForm.setCommandListener(this);
}
public void startApp() {
display.setCurrent(mainForm);
updateStatus("Data Logger Started");
}
public void pauseApp() {
updateStatus("Logger Paused");
}
public void destroyApp(boolean unconditional) {
updateStatus("Logger Shutting Down");
}
public void commandAction(Command c, Displayable d) {
if (c == exitCommand) {
destroyApp(true);
notifyDestroyed();
} else if (c == logCommand) {
logData(logEntryField.getString());
} else if (c == viewCommand) {
viewLogs();
} else if (c == clearCommand) {
clearLogs();
}
}
private void logData(String data) {
if (data == null || data.trim().isEmpty()) {
updateStatus("No data to log");
return;
}
RecordStore rs = null;
try {
// Open record store (create if not exists)
rs = RecordStore.openRecordStore(RECORD_STORE_NAME, true);
// Create log entry with timestamp
String timestamp = new Date().toString();
String logEntry = timestamp + " - " + data;
// Convert to bytes and store
byte[] bytes = logEntry.getBytes("UTF-8");
rs.addRecord(bytes, 0, bytes.length);
updateStatus("Data logged successfully");
logEntryField.setString(""); // Clear input field
} catch (Exception e) {
updateStatus("Log error: " + e.getMessage());
} finally {
closeRecordStore(rs);
}
}
private void viewLogs() {
Form logForm = new Form("Log Entries");
RecordStore rs = null;
try {
rs = RecordStore.openRecordStore(RECORD_STORE_NAME, false);
if (rs.getNumRecords() == 0) {
logForm.append("No log entries found");
} else {
RecordEnumeration re = rs.enumerateRecords(null, new LogComparator(), false);
int count = 0;
while (re.hasNextElement() && count < 20) { // Limit display
int recordId = re.nextRecordId();
byte[] data = rs.getRecord(recordId);
String logEntry = new String(data, "UTF-8");
logForm.append((count + 1) + ". " + logEntry + "\n");
count++;
}
re.destroy();
}
} catch (Exception e) {
logForm.append("Error reading logs: " + e.getMessage());
} finally {
closeRecordStore(rs);
}
Command backCommand = new Command("Back", Command.BACK, 1);
logForm.addCommand(backCommand);
logForm.setCommandListener(new CommandListener() {
public void commandAction(Command c, Displayable d) {
display.setCurrent(mainForm);
}
});
display.setCurrent(logForm);
}
private void clearLogs() {
try {
RecordStore.deleteRecordStore(RECORD_STORE_NAME);
updateStatus("All logs cleared");
} catch (Exception e) {
updateStatus("Clear error: " + e.getMessage());
}
}
private void closeRecordStore(RecordStore rs) {
if (rs != null) {
try {
rs.close();
} catch (Exception e) {
// Ignore close errors
}
}
}
private void updateStatus(String message) {
statusItem.setText(message);
System.out.println("Logger: " + message);
}
}
// Custom comparator for sorting log entries
class LogComparator implements RecordComparator {
public int compare(byte[] rec1, byte[] rec2) {
try {
String str1 = new String(rec1, "UTF-8");
String str2 = new String(rec2, "UTF-8");
// Compare timestamps (assuming they're at the start)
return str2.compareTo(str1); // Descending order (newest first)
} catch (Exception e) {
return RecordComparator.EQUIVALENT;
}
}
}
Network Communication for IoT
Example 5: HTTP Client for Cloud Communication
package com.embedded.network;
import javax.microedition.midlet.MIDlet;
import javax.microedition.lcdui.*;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
public class IoTClientMIDlet extends MIDlet implements CommandListener {
private Display display;
private Form mainForm;
private Command exitCommand;
private Command sendCommand;
private Command configCommand;
private StringItem statusItem;
private TextField dataField;
private TextField urlField;
private String serverURL = "http://api.embedded-server.com/data";
public IoTClientMIDlet() {
display = Display.getDisplay(this);
setupUI();
}
private void setupUI() {
mainForm = new Form("IoT Client");
statusItem = new StringItem("Status: ", "Disconnected");
urlField = new TextField("Server URL:", serverURL, 100, TextField.URL);
dataField = new TextField("Data:", "sensor_data=value", 50, TextField.ANY);
exitCommand = new Command("Exit", Command.EXIT, 0);
sendCommand = new Command("Send Data", Command.SCREEN, 1);
configCommand = new Command("Config", Command.SCREEN, 2);
mainForm.append(statusItem);
mainForm.append(urlField);
mainForm.append(dataField);
mainForm.addCommand(exitCommand);
mainForm.addCommand(sendCommand);
mainForm.addCommand(configCommand);
mainForm.setCommandListener(this);
}
public void startApp() {
display.setCurrent(mainForm);
}
public void pauseApp() {
// Nothing to pause
}
public void destroyApp(boolean unconditional) {
// Cleanup if needed
}
public void commandAction(Command c, Displayable d) {
if (c == exitCommand) {
destroyApp(true);
notifyDestroyed();
} else if (c == sendCommand) {
sendDataToServer();
} else if (c == configCommand) {
showConfiguration();
}
}
private void sendDataToServer() {
Thread networkThread = new Thread(new Runnable() {
public void run() {
HttpConnection conn = null;
InputStream is = null;
OutputStream os = null;
try {
String url = urlField.getString();
String data = dataField.getString();
updateStatus("Connecting to: " + url);
// Create HTTP connection
conn = (HttpConnection) Connector.open(url);
conn.setRequestMethod(HttpConnection.POST);
conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
conn.setRequestProperty("User-Agent", "JavaME-Embedded-Client/1.0");
// Send data
os = conn.openOutputStream();
os.write(data.getBytes("UTF-8"));
os.flush();
// Get response
int responseCode = conn.getResponseCode();
is = conn.openInputStream();
if (responseCode == HttpConnection.HTTP_OK) {
String response = readResponse(is);
updateStatus("Success: " + response);
} else {
updateStatus("Server error: " + responseCode);
}
} catch (Exception e) {
updateStatus("Network error: " + e.getMessage());
} finally {
// Clean up resources
closeStream(is);
closeStream(os);
closeConnection(conn);
}
}
});
networkThread.start();
}
private String readResponse(InputStream is) throws IOException {
StringBuffer sb = new StringBuffer();
int ch;
while ((ch = is.read()) != -1) {
sb.append((char) ch);
}
return sb.toString();
}
private void closeStream(java.io.Closeable stream) {
if (stream != null) {
try {
stream.close();
} catch (Exception e) {
// Ignore
}
}
}
private void closeConnection(HttpConnection conn) {
if (conn != null) {
try {
conn.close();
} catch (Exception e) {
// Ignore
}
}
}
private void showConfiguration() {
Form configForm = new Form("Configuration");
TextField intervalField = new TextField("Update Interval (ms):", "5000", 10, TextField.NUMERIC);
ChoiceGroup protocolChoice = new ChoiceGroup("Protocol", ChoiceGroup.EXCLUSIVE);
protocolChoice.append("HTTP", null);
protocolChoice.append("HTTPS", null);
protocolChoice.append("MQTT", null);
configForm.append(intervalField);
configForm.append(protocolChoice);
Command saveCommand = new Command("Save", Command.OK, 1);
Command backCommand = new Command("Back", Command.BACK, 2);
configForm.addCommand(saveCommand);
configForm.addCommand(backCommand);
configForm.setCommandListener(new CommandListener() {
public void commandAction(Command c, Displayable d) {
if (c == saveCommand) {
// Save configuration
updateStatus("Configuration saved");
}
display.setCurrent(mainForm);
}
});
display.setCurrent(configForm);
}
private void updateStatus(final String message) {
display.callSerially(new Runnable() {
public void run() {
statusItem.setText(message);
System.out.println("IoT Client: " + message);
}
});
}
}
Best Practices for Embedded Java ME
Memory Management
public class MemoryUtils {
// Monitor memory usage
public static void logMemoryUsage() {
Runtime runtime = Runtime.getRuntime();
long free = runtime.freeMemory();
long total = runtime.totalMemory();
long used = total - free;
System.out.println("Memory Usage:");
System.out.println(" Used: " + (used / 1024) + " KB");
System.out.println(" Free: " + (free / 1024) + " KB");
System.out.println(" Total: " + (total / 1024) + " KB");
}
// Optimized string operations for memory-constrained environments
public static String compactString(String input, int maxLength) {
if (input == null || input.length() <= maxLength) {
return input;
}
return input.substring(0, maxLength - 3) + "...";
}
// Efficient array operations
public static byte[] resizeArray(byte[] original, int newSize) {
byte[] newArray = new byte[newSize];
int copyLength = Math.min(original.length, newSize);
System.arraycopy(original, 0, newArray, 0, copyLength);
return newArray;
}
}
// Resource cleanup utility
class ResourceManager {
public static void cleanup(Object... resources) {
for (Object resource : resources) {
if (resource instanceof java.io.Closeable) {
try {
((java.io.Closeable) resource).close();
} catch (Exception e) {
// Log but don't throw
System.err.println("Cleanup error: " + e.getMessage());
}
}
}
}
}
Deployment and JAD File Configuration
Application Descriptor (JAD)
# EmbeddedApp.jad MIDlet-1: SensorMonitor, /icon.png, com.embedded.sensors.SensorMonitorMIDlet MIDlet-2: DataLogger, /icon.png, com.embedded.storage.DataLoggerMIDlet MIDlet-3: IoTClient, /icon.png, com.embedded.network.IoTClientMIDlet MIDlet-Name: Embedded System Suite MIDlet-Version: 1.0.0 MIDlet-Vendor: Your Company MIDlet-Description: Java ME applications for embedded systems MicroEdition-Configuration: CLDC-1.1 MicroEdition-Profile: MIDP-2.0 MIDlet-Jar-Size: 24576 MIDlet-Jar-URL: EmbeddedApp.jar MIDlet-Permissions: javax.microedition.io.Connector.http, \ javax.microedition.io.Connector.comm, \ javax.microedition.io.Connector.socket MIDlet-Data-Size: 8192
Conclusion
Java ME provides a robust platform for embedded systems development with:
- Small Footprint: Optimized for memory-constrained devices
- Portability: Write once, run anywhere philosophy
- Rich APIs: Networking, storage, UI, and communication capabilities
- Security: Sandboxed execution environment
Key Considerations for Embedded Java ME:
- Memory Management: Be mindful of heap usage and object creation
- Power Consumption: Optimize for battery-powered devices
- Real-time Requirements: Java ME is not hard real-time
- Hardware Access: Limited direct hardware access (use JNI if needed)
- Networking: Built-in support for various protocols
Typical Use Cases:
- Industrial control systems
- IoT edge devices
- Medical devices
- Automotive systems
- Consumer electronics
- Smart sensors and actuators
Java ME continues to be relevant for embedded systems where Java's productivity benefits outweigh the performance constraints, particularly in applications requiring network connectivity, user interfaces, or complex business logic.