/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.databinding;
import com.android.databinding.library.R;
import android.annotation.TargetApi;
import android.databinding.CallbackRegistry.NotifierCallback;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.os.Handler;
import android.os.Looper;
import android.text.TextUtils;
import android.util.SparseIntArray;
import android.view.Choreographer;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnAttachStateChangeListener;
import android.view.ViewGroup;
import java.lang.ref.WeakReference;
/**
* Base class for generated data binding classes. If possible, the generated binding should
* be instantiated using one of its generated static bind or inflate methods. If the specific
* binding is unknown, {@link DataBindingUtil#bind(View)} or
* {@link DataBindingUtil#inflate(LayoutInflater, int, ViewGroup, boolean)} should be used.
*/
public abstract class ViewDataBinding {
/**
* Instead of directly accessing Build.VERSION.SDK_INT, generated code uses this value so that
* we can test API dependent behavior.
*/
static int SDK_INT = VERSION.SDK_INT;
private static final int REBIND = 1;
private static final int HALTED = 2;
private static final int REBOUND = 3;
/**
* Prefix for android:tag on Views with binding. The root View and include tags will not have
* android:tag attributes and will use ids instead.
*
* @hide
*/
public static final String BINDING_TAG_PREFIX = "binding_";
// The length of BINDING_TAG_PREFIX prevents calling length repeatedly.
private static final int BINDING_NUMBER_START = BINDING_TAG_PREFIX.length();
// ICS (v 14) fixes a leak when using setTag(int, Object)
private static final boolean USE_TAG_ID = DataBinderMapper.TARGET_MIN_SDK >= 14;
private static final boolean USE_CHOREOGRAPHER = SDK_INT >= 16;
/**
* Method object extracted out to attach a listener to a bound Observable object.
*/
private static final CreateWeakListener CREATE_PROPERTY_LISTENER = new CreateWeakListener() {
@Override
public WeakListener create(ViewDataBinding viewDataBinding, int localFieldId) {
return new WeakPropertyListener(viewDataBinding, localFieldId).getListener();
}
};
/**
* Method object extracted out to attach a listener to a bound ObservableList object.
*/
private static final CreateWeakListener CREATE_LIST_LISTENER = new CreateWeakListener() {
@Override
public WeakListener create(ViewDataBinding viewDataBinding, int localFieldId) {
return new WeakListListener(viewDataBinding, localFieldId).getListener();
}
};
/**
* Method object extracted out to attach a listener to a bound ObservableMap object.
*/
private static final CreateWeakListener CREATE_MAP_LISTENER = new CreateWeakListener() {
@Override
public WeakListener create(ViewDataBinding viewDataBinding, int localFieldId) {
return new WeakMapListener(viewDataBinding, localFieldId).getListener();
}
};
private static final CallbackRegistry.NotifierCallback<OnRebindCallback, ViewDataBinding, Void>
REBIND_NOTIFIER = new NotifierCallback<OnRebindCallback, ViewDataBinding, Void>() {
@Override
public void onNotifyCallback(OnRebindCallback callback, ViewDataBinding sender, int mode,
Void arg2) {
switch (mode) {
case REBIND:
if (!callback.onPreBind(sender)) {
sender.mRebindHalted = true;
}
break;
case HALTED:
callback.onCanceled(sender);
break;
case REBOUND:
callback.onBound(sender);
break;
}
}
};
private static final OnAttachStateChangeListener ROOT_REATTACHED_LISTENER;
static {
if (VERSION.SDK_INT < VERSION_CODES.KITKAT) {
ROOT_REATTACHED_LISTENER = null;
} else {
ROOT_REATTACHED_LISTENER = new OnAttachStateChangeListener() {
@TargetApi(VERSION_CODES.KITKAT)
@Override
public void onViewAttachedToWindow(View v) {
// execute the pending bindings.
final ViewDataBinding binding = getBinding(v);
binding.mRebindRunnable.run();
v.removeOnAttachStateChangeListener(this);
}
@Override
public void onViewDetachedFromWindow(View v) {
}
};
}
}
/**
* Runnable executed on animation heartbeat to rebind the dirty Views.
*/
private final Runnable mRebindRunnable = new Runnable() {
@Override
public void run() {
synchronized (this) {
mPendingRebind = false;
}
if (VERSION.SDK_INT >= VERSION_CODES.KITKAT) {
// Nested so that we don't get a lint warning in IntelliJ
if (!mRoot.isAttachedToWindow()) {
// Don't execute the pending bindings until the View
// is attached again.
mRoot.removeOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);
mRoot.addOnAttachStateChangeListener(ROOT_REATTACHED_LISTENER);
return;
}
}
executePendingBindings();
}
};
/**
* Flag indicates that there are pending bindings that need to be reevaluated.
*/
private boolean mPendingRebind = false;
/**
* Indicates that a onPreBind has stopped the executePendingBindings call.
*/
private boolean mRebindHalted = false;
/**
* The observed expressions.
*/
private WeakListener[] mLocalFieldObservers;
/**
* The root View that this Binding is associated with.
*/
private final View mRoot;
/**
* The collection of OnRebindCallbacks.
*/
private CallbackRegistry<OnRebindCallback, ViewDataBinding, Void> mRebindCallbacks;
/**
* Flag to prevent reentrant executePendingBinding calls.
*/
private boolean mIsExecutingPendingBindings;
// null api < 16
private Choreographer mChoreographer;
private final Choreographer.FrameCallback mFrameCallback;
// null api >= 16
private Handler mUIThreadHandler;
/**
* The DataBindingComponent used by this data binding. This is used for BindingAdapters
* that are instance methods to retrieve the class instance that implements the
* adapter.
*
* @hide
*/
protected final DataBindingComponent mBindingComponent;
/**
* @hide
*/
protected ViewDataBinding(DataBindingComponent bindingComponent, View root, int localFieldCount) {
mBindingComponent = bindingComponent;
mLocalFieldObservers = new WeakListener[localFieldCount];
this.mRoot = root;
if (Looper.myLooper() == null) {
throw new IllegalStateException("DataBinding must be created in view's UI Thread");
}
if (USE_CHOREOGRAPHER) {
mChoreographer = Choreographer.getInstance();
mFrameCallback = new Choreographer.FrameCallback() {
@Override
public void doFrame(long frameTimeNanos) {
mRebindRunnable.run();
}
};
} else {
mFrameCallback = null;
mUIThreadHandler = new Handler(Looper.myLooper());
}
}
/**
* @hide
*/
protected void setRootTag(View view) {
if (USE_TAG_ID) {
view.setTag(R.id.dataBinding, this);
} else {
view.setTag(this);
}
}
/**
* @hide
*/
protected void setRootTag(View[] views) {
if (USE_TAG_ID) {
for (View view : views) {
view.setTag(R.id.dataBinding, this);
}
} else {
for (View view : views) {
view.setTag(this);
}
}
}
/**
* @hide
*/
public static int getBuildSdkInt() {
return SDK_INT;
}
/**
* Called when an observed object changes. Sets the appropriate dirty flag if applicable.
* @param localFieldId The index into mLocalFieldObservers that this Object resides in.
* @param object The object that has changed.
* @param fieldId The BR ID of the field being changed or _all if
* no specific field is being notified.
* @return true if this change should cause a change to the UI.
* @hide
*/
protected abstract boolean onFieldChange(int localFieldId, Object object, int fieldId);
/**
* Set a value value in the Binding class.
* <p>
* Typically, the developer will be able to call the subclass's set method directly. For
* example, if there is a variable <code>x</code> in the Binding, a <code>setX</code> method
* will be generated. However, there are times when the specific subclass of ViewDataBinding
* is unknown, so the generated method cannot be discovered without reflection. The
* setVariable call allows the values of variables to be set without reflection.
*
* @param variableId the BR id of the variable to be set. For example, if the variable is
* <code>x</code>, then variableId will be <code>BR.x</code>.
* @param value The new value of the variable to be set.
* @return <code>true</code> if the variable exists in the binding or <code>false</code>
* otherwise.
*/
public abstract boolean setVariable(int variableId, Object value);
/**
* Add a listener to be called when reevaluating dirty fields. This also allows automatic
* updates to be halted, but does not stop explicit calls to {@link #executePendingBindings()}.
*
* @param listener The listener to add.
*/
public void addOnRebindCallback(OnRebindCallback listener) {
if (mRebindCallbacks == null) {
mRebindCallbacks = new CallbackRegistry<OnRebindCallback, ViewDataBinding, Void>(REBIND_NOTIFIER);
}
mRebindCallbacks.add(listener);
}
/**
* Removes a listener that was added in {@link #addOnRebindCallback(OnRebindCallback)}.
*
* @param listener The listener to remove.
*/
public void removeOnRebindCallback(OnRebindCallback listener) {
if (mRebindCallbacks != null) {
mRebindCallbacks.remove(listener);
}
}
/**
* Evaluates the pending bindings, updating any Views that have expressions bound to
* modified variables. This <b>must</b> be run on the UI thread.
*/
public void executePendingBindings() {
if (mIsExecutingPendingBindings) {
requestRebind();
return;
}
if (!hasPendingBindings()) {
return;
}
mIsExecutingPendingBindings = true;
mRebindHalted = false;
if (mRebindCallbacks != null) {
mRebindCallbacks.notifyCallbacks(this, REBIND, null);
// The onRebindListeners will change mPendingHalted
if (mRebindHalted) {
mRebindCallbacks.notifyCallbacks(this, HALTED, null);
}
}
if (!mRebindHalted) {
executeBindings();
if (mRebindCallbacks != null) {
mRebindCallbacks.notifyCallbacks(this, REBOUND, null);
}
}
mIsExecutingPendingBindings = false;
}
void forceExecuteBindings() {
executeBindings();
}
/**
* @hide
*/
protected abstract void executeBindings();
/**
* Invalidates all binding expressions and requests a new rebind to refresh UI.
*/
public abstract void invalidateAll();
/**
* Returns whether the UI needs to be refresh to represent the current data.
*
* @return true if any field has changed and the binding should be evaluated.
*/
public abstract boolean hasPendingBindings();
/**
* Removes binding listeners to expression variables.
*/
public void unbind() {
for (WeakListener weakListener : mLocalFieldObservers) {
if (weakListener != null) {
weakListener.unregister();
}
}
}
@Override
protected void finalize() throws Throwable {
unbind();
}
static ViewDataBinding getBinding(View v) {
if (v != null) {
if (USE_TAG_ID) {
return (ViewDataBinding) v.getTag(R.id.dataBinding);
} else {
final Object tag = v.getTag();
if (tag instanceof ViewDataBinding) {
return (ViewDataBinding) tag;
}
}
}
return null;
}
/**
* Returns the outermost View in the layout file associated with the Binding. If this
* binding is for a merge layout file, this will return the first root in the merge tag.
*
* @return the outermost View in the layout file associated with the Binding.
*/
public View getRoot() {
return mRoot;
}
private void handleFieldChange(int mLocalFieldId, Object object, int fieldId) {
boolean result = onFieldChange(mLocalFieldId, object, fieldId);
if (result) {
requestRebind();
}
}
/**
* @hide
*/
protected boolean unregisterFrom(int localFieldId) {
WeakListener listener = mLocalFieldObservers[localFieldId];
if (listener != null) {
return listener.unregister();
}
return false;
}
/**
* @hide
*/
protected void requestRebind() {
synchronized (this) {
if (mPendingRebind) {
return;
}
mPendingRebind = true;
}
if (USE_CHOREOGRAPHER) {
mChoreographer.postFrameCallback(mFrameCallback);
} else {
mUIThreadHandler.post(mRebindRunnable);
}
}
/**
* @hide
*/
protected Object getObservedField(int localFieldId) {
WeakListener listener = mLocalFieldObservers[localFieldId];
if (listener == null) {
return null;
}
return listener.getTarget();
}
private boolean updateRegistration(int localFieldId, Object observable,
CreateWeakListener listenerCreator) {
if (observable == null) {
return unregisterFrom(localFieldId);
}
WeakListener listener = mLocalFieldObservers[localFieldId];
if (listener == null) {
registerTo(localFieldId, observable, listenerCreator);
return true;
}
if (listener.getTarget() == observable) {
return false;//nothing to do, same object
}
unregisterFrom(localFieldId);
registerTo(localFieldId, observable, listenerCreator);
return true;
}
/**
* @hide
*/
protected boolean updateRegistration(int localFieldId, Observable observable) {
return updateRegistration(localFieldId, observable, CREATE_PROPERTY_LISTENER);
}
/**
* @hide
*/
protected boolean updateRegistration(int localFieldId, ObservableList observable) {
return updateRegistration(localFieldId, observable, CREATE_LIST_LISTENER);
}
/**
* @hide
*/
protected boolean updateRegistration(int localFieldId, ObservableMap observable) {
return updateRegistration(localFieldId, observable, CREATE_MAP_LISTENER);
}
/**
* @hide
*/
protected void ensureBindingComponentIsNotNull(Class<?> oneExample) {
if (mBindingComponent == null) {
String errorMessage = "Required DataBindingComponent is null in class " +
getClass().getSimpleName() + ". A BindingAdapter in " +
oneExample.getCanonicalName() +
" is not static and requires an object to use, retrieved from the " +
"DataBindingComponent. If you don't use an inflation method taking a " +
"DataBindingComponent, use DataBindingUtil.setDefaultComponent or " +
"make all BindingAdapter methods static.";
throw new IllegalStateException(errorMessage);
}
}
/**
* @hide
*/
protected void registerTo(int localFieldId, Object observable,
CreateWeakListener listenerCreator) {
if (observable == null) {
return;
}
WeakListener listener = mLocalFieldObservers[localFieldId];
if (listener == null) {
listener = listenerCreator.create(this, localFieldId);
mLocalFieldObservers[localFieldId] = listener;
}
listener.setTarget(observable);
}
/**
* @hide
*/
protected static ViewDataBinding bind(DataBindingComponent bindingComponent, View view,
int layoutId) {
return DataBindingUtil.bind(bindingComponent, view, layoutId);
}
/**
* Walks the view hierarchy under root and pulls out tagged Views, includes, and views with
* IDs into an Object[] that is returned. This is used to walk the view hierarchy once to find
* all bound and ID'd views.
*
* @param bindingComponent The binding component to use with this binding.
* @param root The root of the view hierarchy to walk.
* @param numBindings The total number of ID'd views, views with expressions, and includes
* @param includes The include layout information, indexed by their container's index.
* @param viewsWithIds Indexes of views that don't have tags, but have IDs.
* @return An array of size numBindings containing all Views in the hierarchy that have IDs
* (with elements in viewsWithIds), are tagged containing expressions, or the bindings for
* included layouts.
* @hide
*/
protected static Object[] mapBindings(DataBindingComponent bindingComponent, View root,
int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) {
Object[] bindings = new Object[numBindings];
mapBindings(bindingComponent, root, bindings, includes, viewsWithIds, true);
return bindings;
}
/**
* Walks the view hierarchy under roots and pulls out tagged Views, includes, and views with
* IDs into an Object[] that is returned. This is used to walk the view hierarchy once to find
* all bound and ID'd views.
*
* @param bindingComponent The binding component to use with this binding.
* @param roots The root Views of the view hierarchy to walk. This is used with merge tags.
* @param numBindings The total number of ID'd views, views with expressions, and includes
* @param includes The include layout information, indexed by their container's index.
* @param viewsWithIds Indexes of views that don't have tags, but have IDs.
* @return An array of size numBindings containing all Views in the hierarchy that have IDs
* (with elements in viewsWithIds), are tagged containing expressions, or the bindings for
* included layouts.
* @hide
*/
protected static Object[] mapBindings(DataBindingComponent bindingComponent, View[] roots,
int numBindings, IncludedLayouts includes, SparseIntArray viewsWithIds) {
Object[] bindings = new Object[numBindings];
for (int i = 0; i < roots.length; i++) {
mapBindings(bindingComponent, roots[i], bindings, includes, viewsWithIds, true);
}
return bindings;
}
private static void mapBindings(DataBindingComponent bindingComponent, View view,
Object[] bindings, IncludedLayouts includes, SparseIntArray viewsWithIds,
boolean isRoot) {
final int indexInIncludes;
final ViewDataBinding existingBinding = getBinding(view);
if (existingBinding != null) {
return;
}
final String tag = (String) view.getTag();
boolean isBound = false;
if (isRoot && tag != null && tag.startsWith("layout")) {
final int underscoreIndex = tag.lastIndexOf('_');
if (underscoreIndex > 0 && isNumeric(tag, underscoreIndex + 1)) {
final int index = parseTagInt(tag, underscoreIndex + 1);
if (bindings[index] == null) {
bindings[index] = view;
}
indexInIncludes = includes == null ? -1 : index;
isBound = true;
} else {
indexInIncludes = -1;
}
} else if (tag != null && tag.startsWith(BINDING_TAG_PREFIX)) {
int tagIndex = parseTagInt(tag, BINDING_NUMBER_START);
if (bindings[tagIndex] == null) {
bindings[tagIndex] = view;
}
isBound = true;
indexInIncludes = includes == null ? -1 : tagIndex;
} else {
// Not a bound view
indexInIncludes = -1;
}
if (!isBound) {
final int id = view.getId();
if (id > 0) {
int index;
if (viewsWithIds != null && (index = viewsWithIds.get(id, -1)) >= 0 &&
bindings[index] == null) {
bindings[index] = view;
}
}
}
if (view instanceof ViewGroup) {
final ViewGroup viewGroup = (ViewGroup) view;
final int count = viewGroup.getChildCount();
int minInclude = 0;
for (int i = 0; i < count; i++) {
final View child = viewGroup.getChildAt(i);
boolean isInclude = false;
if (indexInIncludes >= 0) {
String childTag = (String) child.getTag();
if (childTag != null && childTag.endsWith("_0") &&
childTag.startsWith("layout") && childTag.indexOf('/') > 0) {
// This *could* be an include. Test against the expected includes.
int includeIndex = findIncludeIndex(childTag, minInclude,
includes, indexInIncludes);
if (includeIndex >= 0) {
isInclude = true;
minInclude = includeIndex + 1;
final int index = includes.indexes[indexInIncludes][includeIndex];
final int layoutId = includes.layoutIds[indexInIncludes][includeIndex];
int lastMatchingIndex = findLastMatching(viewGroup, i);
if (lastMatchingIndex == i) {
bindings[index] = DataBindingUtil.bind(bindingComponent, child,
layoutId);
} else {
final int includeCount = lastMatchingIndex - i + 1;
final View[] included = new View[includeCount];
for (int j = 0; j < includeCount; j++) {
included[j] = viewGroup.getChildAt(i + j);
}
bindings[index] = DataBindingUtil.bind(bindingComponent, included,
layoutId);
i += includeCount - 1;
}
}
}
}
if (!isInclude) {
mapBindings(bindingComponent, child, bindings, includes, viewsWithIds, false);
}
}
}
}
private static int findIncludeIndex(String tag, int minInclude,
IncludedLayouts included, int includedIndex) {
final int slashIndex = tag.indexOf('/');
final CharSequence layoutName = tag.subSequence(slashIndex + 1, tag.length() - 2);
final String[] layouts = included.layouts[includedIndex];
final int length = layouts.length;
for (int i = minInclude; i < length; i++) {
final String layout = layouts[i];
if (TextUtils.equals(layoutName, layout)) {
return i;
}
}
return -1;
}
private static int findLastMatching(ViewGroup viewGroup, int firstIncludedIndex) {
final View firstView = viewGroup.getChildAt(firstIncludedIndex);
final String firstViewTag = (String) firstView.getTag();
final String tagBase = firstViewTag.substring(0, firstViewTag.length() - 1); // don't include the "0"
final int tagSequenceIndex = tagBase.length();
final int count = viewGroup.getChildCount();
int max = firstIncludedIndex;
for (int i = firstIncludedIndex + 1; i < count; i++) {
final View view = viewGroup.getChildAt(i);
final String tag = (String) view.getTag();
if (tag != null && tag.startsWith(tagBase)) {
if (tag.length() == firstViewTag.length() && tag.charAt(tag.length() - 1) == '0') {
return max; // Found another instance of the include
}
if (isNumeric(tag, tagSequenceIndex)) {
max = i;
}
}
}
return max;
}
private static boolean isNumeric(String tag, int startIndex) {
int length = tag.length();
if (length == startIndex) {
return false; // no numerals
}
for (int i = startIndex; i < length; i++) {
if (!Character.isDigit(tag.charAt(i))) {
return false;
}
}
return true;
}
/**
* Parse the tag without creating a new String object. This is fast and assumes the
* tag is in the correct format.
* @param str The tag string.
* @return The binding tag number parsed from the tag string.
*/
private static int parseTagInt(String str, int startIndex) {
final int end = str.length();
int val = 0;
for (int i = startIndex; i < end; i++) {
val *= 10;
char c = str.charAt(i);
val += (c - '0');
}
return val;
}
private interface ObservableReference<T> {
WeakListener<T> getListener();
void addListener(T target);
void removeListener(T target);
}
private static class WeakListener<T> extends WeakReference<ViewDataBinding> {
private final ObservableReference<T> mObservable;
protected final int mLocalFieldId;
private T mTarget;
public WeakListener(ViewDataBinding binder, int localFieldId,
ObservableReference<T> observable) {
super(binder);
mLocalFieldId = localFieldId;
mObservable = observable;
}
public void setTarget(T object) {
unregister();
mTarget = object;
if (mTarget != null) {
mObservable.addListener(mTarget);
}
}
public boolean unregister() {
boolean unregistered = false;
if (mTarget != null) {
mObservable.removeListener(mTarget);
unregistered = true;
}
mTarget = null;
return unregistered;
}
public T getTarget() {
return mTarget;
}
protected ViewDataBinding getBinder() {
ViewDataBinding binder = get();
if (binder == null) {
unregister(); // The binder is dead
}
return binder;
}
}
private static class WeakPropertyListener extends Observable.OnPropertyChangedCallback
implements ObservableReference<Observable> {
final WeakListener<Observable> mListener;
public WeakPropertyListener(ViewDataBinding binder, int localFieldId) {
mListener = new WeakListener<Observable>(binder, localFieldId, this);
}
@Override
public WeakListener<Observable> getListener() {
return mListener;
}
@Override
public void addListener(Observable target) {
target.addOnPropertyChangedCallback(this);
}
@Override
public void removeListener(Observable target) {
target.removeOnPropertyChangedCallback(this);
}
@Override
public void onPropertyChanged(Observable sender, int propertyId) {
ViewDataBinding binder = mListener.getBinder();
if (binder == null) {
return;
}
Observable obj = mListener.getTarget();
if (obj != sender) {
return; // notification from the wrong object?
}
binder.handleFieldChange(mListener.mLocalFieldId, sender, propertyId);
}
}
private static class WeakListListener extends ObservableList.OnListChangedCallback
implements ObservableReference<ObservableList> {
final WeakListener<ObservableList> mListener;
public WeakListListener(ViewDataBinding binder, int localFieldId) {
mListener = new WeakListener<ObservableList>(binder, localFieldId, this);
}
@Override
public WeakListener<ObservableList> getListener() {
return mListener;
}
@Override
public void addListener(ObservableList target) {
target.addOnListChangedCallback(this);
}
@Override
public void removeListener(ObservableList target) {
target.removeOnListChangedCallback(this);
}
@Override
public void onChanged(ObservableList sender) {
ViewDataBinding binder = mListener.getBinder();
if (binder == null) {
return;
}
ObservableList target = mListener.getTarget();
if (target != sender) {
return; // We expect notifications only from sender
}
binder.handleFieldChange(mListener.mLocalFieldId, target, 0);
}
@Override
public void onItemRangeChanged(ObservableList sender, int positionStart, int itemCount) {
onChanged(sender);
}
@Override
public void onItemRangeInserted(ObservableList sender, int positionStart, int itemCount) {
onChanged(sender);
}
@Override
public void onItemRangeMoved(ObservableList sender, int fromPosition, int toPosition,
int itemCount) {
onChanged(sender);
}
@Override
public void onItemRangeRemoved(ObservableList sender, int positionStart, int itemCount) {
onChanged(sender);
}
}
private static class WeakMapListener extends ObservableMap.OnMapChangedCallback
implements ObservableReference<ObservableMap> {
final WeakListener<ObservableMap> mListener;
public WeakMapListener(ViewDataBinding binder, int localFieldId) {
mListener = new WeakListener<ObservableMap>(binder, localFieldId, this);
}
@Override
public WeakListener<ObservableMap> getListener() {
return mListener;
}
@Override
public void addListener(ObservableMap target) {
target.addOnMapChangedCallback(this);
}
@Override
public void removeListener(ObservableMap target) {
target.removeOnMapChangedCallback(this);
}
@Override
public void onMapChanged(ObservableMap sender, Object key) {
ViewDataBinding binder = mListener.getBinder();
if (binder == null || sender != mListener.getTarget()) {
return;
}
binder.handleFieldChange(mListener.mLocalFieldId, sender, 0);
}
}
private interface CreateWeakListener {
WeakListener create(ViewDataBinding viewDataBinding, int localFieldId);
}
/**
* This class is used by generated subclasses of {@link ViewDataBinding} to track the
* included layouts contained in the bound layout. This class is an implementation
* detail of how binding expressions are mapped to Views after inflation.
* @hide
*/
protected static class IncludedLayouts {
public final String[][] layouts;
public final int[][] indexes;
public final int[][] layoutIds;
public IncludedLayouts(int bindingCount) {
layouts = new String[bindingCount][];
indexes = new int[bindingCount][];
layoutIds = new int[bindingCount][];
}
public void setIncludes(int index, String[] layouts, int[] indexes, int[] layoutIds) {
this.layouts[index] = layouts;
this.indexes[index] = indexes;
this.layoutIds[index] = layoutIds;
}
}
}