741 lines
32 KiB
Java
741 lines
32 KiB
Java
package androidx.core.location;
|
|
|
|
import android.location.GnssStatus;
|
|
import android.location.GpsStatus;
|
|
import android.location.Location;
|
|
import android.location.LocationListener;
|
|
import android.location.LocationManager;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Looper;
|
|
import android.os.SystemClock;
|
|
import androidx.annotation.DoNotInline;
|
|
import androidx.annotation.GuardedBy;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RequiresApi;
|
|
import androidx.annotation.RequiresPermission;
|
|
import androidx.collection.SimpleArrayMap;
|
|
import androidx.core.location.GnssStatusCompat;
|
|
import androidx.core.os.CancellationSignal;
|
|
import androidx.core.os.ExecutorCompat;
|
|
import androidx.core.util.Consumer;
|
|
import androidx.core.util.Preconditions;
|
|
import java.lang.reflect.Field;
|
|
import java.util.concurrent.Callable;
|
|
import java.util.concurrent.ExecutionException;
|
|
import java.util.concurrent.Executor;
|
|
import java.util.concurrent.FutureTask;
|
|
import java.util.concurrent.RejectedExecutionException;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.concurrent.TimeoutException;
|
|
public final class LocationManagerCompat {
|
|
private static final long GET_CURRENT_LOCATION_TIMEOUT_MS = 30000;
|
|
private static final long MAX_CURRENT_LOCATION_AGE_MS = 10000;
|
|
private static final long PRE_N_LOOPER_TIMEOUT_S = 5;
|
|
private static Field sContextField;
|
|
@GuardedBy("sGnssStatusListeners")
|
|
private static final SimpleArrayMap<Object, Object> sGnssStatusListeners = new SimpleArrayMap<>();
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements Runnable {
|
|
public final /* synthetic */ Consumer val$consumer;
|
|
public final /* synthetic */ Location val$location;
|
|
|
|
public AnonymousClass1(Consumer consumer, Location location) {
|
|
this.val$consumer = consumer;
|
|
this.val$location = location;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
this.val$consumer.accept(this.val$location);
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$2 reason: invalid class name */
|
|
public class AnonymousClass2 implements CancellationSignal.OnCancelListener {
|
|
public final /* synthetic */ CancellableLocationListener val$listener;
|
|
|
|
public AnonymousClass2(CancellableLocationListener cancellableLocationListener) {
|
|
this.val$listener = cancellableLocationListener;
|
|
}
|
|
|
|
@Override // androidx.core.os.CancellationSignal.OnCancelListener
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
public void onCancel() {
|
|
this.val$listener.cancel();
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$3 reason: invalid class name */
|
|
public class AnonymousClass3 implements Callable<Boolean> {
|
|
public final /* synthetic */ LocationManager val$locationManager;
|
|
public final /* synthetic */ GpsStatusTransport val$myTransport;
|
|
|
|
public AnonymousClass3(LocationManager locationManager, GpsStatusTransport gpsStatusTransport) {
|
|
this.val$locationManager = locationManager;
|
|
this.val$myTransport = gpsStatusTransport;
|
|
}
|
|
|
|
@Override // java.util.concurrent.Callable
|
|
@RequiresPermission("android.permission.ACCESS_FINE_LOCATION")
|
|
public Boolean call() {
|
|
return Boolean.valueOf(this.val$locationManager.addGpsStatusListener(this.val$myTransport));
|
|
}
|
|
}
|
|
|
|
@RequiresApi(28)
|
|
public static class Api28Impl {
|
|
private Api28Impl() {
|
|
}
|
|
|
|
@DoNotInline
|
|
public static String getGnssHardwareModelName(LocationManager locationManager) {
|
|
return locationManager.getGnssHardwareModelName();
|
|
}
|
|
|
|
@DoNotInline
|
|
public static int getGnssYearOfHardware(LocationManager locationManager) {
|
|
return locationManager.getGnssYearOfHardware();
|
|
}
|
|
|
|
@DoNotInline
|
|
public static boolean isLocationEnabled(LocationManager locationManager) {
|
|
return locationManager.isLocationEnabled();
|
|
}
|
|
}
|
|
|
|
@RequiresApi(30)
|
|
public static class Api30Impl {
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$Api30Impl$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements java.util.function.Consumer<Location> {
|
|
public final /* synthetic */ Consumer val$consumer;
|
|
|
|
public AnonymousClass1(Consumer consumer) {
|
|
this.val$consumer = consumer;
|
|
}
|
|
|
|
public void accept(Location location) {
|
|
this.val$consumer.accept(location);
|
|
}
|
|
}
|
|
|
|
private Api30Impl() {
|
|
}
|
|
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
@DoNotInline
|
|
public static void getCurrentLocation(LocationManager locationManager, @NonNull String str, @Nullable CancellationSignal cancellationSignal, @NonNull Executor executor, @NonNull Consumer<Location> consumer) {
|
|
locationManager.getCurrentLocation(str, cancellationSignal != null ? (android.os.CancellationSignal) cancellationSignal.getCancellationSignalObject() : null, executor, new AnonymousClass1(consumer));
|
|
}
|
|
}
|
|
|
|
public static final class CancellableLocationListener implements LocationListener {
|
|
private Consumer<Location> mConsumer;
|
|
private final Executor mExecutor;
|
|
private final LocationManager mLocationManager;
|
|
private final Handler mTimeoutHandler = new Handler(Looper.getMainLooper());
|
|
@Nullable
|
|
public Runnable mTimeoutRunnable;
|
|
@GuardedBy("this")
|
|
private boolean mTriggered;
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$CancellableLocationListener$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements Runnable {
|
|
public AnonymousClass1() {
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
public void run() {
|
|
CancellableLocationListener cancellableLocationListener = CancellableLocationListener.this;
|
|
cancellableLocationListener.mTimeoutRunnable = null;
|
|
cancellableLocationListener.onLocationChanged(null);
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$CancellableLocationListener$2 reason: invalid class name */
|
|
public class AnonymousClass2 implements Runnable {
|
|
public final /* synthetic */ Consumer val$consumer;
|
|
public final /* synthetic */ Location val$location;
|
|
|
|
public AnonymousClass2(Consumer consumer, Location location) {
|
|
this.val$consumer = consumer;
|
|
this.val$location = location;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
this.val$consumer.accept(this.val$location);
|
|
}
|
|
}
|
|
|
|
public CancellableLocationListener(LocationManager locationManager, Executor executor, Consumer<Location> consumer) {
|
|
this.mLocationManager = locationManager;
|
|
this.mExecutor = executor;
|
|
this.mConsumer = consumer;
|
|
}
|
|
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
private void cleanup() {
|
|
this.mConsumer = null;
|
|
this.mLocationManager.removeUpdates(this);
|
|
Runnable runnable = this.mTimeoutRunnable;
|
|
if (runnable != null) {
|
|
this.mTimeoutHandler.removeCallbacks(runnable);
|
|
this.mTimeoutRunnable = null;
|
|
}
|
|
}
|
|
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
public void cancel() {
|
|
synchronized (this) {
|
|
if (!this.mTriggered) {
|
|
this.mTriggered = true;
|
|
cleanup();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.location.LocationListener
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
public void onLocationChanged(@Nullable Location location) {
|
|
synchronized (this) {
|
|
if (!this.mTriggered) {
|
|
this.mTriggered = true;
|
|
this.mExecutor.execute(new AnonymousClass2(this.mConsumer, location));
|
|
cleanup();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.location.LocationListener
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
public void onProviderDisabled(@NonNull String str) {
|
|
onLocationChanged(null);
|
|
}
|
|
|
|
@Override // android.location.LocationListener
|
|
public void onProviderEnabled(@NonNull String str) {
|
|
}
|
|
|
|
@Override // android.location.LocationListener
|
|
public void onStatusChanged(String str, int i, Bundle bundle) {
|
|
}
|
|
|
|
public void startTimeout(long j) {
|
|
synchronized (this) {
|
|
if (!this.mTriggered) {
|
|
AnonymousClass1 r0 = new AnonymousClass1();
|
|
this.mTimeoutRunnable = r0;
|
|
this.mTimeoutHandler.postDelayed(r0, j);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@RequiresApi(30)
|
|
public static class GnssStatusTransport extends GnssStatus.Callback {
|
|
public final GnssStatusCompat.Callback mCallback;
|
|
|
|
public GnssStatusTransport(GnssStatusCompat.Callback callback) {
|
|
Preconditions.checkArgument(callback != null, "invalid null callback");
|
|
this.mCallback = callback;
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onFirstFix(int i) {
|
|
this.mCallback.onFirstFix(i);
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onSatelliteStatusChanged(GnssStatus gnssStatus) {
|
|
this.mCallback.onSatelliteStatusChanged(GnssStatusCompat.wrap(gnssStatus));
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onStarted() {
|
|
this.mCallback.onStarted();
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onStopped() {
|
|
this.mCallback.onStopped();
|
|
}
|
|
}
|
|
|
|
public static class GpsStatusTransport implements GpsStatus.Listener {
|
|
public final GnssStatusCompat.Callback mCallback;
|
|
@Nullable
|
|
public volatile Executor mExecutor;
|
|
private final LocationManager mLocationManager;
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$GpsStatusTransport$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
|
|
public AnonymousClass1(Executor executor) {
|
|
this.val$executor = executor;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (GpsStatusTransport.this.mExecutor == this.val$executor) {
|
|
GpsStatusTransport.this.mCallback.onStarted();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$GpsStatusTransport$2 reason: invalid class name */
|
|
public class AnonymousClass2 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
|
|
public AnonymousClass2(Executor executor) {
|
|
this.val$executor = executor;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (GpsStatusTransport.this.mExecutor == this.val$executor) {
|
|
GpsStatusTransport.this.mCallback.onStopped();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$GpsStatusTransport$3 reason: invalid class name */
|
|
public class AnonymousClass3 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
public final /* synthetic */ int val$ttff;
|
|
|
|
public AnonymousClass3(Executor executor, int i) {
|
|
this.val$executor = executor;
|
|
this.val$ttff = i;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (GpsStatusTransport.this.mExecutor == this.val$executor) {
|
|
GpsStatusTransport.this.mCallback.onFirstFix(this.val$ttff);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$GpsStatusTransport$4 reason: invalid class name */
|
|
public class AnonymousClass4 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
public final /* synthetic */ GnssStatusCompat val$gnssStatus;
|
|
|
|
public AnonymousClass4(Executor executor, GnssStatusCompat gnssStatusCompat) {
|
|
this.val$executor = executor;
|
|
this.val$gnssStatus = gnssStatusCompat;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (GpsStatusTransport.this.mExecutor == this.val$executor) {
|
|
GpsStatusTransport.this.mCallback.onSatelliteStatusChanged(this.val$gnssStatus);
|
|
}
|
|
}
|
|
}
|
|
|
|
public GpsStatusTransport(LocationManager locationManager, GnssStatusCompat.Callback callback) {
|
|
Preconditions.checkArgument(callback != null, "invalid null callback");
|
|
this.mLocationManager = locationManager;
|
|
this.mCallback = callback;
|
|
}
|
|
|
|
@Override // android.location.GpsStatus.Listener
|
|
@RequiresPermission("android.permission.ACCESS_FINE_LOCATION")
|
|
public void onGpsStatusChanged(int i) {
|
|
GpsStatus gpsStatus;
|
|
Executor executor = this.mExecutor;
|
|
if (executor != null) {
|
|
if (i == 1) {
|
|
executor.execute(new AnonymousClass1(executor));
|
|
} else if (i == 2) {
|
|
executor.execute(new AnonymousClass2(executor));
|
|
} else if (i == 3) {
|
|
GpsStatus gpsStatus2 = this.mLocationManager.getGpsStatus(null);
|
|
if (gpsStatus2 != null) {
|
|
executor.execute(new AnonymousClass3(executor, gpsStatus2.getTimeToFirstFix()));
|
|
}
|
|
} else if (i == 4 && (gpsStatus = this.mLocationManager.getGpsStatus(null)) != null) {
|
|
executor.execute(new AnonymousClass4(executor, GnssStatusCompat.wrap(gpsStatus)));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void register(Executor executor) {
|
|
Preconditions.checkState(this.mExecutor == null);
|
|
this.mExecutor = executor;
|
|
}
|
|
|
|
public void unregister() {
|
|
this.mExecutor = null;
|
|
}
|
|
}
|
|
|
|
public static final class InlineHandlerExecutor implements Executor {
|
|
private final Handler mHandler;
|
|
|
|
public InlineHandlerExecutor(@NonNull Handler handler) {
|
|
this.mHandler = (Handler) Preconditions.checkNotNull(handler);
|
|
}
|
|
|
|
@Override // java.util.concurrent.Executor
|
|
public void execute(@NonNull Runnable runnable) {
|
|
if (Looper.myLooper() == this.mHandler.getLooper()) {
|
|
runnable.run();
|
|
} else if (!this.mHandler.post((Runnable) Preconditions.checkNotNull(runnable))) {
|
|
throw new RejectedExecutionException(this.mHandler + " is shutting down");
|
|
}
|
|
}
|
|
}
|
|
|
|
@RequiresApi(24)
|
|
public static class PreRGnssStatusTransport extends GnssStatus.Callback {
|
|
public final GnssStatusCompat.Callback mCallback;
|
|
@Nullable
|
|
public volatile Executor mExecutor;
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$PreRGnssStatusTransport$1 reason: invalid class name */
|
|
public class AnonymousClass1 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
|
|
public AnonymousClass1(Executor executor) {
|
|
this.val$executor = executor;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (PreRGnssStatusTransport.this.mExecutor == this.val$executor) {
|
|
PreRGnssStatusTransport.this.mCallback.onStarted();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$PreRGnssStatusTransport$2 reason: invalid class name */
|
|
public class AnonymousClass2 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
|
|
public AnonymousClass2(Executor executor) {
|
|
this.val$executor = executor;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (PreRGnssStatusTransport.this.mExecutor == this.val$executor) {
|
|
PreRGnssStatusTransport.this.mCallback.onStopped();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$PreRGnssStatusTransport$3 reason: invalid class name */
|
|
public class AnonymousClass3 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
public final /* synthetic */ int val$ttffMillis;
|
|
|
|
public AnonymousClass3(Executor executor, int i) {
|
|
this.val$executor = executor;
|
|
this.val$ttffMillis = i;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (PreRGnssStatusTransport.this.mExecutor == this.val$executor) {
|
|
PreRGnssStatusTransport.this.mCallback.onFirstFix(this.val$ttffMillis);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.core.location.LocationManagerCompat$PreRGnssStatusTransport$4 reason: invalid class name */
|
|
public class AnonymousClass4 implements Runnable {
|
|
public final /* synthetic */ Executor val$executor;
|
|
public final /* synthetic */ GnssStatus val$status;
|
|
|
|
public AnonymousClass4(Executor executor, GnssStatus gnssStatus) {
|
|
this.val$executor = executor;
|
|
this.val$status = gnssStatus;
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
if (PreRGnssStatusTransport.this.mExecutor == this.val$executor) {
|
|
PreRGnssStatusTransport.this.mCallback.onSatelliteStatusChanged(GnssStatusCompat.wrap(this.val$status));
|
|
}
|
|
}
|
|
}
|
|
|
|
public PreRGnssStatusTransport(GnssStatusCompat.Callback callback) {
|
|
Preconditions.checkArgument(callback != null, "invalid null callback");
|
|
this.mCallback = callback;
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onFirstFix(int i) {
|
|
Executor executor = this.mExecutor;
|
|
if (executor != null) {
|
|
executor.execute(new AnonymousClass3(executor, i));
|
|
}
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onSatelliteStatusChanged(GnssStatus gnssStatus) {
|
|
Executor executor = this.mExecutor;
|
|
if (executor != null) {
|
|
executor.execute(new AnonymousClass4(executor, gnssStatus));
|
|
}
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onStarted() {
|
|
Executor executor = this.mExecutor;
|
|
if (executor != null) {
|
|
executor.execute(new AnonymousClass1(executor));
|
|
}
|
|
}
|
|
|
|
@Override // android.location.GnssStatus.Callback
|
|
public void onStopped() {
|
|
Executor executor = this.mExecutor;
|
|
if (executor != null) {
|
|
executor.execute(new AnonymousClass2(executor));
|
|
}
|
|
}
|
|
|
|
public void register(Executor executor) {
|
|
boolean z2 = true;
|
|
Preconditions.checkArgument(executor != null, "invalid null executor");
|
|
if (this.mExecutor != null) {
|
|
z2 = false;
|
|
}
|
|
Preconditions.checkState(z2);
|
|
this.mExecutor = executor;
|
|
}
|
|
|
|
public void unregister() {
|
|
this.mExecutor = null;
|
|
}
|
|
}
|
|
|
|
private LocationManagerCompat() {
|
|
}
|
|
|
|
@RequiresPermission(anyOf = {"android.permission.ACCESS_COARSE_LOCATION", "android.permission.ACCESS_FINE_LOCATION"})
|
|
public static void getCurrentLocation(@NonNull LocationManager locationManager, @NonNull String str, @Nullable CancellationSignal cancellationSignal, @NonNull Executor executor, @NonNull Consumer<Location> consumer) {
|
|
if (Build.VERSION.SDK_INT >= 30) {
|
|
Api30Impl.getCurrentLocation(locationManager, str, cancellationSignal, executor, consumer);
|
|
return;
|
|
}
|
|
if (cancellationSignal != null) {
|
|
cancellationSignal.throwIfCanceled();
|
|
}
|
|
Location lastKnownLocation = locationManager.getLastKnownLocation(str);
|
|
if (lastKnownLocation == null || SystemClock.elapsedRealtime() - LocationCompat.getElapsedRealtimeMillis(lastKnownLocation) >= 10000) {
|
|
CancellableLocationListener cancellableLocationListener = new CancellableLocationListener(locationManager, executor, consumer);
|
|
locationManager.requestLocationUpdates(str, 0, 0.0f, cancellableLocationListener, Looper.getMainLooper());
|
|
if (cancellationSignal != null) {
|
|
cancellationSignal.setOnCancelListener(new AnonymousClass2(cancellableLocationListener));
|
|
}
|
|
cancellableLocationListener.startTimeout(30000);
|
|
return;
|
|
}
|
|
executor.execute(new AnonymousClass1(consumer, lastKnownLocation));
|
|
}
|
|
|
|
@Nullable
|
|
public static String getGnssHardwareModelName(@NonNull LocationManager locationManager) {
|
|
if (Build.VERSION.SDK_INT >= 28) {
|
|
return Api28Impl.getGnssHardwareModelName(locationManager);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static int getGnssYearOfHardware(@NonNull LocationManager locationManager) {
|
|
if (Build.VERSION.SDK_INT >= 28) {
|
|
return Api28Impl.getGnssYearOfHardware(locationManager);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public static boolean isLocationEnabled(@NonNull LocationManager locationManager) {
|
|
return Build.VERSION.SDK_INT >= 28 ? Api28Impl.isLocationEnabled(locationManager) : locationManager.isProviderEnabled("network") || locationManager.isProviderEnabled("gps");
|
|
}
|
|
|
|
/* JADX WARNING: Removed duplicated region for block: B:103:0x0129 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:93:0x010a A[Catch:{ ExecutionException -> 0x0100, TimeoutException -> 0x00e7, all -> 0x00e4, all -> 0x0126 }] */
|
|
/* JADX WARNING: Removed duplicated region for block: B:99:0x011f A[Catch:{ ExecutionException -> 0x0100, TimeoutException -> 0x00e7, all -> 0x00e4, all -> 0x0126 }] */
|
|
@RequiresPermission("android.permission.ACCESS_FINE_LOCATION")
|
|
private static boolean registerGnssStatusCallback(LocationManager locationManager, Handler handler, Executor executor, GnssStatusCompat.Callback callback) {
|
|
Throwable th;
|
|
ExecutionException e;
|
|
TimeoutException e2;
|
|
int i = Build.VERSION.SDK_INT;
|
|
boolean z2 = true;
|
|
if (i >= 30) {
|
|
SimpleArrayMap<Object, Object> simpleArrayMap = sGnssStatusListeners;
|
|
synchronized (simpleArrayMap) {
|
|
GnssStatus.Callback callback2 = (GnssStatusTransport) simpleArrayMap.get(callback);
|
|
if (callback2 == null) {
|
|
callback2 = new GnssStatusTransport(callback);
|
|
}
|
|
if (!locationManager.registerGnssStatusCallback(executor, callback2)) {
|
|
return false;
|
|
}
|
|
simpleArrayMap.put(callback, callback2);
|
|
return true;
|
|
}
|
|
} else if (i >= 24) {
|
|
Preconditions.checkArgument(handler != null);
|
|
SimpleArrayMap<Object, Object> simpleArrayMap2 = sGnssStatusListeners;
|
|
synchronized (simpleArrayMap2) {
|
|
PreRGnssStatusTransport preRGnssStatusTransport = (PreRGnssStatusTransport) simpleArrayMap2.get(callback);
|
|
if (preRGnssStatusTransport == null) {
|
|
preRGnssStatusTransport = new PreRGnssStatusTransport(callback);
|
|
} else {
|
|
preRGnssStatusTransport.unregister();
|
|
}
|
|
preRGnssStatusTransport.register(executor);
|
|
if (!locationManager.registerGnssStatusCallback(preRGnssStatusTransport, handler)) {
|
|
return false;
|
|
}
|
|
simpleArrayMap2.put(callback, preRGnssStatusTransport);
|
|
return true;
|
|
}
|
|
} else {
|
|
Preconditions.checkArgument(handler != null);
|
|
SimpleArrayMap<Object, Object> simpleArrayMap3 = sGnssStatusListeners;
|
|
synchronized (simpleArrayMap3) {
|
|
GpsStatusTransport gpsStatusTransport = (GpsStatusTransport) simpleArrayMap3.get(callback);
|
|
if (gpsStatusTransport == null) {
|
|
gpsStatusTransport = new GpsStatusTransport(locationManager, callback);
|
|
} else {
|
|
gpsStatusTransport.unregister();
|
|
}
|
|
gpsStatusTransport.register(executor);
|
|
FutureTask futureTask = new FutureTask(new AnonymousClass3(locationManager, gpsStatusTransport));
|
|
if (Looper.myLooper() == handler.getLooper()) {
|
|
futureTask.run();
|
|
} else if (!handler.post(futureTask)) {
|
|
throw new IllegalStateException(handler + " is shutting down");
|
|
}
|
|
try {
|
|
long nanos = TimeUnit.SECONDS.toNanos(PRE_N_LOOPER_TIMEOUT_S);
|
|
boolean z3 = false;
|
|
while (true) {
|
|
try {
|
|
break;
|
|
} catch (InterruptedException unused) {
|
|
try {
|
|
nanos = (System.nanoTime() + nanos) - System.nanoTime();
|
|
z3 = true;
|
|
} catch (ExecutionException e3) {
|
|
e = e3;
|
|
if (e.getCause() instanceof RuntimeException) {
|
|
}
|
|
} catch (TimeoutException e4) {
|
|
e2 = e4;
|
|
throw new IllegalStateException(handler + " appears to be blocked, please run registerGnssStatusCallback() directly on a Looper thread or ensure the main Looper is not blocked by this thread", e2);
|
|
}
|
|
} catch (ExecutionException e5) {
|
|
e = e5;
|
|
if (e.getCause() instanceof RuntimeException) {
|
|
}
|
|
} catch (TimeoutException e6) {
|
|
e2 = e6;
|
|
z2 = z3;
|
|
throw new IllegalStateException(handler + " appears to be blocked, please run registerGnssStatusCallback() directly on a Looper thread or ensure the main Looper is not blocked by this thread", e2);
|
|
} catch (Throwable th2) {
|
|
th = th2;
|
|
z2 = z3;
|
|
if (z2) {
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
if (((Boolean) futureTask.get(nanos, TimeUnit.NANOSECONDS)).booleanValue()) {
|
|
sGnssStatusListeners.put(callback, gpsStatusTransport);
|
|
if (z3) {
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
return true;
|
|
}
|
|
if (z3) {
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
return false;
|
|
} catch (ExecutionException e7) {
|
|
e = e7;
|
|
if (e.getCause() instanceof RuntimeException) {
|
|
throw ((RuntimeException) e.getCause());
|
|
} else if (e.getCause() instanceof Error) {
|
|
throw ((Error) e.getCause());
|
|
} else {
|
|
throw new IllegalStateException(e);
|
|
}
|
|
} catch (TimeoutException e8) {
|
|
e2 = e8;
|
|
z2 = false;
|
|
throw new IllegalStateException(handler + " appears to be blocked, please run registerGnssStatusCallback() directly on a Looper thread or ensure the main Looper is not blocked by this thread", e2);
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
if (z2) {
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@RequiresPermission("android.permission.ACCESS_FINE_LOCATION")
|
|
public static boolean registerGnssStatusCallback(@NonNull LocationManager locationManager, @NonNull GnssStatusCompat.Callback callback, @NonNull Handler handler) {
|
|
return Build.VERSION.SDK_INT >= 30 ? registerGnssStatusCallback(locationManager, ExecutorCompat.create(handler), callback) : registerGnssStatusCallback(locationManager, new InlineHandlerExecutor(handler), callback);
|
|
}
|
|
|
|
@RequiresPermission("android.permission.ACCESS_FINE_LOCATION")
|
|
public static boolean registerGnssStatusCallback(@NonNull LocationManager locationManager, @NonNull Executor executor, @NonNull GnssStatusCompat.Callback callback) {
|
|
if (Build.VERSION.SDK_INT >= 30) {
|
|
return registerGnssStatusCallback(locationManager, null, executor, callback);
|
|
}
|
|
Looper myLooper = Looper.myLooper();
|
|
if (myLooper == null) {
|
|
myLooper = Looper.getMainLooper();
|
|
}
|
|
return registerGnssStatusCallback(locationManager, new Handler(myLooper), executor, callback);
|
|
}
|
|
|
|
public static void unregisterGnssStatusCallback(@NonNull LocationManager locationManager, @NonNull GnssStatusCompat.Callback callback) {
|
|
int i = Build.VERSION.SDK_INT;
|
|
if (i >= 30) {
|
|
SimpleArrayMap<Object, Object> simpleArrayMap = sGnssStatusListeners;
|
|
synchronized (simpleArrayMap) {
|
|
GnssStatus.Callback callback2 = (GnssStatusTransport) simpleArrayMap.remove(callback);
|
|
if (callback2 != null) {
|
|
locationManager.unregisterGnssStatusCallback(callback2);
|
|
}
|
|
}
|
|
} else if (i >= 24) {
|
|
SimpleArrayMap<Object, Object> simpleArrayMap2 = sGnssStatusListeners;
|
|
synchronized (simpleArrayMap2) {
|
|
PreRGnssStatusTransport preRGnssStatusTransport = (PreRGnssStatusTransport) simpleArrayMap2.remove(callback);
|
|
if (preRGnssStatusTransport != null) {
|
|
preRGnssStatusTransport.unregister();
|
|
locationManager.unregisterGnssStatusCallback(preRGnssStatusTransport);
|
|
}
|
|
}
|
|
} else {
|
|
SimpleArrayMap<Object, Object> simpleArrayMap3 = sGnssStatusListeners;
|
|
synchronized (simpleArrayMap3) {
|
|
GpsStatusTransport gpsStatusTransport = (GpsStatusTransport) simpleArrayMap3.remove(callback);
|
|
if (gpsStatusTransport != null) {
|
|
gpsStatusTransport.unregister();
|
|
locationManager.removeGpsStatusListener(gpsStatusTransport);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|