{"id":33156871,"url":"https://github.com/GeoTecINIT/nativescript-wearos-sensors","last_synced_at":"2025-11-30T05:01:40.849Z","repository":{"id":98078159,"uuid":"361671550","full_name":"GeoTecINIT/nativescript-wearos-sensors","owner":"GeoTecINIT","description":"Plugin to develop smartphone apps that receive sensors' data from a paired WearOS smartwatch.","archived":false,"fork":false,"pushed_at":"2025-02-13T10:42:41.000Z","size":2555,"stargazers_count":4,"open_issues_count":0,"forks_count":1,"subscribers_count":5,"default_branch":"master","last_synced_at":"2025-10-11T04:56:17.734Z","etag":null,"topics":["nativescript-plugin","sensors"],"latest_commit_sha":null,"homepage":"","language":"TypeScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/GeoTecINIT.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2021-04-26T08:18:52.000Z","updated_at":"2025-02-13T10:37:13.000Z","dependencies_parsed_at":"2025-02-13T11:38:35.301Z","dependency_job_id":null,"html_url":"https://github.com/GeoTecINIT/nativescript-wearos-sensors","commit_stats":{"total_commits":256,"total_committers":1,"mean_commits":256.0,"dds":0.0,"last_synced_commit":"39e7fadbda9b7f7ac1b20a48766dd92395aae191"},"previous_names":[],"tags_count":3,"template":false,"template_full_name":null,"purl":"pkg:github/GeoTecINIT/nativescript-wearos-sensors","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/GeoTecINIT%2Fnativescript-wearos-sensors","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/GeoTecINIT%2Fnativescript-wearos-sensors/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/GeoTecINIT%2Fnativescript-wearos-sensors/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/GeoTecINIT%2Fnativescript-wearos-sensors/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/GeoTecINIT","download_url":"https://codeload.github.com/GeoTecINIT/nativescript-wearos-sensors/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/GeoTecINIT%2Fnativescript-wearos-sensors/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":27377901,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-11-30T02:00:05.582Z","response_time":55,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["nativescript-plugin","sensors"],"created_at":"2025-11-15T20:00:36.804Z","updated_at":"2025-11-30T05:01:40.842Z","avatar_url":"https://github.com/GeoTecINIT.png","language":"TypeScript","funding_links":[],"categories":["Plugins"],"sub_categories":["Utility Plugins"],"readme":"# nativescript-wearos-sensors\n[![npm](https://img.shields.io/npm/v/nativescript-wearos-sensors.svg)](https://www.npmjs.com/package/nativescript-wearos-sensors)\n[![npm](https://img.shields.io/npm/dm/nativescript-wearos-sensors.svg)](https://www.npmjs.com/package/nativescript-wearos-sensors)\n\nThe _nativescript-wearos-sensors_ is a plugin developed with the\n[`NativeScript`](https://nativescript.org) framework. It allows to develop smartphone applications for collecting \ndata from the IMU sensors (i.e., accelerometer and gyroscope), the magnetometer, the heart rate and the GPS of a paired\nAndroid WearOS smartwatch (if the corresponding sensor is available in the device).\n\nThe Android WearOS smartwatch must run a counterpart application built using the native [_WearOS Sensors_](https://github.com/GeoTecINIT/WearOSSensors) library.\nThen, the smartphone application can request the smartwatch to start/stop the collection of the specified sensor, and\nthe smartwatch will send the collected samples to the smartphone application.\n\n\u003e [!WARNING] \n\u003e An application using this plugin is completely useless if there is not a counterpart application\n\u003e build with the _WearOS Sensors_ library installed in the paired smartwatch. In other words, the smartphone can not\n\u003e work by itself alone. It requires a smartwatch to work.\n\nThe data collection can be started both from the smartphone and from the paired smartwatch. In addition. the plugin offers\na way to communicate with the smartwatch by sending messages.\n\n## Installation\nRun the following command in your project's root folder.\n\n```bash\nns plugin add nativescript-wearos-sensors\n```\n\n## Requirements\nThis plugin is **only supported** by Android smartphones. To use it to build an application, the following requirements apply:\n\n- An Android smartphone running Android 6 (API level 23) or higher.\n- In addition, the smartphone must be paired with a smartwatch with the counterpart application installed. To link a smartwatch \n to the smartphone, you must also install the [Smartwatch WearOS by Google](https://play.google.com/store/apps/details?id=com.google.android.wearable.app) or the specific application provided \n by the smartwatch manufacturer (e.g., Mobvoi Health, Samsung Wearable, etc.) and follow the procedure to link both devices.\n\n\u003e [!IMPORTANT] \n\u003e Both applications (smartphone and smartwatch apps) must have the same application id.\n\u003e If that's not the case, the applications will not be able to interact. You can change the application id of a \n\u003e NativeScript application in the `nativescript.config.ts`.\n\n## Usage \nThe plugin offers two features:\n\n- [Sensor data collection](#sensor-data-collection) from the paired smartwatch: it can be started/stopped from the smartphone and from the smartwatch.\n  The smartwatch is able to start and stop the data collection thanks to the WearCommands feature.\n- [Plain Messaging](#plainmessaging): it allows to send and receive simple messages between both devices.\n\nIn first place, you need to initialize the plugin with a [`WearosSensorsConfig`](#wearossensorsconfig) in your app.ts (TypeScript app) or main.ts (Angular app) file:\n\n```typescript\n// TypeScript App:\nimport { Application } from \"@nativescript/core\";\n// or Angular App:\nimport { platformNativeScriptDynamic } from \"nativescript-angular/platform\";\nimport { AppModule } from \"./app/app.module\";\n\n// WearOSSensors import\nimport { wearosSensors, allSensors } from \"nativescript-wearos-sensors\";\n\nwearosSensors.init({\n    sensors: allSensors,\n    disablePlainMessaging: false,\n    disableWearCommands: false\n});\n\n// TypeScript App:\nApplication.run({ moduleName: \"app-root\" });\n// Angular App:\nplatformNativeScriptDynamic().bootstrapModule(AppModule);\n```\n\nThe initialization parameter is optional, and it allows specifying which sensors are enabled (`sensors`), and if PlainMessaging\n(`disablePlainMessaging`) and WearCommands (`disableWearCommands`) features are enabled. The default configuration is\nthe one shown in the example above: all sensors and features enabled.\n\n\u003e [!NOTE] \n\u003e The configuration allows to conditionally wire up native components with the core of the plugin. This allows\n\u003e to reduce the memory used by the application when some features are not going to be used.\n\n### Sensor data collection\nAs stated above, the data collection can be started/stopped by both devices, but only the smartphone has access to\nthe collected data. \n\nTo receive the collected data, the smartphone has to register a listener (at least one) via the\n[`CollectorManager`](#collectormanager). A listener can be set up for a specific node/s (i.e., smartwatch) and a specific sensor/s. This means\nthat there can be several listeners registered, all of them listening for different nodes or sensors. This behaviour can be\nachieved using `ListenerFilters`. Here's an example of registering different listeners:\n\n```typescript\nimport { getCollectorManager } from \"nativescript-wearos-sensors/collection\";\nimport { SensorRecord } from \"nativescript-wearos-sensors/sensors/records\";\nimport { Node } from \"nativescript-wearos-sensors/node\";\nimport { ListenerFilter } from \"nativescript-wearos-sensors/listeners\";\nimport { SensorType } from \"nativescript-wearos-sensors/sensors\";\n\n\nfunction registerGlobalListener() {\n    // Register a listener witout filters --\u003e receives records from all sources\n    getCollectorManager().addSensorListener((sensorRecord: SensorRecord\u003cany\u003e) =\u003e {\n        console.log(deviceId, JSON.stringify(sensorRecord));\n    });\n}\n\nfunction registerListenerForNode(node: Node) {\n    // Register a listener filtering per node --\u003e receives all kind of records from that node\n    const filter: ListenerFilter = {\n        nodes: [node]\n    }\n    getCollectorManager().addSensorListener((sensorRecord: SensorRecord\u003cany\u003e) =\u003e {\n        console.log(deviceId, JSON.stringify(sensorRecord));\n    }, filter);\n}\n\nfunction registerListenerForSensor(sensor: SensorType) {\n    // Register a listener filtering per sensor --\u003e receives records of that sensor from any node\n    const filter: ListenerFilter = {\n        sensors: [sensor]\n    }\n    getCollectorManager().addSensorListener((sensorRecord: SensorRecord\u003cany\u003e) =\u003e {\n        console.log(deviceId, JSON.stringify(sensorRecord));\n    }, filter);\n}\n\nfunction registerListenerForNodeAndSensors(node: Node, sensors: SensorType[]) {\n    // Register a listener filtering per node and sensor --\u003e receives records of that sensors from that node\n    const filter: ListenerFilter = {\n        nodes: [node],\n        sensors: sensors\n    }\n    getCollectorManager().addSensorListener((sensorRecord: SensorRecord\u003cany\u003e) =\u003e {\n        console.log(deviceId, JSON.stringify(sensorRecord));\n    }, filter);\n}\n```\n\n#### Start/stop data collection from smartphone\nIn order to start the data collection for node, first you have to get the connected nodes using the [`NodeDiscoverer`](#nodediscoverer).\nThen, once you have the connected node, you have to follow some steps to start the data collection:\n\n1. Check if a specific sensor on the node is ready to be collected from.\n2. If it is not ready:\n   1. It is because the sensor is not present in the device.\n   2. The sensor is in the device, but the smartwatch app has no permissions to collect from that sensor.\n3. If we lack of permissions, we can just ask the user to grant them.\n   1. If permissions are rejected, it's the end of the way...\n   2. If permissions are granted, we can start the collection!!\n\nTo start the data collection, we also should specify a `CollectionConfiguration`, where we can indicate the desired\ntime between consecutive samples (`sensorDelay`), and the amount of samples to deliver each time (`batchSize`). The \nconfiguration is optional, if no configuration is provided then default values apply.\n\n\u003e [!NOTE]\n\u003e Due to the smartwatch has to send the collected data via Bluetooth, we can't send individual samples when working\n\u003e with a high sampling rate. That would saturate the connection. To solve this problem, we send the samples in batches.\n   \nHere is an example of this collection procedure:\n\n```typescript\nimport { getNodeDiscoverer } from \"nativescript-wearos-sensors/node\";\nimport { getCollectorManager, PrepareError, CollectionConfiguration } from \"nativescript-wearos-sensors/collection\";\nimport { Node } from \"nativescript-wearos-sensors/node\";\nimport { SensorType } from \"nativescript-wearos-sensors/sensors\";\n\nasync function getNodes(): Promise\u003cNode[]\u003e {\n    await nodesDiscovered = nodeDiscoverer.getConnectedNodes();\n    const nodes = []\n    nodesDiscovered.forEach((nodeDiscovered) =\u003e {\n        if (nodeDiscovered.error) {\n            this.logger.logResult(nodeDiscovered.error);\n            return;\n        }\n        nodes.push(nodeDiscovered.node);\n    });\n    return nodes;\n}\n\nasync function collectFrom(node: Node, sensor: SensorType, config: CollectionConfiguration) {\n    const collectorManager = getCollectorManager();\n    \n    const isReady = await collectorManager.isReady(node, sensor);\n    if (!isReady) {\n        const prepareError: PrepareError = await collectorManager.prepare(node, sensor);\n        if (prepareError) {\n            console.log(prepareError.message);\n            return;\n        }\n    }\n    \n    await collectorManager.startCollecting(node, sensor, config);\n}\n\nasync function stopCollecingFrom(node: Node, sensor: SensorType) {\n    await collectorManager.stopCollecting(node, sensor);\n}\n```\n\n#### Start/stop data collection from smartwatch\nThe plugin fully handles this for you. You only have to make sure to register at least a listener to receive\nthe collected data.\n\n\u003e [!IMPORTANT] \n\u003e The WearCommands feature must be enabled at plugin initialization.\n\n\n### PlainMessaging\nWith a system composed by several devices, it is important to have a way to communicate. We provide the \n[`PlainMessageClient`](#plainmessageclient), which allows to send and\nreceive string based messages. There are two types of received messages: the ones which require a response and the\nones which don't. Here's an example on how to use the messaging feature:\n\n```typescript\nimport { getPlainMessageClient } from \"src/internal/communication/plain-message\";\n\nfunction registerListener(): void {\n    // Register a listener to receive messages from the smartwatch\n    getPlainMessageClient().registerListener((receivedMessage) =\u003e {\n        console.log(`received single message ${JSON.stringify(receivedMessage)}`);\n    });\n}\n\nasync function sendMessage(node: Node, message: string): void {\n    // Send a message to the smartwatch\n    const plainMessage = {message: \"You don't have to reply :)\"};\n    await getPlainMessageClient().send(node, plainMessage);\n}\n\nasync function sendMessageAndWaitResponse(node: Node, message: string): void {\n    // Send a message to the smartwatch and wait for a response\n    const plainMessage = {message: \"PING!\"};\n    const receivedMessage = await getPlainMessageClient().sendExpectingResponse(node, plainMessage);\n    console.log(`response received: ${JSON.stringify(receivedMessage)}`);\n}\n```\n\n\u003e [!IMPORTANT] \n\u003e The PlainMessaging feature must be enabled at plugin initialization.\n\n## API\n\n### wearosSensors - Methods\n\n| Name                                 | Return type     | Description                                                                                                                           |\n|--------------------------------------|-----------------|---------------------------------------------------------------------------------------------------------------------------------------|\n| `init(config?: WearosSensorsConfig)` | `Promise\u003cvoid\u003e` | Initializes the native components depending on the provided configuration. If no configuration provided, defaults to `defaultConfig`. |\n\n#### [`WearosSensorsConfig`](src/wearos-sensors.common.ts)\n\n| Property                 | Type           | Description                                              |\n|--------------------------|----------------|----------------------------------------------------------|\n| `sensors?`               | `SensorType[]` | Sensors that are going to be used. Default: all sensors. |\n| `disablePlainMessaging?` | `boolean`      | Disable plain messaging feature. Default: false.         |\n| `disableWearCommands?`   | `boolean`      | Disable wear commands feature. Default: false.           |\n\n##### `defaultConfig`\n\n```typescript\nexport const defaultConfig = {\n    sensors: allSensors, // Constant containing all the sensors\n    disablePlainMessaging: false,\n    disableWearCommands: false\n};\n```\n\n### [`NodeDiscoverer`](src/internal/node/discoverer/node-discoverer.android.ts)\n\n| Function                                    | Return type                | Description                                                                                                                                                        |\n|---------------------------------------------|----------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `getLocalNode()`                            | `Promise\u003cNode\u003e`            | Get a reference to the local node (smartphone).                                                                                                                    |\n| `areConnectedNodes()`                       | `Promise\u003cboolean\u003e`         | Returns true if there are connected nodes.                                                                                                                         |\n| `getConnectedNodes(timeout: number = 5000)` | `Promise\u003cNodeDiscovered[]` | Get the currently connected nodes and their available sensors. Timeout indicates the maximum wait time for the connected nodes to communicate with the smartphone. |\n\n#### [`Node`](src/internal/node/index.ts)\n\n| Field          | Type           | Description                               |\n|----------------|----------------|-------------------------------------------|\n| `name`         | `string`       | Name of the device.                       |\n| `id`           | `string`       | Id number of the device.                  |\n| `capabilities` | `SensorType[]` | Sensors that are available on the device. |\n\n\n#### [`NodeDiscovered`](src/internal/node/discoverer/node-discoverer.ts)\n\n| Field    | Type   | Description                                                                                                     |\n|----------|--------|-----------------------------------------------------------------------------------------------------------------|\n| `node`   | `Node` | Reference to a Node.                                                                                            |\n| `error?` | `any`  | An error message. Present if the Node was not able to communicate with the smartphone in the specified timeout. |\n\n\n### [`SensorType`](src/internal/sensors/sensor-type.ts)\n\n| Value           | Description                          |\n|-----------------|--------------------------------------|\n| `ACCELEROMETER` | Represents the accelerometer sensor. |\n| `GYROSCOPE`     | Represents the gyroscope sensor.     |\n| `MAGNETOMETER`  | Represents the magnetometer sensor.  |\n| `HEART_RATE`    | Represents the heart rate sensor.    |\n| `LOCATION`      | Represents the GPS sensor.           |\n\n\n### [`CollectorManager`](src/internal/collection/android/collector-manager-impl.android.ts)\n\n| Method                                                                             | Return type             | Description                                                                                                                                                            |\n|------------------------------------------------------------------------------------|-------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| `isEnabled(sensor: SensorType)`                                                    | `boolean`               | Returns true if the sensor type is enabled in the initial configuration.                                                                                               |\n| `isReady(node: Node, sensor: SensorType)`                                          | `Promise\u003cboolean\u003e`      | Return true if the sensor is ready to collect data from.                                                                                                               |\n| `prepare(node: Node, sensor: SensorType)`                                          | `Promise\u003cPrepareError\u003e` | Returns a `PrepareError` if anything failed in the preparation (e.g., sensor unavailable, no permissions, etc). Returns `undefined` if the preparation was successful. |\n| `startCollecting(node: Node, sensor: SensorType, config?: CollectionConfiguration` | `Promise\u003cvoid\u003e`         | Starts the data collection of a sensor in a node with the specified configuration.                                                                                     |\n| `stopCollecting(node: Node, sensor: SensorType)`                                   | `Promise\u003cvoid\u003e`         | Stops the data collection of a sensor in a node.                                                                                                                       |\n| `addSensorListener(listener: SensorListener, filters?: ListenerFilter)`            | `number`                | Adds a listener with the specified filters and returns a listener identifier.                                                                                          |\n| `removeSensorListener(listenerId?: number)`                                        | `void`                  | Removes the listener specified by the `listenerId`. If not provided, removes all listeners.                                                                            |\n\n#### `PrepareError`\n\n| Property  | Type     | Description                                              |\n|-----------|----------|----------------------------------------------------------|\n| `node`    | `Node`   | Reference to the Node where the PrepareError comes from. |\n| `message` | `string` | Message describing the error.                            |\n\n#### `CollectionConfiguration`\n\n| Property         | Type             | Description                                                                                       |\n|------------------|------------------|---------------------------------------------------------------------------------------------------|\n| `sensorInterval` | `SensorInterval` | Time between each consecutive sample. Can be a `NativeSensorInterval` or a value in milliseconds. |\n| `batchSize`      | `number`         | Amount of samples to be sent in each record.                                                      |\n\n\n#### `SensorListener`\n\n`(sensorRecord: SensorRecord\u003cany\u003e) =\u003e void`\n\n#### `ListenerFilter`\n\n| Property   | Type           | Description                                     |\n|------------|----------------|-------------------------------------------------|\n| `nodes?`   | `Node[]`       | For which nodes the related listener applies.   |\n| `sensors?` | `SensorType[]` | For which sensors the related listener applies. |\n\n\u003e [!TIP]\n\u003e Filter works as follows:\n\u003e ```typescript\n\u003e { \n\u003e   nodes: [node1, /* OR */ node2]\n\u003e   // AND\n\u003e   sensors: [SensorType.ACCELEROMETER, /* OR */ SensorType.GYROSCOPE]\n\u003e }\n\u003e ```\n\n### [`SensorRecord`](src/internal/sensors/sensor-record.ts)\n\n| Property   | Type         | Description                                                                                            |\n|------------|--------------|--------------------------------------------------------------------------------------------------------|\n| `type`     | `SensorType` | Type of the collected data.                                                                            |\n| `deviceId` | `string`     | Id of the device where the collected data comes from.                                                  |\n| `samples`  | `T[]`        | List of samples, where T is `TriAxialSensorSample`, `HeartRateSensorSample`, or `LocationSensorSample` |\n\n#### [`TriAxialSensorSample`](src/internal/sensors/triaxial/sample.ts)\n\n| Property  | Type      | Description    |\n|-----------|-----------|----------------|\n| `x`       | `number`  | Component _x_. |\n| `y`       | `number`  | Component _y_. |\n| `z`       | `number`  | Component _z_. |\n\n\n#### [`HeartRateSensorSample`](src/internal/sensors/heart-rate/sample.ts)\n\n| Property | Type      | Description       |\n|----------|-----------|-------------------|\n| `value`  | `number`  | Heart rate value. |\n\n\n#### [`LocationSensorSample`](src/internal/sensors/location/sample.ts)\n\n| Property             | Type     | Description                                                  |\n|----------------------|----------|--------------------------------------------------------------|\n| `latitude`           | `number` | Latitude coordinate component.                               |\n| `longitude`          | `number` | Longitude coordinate component.                              |\n| `altitude`           | `number` | Altitude coordinate component.                               |\n| `verticalAccuracy`   | `number` | Estimated error in the latitude.                             |\n| `horizontalAccuracy` | `number` | Estimated error in the longitude.                            |\n| `speed`              | `number` | Estimated device's speed when the location was acquired.     |\n| `direction`          | `number` | Estimated device's direction when the location was acquired. |\n\n\n### [`PlainMessageClient`](src/internal/communication/plain-message/android/plain-message-client.android.ts)\n\n| Function                                                                          | Return type                | Description                                                                        |\n|-----------------------------------------------------------------------------------|----------------------------|------------------------------------------------------------------------------------|\n| `enabled()`                                                                       | `boolean`                  | Returns true if the plain message feature is enabled in the initial configuration. |\n| `registerListener(listener: PlainMessageListener)`                                | `void`                     | Registers the listener for the feature.                                            |\n| `unregisterListener()`                                                            | `void`                     | Unregisters the listener for the feature.                                          |\n| `send(node: Node, plainMessage: PlainMessage)`                                    | `Promise\u003cvoid\u003e`            | Sends a message to the specified Node.                                             |\n| `sendExpectingResponse(node: Node, plainMessage: PlainMessage, timeout?: number)` | `Promise\u003cReceivedMessage\u003e` | Sends a message to the specified Node and wait `timeout` ms for a response.        |\n\n#### `PlainMessage`\n\n| Property        | Type           | Description                                                                                                                             |\n|-----------------|----------------|-----------------------------------------------------------------------------------------------------------------------------------------|\n| `message`       | `string`       | Content of the message.                                                                                                                 |\n| `inResponseTo?` | `PlainMessage` | Contains the message at which the current message is responding. `undefined` means that the message is not responding to other message. |\n\n#### `ReceivedMessage`\n\n| Property       | Type           | Description                          |\n|----------------|----------------|--------------------------------------|\n| `senderNodeId` | `string`       | Id of the node who sent the message. |\n| `PlainMessage` | `PlainMessage` | Message received.                    |\n\n#### `PlainMessageListener`\n\n`(receivedMessage: ReceivedMessage) =\u003e void`\n    \n## License\n\nApache License 2.0\n\nSee [LICENSE](LICENSE).\n\n\n## Author\n\n\u003ca href=\"https://github.com/matey97\" title=\"Miguel Matey Sanz\"\u003e\n  \u003cimg src=\"https://avatars3.githubusercontent.com/u/25453537?s=120\" alt=\"Miguel Matey Sanz\" width=\"120\"/\u003e\n\u003c/a\u003e\n\n\n## Acknowledgements\n\nThe development of this library has been possible thanks to the Spanish Ministry of Universities (grant FPU19/05352).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FGeoTecINIT%2Fnativescript-wearos-sensors","html_url":"https://awesome.ecosyste.ms/projects/github.com%2FGeoTecINIT%2Fnativescript-wearos-sensors","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2FGeoTecINIT%2Fnativescript-wearos-sensors/lists"}