android.databinding.ObservableList Java Examples

@Override
public void onItemRangeMoved(ObservableList sender, int fromPosition, int toPosition, int itemCount)
{
    RecyclerView.Adapter adapter = adapterReference.get();
    if (adapter != null)
    {
        adapter.notifyItemMoved(fromPosition, toPosition);
    }
}
 

@Override
public void onItemRangeInserted(ObservableList observableList,
        int start, int count) {
    if (mLayoutId == 0) {
        return;
    }
    startTransition(mTarget);
    final int end = start + count;
    LayoutInflater inflater = (LayoutInflater) mTarget.getContext()
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    for (int i = end - 1; i >= start; i--) {
        Object entry = observableList.get(i);
        ViewDataBinding binding =
                bindLayout(inflater, mTarget, mLayoutId, entry);
        mTarget.addView(binding.getRoot(), start);
    }
}
 

public ObservableList<Layer> getTwirledDownLayersForGroup(LayerGroup root) {
    ObservableList<Layer> twirledDownLayers = new ObservableArrayList<>();

    for (Layer l : root.getLayers()) {
        twirledDownLayers.add(l);
        if (l instanceof LayerGroup) {
            LayerGroup group = (LayerGroup) l;
            if (group.isTwirledDown()) {
                int i = twirledDownLayers.indexOf(l);
                List<Layer> childLayers = getTwirledDownLayersForGroup(group);
                twirledDownLayers.addAll(i + 1, childLayers);
            }
        }
    }

    return twirledDownLayers;
}
 

@Override
public void onItemRangeInserted(ObservableList observableList,
        int start, int count) {
    if (mLayoutId == 0) {
        return;
    }
    startTransition(mTarget);
    final int end = start + count;
    LayoutInflater inflater = (LayoutInflater) mTarget.getContext()
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    for (int i = end - 1; i >= start; i--) {
        Object entry = observableList.get(i);
        ViewDataBinding binding =
                bindLayout(inflater, mTarget, mLayoutId, entry);
        mTarget.addView(binding.getRoot(), start);
    }
}
 

@Override
public void onItemRangeChanged(final ObservableList<ItemTypeT> items,
        final int start, final int count) {
    mainHandler.post(() -> {
        for (int i = start; i < start + count; ++i) {
            adapterItems.set(i, items.get(i));
        }

        notifyItemRangeChanged(getItemLayoutPosition(start), count);
    });
}
 

@Override
public void onItemRangeChanged(ObservableList observableList,
        int start, int count) {
    if (mLayoutId == 0) {
        return;
    }
    LayoutInflater inflater = (LayoutInflater) mTarget.getContext()
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    startTransition(mTarget);
    final int end = start + count;
    for (int i = start; i < end; i++) {
        Object data = observableList.get(i);
        ViewDataBinding binding = bindLayout(inflater,
                mTarget, mLayoutId, data);
        binding.setVariable(BR.data, observableList.get(i));
        mTarget.removeViewAt(i);
        mTarget.addView(binding.getRoot(), i);
    }
}
 

@Override
public void onItemRangeChanged(ObservableList observableList,
        int start, int count) {
    if (mLayoutId == 0) {
        return;
    }
    LayoutInflater inflater = (LayoutInflater) mTarget.getContext()
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    startTransition(mTarget);
    final int end = start + count;
    for (int i = start; i < end; i++) {
        Object data = observableList.get(i);
        ViewDataBinding binding = bindLayout(inflater,
                mTarget, mLayoutId, data);
        binding.setVariable(BR.data, observableList.get(i));
        mTarget.removeViewAt(i);
        mTarget.addView(binding.getRoot(), i);
    }
}
 

/**
 * Sets the list of items to display.
 * @param items The list of items.
 */
public void setItems(@Nullable Collection<T> items)
{
    if (this.items == items)
    {
        return;
    }

    if (this.items != null)
    {
        this.items.removeOnListChangedCallback(onListChangedCallback);
        notifyItemRangeRemoved(0, this.items.size());
    }

    if (items instanceof ObservableList)
    {
        this.items = (ObservableList<T>) items;
        notifyItemRangeInserted(0, this.items.size());
        this.items.addOnListChangedCallback(onListChangedCallback);
    }
    else if (items != null)
    {
        this.items = new ObservableArrayList<>();
        this.items.addOnListChangedCallback(onListChangedCallback);
        this.items.addAll(items);
    }
    else
    {
        this.items = null;
    }
}
 

@Override
public void onChanged(ObservableList sender)
{
    RecyclerView.Adapter adapter = adapterReference.get();
    if (adapter != null)
    {
        adapter.notifyDataSetChanged();
    }
}
 

/**
 * Called when the list changed
 * @param sender The current list.
 */
@Override
public void onChanged(ObservableList sender)
{
    RecyclerView.Adapter adapter = adapterReference.get();
    if (adapter != null)
    {
        adapter.notifyDataSetChanged();
    }
}
 

/**
 * Called when an item range is inserted in the list.
 * @param sender The current list.
 * @param positionStart The position of the first item inserted.
 * @param itemCount The number of items inserted.
 */
@Override
public void onItemRangeInserted(ObservableList sender, int positionStart, int itemCount)
{
    RecyclerView.Adapter adapter = adapterReference.get();
    if (adapter != null)
    {
        adapter.notifyItemRangeInserted(positionStart, itemCount);
    }
}
 

@Override
public void onItemRangeMoved(ObservableList observableList,
        int from, int to, int count) {
    if (mLayoutId == 0) {
        return;
    }
    startTransition(mTarget);
    for (int i = 0; i < count; i++) {
        View view = mTarget.getChildAt(from);
        mTarget.removeViewAt(from);
        int destination = (from > to) ? to + i : to;
        mTarget.addView(view, destination);
    }
}
 

@Override
public void onItemRangeRemoved(ObservableList observableList,
        int start, int count) {
    if (mLayoutId == 0) {
        return;
    }
    startTransition(mTarget);
    for (int i = 0; i < count; i++) {
        mTarget.removeViewAt(start);
    }
}
 

@Override
public void onItemRangeRemoved(ObservableList observableList,
        int start, int count) {
    if (mLayoutId == 0) {
        return;
    }
    startTransition(mTarget);
    for (int i = 0; i < count; i++) {
        mTarget.removeViewAt(start);
    }
}
 

/**
 * Called when an item range is removed from the list.
 * @param sender The current list.
 * @param positionStart The position of the first item removed.
 * @param itemCount The number of items removed.
 */
@Override
public void onItemRangeRemoved(ObservableList sender, int positionStart, int itemCount)
{
    RecyclerView.Adapter adapter = adapterReference.get();
    if (adapter != null)
    {
        adapter.notifyItemRangeRemoved(positionStart, itemCount);
    }
}
 

/**
 * Assign a list of items to a ViewGroup. This is used with the {@code entries} and
 * {@code layout} attributes in the application namespace. Example Usage:
 * <pre><code>&lt;LinearLayout
 *     android:layout_width="match_parent"
 *     android:layout_height="wrap_content"
 *     android:orientation="vertical"
 *     app:entries="@{items}"
 *     app:layout="@{@layout/item}"/&gt;
 * </code></pre>
 * <p>
 * In the above, {@code items} is a List or ObservableList. {@code layout} does not
 * need to be hard-coded, but most commonly will be. This BindingAdapter will work
 * with any ViewGroup that only needs addView() and removeView() to manage its Views.
 * <p>
 * The layout, &commat;layout/item for example, must have a single variable named
 * {@code data}.
 */
@BindingAdapter({"entries", "layout"})
public static <T> void setEntries(ViewGroup viewGroup,
        List<T> oldEntries, int oldLayoutId,
        List<T> newEntries, int newLayoutId) {
    if (oldEntries == newEntries && oldLayoutId == newLayoutId) {
        return; // nothing has changed
    }

    EntryChangeListener listener =
            ListenerUtil.getListener(viewGroup, R.id.entryListener);
    if (oldEntries != newEntries && listener != null && oldEntries instanceof ObservableList) {
        ((ObservableList)oldEntries).removeOnListChangedCallback(listener);
    }

    if (newEntries == null) {
        viewGroup.removeAllViews();
    } else {
        if (newEntries instanceof ObservableList) {
            if (listener == null) {
                listener =
                        new EntryChangeListener(viewGroup, newLayoutId);
                ListenerUtil.trackListener(viewGroup, listener,
                        R.id.entryListener);
            } else {
                listener.setLayoutId(newLayoutId);
            }
            if (newEntries != oldEntries) {
                ((ObservableList)newEntries).addOnListChangedCallback(listener);
            }
        }
        resetViews(viewGroup, newLayoutId, newEntries);
    }
}
 

@Override
public void onItemRangeInserted(final ObservableList<ItemTypeT> items,
        final int start, final int count) {
    mainHandler.post(() -> {
        for (int i = start + count - 1; i >= start; --i) {
            adapterItems.add(start, items.get(i));
        }

        notifyItemRangeInserted(getItemLayoutPosition(start), count);
    });
}
 

@Override
public void onItemRangeMoved(ObservableList<T> sender,
                             int fromPosition, int toPosition, int itemCount) {
    for (int i = 0; i < itemCount; i++) {
        notifyItemMoved(fromPosition + i, toPosition + i);
    }
}
 

/**
 * Assign a list of items to a ViewGroup. This is used with the {@code entries} and
 * {@code layout} attributes in the application namespace. Example Usage:
 * <pre><code>&lt;LinearLayout
 *     android:layout_width="match_parent"
 *     android:layout_height="wrap_content"
 *     android:orientation="vertical"
 *     app:entries="@{items}"
 *     app:layout="@{@layout/item}"/&gt;
 * </code></pre>
 * <p>
 * In the above, {@code items} is a List or ObservableList. {@code layout} does not
 * need to be hard-coded, but most commonly will be. This BindingAdapter will work
 * with any ViewGroup that only needs addView() and removeView() to manage its Views.
 * <p>
 * The layout, &commat;layout/item for example, must have a single variable named
 * {@code data}.
 */
@BindingAdapter({"entries", "layout"})
public static <T> void setEntries(ViewGroup viewGroup,
        List<T> oldEntries, int oldLayoutId,
        List<T> newEntries, int newLayoutId) {
    if (oldEntries == newEntries && oldLayoutId == newLayoutId) {
        return; // nothing has changed
    }

    EntryChangeListener listener =
            ListenerUtil.getListener(viewGroup, R.id.entryListener);
    if (oldEntries != newEntries && listener != null && oldEntries instanceof ObservableList) {
        ((ObservableList)oldEntries).removeOnListChangedCallback(listener);
    }

    if (newEntries == null) {
        viewGroup.removeAllViews();
    } else {
        if (newEntries instanceof ObservableList) {
            if (listener == null) {
                listener =
                        new EntryChangeListener(viewGroup, newLayoutId);
                ListenerUtil.trackListener(viewGroup, listener,
                        R.id.entryListener);
            } else {
                listener.setLayoutId(newLayoutId);
            }
            if (newEntries != oldEntries) {
                ((ObservableList)newEntries).addOnListChangedCallback(listener);
            }
        }
        resetViews(viewGroup, newLayoutId, newEntries);
    }
}
 

private void addPropertyChangedCallbacks(List<Layer> layers, int start, int end) {
    for (int i = start; i < end; i++) {
        Layer l = layers.get(i);
        l.addOnPropertyChangedCallback(mOnPropertyChangedCallback);
        if (l instanceof LayerGroup) {
            LayerGroup lg = (LayerGroup) l;
            ObservableList<Layer> childLayers = lg.getLayers();
            // Add list listener for future changes to the layer group's list of children
            childLayers.addOnListChangedCallback(mOnListChangedCallback);

            // Recursive call to add property listeners to each child layer
            addPropertyChangedCallbacks(childLayers);
        }
    }
}
 

@Override
public void onItemRangeChanged(ObservableList sender, int positionStart, int itemCount)
{
    RecyclerView.Adapter adapter = adapterReference.get();
    if (adapter != null)
    {
        adapter.notifyItemRangeChanged(positionStart, itemCount);
    }
}
 

private void updateList() {
    PickerViewModel viewModel = PickerViewModel.getInstance();
    ObservableList<File> files = viewModel.getFiles();

    if (mAdapter == null) {
        mAdapter = new FileAdapter();
        mList.setAdapter(mAdapter);
    }

    mAdapter.setFiles(files);
    mBinding.setViewModel(viewModel);
}
 

public FileAdapter() {
    mOnListChangedCallback = new ObservableList
            .OnListChangedCallback<ObservableList<Layer>>() {
        @Override
        public void onChanged(ObservableList<Layer> layers) {

        }

        @Override
        public void onItemRangeChanged(ObservableList<Layer> layers, int i, int i1) {

        }

        @Override
        public void onItemRangeInserted(ObservableList<Layer> layers, int start, int
                count) {
            notifyItemRangeInserted(start, count);
        }

        @Override
        public void onItemRangeMoved(ObservableList<Layer> sender, int fromPosition, int
                toPosition, int itemCount) {

        }

        @Override
        public void onItemRangeRemoved(ObservableList<Layer> sender, int positionStart,
                                       int itemCount) {

        }
    };
}
 

public void setItems(@Nullable Collection<T> items)
{
    if (this.items == items)
    {
        return;
    }

    if (this.items != null)
    {
        this.items.removeOnListChangedCallback(onListChangedCallback);
        notifyItemRangeRemoved(0, this.items.size());
    }

    if (items instanceof ObservableList)
    {
        this.items = (ObservableList<T>) items;
        notifyItemRangeInserted(0, this.items.size());
        this.items.addOnListChangedCallback(onListChangedCallback);
    }
    else if (items != null)
    {
        this.items = new ObservableArrayList<>();
        this.items.addOnListChangedCallback(onListChangedCallback);
        this.items.addAll(items);
    }
    else
    {
        this.items = null;
    }
}
 

private void addListChangedCallbacks(List<Layer> layers, int start, int end) {
    for (int i = start; i < end; i++) {
        Layer l = layers.get(i);
        if (l instanceof LayerGroup) {
            LayerGroup lg = (LayerGroup) l;
            ObservableList<Layer> childLayers = lg.getLayers();
            // Add list listener for future changes to the layer group's list of children
            childLayers.addOnListChangedCallback(mOnListChangedCallback);
            // Recursive call to add property listeners to each child layer
            addListChangedCallbacks(childLayers);
        }
    }
}
 

/**
 * Called when an item range changed in the list.
 * @param sender The current list.
 * @param positionStart The position of the first item modified.
 * @param itemCount The number of items modified.
 */
@Override
public void onItemRangeChanged(ObservableList sender, int positionStart, int itemCount)
{
    RecyclerView.Adapter adapter = adapterReference.get();
    if (adapter != null)
    {
        adapter.notifyItemRangeChanged(positionStart, itemCount);
    }
}
 

@Override
public void onItemRangeRemoved(ObservableList sender, int positionStart, int itemCount) {
    mAdapter.notifyItemRangeRemoved(positionStart, itemCount);
}
 

public void setFiles(ObservableList<File> files) {
    mFiles = files;
    mFiles.addOnListChangedCallback(mOnListChangedCallback);
    notifyDataSetChanged();
}
 

public static IBinding bind(ObservableList observableList, ObservableList.OnListChangedCallback callback) {
    IBinding binding = new ListBinding(observableList, callback);
    binding.bind();

    return binding;
}
 

public MeiziAdapter(Context context, ObservableList<Image> data, RequestManager manager) {
    super(context, data);
    this.mRequestManager = manager;
    setHasStableIds(true);
}