zkit-ui 2.0.3 → 2.0.5

package/android/src/main/java/cn/fontree/zkit/ui/preview/GallerySharedElementState.java

@@ -0,0 +1,25 @@
+package cn.fontree.zkit.ui.preview;
+
+import android.graphics.drawable.Drawable;
+
+import androidx.annotation.NonNull;
+
+public final class GallerySharedElementState {
+    private final Drawable drawable;
+    private final GallerySharedElementGeometry geometry;
+
+    public GallerySharedElementState(@NonNull Drawable drawable, @NonNull GallerySharedElementGeometry geometry) {
+        this.drawable = drawable;
+        this.geometry = geometry;
+    }
+
+    @NonNull
+    public Drawable getDrawable() {
+        return drawable;
+    }
+
+    @NonNull
+    public GallerySharedElementGeometry getGeometry() {
+        return geometry;
+    }
+}

package/android/src/main/java/cn/fontree/zkit/ui/preview/GallerySourceViewRegistry.java

@@ -0,0 +1,115 @@
+package cn.fontree.zkit.ui.preview;
+
+import android.view.View;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.view.ViewCompat;
+
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+public final class GallerySourceViewRegistry {
+    private static final Map<String, WeakReference<ImageView>> SOURCE_VIEWS = new HashMap<>();
+
+    private GallerySourceViewRegistry() {
+    }
+
+    public static synchronized void register(@NonNull String key, @NonNull ImageView imageView) {
+        cleanupLocked();
+        if (!hasUsableGeometry(imageView)) {
+            ImageView existingImageView = resolveMappedViewLocked(key);
+            boolean keepExisting = existingImageView != null
+                    && existingImageView != imageView
+                    && hasUsableGeometry(existingImageView);
+            clearMappingsForViewLocked(imageView);
+            if (keepExisting) {
+                SOURCE_VIEWS.put(key, new WeakReference<>(existingImageView));
+                return;
+            }
+            SOURCE_VIEWS.remove(key);
+            return;
+        }
+
+        ImageView previousImageView = resolveMappedViewLocked(key);
+        if (!isPreferredSourceView(imageView)
+                && previousImageView != null
+                && previousImageView != imageView
+                && isPreferredSourceView(previousImageView)) {
+            clearMappingsForViewLocked(imageView);
+            SOURCE_VIEWS.put(key, new WeakReference<>(previousImageView));
+            return;
+        }
+
+        clearMappingsForViewLocked(imageView);
+        SOURCE_VIEWS.put(key, new WeakReference<>(imageView));
+        ViewCompat.setTransitionName(imageView, key);
+    }
+
+    public static synchronized void unregisterView(@NonNull ImageView imageView) {
+        clearMappingsForViewLocked(imageView);
+    }
+
+    @Nullable
+    public static synchronized ImageView find(@NonNull String key) {
+        cleanupLocked();
+        WeakReference<ImageView> reference = SOURCE_VIEWS.get(key);
+        if (reference == null) {
+            return null;
+        }
+        ImageView imageView = reference.get();
+        if (imageView == null || !imageView.isAttachedToWindow()) {
+            SOURCE_VIEWS.remove(key);
+            return null;
+        }
+        if (!hasUsableGeometry(imageView)) {
+            SOURCE_VIEWS.remove(key);
+            return null;
+        }
+        return imageView;
+    }
+
+    @Nullable
+    private static ImageView resolveMappedViewLocked(@NonNull String key) {
+        WeakReference<ImageView> reference = SOURCE_VIEWS.get(key);
+        return reference != null ? reference.get() : null;
+    }
+
+    private static boolean hasUsableGeometry(@Nullable ImageView imageView) {
+        return imageView != null
+                && imageView.isAttachedToWindow()
+                && imageView.getWidth() > 0
+                && imageView.getHeight() > 0;
+    }
+
+    private static boolean isPreferredSourceView(@Nullable ImageView imageView) {
+        return hasUsableGeometry(imageView)
+                && imageView.getVisibility() == View.VISIBLE
+                && imageView.isShown();
+    }
+
+    private static void clearMappingsForViewLocked(@NonNull ImageView imageView) {
+        Iterator<Map.Entry<String, WeakReference<ImageView>>> iterator = SOURCE_VIEWS.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<String, WeakReference<ImageView>> entry = iterator.next();
+            ImageView mappedView = entry.getValue().get();
+            if (mappedView == null || mappedView == imageView) {
+                iterator.remove();
+            }
+        }
+    }
+
+    private static void cleanupLocked() {
+        Iterator<Map.Entry<String, WeakReference<ImageView>>> iterator = SOURCE_VIEWS.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<String, WeakReference<ImageView>> entry = iterator.next();
+            ImageView mappedView = entry.getValue().get();
+            if (mappedView == null) {
+                iterator.remove();
+            }
+        }
+    }
+}

package/android/src/main/java/cn/fontree/zkit/ui/preview/GalleryTransitionSnapshotView.java

@@ -0,0 +1,60 @@
+package cn.fontree.zkit.ui.preview;
+
+import android.content.Context;
+import android.graphics.RectF;
+import android.graphics.drawable.Drawable;
+import android.view.Gravity;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+
+public final class GalleryTransitionSnapshotView extends FrameLayout {
+    private final ImageView imageView;
+
+    public GalleryTransitionSnapshotView(@NonNull Context context, @NonNull Drawable drawable) {
+        super(context);
+        setClipChildren(true);
+        setClipToPadding(true);
+        imageView = new ImageView(context);
+        imageView.setScaleType(ImageView.ScaleType.FIT_XY);
+        imageView.setImageDrawable(drawable);
+        addView(imageView);
+    }
+
+    public void applyGeometry(@NonNull GallerySharedElementGeometry geometry) {
+        RectF visibleFrame = geometry.getVisibleFrameInWindow();
+        FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) getLayoutParams();
+        if (layoutParams == null) {
+            layoutParams = new FrameLayout.LayoutParams(
+                    Math.max(1, Math.round(visibleFrame.width())),
+                    Math.max(1, Math.round(visibleFrame.height()))
+            );
+        }
+        layoutParams.width = Math.max(1, Math.round(visibleFrame.width()));
+        layoutParams.height = Math.max(1, Math.round(visibleFrame.height()));
+        layoutParams.leftMargin = 0;
+        layoutParams.topMargin = 0;
+        layoutParams.gravity = Gravity.TOP | Gravity.START;
+        setLayoutParams(layoutParams);
+        setX(visibleFrame.left);
+        setY(visibleFrame.top);
+
+        RectF contentFrame = geometry.getContentFrameInVisibleBounds();
+        FrameLayout.LayoutParams imageLayoutParams = (FrameLayout.LayoutParams) imageView.getLayoutParams();
+        if (imageLayoutParams == null) {
+            imageLayoutParams = new FrameLayout.LayoutParams(
+                    Math.max(1, Math.round(contentFrame.width())),
+                    Math.max(1, Math.round(contentFrame.height()))
+            );
+        }
+        imageLayoutParams.width = Math.max(1, Math.round(contentFrame.width()));
+        imageLayoutParams.height = Math.max(1, Math.round(contentFrame.height()));
+        imageLayoutParams.leftMargin = 0;
+        imageLayoutParams.topMargin = 0;
+        imageLayoutParams.gravity = Gravity.TOP | Gravity.START;
+        imageView.setLayoutParams(imageLayoutParams);
+        imageView.setX(contentFrame.left);
+        imageView.setY(contentFrame.top);
+    }
+}

package/android/src/main/java/cn/fontree/zkit/ui/preview/GalleryVideoPlayerView.java

@@ -0,0 +1,338 @@
+package cn.fontree.zkit.ui.preview;
+
+import android.content.Context;
+import android.content.res.ColorStateList;
+import android.graphics.Color;
+import android.graphics.Rect;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.util.TypedValue;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.content.res.AppCompatResources;
+import androidx.appcompat.widget.AppCompatImageButton;
+import androidx.media3.common.MediaItem;
+import androidx.media3.common.Player;
+import androidx.media3.exoplayer.ExoPlayer;
+import androidx.media3.ui.PlayerControlView;
+import androidx.media3.ui.PlayerView;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.target.Target;
+
+public final class GalleryVideoPlayerView extends FrameLayout {
+    public interface Listener {
+        void onCloseRequested();
+    }
+
+    private final ImageView posterImageView;
+    private final PlayerView playerView;
+    private final AppCompatImageButton closeButton;
+    @Nullable
+    private Runnable contentReadyListener;
+    @Nullable
+    private GalleryMediaItem item;
+    @Nullable
+    private ExoPlayer player;
+    @Nullable
+    private String preparedSourceUrl;
+    @Nullable
+    private Listener listener;
+    private boolean firstFrameReady;
+    private boolean active;
+
+    private final Player.Listener playerListener = new Player.Listener() {
+        @Override
+        public void onRenderedFirstFrame() {
+            firstFrameReady = true;
+            if (active) {
+                revealPlayer();
+            }
+        }
+    };
+
+    public GalleryVideoPlayerView(@NonNull Context context) {
+        super(context);
+        setLayoutParams(new LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+        ));
+        setBackgroundColor(Color.TRANSPARENT);
+
+        posterImageView = new ImageView(context);
+        posterImageView.setLayoutParams(new LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+        ));
+        posterImageView.setScaleType(ImageView.ScaleType.FIT_CENTER);
+        posterImageView.setBackgroundColor(Color.TRANSPARENT);
+        addView(posterImageView);
+
+        playerView = (PlayerView) LayoutInflater.from(context)
+                .inflate(R.layout.galeria_player_view, this, false);
+        playerView.setUseController(true);
+        playerView.setControllerAutoShow(true);
+        playerView.setControllerHideOnTouch(true);
+        playerView.setShutterBackgroundColor(Color.TRANSPARENT);
+        playerView.setBackgroundColor(Color.TRANSPARENT);
+        playerView.setShowPreviousButton(false);
+        playerView.setShowNextButton(false);
+        playerView.setShowRewindButton(false);
+        playerView.setShowFastForwardButton(false);
+        playerView.setShowSubtitleButton(false);
+        playerView.setShowVrButton(false);
+        playerView.setShowShuffleButton(false);
+        playerView.setAlpha(0f);
+        playerView.setVisibility(VISIBLE);
+        addView(playerView);
+        hideControllerView(androidx.media3.ui.R.id.exo_settings);
+        hideControllerView(androidx.media3.ui.R.id.exo_overflow_show);
+        hideControllerView(androidx.media3.ui.R.id.exo_overflow_hide);
+
+        closeButton = new AppCompatImageButton(context);
+        LayoutParams closeLayoutParams = new LayoutParams(dp(48), dp(48));
+        closeLayoutParams.gravity = Gravity.TOP | Gravity.START;
+        closeLayoutParams.topMargin = dp(14);
+        closeLayoutParams.leftMargin = dp(10);
+        closeButton.setLayoutParams(closeLayoutParams);
+        closeButton.setImageDrawable(
+                AppCompatResources.getDrawable(context, androidx.appcompat.R.drawable.abc_ic_clear_material)
+        );
+        closeButton.setBackgroundResource(resolveSelectableItemBackgroundBorderless());
+        closeButton.setImageTintList(ColorStateList.valueOf(Color.WHITE));
+        closeButton.setPadding(dp(12), dp(12), dp(12), dp(12));
+        closeButton.setScaleType(ImageView.ScaleType.CENTER_INSIDE);
+        closeButton.setVisibility(GONE);
+        closeButton.setOnClickListener(v -> {
+            if (listener != null) {
+                listener.onCloseRequested();
+            }
+        });
+        addView(closeButton);
+
+        playerView.setControllerVisibilityListener((PlayerControlView.VisibilityListener) visibility -> {
+            if (firstFrameReady) {
+                closeButton.setVisibility(visibility == View.VISIBLE ? View.VISIBLE : View.GONE);
+            }
+        });
+    }
+
+    public void setListener(@Nullable Listener listener) {
+        this.listener = listener;
+    }
+
+    public void setOnContentReadyListener(@Nullable Runnable contentReadyListener) {
+        this.contentReadyListener = contentReadyListener;
+    }
+
+    public void bind(@NonNull GalleryMediaItem item) {
+        this.item = item;
+        firstFrameReady = false;
+        playerView.animate().cancel();
+        playerView.setAlpha(0f);
+        playerView.setVisibility(VISIBLE);
+        closeButton.setVisibility(GONE);
+        posterImageView.animate().cancel();
+        posterImageView.setAlpha(1f);
+        posterImageView.setVisibility(VISIBLE);
+        Glide.with(posterImageView).clear(posterImageView);
+        posterImageView.setImageDrawable(null);
+        Glide.with(posterImageView)
+                .load(item.getThumbnailUrl())
+                .dontAnimate()
+                .listener(new RequestListener<Drawable>() {
+                    @Override
+                    public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
+                        notifyContentReady();
+                        return false;
+                    }
+
+                    @Override
+                    public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target, com.bumptech.glide.load.DataSource dataSource, boolean isFirstResource) {
+                        notifyContentReady();
+                        return false;
+                    }
+                })
+                .into(posterImageView);
+        if (active) {
+            ensurePlayerPrepared(item.getSourceUrl());
+        }
+    }
+
+    public void setActive(boolean active) {
+        this.active = active;
+        if (item == null) {
+            return;
+        }
+        if (active) {
+            ensurePlayerPrepared(item.getSourceUrl());
+            if (player != null) {
+                player.play();
+            }
+            if (firstFrameReady) {
+                revealPlayer();
+            }
+        } else {
+            if (player != null) {
+                player.pause();
+            }
+            closeButton.setVisibility(GONE);
+        }
+    }
+
+    public void setMediaHidden(boolean hidden) {
+        setAlpha(hidden ? 0f : 1f);
+    }
+
+    @Nullable
+    public GallerySharedElementState sharedElementState() {
+        return GalleryLayoutSupport.captureImageViewState(posterImageView);
+    }
+
+    @Nullable
+    public Drawable getPosterDrawable() {
+        return posterImageView.getDrawable();
+    }
+
+    public void prepareForReturnTransition() {
+        playerView.animate().cancel();
+        posterImageView.animate().cancel();
+        posterImageView.setAlpha(1f);
+        posterImageView.setVisibility(VISIBLE);
+        playerView.setAlpha(0f);
+        playerView.setVisibility(VISIBLE);
+        closeButton.setVisibility(GONE);
+    }
+
+    public void restoreAfterDismissCancelled() {
+        if (!firstFrameReady) {
+            prepareForReturnTransition();
+            return;
+        }
+        playerView.setVisibility(VISIBLE);
+        playerView.setAlpha(1f);
+        posterImageView.setVisibility(VISIBLE);
+        posterImageView.setAlpha(0f);
+    }
+
+    public boolean isTouchOnInteractiveControls(float rawX, float rawY) {
+        return isTouchInsideView(playerView.findViewById(androidx.media3.ui.R.id.exo_progress), rawX, rawY, dp(24))
+                || isTouchInsideView(closeButton, rawX, rawY, dp(12));
+    }
+
+    public void release() {
+        Glide.with(posterImageView.getContext().getApplicationContext()).clear(posterImageView);
+        posterImageView.setImageDrawable(null);
+        posterImageView.animate().cancel();
+        posterImageView.setAlpha(1f);
+        posterImageView.setVisibility(VISIBLE);
+        closeButton.setVisibility(GONE);
+        if (player != null) {
+            player.removeListener(playerListener);
+            player.release();
+            player = null;
+            playerView.setPlayer(null);
+        }
+        playerView.animate().cancel();
+        playerView.setAlpha(0f);
+        playerView.setVisibility(VISIBLE);
+        preparedSourceUrl = null;
+        firstFrameReady = false;
+    }
+
+    private void ensurePlayerPrepared(@NonNull String sourceUrl) {
+        if (player == null) {
+            player = new ExoPlayer.Builder(getContext()).build();
+            player.addListener(playerListener);
+            playerView.setPlayer(player);
+        }
+        if (sourceUrl.equals(preparedSourceUrl)) {
+            return;
+        }
+        firstFrameReady = false;
+        playerView.animate().cancel();
+        playerView.setAlpha(0f);
+        playerView.setVisibility(VISIBLE);
+        closeButton.setVisibility(GONE);
+        player.setMediaItem(MediaItem.fromUri(Uri.parse(sourceUrl)));
+        player.prepare();
+        preparedSourceUrl = sourceUrl;
+    }
+
+    private void revealPlayer() {
+        playerView.setVisibility(VISIBLE);
+        playerView.animate().cancel();
+        playerView.setAlpha(0f);
+        posterImageView.animate().cancel();
+        posterImageView.setVisibility(VISIBLE);
+        posterImageView.setAlpha(1f);
+        playerView.animate()
+                .alpha(1f)
+                .setDuration(180L)
+                .start();
+        posterImageView.animate()
+                .alpha(0f)
+                .setDuration(220L)
+                .withEndAction(() -> {
+                    if (playerView.isControllerFullyVisible()) {
+                        closeButton.setVisibility(VISIBLE);
+                    }
+                })
+                .start();
+    }
+
+    private void notifyContentReady() {
+        if (contentReadyListener != null) {
+            contentReadyListener.run();
+        }
+    }
+
+    private void hideControllerView(int viewId) {
+        View target = playerView.findViewById(viewId);
+        if (target != null) {
+            target.setVisibility(GONE);
+        }
+    }
+
+    private boolean isTouchInsideView(@Nullable View target, float rawX, float rawY, int extraPaddingPx) {
+        if (target == null || !target.isShown() || target.getWidth() <= 0 || target.getHeight() <= 0) {
+            return false;
+        }
+        int[] location = new int[2];
+        target.getLocationOnScreen(location);
+        Rect hitRect = new Rect(
+                location[0] - extraPaddingPx,
+                location[1] - extraPaddingPx,
+                location[0] + target.getWidth() + extraPaddingPx,
+                location[1] + target.getHeight() + extraPaddingPx
+        );
+        return hitRect.contains(Math.round(rawX), Math.round(rawY));
+    }
+
+    private int resolveSelectableItemBackgroundBorderless() {
+        TypedValue outValue = new TypedValue();
+        boolean resolved = getContext().getTheme().resolveAttribute(
+                android.R.attr.selectableItemBackgroundBorderless,
+                outValue,
+                true
+        );
+        return resolved ? outValue.resourceId : 0;
+    }
+
+    private int dp(int value) {
+        return (int) TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_DIP,
+                value,
+                getResources().getDisplayMetrics()
+        );
+    }
+}