The Java ME 8 Platform - Oracle … · 1 | © 2012 Oracle Corporation –Proprietary and...

1 | © 2012 Oracle Corporation – Proprietary and Confidential

The Java ME 8 Platform

Technical Presentation


The following is intended to outline our general product direction. It is

intended for information purposes only, and may not be incorporated into

any contract. It is not a commitment to deliver any material, code, or

functionality, and should not be relied upon in making purchasing

decisions. The development, release, and timing of any features or

functionality described for Oracle’s products remains at the sole

discretion of Oracle.


Agenda

• Directions for Java ME evolution

• Java ME 8 Platform overview

• Java ME 8 implementations for vertical markets

• Java ME 9


Make the Future of Java

Platform Completeness

Modernization and Innovation

Developer Productivity

Open, Transparent Evolution

Active Community Involvement

Quality and Security


Java Strategy and Vision

JDK 7: adoption strong

among ISVs, hosting

providers, developers

JDK 8/9: lambda,

JavaScript interop and

JVM convergence in 8,

Jigsaw in 9

JDK 9 and beyond:

generic language interop,

GPU programming,

enhancements for cloud

Java SE

Move towards single

platform JSR

Subset of SE, merge

ME/SE tool and API

ecosystems

Generic small footprint

platform for small

embedded devices

Enable Java everywhere

in “Internet of Things”

Java ME

Expand to generic

security platform any

device

Enable rich ecosystem of

security applications

Use as foundation for

security in “Internet of

Things”

Java Card


Personal Devices

Sensors & Micro controllers

Smart Energy & mHealth

Connected VehiclesSmart Appliances &

Consumer ElectronicsCommunicationsIndustrial controls &

Network Appliances

Multi-function

Embedded Devices

Java Embedded


Platform

Footprint

Device

CPU/

GPU/I-OARM 7 Cortex M ARM9/11 MIPS32/Intel Atom/ARM CortexA/PPC

50KB-1MB

1MB-10MB

10MB-100MB

Java technology for Embedded Devices

Java ME

Java SE

Java

Card


ME Evolution : towards a common Java

Key Principles

• Java ME is the “little sibling” of Java SE.

• CLDC is a strict subset of Java SE

• Any Java ME app/library works on Java SE.

• Java ME vs Java SE is a footprint/functionality tradeoff.

• Java ME and Java SE releases are synchronized

Benefits

• Unified development experience & community

• Align language, core APIs, development and management tools

• Reuse Java ME APIs in Java SE: Bluetooth, Location, Sensors, Messaging….

• Reuse Java SE tools and management features in Java ME

• 9+ Million developers for all of Java from Card to Enterprise

Ensure alignment between ME/SE over the upcoming ME releases


Agenda




• Java ME 9


Java ME 8

• A modernized platform

– Updated VM & Small Embedded Profile

• Language alignment with Java SE

– CLDC 8 to align language/tooling with Java SE8

• Standardized Embedded APIs

– Dedicated APIs for small embedded devices

– Modular / optional specs to address a wide variety of devices

• M2M modules, microcontrollers, feature phones, medical monitoring

devices, smart meters, etc

The first step towards a common Java


Java ME 8 Platform Architecture

Java VM

Vertical

Specific

APIs

Application

Environment

CLDC 8 (with Support for Java Language 8)

Core device

vertical APIsMSA JSRs

Java ME Embedded Profile

(aka IMP 8)

Add. Optional

APIs

Add. Optional

APIs

On-Device I/O

Peripheral

Access

Device Access API

(aka DA API)


Java ME 8 PlatformNew JSRs for small Embedded

JSRs Description

CLDC 8 • New JVM Spec. aligned with JavaSE 7/8 language features

Java ME Embedded Profile 8 • Evolution of IMP and MIDP for the small embedded market.

• Addresses MIDP 3 usability issues and feature gaps.

• New Headless Application Management APIs

Device Access API • APIs to enable access from/to device interfaces and peripherals


• Existing Java ME JSRs can be

implemented atop ME8

• Optional JSRs enables fine-tuned

addressing of embedded needs

– Address vertical requirements

• Communication module/M2M,

smartmeter, healthcare, mobile,…

– Meet device static and dynamic

memory budgets for Java

– Support a variety of

hardware/peripherals/networks

ME8 stack for

M2M module

Java ME 8 PlatformCompatibility with existing optional ME JSRs


Agenda



- CLDC 8


• Java ME 9


Java SE 8

• Description

• CLDC 8 is an evolutionary update for CLDC 1.1.1 to bring the VM, Java language and core

API libraries in alignment with Java SE 7/8

• Key Features

• Synchronize with Java SE 5/6/7/8 Language Features into ME

• Introduce select Java SE API Library Features

• Virtual Machine Update

• Remain as small as possible - footprint optimizations

• Strict subset of SE 8 API

• GCF consolidated from CLDC 1.1, MIDP, CDC, JSR 197: New Access Point API,

connection options and protocol support, packaged as an optional specification

• Backward binary compatible

CLDC 8 High-level overview

CLDC 8


CLDC 8

CLDC 8 architecture

Java VM

java.io java.lang java.net java.nio java.security java.util

GCF

javax.microedition.io

HTTP HTTPSMulti-cast

Socket Datagram…

javax.microedition.pki

New in CLDC 8 Updated in CLDC 8


Area Feature

Java SE Language features Annotation, generics, autoboxing, assertions, enums, etc.

Java SE API Library features Subset of NIO, collections updated, etc.

Virtual machine features New LDC for class references, native resource manager, etc.

Footprint optimizations Up-to-date Java bytecode representation

CLDC 8 Requirements Summary


CLDC 8 new Java (JDK 5/6) Language Features

• Assertions

• Generics

• Enhanced for Loop

• Autoboxing

• Enumerations

• Varargs

• Static imports

• Annotations (JLS 7 section 9.6.3.2

@Retention - SOURCE retentions policy only.)

private void setInterval(int interval) {

assert interval > 0 && interval <= 1000 : "Invalid value?;

}

void processList(Vector<String> list) {

for (String item : list) {

...Hashtable<Integer, String> data = new Hashtable<>();

void add(int id, String value) {

data.put(id, value);

}enum Season {WINTER, SPRING, SUMMER, FALL};

private Season season;

void setSeason(Season newSeason) {

season = newSeason;

}

Added support for AbstractCollection, AbstractList,

AbstractSet, Collection, Collections,

Enumeration.java, Iterator, List, ListIterator, Set

void warning(String format, String... parameters) {

..

for(String p : parameters) { ...process(p);... }

...

}

@Deprecated

public void clear();

import static data.Constants.RATIO;

...

double r = Math.cos(RATIO * theta);


CLDC 8 new Java (JDK 7) Language Features

• Strings in switches

• Binary integral literals and underscores in

numeric literals

• Multi-catch and more precise rethrow

• Improved Type Inference for Generic Instance

Creation (diamond)

• Try-with-resources statement

catch (IOException | InterruptedException ex) {

logger.log(ex);

throw ex;

}

try (DataInputStream is = new DataInputStream(...)) {

return is.readDouble();

}

Hashtable<String, String> map = new Hashtable<>();

long mask = 0xfff0_ff08_4fff_0fffl;

byte flags = 0b01001111;

}

switch (arg) {

case "-data": ...

case "-out": ...


CLDC 8 Service Providerjava.util.ServiceLoader (a subset of the Java SE API)

• Services Framework is a functionality that provides ability to apps to use

different services that can be represented by >1 service provider (SP)

• Services Framework also allows managing lifecycle of SPs on the devices

• Technically, a Service is a well known set of Interfaces/Abstract classes. SP is

an implementation of the Service

• Features of the Service Framework

– java.util.ServiceLoader class from Java SE

– Ability of an application to declare that it can provide a service

– Ability of an application to declare a dependency on a service

– Ability of the AMS to bind a shared library provided by one MIDlet to another requesting a service

– Requirement on the AMS to enable binding only if the shared library is trusted


CLDC 8 Service Providers - Examplejava.util.ServiceLoader

import com.XYZ.ServiceA;

import java.util.ServiceLoader;

ServiceLoader<ServiceA> sl1 = ServiceLoader.load(ServiceA.class);

Iterator<ServiceA> serviceAs = sl1.iterator();

MyResult result = null;

while (serviceAs.hasNext() and result == null) {

ServiceA nextServiceProvider = serviceAs.next();

// use nextServiceProvider instance to find result from each available provider} …

ServiceB

ServiceB

Provider1

ServiceB

Provider2

com.XYZ.ServiceA

ServiceA

Provider1

ServiceA

Provider3

ServiceA

Provider3

JAR File Resources:META-INF/services/com.XYZ.ServiceA:

META-INF/services/ServiceB:

ServiceAProvider1ServiceAProvider2ServiceAProvider3

ServiceBProvider1ServiceBProvider2


Generic Connection Framework (GCF)

• Consolidates GCF specification from

CLDC, MIDP, CDC, and JSR 197

• Consistent IPV6 support

• Extended failure information via

exceptions from java.net

• File support via StreamConnection

• Extends protocol support

• Adds support for IP Multicast

• Permissions apply per protocol

CLDC /GCF 1.1

CLDC /GCF 8

CommConnection MIDP

HttpConnection MIDP

HttpsConnection MIDP

SecureConnection MIDP

ServerSocketConnection MIDP

SocketConnection MIDP

StreamConnection MIDP

UDPDatagramConnection MIDP

UDPMulticastConnectionNew in CLDC 8


New GCF Features

• GCF consistently supports IPV6 addresses

• The value of the host field on Connector.open must be a symbolic hostname, an IPv4 address or an IPv6 address surrounded by square brackets ('[', ']’).

• Normalization:– Any IP address component of a URI is normalized to lower case and

uncompressed form by removing leading zeros and converting the address (RFC 3513).

– The normalized form of an IPV6 address is x:x:x:x:x:x:x:x, where the 'x's are the hexadecimal values of the eight 16-bit pieces of the address.

IPV6


New GCF Features: UDP Multicast

• GCF includes support for UDP Multicast

• Enables 1 to n communication of UDP datagrams

• Multicast is important for distributed services: Used for service announcement and discovery, media streaming

• The new protocol class UDPMulticastConnection enables:– Client and server scenarios

– Joining multicast groups

– Creating a multicast server socket

UDP Multicast


New GCF Features: Connection Options

• ConnectionOptions

– Type-safe mechanism for protocol-specific additional parameters

– Useful for selecting access points, proxy settings, proprietary protocol extensions

• Example:ConnectionOption <String> keep = new ConnectionOption<String>("KeepAlive", "KEEP_ALIVE");

ConnectionOption <byte[]> cred = new ConnectionOption<byte[]>("Credentials",

new byte[]{ (byte) 204, (byte) 29, (byte) 207, (byte) 217 });

ConnectionOption <Integer> port = new ConnectionOption<Integer>("ProxyPort", 80);

ConnectionOption <Integer> timeout = new ConnectionOption<Integer>("Timeout", 2000);

try {

Connection c = Connector.open(<my.server.com>, cred, keep, port, timeout);

} …

Additional protocol parameters


New GCF Features: Access Point

• The AccessPoint API enables:

– Obtaining a list of available network access points

– Querying the access technology (e.g. 3GPP, CDMA, Wifi, WiMax,

Wired)

– Getting Access-point technology-specific properties (e.g. 3GPP

country code, network code, operator name)

– Selection of an access point for a connection

– Detection of connect/disconnect situations

Selecting a Network Access Point


New GCF Features: Access Point

AccessPoint aps[] = AccessPoint.getAccessPoints(true);

AccessPoint ap = aps[0];

// attach an event listener to the first access point

ap.addListener(new AccessPointListener() {

public void notifyEvent(AccessPoint accessPoint, int eventType) {

if ((accessPoint.getTechnology()==AccessPoint.TECHNOLOGY_3GPP) &&

(eventType==AccessPointListener.EVENT_TYPE_AVAILABLE))

System.out.println("Connected to Operator=”+ accessPoint.getProperty("operator"));

}

});

// select the first access point for communication

ConnectionOption<String> id = new ConnectionOption<String>("AccessPoint”,ap.getId());

Connection c = Connector.open("http://www.oracle.com/index.html", id);

Example


Development Tools for CLDC 8

• Standard JDK 7 or 8 tools can be used for application development

• Debug structures are optional

– Debug features are ignored by the CLDC 8 product VM

– Can be filtered out by Converter at build time to save application footprint

• Future tools under consideration may include:

– Optimizing converter for optimizing the application for CLDC platforms

– Process Flow: Compiler → Optimizing Converter

– Can be integrated with Java ME SDK and IDEs


Agenda



- Embedded Profile


• Java ME 9



• An evolution of IMP NG (JSR 228)

– Adopting features from MIDP

– Adding new enhancements for the small embedded market

• New APIs

– App start, pause/resume, destroy, multitasking, system properties, etc

– Dedicated Application Management System (AMS) API

– Events model

– Push Registry based inbound connection handling

– Persistent storage

– Allows diverse UI and media handler implementations

– Device power mode/consumption API

– App access to cellular network properties on communication modules

Dedicated set of Profile APIs for sub 10MB small embedded devices


Package Description

javax.microedition.ams Provides extended application management features to the containing profiles.

javax.microedition.cellular Provides classes to obtain information about cellular networks the device is registered on.

javax.microedition.event Events for system state changes and application to application communication.

javax.microedition.event.power Power management.

javax.microedition.io Networking support based on the Generic Connection Framework Specification.

javax.microedition.lcdui The APIs in the LCDUI package provide a set of features for implementing user interfaces.

javax.microedition.lui Line-oriented User Interface (LUI).

javax.microedition.media Implementations of this specification MAY require the support of the JSR 135 Mobile Media API v1.2 specification or subsets of it.

javax.microedition.midlet The Application and the environment in which the application runs.

javax.microedition.pki Certificates are used to authenticate information for secure Connections.

javax.microedition.rms The Record Management System (RMS) provides a mechanism for applications to persistently store data and later retrieve it.

javax.microedition.srms Simple Record Management System (SRMS)

Java ME Embedded ProfileSpecification Core Package Details


Java ME Embedded Profile – feature highlight

• Provides extended application management features to the

platform

– Trusted applications can invoke all AMS routines

– All necessary callbacks provided

– Installation process status

– Security

– Up to completely substituting AMS UI

javax.microedition.ams


• Shared Library - Functionality is the same as in the MIDP 3 specification.

– A shareable software component that one or more applications MAY use

at runtime

– Save static footprint size by enabling multiple application suites to share

the same common code without packaging them redundantly

– Reduced download times for applications that declare dependencies on

shared components

– Each shared library exposes a set of classes and resources to

applications for their use just as if those classes and resources were

originally packaged within the application JAR.

– No runtime specific APIs exist to support shared libraries

Java ME Embedded Profile – feature highlightShareable software components (shared libraries)


• API allows applications to retrieve device power consumption state

information. and for.

– Retrieve battery % level remaining

– Estimated remaining battery time

– Whether or not device is attached to an external source of power

– Get the current mode or set/request that the system transition to a new power

consumption mode (OFF, SUSPENDED, SLEEP, REGULATED_LOW,

REGULATED_HIGH or FULL power)

– System can signal state changes in power state to applications that have

registered listeners

Java ME Embedded Profile – feature highlightjavax.microedition.events.power - Power management API


• API provides methods to post and subscribe for event Allows

applications to:

– determine the events supported by the device, and

– register to be automatically launched in response to events.

• The system publishes some events and applications publish other

events.

• When an event is posted it is given a timestamp and the identity of

the application, if any, that posted it.

• Some events may convey privileged information to the application

and therefore the application must have the appropriate permission

to access such events

Java ME Embedded Profile – feature highlightjavax.microedition.events - Generalized Events and Notification API


• Subset of the MIDP RMS API:

– Reduced API set

• No integer tag supported for added records

• No listener interfaces for record changes

• No comparator support for enumeration operation

• No open (or create) of record stores for sharing with other

IMlets, can open a record store (not password protected) of

another IMlet.

– Smaller implementation footprint

Java ME Embedded Profile – feature highlightjavax.microedition.srms – Reduced footprint persistent store API


Agenda



- Device Access APIs


• Java ME 9


Device Access API JSR

• A generic peripheral device access API

• An optional package for small embedded devices using Java ME 8

– Requires CLDC 8 features (i.e. Java SE language features)

• Compatible with Java Platform Standard Edition 8

• Supports varying degrees of application level device access

abstractions


Device Access API JSRWhat is a Peripheral in the DA API?

• “Peripheral” designates any kind of peripheral devices, including those

external to the host device or an embedded peripheral chip.

• May designate a resource of that peripheral device subject to independent

access or control from the other components of the device.

– For example, a single pin of a GPIO (General Purpose I/O) controller may be viewed as an

individual Peripheral. Conversely, a Peripheral

• May not always correspond to a single peripheral device or its component,

but may be composed of several other sub-peripherals.

– For example, a Touch Screen Peripheral may be assembled from a Touch Screen SPI (Serial

Peripheral Interface bus) slave Peripheral and a GPIO pin Peripheral handling the Pen-Down

signal.


Device Access API JSRJSR Package Details

Package Description

General Purpose Input/Output(GPIO)

GPIO pins as well as GPIO ports (grouping of GPIO pins) can be accessed and controlled as individual Peripherals. Any number of GPIO controllers can be supported.

Inter-Integrated Circuit Bus (I2C) I2C slave on the I2C bus can be accessed and controlled as individual Peripherals. This specification only defines support for the device as the I2C master role. Any number of I2C buses can be supported.

Serial Peripheral Interface Bus (SPI) SPI slave on the SPI bus can be accessed and controlled as individual Peripherals. This specification only defines support for the device as the SPI master role. Any number of SPI bus can be supported.

Analog To Digital Converter (ADC) ADC channels of an ADC converter can be accessed and controlled as individual Peripherals. Any number of ADC converters can be supported.

Universal Asynchronous Receiver/Transmitter (UART)

UART can be accessed and controlled as individual Peripherals. This API additionally provides means to control the Data Communication Equipment (DTE) signals when connected to a MODEM.

Memory-Mapped Input/Output(MMIO)

Devices with memory-mapped registers and memory blocks can be accessed and controlled as individual Peripherals. MMIO allows for developing device drivers in the Java language and therefore requires for each device only very minimal support in the porting layer of the embedded platform.

AT Command Devices MODEMs and in general devices supporting AT commands, can be accessed and controlled as individual Peripherals

Watchdog Timers Watchdog timers (WDT) can be accessed and controlled as individual Peripherals

Pulse Counter/Timer Pulse counters and timers can be accessed and controlled as individual Peripherals.

Generic Devices Other types of devices can be supported through a set of generic peripheral interfaces.


Java ME 8 - JCP Activities and Timeline

• Oracle is in process of filing the first ME8 JSRs– CLDC 8

– Java ME Embedded Profile

• Additional optional JSRs to follow

– Device Access APIs

• JCP completion within a year

• Two-year platform update cycle– Java ME 8 – 2013,

– Java ME 9 – 2015


Agenda




• Java ME 9


Vertical Market Stack – Example 1

API suited to low power microcontrollers for M2M/Comm. modules JSR Platform Functional Area


8

(Optional) Application Packaging and Provisioning Management, Shared Libraries

Cellular Network information (javax.microedition.cellular)

System /Application Event subsystem (javax.microedition.event)

(Optional) Device Power Mode Control/Monitoring (javax.microedition.event.power)

Inter-application comms. and (optional protocols for) Push Registry

Application execution model and concurrency

(Optional) Persistent data storage and retrieval (SRMS)

Security Policy and Application permissions

(Optional) Graphical UI subsystem (javax.microedition.lcdui/lui)

(Optional) Media manipulation (javax.microedition.media)

Device Access API (Optional) UART, SPI, GPIO and Peripheral Power Mgmt

GCF 8 (Optional) UDP, AccessPoint APIs

CLDC 8 Subset of Java SE 6/7/8 Language and Core APIs(lang, io, util, net, nio, security etc.)

Java ME Optional Package JSRs

JSR x

JSR y

JSR z…etc.


Mobile stack with Java ME Embedded Profile

• Java ME Embedded Profile design considered most MIDP features

– Exceptions : Application Level Access Authorization & RMS

interchange format

• New Connectivity Options

– SIM selection for packet data network connections

– SIM properties for multi-SIM device

– Connection profile selection (WiFi AP, network I/F, etc) and IPv6 support

• New Gesture API

– Higher-order pointer events

• Simplified security model for improved user experience

– Installation of signed unverified applications is allowed

– Implementation is suggested to minimize the amount of user interventions related to security

(security prompts)

Simplifying and improving MIDP APIs


Vertical Market Stack– Example 2

API suited to a core mobile platformJSR Platform Functional Area


8

Application Packaging and Provisioning Management, Shared Libraries

Cellular Network information (javax.microedition.cellular)

System /Application Event subsystem (javax.microedition.event)

Device Power Mode Control/Monitoring (javax.microedition.event.power)

Inter-application communication and Push Registry

Application execution model and concurrency

Persistent data storage and retrieval (Full RMS)

Security Policy and Application permissions

(Optional) Graphical UI subsystem (javax.microedition.lcdui/lui)

(Optional) Media manipulation (javax.microedition.media)

Device Access API (Optional) UART and USB peripheral access

GCF 8 (Optional) Http, Https, Socket, UDP/Multicast, AccessPoint APIs

CLDC 8 Subset of Java SE 6/7/8 Language and Core APIs(lang, io, util, net, nio, security etc.)

Java ME Optional Package JSRs

JSR x

JSR y

JSR z…etc.


Agenda




• Java ME 9


Java ME 9

• ME / SE architectural alignment

– Introduce SE8 Modularity to mobile/embedded

• Upper stack separated from the Core VM

– Relevant Mobile and Embedded APIs can run or ME or SE

– ME vs. SE becomes a footprint/functionality tradeoff.

• New APIs for small embedded devices

• Mobile support from SE development and management tools

Directions


Java ME 9 Use Case

• Identify use cases for Location across Java Platform

– On embedded devices, on desktop, servers, etc.

• Explore update to JSR 179/293 or a new JSR to support Java SE

– Spec, RI for SE, TCK support

• Potential updates for:

– Location provider for getting location based on IP address lookup

– Add an API for accelerometer so only one API is needed for navigation

using compass and accelerometer

– Modularize the API to fit with Java SE 9 module system

Turning Location APIs into a platform agnostic JSR


Summary

• New platform definition

– based on needs of the small embedded device market and its

services environments

• Initiates Java ME-SE API alignment

– A unified ecosystem view and expanded opportunities for Java

SE and Java ME developers and device OEMs

• Commitment to a sustained, standards driven

modernization of the Java ME Platform

– Leveraging the existing Java ME ecosystem and expertise

Java ME 8 Platform Release


Q&A


Date post:	26-Sep-2020
Category:	Documents
Upload:	others
View:	1 times
Download:	0 times

The Java ME 8 Platform - Oracle … · 1 | © 2012 Oracle Corporation –Proprietary and...

Documents