Java Micro Edition (ME) 8 Deep Dive

Java Micro Edition (ME) 8
Deep Dive
Mar 28, 2014
Terrence Barr
Senior Technologist & Principal Product Manager
Java Embedded and Internet of Things
Oracle

Safe Harbor Statement
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
§  The Rise of the Internet of Things
§  Java ME 8: Background and Overview
§  Java ME Connected Limited Device Configuration (CLDC) 8
§  Java ME Embedded Profile (MEEP) 8
§  Java ME 8 Security
§  Device I/O API (DIO)
§  Oracle Java ME Embedded 8 Product Information
§  Conclusion & Resources
Note:
Java ME 8 is not final yet and information presented here is subject to change.

The Rise of the
Internet of Things

x86 Architecture/
Windows OS
Standards Based
Hardware & Software
Proprietary Hardware
& Software
1960 - 1985
Host Era
2006 - 2025
Internet of Things
1985-2006
PC Era
The 3rd IT Revolution

IoT
Everything
Huge
Scale
Fragmentation
Access
Privacy
Security
Cost
Time-to-
Market
Communication
Interoperability
Resources
Lifecycle
Reliability
Power
Management
Data Flow
Analytics
TouchesChallenges

HealthcareIndustrial
Automation
Home
Automation
Smart
Utilities
Automotive
Telematics
Java Embedded Enables New IoT Services

The Path to New Services
Always-on
connected to
variety of sensors
and running
multiple software
applications
Generates
high-frequency
Fast Data analysis
for instant decision
making and
automation of
information flows
Enables customer
service
differentiation from
automated, real-
time
responsiveness
ResponsivenessBig DataIntelligent Devices
Fueling New Services

Need for a Horizontal Services Platform
Stop reinventing the plumbing!
Your Value-Add
Shift from
proprietary point
solutions
to
horizontal platforms
and
infrastructure

The Full Picture: IoT is End-to-End
Data & Control Flow, Security, Management, Integration
Event
Processing
Data
Management
Big Data
Analytics
Integration
Spatial/GIS
CRM
Service
Billing
Industry
Solutions
Intelligent System Application
Portal
UI
Sensing Device
Concentrator or
Gateway
Network Cloud
Intelligent Systems
Foundation
Supporting
Applications
Other Data Generating
Sources such as Social
Media
Fixed Internet
2G, 3G, LTE, Satellite
NFC, Bluetooth, Zigbee,
WLAN, DASH7
Fixed
Internet
Internet
Gateway
Network
Abstraction
Protocol
Gateway
Service
Bus
Data Sync, Control, Feedback and Updates
Data Encryption, Device and Application Identity and Access Management
Base Stations
Switches
Management
Billing
Provisioning
Scalable
Resilient
Secure
Standards Based
Managed
Integrated
Value-Add
Services
External
Systems
Industry Specific
core solutions and
external/customer
systems
Any Device from
Cameras, Smart
Cards, Medical
Equipment,
Consumer Goods,
Vehicles, Containers,
Buildings.

Oracle’s Internet of Things Platform
ENGINEERED SYSTEMS,
SERVERS & STORAGE
EVENT
PROCESSING
JAVA
EMBEDDED
SUITE
INDUSTRY
APPLICATIONS
PARTNER INDUSTRY
APPLICATIONS
BUSINESS
APPLICATIONS

Why Java for IoT?
Software Updatability
& Extended Lifecycle
Large Ecosystem &
Pool of Resources
Reduced Time-to-
Market, Reduced Risk
Software Portability &
Increased Reach
Robust & Proven
Technology
Standards-based,
Trusted Vendor
Faster Innovation &
Competitive Advantage
End-to-end
Development Platform
Ease of Reuse and
Back-End Integration

Drivers behind Java ME 8
Requirement Description
Modern embedded
software platform
•  Robust, secure, cross-platform software execution environment
•  Modular software system and remote operation extends product
value and reduced cost/risk
•  Leverage feature-rich platform and focus on your value-add
Efficient software
development and
deployment model
•  Address the challenges of traditional embedded development
•  Accelerate time-to-market
•  Enable software portability and economies of scale
•  Leverage large ecosystem of expertise and partners
Increased market reach •  Platform “right-sizing” allows to address wide range of use cases
and target markets with a single software model, from low-
footprint devices to more powerful systems
Open, based on
standards, interoperable
•  Avoid vendor lock-in
•  Participate in and benefit from technology innovation
•  Integratable with many industry standards
Meeting the Challenges of the Internet of Things

Java ME 8:
Background and Overview

Unifying the Java Ecosystem for Embedded
•  Java ME 8 is the “little sibling” of Java SE 8
•  Portability of applications and libraries across the Java Platform
•  Java ME vs. Java SE is a footprint/functionality tradeoff
•  Java ME & Java SE release cycles are in sync
Key
Principles
•  Modern and flexible platform for delivering embedded software
•  Unified development experience & community across Java
•  Aligned Java language, core APIs, development, and tools
•  Enable 9+ Million Java developers to develop for Java Embedded
Benefits
Enabling Java Developers to be Embedded Developers

Java ME 8: Key Themes and Features
•  Unifying Java Embedded ecosystem & unleashing innovation
•  Dedicated and optimized embedded software platform
•  Enable increased range of use cases and markets
Themes
Key
Features
•  Modern, flexible, standards-based software platform
•  Value-add new & enhanced features for embedded and wireless
•  Improved configurability and optimized footprint
•  Target devices as low as at 128 KB RAM, 1 MB Flash/ROM (see note)
Target
Markets
•  Small to mid-embedded covering wide range of use cases/markets
•  Intelligent edge devices, communication nodes, healthcare
devices, smart sensors, smart meters, general IoT/M2M solutions
Next-Generation Software Platform for the Internet of Things
Note: MEEP 8 Minimal Profile Set, optimized for single-function devices. Actual footprint will
vary based on target device and use case.

Quick Compare: Java ME 8 vs. CLDC 1.1
Feature Java ME 8 Java ME CLDC 1.1
Supported Standards CLDC 8 and MEEP 8 CLDC 1.1
(+ MIDP 2/IMP-NG)
Year of release 2014 2003
Java SE 8 alignment (language, APIs, VM) yes no
Service-enabled application platform yes no
Concurrent application execution yes no
Enhanced software provisioning and management yes no
Software modularization and re-use yes no
Scalable platform yes no
Dedicated embedded design yes no
Advanced security model and security services yes no
Advanced connectivity yes No

Java ME 8 Focus
Platform
Footprint
Device
CPU/
GPU/I-O
50KB-1MB
1MB-10MB
10MB-100MB Java ME
Java SE
Java
Card
ARM 7 - Cortex M - ARM9/11 - Cortex A - MIPS32 - PPC - Intel Atom

Java ME 8 Platform Overview
Java VM
Additional
APIs
(Examples)
Java ME Connected Limited Device Configuration (CLDC) 8 (JSR 360)
Additional
Optional APIs
On-Device I/O
Access
Vertical Specific
APIs
Location
Messaging
Wireless
Communication
Web Services
Protocols and
Data Conversion
Sensors
Additional
Optional JSRs
Security and
Management
Use Case Software
(e.g. smart pen)
Use Case Software
(e.g. wireless module)
Use Case Software
(e.g. control unit)
Use Case Software
(e.g. smart meter)
Application Platform
Java ME Embedded Profile
(MEEP) 8 (JSR 361)
On-Device I/O
Access
Device I/O
API
SATSA
(JSR 177)
Security and Trust
Services
Generic Connection
Framework
GCF 8

Java ME 8: Top 10 Features
§  Alignment with Java SE platform
§  Designed for Embedded
§  Highly Portable and Scalable
§  Consistent Across Devices
§  Advanced Application Platform
§  Modularized Software Services
§  Multiple Client Domains (Device Partitioning)
§  Access to Peripheral Devices
§  Compatible to existing standard APIs
§  Dedicated Embedded Tooling

1: Aligned with Java SE 8
§  Java ME 8 is a major step towards alignment with Java SE 8
–  Adds SE 8 language, libraries, and virtual machine features
–  Enables portability of code across the Java Platform,
from small to large
–  Unifying the development model: Enables 9 million Java
developers to target embedded space
§  Java ME 8 remains
–  Backward compatible to previous Java ME versions
–  Focused on resource-constrained devices

2: Designed for Embedded
§  Java ME 8 is purpose-built for connected
embedded solutions
–  Fully headless operation
–  Robust and secure application execution
–  Application monitoring and recovery
–  Remote software provisioning and
management
–  Versatile advanced connectivity, including popular
protocols and latest security standards such as TLS 1.2
–  Power management framework

3: Highly Portable and Scalable
Platform
Footprint
Device
CPU/
GPU/I-O
50KB-1MB
1MB-10MB
10MB-100MB Java ME
Java SE
Java
Card
ARM 7 - Cortex M - ARM9/11 - Cortex A - MIPS32 - PPC - Intel Atom

4: Consistent Across Devices
§  Java ME 8 brings consistency to embedded platforms
–  Decouples applications from underlying fragmented
embedded hardware and software
–  Consistent Java APIs and functionality across devices
§  Enables creating embedded solutions efficiently
–  Create portable Java applications that scale across a
variety of devices with minimal effort
–  Replace or update target devices without rewriting
–  Instead of fighting complexity, focus on your business
value and reduce cost and time to market

5: Advanced Application Platform
§  Java ME 8 Multi-Application Model
–  Robust concurrent execution of
multiple applications
§  Enhanced Software Provisioning
–  Secure remote software provisioning and management,
including full application lifecycle control
§  Addresses requirements for many new embedded use cases
–  Enables remotely manageable and flexible software solutions
–  Reliable in-field software updates to deliver improvements, new
features, or to extend product life

6: Modularized Software Services
§  Multi-Application Model enables software modularization
–  Application logic can be partitioned into functional
modules running as individual services
–  Services collaborate to provide complete solution
–  Services can be developed, deployed, and
managed independently
§  Enables faster, more flexible software development and deployment
–  Increases agility in developing new functionality or updates
–  Allows generalization and reuse of services
–  Reduces footprint, deployment overhead, and time-to-market

7: Multiple Client Domains (“Partitioning”)
§  Java ME 8 supports multiple Client Domains on device
(“Multi-Tenancy”)
–  Example clients: ODM, service provider,
system integrator, software developer
–  Each client has its own security domain
(policy, privileges, parameters)
–  All software executes in the domain of
its client with strict enforcement of
security privileges and limitations
§  Enables secure sharing of a device by different clients
as part of an embedded value chain

8: Access to Peripheral Devices
§  Device I/O API
–  Platform-neutral access to peripheral device hardware
directly from Java, no native coding involved
–  Allows easy support of use-case specific
peripherals, such as sensors, actuators,
converters, etc
–  Extensible for specialized devices
–  Supports a range of common I/O
§  GPIO, I2C, SPI, ADC, DAC, UART, AT Commands,
Pulse counter, PWM, memory-mapped I/O, and more
§  Also planned for Java SE

9: Compatible with Standard APIs
§  Java ME 8 is designed to be compatible with established standards
and APIs such as
–  JSR 75 (File API)
–  JSR 120 (Wireless Messaging API)
–  JSR 172 (Web Services API)
–  JSR 177 (Security and Trust Services API)
–  JSR 179 (Location API)
–  JSR 280 (XML API)
–  and more …

10: Enhanced Embedded Tooling
§ Java ME 8 SDK
–  Tools and emulation for rapid development
of embedded Java ME applications
–  Includes device emulator, application
management interface, memory monitor,
network monitor, and more
–  Live code deployment and debugging on
devices
§ NetBeans Plug-ins
–  Integration with Java ME SDK
–  Full-featured, integrated development
environment for embedded
Free
Tools

General IoT and Machine-to-Machine (M2M) solutions
Smart Meters & Smart Sensors
Medical: eHealth & TeleHealth
Wireless Modules, Gateways, Connected Car
Industrial Control, Telemetry
Java ME 8 Example Use Cases
Enabling products and services across different market segments

§  Modular & flexible
§  Complete development and prototyping
platform built around QSC6270T SoC
§  CPU, RAM/Flash, I/O, GPS, 3G, WiFi
§  Extensible through pluggable modules
§  Universal IoE/M2M platform
§  Quickly and easily start building advanced
IoE concepts with Java
§  Leverage Qualcomm and AT&T “Internet
of Everything” developer program
Qualcomm IoE Development Platform
Java ME 8: 2nd Generation Java ME for Qualcomm IoE

§  Smart & small
§  Leverage existing compute resources
§  Small, connected, low power
§  Full Java application platform
§  Remote software provisioning and
management
§  Add intelligence and connectivity to
vertical solutions
§  Industrial automation, healthcare,
security & monitoring, and more
Cinterion Wireless Modules
Java ME 8: Coming to Gemalto Next-Generation M2M Product Range

l  Raspberry Pi (Model B)
l  Broadcom BCM2835 (ARM1176JZF) SOC
l  700 MHz, 512 MB RAM, Linux (Debian)
l  ~1 million devices sold, US $35
l  Peripherals supported
l  Headless (no graphics)
l  Network (Ethernet TCP/IP), SD card (file)
l  Serial/UART
l  Devices attached via I2C, SPI, and GPIO
l  Brings Java ME Embedded features to Raspberry Pi
Raspberry Pi
Popular, low-cost board for development and educational use
GPIO, UART, I2C, SPI

Connected Microcontrollers
A perfect use case for Java ME Embedded
§  Microcontrollers are becoming more powerful and
better connected
-  On-chip memory is expanding to meet the needs of
Java ME Embedded
-  Enables cost effective, single-chip solutions with Java
§  Brings the benefits of Java to the microcontroller
space
-  Platform-independence, efficient software
development, ability for in-field software updates,
secure and robust software execution

Java ME
Connected Limited Device
Configuration (CLDC) 8
And
Generic Connection
Framework (GCF) 8

Java SE 8

•  Description
-  CLDC 8 is an long-anticipated, evolutionary update for CLDC 1.1.1 to bring
the VM, Java language and core API libraries in alignment with Java SE 8
•  Key Features
-  Synchronize Java SE 8 language features into Java ME
-  CLDC 8 is an extended strict subset of Java SE 8
-  Introduce developer-friendly Java SE APIs
-  Includes updated Generic Connection Framework (GCF) 8
-  Virtual Machine update to align with Java SE developer tools
-  Remain small and enable footprint optimizations
-  Backward binary compatible
CLDC 8 High-Level Overview
CLDC 8
Bringing The World of Java SE to Java ME

CLDC 8 architecture
CLDC 8
NIO files
NIO channels
Logging
Compact Configuration
NIO buffers java.lang java.io java.security java.util
GCF 8
Multicast
Secure
Datagram
Modem
Connection HTTP HTTPS Socket
Server
Socket
Datagram
Java VM

Configurations
The “CLDC
Configuration” is the
complete set of
CLDC APIs
Provides
maximum
functionality for
applications
Typical CLDC
platform footprint
is 1-2 MB ROM
The CLDC Compact
Configuration
defines a subset for
very small target
platforms
Omits Logging,
NIO Files, and
NIO Channels
Tailored for very
constrained
devices (512 K
ROM)
CLDC is scalable to small and very small devices

New Java Language Features
• private void setInterval(int interval) {
assert interval > 0 && interval <= 1000 :
"Invalid value?”;
}
Assertions
•  Added support for AbstractCollection, AbstractList, AbstractSet,
Collection, Collections, Enumeration, Iterator, List, ListIteratorGenerics
• void processList(Vector<String> list) {
for (String item : list) {
...
}
Enhanced for
Loop
• Hashtable<Integer, String> data = new Hashtable<>();
void add(int id, String value) {
data.put(id, value);
}
Autoboxing

• enum Season {WINTER, SPRING, SUMMER, FALL};
private Season season;
void setSeason(Season newSeason) {
season = newSeason;
Enumerations
• void warning(String format, String... parameters) {
for(String p : parameters) {
process(p);
}
}
Varargs
• import static data.Constants.RATIO;
...
double r = Math.cos(RATIO * theta);
Static imports
• SuppressWarnings, Deprecated, Override

@Deprecated
public void clear();
• (JLS 7 section 9.6.3.2 @Retention - SOURCE retentions policy only.)

Annotations

• switch (arg) {
case "-data": ...
case "-out": ...
Strings in switches
• long mask = 0xfff0_ff08_4fff_0fffl;
byte flags = 0b01001111;
Binary integral literals and
underscores in numeric literals
• catch (IOException | InterruptedException ex) {
logger.log(ex);
throw ex;
Multi-catch and more precise
rethrow
• Hashtable<String, String> map =
new Hashtable<>();
Improved Type Inference for Gen.
Instance Creation (diamond)
• try (DataInputStream is = new DataInputStream(...)){
return is.readDouble();
}
Try-with-resources statement

Library Updates
§  CLDC Library
–  Platform extensibility via Service Providers (ServiceLoader)
–  EventObject and EventListener
–  Subset of NIO Buffers
–  NIO Files and NIO Channels
–  Logging
–  StringBuilder and String Formatter
–  Comparable interface
–  Try with resources – Closeable and AutoCloseable

Library Updates
§  New Collections
–  List – ArrayList, LinkedList
–  Map – HashMap, LinkedHashMap, WeakHashMap
–  Set – HashSet, LinkedHashSet
–  Queue – Deque, ArrayDeque
–  Iterable and Iterator, ListIterator

Focus on: Service Providers
§  A service is a well-known set of interfaces and abstract classes
that is implemented by a (service) provider.
§  Providers can be installed to extend the Java platform.
§  Providers are located and instantiated on demand.
§  Providers are identified via a provider-configuration file in the
META-INF/services resource directory.
An extension mechanism for the Java platform

Service Providers - Example
import
com.XYZ.ServiceA;

ServiceLoader<ServiceA>
sl1=

ServiceLoader.load(ServiceA.class);

An extension mechanism for the Java platform
ServiceB
ServiceB
Provider1
ServiceB
Provider2
com.XYZ.ServiceA
ServiceA
Provider1
ServiceA
Provider3
ServiceA
Provider3
Resources:
META-INF/services/com.XYZ.ServiceA:
META-INF/services/ServiceB:
ServiceAProvider1
ServiceAProvider2
ServiceAProvider3
ServiceBProvider1
ServiceBProvider2

Updates to CLDC Virtual Machine
•  Target devices are not able to support InvokeDynamic
•  No support for reflection or retention of runtime annotations
CLDC 8 supports the Java VM Specification for SE 7 with some
limitations
•  For classfile versions 51 and 52
•  without a preverifier
Verification by Type Checking
•  For classfile versions 48 and older
Legacy Verification (Preverifier)

Unsupported Java SE 8 Features
§  Features not essential for small embedded use cases – keeping the VM
complexity and footprint low
–  No reflection
–  No serialization
–  No InvokeDynamic/Lambda expressions
–  No JNI and application native code
–  No User-defined class loaders
–  No runtime annotations
–  No thread groups and daemon threads
–  No concurrency utilities
–  Limited Math APIs (No BigDecimals)
–  Limited security APIs
–  Limited collection APIs (No sorted collection classes)

CLDC Summary
Language Alignment with SE 8
VM Alignment with SE 8
Library Alignment with SE 8
Compact Configuration for very small devices
GCF 8 to provides flexible networking
Developer leverage to tools, APIs and knowledge

Generic Connection Framework (GCF)
•  Consistent IPv6 support
•  Generic ConnectionOption mechanism to parameterize connections
•  Permissions apply per protocol
•  Extended failure information via exceptions from java.net
Consolidates GCF specification from CLDC, MIDP, CDC, and JSR 197
•  File support via StreamConnection
•  IP Multicast
•  Latest version of security protocols via TLS 1.2
•  Secure datagram connection via DTLS 1.2
•  Modem connection enhances CommConnection with control of hardware handshake
New and enhanced protocols

Generic Connection Framework (GCF)
CLDC
DatagramConnection
ContentConnection
InputConnection
OutputConnection
StreamConnection
CLDC 8
SecureServerConnection
SecureDatagramConnection
ModemConnection
UDPMulticastConnection
CommConnection
HttpConnection
HttpsConnection
SecureConnection
ServerSocketConnection
SocketConnection
UDPDatagramConnection

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 ('[', ']’).
•  datagram://[2001:db8::7]:4567
•  multicast://[FF0X::101]:4444
IPv6

New GCF Features
•  GCF includes support for UDP Multicast
•  1 to n communication of UDP datagrams
•  Multicast is important for distributed services:
Used for service announcement and discovery, media streaming
•  Dynamic Discovery for configuration and rendezvous (mDNS,
Bonjour)
•  The new protocol class UDPMulticastConnection enables
•  Client and server scenarios
•  Joining multicast groups
•  Creating a multicast server socket
UDP Multicast

New GCF Features
•  SecureConnection and SecureServerConnection
support TLS 1.2
•  SecureServerConnection provides the server-side of a TLS
connection
•  Both can be parameterized to:
•  Select a set of cipher suites
•  Select a minimum protocol version
•  Request client authentication
TLS protocol enhancements

New GCF Features
•  SecureDatagramConnection provides client-side support
for DTLS
•  It can be parameterized to:
•  Select a set of cipher suites
•  Select a minimum protocol version
•  Request client authentication
DTLS protocol support for TLS over UDP

New GCF Features
•  Utility functions for name lookup, reverse name lookup
and for testing the reachability of a host (ping):
• getCanonicalHostName(String host)
• isReachable(String host, int ttl, int timeout)
• getByName(String host)
NetworkUtilities

New GCF Features
•  Purpose: monitor and control the signal lines of a serial
interface
•  Getter and setter for the line mode (input/output)
•  Getter and setter for the line state
•  Listener for changes to the state of an input line
Modem Connection

New GCF Features
•  Type-safe mechanism for protocol-specific additional parameters
•  Useful for selecting access points, proxy settings, proprietary protocol
extensions
•  Multiple connection options can be used with varargs
ConnectionOptions
• ConnectionOption <String> keep = new ConnectionOption<>
("KeepAlive", "KEEP_ALIVE");
ConnectionOption <Integer> port = new
ConnectionOption<>("ProxyPort", 80);
Connection c = Connector.open(“my.server.com”, keep, port)
Example
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, Wi-Fi, Wired)
–  Getting Access-point technology-specific properties (e.g. 3GPP country
code, network code)
–  Selection of an access point for a connection
–  Receive connect/disconnect events
–  Selection of roaming/non-roaming
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
((eventType
==
AccessPointListener.EVENT_TYPE_AVAILABLE))

System.out.println(“signalstrength
=
”+
ap.getProperty(“signalstrength"));

}

});

//
select
the
first
access
point
for
communication

ConnectionOption<String>
id
=
new
ConnectionOption<>("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
§  Embedded-specific hints & warning messages
–  Provides developer with additional information to optimize code
§  Debug structures are optional
–  Debug features can be ignored/filtered out to save footprint
§  Future tools under consideration may include
–  Optimizing converter/compiler plugin for optimizing CLDC 8 applications
§  Integrated with Java ME SDK and IDEs

Java ME Embedded Profile
(MEEP) 8

MEEP 8 High-Level Overview
§ Description
–  MEEP is an evolution of JSR 228 (IMP-NG), defining a modernized Java
application platform with features and enhancements targeted at the
small- and mid-range embedded market
§ Key Features
–  Builds on CLDC 8
–  Robust and flexible multi-tasking/concurrent application model
–  “Services-enabled” application platform supports modular software
design, deployment, and management
–  Enhanced and flexible security model
–  Improved configurability and optimized footprint for deployment
The Evolution of Java ME for Embedded

MEEP 8 Key Features and Benefits
A Modern Services-Enabled Software Platform for Embedded
Feature Benefit
Built on CLDC 8 Leverages CLDC 8 language features, APIs, and
permissions model to align with Java SE 8
API Optionality and
“Profile Sets”
Enables “right-sizing” of platform to optimize footprint and
reduce hardware requirements for specific target device
Software Provisioning and
Management
Supports remote deployment, management, and monitoring
of software components
Support for Software
Modularization
Enables modular software development and deployment,
reducing development effort, complexity, and footprint
Support for advanced
connectivity
Supports a wide range of connectivity options, both wired
and wireless, including advanced support for cellular
Enhanced security model Enables implementation of use case-specific security
policies for authentication and authorization

MEEP 8 Target Devices and Footprint
§ MEEP 8 is designed for “Right-Sizing”
–  Well-defined optionality and modularity allows matching software features
to deployment target footprint
–  Greatly expands the range of addressable use cases and devices
§ Target Device Categories
–  Minimal Single-Function Device: Smallest possible footprint
–  Standard Multi-Function Device: Expands with functional requirements
–  Full Multi-Function Device: Full functionality, footprint not a concern
Adressing New Market Opportunities

MEEP 8: Right-Sizing The Platform
MEEP 8 Full
Profile Set
MEEP 8 Minimal Profile Set
•  Mandatory core APIs, application model,
application packaging
Target Devices/Use Cases
•  Very small devices (low cost/power/size)
•  Single-function use cases (e.g. smart
sensor)
Minimum:
•  128 kB RAM
•  1 MB Flash
Recommended:
•  256 kB RAM
•  2 MB Flash
(see notes 1, 2)
MEEP 8 Standard Profile Set
•  Adds support for software services platform
(multi-tasking, application mgmt, shared libs,
events, enhanced security model, etc)
•  Optional Packages as per use case
•  Mid-range MCU/low-end embedded systems
•  Wide range of use cases (e.g. wireless
module, industrial control system, remote
monitoring device, smart network note, etc)
Minimum:
•  512 kB RAM
•  2 MB Flash
Recommended:
•  1 MB RAM
•  3 MB Flash
(see note 1)
MEEP 8 Full Profile Set
•  All ME 8 functionality and Optional Packages
•  High-end MCU or mid-range embedded
systems
•  Use cases requiring full software functionality,
footprint not a concern
Minimum:
•  2 MB RAM
•  4 MB Flash
(see note 1)
CLDC 8
Optional
Package
Optional
Package
Optional
Package
Application(s)
MEEP 8 Standard
Profile Set
MEEP 8 Minimal
Profile Set
Optional
JRSs
Optional
APIs
Notes:
1) Actual
footprint will
vary based
on target
device and
use case.
2) MEEP 8
Minimal
Profile Set,
optimized for
single-
function
devices.

Application or Service
MEEP 8
MEEP 8 Architecture
CLDC
8

javax.
microedition.
midlet
New in MEEP 8
Updated in MEEP 8
javax.
microedition.
io
(optional)
javax.
microedition.
event
(optional)
javax.
microedition.
key
(optional)
javax.
microedition.
lui
(optional)
javax.
microedition.
media
(optional)
javax.
microedition.
power
(optional)
javax.
microedition.
rms
(optional)
javax.
microedition.
swm
(optional)
javax.
microedition.
cellular
(optional)

Package Description
javax.microedition.midlet The Application and the environment in which the application runs.
javax.microedition.swm [OPTIONAL] Provides extended software management features to MEEP.
javax.microedition.cellular [OPTIONAL] Provides classes to obtain information about cellular networks the
device is registered on.
javax.microedition.event [OPTIONAL] Events for system state changes and application to application
communication.
javax.microedition.power [OPTIONAL] Power management.
javax.microedition.io [OPTIONAL] Networking support based on the Generic Connection Framework
Specification.
javax.microedition.lui [OPTIONAL] Set of features to implement Line-oriented User Interface.
javax.microedition.key [OPTIONAL] Support of embedded device key input.
javax.microedition.media [OPTIONAL] Features for Audio support on embedded Devices.
javax.microedition.rms [OPTIONAL] Mechanism for applications to persistently store data and later retrieve it
MEEP 8 API Packages

MEEP 8 Application Platform
A modern platform to build flexible, modular, and manageable software
Component/concept Description
Software provisioning Provision of applications and libraries, and
management of dependencies
Software management Control lifecycle of software components
Application concurrency (MVM) Concurrent execution of multiple apps, in isolation
Inter-application communication (IMC) Exchange data between applications (synchronous)
Events Send/receive events across system (asynchronous)
Service Provider/Consumer pattern Enable shared services and service consumers
Shared Libraries (LIBlets) Share common code across applications

MEEP 8 Modularized Software Services
§ Multi-Application Model enables software modularization
–  Application logic can be partitioned into functional
modules running as individual services
–  Services collaborate to provide complete solution
–  Services can be developed, deployed, and
managed independently
§ Enables faster, more flexible development and deployment
–  Increases agility in developing new functionality or updates
–  Allows generalization and reuse of services
–  Reduces footprint, deployment overhead, and time-to-market
Flexible Software Design and Re-Use

MEEP 8 Software Provisioning & Management
Installation Mgmt
install/update/remove &
resolve dependencies
Lifecycle Mgmt
start/stop/terminate &
prioritize
Provisioning
download, authenticate,
verify
Security Policy Provider
security policy &
permissionsStorage
App-1
App
Mgmt
Agent
Application Management System (AMS)
Authentication Provider
authenticate
App-2
Java Runtime
Uses API
2. Download
3. Authenticate (2)
4. Install
6. Access
7. Provide
8. Control
9. Secure
5. Store
Application
Package
Deployment Infrastructure
•  Identity
•  Provisioning
•  Security Policy
•  Management
1. Implement protocol
App Management Agent:
•  Privileged application
•  Implements deployment-
specific protocol
•  Manages local
applications via AMS API
3. Authenticate (1)
Client Device

Shareable Software Components
§  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
§  Different implementations of the same API can be can be accessed via
the Service Provider/Consumer pattern
Shared Libraries (LIBlets)

Service Provider/Consumer Pattern
§  Service is a well known set of interfaces/abstract classes;
Service Provider is an implementation of the service
§  Enables consumers to use services by one or more providers
§  Features of the Application Platform Framework
–  Ability of apps, shared libraries, or runtime to declare it provides a service (provider)
–  Ability of apps or shared libraries declare a dependency on a service (consumer)
–  Ability of the AMS to bind a consumer to a provider, and rebind on updates
–  Service provider executed in context of consumer (client application)
§  Benefits
–  Modular software design, increased reuse, easier updating, reduced
testing, reduced footprint
Based on Java SE ServiceLoader API

MIDletSuite1
MIDletSuite2
How does it work?
Simple example, Service Provider and Consumer are two different apps
MIDlet 2
LIBlet 2
MIDlet 1

How does it work? (cont)
MIDletSuite1
MIDletSuite2
MIDlet 2
LIBlet 2
MIDlet 1
LIBlet2.jar/META-INF/services/com.example.CodecSet
LIBlet2.jar/META-INF/MANIFESTMIDletSuite1.jad
LIBlet-Services: com.example.CodecSet
…
MIDlet-Dependency-1: service; required; com.example.CodecSet
…
com.example.impl.StandardCodecs # Standard codecs

How does it work? (cont)
MIDletSuite1
MIDletSuite2
class StandardCodecs
class MIDlet1
MIDlet 2
LIBlet 2
MIDlet 1
public class StadardCodecs implements CodecSet {
public StadardCodecs() { … }
public Encoder getEncoder(String encodingName) {
return new EncoderImpl(…);
}
}
private static ServiceLoader<CodecSet> codecSetLoader
= ServiceLoader.load(CodecSet.class);
public static Encoder getEncoder(String encodingName) {
for (CodecSet cp : codecSetLoader) {
Encoder enc = cp.getEncoder(encodingName);
if (enc != null)
return enc;
}
return null;
}
Interface CodecSet
public interface CodecSet {
public Encoder getEncoder(String encodingName);
public Decoder getDecoder(String encodingName);
}

Java ME 8 Security

Java ME 8 Security Overview
§ Trust Model
–  Authentication of client security domains and all associated software
components
§ Runtime Security
–  Sandboxed execution in a controlled environment with secure code
loading, verification, and strong data typing
–  Code authorization model enforces fine-grain permissions control for
access to resources and data
§ Security Services
–  Advanced Cryptography and Public Key Infrastructure (PKI)
–  Latest secure communication standards (TLS 1.2)
Comprehensive platform security

Java Runtime Execution Security
Example: File Access
§  All code execution is under direct
control of Virtual Machine
§  Access to resources and
functionality must be explicitly
allowed
§  Permissions are checked at
every access
§  All accidental or malicious
access at any point is denied by
Java runtime
Fine-grain Java SE Security Model and Permissions

Multiple Client Security Domains (“Partitioning”)
§ Java ME 8 supports multiple Client Security Domains
on device (“Multi-Tenancy”)
–  Example clients: ODM, service provider,
system integrator, software developer
–  Each client has its own security domain
(policy, privileges, parameters)
–  All software executes in the domain of
its client with strict enforcement of
security privileges and limitations
§ Enables secure sharing of a device by different clients
as part of an embedded solution
Enabling the embedded software value chain

Multiple Client Security Domains: Example
CPU
Designer
Solution
Partner
Service
Provider
System on
Chip Vendor
(SOC)
OEM/ODM Enterprise
Enabling a secure and robust software value chain
§  Each client can have their specific security domain and context, based on
the deployment needs (e.g. permissions, credentials, settings)
§  Clients and associated software co-exist on the device, but are strictly
separated
§  Software components collaborate through well-defined mechanisms to
provide entire solution
Device

Device I/O API (DIO)

Access to Peripheral Devices
§  Device I/O API
–  Platform-neutral access to peripheral device hardware
directly from Java, no native coding involved
–  Allows easy support of use-case specific
peripherals, such as sensors, actuators,
converters, etc
–  Extensible for specialized devices
–  Supports a range of common I/O
§  GPIO, I2C, SPI, ADC, DAC, UART, AT Commands,
Pulse counter, PWM, memory-mapped I/O, and more
–  Also planned for Java SE
Extensible I/O directly from Java applications

Device I/O API Features in ME 8
Peripheral Type Description
Peripheral abstraction interface All access to peripherals via PeripheralManager (late binding)
General Purpose Input/Output (GPIO) Access to buttons, switches, LEDs, etc.
Inter-Integrated Circuit Bus (I2C) Access to I2C slaves (sensors, RTC, DAC/ADC, NVRAM, …)
Serial Peripheral Interface Bus (SPI) Access to SPI slaves (audio devices, LCD screens, EEPROM/Flash, …)
Analog/Digital conversion Access to ADC and DAC channels
Universal Asynchronous Receiver/
Transmitter (UART)
Access to UART serial communication and control
Memory-Mapped Input/Output Access to devices with memory-mapped registers and memory blocks
AT Command Interface Access to modems and devices supporting AT commands
Watchdog Watchdog functionality to ensure reliable operation
Pulse counter Access to pulse counter functionality
Pulse Width Modulation (PWM) Access to pulse width modulation output

Oracle Java ME Embedded 8
Product Information

Embedded Application(s)
Virtual Machine
Optional JSR
System
Controller
Communication
Management
Device
Management
Tooling
Agent
Software
Provisioning
Identity
Management
Messaging
Monitoring &
Logging
Data Store &
Sync
Web Server
Other Services/
Protocols
Graphics/UI
Optional JSR
Oracle Java ME 8 Product Strategy
An extensible, customizable embedded software platform
Oracle Java ME
Embedded
Product
Building Blocks (Oracle or
partners): Services and/or
Libraries (examples)
Oracle or
3rd Party JSRs
3rd Party
Enhancement
3rd Party
Enhancement
3rd Party
Enhancements
• Local Peripherals
• IoT Network
• Enterprise
Note:
Preliminary - Not all
components shown are
currently available
Local or
Network
Interfaces

Designed for Small Embedded
•  Complete Java runtime optimized for low-
footprint ARM architecture devices
•  Portable, extensible architecture to address
diverse embedded requirements
•  Dedicated embedded features and APIs
Latest Java ME platform
•  Best-in-class multitasking VM
•  APIs to support connectivity, encryption,
location, and web services
•  Based on proven, widely-deployed
technology
Flexible, long-life services
•  Extend system life via remote software
update preserving system integrity and
certification
•  Cross-platform, modular applications
•  Distributed processing through Java end to
end
Best-in-class tool chain
•  Java ME SDK tools and emulation
•  Netbeans IDE support
•  Live, Java-level debugging on device
Oracle Java ME Embedded
High-performance Java runtime for small embedded

Oracle Java ME Embedded 8 Stack
A rich, flexible, portable embedded software platform
Legend: Oracle Unique Features
3rd Party ComponentsHardware
(*) : Modifiable Components
CLDC 8 + Virtual Machine (JSR 360)
OEM Extension
APIs *
Porting Layer *
Additional platform port(s)Win32 Emulation port * Reference Board ports *
GPIOSPINetwork Serial
Advanced Tooling
& Debugging
File I2CGPS ...
System
Configuration
...
Device Operating System
Java ME SDK 8
Test, Emulate
NetBeans IDE
Develop, Deploy,
Debug
Porting
Integration
Specialization
Device I/O API
Web Services
JSR 172
File I/O
JSR 75
XML
JSR 280
Security & Trust
JSR 177 subset
Messaging
JSR 120
Location
JSR 179
Robust Multi-
tasking
Standardized Components
HTTP Client API
System Configuration
API
MEEP 8 (JSR 361)
Advanced
Security
Enhanced
Connectivity
Footprint
Scalability
JSON API
OAuth 2.0 API

Included JSRs & APIs
API Description
JSR 075 File I/O: Access to on-board file system(s) (SD card, etc)
JSR 120 Wireless Messaging 1.0: Send/receive SMS messages
JSR 172 Web Services: Basic XML processing, RPC, WSDL, SOAP
JSR 177 Security and Trust Services: Crypto
JSR 177 Security and Trust Services: APDU
JSR 179 Location: Access to location information
JSR 280 Enhanced XML processing, building on JSR 172
Device I/O Access to peripheral devices and hardware
JSON JSON processing
HTTP Client Advanced HTTP connections
OAuth 2.0 Industry-standard authentication protocol
System Configuration Read/write system configuration parameters
Rich API functionality for embedded solutions
Note: Not all JSRs are available on all platform (due to hardware limitations)

Dedicated Embedded Features
Feature Description
Software Managent (SWM) API Remote app management (install, start, update, etc.)
SWM lifecycle notifications Application monitoring (e.g. errors, termination)
Robust software execution Application execution in resource-managed containers
Application autostart/auto-restart Autostart or restart applications
Device I/O API Enhanced access to peripherals from Java apps
AccessPoint API / Cellular API Support for multiple communication channels
Memory Monitor Monitor memory usage during development
Network Monitor Monitor network traffic during development
Headless On-Device Debug (ODD) Full source-level Java debugging
VM Configurator Remote configuration of VM
OEM Extensibility Product specialization through extension mechanism
Build Configuration Options Configure feature/footprint optimization for target use case

Comparing Java ME Embedded 8 to 3.x
Java ME Embedded 8 Feature Benefit over Java ME Embedded 3.3/3.4
Java SE 8 alignment Unified development model - leverage Java SE 8 language, API, and
virtual machine features for more efficient and highly portable code
Java ME 8 features Leverage the features of the Java ME 8 standard:
•  Enhanced service-enabled application platform
•  Increased software modularization and re-use
•  Enhanced software provisioning and management
•  Platform footprint optimization with “Right-Sizing”
•  Enhanced and expanded security model
Updated security services Latest standards for secure connectivity and encryption, such as TLS
1.2 and ECC
Enhanced connectivity Advanced cellular connectivity and improved networking functionality
enables more flexible and intelligent connectivity
New value-add APIs RESTful web services and more
Improved platform portability,
scalability and configurability
Enables easier porting, configuration, and footprint tuning of platform
to address a wider range of devices and use cases
Improved tooling Alignment with Java SE development tools and flow and new and
improved tooling functionality for more efficient development

l  To Be Completed
Lower Costs with Oracle Java ME Embedded
Feature Cost Savings for Embedded System
Productive and secure application
platform
Reduced development time and deployment costs
Pre-integrated, pre-tested runtime Reduced integration and testing costs
Cross-platform software
Optimize hardware platform without software
dependencies
Built-in features to support embedded
use cases
Reduced need to license 3rd party components
Local processing and business logic Lower data transmission and processing costs
Reduce hardware BOM costs
Eliminate bulky operating systems and reduce
system requirements
Java ecosystem expertise, tools, code Leverage ecosystem for quicker time to market

ME 8 GA Release Platform Support
Platform Description Availability
Emulation runtime for
Windows 7
Complete product implementation for
development on Windows desktops
•  Java ME Embedded runtime emulation
•  including I/O emulation and tooling
•  Bundled with Java ME SDK 8
•  Free download from Oracle
Technology Network (OTN) for
evaluation
•  OJPI source (Windows)
ARM11 on Linux Complete, ready-to-run implementation for
Raspberry Pi (Model B) developer platform
on Linux Debian Wheezy
evaluation
•  Commercial binary
•  OJPI source (Linux/ARM)
ARM9 on Brew MP Complete, ready-to-run implementation for
Qualcomm IoE developer platform on
BrewMP
•  Including advanced wireless connectvity
evaluation
•  Commercial binary
•  OJPI source (BrewMP/ARM)

Additional Platform Support
Platform Description Availability
Additional standard platforms •  Oracle standard products for additional
platforms, such as ARM Cortex-M3/4
•  Stay tuned
Other platforms •  Other chip architectures
•  Other operating systems
•  Specialized features, hardware support,
etc.
•  Available from Oracle as
engineering services projects
•  Check with Oracle partners

Conclusion &
Resources

Conclusion
Aspect Benefit
Modern Embedded
Software Platform
•  Java SE alignment enables unified ecosystem for Java Embedded
expertise, reuse, and resources
•  Modular software system and enhanced manageability accelerates
time-to-market and extends product value at reduced cost/risk
•  Enhanced and more flexible security model allows deployment-
specific security infrastructure
Increased Market Reach •  Platform “right-sizing” allows to address wide range of use cases
and target markets with a single software model, from low-footprint
devices to more powerful systems
Open, based on
standards,
interoperable
•  Avoid vendor lock-in
•  Participate in and benefit from technology innovation
•  Integratable with many industry standards
Java ME 8: The Platform for the Internet of Things

Java ME 8: Learn More
•  Download Java ME 8 Early Access
-  oracle.com/technetwork/java/embedded/overview/javame/index.html
•  Documentation for Java ME 8
–  http://docs.oracle.com/javame/embedded/embedded.html
(see top of page for ME 8 content)
•  Java 8 Central:
-  www.oracle.com/java8
•  Follow me
-  Blog: terrencebarr.wordpress.com
-  Twitter: @terrencebarr
Youtube.com/java
blogs.oracle.com.c
om/java
Facebook.com/
ilovejava
@java
@javaembedded
Nighthacking.com

Safe Harbor Statement
The preceding 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.

Java Micro Edition (ME) 8 Deep Dive

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Java Micro Edition (ME) 8 Deep Dive

Similar a Java Micro Edition (ME) 8 Deep Dive (20)

Último

Último (20)

Java Micro Edition (ME) 8 Deep Dive