ADD week 5

2025-03-31 16:33:42 +02:00
parent 86f265f22d
commit bf645048e6
4927 changed files with 544053 additions and 0 deletions
--- a/02-Easy5/E5/sources/androidx/dynamicanimation/animation/AnimationHandler.java
+++ b/02-Easy5/E5/sources/androidx/dynamicanimation/animation/AnimationHandler.java
@@ -0,0 +1,178 @@
+package androidx.dynamicanimation.animation;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import android.view.Choreographer;
+import androidx.collection.SimpleArrayMap;
+import java.util.ArrayList;
+
+/* loaded from: classes.dex */
+class AnimationHandler {
+    private static final long FRAME_DELAY_MS = 10;
+    public static final ThreadLocal<AnimationHandler> sAnimatorHandler = new ThreadLocal<>();
+    private AnimationFrameCallbackProvider mProvider;
+    private final SimpleArrayMap<AnimationFrameCallback, Long> mDelayedCallbackStartTime = new SimpleArrayMap<>();
+    final ArrayList<AnimationFrameCallback> mAnimationCallbacks = new ArrayList<>();
+    private final AnimationCallbackDispatcher mCallbackDispatcher = new AnimationCallbackDispatcher();
+    long mCurrentFrameTime = 0;
+    private boolean mListDirty = false;
+
+    interface AnimationFrameCallback {
+        boolean doAnimationFrame(long j);
+    }
+
+    public void setProvider(AnimationFrameCallbackProvider animationFrameCallbackProvider) {
+        this.mProvider = animationFrameCallbackProvider;
+    }
+
+    AnimationHandler() {
+    }
+
+    class AnimationCallbackDispatcher {
+        AnimationCallbackDispatcher() {
+        }
+
+        void dispatchAnimationFrame() {
+            AnimationHandler.this.mCurrentFrameTime = SystemClock.uptimeMillis();
+            AnimationHandler animationHandler = AnimationHandler.this;
+            animationHandler.doAnimationFrame(animationHandler.mCurrentFrameTime);
+            if (AnimationHandler.this.mAnimationCallbacks.size() > 0) {
+                AnimationHandler.this.getProvider().postFrameCallback();
+            }
+        }
+    }
+
+    public static AnimationHandler getInstance() {
+        ThreadLocal<AnimationHandler> threadLocal = sAnimatorHandler;
+        if (threadLocal.get() == null) {
+            threadLocal.set(new AnimationHandler());
+        }
+        return threadLocal.get();
+    }
+
+    public static long getFrameTime() {
+        ThreadLocal<AnimationHandler> threadLocal = sAnimatorHandler;
+        if (threadLocal.get() == null) {
+            return 0L;
+        }
+        return threadLocal.get().mCurrentFrameTime;
+    }
+
+    AnimationFrameCallbackProvider getProvider() {
+        if (this.mProvider == null) {
+            this.mProvider = new FrameCallbackProvider16(this.mCallbackDispatcher);
+        }
+        return this.mProvider;
+    }
+
+    public void addAnimationFrameCallback(AnimationFrameCallback animationFrameCallback, long j) {
+        if (this.mAnimationCallbacks.size() == 0) {
+            getProvider().postFrameCallback();
+        }
+        if (!this.mAnimationCallbacks.contains(animationFrameCallback)) {
+            this.mAnimationCallbacks.add(animationFrameCallback);
+        }
+        if (j > 0) {
+            this.mDelayedCallbackStartTime.put(animationFrameCallback, Long.valueOf(SystemClock.uptimeMillis() + j));
+        }
+    }
+
+    public void removeCallback(AnimationFrameCallback animationFrameCallback) {
+        this.mDelayedCallbackStartTime.remove(animationFrameCallback);
+        int indexOf = this.mAnimationCallbacks.indexOf(animationFrameCallback);
+        if (indexOf >= 0) {
+            this.mAnimationCallbacks.set(indexOf, null);
+            this.mListDirty = true;
+        }
+    }
+
+    void doAnimationFrame(long j) {
+        long uptimeMillis = SystemClock.uptimeMillis();
+        for (int i = 0; i < this.mAnimationCallbacks.size(); i++) {
+            AnimationFrameCallback animationFrameCallback = this.mAnimationCallbacks.get(i);
+            if (animationFrameCallback != null && isCallbackDue(animationFrameCallback, uptimeMillis)) {
+                animationFrameCallback.doAnimationFrame(j);
+            }
+        }
+        cleanUpList();
+    }
+
+    private boolean isCallbackDue(AnimationFrameCallback animationFrameCallback, long j) {
+        Long l = this.mDelayedCallbackStartTime.get(animationFrameCallback);
+        if (l == null) {
+            return true;
+        }
+        if (l.longValue() >= j) {
+            return false;
+        }
+        this.mDelayedCallbackStartTime.remove(animationFrameCallback);
+        return true;
+    }
+
+    private void cleanUpList() {
+        if (this.mListDirty) {
+            for (int size = this.mAnimationCallbacks.size() - 1; size >= 0; size--) {
+                if (this.mAnimationCallbacks.get(size) == null) {
+                    this.mAnimationCallbacks.remove(size);
+                }
+            }
+            this.mListDirty = false;
+        }
+    }
+
+    private static class FrameCallbackProvider16 extends AnimationFrameCallbackProvider {
+        private final Choreographer mChoreographer;
+        private final Choreographer.FrameCallback mChoreographerCallback;
+
+        FrameCallbackProvider16(AnimationCallbackDispatcher animationCallbackDispatcher) {
+            super(animationCallbackDispatcher);
+            this.mChoreographer = Choreographer.getInstance();
+            this.mChoreographerCallback = new Choreographer.FrameCallback() { // from class: androidx.dynamicanimation.animation.AnimationHandler.FrameCallbackProvider16.1
+                @Override // android.view.Choreographer.FrameCallback
+                public void doFrame(long j) {
+                    FrameCallbackProvider16.this.mDispatcher.dispatchAnimationFrame();
+                }
+            };
+        }
+
+        @Override // androidx.dynamicanimation.animation.AnimationHandler.AnimationFrameCallbackProvider
+        void postFrameCallback() {
+            this.mChoreographer.postFrameCallback(this.mChoreographerCallback);
+        }
+    }
+
+    private static class FrameCallbackProvider14 extends AnimationFrameCallbackProvider {
+        private final Handler mHandler;
+        long mLastFrameTime;
+        private final Runnable mRunnable;
+
+        FrameCallbackProvider14(AnimationCallbackDispatcher animationCallbackDispatcher) {
+            super(animationCallbackDispatcher);
+            this.mLastFrameTime = -1L;
+            this.mRunnable = new Runnable() { // from class: androidx.dynamicanimation.animation.AnimationHandler.FrameCallbackProvider14.1
+                @Override // java.lang.Runnable
+                public void run() {
+                    FrameCallbackProvider14.this.mLastFrameTime = SystemClock.uptimeMillis();
+                    FrameCallbackProvider14.this.mDispatcher.dispatchAnimationFrame();
+                }
+            };
+            this.mHandler = new Handler(Looper.myLooper());
+        }
+
+        @Override // androidx.dynamicanimation.animation.AnimationHandler.AnimationFrameCallbackProvider
+        void postFrameCallback() {
+            this.mHandler.postDelayed(this.mRunnable, Math.max(AnimationHandler.FRAME_DELAY_MS - (SystemClock.uptimeMillis() - this.mLastFrameTime), 0L));
+        }
+    }
+
+    static abstract class AnimationFrameCallbackProvider {
+        final AnimationCallbackDispatcher mDispatcher;
+
+        abstract void postFrameCallback();
+
+        AnimationFrameCallbackProvider(AnimationCallbackDispatcher animationCallbackDispatcher) {
+            this.mDispatcher = animationCallbackDispatcher;
+        }
+    }
+}