mirror of https://github.com/YTVanced/VancedMicroG
193 lines
7.7 KiB
Java
193 lines
7.7 KiB
Java
/*
|
|
* Copyright (C) 2013-2017 microG Project Team
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.google.android.gms.location;
|
|
|
|
import android.content.Intent;
|
|
import android.os.Bundle;
|
|
|
|
import org.microg.gms.common.PublicApi;
|
|
import org.microg.safeparcel.AutoSafeParcelable;
|
|
import org.microg.safeparcel.SafeParcelUtil;
|
|
import org.microg.safeparcel.SafeParceled;
|
|
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Result of an activity recognition.
|
|
* <p>
|
|
* It contains a list of activities that a user may have been doing at a particular time. The
|
|
* activities are sorted by the most probable activity first. A confidence is associated with each
|
|
* activity which indicates how likely that activity is.
|
|
* <p>
|
|
* {@link #getMostProbableActivity()} will return the most probable activity of the user at the time
|
|
* that activity recognition was run.
|
|
*/
|
|
@PublicApi
|
|
public class ActivityRecognitionResult extends AutoSafeParcelable {
|
|
|
|
@PublicApi(exclude = true)
|
|
public static final String EXTRA_ACTIVITY_RESULT = "com.google.android.location.internal.EXTRA_ACTIVITY_RESULT";
|
|
@PublicApi(exclude = true)
|
|
public static final String EXTRA_ACTIVITY_RESULT_LIST = "com.google.android.location.internal.EXTRA_ACTIVITY_RESULT_LIST";
|
|
|
|
@SafeParceled(1000)
|
|
private int versionCode = 2;
|
|
|
|
@SafeParceled(value = 1, subClass = DetectedActivity.class)
|
|
private List<DetectedActivity> probableActivities;
|
|
|
|
@SafeParceled(2)
|
|
private long time;
|
|
|
|
@SafeParceled(3)
|
|
private long elapsedRealtimeMillis;
|
|
|
|
@SafeParceled(5)
|
|
private Bundle extras;
|
|
|
|
/**
|
|
* Constructs an ActivityRecognitionResult.
|
|
*
|
|
* @param probableActivities the activities that where detected, sorted by confidence (most probable first).
|
|
* @param time the UTC time of this detection, in milliseconds since January 1, 1970.
|
|
* @param elapsedRealtimeMillis milliseconds since boot
|
|
*/
|
|
public ActivityRecognitionResult(List<DetectedActivity> probableActivities, long time, long elapsedRealtimeMillis) {
|
|
this(probableActivities, time, elapsedRealtimeMillis, null);
|
|
}
|
|
|
|
/**
|
|
* Constructs an ActivityRecognitionResult from a single activity.
|
|
*
|
|
* @param activity the most probable activity of the device.
|
|
* @param time the UTC time of this detection, in milliseconds since January 1, 1970.
|
|
* @param elapsedRealtimeMillis milliseconds since boot
|
|
*/
|
|
public ActivityRecognitionResult(DetectedActivity activity, long time, long elapsedRealtimeMillis) {
|
|
this(Collections.singletonList(activity), time, elapsedRealtimeMillis);
|
|
}
|
|
|
|
private ActivityRecognitionResult(List<DetectedActivity> probableActivities, long time, long elapsedRealtimeMillis, Bundle extras) {
|
|
if (probableActivities == null || probableActivities.isEmpty())
|
|
throw new IllegalArgumentException("Must have at least 1 detected activity");
|
|
if (time <= 0 || elapsedRealtimeMillis <= 0)
|
|
throw new IllegalArgumentException("Must set times");
|
|
this.probableActivities = probableActivities;
|
|
this.time = time;
|
|
this.elapsedRealtimeMillis = elapsedRealtimeMillis;
|
|
this.extras = extras;
|
|
}
|
|
|
|
/**
|
|
* Extracts the ActivityRecognitionResult from an Intent.
|
|
* <p>
|
|
* This is a utility function which extracts the ActivityRecognitionResult from the extras of
|
|
* an Intent that was sent from the activity detection service.
|
|
*
|
|
* @return an ActivityRecognitionResult, or {@code null} if the intent doesn't contain an
|
|
* ActivityRecognitionResult.
|
|
*/
|
|
public static ActivityRecognitionResult extractResult(Intent intent) {
|
|
if (intent.hasExtra(EXTRA_ACTIVITY_RESULT_LIST)) {
|
|
intent.setExtrasClassLoader(ActivityRecognitionResult.class.getClassLoader());
|
|
List<ActivityRecognitionResult> list = intent.getParcelableArrayListExtra(EXTRA_ACTIVITY_RESULT_LIST);
|
|
if (list != null && !list.isEmpty())
|
|
return list.get(list.size() - 1);
|
|
}
|
|
if (intent.hasExtra(EXTRA_ACTIVITY_RESULT)) {
|
|
Bundle extras = intent.getExtras();
|
|
extras.setClassLoader(ActivityRecognitionResult.class.getClassLoader());
|
|
Object res = extras.get(EXTRA_ACTIVITY_RESULT);
|
|
if (res instanceof ActivityRecognitionResult)
|
|
return (ActivityRecognitionResult) res;
|
|
if (res instanceof byte[])
|
|
return SafeParcelUtil.fromByteArray((byte[]) res, CREATOR);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the confidence of the given activity type.
|
|
*/
|
|
public int getActivityConfidence(int activityType) {
|
|
for (DetectedActivity activity : probableActivities) {
|
|
if (activity.getType() == activityType)
|
|
return activity.getConfidence();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the elapsed real time of this detection in milliseconds since boot, including time
|
|
* spent in sleep as obtained by SystemClock.elapsedRealtime().
|
|
*/
|
|
public long getElapsedRealtimeMillis() {
|
|
return elapsedRealtimeMillis;
|
|
}
|
|
|
|
/**
|
|
* Returns the most probable activity of the user.
|
|
*/
|
|
public DetectedActivity getMostProbableActivity() {
|
|
return probableActivities.get(0);
|
|
}
|
|
|
|
/**
|
|
* Returns the list of activities that where detected with the confidence value associated with
|
|
* each activity. The activities are sorted by most probable activity first.
|
|
* <p>
|
|
* The sum of the confidences of all detected activities this method returns does not have to
|
|
* be <= 100 since some activities are not mutually exclusive (for example, you can be walking
|
|
* while in a bus) and some activities are hierarchical (ON_FOOT is a generalization of WALKING
|
|
* and RUNNING).
|
|
*/
|
|
public List<DetectedActivity> getProbableActivities() {
|
|
return probableActivities;
|
|
}
|
|
|
|
/**
|
|
* Returns the UTC time of this detection, in milliseconds since January 1, 1970.
|
|
*/
|
|
public long getTime() {
|
|
return time;
|
|
}
|
|
|
|
/**
|
|
* Returns true if an Intent contains an ActivityRecognitionResult.
|
|
* <p>
|
|
* This is a utility function that can be called from inside an intent receiver to make sure
|
|
* the received intent is from activity recognition.
|
|
*
|
|
* @return true if the intent contains an ActivityRecognitionResult, false otherwise or the given intent is null
|
|
*/
|
|
public static boolean hasResult(Intent intent) {
|
|
if (intent == null) return false;
|
|
if (intent.hasExtra(EXTRA_ACTIVITY_RESULT)) return true;
|
|
intent.setExtrasClassLoader(ActivityRecognitionResult.class.getClassLoader());
|
|
List<ActivityRecognitionResult> list = intent.getParcelableArrayListExtra(EXTRA_ACTIVITY_RESULT_LIST);
|
|
return list != null && !list.isEmpty();
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "ActivityRecognitionResult [probableActivities=" + probableActivities + ", timeMillis" + time + ", elapsedRealtimeMillis=" + elapsedRealtimeMillis + "]";
|
|
}
|
|
|
|
public static final Creator<ActivityRecognitionResult> CREATOR = new AutoCreator<ActivityRecognitionResult>(ActivityRecognitionResult.class);
|
|
}
|