463 lines
15 KiB
Java
463 lines
15 KiB
Java
package com.squareup.picasso;
|
|
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.net.ConnectivityManager;
|
|
import android.net.NetworkInfo;
|
|
import android.os.Handler;
|
|
import android.os.HandlerThread;
|
|
import android.os.Looper;
|
|
import android.os.Message;
|
|
import com.squareup.picasso.NetworkRequestHandler;
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.WeakHashMap;
|
|
import java.util.concurrent.ExecutorService;
|
|
|
|
/* loaded from: classes.dex */
|
|
class Dispatcher {
|
|
final DispatcherThread a = new DispatcherThread();
|
|
final Context b;
|
|
final ExecutorService c;
|
|
final Downloader d;
|
|
final Map<String, BitmapHunter> e;
|
|
final Map<Object, Action> f;
|
|
final Map<Object, Action> g;
|
|
final Set<Object> h;
|
|
final Handler i;
|
|
final Handler j;
|
|
final Cache k;
|
|
final Stats l;
|
|
final List<BitmapHunter> m;
|
|
final NetworkBroadcastReceiver n;
|
|
final boolean o;
|
|
boolean p;
|
|
|
|
private static class DispatcherHandler extends Handler {
|
|
private final Dispatcher a;
|
|
|
|
public DispatcherHandler(Looper looper, Dispatcher dispatcher) {
|
|
super(looper);
|
|
this.a = dispatcher;
|
|
}
|
|
|
|
@Override // android.os.Handler
|
|
public void handleMessage(final Message message) {
|
|
switch (message.what) {
|
|
case 1:
|
|
this.a.d((Action) message.obj);
|
|
break;
|
|
case 2:
|
|
this.a.c((Action) message.obj);
|
|
break;
|
|
case 3:
|
|
case 8:
|
|
default:
|
|
Picasso.p.post(new Runnable(this) { // from class: com.squareup.picasso.Dispatcher.DispatcherHandler.1
|
|
@Override // java.lang.Runnable
|
|
public void run() {
|
|
throw new AssertionError("Unknown handler message received: " + message.what);
|
|
}
|
|
});
|
|
break;
|
|
case 4:
|
|
this.a.d((BitmapHunter) message.obj);
|
|
break;
|
|
case 5:
|
|
this.a.e((BitmapHunter) message.obj);
|
|
break;
|
|
case 6:
|
|
this.a.a((BitmapHunter) message.obj, false);
|
|
break;
|
|
case 7:
|
|
this.a.a();
|
|
break;
|
|
case 9:
|
|
this.a.b((NetworkInfo) message.obj);
|
|
break;
|
|
case 10:
|
|
this.a.b(message.arg1 == 1);
|
|
break;
|
|
case 11:
|
|
this.a.a(message.obj);
|
|
break;
|
|
case 12:
|
|
this.a.b(message.obj);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static class DispatcherThread extends HandlerThread {
|
|
DispatcherThread() {
|
|
super("Picasso-Dispatcher", 10);
|
|
}
|
|
}
|
|
|
|
static class NetworkBroadcastReceiver extends BroadcastReceiver {
|
|
private final Dispatcher a;
|
|
|
|
NetworkBroadcastReceiver(Dispatcher dispatcher) {
|
|
this.a = dispatcher;
|
|
}
|
|
|
|
void a() {
|
|
IntentFilter intentFilter = new IntentFilter();
|
|
intentFilter.addAction("android.intent.action.AIRPLANE_MODE");
|
|
if (this.a.o) {
|
|
intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
|
|
}
|
|
this.a.b.registerReceiver(this, intentFilter);
|
|
}
|
|
|
|
@Override // android.content.BroadcastReceiver
|
|
public void onReceive(Context context, Intent intent) {
|
|
if (intent == null) {
|
|
return;
|
|
}
|
|
String action = intent.getAction();
|
|
if ("android.intent.action.AIRPLANE_MODE".equals(action)) {
|
|
if (intent.hasExtra("state")) {
|
|
this.a.a(intent.getBooleanExtra("state", false));
|
|
}
|
|
} else if ("android.net.conn.CONNECTIVITY_CHANGE".equals(action)) {
|
|
this.a.a(((ConnectivityManager) Utils.a(context, "connectivity")).getActiveNetworkInfo());
|
|
}
|
|
}
|
|
}
|
|
|
|
Dispatcher(Context context, ExecutorService executorService, Handler handler, Downloader downloader, Cache cache, Stats stats) {
|
|
this.a.start();
|
|
Utils.a(this.a.getLooper());
|
|
this.b = context;
|
|
this.c = executorService;
|
|
this.e = new LinkedHashMap();
|
|
this.f = new WeakHashMap();
|
|
this.g = new WeakHashMap();
|
|
this.h = new HashSet();
|
|
this.i = new DispatcherHandler(this.a.getLooper(), this);
|
|
this.d = downloader;
|
|
this.j = handler;
|
|
this.k = cache;
|
|
this.l = stats;
|
|
this.m = new ArrayList(4);
|
|
this.p = Utils.d(this.b);
|
|
this.o = Utils.b(context, "android.permission.ACCESS_NETWORK_STATE");
|
|
this.n = new NetworkBroadcastReceiver(this);
|
|
this.n.a();
|
|
}
|
|
|
|
private void f(BitmapHunter bitmapHunter) {
|
|
if (bitmapHunter.o()) {
|
|
return;
|
|
}
|
|
this.m.add(bitmapHunter);
|
|
if (this.i.hasMessages(7)) {
|
|
return;
|
|
}
|
|
this.i.sendEmptyMessageDelayed(7, 200L);
|
|
}
|
|
|
|
private void g(BitmapHunter bitmapHunter) {
|
|
Action a = bitmapHunter.a();
|
|
if (a != null) {
|
|
e(a);
|
|
}
|
|
List<Action> b = bitmapHunter.b();
|
|
if (b != null) {
|
|
int size = b.size();
|
|
for (int i = 0; i < size; i++) {
|
|
e(b.get(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
void a(Action action) {
|
|
Handler handler = this.i;
|
|
handler.sendMessage(handler.obtainMessage(2, action));
|
|
}
|
|
|
|
void b(Action action) {
|
|
Handler handler = this.i;
|
|
handler.sendMessage(handler.obtainMessage(1, action));
|
|
}
|
|
|
|
void c(BitmapHunter bitmapHunter) {
|
|
Handler handler = this.i;
|
|
handler.sendMessageDelayed(handler.obtainMessage(5, bitmapHunter), 500L);
|
|
}
|
|
|
|
void d(Action action) {
|
|
a(action, true);
|
|
}
|
|
|
|
void e(BitmapHunter bitmapHunter) {
|
|
if (bitmapHunter.o()) {
|
|
return;
|
|
}
|
|
boolean z = false;
|
|
if (this.c.isShutdown()) {
|
|
a(bitmapHunter, false);
|
|
return;
|
|
}
|
|
NetworkInfo activeNetworkInfo = this.o ? ((ConnectivityManager) Utils.a(this.b, "connectivity")).getActiveNetworkInfo() : null;
|
|
boolean z2 = activeNetworkInfo != null && activeNetworkInfo.isConnected();
|
|
boolean a = bitmapHunter.a(this.p, activeNetworkInfo);
|
|
boolean p = bitmapHunter.p();
|
|
if (!a) {
|
|
if (this.o && p) {
|
|
z = true;
|
|
}
|
|
a(bitmapHunter, z);
|
|
if (z) {
|
|
g(bitmapHunter);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (this.o && !z2) {
|
|
a(bitmapHunter, p);
|
|
if (p) {
|
|
g(bitmapHunter);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
if (bitmapHunter.k().n) {
|
|
Utils.a("Dispatcher", "retrying", Utils.a(bitmapHunter));
|
|
}
|
|
if (bitmapHunter.d() instanceof NetworkRequestHandler.ContentLengthException) {
|
|
bitmapHunter.i |= NetworkPolicy.NO_CACHE.index;
|
|
}
|
|
bitmapHunter.n = this.c.submit(bitmapHunter);
|
|
}
|
|
|
|
void a(BitmapHunter bitmapHunter) {
|
|
Handler handler = this.i;
|
|
handler.sendMessage(handler.obtainMessage(4, bitmapHunter));
|
|
}
|
|
|
|
void b(BitmapHunter bitmapHunter) {
|
|
Handler handler = this.i;
|
|
handler.sendMessage(handler.obtainMessage(6, bitmapHunter));
|
|
}
|
|
|
|
void c(Action action) {
|
|
String c = action.c();
|
|
BitmapHunter bitmapHunter = this.e.get(c);
|
|
if (bitmapHunter != null) {
|
|
bitmapHunter.b(action);
|
|
if (bitmapHunter.cancel()) {
|
|
this.e.remove(c);
|
|
if (action.f().n) {
|
|
Utils.a("Dispatcher", "canceled", action.h().d());
|
|
}
|
|
}
|
|
}
|
|
if (this.h.contains(action.i())) {
|
|
this.g.remove(action.j());
|
|
if (action.f().n) {
|
|
Utils.a("Dispatcher", "canceled", action.h().d(), "because paused request got canceled");
|
|
}
|
|
}
|
|
Action remove = this.f.remove(action.j());
|
|
if (remove == null || !remove.f().n) {
|
|
return;
|
|
}
|
|
Utils.a("Dispatcher", "canceled", remove.h().d(), "from replaying");
|
|
}
|
|
|
|
void d(BitmapHunter bitmapHunter) {
|
|
if (MemoryPolicy.shouldWriteToMemoryCache(bitmapHunter.j())) {
|
|
this.k.a(bitmapHunter.e(), bitmapHunter.m());
|
|
}
|
|
this.e.remove(bitmapHunter.e());
|
|
f(bitmapHunter);
|
|
if (bitmapHunter.k().n) {
|
|
Utils.a("Dispatcher", "batched", Utils.a(bitmapHunter), "for completion");
|
|
}
|
|
}
|
|
|
|
void a(NetworkInfo networkInfo) {
|
|
Handler handler = this.i;
|
|
handler.sendMessage(handler.obtainMessage(9, networkInfo));
|
|
}
|
|
|
|
void b(Object obj) {
|
|
if (this.h.remove(obj)) {
|
|
ArrayList arrayList = null;
|
|
Iterator<Action> it = this.g.values().iterator();
|
|
while (it.hasNext()) {
|
|
Action next = it.next();
|
|
if (next.i().equals(obj)) {
|
|
if (arrayList == null) {
|
|
arrayList = new ArrayList();
|
|
}
|
|
arrayList.add(next);
|
|
it.remove();
|
|
}
|
|
}
|
|
if (arrayList != null) {
|
|
Handler handler = this.j;
|
|
handler.sendMessage(handler.obtainMessage(13, arrayList));
|
|
}
|
|
}
|
|
}
|
|
|
|
void a(boolean z) {
|
|
Handler handler = this.i;
|
|
handler.sendMessage(handler.obtainMessage(10, z ? 1 : 0, 0));
|
|
}
|
|
|
|
void a(Action action, boolean z) {
|
|
if (this.h.contains(action.i())) {
|
|
this.g.put(action.j(), action);
|
|
if (action.f().n) {
|
|
Utils.a("Dispatcher", "paused", action.b.d(), "because tag '" + action.i() + "' is paused");
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
BitmapHunter bitmapHunter = this.e.get(action.c());
|
|
if (bitmapHunter != null) {
|
|
bitmapHunter.a(action);
|
|
return;
|
|
}
|
|
if (this.c.isShutdown()) {
|
|
if (action.f().n) {
|
|
Utils.a("Dispatcher", "ignored", action.b.d(), "because shut down");
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
BitmapHunter a = BitmapHunter.a(action.f(), this, this.k, this.l, action);
|
|
a.n = this.c.submit(a);
|
|
this.e.put(action.c(), a);
|
|
if (z) {
|
|
this.f.remove(action.j());
|
|
}
|
|
if (action.f().n) {
|
|
Utils.a("Dispatcher", "enqueued", action.b.d());
|
|
}
|
|
}
|
|
|
|
void b(boolean z) {
|
|
this.p = z;
|
|
}
|
|
|
|
void b(NetworkInfo networkInfo) {
|
|
ExecutorService executorService = this.c;
|
|
if (executorService instanceof PicassoExecutorService) {
|
|
((PicassoExecutorService) executorService).a(networkInfo);
|
|
}
|
|
if (networkInfo == null || !networkInfo.isConnected()) {
|
|
return;
|
|
}
|
|
b();
|
|
}
|
|
|
|
private void b() {
|
|
if (this.f.isEmpty()) {
|
|
return;
|
|
}
|
|
Iterator<Action> it = this.f.values().iterator();
|
|
while (it.hasNext()) {
|
|
Action next = it.next();
|
|
it.remove();
|
|
if (next.f().n) {
|
|
Utils.a("Dispatcher", "replaying", next.h().d());
|
|
}
|
|
a(next, false);
|
|
}
|
|
}
|
|
|
|
private void e(Action action) {
|
|
Object j = action.j();
|
|
if (j != null) {
|
|
action.k = true;
|
|
this.f.put(j, action);
|
|
}
|
|
}
|
|
|
|
void a(Object obj) {
|
|
if (this.h.add(obj)) {
|
|
Iterator<BitmapHunter> it = this.e.values().iterator();
|
|
while (it.hasNext()) {
|
|
BitmapHunter next = it.next();
|
|
boolean z = next.k().n;
|
|
Action a = next.a();
|
|
List<Action> b = next.b();
|
|
boolean z2 = (b == null || b.isEmpty()) ? false : true;
|
|
if (a != null || z2) {
|
|
if (a != null && a.i().equals(obj)) {
|
|
next.b(a);
|
|
this.g.put(a.j(), a);
|
|
if (z) {
|
|
Utils.a("Dispatcher", "paused", a.b.d(), "because tag '" + obj + "' was paused");
|
|
}
|
|
}
|
|
if (z2) {
|
|
for (int size = b.size() - 1; size >= 0; size--) {
|
|
Action action = b.get(size);
|
|
if (action.i().equals(obj)) {
|
|
next.b(action);
|
|
this.g.put(action.j(), action);
|
|
if (z) {
|
|
Utils.a("Dispatcher", "paused", action.b.d(), "because tag '" + obj + "' was paused");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (next.cancel()) {
|
|
it.remove();
|
|
if (z) {
|
|
Utils.a("Dispatcher", "canceled", Utils.a(next), "all actions paused");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void a() {
|
|
ArrayList arrayList = new ArrayList(this.m);
|
|
this.m.clear();
|
|
Handler handler = this.j;
|
|
handler.sendMessage(handler.obtainMessage(8, arrayList));
|
|
a((List<BitmapHunter>) arrayList);
|
|
}
|
|
|
|
void a(BitmapHunter bitmapHunter, boolean z) {
|
|
if (bitmapHunter.k().n) {
|
|
String a = Utils.a(bitmapHunter);
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("for error");
|
|
sb.append(z ? " (will replay)" : "");
|
|
Utils.a("Dispatcher", "batched", a, sb.toString());
|
|
}
|
|
this.e.remove(bitmapHunter.e());
|
|
f(bitmapHunter);
|
|
}
|
|
|
|
private void a(List<BitmapHunter> list) {
|
|
if (list == null || list.isEmpty() || !list.get(0).k().n) {
|
|
return;
|
|
}
|
|
StringBuilder sb = new StringBuilder();
|
|
for (BitmapHunter bitmapHunter : list) {
|
|
if (sb.length() > 0) {
|
|
sb.append(", ");
|
|
}
|
|
sb.append(Utils.a(bitmapHunter));
|
|
}
|
|
Utils.a("Dispatcher", "delivered", sb.toString());
|
|
}
|
|
}
|