ADD week 5
This commit is contained in:
7
02-Easy5/E5/sources/androidx/arch/core/R.java
Normal file
7
02-Easy5/E5/sources/androidx/arch/core/R.java
Normal file
@ -0,0 +1,7 @@
|
||||
package androidx.arch.core;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public final class R {
|
||||
private R() {
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,70 @@
|
||||
package androidx.arch.core.executor;
|
||||
|
||||
import java.util.concurrent.Executor;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public class ArchTaskExecutor extends TaskExecutor {
|
||||
private static volatile ArchTaskExecutor sInstance;
|
||||
private final TaskExecutor mDefaultTaskExecutor;
|
||||
private TaskExecutor mDelegate;
|
||||
private static final Executor sMainThreadExecutor = new Executor() { // from class: androidx.arch.core.executor.ArchTaskExecutor$$ExternalSyntheticLambda0
|
||||
@Override // java.util.concurrent.Executor
|
||||
public final void execute(Runnable runnable) {
|
||||
ArchTaskExecutor.getInstance().postToMainThread(runnable);
|
||||
}
|
||||
};
|
||||
private static final Executor sIOThreadExecutor = new Executor() { // from class: androidx.arch.core.executor.ArchTaskExecutor$$ExternalSyntheticLambda1
|
||||
@Override // java.util.concurrent.Executor
|
||||
public final void execute(Runnable runnable) {
|
||||
ArchTaskExecutor.getInstance().executeOnDiskIO(runnable);
|
||||
}
|
||||
};
|
||||
|
||||
public static Executor getIOThreadExecutor() {
|
||||
return sIOThreadExecutor;
|
||||
}
|
||||
|
||||
public static Executor getMainThreadExecutor() {
|
||||
return sMainThreadExecutor;
|
||||
}
|
||||
|
||||
public void setDelegate(TaskExecutor taskExecutor) {
|
||||
if (taskExecutor == null) {
|
||||
taskExecutor = this.mDefaultTaskExecutor;
|
||||
}
|
||||
this.mDelegate = taskExecutor;
|
||||
}
|
||||
|
||||
private ArchTaskExecutor() {
|
||||
DefaultTaskExecutor defaultTaskExecutor = new DefaultTaskExecutor();
|
||||
this.mDefaultTaskExecutor = defaultTaskExecutor;
|
||||
this.mDelegate = defaultTaskExecutor;
|
||||
}
|
||||
|
||||
public static ArchTaskExecutor getInstance() {
|
||||
if (sInstance != null) {
|
||||
return sInstance;
|
||||
}
|
||||
synchronized (ArchTaskExecutor.class) {
|
||||
if (sInstance == null) {
|
||||
sInstance = new ArchTaskExecutor();
|
||||
}
|
||||
}
|
||||
return sInstance;
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.executor.TaskExecutor
|
||||
public void executeOnDiskIO(Runnable runnable) {
|
||||
this.mDelegate.executeOnDiskIO(runnable);
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.executor.TaskExecutor
|
||||
public void postToMainThread(Runnable runnable) {
|
||||
this.mDelegate.postToMainThread(runnable);
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.executor.TaskExecutor
|
||||
public boolean isMainThread() {
|
||||
return this.mDelegate.isMainThread();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,71 @@
|
||||
package androidx.arch.core.executor;
|
||||
|
||||
import android.os.Build;
|
||||
import android.os.Handler;
|
||||
import android.os.Looper;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.ThreadFactory;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public class DefaultTaskExecutor extends TaskExecutor {
|
||||
private volatile Handler mMainHandler;
|
||||
private final Object mLock = new Object();
|
||||
private final ExecutorService mDiskIO = Executors.newFixedThreadPool(4, new ThreadFactory() { // from class: androidx.arch.core.executor.DefaultTaskExecutor.1
|
||||
private static final String THREAD_NAME_STEM = "arch_disk_io_";
|
||||
private final AtomicInteger mThreadId = new AtomicInteger(0);
|
||||
|
||||
@Override // java.util.concurrent.ThreadFactory
|
||||
public Thread newThread(Runnable runnable) {
|
||||
Thread thread = new Thread(runnable);
|
||||
thread.setName(THREAD_NAME_STEM + this.mThreadId.getAndIncrement());
|
||||
return thread;
|
||||
}
|
||||
});
|
||||
|
||||
@Override // androidx.arch.core.executor.TaskExecutor
|
||||
public void executeOnDiskIO(Runnable runnable) {
|
||||
this.mDiskIO.execute(runnable);
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.executor.TaskExecutor
|
||||
public void postToMainThread(Runnable runnable) {
|
||||
if (this.mMainHandler == null) {
|
||||
synchronized (this.mLock) {
|
||||
if (this.mMainHandler == null) {
|
||||
this.mMainHandler = createAsync(Looper.getMainLooper());
|
||||
}
|
||||
}
|
||||
}
|
||||
this.mMainHandler.post(runnable);
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.executor.TaskExecutor
|
||||
public boolean isMainThread() {
|
||||
return Looper.getMainLooper().getThread() == Thread.currentThread();
|
||||
}
|
||||
|
||||
private static Handler createAsync(Looper looper) {
|
||||
if (Build.VERSION.SDK_INT >= 28) {
|
||||
return Api28Impl.createAsync(looper);
|
||||
}
|
||||
try {
|
||||
return (Handler) Handler.class.getDeclaredConstructor(Looper.class, Handler.Callback.class, Boolean.TYPE).newInstance(looper, null, true);
|
||||
} catch (IllegalAccessException | InstantiationException | NoSuchMethodException unused) {
|
||||
return new Handler(looper);
|
||||
} catch (InvocationTargetException unused2) {
|
||||
return new Handler(looper);
|
||||
}
|
||||
}
|
||||
|
||||
private static class Api28Impl {
|
||||
private Api28Impl() {
|
||||
}
|
||||
|
||||
public static Handler createAsync(Looper looper) {
|
||||
return Handler.createAsync(looper);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
package androidx.arch.core.executor;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public abstract class TaskExecutor {
|
||||
public abstract void executeOnDiskIO(Runnable runnable);
|
||||
|
||||
public abstract boolean isMainThread();
|
||||
|
||||
public abstract void postToMainThread(Runnable runnable);
|
||||
|
||||
public void executeOnMainThread(Runnable runnable) {
|
||||
if (isMainThread()) {
|
||||
runnable.run();
|
||||
} else {
|
||||
postToMainThread(runnable);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,43 @@
|
||||
package androidx.arch.core.internal;
|
||||
|
||||
import androidx.arch.core.internal.SafeIterableMap;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public class FastSafeIterableMap<K, V> extends SafeIterableMap<K, V> {
|
||||
private final HashMap<K, SafeIterableMap.Entry<K, V>> mHashMap = new HashMap<>();
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap
|
||||
protected SafeIterableMap.Entry<K, V> get(K k) {
|
||||
return this.mHashMap.get(k);
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap
|
||||
public V putIfAbsent(K k, V v) {
|
||||
SafeIterableMap.Entry<K, V> entry = get(k);
|
||||
if (entry != null) {
|
||||
return entry.mValue;
|
||||
}
|
||||
this.mHashMap.put(k, put(k, v));
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap
|
||||
public V remove(K k) {
|
||||
V v = (V) super.remove(k);
|
||||
this.mHashMap.remove(k);
|
||||
return v;
|
||||
}
|
||||
|
||||
public boolean contains(K k) {
|
||||
return this.mHashMap.containsKey(k);
|
||||
}
|
||||
|
||||
public Map.Entry<K, V> ceil(K k) {
|
||||
if (contains(k)) {
|
||||
return this.mHashMap.get(k).mPrevious;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,321 @@
|
||||
package androidx.arch.core.internal;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.WeakHashMap;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public class SafeIterableMap<K, V> implements Iterable<Map.Entry<K, V>> {
|
||||
private Entry<K, V> mEnd;
|
||||
private final WeakHashMap<SupportRemove<K, V>, Boolean> mIterators = new WeakHashMap<>();
|
||||
private int mSize = 0;
|
||||
Entry<K, V> mStart;
|
||||
|
||||
public static abstract class SupportRemove<K, V> {
|
||||
abstract void supportRemove(Entry<K, V> entry);
|
||||
}
|
||||
|
||||
public Map.Entry<K, V> eldest() {
|
||||
return this.mStart;
|
||||
}
|
||||
|
||||
public Map.Entry<K, V> newest() {
|
||||
return this.mEnd;
|
||||
}
|
||||
|
||||
public int size() {
|
||||
return this.mSize;
|
||||
}
|
||||
|
||||
protected Entry<K, V> get(K k) {
|
||||
Entry<K, V> entry = this.mStart;
|
||||
while (entry != null && !entry.mKey.equals(k)) {
|
||||
entry = entry.mNext;
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
|
||||
public V putIfAbsent(K k, V v) {
|
||||
Entry<K, V> entry = get(k);
|
||||
if (entry != null) {
|
||||
return entry.mValue;
|
||||
}
|
||||
put(k, v);
|
||||
return null;
|
||||
}
|
||||
|
||||
Entry<K, V> put(K k, V v) {
|
||||
Entry<K, V> entry = new Entry<>(k, v);
|
||||
this.mSize++;
|
||||
Entry<K, V> entry2 = this.mEnd;
|
||||
if (entry2 == null) {
|
||||
this.mStart = entry;
|
||||
this.mEnd = entry;
|
||||
return entry;
|
||||
}
|
||||
entry2.mNext = entry;
|
||||
entry.mPrevious = this.mEnd;
|
||||
this.mEnd = entry;
|
||||
return entry;
|
||||
}
|
||||
|
||||
public V remove(K k) {
|
||||
Entry<K, V> entry = get(k);
|
||||
if (entry == null) {
|
||||
return null;
|
||||
}
|
||||
this.mSize--;
|
||||
if (!this.mIterators.isEmpty()) {
|
||||
Iterator<SupportRemove<K, V>> it = this.mIterators.keySet().iterator();
|
||||
while (it.hasNext()) {
|
||||
it.next().supportRemove(entry);
|
||||
}
|
||||
}
|
||||
if (entry.mPrevious != null) {
|
||||
entry.mPrevious.mNext = entry.mNext;
|
||||
} else {
|
||||
this.mStart = entry.mNext;
|
||||
}
|
||||
if (entry.mNext != null) {
|
||||
entry.mNext.mPrevious = entry.mPrevious;
|
||||
} else {
|
||||
this.mEnd = entry.mPrevious;
|
||||
}
|
||||
entry.mNext = null;
|
||||
entry.mPrevious = null;
|
||||
return entry.mValue;
|
||||
}
|
||||
|
||||
@Override // java.lang.Iterable
|
||||
public Iterator<Map.Entry<K, V>> iterator() {
|
||||
AscendingIterator ascendingIterator = new AscendingIterator(this.mStart, this.mEnd);
|
||||
this.mIterators.put(ascendingIterator, false);
|
||||
return ascendingIterator;
|
||||
}
|
||||
|
||||
public Iterator<Map.Entry<K, V>> descendingIterator() {
|
||||
DescendingIterator descendingIterator = new DescendingIterator(this.mEnd, this.mStart);
|
||||
this.mIterators.put(descendingIterator, false);
|
||||
return descendingIterator;
|
||||
}
|
||||
|
||||
public SafeIterableMap<K, V>.IteratorWithAdditions iteratorWithAdditions() {
|
||||
SafeIterableMap<K, V>.IteratorWithAdditions iteratorWithAdditions = new IteratorWithAdditions();
|
||||
this.mIterators.put(iteratorWithAdditions, false);
|
||||
return iteratorWithAdditions;
|
||||
}
|
||||
|
||||
public boolean equals(Object obj) {
|
||||
if (obj == this) {
|
||||
return true;
|
||||
}
|
||||
if (!(obj instanceof SafeIterableMap)) {
|
||||
return false;
|
||||
}
|
||||
SafeIterableMap safeIterableMap = (SafeIterableMap) obj;
|
||||
if (size() != safeIterableMap.size()) {
|
||||
return false;
|
||||
}
|
||||
Iterator<Map.Entry<K, V>> it = iterator();
|
||||
Iterator<Map.Entry<K, V>> it2 = safeIterableMap.iterator();
|
||||
while (it.hasNext() && it2.hasNext()) {
|
||||
Map.Entry<K, V> next = it.next();
|
||||
Map.Entry<K, V> next2 = it2.next();
|
||||
if ((next == null && next2 != null) || (next != null && !next.equals(next2))) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return (it.hasNext() || it2.hasNext()) ? false : true;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
Iterator<Map.Entry<K, V>> it = iterator();
|
||||
int i = 0;
|
||||
while (it.hasNext()) {
|
||||
i += it.next().hashCode();
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder("[");
|
||||
Iterator<Map.Entry<K, V>> it = iterator();
|
||||
while (it.hasNext()) {
|
||||
sb.append(it.next().toString());
|
||||
if (it.hasNext()) {
|
||||
sb.append(", ");
|
||||
}
|
||||
}
|
||||
sb.append("]");
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private static abstract class ListIterator<K, V> extends SupportRemove<K, V> implements Iterator<Map.Entry<K, V>> {
|
||||
Entry<K, V> mExpectedEnd;
|
||||
Entry<K, V> mNext;
|
||||
|
||||
abstract Entry<K, V> backward(Entry<K, V> entry);
|
||||
|
||||
abstract Entry<K, V> forward(Entry<K, V> entry);
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public boolean hasNext() {
|
||||
return this.mNext != null;
|
||||
}
|
||||
|
||||
ListIterator(Entry<K, V> entry, Entry<K, V> entry2) {
|
||||
this.mExpectedEnd = entry2;
|
||||
this.mNext = entry;
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap.SupportRemove
|
||||
public void supportRemove(Entry<K, V> entry) {
|
||||
if (this.mExpectedEnd == entry && entry == this.mNext) {
|
||||
this.mNext = null;
|
||||
this.mExpectedEnd = null;
|
||||
}
|
||||
Entry<K, V> entry2 = this.mExpectedEnd;
|
||||
if (entry2 == entry) {
|
||||
this.mExpectedEnd = backward(entry2);
|
||||
}
|
||||
if (this.mNext == entry) {
|
||||
this.mNext = nextNode();
|
||||
}
|
||||
}
|
||||
|
||||
private Entry<K, V> nextNode() {
|
||||
Entry<K, V> entry = this.mNext;
|
||||
Entry<K, V> entry2 = this.mExpectedEnd;
|
||||
if (entry == entry2 || entry2 == null) {
|
||||
return null;
|
||||
}
|
||||
return forward(entry);
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public Map.Entry<K, V> next() {
|
||||
Entry<K, V> entry = this.mNext;
|
||||
this.mNext = nextNode();
|
||||
return entry;
|
||||
}
|
||||
}
|
||||
|
||||
static class AscendingIterator<K, V> extends ListIterator<K, V> {
|
||||
AscendingIterator(Entry<K, V> entry, Entry<K, V> entry2) {
|
||||
super(entry, entry2);
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
|
||||
Entry<K, V> forward(Entry<K, V> entry) {
|
||||
return entry.mNext;
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
|
||||
Entry<K, V> backward(Entry<K, V> entry) {
|
||||
return entry.mPrevious;
|
||||
}
|
||||
}
|
||||
|
||||
private static class DescendingIterator<K, V> extends ListIterator<K, V> {
|
||||
DescendingIterator(Entry<K, V> entry, Entry<K, V> entry2) {
|
||||
super(entry, entry2);
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
|
||||
Entry<K, V> forward(Entry<K, V> entry) {
|
||||
return entry.mPrevious;
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap.ListIterator
|
||||
Entry<K, V> backward(Entry<K, V> entry) {
|
||||
return entry.mNext;
|
||||
}
|
||||
}
|
||||
|
||||
public class IteratorWithAdditions extends SupportRemove<K, V> implements Iterator<Map.Entry<K, V>> {
|
||||
private boolean mBeforeStart = true;
|
||||
private Entry<K, V> mCurrent;
|
||||
|
||||
IteratorWithAdditions() {
|
||||
}
|
||||
|
||||
@Override // androidx.arch.core.internal.SafeIterableMap.SupportRemove
|
||||
void supportRemove(Entry<K, V> entry) {
|
||||
Entry<K, V> entry2 = this.mCurrent;
|
||||
if (entry == entry2) {
|
||||
Entry<K, V> entry3 = entry2.mPrevious;
|
||||
this.mCurrent = entry3;
|
||||
this.mBeforeStart = entry3 == null;
|
||||
}
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public boolean hasNext() {
|
||||
if (this.mBeforeStart) {
|
||||
return SafeIterableMap.this.mStart != null;
|
||||
}
|
||||
Entry<K, V> entry = this.mCurrent;
|
||||
return (entry == null || entry.mNext == null) ? false : true;
|
||||
}
|
||||
|
||||
@Override // java.util.Iterator
|
||||
public Map.Entry<K, V> next() {
|
||||
if (this.mBeforeStart) {
|
||||
this.mBeforeStart = false;
|
||||
this.mCurrent = SafeIterableMap.this.mStart;
|
||||
} else {
|
||||
Entry<K, V> entry = this.mCurrent;
|
||||
this.mCurrent = entry != null ? entry.mNext : null;
|
||||
}
|
||||
return this.mCurrent;
|
||||
}
|
||||
}
|
||||
|
||||
static class Entry<K, V> implements Map.Entry<K, V> {
|
||||
final K mKey;
|
||||
Entry<K, V> mNext;
|
||||
Entry<K, V> mPrevious;
|
||||
final V mValue;
|
||||
|
||||
@Override // java.util.Map.Entry
|
||||
public K getKey() {
|
||||
return this.mKey;
|
||||
}
|
||||
|
||||
@Override // java.util.Map.Entry
|
||||
public V getValue() {
|
||||
return this.mValue;
|
||||
}
|
||||
|
||||
Entry(K k, V v) {
|
||||
this.mKey = k;
|
||||
this.mValue = v;
|
||||
}
|
||||
|
||||
@Override // java.util.Map.Entry
|
||||
public V setValue(V v) {
|
||||
throw new UnsupportedOperationException("An entry modification is not supported");
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return this.mKey + "=" + this.mValue;
|
||||
}
|
||||
|
||||
@Override // java.util.Map.Entry
|
||||
public boolean equals(Object obj) {
|
||||
if (obj == this) {
|
||||
return true;
|
||||
}
|
||||
if (!(obj instanceof Entry)) {
|
||||
return false;
|
||||
}
|
||||
Entry entry = (Entry) obj;
|
||||
return this.mKey.equals(entry.mKey) && this.mValue.equals(entry.mValue);
|
||||
}
|
||||
|
||||
@Override // java.util.Map.Entry
|
||||
public int hashCode() {
|
||||
return this.mKey.hashCode() ^ this.mValue.hashCode();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,6 @@
|
||||
package androidx.arch.core.util;
|
||||
|
||||
/* loaded from: classes.dex */
|
||||
public interface Function<I, O> {
|
||||
O apply(I i);
|
||||
}
|
||||
Reference in New Issue
Block a user