xDrip+ v04633772025.07.16 - ActivityRecognizedService.java 源代码

package com.eveningoutpost.dexdrip.services;

import android.app.IntentService;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.Uri;
import android.os.Bundle;
import android.os.PowerManager;
import android.util.Log;
import android.util.SparseArray;
import androidx.core.app.NotificationCompat;
import androidx.core.app.NotificationManagerCompat;
import com.eveningoutpost.dexdrip.ErrorsActivity;
import com.eveningoutpost.dexdrip.GcmActivity;
import com.eveningoutpost.dexdrip.Home;
import com.eveningoutpost.dexdrip.importedlibraries.usbserial.driver.UsbId;
import com.eveningoutpost.dexdrip.models.JoH;
import com.eveningoutpost.dexdrip.models.UserError;
import com.eveningoutpost.dexdrip.utilitymodels.Pref;
import com.eveningoutpost.dexdrip.utilitymodels.ShotStateStore;
import com.eveningoutpost.dexdrip.utilitymodels.VehicleMode;
import com.eveningoutpost.dexdrip.utils.PowerStateReceiver;
import com.eveningoutpost.dexdrip.xdrip;
import com.google.android.gms.common.ConnectionResult;
import com.google.android.gms.common.api.GoogleApiClient;
import com.google.android.gms.location.ActivityRecognition;
import com.google.android.gms.location.ActivityRecognitionResult;
import com.google.android.gms.location.DetectedActivity;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.annotations.Expose;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

public class ActivityRecognizedService extends IntentService implements GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
    public static DetectedActivity activityState = null;
    public static double last_data = -1.0d;
    private static DetectedActivity lastactivity;
    private static GoogleApiClient mApiClient;
    private static PendingIntent mPendingIntent;
    public static SharedPreferences.OnSharedPreferenceChangeListener prefListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String str) {
            str.hashCode();
            switch (str) {
                case "use_remote_motion":
                    if (sharedPreferences.getBoolean("use_remote_motion", false) && sharedPreferences.getBoolean("act_as_motion_master", false)) {
                        sharedPreferences.edit().putBoolean("act_as_motion_master", false).apply();
                    }
                    ActivityRecognizedService.reStartActivityRecogniser(xdrip.getAppContext());
                    break;
                case "act_as_motion_master":
                    if (sharedPreferences.getBoolean("act_as_motion_master", false) && sharedPreferences.getBoolean("use_remote_motion", false)) {
                        sharedPreferences.edit().putBoolean("use_remote_motion", false).apply();
                    }
                    ActivityRecognizedService.reStartActivityRecogniser(xdrip.getAppContext());
                    break;
                case "motion_tracking_enabled":
                    if (sharedPreferences.getBoolean("motion_tracking_enabled", false)) {
                        ActivityRecognizedService.resetRequestedReceivedCounters();
                        ActivityRecognizedService.startActivityRecogniser(xdrip.getAppContext());
                        ActivityRecognizedService.startupInfo();
                        break;
                    } else {
                        ActivityRecognizedService.stopActivityRecogniser(xdrip.getAppContext());
                        ActivityRecognizedService.set_vehicle_mode(false);
                        break;
                    }
            }
        }
    };
    private static SharedPreferences prefs;
    private static int received;
    private static PowerManager.WakeLock wl_global;
    private static PowerManager.WakeLock wl_start;

    public static double getVehicle_mode_adjust_mgdl() {
        return 18.0d;
    }

    public ActivityRecognizedService() {
        super("ActivityRecognizedService");
    }

    public static void startActivityRecogniser(Context context) {
        Intent intent = new Intent(context, (Class<?>) ActivityRecognizedService.class);
        intent.putExtra("START_ACTIVITY_ACTION", "START_ACTIVITY_ACTION");
        context.startService(intent);
    }

    public static void reStartActivityRecogniser(Context context) {
        Intent intent = new Intent(context, (Class<?>) ActivityRecognizedService.class);
        intent.putExtra("RESTART_ACTIVITY_ACTION", "RESTART_ACTIVITY_ACTION");
        context.startService(intent);
    }

    public static void stopActivityRecogniser(Context context) {
        Intent intent = new Intent(context, (Class<?>) ActivityRecognizedService.class);
        intent.putExtra("STOP_ACTIVITY_ACTION", "STOP_ACTIVITY_ACTION");
        context.startService(intent);
    }

    public static void spoofActivityRecogniser(Context context, String str) {
        Intent intent = new Intent(context, (Class<?>) ActivityRecognizedService.class);
        intent.putExtra("INCOMING_ACTIVITY_ACTION", str);
        context.startService(intent);
    }

    public synchronized void start() {
        start(false);
    }

    public synchronized void start(boolean z) {
        if (Pref.getBoolean("use_remote_motion", false)) {
            Log.d("ActivityRecognizer", "Not starting as we are expecting remote instead of local motion");
            return;
        }
        if (!z && !JoH.ratelimit("recognizer-start", 60)) {
            UserError.Log.e("ActivityRecognizer", "Couldn't restart API due to ratelimit");
        }
        release_wl_start();
        wl_start = JoH.getWakeLock("recognizer-start", UsbId.SILABS_CP2102);
        UserError.Log.e("ActivityRecognizer", "Restarting API");
        GoogleApiClient build = new GoogleApiClient.Builder(this).addApi(ActivityRecognition.API).addConnectionCallbacks(this).addOnConnectionFailedListener(this).build();
        mApiClient = build;
        build.connect();
    }

    public synchronized void stop() {
        stopUpdates();
    }

    private PendingIntent get_pending_intent() {
        if (mPendingIntent == null) {
            mPendingIntent = PendingIntent.getService(this, 0, new Intent(this, (Class<?>) ActivityRecognizedService.class), 134217728);
        }
        return mPendingIntent;
    }

    private static void init_prefs() {
        if (prefs == null) {
            prefs = xdrip.getAppContext().getSharedPreferences("motion_internal", 0);
        }
    }

    private static String getInternalPrefsString(String str) {
        init_prefs();
        return prefs.getString(str, "");
    }

    private static void setInternalPrefsString(String str, String str2) {
        init_prefs();
        prefs.edit().putString(str, str2).apply();
    }

    private static long getInternalPrefsLong(String str) {
        init_prefs();
        return prefs.getLong(str, 0L);
    }

    private static void setInternalPrefsLong(String str, long j) {
        init_prefs();
        prefs.edit().putLong(str, j).apply();
    }

    private static void incrementInternalPrefsLong(String str) {
        setInternalPrefsLong(str, getInternalPrefsLong(str) + 1);
    }

    private static long addInternalPrefsLong(String str, String str2) {
        long internalPrefsLong = getInternalPrefsLong(str2) + getInternalPrefsLong(str);
        setInternalPrefsLong(str2, internalPrefsLong);
        return internalPrefsLong;
    }

    private static void interpretRatio(Context context) {
        long internalPrefsLong = getInternalPrefsLong("requested");
        long internalPrefsLong2 = getInternalPrefsLong("received");
        if (internalPrefsLong > 0) {
            Log.d("ActivityRecognizer", "Requested: " + internalPrefsLong + " Received: " + internalPrefsLong2);
            if (internalPrefsLong == 10) {
                if (internalPrefsLong2 < 4) {
                    UserError.Log.ueh("ActivityRecognizer", "Issuing full screen wakeup as req: " + getInternalPrefsLong("requested") + " rec: " + getInternalPrefsLong("received"));
                    Home.startHomeWithExtra(context, "HOME_FULL_WAKEUP", "1");
                }
            } else if (internalPrefsLong == 15 && internalPrefsLong2 < 4 && !PowerStateReceiver.is_power_connected()) {
                disableMotionTrackingDueToErrors(context);
            }
            if (internalPrefsLong > 20) {
                evaluateRequestReceivedCounters(false, context);
                resetRequestedReceivedCounters();
            }
        }
    }

    private static void disableMotionTrackingDueToErrors(Context context) {
        long internalPrefsLong = getInternalPrefsLong("requested");
        long internalPrefsLong2 = getInternalPrefsLong("received");
        Home.toaststaticnext("DISABLED MOTION TRACKING DUE TO FAILURES! See Error Log!");
        String str = "Had to disable motion tracking feature as it did not seem to be working and may be incompatible with your phone. Please report this to the developers using the send logs feature: " + internalPrefsLong + " vs " + internalPrefsLong2 + " " + JoH.getDeviceDetails();
        UserError.Log.wtf("ActivityRecognizer", str);
        UserError.Log.ueh("ActivityRecognizer", str);
        Pref.setBoolean("motion_tracking_enabled", false);
        evaluateRequestReceivedCounters(true, context);
        setInternalPrefsLong("requested", 0L);
        setInternalPrefsLong("received", 0L);
        NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
        Intent intent = new Intent(xdrip.getAppContext(), (Class<?>) ErrorsActivity.class);
        intent.addFlags(67108864);
        PendingIntent activity = PendingIntent.getActivity(xdrip.getAppContext(), 0, intent, 1073741824);
        builder.setContentText("Shut down motion detection! See Error Logs - Please report to developer" + JoH.dateTimeText(JoH.tsl()));
        builder.setContentIntent(activity);
        builder.setSmallIcon(2131230915);
        builder.setContentTitle("Problem with motion detection!");
        NotificationManagerCompat.from(context).notify(38, builder.build());
    }

    private static void evaluateRequestReceivedCounters(boolean z, Context context) {
        long addInternalPrefsLong = addInternalPrefsLong("requested", "requested_all_time");
        double addInternalPrefsLong2 = (addInternalPrefsLong("received", "received_all_time") * 100) / addInternalPrefsLong;
        if (z || addInternalPrefsLong <= 100 || addInternalPrefsLong2 >= 90.0d || PowerStateReceiver.is_power_connected() || !JoH.isAnyNetworkConnected() || !JoH.ratelimit("disable_motion", 86400)) {
            return;
        }
        disableMotionTrackingDueToErrors(context);
    }

    public static void resetRequestedReceivedCounters() {
        setInternalPrefsLong("requested", 0L);
        setInternalPrefsLong("received", 0L);
    }

    public static boolean is_in_vehicle_mode() {
        return (Pref.getBooleanDefaultFalse("motion_tracking_enabled") || VehicleMode.viaCarAudio()) && VehicleMode.isEnabled() && getInternalPrefsString("vehicle_mode").equals("true");
    }

    public static boolean raise_limit_due_to_vehicle_mode() {
        return is_in_vehicle_mode() && Pref.getBoolean("raise_low_limit_in_vehicle_mode", false);
    }

    public static void set_vehicle_mode(boolean z) {
        setInternalPrefsString("vehicle_mode", z ? "true" : "false");
        if (z) {
            setInternalPrefsLong("vehicle_mode_since", JoH.tsl());
        } else {
            long j = get_vehicle_mode_minutes();
            setInternalPrefsLong("vehicle_mode_since", -1L);
            if (j > 0) {
                UserError.Log.ueh("ActivityRecognizer", "Exiting vehicle mode after: " + j + " minutes");
            }
        }
        VehicleMode.sendBroadcast();
    }

    private static int get_vehicle_mode_minutes() {
        long tsl = JoH.tsl() - getInternalPrefsLong("vehicle_mode_since");
        if (tsl < 86400000) {
            return (int) (tsl / 60000);
        }
        return -1;
    }

    private static int get_minutes_since_last_alert() {
        long tsl = JoH.tsl() - getInternalPrefsLong("vehicle_mode_last_alert");
        if (tsl < 86400000) {
            return (int) (tsl / 60000);
        }
        return -1;
    }

    private static int getLastStoredActivity() {
        motionDataWrapper loadActivityTimeSeries = loadActivityTimeSeries();
        if (loadActivityTimeSeries.entries.size() <= 0) {
            return -1;
        }
        return loadActivityTimeSeries.entries.get(r0.size() - 1).activity;
    }

    public static ArrayList<motionData> getForGraph(long j, long j2) {
        motionDataWrapper loadActivityTimeSeries = loadActivityTimeSeries();
        ArrayList<motionData> arrayList = new ArrayList<>();
        Log.d("ActivityRecognizer", "Motion list original size: " + loadActivityTimeSeries.entries.size() + " start: " + JoH.dateTimeText(j) + " end:" + JoH.dateTimeText(j2));
        Iterator<motionData> it = loadActivityTimeSeries.entries.iterator();
        while (it.hasNext()) {
            motionData next = it.next();
            long j3 = next.timestamp;
            if (j3 >= j && j3 <= j2) {
                arrayList.add(next);
            }
        }
        return arrayList;
    }

    private static DetectedActivity getLastStoredDetectedActivity() {
        int lastStoredActivity = getLastStoredActivity();
        if (lastStoredActivity == -1) {
            return null;
        }
        return new DetectedActivity(lastStoredActivity, 102);
    }

    private static motionDataWrapper loadActivityTimeSeries() {
        String internalPrefsString = getInternalPrefsString("time_series");
        if (internalPrefsString.length() > 0) {
            return (motionDataWrapper) new Gson().fromJson(internalPrefsString, motionDataWrapper.class);
        }
        return new motionDataWrapper();
    }

    private static void saveUpdatedActivityState(long j) {
        motionDataWrapper loadActivityTimeSeries = loadActivityTimeSeries();
        boolean z = false;
        if (loadActivityTimeSeries.entries.size() > 20) {
            for (int i = 0; i < 3; i++) {
                int i2 = 0;
                while (true) {
                    if (i2 >= loadActivityTimeSeries.entries.size()) {
                        break;
                    }
                    if (JoH.tsl() - loadActivityTimeSeries.entries.get(i2).timestamp > 86400000) {
                        loadActivityTimeSeries.entries.remove(i2);
                        break;
                    }
                    i2++;
                }
            }
        }
        if (loadActivityTimeSeries.entries.size() > 0) {
            ArrayList<motionData> arrayList = loadActivityTimeSeries.entries;
            if (j < arrayList.get(arrayList.size() - 1).timestamp) {
                z = true;
            }
        }
        loadActivityTimeSeries.entries.add(new motionData(j, activityState.getType()));
        if (z) {
            Collections.sort(loadActivityTimeSeries.entries, new Comparator<motionData>() {
                @Override
                public int compare(motionData motiondata, motionData motiondata2) {
                    long j2 = motiondata.timestamp;
                    long j3 = motiondata2.timestamp;
                    if (j2 == j3) {
                        return 0;
                    }
                    return j2 - j3 > 0 ? 1 : -1;
                }
            });
        }
        setInternalPrefsString("time_series", new GsonBuilder().excludeFieldsWithoutExposeAnnotation().serializeSpecialFloatingPointValues().create().toJson(loadActivityTimeSeries));
    }

    private synchronized void requestUpdates(int i) {
        try {
            received = 0;
            wl_global = JoH.getWakeLock("motion-wait", i * 5);
            incrementInternalPrefsLong("requested");
            interpretRatio(this);
            ActivityRecognition.ActivityRecognitionApi.requestActivityUpdates(mApiClient, i, get_pending_intent());
        } catch (Exception e) {
            UserError.Log.wtf("ActivityRecognizer", "Got exception starting activity recognition: " + e.toString());
        }
    }

    private synchronized void stopUpdates() {
        try {
            ActivityRecognition.ActivityRecognitionApi.removeActivityUpdates(mApiClient, get_pending_intent());
            PowerManager.WakeLock wakeLock = wl_global;
            if (wakeLock != null) {
                JoH.releaseWakeLock(wakeLock);
                wl_global = null;
            }
        } catch (Exception e) {
            UserError.Log.wtf("ActivityRecognizer", "Got exception stopping activity recognition: " + e.toString());
        }
    }

    private void restart(int i) {
        if (Pref.getBoolean("use_remote_motion", false)) {
            return;
        }
        GoogleApiClient googleApiClient = mApiClient;
        if (googleApiClient == null || !googleApiClient.isConnected()) {
            start(true);
        } else {
            requestUpdates(i);
        }
    }

    private synchronized void release_wl_start() {
        PowerManager.WakeLock wakeLock = wl_start;
        if (wakeLock != null) {
            JoH.releaseWakeLock(wakeLock);
            wl_start = null;
        }
    }

    @Override
    public void onConnected(Bundle bundle) {
        UserError.Log.e("ActivityRecognizer", "onConnected");
        requestUpdates(1000);
        release_wl_start();
    }

    @Override
    public void onConnectionSuspended(int i) {
        UserError.Log.e("ActivityRecognizer", "onConnectionSuspended");
        start();
    }

    @Override
    public void onConnectionFailed(ConnectionResult connectionResult) {
        UserError.Log.e("ActivityRecognizer", "onConnectionFailed: " + connectionResult.toString());
        if (connectionResult.hasResolution()) {
            try {
                connectionResult.getResolution().send();
                return;
            } catch (NullPointerException unused) {
                return;
            } catch (Exception e) {
                UserError.Log.e("ActivityRecognizer", e.toString());
                return;
            }
        }
        if (connectionResult.getErrorCode() == 2) {
            JoH.static_toast_long("Google Play Services update download needed for Motion");
            Intent intent = new Intent("android.intent.action.VIEW");
            intent.setData(Uri.parse("https://play.google.com/store/apps/details?id=com.google.android.gms"));
            JoH.showNotification("Google Update Needed", "Google Play Services update download needed for Motion. Download update via Google Play Store and try motion again after installed.", PendingIntent.getActivity(this, 0, intent, 0), 60302, true, true, true);
            UserError.Log.ueh("ActivityRecognizer", "Google Play Services updated needed for motion - disabling motion for now");
            Pref.setBoolean("motion_tracking_enabled", false);
        }
        start();
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        PowerManager.WakeLock wakeLock = JoH.getWakeLock("ActivityRecognizer", UsbId.SILABS_CP2102);
        try {
            if (intent.getStringExtra("START_ACTIVITY_ACTION") != null) {
                start(true);
            } else if (intent.getStringExtra("RESTART_ACTIVITY_ACTION") != null) {
                restart(1000);
                checkVehicleRepeatNotification();
            } else if (intent.getStringExtra("STOP_ACTIVITY_ACTION") != null) {
                UserError.Log.uel("ActivityRecognizer", "Stopping service");
                stop();
            } else if (intent.getStringExtra("RECHECK_VEHICLE_MODE") != null) {
                checkVehicleRepeatNotification();
            } else if (ActivityRecognitionResult.hasResult(intent)) {
                if (Pref.getBooleanDefaultFalse("motion_tracking_enabled")) {
                    if (mApiClient == null) {
                        start();
                    }
                    int handleDetectedActivities = handleDetectedActivities(ActivityRecognitionResult.extractResult(intent).getProbableActivities(), true, 0L);
                    last_data = JoH.ts();
                    int i = received + 1;
                    received = i;
                    if (i > 4 || handleDetectedActivities > 90) {
                        stopUpdates();
                    }
                } else if (JoH.ratelimit("not-expected-activity", 1200)) {
                    UserError.Log.e("ActivityRecognizer", "Received ActivityRecognition we were not expecting!");
                    stop();
                }
            } else {
                String stringExtra = intent.getStringExtra("INCOMING_ACTIVITY_ACTION");
                if (stringExtra != null && Pref.getBoolean("use_remote_motion", false)) {
                    try {
                        String[] split = stringExtra.split("\\^");
                        long parseLong = Long.parseLong(split[0]);
                        int parseInt = Integer.parseInt(split[1]);
                        ArrayList arrayList = new ArrayList();
                        arrayList.add(new DetectedActivity(parseInt, 101));
                        handleDetectedActivities(arrayList, false, parseLong);
                    } catch (Exception e) {
                        Log.wtf("ActivityRecognizer", "Exception processing incoming motion: " + e.toString());
                    }
                }
            }
        } finally {
            JoH.releaseWakeLock(wakeLock);
        }
    }

    private int handleDetectedActivities(List<DetectedActivity> list, boolean z, long j) {
        DetectedActivity detectedActivity;
        if (j == 0) {
            j = JoH.tsl();
        }
        incrementInternalPrefsLong("received");
        DetectedActivity detectedActivity2 = null;
        int i = 0;
        for (DetectedActivity detectedActivity3 : list) {
            if (detectedActivity3.getType() != 5 && detectedActivity3.getType() != 4 && detectedActivity3.getConfidence() > i) {
                i = detectedActivity3.getConfidence();
                detectedActivity2 = detectedActivity3;
            }
        }
        if (detectedActivity2 != null && detectedActivity2.getType() != 4 && detectedActivity2.getType() != 5) {
            if (activityState == null) {
                activityState = getLastStoredDetectedActivity();
            }
            if ((detectedActivity2.getConfidence() > 89 || (lastactivity != null && detectedActivity2.getType() == lastactivity.getType() && lastactivity.getConfidence() + detectedActivity2.getConfidence() > 150)) && ((detectedActivity = activityState) == null || detectedActivity.getType() != detectedActivity2.getType())) {
                if (Pref.getBoolean("motion_tracking_enabled", false)) {
                    StringBuilder sb = new StringBuilder();
                    sb.append("Changed activity state from ");
                    DetectedActivity detectedActivity4 = activityState;
                    sb.append(detectedActivity4 == null ? "null" : detectedActivity4.toString());
                    sb.append(" to: ");
                    sb.append(detectedActivity2.toString());
                    UserError.Log.ueh("ActivityRecognizer", sb.toString());
                    activityState = detectedActivity2;
                    if (Pref.getBoolean("plot_motion", true)) {
                        saveUpdatedActivityState(j);
                    }
                    if (detectedActivity2.getType() == 0) {
                        UserError.Log.e("ActivityRecognizer", "Vehicle: " + detectedActivity2.getConfidence());
                        if (detectedActivity2.getConfidence() >= 75) {
                            if (!VehicleMode.isVehicleModeActive()) {
                                VehicleMode.setVehicleModeActive(true);
                            }
                            if (is_in_vehicle_mode()) {
                                raise_vehicle_notification("In Vehicle Mode: " + JoH.dateTimeText(JoH.tsl()));
                            }
                        }
                    } else if (is_in_vehicle_mode()) {
                        set_vehicle_mode(false);
                        cancel_vehicle_notification();
                    }
                    if (z && Pref.getBoolean("motion_tracking_enabled", false) && Pref.getBoolean("act_as_motion_master", false)) {
                        GcmActivity.sendMotionUpdate(JoH.tsl(), activityState.getType());
                    }
                } else {
                    UserError.Log.e("ActivityRecognizer", "Shutting down");
                    stop();
                }
            } else if (JoH.ratelimit("check-vehicle-repeat", 60)) {
                checkVehicleRepeatNotification();
            }
            lastactivity = detectedActivity2;
        }
        return i;
    }

    private void raise_vehicle_notification(String str) {
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
        builder.setContentText(str);
        builder.setSmallIcon(2131230915);
        if (VehicleMode.shouldPlaySound()) {
            setInternalPrefsLong("vehicle_mode_last_alert", JoH.tsl());
            builder.setSound(Uri.parse("android.resource://" + getPackageName() + "/2131689966"));
        }
        builder.setContentTitle(getString(2131755147) + " Vehicle mode");
        cancel_vehicle_notification();
        NotificationManagerCompat.from(this).notify(37, builder.build());
    }

    private void cancel_vehicle_notification() {
        NotificationManagerCompat.from(this).cancel(37);
    }

    private void checkVehicleRepeatNotification() {
        if (Pref.getBoolean("play_sound_in_vehicle_mode", false) && is_in_vehicle_mode() && Pref.getBoolean("repeat_sound_in_vehicle_mode", true) && get_minutes_since_last_alert() > 90) {
            raise_vehicle_notification("Still in Vehicle mode, duration: " + get_vehicle_mode_minutes() + " mins");
        }
    }

    public static void startupInfo() {
        if (ShotStateStore.hasShot(11)) {
            return;
        }
        Home.startHomeWithExtra(xdrip.getAppContext(), "ACTIVITY_SHOWCASE_INFO", "");
    }

    protected static class motionDataWrapper {

        @Expose
        public ArrayList<motionData> entries = new ArrayList<>();

        motionDataWrapper() {
        }
    }

    public static class motionData {
        private static final SparseArray<String> classification;

        @Expose
        public int activity;

        @Expose
        public long timestamp;

        static {
            SparseArray<String> sparseArray = new SparseArray<>();
            classification = sparseArray;
            sparseArray.put(0, "in vehicle");
            sparseArray.put(1, "on bicycle");
            sparseArray.put(2, "on foot");
            sparseArray.put(8, "running");
            sparseArray.put(3, "still");
            sparseArray.put(5, "tilting");
            sparseArray.put(4, "unknown");
            sparseArray.put(7, "walking");
        }

        public motionData(long j, int i) {
            this.timestamp = j;
            this.activity = i;
        }

        public String toPrettyType() {
            String str = classification.get(this.activity);
            if (str != null) {
                return str;
            }
            return "unclassified " + this.activity;
        }
    }
}