IssueTracker

I have devices for collecting data from sensors:

Model: XMWT01<br> Device name: Mi Watch 78CC<br> Build number: PXDP.210508.001.XM129<br>

Model: WG12026<br> Device name: TicWatch E2 0846<br> Build number: PWDR.190618.001.B8<br>

Model: SM-R860<br> Device name: Galaxy Watch4<br> Build number: R860XXU1BUH9<br>

For this devices I register accelerometer and gyroscope for collect data with 50 Hz frequency (for example):

int samplingPeriodUs = 20_000;
SensorManager sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE)
Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
sensorManager.registerListener(this, sensor, samplingPeriodUs, 0);

I run the listener in the background service and save the data file in a separate thread using ExecutorService. After collecting and uploading the data, I do the validation.

My Service:

////

public class ReaderSensorService extends Service implements SensorEventListener, LocationListener {

    public static final String CHANNEL_ID = "channel_reader_service";
    public static final int NOTIFY_ID = 1001;

    private static final LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(MainActivity.getAppContext());
    private static final UserPreferences userPreferences = UserPreferences.getInstance();
    private final DataCollector dataCollector = DataCollector.getInstance();
    private final Map<Integer, SensorData> mapSensors = new HashMap<>();
    private static SensorManager sensorManager = null;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        switch (intent.getAction()) {
            case ACT_START_FOREGROUND:
                createNotificationChannel();
                Notification notification = createNotification(intent);
                startForeground(NOTIFY_ID, notification);
                LocationManager locationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
                int periodMs = userPreferences.getSensorPeriodMeasurement(SensorType.GNSS);
                if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
                        && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
                    locationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, periodMs, 0, this);
                    locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, periodMs, 0, this);
                }
                States state = start();
                if (state == States.SENSOR_AVAILABLE) {
                    return START_STICKY;
                }
                intentErrorMessage(state);
            case ACT_STOP_FOREGROUND:
                stop();
                stopForeground(true);
                stopSelf();
                break;
            default:
                break;
        }
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onTaskRemoved(Intent rootIntent) {
        super.onTaskRemoved(rootIntent);
    }

    @Override
    public void onDestroy() {
        stop();
        super.onDestroy();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    private Notification createNotification(Intent intent) {
        Intent intentNotify = new Intent(this, MainActivity.class);
        intentNotify.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intentNotify, PendingIntent.FLAG_UPDATE_CURRENT);
        return new NotificationCompat.Builder(this, CHANNEL_ID)
                .setContentTitle(getString(R.string.app_name))
                .setContentText(intent.getStringExtra("inputExtra"))
                .setContentText("Service is running in background")
                .setWhen(0)
                .setContentIntent(pendingIntent)
                .setOngoing(true)
                .build();
    }

    private void createNotificationChannel() {
        NotificationChannel channel = new NotificationChannel(CHANNEL_ID, getString(R.string.app_name), NotificationManager.IMPORTANCE_DEFAULT);
        NotificationManager manager = getSystemService(NotificationManager.class);
        manager.createNotificationChannel(channel);
    }

    private void intentErrorMessage(States state) {
        Intent intent = new Intent(ACT_UPLOAD_DATA);
        switch (state) {
            case DEVICE_NO_MAC:
                intent.putExtra(BROADCAST_MESSAGE, MSG_NOT_MAC_AVAILABLE);
                break;
            case SENSOR_ALL_UNAVAILABLE:
                intent.putExtra(BROADCAST_MESSAGE, MSG_NOT_SUPPORTED);
                break;
            case SENSOR_NO_ACC:
                intent.putExtra(BROADCAST_MESSAGE, MSG_NOT_SUPPORTED_ACC);
                break;
            case SENSOR_NO_GYRO:
                intent.putExtra(BROADCAST_MESSAGE, MSG_NOT_SUPPORTED_GYRO);
                break;
            default:
                break;
        }
        localBroadcastManager.sendBroadcast(intent);
    }

    public States start() {
        int code = 0;
        String macAddress = IdentifyUtils.getMACAddress();
        if (macAddress.isEmpty()) {
            return States.DEVICE_NO_MAC;
        }
        List<SensorType> sensorList = Arrays.stream(SensorType.values())
                .filter(sensorType -> sensorType.getID() != Sensor.TYPE_ALL)
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
        for (SensorType sensorType : sensorList) {
            if (!register(sensorType)) {
                code |= States.getCode(sensorType);
            }
        }
        if (code == States.SENSOR_ALL_UNAVAILABLE.getCode()) {
            return States.SENSOR_ALL_UNAVAILABLE;
        }
        return States.SENSOR_AVAILABLE;
    }

    public void stop() {
        unregister();
        dataCollector.shutdown();
    }
    public static Boolean checkSupportSensor(int typeSensor) {
        Sensor sensor = sensorManager.getDefaultSensor(typeSensor);
        return sensor != null;
    }

    private Boolean register(SensorType sensorType) {
        boolean status = false;
        if (userPreferences.isEnableSensor(sensorType)) {
            int periodMs = userPreferences.getSensorPeriodMeasurement(sensorType);
            String mac = IdentifyUtils.getMACAddress();
            if (sensorType != SensorType.GNSS) {
                Sensor sensor = sensorManager.getDefaultSensor(sensorType.getID());
                if ((status = sensor != null)) {
                    sensorManager.registerListener(this, sensor, 20_000 /* temp value for fix 50 Hz */, 0);
                } else {
                    return false;
                }
            }
            DeviceData deviceData = dataCollector.getDevice(mac);
            SensorData sensorData = deviceData.addSensor(sensorType);
            mapSensors.put(sensorType.getID(), sensorData);
        }
        return status;
    }

    private void unregister() {
        sensorManager.unregisterListener(this);
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        float[] values = event.values;
        long timestamp = event.timestamp;
        int sensorType = event.sensor.getType();
        SensorData sensorData = mapSensors.get(sensorType);
        synchronized (this) {
            switch (sensorType) {
                case Sensor.TYPE_ACCELEROMETER:
                case Sensor.TYPE_GYROSCOPE:
                case Sensor.TYPE_MAGNETIC_FIELD:
                    sensorData.add(new FloatVector3(timestamp, values[0], values[1], values[2]));
                    break;
                case Sensor.TYPE_HEART_RATE:
                case Sensor.TYPE_LIGHT:
                    sensorData.add(new FloatVector1(timestamp, values[0]));
                    break;
                default:
                    break;
            }
        }
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }

    @Override
    public void onLocationChanged(@NonNull Location location) {
        float[] values = {(float) location.getAltitude(), (float) location.getLatitude(), (float) location.getLongitude()};
        SensorData sensorData = mapSensors.get(SensorType.GNSS.getID());
        sensorData.add(new DoubleVector3(location.getElapsedRealtimeNanos(), values[0], values[1], values[2]));
    }
}

I count the number of counts per second and plot the accelerometer and gyro for 7-8 hours. The result is shown in the attached figure (test_samsung_gw4.png). As you can see from the figure, I'm getting big data misses. But, when I leave my application's main window on the screen (getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) in the main activity), I get data at a stable frequency and no data is lost.

enter image description here

I attached part of my code in the letter. The most important class is ReaderSensorService, which runs a listener for sensors.

My question is as follows: Can I specify any options, or by changing the approach to obtain data without loss in the background? (When my application is running in the background and the screen is off.)