@nstudio/ui-collectionview 4.0.70

package/index.android.js

@@ -0,0 +1,1097 @@
+/* eslint-disable no-redeclare */
+import { ChangeType, ContentView, Property, ProxyViewContainer, Trace, Utils, View, booleanConverter, paddingBottomProperty, paddingLeftProperty, paddingRightProperty, paddingTopProperty, profile } from '@nativescript/core';
+import { reorderLongPressEnabledProperty, reorderingEnabledProperty, reverseLayoutProperty, scrollBarIndicatorVisibleProperty } from './common';
+import { CLog, CLogTypes, CollectionViewBase, ListViewViewTypes, isScrollEnabledProperty, orientationProperty } from './common';
+export * from './common';
+let CollectionViewCellHolder;
+let CollectionViewRecyclerView;
+var SimpleCallback = /** @class */ (function (_super) {
+    __extends(SimpleCallback, _super);
+    function SimpleCallback(param1, param2) {
+        var _this = _super.call(this, param1, param2) || this;
+        _this.startPosition = -1;
+        _this.endPosition = -1;
+        return global.__native(_this);
+    }
+    SimpleCallback.prototype.onMove = function (recyclerview, viewHolder, target) {
+        var startPosition = viewHolder.getAdapterPosition();
+        var endPosition = target.getAdapterPosition();
+        if (this.startPosition === -1) {
+            this.startPosition = startPosition;
+        }
+        this.endPosition = endPosition;
+        var owner = this.owner && this.owner.get();
+        if (owner) {
+            owner._reorderItemInSource(startPosition, endPosition);
+            return true;
+        }
+        return false;
+    };
+    SimpleCallback.prototype.onSelectedChanged = function (viewHolder, state) {
+        if (viewHolder) {
+            if (this.startPosition === -1) {
+                this.startPosition = viewHolder.getAdapterPosition();
+            }
+        }
+        if (!viewHolder) {
+            // this is where we identify the end of the drag and call the end event
+            var owner = this.owner && this.owner.get();
+            if (this.endPosition === -1) {
+                this.endPosition = this.startPosition;
+            }
+            if (owner) {
+                var item = owner.getItemAtIndex(this.startPosition);
+                owner._callItemReorderedEvent(this.startPosition, this.endPosition, item);
+            }
+            this.startPosition = -1;
+            this.endPosition = -1;
+            owner.isDragging = false;
+        }
+    };
+    SimpleCallback.prototype.onSwiped = function (viewHolder, direction) { };
+    SimpleCallback.prototype.isItemViewSwipeEnabled = function () {
+        // disabled for now
+        return false;
+    };
+    SimpleCallback.prototype.isLongPressDragEnabled = function () {
+        // we use our custom longpress gesture handler
+        return false;
+    };
+    return SimpleCallback;
+}(androidx.recyclerview.widget.ItemTouchHelper.SimpleCallback));
+var LongPressGestureListenerImpl = /** @class */ (function (_super) {
+    __extends(LongPressGestureListenerImpl, _super);
+    function LongPressGestureListenerImpl(_owner) {
+        var _this = _super.call(this) || this;
+        _this._owner = _owner;
+        return global.__native(_this);
+    }
+    LongPressGestureListenerImpl.prototype.onLongPress = function (motionEvent) {
+        var owner = this._owner && this._owner.get();
+        if (owner) {
+            owner.onReorderLongPress(motionEvent);
+        }
+    };
+    return LongPressGestureListenerImpl;
+}(android.view.GestureDetector.SimpleOnGestureListener));
+let LayoutParams;
+const extraLayoutSpaceProperty = new Property({
+    name: 'extraLayoutSpace'
+});
+const itemViewCacheSizeProperty = new Property({
+    name: 'itemViewCacheSize'
+});
+const nestedScrollingEnabledProperty = new Property({
+    name: 'nestedScrollingEnabled',
+    defaultValue: true,
+    valueConverter: booleanConverter
+});
+export class CollectionView extends CollectionViewBase {
+    constructor() {
+        super(...arguments);
+        this.templateTypeNumberString = new Map();
+        this.templateStringTypeNumber = new Map();
+        this._currentNativeItemType = 0;
+        this.currentSpanCount = 1;
+        // used to store viewHolder and thus their corresponding Views
+        // used to "destroy" cells when possible
+        this._viewHolders = new Set();
+        this._scrollOrLoadMoreChangeCount = 0;
+        this.scrolling = false;
+        this.needsScrollStartEvent = false;
+        this.animateItemUpdate = false;
+        this.defaultPoolSize = 10;
+        this.desiredPoolSize = new Map();
+        this.isDragging = false;
+        this._layedOut = false;
+    }
+    createNativeView() {
+        // storing the class in a property for reuse in the future cause a materializing which is pretty slow!
+        if (!CollectionViewRecyclerView) {
+            CollectionViewRecyclerView = com.nativescript.collectionview.RecyclerView;
+        }
+        const recyclerView = CollectionViewRecyclerView.createRecyclerView(this._context);
+        // const expMgr = new RecyclerViewExpandableItemManager(null);
+        // adapter.setDisplayHeadersAtStartUp(true).setStickyHeaders(true); //Make headers sticky
+        // Endless scroll with 1 item threshold
+        // .setLoadingMoreAtStartUp(true)
+        // .setEndlessScrollListener(this, new ProgressItem())
+        // .setEndlessScrollThreshold(1); //Default=1
+        // const fastScroller = new com.l4digital.fastscroll.FastScroller(this._context);
+        // fastScroller.setSectionIndexer(adapter);
+        // fastScroller.attachRecyclerView(recyclerView);
+        return recyclerView;
+    }
+    initNativeView() {
+        this.setOnLayoutChangeListener();
+        super.initNativeView();
+        this.recycledViewPool = new com.nativescript.collectionview.RecycledViewPool();
+        this.recycledViewPoolDisposeListener = new com.nativescript.collectionview.RecycledViewPool.ViewPoolListener({
+            onViewHolderDisposed: (holder) => {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.log, 'onViewHolderDisposed', holder);
+                }
+                if (this._viewHolders) {
+                    this._viewHolders.delete(holder);
+                }
+                const isNonSync = holder['defaultItemView'] === true;
+                const view = isNonSync ? holder.view.content : holder.view;
+                const args = {
+                    eventName: CollectionViewBase.itemDisposingEvent,
+                    index: holder.getAdapterPosition(),
+                    object: this,
+                    view,
+                    android: holder
+                };
+                this.notify(args);
+                if (view && view.isLoaded) {
+                    view.callUnloaded();
+                }
+                view._isAddedToNativeVisualTree = false;
+                //@ts-ignore
+                view.parent = null;
+                view._tearDownUI();
+            }
+        });
+        this.recycledViewPool.mListener = this.recycledViewPoolDisposeListener;
+        const recyclerListener = (this.recyclerListener = new androidx.recyclerview.widget.RecyclerView.RecyclerListener({
+            onViewRecycled: (holder) => {
+                if (Trace.isEnabled()) {
+                    CLog(CLogTypes.log, 'onViewRecycled', holder);
+                }
+                const isNonSync = holder['defaultItemView'] === true;
+                const view = isNonSync ? holder.view.content : holder.view;
+                const args = {
+                    eventName: CollectionViewBase.itemRecyclingEvent,
+                    index: holder.getAdapterPosition(),
+                    object: this,
+                    view,
+                    android: holder
+                };
+                this.notify(args);
+            }
+        }));
+        this.android.setRecyclerListener(recyclerListener);
+        this.android.setRecycledViewPool(this.recycledViewPool);
+        // nativeView.owner = new WeakRef(this);
+        // nativeView.sizeChangedListener = new com.nativescript.collectionview.SizeChangedListener({
+        //     onSizeChanged: (w, h, oldW, oldH) => this.onSizeChanged(w, h),
+        // });
+        // const orientation = this._getLayoutManagarOrientation();
+        // initGridLayoutManager();
+        if (CollectionViewBase.layoutStyles[this.layoutStyle]) {
+            this.android.layoutManager = CollectionViewBase.layoutStyles[this.layoutStyle].createLayout(this);
+        }
+        else {
+            this.android.layoutManager = new com.nativescript.collectionview.PreCachingGridLayoutManager(this._context, 1);
+            // layoutManager = new PreCachingGridLayoutManager(this._context, 1);
+            // (layoutManager as any).owner = new WeakRef(this);
+        }
+        // this.spanSize
+        this.android.setLayoutManager(this.android.layoutManager);
+        this.android.sizeChangedListener = new com.nativescript.collectionview.SizeChangedListener({
+            onSizeChanged() { },
+            onMeasure: () => this.updateInnerSize()
+        });
+        this.spanSize = this._getSpanSize;
+        // const animator = new com.h6ah4i.android.widget.advrecyclerview.animator.RefactoredDefaultItemAnimator();
+        // // Change animations are enabled by default since support-v7-recyclerview v22.
+        // // Need to disable them when using animation indicator.
+        // animator.setSupportsChangeAnimations(false);
+        // this.android.setItemAnimator(animator);
+        this.refresh();
+    }
+    disposeNativeView() {
+        // clear the cache
+        // this.eachChildView((view) => {
+        //     view.parent._removeView(view);
+        //     return true;
+        // });
+        // this._realizedItems.clear();
+        this.android.setRecyclerListener(null);
+        this.android.setRecycledViewPool(null);
+        this.recycledViewPoolDisposeListener = null;
+        this.recycledViewPool = null;
+        if (this.android.scrollListener) {
+            this.android.removeOnScrollListener(this.android.scrollListener);
+            this.android.scrollListener = null;
+            this._nScrollListener = null;
+        }
+        this.android.sizeChangedListener = null;
+        this.android.layoutManager = null;
+        this._listViewAdapter = null;
+        this._itemTouchHelper = null;
+        this._simpleItemTouchCallback = null;
+        this.disposeViewHolderViews();
+        this._hlayoutParams = null;
+        this._vlayoutParams = null;
+        this.clearTemplateTypes();
+        super.disposeNativeView();
+    }
+    onLoaded() {
+        super.onLoaded();
+        this.attachScrollListener();
+        this.refresh();
+    }
+    getViewForItemAtIndex(index) {
+        return this.enumerateViewHolders((v) => (v.getAdapterPosition() === index ? v.view : undefined));
+    }
+    //@ts-ignore
+    set spanSize(inter) {
+        if (!(typeof inter === 'function')) {
+            return;
+        }
+        this._getSpanSize = inter;
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager['setSpanSizeLookup']) {
+            if (inter) {
+                layoutManager['setSpanSizeLookup'](new com.nativescript.collectionview.SpanSizeLookup(new com.nativescript.collectionview.SpanSizeLookup.Interface({
+                    getSpanSize: (position) => {
+                        const dataItem = this.getItemAtIndex(position);
+                        return Math.min(inter(dataItem, position), this.currentSpanCount);
+                    }
+                })));
+            }
+            else {
+                layoutManager['setSpanSizeLookup'](null);
+            }
+        }
+    }
+    get spanSize() {
+        return this._getSpanSize;
+    }
+    attachScrollListener() {
+        if (this._scrollOrLoadMoreChangeCount > 0 && this.isLoaded) {
+            if (!this.android) {
+                return;
+            }
+            if (!this.android.scrollListener) {
+                this._nScrollListener = new com.nativescript.collectionview.OnScrollListener.Listener({
+                    onScrollStateChanged: this.onScrollStateChanged.bind(this),
+                    onScrolled: this.onScrolled.bind(this)
+                });
+                this.android.scrollListener = new com.nativescript.collectionview.OnScrollListener(this._nScrollListener);
+                this.android.addOnScrollListener(this.android.scrollListener);
+            }
+        }
+    }
+    detachScrollListener() {
+        if (this._scrollOrLoadMoreChangeCount === 0 && this.isLoaded) {
+            if (!this.android) {
+                return;
+            }
+            if (this.android.scrollListener) {
+                this.android.removeOnScrollListener(this.android.scrollListener);
+                this.android.scrollListener = null;
+                this._nScrollListener = null;
+            }
+        }
+    }
+    computeScrollEventData(view, eventName, dx, dy) {
+        const horizontal = this.isHorizontal();
+        const offset = horizontal ? view.computeHorizontalScrollOffset() : view.computeVerticalScrollOffset();
+        const range = horizontal ? view.computeHorizontalScrollRange() : view.computeVerticalScrollRange();
+        const extent = horizontal ? view.computeHorizontalScrollExtent() : view.computeVerticalScrollExtent();
+        return {
+            object: this,
+            eventName,
+            scrollOffset: offset / Utils.layout.getDisplayDensity(),
+            scrollOffsetPercentage: offset / (range - extent),
+            dx,
+            dy
+        };
+    }
+    onScrolled(view, dx, dy) {
+        if (!this || !this.scrolling) {
+            return;
+        }
+        if (this.needsScrollStartEvent) {
+            this.needsScrollStartEvent = false;
+            if (this.hasListeners(CollectionViewBase.scrollStartEvent)) {
+                this.notify(this.computeScrollEventData(view, CollectionViewBase.scrollStartEvent, dx, dy));
+            }
+        }
+        if (this.hasListeners(CollectionViewBase.scrollEvent)) {
+            this.notify(this.computeScrollEventData(view, CollectionViewBase.scrollEvent, dx, dy));
+        }
+        if (this.hasListeners(CollectionViewBase.loadMoreItemsEvent) && this.items) {
+            const layoutManager = view.getLayoutManager();
+            if (layoutManager['findLastCompletelyVisibleItemPosition']) {
+                const lastVisibleItemPos = layoutManager['findLastCompletelyVisibleItemPosition']();
+                const loadMoreItemIndex = this.items.length - this.loadMoreThreshold;
+                if (lastVisibleItemPos === loadMoreItemIndex) {
+                    this.notify({
+                        eventName: CollectionViewBase.loadMoreItemsEvent,
+                        object: this
+                    });
+                }
+            }
+            else if (layoutManager['findLastCompletelyVisibleItemPositions'] && layoutManager['getSpanCount']) {
+                let positions = Array.create('int', layoutManager['getSpanCount']());
+                positions = layoutManager['findLastCompletelyVisibleItemPositions'](positions);
+                let lastVisibleItemPos = 0;
+                for (let i = 0; i < positions.length; i++) {
+                    if (positions[i] > lastVisibleItemPos) {
+                        lastVisibleItemPos = positions[i];
+                    }
+                }
+                const loadMoreItemIndex = this.items.length - this.loadMoreThreshold;
+                if (lastVisibleItemPos >= loadMoreItemIndex) {
+                    this.notify({
+                        eventName: CollectionViewBase.loadMoreItemsEvent,
+                        object: this
+                    });
+                }
+            }
+        }
+    }
+    onScrollStateChanged(view, newState) {
+        if (this.scrolling && newState === 0) {
+            // SCROLL_STATE_IDLE
+            this.scrolling = false;
+            if (this.hasListeners(CollectionViewBase.scrollEndEvent)) {
+                this.notify(this.computeScrollEventData(view, CollectionViewBase.scrollEndEvent));
+            }
+        }
+        else if (!this.scrolling && newState === 1) {
+            //SCROLL_STATE_DRAGGING
+            this.needsScrollStartEvent = true;
+            this.scrolling = true;
+        }
+    }
+    addEventListener(arg, callback, thisArg) {
+        super.addEventListener(arg, callback, thisArg);
+        if (arg === CollectionViewBase.scrollEvent || arg === CollectionViewBase.scrollStartEvent || arg === CollectionViewBase.scrollEndEvent || arg === CollectionViewBase.loadMoreItemsEvent) {
+            this._scrollOrLoadMoreChangeCount++;
+            this.attachScrollListener();
+        }
+    }
+    removeEventListener(arg, callback, thisArg) {
+        super.removeEventListener(arg, callback, thisArg);
+        if (arg === CollectionViewBase.scrollEvent || arg === CollectionViewBase.scrollStartEvent || arg === CollectionViewBase.scrollEndEvent || arg === CollectionViewBase.loadMoreItemsEvent) {
+            this._scrollOrLoadMoreChangeCount--;
+            this.detachScrollListener();
+        }
+    }
+    //@ts-ignore
+    get android() {
+        return this.nativeViewProtected;
+    }
+    get layoutManager() {
+        return this.android && this.android.layoutManager;
+    }
+    _getViewLayoutParams() {
+        if (this.isHorizontal()) {
+            if (!this._hlayoutParams) {
+                LayoutParams = LayoutParams || android.view.ViewGroup.LayoutParams;
+                this._hlayoutParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.MATCH_PARENT);
+            }
+            return this._hlayoutParams;
+        }
+        else {
+            if (!this._vlayoutParams) {
+                LayoutParams = LayoutParams || android.view.ViewGroup.LayoutParams;
+                this._vlayoutParams = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+            }
+            return this._vlayoutParams;
+        }
+    }
+    setNativePoolSize(key, nativeIndex) {
+        if (this.desiredPoolSize.has(key)) {
+            this.android.getRecycledViewPool().setMaxRecycledViews(nativeIndex, this.desiredPoolSize.get(key));
+        }
+        else {
+            if (this.defaultPoolSize >= 0) {
+                this.android.getRecycledViewPool().setMaxRecycledViews(nativeIndex, this.defaultPoolSize);
+            }
+        }
+    }
+    setPoolSizes() {
+        if (!this.android || !this.templateTypeNumberString) {
+            return;
+        }
+        this.desiredPoolSize.forEach((v, k) => {
+            if (this.templateTypeNumberString.has(k)) {
+                this.android.getRecycledViewPool().setMaxRecycledViews(this.templateTypeNumberString.get(k), v);
+            }
+        });
+    }
+    setPoolSize(key, size) {
+        this.desiredPoolSize.set(key, size);
+        this.setPoolSizes();
+    }
+    [paddingTopProperty.getDefault]() {
+        return { value: this._defaultPaddingTop, unit: 'px' };
+    }
+    [paddingTopProperty.setNative](value) {
+        this._setPadding({ top: this.effectivePaddingTop });
+    }
+    [paddingRightProperty.getDefault]() {
+        return { value: this._defaultPaddingRight, unit: 'px' };
+    }
+    [paddingRightProperty.setNative](value) {
+        this._setPadding({ right: this.effectivePaddingRight });
+    }
+    [paddingBottomProperty.getDefault]() {
+        return { value: this._defaultPaddingBottom, unit: 'px' };
+    }
+    [paddingBottomProperty.setNative](value) {
+        this._setPadding({ bottom: this.effectivePaddingBottom });
+    }
+    [paddingLeftProperty.getDefault]() {
+        return { value: this._defaultPaddingLeft, unit: 'px' };
+    }
+    [paddingLeftProperty.setNative](value) {
+        this._setPadding({ left: this.effectivePaddingLeft });
+    }
+    [orientationProperty.getDefault]() {
+        return 'vertical';
+    }
+    [orientationProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (!layoutManager || !layoutManager['setOrientation']) {
+            return;
+        }
+        if (this.isHorizontal()) {
+            layoutManager['setOrientation'](0);
+        }
+        else {
+            layoutManager['setOrientation'](1);
+        }
+        this.updateScrollBarVisibility(this.scrollBarIndicatorVisible);
+    }
+    [isScrollEnabledProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager.setScrollEnabled) {
+            layoutManager.setScrollEnabled(value);
+        }
+    }
+    [reverseLayoutProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager.setReverseLayout) {
+            layoutManager.setReverseLayout(value);
+            // layoutManager['setStackFromEnd'](value);
+        }
+    }
+    [nestedScrollingEnabledProperty.setNative](value) {
+        if (this.android) {
+            this.android.setNestedScrollingEnabled(value);
+        }
+    }
+    [extraLayoutSpaceProperty.setNative](value) {
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager['setExtraLayoutSpace']) {
+            layoutManager['setExtraLayoutSpace'](value);
+        }
+    }
+    [itemViewCacheSizeProperty.setNative](value) {
+        if (this.android) {
+            this.android.setItemViewCacheSize(value);
+        }
+    }
+    [scrollBarIndicatorVisibleProperty.getDefault]() {
+        return true;
+    }
+    [scrollBarIndicatorVisibleProperty.setNative](value) {
+        this.updateScrollBarVisibility(value);
+    }
+    updateScrollBarVisibility(value) {
+        if (!this.android) {
+            return;
+        }
+        if (this.orientation === 'horizontal') {
+            this.android.setHorizontalScrollBarEnabled(value);
+        }
+        else {
+            this.android.setVerticalScrollBarEnabled(value);
+        }
+    }
+    enumerateViewHolders(cb) {
+        let result, v;
+        for (let it = this._viewHolders.values(), cellItemView = null; (cellItemView = it.next().value);) {
+            result = cb(cellItemView);
+            if (result) {
+                return result;
+            }
+        }
+        return result;
+    }
+    startDragging(index) {
+        if (this.reorderEnabled && this._itemTouchHelper) {
+            // let viewHolder: CollectionViewCellHolder;
+            const viewHolder = this.enumerateViewHolders((v) => (v.getAdapterPosition() === index ? v : undefined));
+            if (viewHolder) {
+                this.startViewHolderDragging(index, viewHolder);
+            }
+        }
+    }
+    startViewHolderDragging(index, viewHolder) {
+        // isDragging is to prevent longPress from triggering and starting a new drag
+        // when triggered manually
+        if (!this.isDragging && this.shouldMoveItemAtIndex(index)) {
+            this.isDragging = true;
+            this._itemTouchHelper.startDrag(viewHolder);
+        }
+    }
+    onReorderLongPress(motionEvent) {
+        if (!this.android) {
+            return;
+        }
+        const view = this.android.findChildViewUnder(motionEvent.getX(), motionEvent.getY());
+        const viewHolder = view != null ? this.android.getChildViewHolder(view) : null;
+        if (viewHolder) {
+            this.startViewHolderDragging(viewHolder.getAdapterPosition(), viewHolder);
+        }
+    }
+    _reorderItemInSource(oldPosition, newPosition) {
+        const adapter = this._listViewAdapter;
+        // 3. Tell adapter to render the model update.
+        adapter.notifyItemMoved(oldPosition, newPosition);
+        // on android _reorderItemInSource is call on every "move" and needs to update the adapter/items
+        // we will call events only at then end
+        super._reorderItemInSource(oldPosition, newPosition, false);
+    }
+    [reorderLongPressEnabledProperty.setNative](value) {
+        if (!this.android) {
+            return;
+        }
+        if (value) {
+            if (!this._longPressGesture) {
+                this._longPressGesture = new androidx.core.view.GestureDetectorCompat(this._context, new LongPressGestureListenerImpl(new WeakRef(this)));
+                this._itemTouchListerner = new androidx.recyclerview.widget.RecyclerView.OnItemTouchListener({
+                    onInterceptTouchEvent: (view, event) => {
+                        if (this.reorderEnabled && this._longPressGesture) {
+                            this._longPressGesture.onTouchEvent(event);
+                        }
+                        return false;
+                    },
+                    onTouchEvent: (param0, param1) => { },
+                    onRequestDisallowInterceptTouchEvent: (disallowIntercept) => { }
+                });
+            }
+            this.android.addOnItemTouchListener(this._itemTouchListerner);
+        }
+        else {
+            if (this._itemTouchListerner) {
+                this.android.removeOnItemTouchListener(this._itemTouchListerner);
+            }
+        }
+    }
+    [reorderingEnabledProperty.setNative](value) {
+        if (!this.android) {
+            return;
+        }
+        if (value) {
+            if (!this._simpleItemTouchCallback) {
+                const ItemTouchHelper = androidx.recyclerview.widget.ItemTouchHelper;
+                this._simpleItemTouchCallback = new SimpleCallback(ItemTouchHelper.UP | ItemTouchHelper.DOWN | ItemTouchHelper.START | ItemTouchHelper.END, 0);
+                this._simpleItemTouchCallback.owner = new WeakRef(this);
+                this._itemTouchHelper = new androidx.recyclerview.widget.ItemTouchHelper(this._simpleItemTouchCallback);
+                this._itemTouchHelper.attachToRecyclerView(this.android);
+            }
+        }
+    }
+    onItemViewLoaderChanged() {
+        if (this.itemViewLoader) {
+            this.refresh();
+        }
+    }
+    onItemTemplateSelectorChanged(oldValue, newValue) {
+        super.onItemTemplateSelectorChanged(oldValue, newValue);
+        this.clearTemplateTypes();
+        this.refresh();
+    }
+    onItemTemplateChanged(oldValue, newValue) {
+        super.onItemTemplateChanged(oldValue, newValue); // TODO: update current template with the new one
+        this.refresh();
+    }
+    onItemTemplatesChanged(oldValue, newValue) {
+        super.onItemTemplatesChanged(oldValue, newValue); // TODO: update current template with the new one
+        this.refresh();
+    }
+    setOnLayoutChangeListener() {
+        if (this.android) {
+            const owner = this;
+            this.layoutChangeListenerIsSet = true;
+            this.layoutChangeListener =
+                this.layoutChangeListener ||
+                    new android.view.View.OnLayoutChangeListener({
+                        onLayoutChange(v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom) {
+                            if (left !== oldLeft || top !== oldTop || right !== oldRight || bottom !== oldBottom) {
+                                owner.onLayout(left, top, right, bottom);
+                                if (owner.hasListeners(View.layoutChangedEvent)) {
+                                    owner._raiseLayoutChangedEvent();
+                                }
+                            }
+                        }
+                    });
+            this.android.addOnLayoutChangeListener(this.layoutChangeListener);
+        }
+    }
+    _updateSpanCount() {
+        const layoutManager = this.layoutManager;
+        if (layoutManager && layoutManager['setSpanCount']) {
+            const newValue = (this.currentSpanCount = this.computeSpanCount());
+            if (newValue !== layoutManager['getSpanCount']()) {
+                layoutManager['setSpanCount'](newValue);
+                layoutManager.requestLayout();
+            }
+        }
+    }
+    updateInnerSize() {
+        super.updateInnerSize();
+        this._updateSpanCount();
+    }
+    _onColWidthPropertyChanged(oldValue, newValue) {
+        this._updateSpanCount();
+        super._onColWidthPropertyChanged(oldValue, newValue);
+    }
+    _onRowHeightPropertyChanged(oldValue, newValue) {
+        this._updateSpanCount();
+        super._onRowHeightPropertyChanged(oldValue, newValue);
+    }
+    onLayout(left, top, right, bottom) {
+        this._layedOut = true;
+        super.onLayout(left, top, right, bottom);
+        const p = CollectionViewBase.plugins[this.layoutStyle];
+        if (p && p.onLayout) {
+            p.onLayout(this, left, top, right, bottom);
+        }
+        this.plugins.forEach((k) => {
+            const p = CollectionViewBase.plugins[k];
+            p.onLayout && p.onLayout(this, left, top, right, bottom);
+        });
+        // there is no need to call refresh if it was triggered before with same size.
+        // this refresh is just to handle size change
+        const layoutKey = this._innerWidth + '_' + this._innerHeight;
+        if (this._isDataDirty || (this._lastLayoutKey && this._lastLayoutKey !== layoutKey)) {
+            setTimeout(() => this.refresh(), 0);
+        }
+        this._lastLayoutKey = layoutKey;
+    }
+    onSourceCollectionChanged(event) {
+        if (!this._listViewAdapter || this._dataUpdatesSuspended) {
+            return;
+        }
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onItemsChanged', event.action, event.index, event.addedCount, event.removed, event.removed && event.removed.length);
+        }
+        switch (event.action) {
+            case ChangeType.Delete: {
+                this._listViewAdapter.notifyItemRangeRemoved(event.index, event.removed.length);
+                return;
+            }
+            case ChangeType.Add: {
+                if (event.addedCount > 0) {
+                    this._listViewAdapter.notifyItemRangeInserted(event.index, event.addedCount);
+                }
+                // Reload the items to avoid duplicate Load on Demand indicators:
+                return;
+            }
+            case ChangeType.Update: {
+                if (event.addedCount > 0) {
+                    this._listViewAdapter.notifyItemRangeChanged(event.index, event.addedCount);
+                }
+                return;
+            }
+            case ChangeType.Splice: {
+                const added = event.addedCount;
+                const removed = (event.removed && event.removed.length) || 0;
+                if (added > 0 && added === removed) {
+                    // notifyItemRangeChanged wont create a fade effect
+                    if (!this.animateItemUpdate) {
+                        this._listViewAdapter.notifyItemRangeChanged(event.index, added);
+                    }
+                    else {
+                        this._listViewAdapter.notifyItemRangeRemoved(event.index, added);
+                        this._listViewAdapter.notifyItemRangeInserted(event.index, added);
+                    }
+                }
+                else {
+                    if (!this.animateItemUpdate) {
+                        if (added > removed) {
+                            if (removed > 0) {
+                                this._listViewAdapter.notifyItemRangeChanged(event.index, removed);
+                            }
+                            this._listViewAdapter.notifyItemRangeInserted(event.index + removed, added - removed);
+                        }
+                        else {
+                            if (added > 0) {
+                                this._listViewAdapter.notifyItemRangeChanged(event.index, added);
+                            }
+                            this._listViewAdapter.notifyItemRangeRemoved(event.index + added, removed - added);
+                        }
+                    }
+                    else {
+                        if (event.removed && event.removed.length > 0) {
+                            this._listViewAdapter.notifyItemRangeRemoved(event.index, event.removed.length);
+                        }
+                        if (event.addedCount > 0) {
+                            this._listViewAdapter.notifyItemRangeInserted(event.index, event.addedCount);
+                        }
+                    }
+                }
+                return;
+            }
+        }
+        this._listViewAdapter.notifyDataSetChanged();
+    }
+    eachChild(callback) {
+        // used for css updates (like theme change)
+        this.enumerateViewHolders((v) => {
+            const view = v.view;
+            if (view) {
+                if (view.parent instanceof CollectionView) {
+                    callback(view);
+                }
+                else {
+                    // in some cases (like item is unloaded from another place (like angular) view.parent becomes undefined)
+                    if (view.parent) {
+                        callback(view.parent);
+                    }
+                }
+            }
+        });
+    }
+    refreshVisibleItems() {
+        if (!this.android) {
+            return;
+        }
+        const ids = Array.from(this._viewHolders)
+            .map((s) => s['position'])
+            .filter((s) => s !== null)
+            .sort((a, b) => a - b);
+        this._listViewAdapter.notifyItemRangeChanged(ids[0], ids[ids.length - 1] - ids[0] + 1);
+    }
+    isItemAtIndexVisible(index) {
+        if (!this.android) {
+            return false;
+        }
+        const layoutManager = this.layoutManager;
+        if (layoutManager['findFirstVisibleItemPosition']) {
+            const first = layoutManager.findFirstVisibleItemPosition();
+            const last = layoutManager.findLastVisibleItemPosition();
+            return index >= first && index <= last;
+        }
+        return false;
+    }
+    refresh() {
+        if (!this.android) {
+            return;
+        }
+        if (!this.isLoaded) {
+            this._isDataDirty = true;
+            return;
+        }
+        this._isDataDirty = false;
+        this._lastLayoutKey = this._innerWidth + '_' + this._innerHeight;
+        let adapter = this._listViewAdapter;
+        if (!adapter) {
+            adapter = this._listViewAdapter = this.createComposedAdapter();
+            adapter.setHasStableIds(!!this._itemIdGenerator);
+            this.android.setAdapter(adapter);
+        }
+        else if (!this.android.getAdapter()) {
+            this.android.setAdapter(adapter);
+        }
+        this._updateSpanCount();
+        adapter.notifyDataSetChanged();
+        const args = {
+            eventName: CollectionViewBase.dataPopulatedEvent,
+            object: this
+        };
+        this.notify(args);
+    }
+    //@ts-ignore
+    get scrollOffset() {
+        if (!this.android) {
+            return 0;
+        }
+        return (this.isHorizontal() ? this.android.computeHorizontalScrollOffset() : this.android.computeVerticalScrollOffset()) / Utils.layout.getDisplayDensity();
+    }
+    get verticalOffsetX() {
+        if (!this.android) {
+            return 0;
+        }
+        return this.android.computeHorizontalScrollOffset() / Utils.layout.getDisplayDensity();
+    }
+    get verticalOffsetY() {
+        if (!this.android) {
+            return 0;
+        }
+        return this.android.computeVerticalScrollOffset() / Utils.layout.getDisplayDensity();
+    }
+    scrollToIndex(index, animated = true) {
+        if (!this.android) {
+            return;
+        }
+        if (animated) {
+            this.android.smoothScrollToPosition(index);
+        }
+        else {
+            this.android.scrollToPosition(index);
+        }
+    }
+    _setPadding(newPadding) {
+        if (this.android) {
+            const padding = {
+                top: this.android.getPaddingTop(),
+                right: this.android.getPaddingRight(),
+                bottom: this.android.getPaddingBottom(),
+                left: this.android.getPaddingLeft()
+            };
+            // tslint:disable-next-line:prefer-object-spread
+            const newValue = Object.assign(padding, newPadding);
+            this.android.setClipToPadding(false);
+            this.android.setPadding(newValue.left, newValue.top, newValue.right, newValue.bottom);
+            this.updateInnerSize();
+        }
+    }
+    createComposedAdapter() {
+        const adapter = new com.nativescript.collectionview.Adapter();
+        adapter.adapterInterface = new com.nativescript.collectionview.AdapterInterface({
+            getItemId: this.getItemId.bind(this),
+            getItemViewType: this.getItemViewType.bind(this),
+            getItemCount: this.getItemCount.bind(this),
+            onCreateViewHolder: this.onCreateViewHolder.bind(this),
+            onBindViewHolder: this.onBindViewHolder.bind(this),
+            onViewRecycled: this.onViewRecycled.bind(this)
+        });
+        // const composedAdapter = new com.h6ah4i.android.widget.advrecyclerview.composedadapter.ComposedAdapter();
+        // composedAdapter.addAdapter(new CollectionViewAdapter(new WeakRef(this)));
+        return adapter;
+    }
+    getItemCount() {
+        return this.items ? this.items.length : 0;
+    }
+    getItem(i) {
+        if (this.items && i < this.items.length) {
+            return this.getItemAtIndex(i);
+        }
+        return null;
+    }
+    getItemId(i) {
+        let id = -1;
+        if (this._itemIdGenerator && this.items) {
+            const item = this.getItemAtIndex(i);
+            id = this._itemIdGenerator(item, i, this.items);
+        }
+        return long(id);
+    }
+    onItemIdGeneratorChanged(oldValue, newValue) {
+        super.onItemIdGeneratorChanged(oldValue, newValue);
+        if (this._listViewAdapter) {
+            this._listViewAdapter.setHasStableIds(!!newValue);
+        }
+    }
+    clearTemplateTypes() {
+        this._currentNativeItemType = 0;
+        this.templateTypeNumberString.clear();
+        this.templateStringTypeNumber.clear();
+    }
+    getItemViewType(position) {
+        let selectorType = 'default';
+        if (this._itemTemplateSelector) {
+            const selector = this._itemTemplateSelector;
+            const dataItem = this.getItemAtIndex(position);
+            if (dataItem) {
+                selectorType = selector(dataItem, position, this.items);
+            }
+        }
+        return this.templateKeyToNativeItem(selectorType);
+        // if (!this.templateTypeNumberString.has(selectorType)) {
+        //     resultType = this._currentNativeItemType;
+        //     this.templateTypeNumberString.set(selectorType, resultType);
+        //     this.templateStringTypeNumber.set(resultType, selectorType);
+        //     this._currentNativeItemType++;
+        // } else {
+        //     resultType = this.templateTypeNumberString.get(selectorType);
+        // }
+        // return resultType;
+    }
+    templateKeyToNativeItem(key) {
+        if (!this.templateTypeNumberString) {
+            this.templateTypeNumberString = new Map();
+            this._currentNativeItemType = 0;
+            this._itemTemplatesInternal.forEach((v, i) => {
+                this.templateTypeNumberString.set(v.key, this._currentNativeItemType);
+                this.templateStringTypeNumber.set(this._currentNativeItemType, v.key);
+                this.setNativePoolSize(v.key, this._currentNativeItemType);
+                this._currentNativeItemType++;
+            });
+            this._currentNativeItemType = Math.max(this._itemTemplatesInternal.size, 100);
+            // templates will be numbered 0,1,2,3... for named templates
+            // default/unnamed templates will be numbered 100, 101, 102, 103...
+        }
+        if (!this.templateTypeNumberString.has(key)) {
+            this.templateTypeNumberString.set(key, this._currentNativeItemType);
+            this.templateStringTypeNumber.set(this._currentNativeItemType, key);
+            this.setNativePoolSize(key, this._currentNativeItemType);
+            this._currentNativeItemType++;
+        }
+        return this.templateTypeNumberString.get(key);
+    }
+    nativeItemToTemplateKey(item) {
+        let result;
+        this.templateTypeNumberString?.forEach((value, key, map) => {
+            if (value === item) {
+                result = key;
+            }
+        }, this);
+        return result;
+    }
+    disposeViewHolderViews() {
+        this.enumerateViewHolders((v) => {
+            const view = v.view;
+            if (view && view.isLoaded) {
+                view.callUnloaded();
+            }
+            view._isAddedToNativeVisualTree = false;
+            view._tearDownUI();
+            v.view = null;
+            v.clickListener = null;
+        });
+        this._viewHolders = new Set();
+    }
+    getKeyByValue(viewType) {
+        return this.templateStringTypeNumber.get(viewType);
+    }
+    onCreateViewHolder(parent, viewType) {
+        let view = this.getViewForViewType(ListViewViewTypes.ItemView, this.getKeyByValue(viewType));
+        const isNonSync = view === undefined;
+        // dont create unecessary StackLayout if template.createView returns. Will happend when not using Vue or angular
+        if (isNonSync || view instanceof ProxyViewContainer) {
+            const parentView = new ContentView();
+            parentView.id = 'collectionViewHolder';
+            view = parentView;
+        }
+        view._setupAsRootView(this._context);
+        view._isAddedToNativeVisualTree = true;
+        //@ts-ignore
+        view.parent = this;
+        view.callLoaded();
+        if (!CollectionViewCellHolder) {
+            CollectionViewCellHolder = com.nativescript.collectionview.CollectionViewCellHolder;
+        }
+        const holder = new CollectionViewCellHolder(view.nativeView);
+        const collectionView = this;
+        const clickListener = new android.view.View.OnClickListener({
+            onClick: () => {
+                const position = holder.getAdapterPosition();
+                collectionView.notify({
+                    eventName: CollectionViewBase.itemTapEvent,
+                    object: collectionView,
+                    index: position,
+                    item: collectionView.getItem(position),
+                    view: holder.view
+                });
+            }
+        });
+        view.nativeView.setOnClickListener(clickListener);
+        holder.clickListener = clickListener;
+        holder.view = view;
+        const layoutParams = this._getViewLayoutParams();
+        view.nativeView.setLayoutParams(layoutParams);
+        if (isNonSync) {
+            holder['defaultItemView'] = true;
+        }
+        this._viewHolders.add(holder);
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onCreateViewHolder', this._viewHolders.size);
+        }
+        return holder;
+    }
+    onBindViewHolder(holder, position) {
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onBindViewHolder', position);
+        }
+        let view = holder.view;
+        const bindingContext = this._prepareItem(view, position);
+        const isNonSync = holder['defaultItemView'] === true;
+        holder['position'] = position;
+        view = isNonSync ? view.content : view;
+        const args = {
+            eventName: CollectionViewBase.itemLoadingEvent,
+            index: position,
+            object: this,
+            view,
+            bindingContext,
+            android: holder
+        };
+        this.notify(args);
+        if (isNonSync && args.view !== view) {
+            view = args.view;
+            // the view has been changed on the event handler
+            holder.view.content = args.view;
+        }
+        view.notify({ eventName: CollectionViewBase.bindedEvent });
+        let width = this._effectiveColWidth;
+        let height = this._effectiveRowHeight;
+        if (this._getSpanSize) {
+            const spanSize = this._getSpanSize(bindingContext, position);
+            const horizontal = this.isHorizontal();
+            if (horizontal) {
+                height *= spanSize;
+            }
+            else {
+                width *= spanSize;
+            }
+        }
+        if (width || !view.width) {
+            view.width = Utils.layout.toDeviceIndependentPixels(width);
+        }
+        if (height || !view.height) {
+            view.height = Utils.layout.toDeviceIndependentPixels(height);
+        }
+        if (this.hasListeners(CollectionViewBase.displayItemEvent)) {
+            this.notify({
+                eventName: CollectionViewBase.displayItemEvent,
+                index: position,
+                object: this,
+                cell: holder
+            });
+        }
+        if (Trace.isEnabled()) {
+            CLog(CLogTypes.log, 'onBindViewHolder done ', position);
+        }
+    }
+    onViewRecycled(holder) {
+        holder['position'] = null;
+    }
+}
+CollectionView.DEFAULT_TEMPLATE_VIEW_TYPE = 0;
+CollectionView.CUSTOM_TEMPLATE_ITEM_TYPE = 1;
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], CollectionView.prototype, "createNativeView", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], CollectionView.prototype, "initNativeView", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], CollectionView.prototype, "refresh", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [android.view.ViewGroup, Number]),
+    __metadata("design:returntype", void 0)
+], CollectionView.prototype, "onCreateViewHolder", null);
+__decorate([
+    profile,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CollectionViewCellHolder, Number]),
+    __metadata("design:returntype", void 0)
+], CollectionView.prototype, "onBindViewHolder", null);
+itemViewCacheSizeProperty.register(CollectionViewBase);
+extraLayoutSpaceProperty.register(CollectionViewBase);
+nestedScrollingEnabledProperty.register(CollectionViewBase);
+//# sourceMappingURL=index.android.js.map