zkit-ui 2.0.4 → 2.0.6

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

@@ -0,0 +1,43 @@
+package cn.fontree.zkit.ui.preview
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class NativeImagePreviewModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("ZKitNativeImagePreview")
+
+        View(NativeImagePreviewView::class) {
+            Events(
+                "onIndexChange"
+            )
+            Prop("theme") { view: NativeImagePreviewView, theme: Theme ->
+                view.theme = theme
+            }
+            Prop("items") { view: NativeImagePreviewView, items: Array<Map<String, Any?>> ->
+                view.items = items.toList()
+            }
+            Prop("urls") { view: NativeImagePreviewView, urls: Array<String> ->
+                view.urls = urls
+            }
+            Prop("index") { view: NativeImagePreviewView, index: Int ->
+                view.initialIndex = index
+            }
+            Prop("previewGroupId") { view: NativeImagePreviewView, previewGroupId: String? ->
+                view.previewGroupId = previewGroupId
+            }
+            Prop("disableHiddenOriginalImage") { view: NativeImagePreviewView, disableHiddenOriginalImage: Boolean ->
+                view.disableHiddenOriginalImage = disableHiddenOriginalImage
+            }
+            Prop("edgeToEdge") { view: NativeImagePreviewView, edgeToEdge: Boolean ->
+                view.edgeToEdge = edgeToEdge
+            }
+            Prop("transitionOffsetY") { view: NativeImagePreviewView, transitionOffsetY: Int? ->
+                view.transitionOffsetY = transitionOffsetY
+            }
+            Prop("transitionOffsetX") { view: NativeImagePreviewView, transitionOffsetX: Int? ->
+                view.transitionOffsetX = transitionOffsetX
+            }
+        }
+    }
+}

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

@@ -0,0 +1,140 @@
+package cn.fontree.zkit.ui.preview;
+
+import android.view.ViewGroup;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.RecyclerView;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public final class NativeImagePreviewPagerAdapter extends RecyclerView.Adapter<NativeImagePreviewPagerAdapter.PageViewHolder> {
+    public interface PageBindCallback {
+        void onPageBound(@NonNull NativeImagePreviewViewerPageView pageView, int position);
+    }
+
+    private final List<NativeImagePreviewMediaItem> items = new ArrayList<>();
+    private final Map<Integer, NativeImagePreviewViewerPageView> attachedViews = new HashMap<>();
+    @Nullable
+    private final NativeImagePreviewViewerPageView.Listener pageListener;
+    @Nullable
+    private final PageBindCallback pageBindCallback;
+    private int activeIndex = -1;
+
+    public NativeImagePreviewPagerAdapter(
+            @Nullable NativeImagePreviewViewerPageView.Listener pageListener,
+            @Nullable PageBindCallback pageBindCallback
+    ) {
+        this.pageListener = pageListener;
+        this.pageBindCallback = pageBindCallback;
+    }
+
+    public void setItems(@NonNull List<NativeImagePreviewMediaItem> list) {
+        attachedViews.clear();
+        items.clear();
+        items.addAll(list);
+        notifyDataSetChanged();
+    }
+
+    public void setActiveIndex(int index) {
+        activeIndex = index;
+        for (Map.Entry<Integer, NativeImagePreviewViewerPageView> entry : attachedViews.entrySet()) {
+            entry.getValue().setActive(entry.getKey() == index);
+        }
+    }
+
+    public void releaseAll() {
+        for (NativeImagePreviewViewerPageView view : attachedViews.values()) {
+            view.release();
+        }
+        attachedViews.clear();
+    }
+
+    @Nullable
+    public NativeImagePreviewViewerPageView findAttachedView(int position) {
+        NativeImagePreviewViewerPageView pageView = attachedViews.get(position);
+        if (pageView == null) {
+            return null;
+        }
+        if (!pageView.isAttachedToWindow()) {
+            attachedViews.remove(position);
+            return null;
+        }
+        return pageView;
+    }
+
+    @Nullable
+    public NativeImagePreviewViewerPageView findActiveView() {
+        return attachedViews.get(activeIndex);
+    }
+
+    @NonNull
+    @Override
+    public PageViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+        NativeImagePreviewViewerPageView pageView = new NativeImagePreviewViewerPageView(parent.getContext());
+        pageView.setListener(pageListener);
+        return new PageViewHolder(pageView);
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull PageViewHolder holder, int position) {
+        holder.pageView.bind(items.get(position));
+        if (pageBindCallback != null) {
+            pageBindCallback.onPageBound(holder.pageView, position);
+        }
+        holder.pageView.setActive(position == activeIndex);
+    }
+
+    @Override
+    public void onViewAttachedToWindow(@NonNull PageViewHolder holder) {
+        super.onViewAttachedToWindow(holder);
+        removeAttachedViewKeys(holder.pageView);
+        int position = holder.getBindingAdapterPosition();
+        if (position == RecyclerView.NO_POSITION) {
+            return;
+        }
+        attachedViews.put(position, holder.pageView);
+    }
+
+    @Override
+    public void onViewDetachedFromWindow(@NonNull PageViewHolder holder) {
+        super.onViewDetachedFromWindow(holder);
+        removeAttachedViewKeys(holder.pageView);
+    }
+
+    @Override
+    public void onViewRecycled(@NonNull PageViewHolder holder) {
+        super.onViewRecycled(holder);
+        removeAttachedViewKeys(holder.pageView);
+        holder.pageView.release();
+    }
+
+    private void removeAttachedViewKeys(@NonNull NativeImagePreviewViewerPageView pageView) {
+        List<Integer> keys = new ArrayList<>();
+        for (Map.Entry<Integer, NativeImagePreviewViewerPageView> entry : attachedViews.entrySet()) {
+            if (entry.getValue() == pageView) {
+                keys.add(entry.getKey());
+            }
+        }
+        for (Integer key : keys) {
+            attachedViews.remove(key);
+        }
+    }
+
+    @Override
+    public int getItemCount() {
+        return items.size();
+    }
+
+    static final class PageViewHolder extends RecyclerView.ViewHolder {
+        final NativeImagePreviewViewerPageView pageView;
+
+        PageViewHolder(@NonNull NativeImagePreviewViewerPageView itemView) {
+            super(itemView);
+            this.pageView = itemView;
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+package cn.fontree.zkit.ui.preview;
+
+import android.graphics.RectF;
+
+import androidx.annotation.NonNull;
+
+public final class NativeImagePreviewSharedElementGeometry {
+    private final RectF visibleFrameInWindow;
+    private final RectF contentFrameInVisibleBounds;
+
+    public NativeImagePreviewSharedElementGeometry(@NonNull RectF visibleFrameInWindow, @NonNull RectF contentFrameInVisibleBounds) {
+        this.visibleFrameInWindow = new RectF(visibleFrameInWindow);
+        this.contentFrameInVisibleBounds = new RectF(contentFrameInVisibleBounds);
+    }
+
+    @NonNull
+    public RectF getVisibleFrameInWindow() {
+        return new RectF(visibleFrameInWindow);
+    }
+
+    @NonNull
+    public RectF getContentFrameInVisibleBounds() {
+        return new RectF(contentFrameInVisibleBounds);
+    }
+}

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

@@ -0,0 +1,39 @@
+package cn.fontree.zkit.ui.preview;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public final class NativeImagePreviewSharedElementNames {
+    private static final String PREFIX = "zkit-native-image-preview:media:";
+
+    private NativeImagePreviewSharedElementNames() {
+    }
+
+    @NonNull
+    public static String forItem(@NonNull NativeImagePreviewMediaItem item) {
+        return forItem(null, item);
+    }
+
+    @NonNull
+    public static String forItem(@Nullable String previewGroupId, @NonNull NativeImagePreviewMediaItem item) {
+        return forId(previewGroupId, item.getId());
+    }
+
+    @NonNull
+    public static String forIndex(int index) {
+        return forIndex(null, index);
+    }
+
+    @NonNull
+    public static String forIndex(@Nullable String previewGroupId, int index) {
+        return forId(previewGroupId, String.valueOf(index));
+    }
+
+    @NonNull
+    private static String forId(@Nullable String previewGroupId, @NonNull String id) {
+        if (previewGroupId == null || previewGroupId.isEmpty()) {
+            return PREFIX + id;
+        }
+        return PREFIX + previewGroupId + ":" + id;
+    }
+}

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

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

package/android/src/main/java/cn/fontree/zkit/ui/preview/NativeImagePreviewSourceViewRegistry.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 NativeImagePreviewSourceViewRegistry {
+    private static final Map<String, WeakReference<ImageView>> SOURCE_VIEWS = new HashMap<>();
+
+    private NativeImagePreviewSourceViewRegistry() {
+    }
+
+    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/NativeImagePreviewTransitionSnapshotView.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 NativeImagePreviewTransitionSnapshotView extends FrameLayout {
+    private final ImageView imageView;
+
+    public NativeImagePreviewTransitionSnapshotView(@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 NativeImagePreviewSharedElementGeometry 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);
+    }
+}