diff --git a/README.md b/README.md
index d63dcc5..3491e8f 100644
--- a/README.md
+++ b/README.md
@@ -39,7 +39,7 @@ The plugin offers two features:
 
 - [Sensor data collection](#sensor-data-collection) from the paired smartwatch: it can be started/stopped from the smartphone and from the smartwatch.
   The smartwatch is able to start and stop the data collection thanks to the WearCommands feature.
-- [FreeMessaging](#freemessaging): it allows to send and receive simple messages between both devices.
+- [Plain Messaging](#plainmessaging): it allows to send and receive simple messages between both devices.
 
 In first place, you need to initialize the plugin with a [`WearosSensorsConfig`](#wearossensorsconfig) in your app.ts (TypeScript app) or main.ts (Angular app) file:
 
@@ -51,12 +51,11 @@ import { platformNativeScriptDynamic } from "nativescript-angular/platform";
 import { AppModule } from "./app/app.module";
 
 // WearOSSensors import
-import { wearosSensors } from "nativescript-wearos-sensors";
-import { allSensors } from "nativescript-wearos-sensors/wearos-sensors.common";
+import { wearosSensors, allSensors } from "nativescript-wearos-sensors";
 
 wearosSensors.init({
     sensors: allSensors,
-    disableFreeMessaging: false,
+    disablePlainMessaging: false,
     disableWearCommands: false
 });
 
@@ -66,8 +65,8 @@ Application.run({ moduleName: "app-root" });
 platformNativeScriptDynamic().bootstrapModule(AppModule);
 ```
 
-The initialization parameter is optional, and it allows specifying which sensors are enabled (`sensors`), and if FreeMessaging
-(`disableFreeMessaging`) and WearCommands (`disableWearCommands`) features are enabled. The default configuration is
+The initialization parameter is optional, and it allows specifying which sensors are enabled (`sensors`), and if PlainMessaging
+(`disablePlainMessaging`) and WearCommands (`disableWearCommands`) features are enabled. The default configuration is
 the one shown in the example above: all sensors and features enabled.
 
 > **Note**: the configuration allows conditionally wire up native components with the core of the plugin. This allows
@@ -196,37 +195,37 @@ the collected data.
 > **Warning**: the WearCommands feature must be enabled at plugin initialization.
 
 
-### FreeMessaging
+### PlainMessaging
 With a system composed by several devices, it is important to have a way to communicate. We provide the 
-[`FreeMessageClient`](#freemessageclient), which allows to send and
+[`PlainMessageClient`](#plainmessageclient), which allows to send and
 receive string based messages. There are two types of received messages: the ones which require a response and the
 ones which don't. Here's an example on how to use the messaging feature:
 
 ```typescript
-import { getFreeMessageClient } from "nativescript-wearos-sensors/internal/communication/free-message";
+import { getPlainMessageClient } from "src/internal/communication/plain-message";
 
 function registerListener(): void {
     // Register a listener to receive messages from the smartwatch
-    getFreeMessageClient().registerListener((receivedMessage) => {
+    getPlainMessageClient().registerListener((receivedMessage) => {
         console.log(`received single message ${JSON.stringify(receivedMessage)}`);
     });
 }
 
 async function sendMessage(node: Node, message: string): void {
     // Send a message to the smartwatch
-    const freeMessage = { message: "You don't have to reply :)" };
-    await getFreeMessageClient().send(node, freeMessage);
+    const plainMessage = {message: "You don't have to reply :)"};
+    await getPlainMessageClient().send(node, plainMessage);
 }
 
 async function sendMessageAndWaitResponse(node: Node, message: string): void {
     // Send a message to the smartwatch and wait for a response
-    const freeMessage = { message: "PING!"};
-    const receivedMessage = await getFreeMessageClient().sendExpectingResponse(node, freeMessage);
+    const plainMessage = {message: "PING!"};
+    const receivedMessage = await getPlainMessageClient().sendExpectingResponse(node, plainMessage);
     console.log(`response received: ${JSON.stringify(receivedMessage)}`);
 }
 ```
 
-> **Warning**: the FreeMessaging feature must be enabled at plugin initialization.
+> **Warning**: the PlainMessaging feature must be enabled at plugin initialization.
 
 ## API
 
@@ -238,18 +237,18 @@ async function sendMessageAndWaitResponse(node: Node, message: string): void {
 
 #### [`WearosSensorsConfig`](src/wearos-sensors.common.ts)
 
-| Property                | Type           | Description                                              |
-|-------------------------|----------------|----------------------------------------------------------|
-| `sensors?`              | `SensorType[]` | Sensors that are going to be used. Default: all sensors. |
-| `disableFreeMessaging?` | `boolean`      | Disable free messaging feature. Default: false.          |
-| `disableWearCommands?`  | `boolean`      | Disable wear commands feature. Default: false.           |
+| Property                 | Type           | Description                                              |
+|--------------------------|----------------|----------------------------------------------------------|
+| `sensors?`               | `SensorType[]` | Sensors that are going to be used. Default: all sensors. |
+| `disablePlainMessaging?` | `boolean`      | Disable plain messaging feature. Default: false.         |
+| `disableWearCommands?`   | `boolean`      | Disable wear commands feature. Default: false.           |
 
 ##### `defaultConfig`
 
 ```typescript
 export const defaultConfig = {
     sensors: allSensors, // Constant containing all the sensors
-    disableFreeMessaging: false,
+    disablePlainMessaging: false,
     disableWearCommands: false
 };
 ```
@@ -368,31 +367,31 @@ export const defaultConfig = {
 | `longitude` | `number`  | Longitude coordinate component. |
 | `altitude`  | `number`  | Altitude coordinate component.  |
 
-### [`FreeMessageClient`](src/internal/communication/free-message/android/free-message-client.android.ts)
+### [`PlainMessageClient`](src/internal/communication/plain-message/android/plain-message-client.android.ts)
 
-| Function                                                                        | Return type                | Description                                                                       |
-|---------------------------------------------------------------------------------|----------------------------|-----------------------------------------------------------------------------------|
-| `enabled()`                                                                     | `boolean`                  | Returns true if the free message feature is enabled in the initial configuration. |
-| `registerListener(listener: FreeMessageListener)`                               | `void`                     | Registers the listener for the feature.                                           |
-| `unregisterListener()`                                                          | `void`                     | Unregisters the listener for the feature.                                         |
-| `send(node: Node, freeMessage: FreeMessage)`                                    | `Promise<void>`            | Sends a message to the specified Node.                                            |
-| `sendExpectingResponse(node: Node, freeMessage: FreeMessage, timeout?: number)` | `Promise<ReceivedMessage>` | Sends a message to the specified Node and wait `timeout` ms for a response.       |
+| Function                                                                          | Return type                | Description                                                                        |
+|-----------------------------------------------------------------------------------|----------------------------|------------------------------------------------------------------------------------|
+| `enabled()`                                                                       | `boolean`                  | Returns true if the plain message feature is enabled in the initial configuration. |
+| `registerListener(listener: PlainMessageListener)`                                | `void`                     | Registers the listener for the feature.                                            |
+| `unregisterListener()`                                                            | `void`                     | Unregisters the listener for the feature.                                          |
+| `send(node: Node, plainMessage: PlainMessage)`                                    | `Promise<void>`            | Sends a message to the specified Node.                                             |
+| `sendExpectingResponse(node: Node, plainMessage: PlainMessage, timeout?: number)` | `Promise<ReceivedMessage>` | Sends a message to the specified Node and wait `timeout` ms for a response.        |
 
-#### `FreeMessage`
+#### `PlainMessage`
 
-| Property        | Type          | Description                                                                                                                             |
-|-----------------|---------------|-----------------------------------------------------------------------------------------------------------------------------------------|
-| `message`       | `string`      | Content of the message.                                                                                                                 |
-| `inResponseTo?` | `FreeMessage` | Contains the message at which the current message is responding. `undefined` means that the message is not responding to other message. |
+| Property        | Type           | Description                                                                                                                             |
+|-----------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------|
+| `message`       | `string`       | Content of the message.                                                                                                                 |
+| `inResponseTo?` | `PlainMessage` | Contains the message at which the current message is responding. `undefined` means that the message is not responding to other message. |
 
 #### `ReceivedMessage`
 
-| Property       | Type          | Description                          |
-|----------------|---------------|--------------------------------------|
-| `senderNodeId` | `string`      | Id of the node who sent the message. |
-| `freeMessage`  | `FreeMessage` | Message received.                    |
+| Property       | Type           | Description                          |
+|----------------|----------------|--------------------------------------|
+| `senderNodeId` | `string`       | Id of the node who sent the message. |
+| `PlainMessage` | `PlainMessage` | Message received.                    |
 
-#### `FreeMessageListener`
+#### `PlainMessageListener`
 
 `(receivedMessage: ReceivedMessage) => void`
     
diff --git a/demo/app/home/device-list/device-list-view-model.ts b/demo/app/home/device-list/device-list-view-model.ts
index 9a67741..34ef664 100644
--- a/demo/app/home/device-list/device-list-view-model.ts
+++ b/demo/app/home/device-list/device-list-view-model.ts
@@ -1,7 +1,7 @@
 import { Observable } from "@nativescript/core";
 import { getLogger } from "~/home/logger/logger-view-model";
 import { getNodeDiscoverer } from "nativescript-wearos-sensors/node";
-import { getFreeMessageClient } from "nativescript-wearos-sensors/internal/communication/free-message";
+import { getPlainMessageClient } from "../../../../src/internal/communication/plain-message";
 import { getCollectorManager } from "nativescript-wearos-sensors/internal/collection";
 import { getStore } from "~/home/store";
 
@@ -23,7 +23,7 @@ export class DeviceListViewModel extends Observable {
             getStore().addRecord(sensorRecord);
             this.logger.logResultForNode(deviceId, JSON.stringify(samples));
         });
-        getFreeMessageClient().registerListener((receivedMessage) => {
+        getPlainMessageClient().registerListener((receivedMessage) => {
             this.logger.logInfo(`received single message ${JSON.stringify(receivedMessage)}`);
         });
     }
diff --git a/demo/app/home/device/device-page.xml b/demo/app/home/device/device-page.xml
index 8f3418a..2648d6e 100644
--- a/demo/app/home/device/device-page.xml
+++ b/demo/app/home/device/device-page.xml
@@ -25,14 +25,14 @@
 
     <StackLayout orientation="vertical">
         <GridLayout rows="auto, auto" columns="*, *" class="card" height="100">
-            <Label row="0" col="0" colspan="2" class="bold" text="FreeMessages"/>
+            <Label row="0" col="0" colspan="2" class="bold" text="PlainMessages"/>
             <Button row="1" col="0"
                     backgroundColor="deepskyblue"
-                    tap="{{ onTestFreeMessage }}"
+                    tap="{{ onTestPlainMessage }}"
                     text="Single"/>
             <Button row="1" col="1"
                     backgroundColor="deepskyblue"
-                    tap="{{ onTestFreeMessageWithResponse }}"
+                    tap="{{ onTestPlainMessageWithResponse }}"
                     text="Single with response"/>
         </GridLayout>
         <GridLayout class="card" rows="auto, auto" columns="2*, *" height="80">
diff --git a/demo/app/home/device/device-view-model.ts b/demo/app/home/device/device-view-model.ts
index 0c162d8..90f96ec 100644
--- a/demo/app/home/device/device-view-model.ts
+++ b/demo/app/home/device/device-view-model.ts
@@ -5,7 +5,9 @@ import { Node } from "nativescript-wearos-sensors/node";
 import { getCollectorManager, PrepareError, NativeSensorDelay } from "nativescript-wearos-sensors/collection";
 import { SensorType } from "nativescript-wearos-sensors/sensors";
 import { getStore } from "~/home/store";
-import { getFreeMessageClient, FreeMessageClient } from "nativescript-wearos-sensors/free-message";
+import {
+    getPlainMessageClient, PlainMessageClient
+} from "nativescript-wearos-sensors/plain-message";
 
 
 export class DeviceViewModel extends Observable {
@@ -41,7 +43,7 @@ export class DeviceViewModel extends Observable {
 
     private batchSize = 50;
 
-    private freeMessageClient: FreeMessageClient;
+    private plainMessageClient: PlainMessageClient;
 
     constructor(
         private node: Node
@@ -61,28 +63,28 @@ export class DeviceViewModel extends Observable {
             };
         });
 
-        this.freeMessageClient = getFreeMessageClient();
+        this.plainMessageClient = getPlainMessageClient();
     }
 
-    async onTestFreeMessage() {
-        if (!this.freeMessageClient.enabled()) {
-            this.logger.logInfo(`Free messages are not enabled`);
+    async onTestPlainMessage() {
+        if (!this.plainMessageClient.enabled()) {
+            this.logger.logInfo(`Plain messages are not enabled`);
             return;
         }
-        const freeMessage = { message: "You don't have to reply :)"};
-        this.logger.logInfoForNode(this.node.name, `sending ${JSON.stringify(freeMessage)}`);
-        await this.freeMessageClient.send(this.node, freeMessage);
+        const plainMessage = { message: "You don't have to reply :)"};
+        this.logger.logInfoForNode(this.node.name, `sending ${JSON.stringify(plainMessage)}`);
+        await this.plainMessageClient.send(this.node, plainMessage);
     }
 
-    async onTestFreeMessageWithResponse() {
-        if (!this.freeMessageClient.enabled()) {
-            this.logger.logInfo(`Free messages are not enabled`);
+    async onTestPlainMessageWithResponse() {
+        if (!this.plainMessageClient.enabled()) {
+            this.logger.logInfo(`Plain messages are not enabled`);
             return;
         }
 
-        const freeMessage = { message: "PING!"};
-        this.logger.logInfoForNode(this.node.name, `sending ${JSON.stringify(freeMessage)} and awaiting for response`);
-        const receivedMessage = await this.freeMessageClient.sendExpectingResponse(this.node, freeMessage);
+        const plainMessage = { message: "PING!"};
+        this.logger.logInfoForNode(this.node.name, `sending ${JSON.stringify(plainMessage)} and awaiting for response`);
+        const receivedMessage = await this.plainMessageClient.sendExpectingResponse(this.node, plainMessage);
         this.logger.logResultForNode(this.node.name, `response received: ${JSON.stringify(receivedMessage)}`);
     }
 
diff --git a/demo/app/tests/internal/collector-manager-impl.android.spec.ts b/demo/app/tests/internal/collector-manager-impl.android.spec.ts
index 4c26f31..19329df 100644
--- a/demo/app/tests/internal/collector-manager-impl.android.spec.ts
+++ b/demo/app/tests/internal/collector-manager-impl.android.spec.ts
@@ -4,6 +4,7 @@ import { MessagingClient } from "nativescript-wearos-sensors/internal/communicat
 import { CollectorManagerImpl } from "nativescript-wearos-sensors/internal/collection/android/collector-manager-impl.android";
 import { buildFakeResolutionResult } from "~/tests/internal/index.spec";
 import { CollectorManager } from "nativescript-wearos-sensors/internal/collection/collector-manager";
+import { allSensors } from "nativescript-wearos-sensors/wearos-sensors.common";
 
 describe("Collector manager implementation", () => {
     const node1 = new Node("node1", "node1", [SensorType.ACCELEROMETER, SensorType.GYROSCOPE]);
@@ -15,7 +16,7 @@ describe("Collector manager implementation", () => {
 
     beforeEach(() => {
         messagingClient = buildFakeMessagingClient();
-        collectorManager = new CollectorManagerImpl((_) => messagingClient, null);
+        collectorManager = new CollectorManagerImpl((_) => messagingClient, null, allSensors);
     });
 
     it("isReady returns true when a node has a determined capability and false otherwise", async() => {
diff --git a/demo/app/tests/internal/communication/free-message/android/free-message-client.android.spec.ts b/demo/app/tests/internal/communication/free-message/android/free-message-client.android.spec.ts
deleted file mode 100644
index 43a57a0..0000000
--- a/demo/app/tests/internal/communication/free-message/android/free-message-client.android.spec.ts
+++ /dev/null
@@ -1,125 +0,0 @@
-import { FreeMessageClient } from "nativescript-wearos-sensors/internal/communication/free-message/free-message-client";
-import {
-    FreeMessageAndroidClient
-} from "nativescript-wearos-sensors/internal/communication/free-message/android/free-message-client.android";
-import {
-    FreeMessage,
-    FreeMessageProtocol,
-    ReceivedMessage
-} from "nativescript-wearos-sensors/internal/communication/free-message";
-import {
-    FreeMessageResultService
-} from "nativescript-wearos-sensors/internal/communication/free-message/android/free-message-result-service.android";
-import { Node } from "nativescript-wearos-sensors/internal/node";
-import { buildFakeMessageEvent } from "~/tests/internal/index.spec";
-
-describe("Free message client", () => {
-
-    const node: Node = new Node("test", "test");
-    const protocol: FreeMessageProtocol = {
-        withoutResponse: "test-no-response",
-        expectingResponse: "test-expecting-response",
-    };
-
-    let freeMessageClient: FreeMessageClient;
-    let freeMessageResultService: FreeMessageResultService;
-
-    beforeEach(() => {
-        freeMessageResultService = new FreeMessageResultService();
-        spyOn(freeMessageResultService, "onMessageReceived").and.callThrough();
-        freeMessageClient = new FreeMessageAndroidClient(
-            protocol,
-            freeMessageResultService
-        );
-        spyOn<any>(freeMessageClient, "sendMessage").and.callFake(() => Promise.resolve());
-    });
-
-    it("sends a message to a node", async () => {
-        const freeMessage: FreeMessage = {
-            message: "test message"
-        };
-
-        await expectAsync(freeMessageClient.send(node, freeMessage)).toBeResolved();
-    });
-
-    it("sends a message expecting a response an a response is received", async () => {
-        const freeMessage: FreeMessage = {
-            message: "test message"
-        };
-        const freeResponse: FreeMessage = {
-            message: "test response",
-            inResponseTo: freeMessage
-        }
-
-        const receivedMessagePromise = freeMessageClient.sendExpectingResponse(node, freeMessage);
-
-        freeMessageResultService.onMessageReceived(
-            buildFakeMessageEvent(
-                node.id,
-                protocol.withoutResponse,
-                JSON.stringify(freeResponse)
-            )
-        );
-
-        const receivedMessage: ReceivedMessage = await receivedMessagePromise;
-
-        expect(receivedMessage).toEqual({
-            senderNodeId: node.id,
-            freeMessage: freeResponse
-        });
-    });
-
-    it("sends a message expecting a response but no response is received", async () => {
-        const freeMessage: FreeMessage = {
-            message: "test message"
-        };
-
-        await expectAsync(freeMessageClient.sendExpectingResponse(node, freeMessage, 100))
-            .toBeRejectedWith(`Timeout for communication request in node ${node.name} (${node.id})`);
-    });
-
-    it("receives a wearable-triggered message", async () => {
-        const freeMessageReceived: FreeMessage = {
-            message: "message received from watch"
-        };
-
-        freeMessageClient.registerListener((receivedMessage) => {
-            expect(receivedMessage).toEqual({
-                senderNodeId: node.id,
-                freeMessage: freeMessageReceived
-            })
-        });
-
-        freeMessageResultService.onMessageReceived(
-            buildFakeMessageEvent(
-                node.id,
-                protocol.withoutResponse,
-                JSON.stringify(freeMessageReceived)
-            )
-        );
-
-        await new Promise((resolve) => {
-            setTimeout(resolve, 200)
-        });
-    });
-
-    it("receives a wearable-triggered message but there is no listener attached", () => {
-        const freeMessageReceived: FreeMessage = {
-            message: "message received from watch"
-        };
-        const receivedMessage: ReceivedMessage = {
-            senderNodeId: node.id,
-            freeMessage: freeMessageReceived,
-        };
-
-        expect(() => {
-            freeMessageResultService.onMessageReceived(
-                buildFakeMessageEvent(
-                    node.id,
-                    protocol.withoutResponse,
-                    JSON.stringify(freeMessageReceived)
-                )
-            )
-        }).toThrow(new Error(`received message ${JSON.stringify(receivedMessage)} but there are no callbacks set`))
-    });
-});
diff --git a/demo/app/tests/internal/communication/plain-message/android/plain-message-client.android.spec.ts b/demo/app/tests/internal/communication/plain-message/android/plain-message-client.android.spec.ts
new file mode 100644
index 0000000..d2a84b4
--- /dev/null
+++ b/demo/app/tests/internal/communication/plain-message/android/plain-message-client.android.spec.ts
@@ -0,0 +1,126 @@
+import { PlainMessageClient } from "nativescript-wearos-sensors/internal/communication/plain-message/plain-message-client";
+import {
+    PlainMessageAndroidClient
+} from "nativescript-wearos-sensors/internal/communication/plain-message/android/plain-message-client.android";
+import {
+    PlainMessage,
+    PlainMessageProtocol,
+    ReceivedMessage, setPlainMessagesEnabled
+} from "nativescript-wearos-sensors/internal/communication/plain-message";
+import {
+    PlainMessageResultService
+} from "nativescript-wearos-sensors/internal/communication/plain-message/android/plain-message-result-service.android";
+import { Node } from "nativescript-wearos-sensors/internal/node";
+import { buildFakeMessageEvent } from "~/tests/internal/index.spec";
+
+describe("Plain message client", () => {
+
+    const node: Node = new Node("test", "test");
+    const protocol: PlainMessageProtocol = {
+        withoutResponse: "test-no-response",
+        expectingResponse: "test-expecting-response",
+    };
+
+    let plainMessageClient: PlainMessageClient;
+    let plainMessageResultService: PlainMessageResultService;
+
+    beforeEach(() => {
+        setPlainMessagesEnabled(true);
+        plainMessageResultService = new PlainMessageResultService();
+        spyOn(plainMessageResultService, "onMessageReceived").and.callThrough();
+        plainMessageClient = new PlainMessageAndroidClient(
+            protocol,
+            plainMessageResultService
+        );
+        spyOn<any>(plainMessageClient, "sendMessage").and.callFake(() => Promise.resolve());
+    });
+
+    it("sends a message to a node", async () => {
+        const plainMessage: PlainMessage = {
+            message: "test message"
+        };
+
+        await expectAsync(plainMessageClient.send(node, plainMessage)).toBeResolved();
+    });
+
+    it("sends a message expecting a response an a response is received", async () => {
+        const plainMessage: PlainMessage = {
+            message: "test message"
+        };
+        const plainResponse: PlainMessage = {
+            message: "test response",
+            inResponseTo: plainMessage
+        }
+
+        const receivedMessagePromise = plainMessageClient.sendExpectingResponse(node, plainMessage);
+
+        plainMessageResultService.onMessageReceived(
+            buildFakeMessageEvent(
+                node.id,
+                protocol.withoutResponse,
+                JSON.stringify(plainResponse)
+            )
+        );
+
+        const receivedMessage: ReceivedMessage = await receivedMessagePromise;
+
+        expect(receivedMessage).toEqual({
+            senderNodeId: node.id,
+            plainMessage: plainResponse
+        });
+    });
+
+    it("sends a message expecting a response but no response is received", async () => {
+        const plainMessage: PlainMessage = {
+            message: "test message"
+        };
+
+        await expectAsync(plainMessageClient.sendExpectingResponse(node, plainMessage, 100))
+            .toBeRejectedWith(`Timeout for communication request in node ${node.name} (${node.id})`);
+    });
+
+    it("receives a wearable-triggered message", async () => {
+        const plainMessageReceived: PlainMessage = {
+            message: "message received from watch"
+        };
+
+        plainMessageClient.registerListener((receivedMessage) => {
+            expect(receivedMessage).toEqual({
+                senderNodeId: node.id,
+                plainMessage: plainMessageReceived
+            })
+        });
+
+        plainMessageResultService.onMessageReceived(
+            buildFakeMessageEvent(
+                node.id,
+                protocol.withoutResponse,
+                JSON.stringify(plainMessageReceived)
+            )
+        );
+
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200)
+        });
+    });
+
+    it("receives a wearable-triggered message but there is no listener attached", () => {
+        const plainMessageReceived: PlainMessage = {
+            message: "message received from watch"
+        };
+        const receivedMessage: ReceivedMessage = {
+            senderNodeId: node.id,
+            plainMessage: plainMessageReceived,
+        };
+
+        expect(() => {
+            plainMessageResultService.onMessageReceived(
+                buildFakeMessageEvent(
+                    node.id,
+                    protocol.withoutResponse,
+                    JSON.stringify(plainMessageReceived)
+                )
+            )
+        }).toThrow(new Error(`received message ${JSON.stringify(receivedMessage)} but there are no callbacks set`))
+    });
+});
diff --git a/demo/app/tests/internal/communication/free-message/android/free-message-result-service.android.spec.ts b/demo/app/tests/internal/communication/plain-message/android/plain-message-result-service.android.spec.ts
similarity index 63%
rename from demo/app/tests/internal/communication/free-message/android/free-message-result-service.android.spec.ts
rename to demo/app/tests/internal/communication/plain-message/android/plain-message-result-service.android.spec.ts
index 3b400c5..3417b9a 100644
--- a/demo/app/tests/internal/communication/free-message/android/free-message-result-service.android.spec.ts
+++ b/demo/app/tests/internal/communication/plain-message/android/plain-message-result-service.android.spec.ts
@@ -1,17 +1,17 @@
 import { Node } from "nativescript-wearos-sensors/internal/node";
 import {
-    FreeMessage,
-    FreeMessageProtocol,
+    PlainMessage,
+    PlainMessageProtocol,
     ReceivedMessage
-} from "nativescript-wearos-sensors/internal/communication/free-message";
+} from "nativescript-wearos-sensors/internal/communication/plain-message";
 import {
-    FreeMessageResultService
-} from "nativescript-wearos-sensors/internal/communication/free-message/android/free-message-result-service.android";
+    PlainMessageResultService
+} from "nativescript-wearos-sensors/internal/communication/plain-message/android/plain-message-result-service.android";
 import { buildFakeMessageEvent } from "~/tests/internal/index.spec";
 
-describe("Free message result service", () => {
+describe("Plain message result service", () => {
     const node: Node = new Node("test", "test");
-    const protocol: FreeMessageProtocol = {
+    const protocol: PlainMessageProtocol = {
         withoutResponse: "test-no-response",
         expectingResponse: "test-expecting-response",
     };
@@ -19,20 +19,20 @@ describe("Free message result service", () => {
 
     let resolutionCallback;
     let defaultListener;
-    let freeMessageResultService: FreeMessageResultService;
+    let plainMessageResultService: PlainMessageResultService;
 
     beforeEach(() => {
         resolutionCallback = jasmine.createSpy("resolutionCallbackSpy");
         defaultListener = jasmine.createSpy("defaultListenerSpy");
-        freeMessageResultService = new FreeMessageResultService();
-        freeMessageResultService.setProtocol(protocol);
-        freeMessageResultService.setDefaultListener(defaultListener);
-        freeMessageResultService.setResolutionCallbackForNode(node.id, resolutionCallback);
+        plainMessageResultService = new PlainMessageResultService();
+        plainMessageResultService.setProtocol(protocol);
+        plainMessageResultService.setDefaultListener(defaultListener);
+        plainMessageResultService.setResolutionCallbackForNode(node.id, resolutionCallback);
     });
 
     it("does nothing if receives a free message with an unknown protocol", () => {
         const messageEvent = buildFakeMessageEvent(node.id, unknownPath);
-        freeMessageResultService.onMessageReceived(messageEvent);
+        plainMessageResultService.onMessageReceived(messageEvent);
 
         expect(resolutionCallback).not.toHaveBeenCalled();
         expect(defaultListener).not.toHaveBeenCalled();
@@ -40,14 +40,14 @@ describe("Free message result service", () => {
 
     it("does nothing when receives a free message without data", () => {
         const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse);
-        freeMessageResultService.onMessageReceived(messageEvent);
+        plainMessageResultService.onMessageReceived(messageEvent);
 
         expect(resolutionCallback).not.toHaveBeenCalled();
         expect(defaultListener).not.toHaveBeenCalled();
     });
 
     it("receives a free message in response to other message", () => {
-        const freeMessage: FreeMessage = {
+        const plainMessage: PlainMessage = {
             message: "Hi! :)",
             inResponseTo: {
                 message: "Hey :P"
@@ -55,18 +55,18 @@ describe("Free message result service", () => {
         };
         const expectedResponse: ReceivedMessage = {
             senderNodeId: node.id,
-            freeMessage
+            plainMessage
         };
 
-        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(freeMessage));
-        freeMessageResultService.onMessageReceived(messageEvent);
+        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(plainMessage));
+        plainMessageResultService.onMessageReceived(messageEvent);
 
         expect(resolutionCallback).toHaveBeenCalledWith(expectedResponse);
         expect(defaultListener).not.toHaveBeenCalled();
     });
 
     it("receives a free message in response to other message but there are no listeners to handle it", () => {
-        const freeMessage: FreeMessage = {
+        const plainMessage: PlainMessage = {
             message: "Hi! :)",
             inResponseTo: {
                 message: "Hey :P"
@@ -74,46 +74,46 @@ describe("Free message result service", () => {
         };
         const expectedResponse: ReceivedMessage = {
             senderNodeId: node.id,
-            freeMessage
+            plainMessage
         };
-        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(freeMessage));
-        (freeMessageResultService as any).resolutionCallbacks.delete(node.id);
-        freeMessageResultService.clearDefaultListener();
+        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(plainMessage));
+        (plainMessageResultService as any).resolutionCallbacks.delete(node.id);
+        plainMessageResultService.clearDefaultListener();
 
-        expect(() => { freeMessageResultService.onMessageReceived(messageEvent) })
+        expect(() => { plainMessageResultService.onMessageReceived(messageEvent) })
             .toThrow(new Error(`received message ${JSON.stringify(expectedResponse)} but there are no callbacks set`));
         expect(resolutionCallback).not.toHaveBeenCalled();
         expect(defaultListener).not.toHaveBeenCalled();
     });
 
     it("receives a wearable-triggered message", () => {
-        const freeMessage: FreeMessage = {
+        const plainMessage: PlainMessage = {
             message: "Hi! :)",
         };
         const expectedResponse: ReceivedMessage = {
             senderNodeId: node.id,
-            freeMessage
+            plainMessage
         };
 
-        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(freeMessage));
-        freeMessageResultService.onMessageReceived(messageEvent);
+        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(plainMessage));
+        plainMessageResultService.onMessageReceived(messageEvent);
         expect(resolutionCallback).not.toHaveBeenCalled();
         expect(defaultListener).toHaveBeenCalledWith(expectedResponse);
     });
 
     it("receives a wearable-triggered message but there are no listeners set", () => {
-        const freeMessage: FreeMessage = {
+        const plainMessage: PlainMessage = {
             message: "Hi! :)",
         };
         const expectedResponse: ReceivedMessage = {
             senderNodeId: node.id,
-            freeMessage
+            plainMessage
         };
 
-        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(freeMessage));
-        freeMessageResultService.clearDefaultListener();
+        const messageEvent = buildFakeMessageEvent(node.id, protocol.withoutResponse, JSON.stringify(plainMessage));
+        plainMessageResultService.clearDefaultListener();
 
-        expect(() => { freeMessageResultService.onMessageReceived(messageEvent) })
+        expect(() => { plainMessageResultService.onMessageReceived(messageEvent) })
             .toThrow(new Error(`received message ${JSON.stringify(expectedResponse)} but there are no callbacks set`));
         expect(resolutionCallback).not.toHaveBeenCalled();
         expect(defaultListener).not.toHaveBeenCalled();
diff --git a/src-native/app/src/main/AndroidManifest.xml b/src-native/app/src/main/AndroidManifest.xml
index 2e8a7ae..3c4e629 100644
--- a/src-native/app/src/main/AndroidManifest.xml
+++ b/src-native/app/src/main/AndroidManifest.xml
@@ -56,13 +56,13 @@
         </service>
 
         <service
-            android:name=".freemessage.WearosSensorsFreeMessageService"
+            android:name=".plainmessage.WearosSensorsPlainMessageService"
             android:exported="true">
             <intent-filter>
                 <action android:name="com.google.android.gms.wearable.MESSAGE_RECEIVED" />
                 <data
                     android:host="*"
-                    android:pathPattern="/free-message.*"
+                    android:pathPattern="/plain-message.*"
                     android:scheme="wear" />
             </intent-filter>
         </service>
diff --git a/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearService.java b/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearService.java
index 11aae6f..5added2 100644
--- a/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearService.java
+++ b/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearService.java
@@ -1,5 +1,5 @@
 package es.uji.geotec.wearossensors;
 
 public enum WearService {
-    CAPABILITY, COMMAND, FREE_MESSAGE
+    CAPABILITY, COMMAND, PLAIN_MESSAGE
 }
diff --git a/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearosService.java b/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearosService.java
index 95cfff1..1ba66d6 100644
--- a/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearosService.java
+++ b/src-native/app/src/main/java/es/uji/geotec/wearossensors/WearosService.java
@@ -1,7 +1,5 @@
 package es.uji.geotec.wearossensors;
 
-import android.util.Log;
-
 import com.google.android.gms.wearable.MessageEvent;
 import com.google.android.gms.wearable.WearableListenerService;
 
@@ -23,8 +21,8 @@ public void onMessageReceived(MessageEvent messageEvent) {
             handleMessage(WearService.CAPABILITY, messageEvent);
         } else if (path.contains("command")) {
             handleMessage(WearService.COMMAND, messageEvent);
-        } else if (path.contains("free-message")) {
-            handleMessage(WearService.FREE_MESSAGE, messageEvent);
+        } else if (path.contains("plain-message")) {
+            handleMessage(WearService.PLAIN_MESSAGE, messageEvent);
         }
     }
 
diff --git a/src-native/app/src/main/java/es/uji/geotec/wearossensors/freemessage/WearosSensorsFreeMessageService.java b/src-native/app/src/main/java/es/uji/geotec/wearossensors/freemessage/WearosSensorsFreeMessageService.java
deleted file mode 100644
index eb98e98..0000000
--- a/src-native/app/src/main/java/es/uji/geotec/wearossensors/freemessage/WearosSensorsFreeMessageService.java
+++ /dev/null
@@ -1,6 +0,0 @@
-package es.uji.geotec.wearossensors.freemessage;
-
-import es.uji.geotec.wearossensors.WearosService;
-
-public class WearosSensorsFreeMessageService extends WearosService {
-}
diff --git a/src-native/app/src/main/java/es/uji/geotec/wearossensors/plainmessage/WearosSensorsPlainMessageService.java b/src-native/app/src/main/java/es/uji/geotec/wearossensors/plainmessage/WearosSensorsPlainMessageService.java
new file mode 100644
index 0000000..ec0cbe8
--- /dev/null
+++ b/src-native/app/src/main/java/es/uji/geotec/wearossensors/plainmessage/WearosSensorsPlainMessageService.java
@@ -0,0 +1,6 @@
+package es.uji.geotec.wearossensors.plainmessage;
+
+import es.uji.geotec.wearossensors.WearosService;
+
+public class WearosSensorsPlainMessageService extends WearosService {
+}
diff --git a/src/free-message/index.ts b/src/free-message/index.ts
deleted file mode 100644
index 9c2ac37..0000000
--- a/src/free-message/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-export { getFreeMessageClient } from "../internal/communication/free-message";
-import {
-    FreeMessage as FM,
-    FreeMessageListener as FL,
-    ReceivedMessage as RM
-} from "../internal/communication/free-message";
-export type FreeMessage = FM;
-export type FreeMessageListener = FL;
-export type ReceivedMessage = RM;
-
-import { FreeMessageClient as FMC } from "../internal/communication/free-message/free-message-client";
-export type FreeMessageClient = FMC;
\ No newline at end of file
diff --git a/src/index.d.ts b/src/index.d.ts
index eb22f18..d2e8e12 100644
--- a/src/index.d.ts
+++ b/src/index.d.ts
@@ -3,4 +3,4 @@ export declare class WearosSensors extends Common {
     init(config?: WearosSensorsConfig): Promise<void>;
 }
 export declare const wearosSensors: WearosSensors;
-export { WearosSensorsConfig } from './wearos-sensors.common';
+export { WearosSensorsConfig, allSensors, defaultConfig } from './wearos-sensors.common';
diff --git a/src/internal/communication/free-message/android/free-message-client.android.ts b/src/internal/communication/free-message/android/free-message-client.android.ts
deleted file mode 100644
index 130154a..0000000
--- a/src/internal/communication/free-message/android/free-message-client.android.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { CommunicationClient } from "../../communication-client.android";
-import {
-    freeMessageProtocol,
-    FreeMessage,
-    ReceivedMessage,
-    FreeMessageListener,
-    areFreeMessagesEnabled
-} from "../index";
-import { FreeMessageClient } from "../free-message-client";
-import { Node } from "../../../node";
-import { getFreeMessageResultService } from "./free-message-result-service.android";
-import { encodeFreeMessage } from "../encoder-decoder";
-
-export class FreeMessageAndroidClient extends CommunicationClient<ReceivedMessage> implements FreeMessageClient {
-
-    constructor(
-        private protocol = freeMessageProtocol,
-        private freeMessageResultService = getFreeMessageResultService(),
-        private freeMessagesEnabled = areFreeMessagesEnabled()
-    ) {
-        super(freeMessageResultService);
-        freeMessageResultService.setProtocol(protocol);
-    }
-
-    public enabled(): boolean {
-        return this.freeMessagesEnabled;
-    }
-
-    public registerListener(listener: FreeMessageListener): void {
-        this.freeMessageResultService.setDefaultListener(listener);
-    }
-
-    public unregisterListener(): void {
-        this.freeMessageResultService.clearDefaultListener();
-    }
-
-    public async send(node: Node, freeMessage: FreeMessage): Promise<void> {
-        if (!this.enabled()) return;
-
-        const message = encodeFreeMessage(freeMessage);
-        await this.sendMessage(node, this.protocol.withoutResponse, message);
-    }
-
-    public async sendExpectingResponse(node: Node, freeMessage: FreeMessage, timeout: number = 5000): Promise<ReceivedMessage> {
-        if (!this.enabled()) return undefined;
-
-        const resolutionPromise = this.createResolutionPromise(
-            this.protocol,
-            node,
-            timeout
-        );
-
-        const message = encodeFreeMessage(freeMessage);
-        await this.sendMessage(node, this.protocol.expectingResponse, message);
-        return await resolutionPromise;
-    }
-}
-
-let _instance: FreeMessageClient;
-export function getFreeMessageAndroidClient(): FreeMessageClient {
-    if (!_instance) {
-        _instance = new FreeMessageAndroidClient();
-    }
-    return _instance;
-}
\ No newline at end of file
diff --git a/src/internal/communication/free-message/encoder-decoder.ts b/src/internal/communication/free-message/encoder-decoder.ts
deleted file mode 100644
index b9a5c95..0000000
--- a/src/internal/communication/free-message/encoder-decoder.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { FreeMessage } from "./index";
-
-// TODO: Might be to heavy (?)
-export function encodeFreeMessage(freeMessage: FreeMessage): string {
-    return JSON.stringify(freeMessage);
-}
-
-export function decodeFreeMessage(message: string): FreeMessage {
-    return JSON.parse(message);
-}
\ No newline at end of file
diff --git a/src/internal/communication/free-message/free-message-client.ts b/src/internal/communication/free-message/free-message-client.ts
deleted file mode 100644
index fdcac20..0000000
--- a/src/internal/communication/free-message/free-message-client.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { FreeMessage, FreeMessageListener, ReceivedMessage } from "./index";
-import { Node } from "../../node";
-
-export interface FreeMessageClient {
-    enabled(): boolean;
-    registerListener(listener: FreeMessageListener): void;
-    unregisterListener(): void;
-    send(node: Node, freeMessage: FreeMessage): Promise<void>;
-    sendExpectingResponse(node: Node, freeMessage: FreeMessage, timeout?: number): Promise<ReceivedMessage>;
-}
\ No newline at end of file
diff --git a/src/internal/communication/free-message/index.ts b/src/internal/communication/free-message/index.ts
deleted file mode 100644
index e1ec222..0000000
--- a/src/internal/communication/free-message/index.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { FreeMessageClient } from "./free-message-client";
-import { Application } from "@nativescript/core";
-import { getFreeMessageAndroidClient } from "./android/free-message-client.android";
-
-export function getFreeMessageClient(): FreeMessageClient {
-    if (Application.android) {
-        return getFreeMessageAndroidClient();
-    } else {
-        return null;
-    }
-}
-
-export interface FreeMessageProtocol {
-    withoutResponse: string;
-    expectingResponse: string;
-}
-
-export const freeMessageProtocol: FreeMessageProtocol = {
-    withoutResponse: "free-message-no-response",
-    expectingResponse: "free-message-expecting-response"
-};
-
-export interface FreeMessage {
-    message: string;
-    inResponseTo?: FreeMessage;
-}
-
-export interface ReceivedMessage {
-    senderNodeId: string;
-    freeMessage: FreeMessage;
-}
-
-export type FreeMessageListener = (receivedMessage: ReceivedMessage) => void;
-
-let _freeMessagesEnabled: boolean;
-export function setFreeMessagesEnabled(enabled: boolean): void {
-    _freeMessagesEnabled = enabled;
-}
-
-export function areFreeMessagesEnabled(): boolean {
-    return _freeMessagesEnabled;
-}
\ No newline at end of file
diff --git a/src/internal/communication/plain-message/android/plain-message-client.android.ts b/src/internal/communication/plain-message/android/plain-message-client.android.ts
new file mode 100644
index 0000000..6a8f1e3
--- /dev/null
+++ b/src/internal/communication/plain-message/android/plain-message-client.android.ts
@@ -0,0 +1,65 @@
+import { CommunicationClient } from "../../communication-client.android";
+import {
+    plainMessageProtocol,
+    PlainMessage,
+    ReceivedMessage,
+    PlainMessageListener,
+    arePlainMessagesEnabled
+} from "../index";
+import { PlainMessageClient } from "../plain-message-client";
+import { Node } from "../../../node";
+import { getPlainMessageResultService } from "./plain-message-result-service.android";
+import { encodePlainMessage } from "../encoder-decoder";
+
+export class PlainMessageAndroidClient extends CommunicationClient<ReceivedMessage> implements PlainMessageClient {
+
+    constructor(
+        private protocol = plainMessageProtocol,
+        private plainMessageResultService = getPlainMessageResultService(),
+        private plainMessagesEnabled = arePlainMessagesEnabled()
+    ) {
+        super(plainMessageResultService);
+        plainMessageResultService.setProtocol(protocol);
+    }
+
+    public enabled(): boolean {
+        return this.plainMessagesEnabled;
+    }
+
+    public registerListener(listener: PlainMessageListener): void {
+        this.plainMessageResultService.setDefaultListener(listener);
+    }
+
+    public unregisterListener(): void {
+        this.plainMessageResultService.clearDefaultListener();
+    }
+
+    public async send(node: Node, plainMessage: PlainMessage): Promise<void> {
+        if (!this.enabled()) return;
+
+        const message = encodePlainMessage(plainMessage);
+        await this.sendMessage(node, this.protocol.withoutResponse, message);
+    }
+
+    public async sendExpectingResponse(node: Node, plainMessage: PlainMessage, timeout: number = 5000): Promise<ReceivedMessage> {
+        if (!this.enabled()) return undefined;
+
+        const resolutionPromise = this.createResolutionPromise(
+            this.protocol,
+            node,
+            timeout
+        );
+
+        const message = encodePlainMessage(plainMessage);
+        await this.sendMessage(node, this.protocol.expectingResponse, message);
+        return await resolutionPromise;
+    }
+}
+
+let _instance: PlainMessageClient;
+export function getPlainMessageAndroidClient(): PlainMessageClient {
+    if (!_instance) {
+        _instance = new PlainMessageAndroidClient();
+    }
+    return _instance;
+}
\ No newline at end of file
diff --git a/src/internal/communication/free-message/android/free-message-result-service.android.ts b/src/internal/communication/plain-message/android/plain-message-result-service.android.ts
similarity index 62%
rename from src/internal/communication/free-message/android/free-message-result-service.android.ts
rename to src/internal/communication/plain-message/android/plain-message-result-service.android.ts
index 88f8420..84dec5a 100644
--- a/src/internal/communication/free-message/android/free-message-result-service.android.ts
+++ b/src/internal/communication/plain-message/android/plain-message-result-service.android.ts
@@ -1,26 +1,26 @@
 import { CommunicationResultService } from "../../communication-result-service";
 import WearableListenerServiceDelegate = es.uji.geotec.wearossensors.WearableListenerServiceDelegate;
-import { FreeMessage, FreeMessageListener, freeMessageProtocol, FreeMessageProtocol, ReceivedMessage } from "../index";
+import { PlainMessage, PlainMessageListener, plainMessageProtocol, PlainMessageProtocol, ReceivedMessage } from "../index";
 import { CommunicationProtocol } from "../../communication-protocol";
 import { wearOS } from "../../../utils/android/wear-os-types.android";
 import { decodeMessage } from "../../encoder-decoder";
-import { decodeFreeMessage } from "../encoder-decoder";
+import { decodePlainMessage } from "../encoder-decoder";
 
-export class FreeMessageResultService implements CommunicationResultService, WearableListenerServiceDelegate {
+export class PlainMessageResultService implements CommunicationResultService, WearableListenerServiceDelegate {
 
-    private protocol: FreeMessageProtocol = freeMessageProtocol;
-    private resolutionCallbacks = new Map<string, FreeMessageListener>();
-    private defaultListener: FreeMessageListener;
+    private protocol: PlainMessageProtocol = plainMessageProtocol;
+    private resolutionCallbacks = new Map<string, PlainMessageListener>();
+    private defaultListener: PlainMessageListener;
 
     setProtocol(protocol: CommunicationProtocol): void {
-        this.protocol = protocol as FreeMessageProtocol;
+        this.protocol = protocol as PlainMessageProtocol;
     }
 
-    setResolutionCallbackForNode(nodeId: string, callback: (freeMessage) => void): void {
+    setResolutionCallbackForNode(nodeId: string, callback: (plainMessage) => void): void {
         this.resolutionCallbacks.set(nodeId, callback);
     }
 
-    setDefaultListener(listener: FreeMessageListener): void {
+    setDefaultListener(listener: PlainMessageListener): void {
         this.defaultListener = listener;
     }
 
@@ -42,13 +42,13 @@ export class FreeMessageResultService implements CommunicationResultService, Wea
         }
 
         const stringMessage: string = decodeMessage(message.getData());
-        const freeMessage: FreeMessage = decodeFreeMessage(stringMessage);
+        const plainMessage: PlainMessage = decodePlainMessage(stringMessage);
         const receivedMessage: ReceivedMessage = {
             senderNodeId,
-            freeMessage
+            plainMessage
         };
 
-        if (freeMessage.inResponseTo && this.resolutionCallbacks.has(senderNodeId)) {
+        if (plainMessage.inResponseTo && this.resolutionCallbacks.has(senderNodeId)) {
             const callback = this.resolutionCallbacks.get(senderNodeId);
             callback(receivedMessage);
             this.resolutionCallbacks.delete(senderNodeId);
@@ -64,9 +64,9 @@ export class FreeMessageResultService implements CommunicationResultService, Wea
 }
 
 let _instance;
-export function getFreeMessageResultService(): FreeMessageResultService {
+export function getPlainMessageResultService(): PlainMessageResultService {
     if (!_instance) {
-        _instance = new FreeMessageResultService();
+        _instance = new PlainMessageResultService();
     }
     return _instance;
 }
\ No newline at end of file
diff --git a/src/internal/communication/plain-message/encoder-decoder.ts b/src/internal/communication/plain-message/encoder-decoder.ts
new file mode 100644
index 0000000..7bc3d51
--- /dev/null
+++ b/src/internal/communication/plain-message/encoder-decoder.ts
@@ -0,0 +1,10 @@
+import { PlainMessage } from "./index";
+
+// TODO: Might be to heavy (?)
+export function encodePlainMessage(plainMessage: PlainMessage): string {
+    return JSON.stringify(plainMessage);
+}
+
+export function decodePlainMessage(message: string): PlainMessage {
+    return JSON.parse(message);
+}
\ No newline at end of file
diff --git a/src/internal/communication/plain-message/index.ts b/src/internal/communication/plain-message/index.ts
new file mode 100644
index 0000000..4bbfd65
--- /dev/null
+++ b/src/internal/communication/plain-message/index.ts
@@ -0,0 +1,42 @@
+import { PlainMessageClient } from "./plain-message-client";
+import { Application } from "@nativescript/core";
+import { getPlainMessageAndroidClient } from "./android/plain-message-client.android";
+
+export function getPlainMessageClient(): PlainMessageClient {
+    if (Application.android) {
+        return getPlainMessageAndroidClient();
+    } else {
+        return null;
+    }
+}
+
+export interface PlainMessageProtocol {
+    withoutResponse: string;
+    expectingResponse: string;
+}
+
+export const plainMessageProtocol: PlainMessageProtocol = {
+    withoutResponse: "plain-message-no-response",
+    expectingResponse: "plain-message-expecting-response"
+};
+
+export interface PlainMessage {
+    message: string;
+    inResponseTo?: PlainMessage;
+}
+
+export interface ReceivedMessage {
+    senderNodeId: string;
+    plainMessage: PlainMessage;
+}
+
+export type PlainMessageListener = (receivedMessage: ReceivedMessage) => void;
+
+let _plainMessagesEnabled: boolean;
+export function setPlainMessagesEnabled(enabled: boolean): void {
+    _plainMessagesEnabled = enabled;
+}
+
+export function arePlainMessagesEnabled(): boolean {
+    return _plainMessagesEnabled;
+}
\ No newline at end of file
diff --git a/src/internal/communication/plain-message/plain-message-client.ts b/src/internal/communication/plain-message/plain-message-client.ts
new file mode 100644
index 0000000..050103a
--- /dev/null
+++ b/src/internal/communication/plain-message/plain-message-client.ts
@@ -0,0 +1,10 @@
+import { PlainMessage, PlainMessageListener, ReceivedMessage } from "./index";
+import { Node } from "../../node";
+
+export interface PlainMessageClient {
+    enabled(): boolean;
+    registerListener(listener: PlainMessageListener): void;
+    unregisterListener(): void;
+    send(node: Node, plainMessage: PlainMessage): Promise<void>;
+    sendExpectingResponse(node: Node, plainMessage: PlainMessage, timeout?: number): Promise<ReceivedMessage>;
+}
\ No newline at end of file
diff --git a/src/plain-message/index.ts b/src/plain-message/index.ts
new file mode 100644
index 0000000..a8a3b2f
--- /dev/null
+++ b/src/plain-message/index.ts
@@ -0,0 +1,12 @@
+export { getPlainMessageClient } from "../internal/communication/plain-message";
+import {
+    PlainMessage as FM,
+    PlainMessageListener as FL,
+    ReceivedMessage as RM
+} from "../internal/communication/plain-message";
+export type PlainMessage = FM;
+export type PlainMessageListener = FL;
+export type ReceivedMessage = RM;
+
+import { PlainMessageClient as FMC } from "../internal/communication/plain-message/plain-message-client";
+export type PlainMessageClient = FMC;
\ No newline at end of file
diff --git a/src/platforms/android/wearossensors-native.aar b/src/platforms/android/wearossensors-native.aar
index ad7d0f0..3613766 100644
Binary files a/src/platforms/android/wearossensors-native.aar and b/src/platforms/android/wearossensors-native.aar differ
diff --git a/src/typings/native-lib.d.ts b/src/typings/native-lib.d.ts
index 439a7ce..02ff4f0 100644
--- a/src/typings/native-lib.d.ts
+++ b/src/typings/native-lib.d.ts
@@ -57,7 +57,7 @@ declare namespace es {
 					public static class: java.lang.Class<es.uji.geotec.wearossensors.WearService>;
 					public static CAPABILITY: es.uji.geotec.wearossensors.WearService;
 					public static COMMAND: es.uji.geotec.wearossensors.WearService;
-					public static FREE_MESSAGE: es.uji.geotec.wearossensors.WearService;
+					public static PLAIN_MESSAGE: es.uji.geotec.wearossensors.WearService;
 					public static values(): androidNative.Array<es.uji.geotec.wearossensors.WearService>;
 					public static valueOf(param0: string): es.uji.geotec.wearossensors.WearService;
 				}
@@ -135,9 +135,9 @@ declare namespace es {
 	export namespace uji {
 		export namespace geotec {
 			export namespace wearossensors {
-				export namespace freemessage {
-					export class WearosSensorsFreeMessageService extends es.uji.geotec.wearossensors.WearosService {
-						public static class: java.lang.Class<es.uji.geotec.wearossensors.freemessage.WearosSensorsFreeMessageService>;
+				export namespace plainmessage {
+					export class WearosSensorsPlainMessageService extends es.uji.geotec.wearossensors.WearosService {
+						public static class: java.lang.Class<es.uji.geotec.wearossensors.plainmessage.WearosSensorsPlainMessageService>;
 						public constructor();
 					}
 				}
diff --git a/src/wearos-sensors.android.ts b/src/wearos-sensors.android.ts
index c5f6e33..0b890c2 100644
--- a/src/wearos-sensors.android.ts
+++ b/src/wearos-sensors.android.ts
@@ -4,19 +4,19 @@ import { getCapabilityAdvertiserResultService } from "./internal/communication/c
 import { getResultMessagingService } from "./internal/communication/messaging/android/messaging-result-service.android";
 import { getSensorRecordService } from "./internal/sensors/records-service";
 import { getCommandService } from "./internal/communication/command/command-service.android";
-import { getFreeMessageResultService } from "./internal/communication/free-message/android/free-message-result-service.android";
+import { getPlainMessageResultService } from "./internal/communication/plain-message/android/plain-message-result-service.android";
 
 import { SensorType } from "./internal/sensors/sensor-type";
 
 import { setEnabledSensors } from "./internal/collection/enabled-sensors";
-import { setFreeMessagesEnabled } from "./internal/communication/free-message";
+import { setPlainMessagesEnabled } from "./internal/communication/plain-message";
 
 import WearosSensorsCapabilityAdvertiserService = es.uji.geotec.wearossensors.capability.WearosSensorsCapabilityAdvertiserService;
 import WearableListenerServiceDelegate = es.uji.geotec.wearossensors.WearableListenerServiceDelegate;
 import WearosSensorsResultsMessagingService = es.uji.geotec.wearossensors.sensors.WearosSensorsResultsMessagingService;
 import WearosSensorsRecordsMessagingService = es.uji.geotec.wearossensors.sensors.WearosSensorsRecordsMessagingService;
 import WearosSensorsCommandService = es.uji.geotec.wearossensors.command.WearosSensorsCommandService;
-import WearosSensorsFreeMessageService = es.uji.geotec.wearossensors.freemessage.WearosSensorsFreeMessageService;
+import WearosSensorsPlainMessageService = es.uji.geotec.wearossensors.plainmessage.WearosSensorsPlainMessageService;
 import WearSensor = es.uji.geotec.wearossensors.WearSensor;
 import WearService = es.uji.geotec.wearossensors.WearService;
 
@@ -33,9 +33,9 @@ class WearosSensors extends Common {
             this.wireUpCommandService();
         }
 
-        setFreeMessagesEnabled(!config.disableFreeMessaging);
-        if (!config.disableFreeMessaging) {
-            this.wireUpFreeMessageService();
+        setPlainMessagesEnabled(!config.disablePlainMessaging);
+        if (!config.disablePlainMessaging) {
+            this.wireUpPlainMessageService();
         }
     }
 
@@ -78,12 +78,12 @@ class WearosSensors extends Common {
         );
     }
 
-    private wireUpFreeMessageService(): void {
-        WearosSensorsFreeMessageService.setServiceDelegate(
-            WearService.FREE_MESSAGE,
+    private wireUpPlainMessageService(): void {
+        WearosSensorsPlainMessageService.setServiceDelegate(
+            WearService.PLAIN_MESSAGE,
             new WearableListenerServiceDelegate({
                 onMessageReceived: (messageEvent) =>
-                    getFreeMessageResultService().onMessageReceived(messageEvent)
+                    getPlainMessageResultService().onMessageReceived(messageEvent)
             })
         );
     }
diff --git a/src/wearos-sensors.common.ts b/src/wearos-sensors.common.ts
index b6e150b..e12ac0f 100644
--- a/src/wearos-sensors.common.ts
+++ b/src/wearos-sensors.common.ts
@@ -17,7 +17,7 @@ export const allSensors = [
 
 export interface WearosSensorsConfig {
   sensors?: SensorType[];
-  disableFreeMessaging?: boolean;
+  disablePlainMessaging?: boolean;
   disableWearCommands?: boolean;
 }