926 lines
33 KiB
Java
926 lines
33 KiB
Java
/*
|
|
* Copyright (C) 2019 The Android Open Source Project
|
|
*
|
|
* 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 android.location;
|
|
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.SystemApi;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.Executor;
|
|
|
|
/**
|
|
* GNSS chipset capabilities.
|
|
*/
|
|
public final class GnssCapabilities implements Parcelable {
|
|
|
|
// IMPORTANT - must match the Capabilities enum in IGnssCallback.hal
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_SCHEDULING = 1;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_MSB = 1 << 1;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_MSA = 1 << 2;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_SINGLE_SHOT = 1 << 3;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_ON_DEMAND_TIME = 1 << 4;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_GEOFENCING = 1 << 5;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_MEASUREMENTS = 1 << 6;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_NAV_MESSAGES = 1 << 7;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_LOW_POWER_MODE = 1 << 8;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_SATELLITE_BLOCKLIST = 1 << 9;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS = 1 << 10;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_ANTENNA_INFO = 1 << 11;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_CORRELATION_VECTOR = 1 << 12;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_SATELLITE_PVT = 1 << 13;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS_FOR_DRIVING = 1 << 14;
|
|
/** @hide */
|
|
public static final int TOP_HAL_CAPABILITY_ACCUMULATED_DELTA_RANGE = 1 << 15;
|
|
|
|
/** @hide */
|
|
@IntDef(flag = true, prefix = {"TOP_HAL_CAPABILITY_"}, value = {TOP_HAL_CAPABILITY_SCHEDULING,
|
|
TOP_HAL_CAPABILITY_MSB, TOP_HAL_CAPABILITY_MSA, TOP_HAL_CAPABILITY_SINGLE_SHOT,
|
|
TOP_HAL_CAPABILITY_ON_DEMAND_TIME, TOP_HAL_CAPABILITY_GEOFENCING,
|
|
TOP_HAL_CAPABILITY_MEASUREMENTS, TOP_HAL_CAPABILITY_NAV_MESSAGES,
|
|
TOP_HAL_CAPABILITY_LOW_POWER_MODE, TOP_HAL_CAPABILITY_SATELLITE_BLOCKLIST,
|
|
TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS, TOP_HAL_CAPABILITY_ANTENNA_INFO,
|
|
TOP_HAL_CAPABILITY_CORRELATION_VECTOR, TOP_HAL_CAPABILITY_SATELLITE_PVT,
|
|
TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS_FOR_DRIVING,
|
|
TOP_HAL_CAPABILITY_ACCUMULATED_DELTA_RANGE})
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface TopHalCapabilityFlags {}
|
|
|
|
// IMPORTANT - must match the Capabilities enum in IMeasurementCorrectionsCallback.hal
|
|
/** @hide */
|
|
public static final int SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_LOS_SATS = 1;
|
|
/** @hide */
|
|
public static final int SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_EXCESS_PATH_LENGTH = 2;
|
|
/** @hide */
|
|
public static final int SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_REFLECTING_PLANE = 4;
|
|
|
|
/** @hide */
|
|
@IntDef(flag = true, prefix = {"SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_"}, value = {
|
|
SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_LOS_SATS,
|
|
SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_EXCESS_PATH_LENGTH,
|
|
SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_REFLECTING_PLANE})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface SubHalMeasurementCorrectionsCapabilityFlags {}
|
|
|
|
// IMPORATANT - must match values in IGnssPowerIndicationCallback.aidl
|
|
/** @hide */
|
|
public static final int SUB_HAL_POWER_CAPABILITY_TOTAL = 1;
|
|
/** @hide */
|
|
public static final int SUB_HAL_POWER_CAPABILITY_SINGLEBAND_TRACKING = 2;
|
|
/** @hide */
|
|
public static final int SUB_HAL_POWER_CAPABILITY_MULTIBAND_TRACKING = 4;
|
|
/** @hide */
|
|
public static final int SUB_HAL_POWER_CAPABILITY_SINGLEBAND_ACQUISITION = 8;
|
|
/** @hide */
|
|
public static final int SUB_HAL_POWER_CAPABILITY_MULTIBAND_ACQUISITION = 16;
|
|
/** @hide */
|
|
public static final int SUB_HAL_POWER_CAPABILITY_OTHER_MODES = 32;
|
|
|
|
/** @hide */
|
|
@IntDef(flag = true, prefix = {"SUB_HAL_POWER_CAPABILITY_"}, value = {
|
|
SUB_HAL_POWER_CAPABILITY_TOTAL, SUB_HAL_POWER_CAPABILITY_SINGLEBAND_TRACKING,
|
|
SUB_HAL_POWER_CAPABILITY_MULTIBAND_TRACKING,
|
|
SUB_HAL_POWER_CAPABILITY_SINGLEBAND_ACQUISITION,
|
|
SUB_HAL_POWER_CAPABILITY_MULTIBAND_ACQUISITION,
|
|
SUB_HAL_POWER_CAPABILITY_OTHER_MODES})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface SubHalPowerCapabilityFlags {}
|
|
|
|
/** The capability is unknown to be supported or not. */
|
|
public static final int CAPABILITY_UNKNOWN = 0;
|
|
/** The capability is supported. */
|
|
public static final int CAPABILITY_SUPPORTED = 1;
|
|
/** The capability is not supported. */
|
|
public static final int CAPABILITY_UNSUPPORTED = 2;
|
|
|
|
/** @hide */
|
|
@IntDef(flag = true, prefix = {"CAPABILITY_"}, value = {CAPABILITY_UNKNOWN,
|
|
CAPABILITY_SUPPORTED,
|
|
CAPABILITY_UNSUPPORTED})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface CapabilitySupportType {}
|
|
|
|
|
|
/**
|
|
* Returns an empty GnssCapabilities object.
|
|
*
|
|
* @hide
|
|
*/
|
|
public static GnssCapabilities empty() {
|
|
return new GnssCapabilities(/*topFlags=*/ 0, /*isAdrCapabilityKnown=*/ false,
|
|
/*measurementCorrectionsFlags=*/ 0, /*powerFlags=*/ 0, /*gnssSignalTypes=*/
|
|
Collections.emptyList());
|
|
}
|
|
|
|
private final @TopHalCapabilityFlags int mTopFlags;
|
|
private final boolean mIsAdrCapabilityKnown;
|
|
private final @SubHalMeasurementCorrectionsCapabilityFlags int mMeasurementCorrectionsFlags;
|
|
private final @SubHalPowerCapabilityFlags int mPowerFlags;
|
|
private final @NonNull List<GnssSignalType> mGnssSignalTypes;
|
|
|
|
private GnssCapabilities(
|
|
@TopHalCapabilityFlags int topFlags,
|
|
boolean isAdrCapabilityKnown,
|
|
@SubHalMeasurementCorrectionsCapabilityFlags int measurementCorrectionsFlags,
|
|
@SubHalPowerCapabilityFlags int powerFlags,
|
|
@NonNull List<GnssSignalType> gnssSignalTypes) {
|
|
Objects.requireNonNull(gnssSignalTypes);
|
|
mTopFlags = topFlags;
|
|
mIsAdrCapabilityKnown = isAdrCapabilityKnown;
|
|
mMeasurementCorrectionsFlags = measurementCorrectionsFlags;
|
|
mPowerFlags = powerFlags;
|
|
mGnssSignalTypes = Collections.unmodifiableList(gnssSignalTypes);
|
|
}
|
|
|
|
/**
|
|
* Returns a new GnssCapabilities object with top hal values set from the given flags.
|
|
*
|
|
* @hide
|
|
*/
|
|
public GnssCapabilities withTopHalFlags(@TopHalCapabilityFlags int flags,
|
|
boolean isAdrCapabilityKnown) {
|
|
if (mTopFlags == flags && mIsAdrCapabilityKnown == isAdrCapabilityKnown) {
|
|
return this;
|
|
} else {
|
|
return new GnssCapabilities(flags, isAdrCapabilityKnown,
|
|
mMeasurementCorrectionsFlags, mPowerFlags, mGnssSignalTypes);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a new GnssCapabilities object with gnss measurement corrections sub hal values set
|
|
* from the given flags.
|
|
*
|
|
* @hide
|
|
*/
|
|
public GnssCapabilities withSubHalMeasurementCorrectionsFlags(
|
|
@SubHalMeasurementCorrectionsCapabilityFlags int flags) {
|
|
if (mMeasurementCorrectionsFlags == flags) {
|
|
return this;
|
|
} else {
|
|
return new GnssCapabilities(mTopFlags, mIsAdrCapabilityKnown, flags, mPowerFlags,
|
|
mGnssSignalTypes);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a new GnssCapabilities object with gnss measurement corrections sub hal values set
|
|
* from the given flags.
|
|
*
|
|
* @hide
|
|
*/
|
|
public GnssCapabilities withSubHalPowerFlags(@SubHalPowerCapabilityFlags int flags) {
|
|
if (mPowerFlags == flags) {
|
|
return this;
|
|
} else {
|
|
return new GnssCapabilities(mTopFlags, mIsAdrCapabilityKnown,
|
|
mMeasurementCorrectionsFlags, flags, mGnssSignalTypes);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a new GnssCapabilities object with a list of GnssSignalType.
|
|
*
|
|
* @hide
|
|
*/
|
|
public GnssCapabilities withSignalTypes(@NonNull List<GnssSignalType> gnssSignalTypes) {
|
|
Objects.requireNonNull(gnssSignalTypes);
|
|
if (mGnssSignalTypes.equals(gnssSignalTypes)) {
|
|
return this;
|
|
} else {
|
|
return new GnssCapabilities(mTopFlags, mIsAdrCapabilityKnown,
|
|
mMeasurementCorrectionsFlags, mPowerFlags, new ArrayList<>(gnssSignalTypes));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports scheduling, {@code false} otherwise.
|
|
*/
|
|
public boolean hasScheduling() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_SCHEDULING) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports Mobile Station Based assistance, {@code false}
|
|
* otherwise.
|
|
*/
|
|
public boolean hasMsb() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_MSB) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports Mobile Station Assisted assitance,
|
|
* {@code false} otherwise.
|
|
*/
|
|
public boolean hasMsa() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_MSA) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports single shot locating, {@code false} otherwise.
|
|
*/
|
|
public boolean hasSingleShotFix() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_SINGLE_SHOT) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset requests periodic time signal injection from the
|
|
* platform in addition to on-demand and occasional time updates, {@code false} otherwise.
|
|
*
|
|
* <p><em>Note: The naming of this capability and the behavior it controls differ substantially.
|
|
* This is the result of a historic implementation bug, b/73893222.</em>
|
|
*/
|
|
public boolean hasOnDemandTime() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_ON_DEMAND_TIME) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports geofencing, {@code false} otherwise.
|
|
*/
|
|
public boolean hasGeofencing() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_GEOFENCING) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measurements, {@code false} otherwise.
|
|
*
|
|
* @see LocationManager#registerGnssMeasurementsCallback(Executor, GnssMeasurementsEvent.Callback)
|
|
*/
|
|
public boolean hasMeasurements() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_MEASUREMENTS) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports navigation messages, {@code false} otherwise.
|
|
*
|
|
* @deprecated Use {@link #hasNavigationMessages()} instead.
|
|
*
|
|
* @hide
|
|
*/
|
|
@Deprecated
|
|
@SystemApi
|
|
public boolean hasNavMessages() {
|
|
return hasNavigationMessages();
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports navigation messages, {@code false} otherwise.
|
|
*
|
|
* @see LocationManager#registerGnssNavigationMessageCallback(Executor, GnssNavigationMessage.Callback)
|
|
*/
|
|
public boolean hasNavigationMessages() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_NAV_MESSAGES) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports low power mode, {@code false} otherwise.
|
|
*
|
|
* <p>The low power mode is defined in GNSS HAL. When the low power mode is active, the GNSS
|
|
* hardware must make strong tradeoffs to substantially restrict power use.
|
|
*/
|
|
public boolean hasLowPowerMode() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_LOW_POWER_MODE) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports satellite blocklists, {@code false} otherwise.
|
|
*
|
|
* @deprecated Use {@link #hasSatelliteBlocklist} instead.
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@Deprecated
|
|
public boolean hasSatelliteBlacklist() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_SATELLITE_BLOCKLIST) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports satellite blocklists, {@code false} otherwise.
|
|
*/
|
|
public boolean hasSatelliteBlocklist() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_SATELLITE_BLOCKLIST) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports satellite PVT, {@code false} otherwise.
|
|
*/
|
|
public boolean hasSatellitePvt() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_SATELLITE_PVT) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measurement corrections, {@code false}
|
|
* otherwise.
|
|
*/
|
|
public boolean hasMeasurementCorrections() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports antenna info, {@code false} otherwise.
|
|
*
|
|
* @deprecated Use {@link #hasAntennaInfo()} instead.
|
|
*/
|
|
@Deprecated
|
|
public boolean hasGnssAntennaInfo() {
|
|
return hasAntennaInfo();
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports antenna info, {@code false} otherwise.
|
|
*
|
|
* @see LocationManager#registerAntennaInfoListener(Executor, GnssAntennaInfo.Listener)
|
|
*/
|
|
public boolean hasAntennaInfo() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_ANTENNA_INFO) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports correlation vectors as part of measurements
|
|
* outputs, {@code false} otherwise.
|
|
*/
|
|
public boolean hasMeasurementCorrelationVectors() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_CORRELATION_VECTOR) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset will benefit from measurement corrections for driving
|
|
* use case if provided, {@code false} otherwise.
|
|
*/
|
|
public boolean hasMeasurementCorrectionsForDriving() {
|
|
return (mTopFlags & TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS_FOR_DRIVING) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@link #CAPABILITY_SUPPORTED} if GNSS chipset supports accumulated delta
|
|
* range, {@link #CAPABILITY_UNSUPPORTED} if GNSS chipset does not support accumulated
|
|
* delta range, and {@link #CAPABILITY_UNKNOWN} if it is unknown, which means GNSS
|
|
* chipset may or may not support accumulated delta range.
|
|
*
|
|
* <p>The accumulated delta range information can be queried in
|
|
* {@link android.location.GnssMeasurement#getAccumulatedDeltaRangeState()},
|
|
* {@link android.location.GnssMeasurement#getAccumulatedDeltaRangeMeters()}, and
|
|
* {@link android.location.GnssMeasurement#getAccumulatedDeltaRangeUncertaintyMeters()}.
|
|
*/
|
|
public @CapabilitySupportType int hasAccumulatedDeltaRange() {
|
|
if (!mIsAdrCapabilityKnown) {
|
|
return CAPABILITY_UNKNOWN;
|
|
}
|
|
if ((mTopFlags & TOP_HAL_CAPABILITY_ACCUMULATED_DELTA_RANGE) != 0) {
|
|
return CAPABILITY_SUPPORTED;
|
|
} else {
|
|
return CAPABILITY_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports line-of-sight satellite identification
|
|
* measurement corrections, {@code false} otherwise.
|
|
*/
|
|
public boolean hasMeasurementCorrectionsLosSats() {
|
|
return (mMeasurementCorrectionsFlags & SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_LOS_SATS)
|
|
!= 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports per satellite excess-path-length measurement
|
|
* corrections, {@code false} otherwise.
|
|
*/
|
|
public boolean hasMeasurementCorrectionsExcessPathLength() {
|
|
return (mMeasurementCorrectionsFlags
|
|
& SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_EXCESS_PATH_LENGTH) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports reflecting plane measurement corrections,
|
|
* {@code false} otherwise.
|
|
*
|
|
* @deprecated Use {@link #hasMeasurementCorrectionsReflectingPlane()} instead.
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public boolean hasMeasurementCorrectionsReflectingPane() {
|
|
return hasMeasurementCorrectionsReflectingPlane();
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports reflecting plane measurement corrections,
|
|
* {@code false} otherwise.
|
|
*/
|
|
public boolean hasMeasurementCorrectionsReflectingPlane() {
|
|
return (mMeasurementCorrectionsFlags
|
|
& SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_REFLECTING_PLANE) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measuring power totals, {@code false}
|
|
* otherwise.
|
|
*/
|
|
public boolean hasPowerTotal() {
|
|
return (mPowerFlags & SUB_HAL_POWER_CAPABILITY_TOTAL) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measuring single-band tracking power,
|
|
* {@code false} otherwise.
|
|
*/
|
|
public boolean hasPowerSinglebandTracking() {
|
|
return (mPowerFlags & SUB_HAL_POWER_CAPABILITY_SINGLEBAND_TRACKING) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measuring multi-band tracking power,
|
|
* {@code false} otherwise.
|
|
*/
|
|
public boolean hasPowerMultibandTracking() {
|
|
return (mPowerFlags & SUB_HAL_POWER_CAPABILITY_MULTIBAND_TRACKING) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measuring single-band acquisition power,
|
|
* {@code false} otherwise.
|
|
*/
|
|
public boolean hasPowerSinglebandAcquisition() {
|
|
return (mPowerFlags & SUB_HAL_POWER_CAPABILITY_SINGLEBAND_ACQUISITION) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measuring multi-band acquisition power,
|
|
* {@code false} otherwise.
|
|
*/
|
|
public boolean hasPowerMultibandAcquisition() {
|
|
return (mPowerFlags & SUB_HAL_POWER_CAPABILITY_MULTIBAND_ACQUISITION) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns {@code true} if GNSS chipset supports measuring OEM defined mode power, {@code false}
|
|
* otherwise.
|
|
*/
|
|
public boolean hasPowerOtherModes() {
|
|
return (mPowerFlags & SUB_HAL_POWER_CAPABILITY_OTHER_MODES) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of {@link GnssSignalType}s that the GNSS chipset supports.
|
|
*/
|
|
@NonNull
|
|
public List<GnssSignalType> getGnssSignalTypes() {
|
|
return mGnssSignalTypes;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) {
|
|
return true;
|
|
}
|
|
if (!(o instanceof GnssCapabilities)) {
|
|
return false;
|
|
}
|
|
|
|
GnssCapabilities that = (GnssCapabilities) o;
|
|
return mTopFlags == that.mTopFlags
|
|
&& mIsAdrCapabilityKnown == that.mIsAdrCapabilityKnown
|
|
&& mMeasurementCorrectionsFlags == that.mMeasurementCorrectionsFlags
|
|
&& mPowerFlags == that.mPowerFlags
|
|
&& mGnssSignalTypes.equals(that.mGnssSignalTypes);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mTopFlags, mIsAdrCapabilityKnown, mMeasurementCorrectionsFlags,
|
|
mPowerFlags, mGnssSignalTypes);
|
|
}
|
|
|
|
public static final @NonNull Creator<GnssCapabilities> CREATOR =
|
|
new Creator<GnssCapabilities>() {
|
|
@Override
|
|
public GnssCapabilities createFromParcel(Parcel in) {
|
|
return new GnssCapabilities(in.readInt(), in.readBoolean(), in.readInt(),
|
|
in.readInt(), in.createTypedArrayList(GnssSignalType.CREATOR));
|
|
}
|
|
|
|
@Override
|
|
public GnssCapabilities[] newArray(int size) {
|
|
return new GnssCapabilities[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel parcel, int flags) {
|
|
parcel.writeInt(mTopFlags);
|
|
parcel.writeBoolean(mIsAdrCapabilityKnown);
|
|
parcel.writeInt(mMeasurementCorrectionsFlags);
|
|
parcel.writeInt(mPowerFlags);
|
|
parcel.writeTypedList(mGnssSignalTypes);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.append("[");
|
|
if (hasScheduling()) {
|
|
builder.append("SCHEDULING ");
|
|
}
|
|
if (hasMsb()) {
|
|
builder.append("MSB ");
|
|
}
|
|
if (hasMsa()) {
|
|
builder.append("MSA ");
|
|
}
|
|
if (hasSingleShotFix()) {
|
|
builder.append("SINGLE_SHOT ");
|
|
}
|
|
if (hasOnDemandTime()) {
|
|
builder.append("ON_DEMAND_TIME ");
|
|
}
|
|
if (hasGeofencing()) {
|
|
builder.append("GEOFENCING ");
|
|
}
|
|
if (hasMeasurementCorrections()) {
|
|
builder.append("MEASUREMENTS ");
|
|
}
|
|
if (hasNavigationMessages()) {
|
|
builder.append("NAVIGATION_MESSAGES ");
|
|
}
|
|
if (hasLowPowerMode()) {
|
|
builder.append("LOW_POWER_MODE ");
|
|
}
|
|
if (hasSatelliteBlocklist()) {
|
|
builder.append("SATELLITE_BLOCKLIST ");
|
|
}
|
|
if (hasSatellitePvt()) {
|
|
builder.append("SATELLITE_PVT ");
|
|
}
|
|
if (hasMeasurementCorrections()) {
|
|
builder.append("MEASUREMENT_CORRECTIONS ");
|
|
}
|
|
if (hasAntennaInfo()) {
|
|
builder.append("ANTENNA_INFO ");
|
|
}
|
|
if (hasMeasurementCorrelationVectors()) {
|
|
builder.append("MEASUREMENT_CORRELATION_VECTORS ");
|
|
}
|
|
if (hasMeasurementCorrectionsForDriving()) {
|
|
builder.append("MEASUREMENT_CORRECTIONS_FOR_DRIVING ");
|
|
}
|
|
if (hasAccumulatedDeltaRange() == CAPABILITY_SUPPORTED) {
|
|
builder.append("ACCUMULATED_DELTA_RANGE ");
|
|
} else if (hasAccumulatedDeltaRange() == CAPABILITY_UNKNOWN) {
|
|
builder.append("ACCUMULATED_DELTA_RANGE(unknown) ");
|
|
}
|
|
if (hasMeasurementCorrectionsLosSats()) {
|
|
builder.append("LOS_SATS ");
|
|
}
|
|
if (hasMeasurementCorrectionsExcessPathLength()) {
|
|
builder.append("EXCESS_PATH_LENGTH ");
|
|
}
|
|
if (hasMeasurementCorrectionsReflectingPlane()) {
|
|
builder.append("REFLECTING_PLANE ");
|
|
}
|
|
if (hasPowerTotal()) {
|
|
builder.append("TOTAL_POWER ");
|
|
}
|
|
if (hasPowerSinglebandTracking()) {
|
|
builder.append("SINGLEBAND_TRACKING_POWER ");
|
|
}
|
|
if (hasPowerMultibandTracking()) {
|
|
builder.append("MULTIBAND_TRACKING_POWER ");
|
|
}
|
|
if (hasPowerSinglebandAcquisition()) {
|
|
builder.append("SINGLEBAND_ACQUISITION_POWER ");
|
|
}
|
|
if (hasPowerMultibandAcquisition()) {
|
|
builder.append("MULTIBAND_ACQUISITION_POWER ");
|
|
}
|
|
if (hasPowerOtherModes()) {
|
|
builder.append("OTHER_MODES_POWER ");
|
|
}
|
|
if (!mGnssSignalTypes.isEmpty()) {
|
|
builder.append("signalTypes=").append(mGnssSignalTypes).append(" ");
|
|
}
|
|
if (builder.length() > 1) {
|
|
builder.setLength(builder.length() - 1);
|
|
} else {
|
|
builder.append("NONE");
|
|
}
|
|
builder.append("]");
|
|
return builder.toString();
|
|
}
|
|
|
|
/**
|
|
* Builder for GnssCapabilities.
|
|
*/
|
|
public static final class Builder {
|
|
|
|
private @TopHalCapabilityFlags int mTopFlags;
|
|
private boolean mIsAdrCapabilityKnown;
|
|
private @SubHalMeasurementCorrectionsCapabilityFlags int mMeasurementCorrectionsFlags;
|
|
private @SubHalPowerCapabilityFlags int mPowerFlags;
|
|
private @NonNull List<GnssSignalType> mGnssSignalTypes;
|
|
|
|
public Builder() {
|
|
mTopFlags = 0;
|
|
mIsAdrCapabilityKnown = false;
|
|
mMeasurementCorrectionsFlags = 0;
|
|
mPowerFlags = 0;
|
|
mGnssSignalTypes = Collections.emptyList();
|
|
}
|
|
|
|
public Builder(@NonNull GnssCapabilities capabilities) {
|
|
mTopFlags = capabilities.mTopFlags;
|
|
mIsAdrCapabilityKnown = capabilities.mIsAdrCapabilityKnown;
|
|
mMeasurementCorrectionsFlags = capabilities.mMeasurementCorrectionsFlags;
|
|
mPowerFlags = capabilities.mPowerFlags;
|
|
mGnssSignalTypes = capabilities.mGnssSignalTypes;
|
|
}
|
|
|
|
/**
|
|
* Sets scheduling capability.
|
|
*/
|
|
public @NonNull Builder setHasScheduling(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_SCHEDULING, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets Mobile Station Based capability.
|
|
*/
|
|
public @NonNull Builder setHasMsb(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_MSB, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets Mobile Station Assisted capability.
|
|
*/
|
|
public @NonNull Builder setHasMsa(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_MSA, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets single shot locating capability.
|
|
*/
|
|
public @NonNull Builder setHasSingleShotFix(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_SINGLE_SHOT, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets on demand time capability.
|
|
*/
|
|
public @NonNull Builder setHasOnDemandTime(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_ON_DEMAND_TIME, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets geofencing capability.
|
|
*/
|
|
public @NonNull Builder setHasGeofencing(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_GEOFENCING, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets measurements capability.
|
|
*/
|
|
public @NonNull Builder setHasMeasurements(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_MEASUREMENTS, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets navigation messages capability.
|
|
*/
|
|
public @NonNull Builder setHasNavigationMessages(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_NAV_MESSAGES, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets low power mode capability.
|
|
*
|
|
* <p>The low power mode is defined in GNSS HAL. When the low power mode is active, the GNSS
|
|
* hardware must make strong tradeoffs to substantially restrict power use.
|
|
*/
|
|
public @NonNull Builder setHasLowPowerMode(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_LOW_POWER_MODE, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets satellite blocklist capability.
|
|
*/
|
|
public @NonNull Builder setHasSatelliteBlocklist(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_SATELLITE_BLOCKLIST, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets satellite PVT capability.
|
|
*/
|
|
public @NonNull Builder setHasSatellitePvt(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_SATELLITE_PVT, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets measurement corrections capability.
|
|
*/
|
|
public @NonNull Builder setHasMeasurementCorrections(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets antenna info capability.
|
|
*/
|
|
public @NonNull Builder setHasAntennaInfo(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_ANTENNA_INFO, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets correlation vector capability.
|
|
*/
|
|
public @NonNull Builder setHasMeasurementCorrelationVectors(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_CORRELATION_VECTOR, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets measurement corrections for driving capability.
|
|
*/
|
|
public @NonNull Builder setHasMeasurementCorrectionsForDriving(boolean capable) {
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_MEASUREMENT_CORRECTIONS_FOR_DRIVING,
|
|
capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets accumulated delta range capability.
|
|
*/
|
|
public @NonNull Builder setHasAccumulatedDeltaRange(@CapabilitySupportType int capable) {
|
|
if (capable == CAPABILITY_UNKNOWN) {
|
|
mIsAdrCapabilityKnown = false;
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_ACCUMULATED_DELTA_RANGE, false);
|
|
} else if (capable == CAPABILITY_SUPPORTED) {
|
|
mIsAdrCapabilityKnown = true;
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_ACCUMULATED_DELTA_RANGE, true);
|
|
} else if (capable == CAPABILITY_UNSUPPORTED) {
|
|
mIsAdrCapabilityKnown = true;
|
|
mTopFlags = setFlag(mTopFlags, TOP_HAL_CAPABILITY_ACCUMULATED_DELTA_RANGE, false);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets measurement corrections line-of-sight satellites capability.
|
|
*/
|
|
public @NonNull Builder setHasMeasurementCorrectionsLosSats(boolean capable) {
|
|
mMeasurementCorrectionsFlags = setFlag(mMeasurementCorrectionsFlags,
|
|
SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_LOS_SATS, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets measurement corrections excess path length capability.
|
|
*/
|
|
public @NonNull Builder setHasMeasurementCorrectionsExcessPathLength(boolean capable) {
|
|
mMeasurementCorrectionsFlags = setFlag(mMeasurementCorrectionsFlags,
|
|
SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_EXCESS_PATH_LENGTH, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets measurement corrections reflecting plane capability.
|
|
*/
|
|
public @NonNull Builder setHasMeasurementCorrectionsReflectingPlane(boolean capable) {
|
|
mMeasurementCorrectionsFlags = setFlag(mMeasurementCorrectionsFlags,
|
|
SUB_HAL_MEASUREMENT_CORRECTIONS_CAPABILITY_REFLECTING_PLANE, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets power totals capability.
|
|
*/
|
|
public @NonNull Builder setHasPowerTotal(boolean capable) {
|
|
mPowerFlags = setFlag(mPowerFlags, SUB_HAL_POWER_CAPABILITY_TOTAL, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets power single-band tracking capability.
|
|
*/
|
|
public @NonNull Builder setHasPowerSinglebandTracking(boolean capable) {
|
|
mPowerFlags = setFlag(mPowerFlags, SUB_HAL_POWER_CAPABILITY_SINGLEBAND_TRACKING,
|
|
capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets power multi-band tracking capability.
|
|
*/
|
|
public @NonNull Builder setHasPowerMultibandTracking(boolean capable) {
|
|
mPowerFlags = setFlag(mPowerFlags, SUB_HAL_POWER_CAPABILITY_MULTIBAND_TRACKING,
|
|
capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets power single-band acquisition capability.
|
|
*/
|
|
public @NonNull Builder setHasPowerSinglebandAcquisition(boolean capable) {
|
|
mPowerFlags = setFlag(mPowerFlags, SUB_HAL_POWER_CAPABILITY_SINGLEBAND_ACQUISITION,
|
|
capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets power multi-band acquisition capability.
|
|
*/
|
|
public @NonNull Builder setHasPowerMultibandAcquisition(boolean capable) {
|
|
mPowerFlags = setFlag(mPowerFlags, SUB_HAL_POWER_CAPABILITY_MULTIBAND_ACQUISITION,
|
|
capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets OEM-defined power modes capability.
|
|
*/
|
|
public @NonNull Builder setHasPowerOtherModes(boolean capable) {
|
|
mPowerFlags = setFlag(mPowerFlags, SUB_HAL_POWER_CAPABILITY_OTHER_MODES, capable);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets a list of {@link GnssSignalType}.
|
|
*/
|
|
public @NonNull Builder setGnssSignalTypes(@NonNull List<GnssSignalType> gnssSignalTypes) {
|
|
mGnssSignalTypes = gnssSignalTypes;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Builds a new GnssCapabilities.
|
|
*/
|
|
public @NonNull GnssCapabilities build() {
|
|
return new GnssCapabilities(mTopFlags, mIsAdrCapabilityKnown,
|
|
mMeasurementCorrectionsFlags, mPowerFlags, new ArrayList<>(mGnssSignalTypes));
|
|
}
|
|
|
|
private static int setFlag(int value, int flag, boolean set) {
|
|
if (set) {
|
|
return value | flag;
|
|
} else {
|
|
return value & ~flag;
|
|
}
|
|
}
|
|
}
|
|
}
|