<!-- 
	This document is provided as a template along with some guidance for creating
	your project proposal. This is just a template. Feel free to change it as
	you see fit (add sections, remove section). We feel, however, that the
	suggestions represented in this document represent the reasonable minimum
	amount of information to move forward.
	
	Please keep the formatting in this document simple. Please do not edit 
	this document in Microsoft Word as it adds huge piles of markup that make
	it difficult to restyle.
	
	More information is available here:
	
	http://wiki.eclipse.org/Development_Resources/HOWTO/Pre-Proposal_Phase
	
	Direct any questions about this template to emo@eclipse.org
 -->

<html>
<head>

<!-- 
	Include the title here. We will parse it out of here and include it on the
	rendered webpage. Do not duplicate the title within the text of your page.
 -->

<title>OM2M</title>
</head>

<!-- 
	We make use of the 'classic' HTML Definition List (dl) tag to specify
	committers. I know... you haven't seen this tag in a long while...
 -->

<style>
dt {
	display: list-item;
	list-style-position: outside;
	list-style-image:
		url(/eclipse.org-common/themes/Phoenix/images/arrow.gif);
	margin-left: 16px;
}

dd {
	margin-left: 25px;
	margin-bottom: 5px;
}
</style>

<body>
	<p>
		The OM2M project is a proposed open source project under the <a
			href="http://projects.eclipse.org/projects/[top-level-project-id]">Eclipse
			Technology Project</a>.
	</p>

	<!-- 
	The communication channel must be specified. Typically, this is the
	"Proposals" forum. In general, you don't need to change this.
 -->
	<p>
		This proposal is in the Project Proposal Phase (as defined in the
		Eclipse Development Process) and is written to declare its intent and
		scope. We solicit additional participation and input from the Eclipse
		community. Please send all feedback to the <a
			href="http://www.eclipse.org/forums/eclipse.proposals">Eclipse
			Proposals</a> Forum.
	</p>

	<h2>Background</h2>

	<!-- 
	Optionally provide the background that has lead you to creating this project.
 -->
	<p>Machine-to-Machine communications (M2M) is a phenomenon that has
		been proceeding quietly in the background, and it is coming into the
		phase, where explosion of usage scenarios in businesses will happen.
		Sensors, actuators, RFID/NFC tags, vehicles, and intelligent machines
		all have the ability to communicate. The number of M2M connections is
		continuously increasing, and it has been predicted to see billions of
		machines interconnected in a near future. M2M applications provide
		advantages in various domains from building, energy, healthcare,
		industrial, transportation, retail, security to environmental
		services. This fast-growing ecosystem is leading M2M towards a
		promising future, however M2M market expansion opportunities are not
		straight forward.</p>
	<p>M2M is suffering from the highly fragmented vertical domain
		specific approach, which has increased the R&amp;D cost in each
		specific domain. In fact, various vertical M2M solutions have been
		designed independently and separately for different applications,
		which inevitably impacts or even impedes large-scale M2M deployment.
		The existence of multiple manufacturers, the lack of a common M2M
		Service Capability Layer and no clarity about what can be achieved
		have all combined to leave the field of M2M communications closer to
		dream than reality.</p>
	<p>To reduce the standardization gap which exist between M2M
		domains, the ETSI Technical committee M2M defined an end to end M2M
		service platform with the intermediate service layer that are key
		components of the horizontal M2M solution. This standards based
		platform follows a RESTful approach with open interfaces to enable
		developing services and applications independently of the underlying
		network, thus easing the deployment of vertical applications for an
		effective interoperability, and facilitating innovation across
		industries.</p>
	<p>To avoid creation of competing M2M standards the 7 standards
		developing organizations, that publish telecom standards: TTC, ARIB
		(Japan), ATIS, TIA (USA), TTA (Korea) CCSA (China), ETSI (Europe)
		started the OneM2M Global Initiative to develop one globally agreed
		M2M Specification with initial focus on Service Layer. OneM2M aims to
		consolidate current M2M Service Layer standards activities such as
		ETSI TC M2M (Europe), TIA TR-50 (USA) and CCSA TC 10 (China), and to
		reduce standardization overlap and confusion and provide ongoing
		standards support to enhance interoperability, reduce market
		fragmentation, and improve security and reliability.</p>

	<h2>Scope</h2>

	<!-- 
	All projects must have a well-defined scope. Describe, concisely, what
	is in-scope and (optionally) what is out-of-scope. An Eclipse project
	cannot have an open-ended scope.
 -->

	<p>The OM2M project is an open source implementation of the ETSI
		M2M standard. It provides a framework for developing services
		independently of the underlying network and aims to facilitate
		deployment of vertical applications and heterogeneous devices. The
		scope of this project can be summarized as follows:</p>
	<ul>
		<li>Implement a Service Capability Layer (SCL) for an M2M
			network, M2M gateway and M2M device according to the ETSI M2M
			architecture.</li>
		<li>API for applications is based on REST principles to enhance
			interoperability and allow exposing data and providing services
			through unreliable connections within a highly distributed
			environment.</li>
		<li>Support generic communication technologies for ensuring
			multiple protocol binding such as HTTP and CoAP.</li>
		<li>Re-use of the OMA-DM protocol as a remote entity management
			service to perform software updates and life-cycle managements on
			OMA-DM enabled devices based on SyncML files.</li>
		<li>Ensure security based on the TLS-PSK protocol to enable
			secure communication based on pre-shared keys.</li>
		<li>Provides various interworking proxies to enable seamless
			communication with non-ETSI compliant devices such as ZIGBEE and
			PHIDGETS technologies.</li>
		<li>Manage M2M SCLs mutual authentications and M2M applications
			registrations</li>
		<li>Provide advanced user profile, access right and permission
			management.</li>
		<li>Enable synchronous communications based on the
			request/response design pattern.</li>
		<li>Enable asynchronous event notifications based on the
			publish/subscribe design pattern.</li>
		<li>Provide advanced mechanism for distributed M2M resource
			discovery.</li>
		<li>Be the basis for the future implementation of the OneM2M
			standard.</li>
	</ul>
	<h2>Description</h2>

	<!-- 
	Describe the project here. Be concise, but provide enough information that
	somebody who doesn't already know very much about your project idea or domain
	has at least a fighting chance of understanding its purpose.
 -->

	<p>The OM2M architecture follows the ETSI M2M standards. It is
		composed of the following elements:</p>
	<ul>
		<li><b>M2M Device</b>: a machine that runs an M2M device SCL
			(DSCL) that can be queried by M2M device applications (DAs) via an
			open interface. An M2M device can connect directly to the M2M Network
			or indirectly via a gateway that acts as a network proxy.</li>
		<li><b>M2M Area Network</b>: provides connectivity between M2M
			devices, and also between the devices and the M2M gateways. It is
			based on existing technologies such as Zigbee, Phidgets, M-BUS, KNX,
			etc.</li>
		<li><b>M2M Gateway</b>: a machine that runs an M2M Gateway SCL
			(GSCL) that can be queried by M2M Gateway applications (GAs) or DAs
			via an open interface. It identifies and addresses heterogeneous
			devices, and interconnects M2M area networks with different protocol
			technologies by performing mapping/converting operations.</li>
		<li><b>Wide Area Network</b> provides the core network with
			access networks to enable M2M devices and gateways to communicate
			with the M2M network. It is based on existing technologies such as
			xDSL, GERAN, UTRAN, eUTRAN, W-LAN, WiMAX, etc.</li>
		<li><b>M2M Network</b>: provides an M2M Network SCL (NSCL) that
			can be queried by M2M Network applications (NAs) via an open
			interface.</li>
		<li><b>M2M service capabilities Layer (SCL)</b> provides a
			horizontal service layer for M2M applications abstracting the
			complexity of hetergogeneous devices and enhancing M2M
			interoperability .</li>
		<li><b>M2M application</b> a domain-specific software application
			that interracts with the M2M machines by quering the service layer
			through a set of open interfaces</li>
	</ul>
	<img width="480" src="images/om2m_architecture.png" />


	<p>OM2M provides the following service capabilities that
		communicate through the Routing Function (RF) module within the SCL.
		SCs can be deployed on an M2M network, gateway or device:</p>
	<ul>
		<li><b>Application enablement(xAE)</b> provides a single point of
			contact to M2M applications using XML files and HTTP protocol but can
			be mapped easily to other protocol technologies such as CoAP.</li>
		<li><b>Generic communication(xGC)</b> provides a single point of
			contact for communication between different SCLs using XML files and
			HTTP protocol but can also bind to other protocols. It makes use of
			existing network connectivity and manages all security aspects for
			secure session establishment and teardown.</li>
		<li><b>Reachability, addressing, and repository(xRAR)</b>
			provides persistence capability to store M2M resource states within
			the SCL. It enables to Create, Retrieve, Update and Delete (CRUD) M2M
			resources, to store information related to M2M applications and SCls
			registrations, and to manage data required for publish/subscribe
			communication..</li>
		<li><b>Communication selection(xCS)</b> provides network
			selection algorithms and mechanisms based on policies for M2M machine
			with multiple interfaces and bearer such as Ethernet, Wifi, GPRS or
			3G. It also proposes alternative Network after a communication
			failure.</li>
		<li><b>Remote entity management(xREM)</b> interworks with
			existing REM standards such as the OMA-DM by performing
			mapping/converting operations. It provides functions pertaining to
			device/gateway life cycle management, such as software and firmware
			upgrade and provides mechanisms for fault and performance management.</li>
		<li><b>SECurity(xSEC)</b> implements bootstrapping,
			authentication, authorization, and key management functions to
			establish secure communication between M2M applications and SCLs
			based on the TLS-PSK protocol.</li>
		<li><b>Interworking proxy(xIP)</b> allows non-ETSI-compliant
			devices such as Zigbee, Phidgets, and many other technologies to
			interwork with the ETSI M2M standard by performing mapping/converting
			operations. In the smart building domain, a specific application
			payload is proposed based on the OBIX information model to enhance
			interoperability.</li>
	</ul>

	<p>(Where x refers to: "N" for network, "G" for gateway, and "D"
		for device)</p>

	<p>OM2M offers the mIa, dIa, and mId reference points:</p>
	<ul>
		<li><b>mIa reference point</b>: allows a NA to communicate
			remotely with the NSCL</li>
		<li><b>dIa reference point</b>: allows a DA to communicate with
			the DSCL or the GSCL where it is residing. It allows also a GA to
			communicate with the GSCL where it is residing</li>
		<li><b>mId reference point</b>: allows DSCL and GSCL to
			communicate with the NSCL on the service level and vice versa. the
			mId uses core network connectivity functions as an underlying
			transport.</li>
	</ul>
	<p>As the OM2M architecture follows a RESTful style with a
		hierarchical namespace, an AJAX web interface based is provided to
		enable exploring SCLs resource trees, monitoring sensors and
		controlling actuators. The OM2M web interface offers the following
		functionalities:</p>
	<ul>
		<li>Explore SCL resource tree of an M2M machine and display
			sub-resources attributes</li>
		<li>Discover authenticated SCLs and navigate from one SCL to
			another in a seamless way using retargeting mechanism</li>
		<li>Retrieve sensor events e.g. temperature, luminosity, power,
			etc. using two ways: read cached copies from the resources tree, or
			make a direct request to the sensor through the interworking proxy</li>
		<li>Execute action on actuators e.g. to switch ON/OFF a lamp,
			control a servo motor, etc. and monitor their new states using
			retargeting mechanism</li>
	</ul>

	<p>A screenshot of the OM2M web interface is presented on the
		following figure:</p>
	<img width="480" src="images/om2m_interface.png" />
	<p>ETSI M2M standardized the M2M SCL resources tree. Each SCL
		resource is referenced with a global identifier and has a type, a set
		of attributes, a set of methods that operate on it, and some links to
		other resources. Most important SCL resources are listed below:</p>
	<ul>
		<li><b>sclBase resource</b> describes the hosting SCL, and is the
			root for all other resources within the hosting SCL.</li>
		<li><b>scl resource</b> stores information related to M2M SCLs
			residing on other M2M machines after successful mutual
			authentication. It enables SCLs interractions using retargeting
			operations</li>
		<li><b>application resource</b> stores information about the
			application after a successful registration on the hosting SCL.</li>
		<li><b>container resource</b> acts as a mediator for data
			buffering to enable data exchange between applications and SCLs</li>
		<li><b>accessRight resource</b> manages permissions and
			permissions holders to limit and protect the access to the resource
			tree structure.</li>
		<li><b>group resource</b> enhances resources tree operations and
			simplifying the interactions on the API interfaces by adding the
			grouping feature. It enables an issuer to send one request to a set
			of receivers instead of sending requests one by one.</li>
		<li><b>subscription resource</b> stores information related to
			subscriptions for some resources. It allow subscribers to receive
			asynchronous notification when an event happens such as the reception
			of new sensor event or the creation, update, or delete of a resource.</li>
		<li><b>collection resource</b> groups commun resources togethers.
			It is used at different places such as scls, applications, or
			containers.</li>
		<li><b>announced resource</b> contains a partial representation
			of a resource in a remote SCL to simplify discovery request on
			distributed SCLs.</li>
		<li><b>discovery resource</b> acts as a search engine for
			resources. It enables to retrieve the set of resources URIs matching
			a specific filter criteria and constraints.</li>
	</ul>


	<h3>ETSI M2M references</h3>
	For more details on the ETSI M2M standard you can see:
	<ul>
		<li>M2M Communications: A Systems Approach. Edited by David
			Boswarthick, Omar Elloumi and Olivier Hersent</li>
		<li>ETSI TS 102 689, Machine-to-Machine communications (M2M); M2M
			service requirements</li>
		<li>ETSI TS 102 690, Machine-to-Machine communications (M2M);
			Functional architecture</li>
		<li>ETSI TS 102 921, Machine-to-Machine communications (M2M);
			mIa, dIa and mId interfaces</li>
	</ul>
	<h2>Why Eclipse?</h2>

	<!-- 
	Answer these two questions:	What value does this project bring to the Eclipse
	community? What value do you expect to obtain from hosting your project at Eclipse?
	
	What value do you get by having your project at Eclipse over and above the value
	of hosting at Eclipse Labs?
 -->
	<p>Being an eclipse project, OM2M aims to boost the development of
		M2M applications through the Eclipse community. The OM2M service
		architecture can be a key peice to bring together M2M projects within
		the Eclipse M2M Industry Working Group. OM2M already has a strong
		relationship with other Eclipse projects such as Koneki which is used
		for remote entity management based on the OMA-DM protocol. The Equinox
		project will be also adopted for dynamic deployment and dependencies
		management of M2M services and applications. OM2M team will work
		closely with other Eclipse M2M projects to come up with one global
		technology-agnostic M2M platform that makes easy the development of
		new service capabilities, connecting heterogeneous devices, and
		deployment of vertical applications.</p>

	<h2>Initial Contribution</h2>

	<p>The OM2M project will be provided with an initial contribution
		from LAAS-CNRS laboratory:</p>
	<ul>
		<li>A java implementation of an M2M network, M2M gateway and M2M
			device in line with the ETSI M2M specifications</li>
		<li>A HTTP mapping module for vertical and horizontal reference
			points for application enablement and generic communication</li>
		<li>A Phidget and Zigbee interworking proxies to experiment
			non-ETSI compliant devices</li>
		<li>An OMA-DM remote entity management service using the Funambol
			server and the Koneki Simulator</li>
		<li>A web interface based on AJAX for SCLs resource trees
			exploration, and devices monitoring and controlling.</li>
	</ul>

	<!-- 
	Projects are expected to arrive at Eclipse with existing code.
	
	Describe the existing code that will be contributed to the project. Please provide
	a couple of paragraphs describing the code with modest detail, including important
	information like code ownership (who holds the copyright?), and some consideration
	of community that exists around the code. Include a listing of third-party libraries 
	and associated licenses.
 -->

	<h2>Legal Issues</h2>

	<!-- 
	Please describe any potential legal issues in this section. Does somebody else
	own the trademark to the project name? Is there some issue that prevents you
	from licensing the project under the Eclipse Public License? Are parts of the 
	code available under some other license? Are there any LGPL/GPL bits that you
	absolutely require?
 -->
	<p>The following parts of the code are available under different
		licenses</p>
	<ul>
		<li>Apache HTTP Server library: Apache 2.0</li>
		<li>Apache HTTP Client library: Apache 2.0</li>
		<li>JAXB library: CDDL v1.1 and GPL v2</li>
		<li>DB4O library: dOCL and GPL v3</li>
		<li>jQuery library: MIT</li>
	</ul>
	<p>Optional libraries:</p>
	<ul>
		<li>Security IAIK-JCE library: EUPL and GPL v2</li>
		<li>RXTX library: LGPL v 2.1 + Linking Over Controlled Interface</li>
		<li>Phidgets library: LGPL v3</li>
		<li>Obix JAVA Toolkit: Free</li>
	</ul>

	<h2>Committers</h2>

	<!-- 
	List any initial committers that should be provisioned along with the
	new project. Include affiliation, but do not include email addresses at
	this point.
 -->

	<p>The following individuals are proposed as initial committers to
		the project:</p>

	<dl>
		<dt>Mahdi Ben Alaya, LAAS-CNRS</dt>
		<dd>OM2M project co-lead</dd>
		<dt>Thierry Monteil, LAAS-CNRS</dt>
		<dd>OM2M project co-lead</dd>
		<dt>Khalil Drira, LAAS-CNRS</dt>
		<dd>OM2M project commiter</dd>
		<dt>Christophe Chassot, LAAS-CNRS</dt>
		<dd>OM2M project commiter</dd>
	</dl>

	<p>We welcome additional committers and contributions.</p>

	<!-- 
	Describe any initial contributions of code that will be brought to the 
	project. If there is no existing code, just remove this section.
 -->

	<h2>Mentors</h2>

	<!-- 
	New Eclipse projects require a minimum of two mentors from the Architecture
	Council. You need to identify two mentors before the project is created. The
	proposal can be posted before this section is filled in (it's a little easier
	to find a mentor when the proposal itself is public).
 -->

	<p>The following Architecture Council members will mentor this
		project:</p>

	<ul>
		<li>Denis Roy</li>
		<li>Benjamin Cab&eacute;</li>
	</ul>

	<h2>Interested Parties</h2>

	<!-- 
	Provide a list of individuals, organisations, companies, and other Eclipse
	projects that are interested in this project. This list will provide some
	insight into who your project's community will ultimately include. Where
	possible, include affiliations. Do not include email addresses.
 -->

	<p>The following individuals, organisations, companies and projects
		have expressed interest in this project:</p>

	<ul>
		<li>Luigi Alfredo Grieco, Department of Electrical and
			Information engineering, Politecnico di Bari, Italy</li>
		<li>Miriam Capretz, Software Evolution Lab/ECE, Western
			University, Canada</li>
		<li>Amine Dhraief, HANA Lab, University of Manouba, Tunisia</li>
		<li>Juhani Latvakoski, VTT Technical Research Centre of Finland</li>
		<li>Georges Da Costa, IRIT, France</li>
		<li>Giuseppe Monteleone, Italtel, Italy</li>
		<li>Gowri Shankar, Prodapt Solutions, India</li>
		<li>Werner Keil, Eclipse UOMo Project lead</li>
		<li>Mathieu Rousselle </li>
		<li>Mario Kusek, Faculty of Electrical Engineering and Computing, University of Zagreb</li>
	</ul>

	<h2>Project Scheduling</h2>

	<!-- 
	Describe, in rough terms, what the basic scheduling of the project will
	be. You might, for example, include an indication of when an initial contribution
	should be expected, when your first build will be ready, etc. Exact
	dates are not required.
 -->

	<h2>Changes to this Document</h2>

	<!-- 
	List any changes that have occurred in the document here.
	You only need to document changes that have occurred after the document
	has been posted live for the community to view and comment.
 -->

	<table>
		<tr>
			<th>Date</th>
			<th>Change</th>
		</tr>
		<tr>
			<td>6-January-2014</td>
			<td>Added interested parties</td>
		</tr>
		<tr>
			<td>13-November-2013</td>
			<td>Added interested parties</td>
		</tr>
		<tr>
			<td>30-October-2013</td>
			<td>Document created</td>
		</tr>
	</table>
</body>
</html>
