The number of applications leveraging data from sensors on smart-phones is growing. However, they tend to focus on single Apps for personal sensing rather than trying to achieve a greater good (social sensing) by addressing challenges as App interoperability and geographical distribution of devices. In this paper, we present MobileWave a framework that allows creating, composing and publishing RDF streams from smart-phones. MobileWave extends TripleWave with a publish/subscribe middleware that collects a uent RDF Streams, composes them into a swollen RDF stream and publishes it on the Web.
Smart-phones may not have started the Web-of-Things revolution, but are now
active part of it. We all became sensor when we started posting on social media,
but many applications are now turning the phones into actual platform able to
measure all the aspect of our life [
Can the Semantic Web actively contribute to this change of paradigm? Few
years ago, the Stream Reasoning (SR) community proposed a framework,
TripleWave, to publish RDF streams on the Web [
2 https://www.google.com/fit/ 3 Waze { https://www.waze.com/en-GB/ that combines GPS and social data from millions of users provide better tra c analyses.
In this paper, we propose MobileWave, a framework that allows accessing, gathering and collectively publishing RDF streams from Smart-Phone sensors. MobileWave: (i) exploits Ontology Based Data Access (OBDA) techniques on smart-phones; (ii) de nes a protocol between phones and a publish-subscribe middleware; (iii) creates a composed RDF stream and publishes it through an enhanced version of TripleWave. 2
As in the social sensing vision, we aim at gathering data from millions of smartphone users. This practically implies two problems: 1. a data integration problem, since di erent phones have di erent speci cations, hardware and licensing; and 2. a scalability problem, since we cannot rely neither in high computational power nor in long battery durations.
Unfortunately, usual techniques to solve these tasks would drain the phones' battery. Phone does have enough space, memory or power to integrate data and stream directly to all the interested consumers. In the following sections we explain how MobileWave solves them using Figure 1 to visualize the work ow. 2.1
Virtual RDF Streams on the Phones In order to solve the data integration problem (1), we ported on mobile OBDA techniques. We developed an Integrate Conceptual Model (ICM), MobileWaveOnto4
owards Distributed RDF Stream Publication
using Semantic Sensor Networks (SSN) ontology [
In MobileWaveOnto, we modeled both static information about the device, i.e. the capabilities of the deployed sensors, and sensor observations. While the former represent quasi-static information, the latter are highly dynamic. Therefore, two kinds of mappings are possible, i.e. (a) mappings describing the device and; (b) mappings representing a sensor observation as time-varying graph. Listings 1 and 2 respectively exemplify these mappings.
Figure 1.(b) shows the deployment of the R2RML mappings on the phone. MobileWave applies the mapping by means of Apache Cordova7, which o ers a generic view over phones hardware. R2RML mappings are translated in a JSONLD based syntax which is more convenient for Apache Cordova to combine with phone data, but it still preserves the semantic value of R2RML. Each translation includes: (1) a Context that maps terms to IRIs, and; (2) a Pattern list that contains the actual mappings from Apache Cordova's JSON to RDF graphs. 2.2
From A
uents to Swollen RDF Streams In order to solve the scalability problem (2), MobileWave comprises a publish/subscribe middleware that exposes REST methods for device to register and then composes and publishes an RDF stream to be consumed. We name this stream Swollen RDF stream and a uent s RDF streams those stream that participate. To be added as an a uent, a device must identify itself by sharing a descriptions le. We call it description Graph (dGraph) and we build it by means of the (a)-type mappings described in Section 2.1 and exempli ed in Listing 1. MobileWave middleware stores the dGraph and replies to the device with the URL where the sensor observations should be pushed.
"dGraph": [f "subject": "#GPSSensor ffuuidgg", "sources": ["device", "position "], "properties": [f "predicate": "rdf:type", "object": "GPSSensor", " isLiteral ": false g, f "predicate": "ssn:onPlatform", "object": "SmartPhone ffuuidgg", " isLiteral ": false g]g] "iGraph": [f "subject": "GPSObservation fftimegg", "sources": ["device", "position "], "properties": [f "predicate": "rdf:type", "object": "GPSObservation", " isLiteral ": false g, f "predicate": "ssn:observedBy", "object": "GPSSensor ffuuidgg", " isLiteral ": false g]g] Listing 1: dGraph mapping example
Listing 2: iGraph mapping example
In order to publish the Swollen RDF Stream we rely on two TripleWave's abstractions: the sGraph, a named graph that describes the stream itself and; the iGraph, i.e. a named graph that represents one element of the stream. We 5 https://github.com/ontop/ontop 6 W3C Recommendation: https://www.w3.org/TR/r2rml/ 7 https://cordova.apache.org/ can represent both the a uent RDF streams and the Swollen RDF using these abstractions.
MobileWave middleware is aware of all the a uent RDF streams descriptions (dGraphs) and it can select and compose them to de ne the Swollen RDF stream's sGraph accordingly to a given user need. For instance,it can select only the streams that come from beacons in mobile phones located in Milan.
MobileWave middleware controls the destination of the observations each a uent sends. Therefore, an iGraph in an a uent RDF stream directly corresponds to an iGraph in the Swollen RDF stream.
Figure 1.(c) and (d) show respectively the creation and publication processes. As we anticipated in Section 1 we developed a custom version of TripleWave that supports this kind of stream composition. Indeed, once the sGraph of the Swollen RDF stream is de ned the publication phase, which is illustrated in Figure 1.(d), follows the same process of publishing a plain RDF Stream. From a stream consumer perspective the Swollen RDF stream looks like any other RDF stream on the Web.
In this paper, we presented MobileWave, a framework that enables creating, composing and collectively publishing RDF stream from mobile phones.
MobileWave uses OBDA technologies to access smart-phones sensors data and a publish/subscribe version of TripleWave that gathers data from several devices and publishes Swollen RDF stream on the Web.