CARP Mobile Sensing Framework in Flutter

pub package style: effective dart github stars MIT License arXiv

This library contains the core Flutter package for the CARP Mobile Sensing (CAMS) framework. Supports cross-platform (iOS and Android) mobile sensing.

For an overview of all CAMS packages, see CARP Mobile Sensing in Flutter. For documentation on how to use CAMS, see the CAMS wiki.


To use this plugin, add carp_mobile_sensing as dependencies in your pubspec.yaml file.

    sdk: flutter
  carp_mobile_sensing: ^0.21.0

Android Integration

Add the following to your app's manifest.xml file located in android/app/src/main:

<manifest xmlns:android=""

    <!-- The following permissions are used for CARP Mobile Sensing -->
    <uses-permission android:name="android.permission.PACKAGE_USAGE_STATS" tools:ignore="ProtectedPermissions"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />


NOTE: Other CAMS sampling packages require additional permissions in the manifest.xml file. See the documentation for each package.

NOTE: Version 0.5.0 is migrated to AndroidX. It requires any Android apps using this plugin to also migrate if they're using the original support library. See Flutter AndroidX compatibility

iOS Integration

The pedometer (step count) probe uses NSMotion on iOS and the NSMotionUsageDescription needs to be specified in the app's Info.plist file located in ios/Runner:

  <string>Collecting step count.</string>


The Dart API doc describes the different libraries and classes.

The wiki contains detailed documentation on the CARP Mobile Sensing Framework, including the domain model, how to use it by create a Study configuration, how to extend it, and an overview of the different Measure types available.

A more scientific documentation of CAMS is available at

  • Bardram, Jakob E. "The CARP Mobile Sensing Framework--A Cross-platform, Reactive, Programming Framework and Runtime Environment for Digital Phenotyping." arXiv preprint arXiv:2006.11904 (2020). [pdf]
  title={The CARP Mobile Sensing Framework--A Cross-platform, Reactive, Programming Framework and Runtime Environment for Digital Phenotyping},
  author={Bardram, Jakob E},
  journal={arXiv preprint arXiv:2006.11904},

Please use this as a reference in any scientific papers using CAMS.

Examples of configuring and using CAMS

There is a very simple example app app which shows how a study can be created with different tasks and measures. This app just prints the sensing data to a console screen on the phone. There is also a range of different examples on how to create a study to take inspiration from.

However, the CARP Mobile Sensing App provides a MUCH better example of how to use the package in a Flutter BLoC architecture, including good documentation of how to do this.

Below is a small primer in the use of CAMS.

Following carp_core, a CAMS study can be configured, deployed, executed, and used in different steps:

  1. Define a StudyProtcol.
  2. Deploy this protocol to a DeploymentService.
  3. Get a study deployment for the phone and start executing this study deployment using a SmartPhoneClientManager.
  4. Use the generated data locally in the app or specify how and where to store or upload it using a DataEndPoint.

Note that as a mobile sensing framework running on a phone, CAMS could be limited to support 3-4. However, to support the 'full cycle', CAMS also supports 1-2. This allows for local creation, deployment, and execution of study protocols (which in many applications have shown to be useful).

Defining a StudyProtcol

In CAMS, a sensing protocol is configured in a StudyProtocol. Below is a simple example of how to set up a protocol that sense step counts (pedometer), ambient light (light), screen activity (screen), and power consumption (battery).

// import package
import 'package:carp_core/carp_core.dart';
import 'package:carp_mobile_sensing/carp_mobile_sensing.dart';

void example() async {
  // create a study protocol
  StudyProtocol protocol = StudyProtocol(
    ownerId: '',
    name: 'Tracking',
    description: 'Tracking patient movment',

  // define which devices are used for data collection
  // in this case, its only this smartphone
  Smartphone phone = Smartphone();

  // add an automatic task that immediately starts collecting
  // step counts, ambient light, screen activity, and battery level
          types: [
          types: [

The above example make use of the pre-defined SamplingSchema named common. This sampling schema contains a set of default settings for how to sample the different measures.

Sampling can be configured in a very sophisticated ways, by specifying different types of triggers, tasks, and measures - see the CAMS domain model for an overview.

Using a DeploymentService

A device deployment specifies how a study protocol is executed on a specific device - in this case a smartphone - including how to store or upload the sampled data.

A StudyProtocol can be deployed to a DeploymentService which handles the deployment of protocols for different devices. CAMS comes with a simple deployment service (the SmartphoneDeploymentService) which runs locally on the phone. This can be used to deploy a protocol and get back a MasterDeviceDeployment, which can be executed on the phone. Per default, the local device deployment service configures the deployment to store sampled data in a file, using a FileDataEndPoint.


// deploy this protocol using the on-phone deployment service
StudyDeploymentStatus status =
  await SmartphoneDeploymentService().createStudyDeployment(protocol);


// you can get the device deployment configuration for this phone....
// ... but this is rarely needed - see below
SmartphoneDeployment deployment = await SmartphoneDeploymentService()


Running a StudyDeploymentController

A study deployment for a phone (master device) is handled by a SmartPhoneClientManager. This client manager is able to create a StudyDeploymentController which controls the execution of a study deployment.


String studyDeploymentId = ... // any id obtained e.g. from an invitation
String deviceRolename = ... // the rolename of this phone in the protocol;

// create and configure a client manager for this phone
SmartPhoneClientManager client = SmartPhoneClientManager();
await client.configure();

// create a study runtime controller to execute and control this deployment
StudyDeploymentController controller = await client.addStudy(studyDeploymentId,deviceRolename);

// configure the controller and resume sampling
await controller.configure();

// listening and print all data collected by the controller;


A SmartPhoneClientManager per default uses the local SmartphoneDeploymentService which per default saves data in json to zipped files (see more on data backends on the wiki). If you want to use another data backend, this can be configured in two ways: (i) either as part of the deployment or (ii) as part of the configuration - like this:


// you can change the deployment locally, before starting the
// execution of it - e.g. setting another data endpoint.
controller.deployment.dataEndPoint = FileDataEndPoint(
  bufferSize: 500 * 1000,
  zip: true,
  encrypt: false,

// or you can configure the controller with a data endpoint 
// this has the same effect as above
await controller.configure(
  dataEndPoint: FileDataEndPoint(
    bufferSize: 500 * 1000,
    zip: true,
    encrypt: false,

Note that the data endpoint has to be set before sampling is resumed.

You can write your own DataEndPoint definitions and coresponding DataManagers for uploading data to your own data endpoint. See the wiki on how to add a new data manager.

Using the generated data

The generated data can be accessed and used in the app. Access to data is done by listening on the data streams from the study deployment controller or some of its underlying executors or probes. Below are a few examples on how to listen on data streams.


// listening to the stream of all data events from the controller => print(dataPoint));

// listen only on CARP events
  .where((dataPoint) => == NameSpace.CARP)
  .listen((event) => print(event));

// listen on LIGHT events only
  .where((dataPoint) => == SensorSamplingPackage.LIGHT)
  .listen((event) => print(event));

// listening on the data generated from all probes 
// this is equivalent to the statement above
  .listen((dataPoint) => print(dataPoint));

// map events to JSON and then print
  .map((dataPoint) => dataPoint.toJson())
  .listen((event) => print(event));

// subscribe to the stream of data
StreamSubscription<DataPoint> subscription = dataPoint) {
    // do something w. the datum, e.g. print the json
    print(JsonEncoder.withIndent(' ').convert(dataPoint));


Controlling the sampling of data

The execution of sensing can be controlled on runtime in a number of ways. For example:


// sampling can be paused and resumed

// pause specific probe(s)
  .forEach((probe) => probe.pause());

// adapt measures on the go - calling hasChanged() force a restart of
// the probe, which will load the new measure
  ..frequency = const Duration(seconds: 12)
  ..duration = const Duration(milliseconds: 500)

// disabling a measure will pause the probe
  ..enabled = false

// once the sampling has to stop, e.g. in a Flutter dispose() methods, call stop.
// note that once a sampling has stopped, it cannot be restarted.
await subscription.cancel();


Features and bugs

Please read about existing issues and file new feature requests and bug reports at the issue tracker.


This software is copyright (c) Copenhagen Center for Health Technology (CACHET) at the Technical University of Denmark (DTU). This software is available 'as-is' under a MIT license.


This library contains the software architecture for the CARP Mobile Sensing (CAMS) framework implemented in Flutter. Supports cross-platform (iOS and Android) sensing.
A library containing a sampling package for collecting information from the device hardware: [...]
The CAMS implementation of the core CARP domain classes like StudyProtocol, TaskDescriptor, and Measure. Also hold JSON serialization and deseralization logic to handle seraialization of the domain objects.
A library for handling data managers.
Contains classes for running the sensing framework incl. the StudyDeploymentExecutor, TaskExecutor and different types of abstract Probes.
Alibrary containing a sampling package for collecting data from the basic device sensors: [...]