CrackMe.apk
Download file
package androidx.core.location;
import android.location.LocationRequest;
import android.os.Build;
import androidx.core.util.Preconditions;
import androidx.core.util.TimeUtils;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public final class LocationRequestCompat {
private static final long IMPLICIT_MIN_UPDATE_INTERVAL = -1;
public static final long PASSIVE_INTERVAL = Long.MAX_VALUE;
public static final int QUALITY_BALANCED_POWER_ACCURACY = 102;
public static final int QUALITY_HIGH_ACCURACY = 100;
public static final int QUALITY_LOW_POWER = 104;
private static Method sCreateFromDeprecatedProviderMethod;
private static Method sSetExpireInMethod;
private static Method sSetFastestIntervalMethod;
private static Method sSetNumUpdatesMethod;
private static Method sSetQualityMethod;
final long mDurationMillis;
final long mIntervalMillis;
final long mMaxUpdateDelayMillis;
final int mMaxUpdates;
final float mMinUpdateDistanceMeters;
final long mMinUpdateIntervalMillis;
final int mQuality;
@Retention(RetentionPolicy.SOURCE)
public @interface Quality {
}
LocationRequestCompat(long j, int i, long j2, int i2, long j3, float f, long j4) {
this.mIntervalMillis = j;
this.mQuality = i;
this.mMinUpdateIntervalMillis = j3;
this.mDurationMillis = j2;
this.mMaxUpdates = i2;
this.mMinUpdateDistanceMeters = f;
this.mMaxUpdateDelayMillis = j4;
}
public int getQuality() {
return this.mQuality;
}
public long getIntervalMillis() {
return this.mIntervalMillis;
}
public long getMinUpdateIntervalMillis() {
long j = this.mMinUpdateIntervalMillis;
return j == -1 ? this.mIntervalMillis : j;
}
public long getDurationMillis() {
return this.mDurationMillis;
}
public int getMaxUpdates() {
return this.mMaxUpdates;
}
public float getMinUpdateDistanceMeters() {
return this.mMinUpdateDistanceMeters;
}
public long getMaxUpdateDelayMillis() {
return this.mMaxUpdateDelayMillis;
}
public LocationRequest toLocationRequest() {
return new LocationRequest.Builder(this.mIntervalMillis).setQuality(this.mQuality).setMinUpdateIntervalMillis(this.mMinUpdateIntervalMillis).setDurationMillis(this.mDurationMillis).setMaxUpdates(this.mMaxUpdates).setMinUpdateDistanceMeters(this.mMinUpdateDistanceMeters).setMaxUpdateDelayMillis(this.mMaxUpdateDelayMillis).build();
}
public LocationRequest toLocationRequest(String str) {
if (Build.VERSION.SDK_INT >= 31) {
return toLocationRequest();
}
try {
if (sCreateFromDeprecatedProviderMethod == null) {
Method declaredMethod = LocationRequest.class.getDeclaredMethod("createFromDeprecatedProvider", new Class[]{String.class, Long.TYPE, Float.TYPE, Boolean.TYPE});
sCreateFromDeprecatedProviderMethod = declaredMethod;
declaredMethod.setAccessible(true);
}
LocationRequest locationRequest = (LocationRequest) sCreateFromDeprecatedProviderMethod.invoke((Object) null, new Object[]{str, Long.valueOf(this.mIntervalMillis), Float.valueOf(this.mMinUpdateDistanceMeters), false});
if (locationRequest == null) {
return null;
}
if (sSetQualityMethod == null) {
Method declaredMethod2 = LocationRequest.class.getDeclaredMethod("setQuality", new Class[]{Integer.TYPE});
sSetQualityMethod = declaredMethod2;
declaredMethod2.setAccessible(true);
}
sSetQualityMethod.invoke(locationRequest, new Object[]{Integer.valueOf(this.mQuality)});
if (getMinUpdateIntervalMillis() != this.mIntervalMillis) {
if (sSetFastestIntervalMethod == null) {
Method declaredMethod3 = LocationRequest.class.getDeclaredMethod("setFastestInterval", new Class[]{Long.TYPE});
sSetFastestIntervalMethod = declaredMethod3;
declaredMethod3.setAccessible(true);
}
sSetFastestIntervalMethod.invoke(locationRequest, new Object[]{Long.valueOf(this.mMinUpdateIntervalMillis)});
}
if (this.mMaxUpdates < Integer.MAX_VALUE) {
if (sSetNumUpdatesMethod == null) {
Method declaredMethod4 = LocationRequest.class.getDeclaredMethod("setNumUpdates", new Class[]{Integer.TYPE});
sSetNumUpdatesMethod = declaredMethod4;
declaredMethod4.setAccessible(true);
}
sSetNumUpdatesMethod.invoke(locationRequest, new Object[]{Integer.valueOf(this.mMaxUpdates)});
}
if (this.mDurationMillis < Long.MAX_VALUE) {
if (sSetExpireInMethod == null) {
Method declaredMethod5 = LocationRequest.class.getDeclaredMethod("setExpireIn", new Class[]{Long.TYPE});
sSetExpireInMethod = declaredMethod5;
declaredMethod5.setAccessible(true);
}
sSetExpireInMethod.invoke(locationRequest, new Object[]{Long.valueOf(this.mDurationMillis)});
}
return locationRequest;
} catch (IllegalAccessException | NoSuchMethodException | InvocationTargetException unused) {
return null;
}
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof LocationRequestCompat)) {
return false;
}
LocationRequestCompat locationRequestCompat = (LocationRequestCompat) obj;
if (this.mQuality == locationRequestCompat.mQuality && this.mIntervalMillis == locationRequestCompat.mIntervalMillis && this.mMinUpdateIntervalMillis == locationRequestCompat.mMinUpdateIntervalMillis && this.mDurationMillis == locationRequestCompat.mDurationMillis && this.mMaxUpdates == locationRequestCompat.mMaxUpdates && Float.compare(locationRequestCompat.mMinUpdateDistanceMeters, this.mMinUpdateDistanceMeters) == 0 && this.mMaxUpdateDelayMillis == locationRequestCompat.mMaxUpdateDelayMillis) {
return true;
}
return false;
}
public int hashCode() {
long j = this.mIntervalMillis;
long j2 = this.mMinUpdateIntervalMillis;
return (((this.mQuality * 31) + ((int) (j ^ (j >>> 32)))) * 31) + ((int) (j2 ^ (j2 >>> 32)));
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("Request[");
if (this.mIntervalMillis != Long.MAX_VALUE) {
sb.append("@");
TimeUtils.formatDuration(this.mIntervalMillis, sb);
int i = this.mQuality;
if (i == 100) {
sb.append(" HIGH_ACCURACY");
} else if (i == 102) {
sb.append(" BALANCED");
} else if (i == 104) {
sb.append(" LOW_POWER");
}
} else {
sb.append("PASSIVE");
}
if (this.mDurationMillis != Long.MAX_VALUE) {
sb.append(", duration=");
TimeUtils.formatDuration(this.mDurationMillis, sb);
}
if (this.mMaxUpdates != Integer.MAX_VALUE) {
sb.append(", maxUpdates=");
sb.append(this.mMaxUpdates);
}
long j = this.mMinUpdateIntervalMillis;
if (j != -1 && j < this.mIntervalMillis) {
sb.append(", minUpdateInterval=");
TimeUtils.formatDuration(this.mMinUpdateIntervalMillis, sb);
}
if (((double) this.mMinUpdateDistanceMeters) > 0.0d) {
sb.append(", minUpdateDistance=");
sb.append(this.mMinUpdateDistanceMeters);
}
if (this.mMaxUpdateDelayMillis / 2 > this.mIntervalMillis) {
sb.append(", maxUpdateDelay=");
TimeUtils.formatDuration(this.mMaxUpdateDelayMillis, sb);
}
sb.append(']');
return sb.toString();
}
public static final class Builder {
private long mDurationMillis;
private long mIntervalMillis;
private long mMaxUpdateDelayMillis;
private int mMaxUpdates;
private float mMinUpdateDistanceMeters;
private long mMinUpdateIntervalMillis;
private int mQuality;
public Builder(long j) {
setIntervalMillis(j);
this.mQuality = 102;
this.mDurationMillis = Long.MAX_VALUE;
this.mMaxUpdates = Integer.MAX_VALUE;
this.mMinUpdateIntervalMillis = -1;
this.mMinUpdateDistanceMeters = 0.0f;
this.mMaxUpdateDelayMillis = 0;
}
public Builder(LocationRequestCompat locationRequestCompat) {
this.mIntervalMillis = locationRequestCompat.mIntervalMillis;
this.mQuality = locationRequestCompat.mQuality;
this.mDurationMillis = locationRequestCompat.mDurationMillis;
this.mMaxUpdates = locationRequestCompat.mMaxUpdates;
this.mMinUpdateIntervalMillis = locationRequestCompat.mMinUpdateIntervalMillis;
this.mMinUpdateDistanceMeters = locationRequestCompat.mMinUpdateDistanceMeters;
this.mMaxUpdateDelayMillis = locationRequestCompat.mMaxUpdateDelayMillis;
}
public Builder setIntervalMillis(long j) {
this.mIntervalMillis = Preconditions.checkArgumentInRange(j, 0, Long.MAX_VALUE, "intervalMillis");
return this;
}
public Builder setQuality(int i) {
Preconditions.checkArgument(i == 104 || i == 102 || i == 100, "quality must be a defined QUALITY constant, not %d", Integer.valueOf(i));
this.mQuality = i;
return this;
}
public Builder setDurationMillis(long j) {
this.mDurationMillis = Preconditions.checkArgumentInRange(j, 1, Long.MAX_VALUE, "durationMillis");
return this;
}
public Builder setMaxUpdates(int i) {
this.mMaxUpdates = Preconditions.checkArgumentInRange(i, 1, Integer.MAX_VALUE, "maxUpdates");
return this;
}
public Builder setMinUpdateIntervalMillis(long j) {
this.mMinUpdateIntervalMillis = Preconditions.checkArgumentInRange(j, 0, Long.MAX_VALUE, "minUpdateIntervalMillis");
return this;
}
public Builder clearMinUpdateIntervalMillis() {
this.mMinUpdateIntervalMillis = -1;
return this;
}
public Builder setMinUpdateDistanceMeters(float f) {
this.mMinUpdateDistanceMeters = f;
this.mMinUpdateDistanceMeters = Preconditions.checkArgumentInRange(f, 0.0f, Float.MAX_VALUE, "minUpdateDistanceMeters");
return this;
}
public Builder setMaxUpdateDelayMillis(long j) {
this.mMaxUpdateDelayMillis = j;
this.mMaxUpdateDelayMillis = Preconditions.checkArgumentInRange(j, 0, Long.MAX_VALUE, "maxUpdateDelayMillis");
return this;
}
public LocationRequestCompat build() {
Preconditions.checkState((this.mIntervalMillis == Long.MAX_VALUE && this.mMinUpdateIntervalMillis == -1) ? false : true, "passive location requests must have an explicit minimum update interval");
long j = this.mIntervalMillis;
return new LocationRequestCompat(j, this.mQuality, this.mDurationMillis, this.mMaxUpdates, Math.min(this.mMinUpdateIntervalMillis, j), this.mMinUpdateDistanceMeters, this.mMaxUpdateDelayMillis);
}
}
}
Download file