Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
560 lines
23 KiB
Java
560 lines
23 KiB
Java
package com.ea.nimble;
|
|
|
|
import android.annotation.TargetApi;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.net.ConnectivityManager;
|
|
import android.net.NetworkCapabilities;
|
|
import android.os.Build;
|
|
import com.ea.nimble.Error;
|
|
import com.ea.nimble.IHttpRequest;
|
|
import com.ea.nimble.Log;
|
|
import com.ea.nimble.Network;
|
|
import com.mbridge.msdk.foundation.entity.CampaignEx;
|
|
import com.unity3d.ads.core.domain.InitializeAndroidBoldSDK;
|
|
import java.net.MalformedURLException;
|
|
import java.net.URL;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
/* loaded from: classes2.dex */
|
|
class NetworkImpl extends Component implements INetwork, LogSource {
|
|
private static final String BACKUP_NETWORK_REACHABILITY_CHECK_URL = "https://www.google.com";
|
|
private static final int DETECTION_TIMEOUT = 30;
|
|
private static final String MAIN_NETWORK_REACHABILITY_CHECK_URL = "https://ping1.tnt-ea.com";
|
|
private static final int MAX_CONCURRENT_THREADS = 4;
|
|
private static final int[] PING_INTERVAL = {5, 10, 30, 60};
|
|
private static final int QUICK_DETECTION_TIMEOUT = 5;
|
|
private ExecutorService m_asyncTaskManager;
|
|
private ConnectivityReceiver m_connectivityReceiver;
|
|
private NetworkConnection m_detectionConnection;
|
|
private boolean m_isWifi;
|
|
private NetworkCallback m_networkCallback;
|
|
private DetectionState m_networkDetectionState;
|
|
private int m_pingIndex;
|
|
private final List<NetworkConnection> m_queue;
|
|
private Network.Status m_status;
|
|
private Timer m_timer;
|
|
private LinkedList<NetworkConnection> m_waitingToExecuteQueue;
|
|
|
|
public enum DetectionState {
|
|
NONE,
|
|
VERIFY_REACHABLE_MAIN,
|
|
VERIFY_UNREACHABLE_MAIN,
|
|
VERIFY_REACHABLE_BACKUP,
|
|
PING
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public String getComponentId() {
|
|
return "com.ea.nimble.network";
|
|
}
|
|
|
|
@Override // com.ea.nimble.LogSource
|
|
public String getLogSourceTitle() {
|
|
return InitializeAndroidBoldSDK.MSG_NETWORK;
|
|
}
|
|
|
|
public class ConnectivityReceiver extends BroadcastReceiver {
|
|
private ConnectivityReceiver() {
|
|
}
|
|
|
|
public /* synthetic */ ConnectivityReceiver(NetworkImpl networkImpl, AnonymousClass1 anonymousClass1) {
|
|
this();
|
|
}
|
|
|
|
@Override // android.content.BroadcastReceiver
|
|
public void onReceive(Context context, Intent intent) {
|
|
Log.Helper.LOGD(this, "Network reachability changed!", new Object[0]);
|
|
synchronized (NetworkImpl.this) {
|
|
NetworkImpl.this.detect(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
@TargetApi(28)
|
|
public class NetworkCallback extends ConnectivityManager.NetworkCallback {
|
|
private NetworkCallback() {
|
|
}
|
|
|
|
public /* synthetic */ NetworkCallback(NetworkImpl networkImpl, AnonymousClass1 anonymousClass1) {
|
|
this();
|
|
}
|
|
|
|
@Override // android.net.ConnectivityManager.NetworkCallback
|
|
public void onAvailable(android.net.Network network) {
|
|
Log.Helper.LOGD(this, "Network reachability changed!", new Object[0]);
|
|
super.onAvailable(network);
|
|
synchronized (NetworkImpl.this) {
|
|
NetworkImpl.this.detect(true);
|
|
}
|
|
}
|
|
|
|
@Override // android.net.ConnectivityManager.NetworkCallback
|
|
public void onLost(android.net.Network network) {
|
|
Log.Helper.LOGD(this, "Network reachability changed!", new Object[0]);
|
|
super.onLost(network);
|
|
synchronized (NetworkImpl.this) {
|
|
NetworkImpl.this.detect(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public NetworkImpl() {
|
|
Log.Helper.LOGFUNC(this);
|
|
this.m_connectivityReceiver = null;
|
|
this.m_networkCallback = null;
|
|
this.m_status = Network.Status.UNKNOWN;
|
|
this.m_detectionConnection = null;
|
|
this.m_networkDetectionState = DetectionState.NONE;
|
|
this.m_pingIndex = 0;
|
|
this.m_queue = new ArrayList();
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void setup() {
|
|
Log.Helper.LOGV(this, "setup", new Object[0]);
|
|
startWork();
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void suspend() {
|
|
synchronized (this) {
|
|
stopPing();
|
|
unregisterNetworkListener();
|
|
synchronized (this) {
|
|
try {
|
|
Iterator it = new ArrayList(this.m_queue).iterator();
|
|
while (it.hasNext()) {
|
|
((NetworkConnection) it.next()).cancelForAppSuspend();
|
|
}
|
|
} catch (Throwable th) {
|
|
throw th;
|
|
}
|
|
}
|
|
Log.Helper.LOGV(this, "suspend", new Object[0]);
|
|
}
|
|
Log.Helper.LOGV(this, "suspend", new Object[0]);
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void resume() {
|
|
Log.Helper.LOGV(this, CampaignEx.JSON_NATIVE_VIDEO_RESUME, new Object[0]);
|
|
synchronized (this) {
|
|
detect(true);
|
|
registerNetworkListener();
|
|
}
|
|
}
|
|
|
|
@Override // com.ea.nimble.Component
|
|
public void cleanup() {
|
|
stopWork();
|
|
Log.Helper.LOGV(this, "cleanup", new Object[0]);
|
|
}
|
|
|
|
private void registerNetworkListener() {
|
|
Log.Helper.LOGFUNC(this);
|
|
AnonymousClass1 anonymousClass1 = null;
|
|
if (Build.VERSION.SDK_INT < 28) {
|
|
if (this.m_connectivityReceiver == null) {
|
|
Log.Helper.LOGD(this, "Register network reachability listener.", new Object[0]);
|
|
this.m_connectivityReceiver = new ConnectivityReceiver(this, anonymousClass1);
|
|
ApplicationEnvironment.getComponent().getApplicationContext().registerReceiver(this.m_connectivityReceiver, new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (this.m_networkCallback == null) {
|
|
ConnectivityManager connectivityManager = (ConnectivityManager) ApplicationEnvironment.getComponent().getApplicationContext().getSystemService("connectivity");
|
|
if (connectivityManager == null) {
|
|
Log.Helper.LOGE(this, "Can not get ConnectivityManager from context.", new Object[0]);
|
|
return;
|
|
}
|
|
NetworkCallback networkCallback = new NetworkCallback(this, anonymousClass1);
|
|
this.m_networkCallback = networkCallback;
|
|
connectivityManager.registerDefaultNetworkCallback(networkCallback);
|
|
}
|
|
}
|
|
|
|
private void unregisterNetworkListener() {
|
|
Log.Helper.LOGFUNC(this);
|
|
if (Build.VERSION.SDK_INT < 28) {
|
|
if (this.m_connectivityReceiver != null) {
|
|
try {
|
|
ApplicationEnvironment.getComponent().getApplicationContext().unregisterReceiver(this.m_connectivityReceiver);
|
|
} catch (IllegalArgumentException unused) {
|
|
Log.Helper.LOGE(this, "Unable to unregister network reachability listener even it does exists", new Object[0]);
|
|
}
|
|
this.m_connectivityReceiver = null;
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (this.m_networkCallback != null) {
|
|
ConnectivityManager connectivityManager = (ConnectivityManager) ApplicationEnvironment.getComponent().getApplicationContext().getSystemService("connectivity");
|
|
if (connectivityManager == null) {
|
|
Log.Helper.LOGE(this, "Can not get ConnectivityManager from context.", new Object[0]);
|
|
} else {
|
|
connectivityManager.unregisterNetworkCallback(this.m_networkCallback);
|
|
this.m_networkCallback = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public NetworkConnectionHandle sendGetRequest(URL url, HashMap<String, String> hashMap, NetworkConnectionCallback networkConnectionCallback) {
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
HttpRequest httpRequest = new HttpRequest(url);
|
|
httpRequest.method = IHttpRequest.Method.GET;
|
|
httpRequest.headers = hashMap;
|
|
return sendRequest(httpRequest, networkConnectionCallback);
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public NetworkConnectionHandle sendPostRequest(URL url, HashMap<String, String> hashMap, byte[] bArr, NetworkConnectionCallback networkConnectionCallback) {
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
HttpRequest httpRequest = new HttpRequest(url);
|
|
httpRequest.method = IHttpRequest.Method.POST;
|
|
httpRequest.headers = hashMap;
|
|
try {
|
|
httpRequest.data.write(bArr);
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
return sendRequest(httpRequest, networkConnectionCallback);
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public NetworkConnectionHandle sendDeleteRequest(URL url, HashMap<String, String> hashMap, NetworkConnectionCallback networkConnectionCallback) {
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
HttpRequest httpRequest = new HttpRequest(url);
|
|
httpRequest.method = IHttpRequest.Method.DELETE;
|
|
httpRequest.headers = hashMap;
|
|
return sendRequest(httpRequest, networkConnectionCallback);
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public NetworkConnectionHandle sendRequest(HttpRequest httpRequest, NetworkConnectionCallback networkConnectionCallback) {
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
return sendRequest(httpRequest, networkConnectionCallback, null);
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public NetworkConnectionHandle sendRequest(HttpRequest httpRequest, NetworkConnectionCallback networkConnectionCallback, IOperationalTelemetryDispatch iOperationalTelemetryDispatch) {
|
|
NetworkConnection networkConnection;
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
if (httpRequest.runInBackground) {
|
|
networkConnection = new BackgroundNetworkConnection(this, httpRequest, iOperationalTelemetryDispatch);
|
|
} else {
|
|
networkConnection = new NetworkConnection(this, httpRequest, iOperationalTelemetryDispatch);
|
|
}
|
|
networkConnection.setCompletionCallback(networkConnectionCallback);
|
|
URL url = httpRequest.url;
|
|
if (url == null || !Utility.validString(url.toString())) {
|
|
networkConnection.finishWithError(new Error(Error.Code.INVALID_ARGUMENT, "Sending request without valid url"));
|
|
return networkConnection;
|
|
}
|
|
if (this.m_status != Network.Status.OK) {
|
|
networkConnection.finishWithError(new Error(Error.Code.NETWORK_NO_CONNECTION, "No network connection, network status " + this.m_status.toString()));
|
|
return networkConnection;
|
|
}
|
|
synchronized (this) {
|
|
this.m_queue.add(networkConnection);
|
|
}
|
|
ExecutorService executorService = this.m_asyncTaskManager;
|
|
if (executorService == null || executorService.isShutdown()) {
|
|
if (this.m_asyncTaskManager != null) {
|
|
Log.Helper.LOGW(this, "AsyncTaskManager shutdown. Queueing network connection until AsyncTaskManager is started.", new Object[0]);
|
|
} else {
|
|
Log.Helper.LOGW(this, "AsyncTaskManager is not ready. Queueing network connection until AsyncTaskManager is started.", new Object[0]);
|
|
}
|
|
if (this.m_waitingToExecuteQueue == null) {
|
|
this.m_waitingToExecuteQueue = new LinkedList<>();
|
|
}
|
|
this.m_waitingToExecuteQueue.add(networkConnection);
|
|
} else {
|
|
this.m_asyncTaskManager.execute(networkConnection);
|
|
}
|
|
return networkConnection;
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public synchronized void forceRedetectNetworkStatus() {
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
detect(true);
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public Network.Status getStatus() {
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
return this.m_status;
|
|
}
|
|
|
|
@Override // com.ea.nimble.INetwork
|
|
public boolean isNetworkWifi() {
|
|
Log.Helper.LOGPUBLICFUNC(this);
|
|
return this.m_isWifi;
|
|
}
|
|
|
|
public synchronized void removeConnection(NetworkConnection networkConnection) {
|
|
Log.Helper.LOGFUNC(this);
|
|
this.m_queue.remove(networkConnection);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void detect(boolean z) {
|
|
Log.Helper.LOGFUNC(this);
|
|
NetworkConnection networkConnection = this.m_detectionConnection;
|
|
if (networkConnection != null) {
|
|
if (!z) {
|
|
return;
|
|
}
|
|
this.m_detectionConnection = null;
|
|
networkConnection.cancel();
|
|
}
|
|
stopPing();
|
|
boolean z2 = this.m_isWifi;
|
|
if (reachabilityCheck()) {
|
|
if (this.m_status != Network.Status.DEAD) {
|
|
setStatus(Network.Status.OK, z2 != this.m_isWifi);
|
|
}
|
|
this.m_networkDetectionState = DetectionState.VERIFY_REACHABLE_MAIN;
|
|
} else {
|
|
if (this.m_status == Network.Status.UNKNOWN) {
|
|
setStatus(Network.Status.NONE, false);
|
|
}
|
|
this.m_networkDetectionState = DetectionState.VERIFY_UNREACHABLE_MAIN;
|
|
}
|
|
verifyReachability(MAIN_NETWORK_REACHABILITY_CHECK_URL, 5.0d);
|
|
}
|
|
|
|
private boolean reachabilityCheck() {
|
|
ConnectivityManager connectivityManager;
|
|
android.net.Network activeNetwork;
|
|
Log.Helper.LOGFUNC(this);
|
|
boolean z = false;
|
|
if (!BaseCore.getInstance().isActive()) {
|
|
Log.Helper.LOGD(this, "BaseCore not active yet. Postpone reachability check.", new Object[0]);
|
|
return false;
|
|
}
|
|
this.m_isWifi = false;
|
|
Context applicationContext = ApplicationEnvironment.getComponent().getApplicationContext();
|
|
if (applicationContext == null || (connectivityManager = (ConnectivityManager) applicationContext.getSystemService("connectivity")) == null || (activeNetwork = connectivityManager.getActiveNetwork()) == null) {
|
|
return false;
|
|
}
|
|
NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(activeNetwork);
|
|
if (networkCapabilities != null) {
|
|
if (!networkCapabilities.hasCapability(12)) {
|
|
return false;
|
|
}
|
|
z = true;
|
|
if (networkCapabilities.hasTransport(1) || networkCapabilities.hasTransport(3)) {
|
|
this.m_isWifi = true;
|
|
}
|
|
}
|
|
return z;
|
|
}
|
|
|
|
private void startPing() {
|
|
Log.Helper.LOGFUNC(this);
|
|
if (this.m_pingIndex >= PING_INTERVAL.length) {
|
|
this.m_pingIndex = r1.length - 1;
|
|
}
|
|
Timer timer = new Timer(new TimerTask(this, null));
|
|
this.m_timer = timer;
|
|
timer.schedule(r1[this.m_pingIndex], false);
|
|
}
|
|
|
|
private void stopPing() {
|
|
Log.Helper.LOGFUNC(this);
|
|
Timer timer = this.m_timer;
|
|
if (timer != null) {
|
|
timer.cancel();
|
|
this.m_timer = null;
|
|
}
|
|
}
|
|
|
|
public class TimerTask implements Runnable {
|
|
private TimerTask() {
|
|
}
|
|
|
|
public /* synthetic */ TimerTask(NetworkImpl networkImpl, AnonymousClass1 anonymousClass1) {
|
|
this();
|
|
}
|
|
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
synchronized (NetworkImpl.this) {
|
|
NetworkImpl.this.m_timer = null;
|
|
NetworkImpl.this.verifyReachability(NetworkImpl.MAIN_NETWORK_REACHABILITY_CHECK_URL, 30.0d);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void verifyReachability(String str, double d) {
|
|
Log.Helper.LOGFUNC(this);
|
|
try {
|
|
HttpRequest httpRequest = new HttpRequest(new URL(str));
|
|
httpRequest.timeout = d;
|
|
httpRequest.method = IHttpRequest.Method.HEAD;
|
|
NetworkConnection networkConnection = new NetworkConnection(this, httpRequest);
|
|
this.m_detectionConnection = networkConnection;
|
|
networkConnection.setCompletionCallback(new NetworkConnectionCallback() { // from class: com.ea.nimble.NetworkImpl$$ExternalSyntheticLambda0
|
|
@Override // com.ea.nimble.NetworkConnectionCallback
|
|
public final void callback(NetworkConnectionHandle networkConnectionHandle) {
|
|
NetworkImpl.this.lambda$verifyReachability$0(networkConnectionHandle);
|
|
}
|
|
});
|
|
ExecutorService executorService = this.m_asyncTaskManager;
|
|
if (executorService == null || executorService.isShutdown()) {
|
|
Log.Helper.LOGW(this, "AsyncTaskManager is not ready. Queueing network connection until AsyncTaskManager is started.", new Object[0]);
|
|
if (this.m_waitingToExecuteQueue == null) {
|
|
this.m_waitingToExecuteQueue = new LinkedList<>();
|
|
}
|
|
this.m_waitingToExecuteQueue.addFirst(this.m_detectionConnection);
|
|
return;
|
|
}
|
|
this.m_asyncTaskManager.execute(this.m_detectionConnection);
|
|
} catch (MalformedURLException unused) {
|
|
Log.Helper.LOGE(this, "Invalid url: " + str, new Object[0]);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
/* renamed from: onReachabilityVerification, reason: merged with bridge method [inline-methods] */
|
|
public synchronized void lambda$verifyReachability$0(NetworkConnectionHandle networkConnectionHandle) {
|
|
Log.Helper.LOGFUNC(this);
|
|
Exception error = networkConnectionHandle.getResponse().getError();
|
|
if (error == null) {
|
|
Log.Helper.LOGD(this, "network verified reachable.", new Object[0]);
|
|
setStatus(Network.Status.OK, false);
|
|
this.m_detectionConnection = null;
|
|
return;
|
|
}
|
|
if (networkConnectionHandle != this.m_detectionConnection) {
|
|
return;
|
|
}
|
|
this.m_detectionConnection = null;
|
|
Log.Helper.LOGD(this, "network verified unreachable, ERROR %s for detection state %s", networkConnectionHandle.getResponse().getError(), this.m_networkDetectionState);
|
|
if (error instanceof Error) {
|
|
Error error2 = (Error) error;
|
|
if (error2.getDomain().equals(Error.ERROR_DOMAIN) && error2.isError(Error.Code.NETWORK_OPERATION_CANCELLED)) {
|
|
Log.Helper.LOGW(this, "Network detection verification connection get cancelled for unknown reason (maybe reasonable for Android)", new Object[0]);
|
|
}
|
|
}
|
|
int i = AnonymousClass1.$SwitchMap$com$ea$nimble$NetworkImpl$DetectionState[this.m_networkDetectionState.ordinal()];
|
|
if (i == 1) {
|
|
this.m_networkDetectionState = DetectionState.VERIFY_REACHABLE_BACKUP;
|
|
verifyReachability(BACKUP_NETWORK_REACHABILITY_CHECK_URL, 30.0d);
|
|
} else if (i == 2) {
|
|
setStatus(Network.Status.NONE, false);
|
|
} else if (i == 3) {
|
|
this.m_networkDetectionState = DetectionState.PING;
|
|
Network.Status status = this.m_status;
|
|
Network.Status status2 = Network.Status.DEAD;
|
|
if (status != status2) {
|
|
setStatus(status2, false);
|
|
this.m_pingIndex = 0;
|
|
}
|
|
startPing();
|
|
} else if (i == 4) {
|
|
this.m_pingIndex++;
|
|
startPing();
|
|
}
|
|
}
|
|
|
|
/* renamed from: com.ea.nimble.NetworkImpl$1, reason: invalid class name */
|
|
public static /* synthetic */ class AnonymousClass1 {
|
|
static final /* synthetic */ int[] $SwitchMap$com$ea$nimble$NetworkImpl$DetectionState;
|
|
|
|
static {
|
|
int[] iArr = new int[DetectionState.values().length];
|
|
$SwitchMap$com$ea$nimble$NetworkImpl$DetectionState = iArr;
|
|
try {
|
|
iArr[DetectionState.VERIFY_REACHABLE_MAIN.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$ea$nimble$NetworkImpl$DetectionState[DetectionState.VERIFY_UNREACHABLE_MAIN.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$ea$nimble$NetworkImpl$DetectionState[DetectionState.VERIFY_REACHABLE_BACKUP.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
$SwitchMap$com$ea$nimble$NetworkImpl$DetectionState[DetectionState.PING.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setStatus(Network.Status status, boolean z) {
|
|
Log.Helper.LOGI(this, "Status change %s -> %s", this.m_status, status);
|
|
if (status != this.m_status || z) {
|
|
this.m_status = status;
|
|
Utility.sendBroadcast(Global.NOTIFICATION_NETWORK_STATUS_CHANGE);
|
|
}
|
|
}
|
|
|
|
private synchronized void startWork() {
|
|
try {
|
|
Log.Helper.LOGFUNC(this);
|
|
if (this.m_asyncTaskManager != null) {
|
|
return;
|
|
}
|
|
detect(true);
|
|
registerNetworkListener();
|
|
this.m_asyncTaskManager = Executors.newFixedThreadPool(4);
|
|
LinkedList<NetworkConnection> linkedList = this.m_waitingToExecuteQueue;
|
|
if (linkedList != null && !linkedList.isEmpty()) {
|
|
Log.Helper.LOGW(this, "NetworkConnections waiting to execute on new AsyncTaskManager. Executing.", new Object[0]);
|
|
while (!this.m_waitingToExecuteQueue.isEmpty()) {
|
|
NetworkConnection poll = this.m_waitingToExecuteQueue.poll();
|
|
if (poll != null) {
|
|
Log.Helper.LOGW(this, "Executing request URL: " + poll.getRequest().url.toString(), new Object[0]);
|
|
this.m_asyncTaskManager.execute(poll);
|
|
} else {
|
|
Log.Helper.LOGE(this, "Could not get queued connection", new Object[0]);
|
|
}
|
|
}
|
|
}
|
|
} catch (Throwable th) {
|
|
throw th;
|
|
}
|
|
}
|
|
|
|
private void stopWork() {
|
|
Log.Helper.LOGFUNC(this);
|
|
synchronized (this) {
|
|
this.m_detectionConnection = null;
|
|
stopPing();
|
|
unregisterNetworkListener();
|
|
}
|
|
ExecutorService executorService = this.m_asyncTaskManager;
|
|
if (executorService == null) {
|
|
return;
|
|
}
|
|
try {
|
|
Iterator<Runnable> it = executorService.shutdownNow().iterator();
|
|
while (it.hasNext()) {
|
|
((NetworkConnection) it.next()).cancelForAppSuspend();
|
|
}
|
|
this.m_asyncTaskManager.awaitTermination(60L, TimeUnit.SECONDS);
|
|
} catch (InterruptedException unused) {
|
|
this.m_asyncTaskManager.shutdownNow();
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
this.m_asyncTaskManager = null;
|
|
}
|
|
}
|