*@BindingAdapter("android:bufferType")
* public static void setBufferType(TextView view, TextView.BufferType bufferType) {
* view.setText(view.getText(), bufferType);
* }
* In the above example, when android:bufferType is used on a TextView, the method
* setBufferType is called.
* * It is also possible to take previously set values, if the old values are listed first: *
*@BindingAdapter("android:onLayoutChange")
* public static void setOnLayoutChangeListener(View view, View.OnLayoutChangeListener oldValue,
* View.OnLayoutChangeListener newValue) {
* if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
* if (oldValue != null) {
* view.removeOnLayoutChangeListener(oldValue);
* }
* if (newValue != null) {
* view.addOnLayoutChangeListener(newValue);
* }
* }
* }
* When a binding adapter may also take multiple attributes, it will only be called when all
* attributes associated with the binding adapter have binding expressions associated with them.
* This is useful when there are unusual interactions between attributes. For example:
*
*@BindingAdapter({"android:onClick", "android:clickable"})
* public static void setOnClick(View view, View.OnClickListener clickListener,
* boolean clickable) {
* view.setOnClickListener(clickListener);
* view.setClickable(clickable);
* }
* The order of the parameters must match the order of the attributes in values in the
* BindingAdapter.
* * A binding adapter may optionally take a class extending DataBindingComponent as the first * parameter as well. If it does, it will be passed the value passed in during binding, either * directly in the inflate method or indirectly, using the value from * {@link DataBindingUtil#getDefaultComponent()}. *
* If a binding adapter is an instance method, the generated DataBindingComponent will have * a getter to retrieve an instance of the BindingAdapter's class to use to call the method. */ @Target(ElementType.METHOD) public @interface BindingAdapter { /** * @return The attributes associated with this binding adapter. */ String[] value(); /** * Whether every attribute must be assigned a binding expression or if some * can be absent. When this is false, the BindingAdapter will be called * when at least one associated attribute has a binding expression. The attributes * for which there was no binding expression (even a normal XML value) will * cause the associated parameter receive the Java default value. Care must be * taken to ensure that a default value is not confused with a valid XML value. * * @return whether or not every attribute must be assigned a binding expression. The default * value is true. */ boolean requireAll() default true; } baseLibrary/src/main/java/android/databinding/BindingBuildInfo.java 0100644 0000000 0000000 00000002600 13027042270 024370 0 ustar 00 0000000 0000000 /* * Copyright (C) 2015 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 java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * @hide */ @Target({ElementType.TYPE}) @Retention(RetentionPolicy.SOURCE) public @interface BindingBuildInfo { String buildId(); String modulePackage(); String sdkRoot(); int minSdk(); /** * The folder that includes xml files which are exported by aapt or gradle plugin from layout files */ String layoutInfoDir(); /** * The file to which the list of generated classes should be exported */ String exportClassListTo(); boolean isLibrary(); boolean enableDebugLogs() default false; boolean printEncodedError() default false; } baseLibrary/src/main/java/android/databinding/BindingConversion.java 0100644 0000000 0000000 00000002204 13027042270 024642 0 ustar 00 0000000 0000000 /* * Copyright (C) 2015 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 java.lang.annotation.ElementType; import java.lang.annotation.Target; /** * Annotate methods that are used to automatically convert from the expression type to the value * used in the setter. The converter should take one parameter, the expression type, and the * return value should be the target value type used in the setter. Converters are used * whenever they can be applied and are not specific to any attribute. */ @Target({ElementType.METHOD}) public @interface BindingConversion { } baseLibrary/src/main/java/android/databinding/BindingMethod.java 0100644 0000000 0000000 00000002574 13027042270 023747 0 ustar 00 0000000 0000000 /* * Copyright (C) 2015 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 java.lang.annotation.ElementType; import java.lang.annotation.Target; /** * Used within an {@link BindingMethods} annotation to describe a renaming of an attribute to * the setter used to set that attribute. By default, an attribute attr will be associated with * setter setAttr. */ @Target(ElementType.ANNOTATION_TYPE) public @interface BindingMethod { /** * @return the View Class that the attribute is associated with. */ Class type(); /** * @return The attribute to rename. Use android: namespace for all android attributes or * no namespace for application attributes. */ String attribute(); /** * @return The method to call to set the attribute value. */ String method(); } baseLibrary/src/main/java/android/databinding/BindingMethods.java 0100644 0000000 0000000 00000002043 13027042270 024121 0 ustar 00 0000000 0000000 /* * Copyright (C) 2015 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 java.lang.annotation.ElementType; import java.lang.annotation.Target; /** * Used to enumerate attribute-to-setter renaming. By default, an attribute is associated with * setAttribute setter. If there is a simple rename, enumerate them in an array of * {@link BindingMethod} annotations in the value. */ @Target({ElementType.TYPE}) public @interface BindingMethods { BindingMethod[] value(); } baseLibrary/src/main/java/android/databinding/CallbackRegistry.java 0100644 0000000 0000000 00000042074 13027042270 024460 0 ustar 00 0000000 0000000 /* * 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 java.util.ArrayList; import java.util.List; /** * A utility for storing and notifying callbacks. This class supports reentrant modification * of the callbacks during notification without adversely disrupting notifications. * A common pattern for callbacks is to receive a notification and then remove * themselves. This class handles this behavior with constant memory under * most circumstances. * *
A subclass of {@link CallbackRegistry.NotifierCallback} must be passed to * the constructor to define how notifications should be called. That implementation * does the actual notification on the listener. It is typically a static instance * that can be reused for all similar CallbackRegistries.
* *This class supports only callbacks with at most three parameters.
* Typically, these are the notification originator and a parameter, with another to
* indicate which method to call, but these may be used as required. If more than
* three parameters are required or primitive types other than the single int provided
* must be used, A should be some kind of containing structure that
* the subclass may reuse between notifications.
removed.
*
* @param sender The originator. This is an opaque parameter passed to
* {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)}
* @param arg An opaque parameter passed to
* {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)}
* @param arg2 An opaque parameter passed to
* {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)}
*/
private void notifyFirst64(T sender, int arg, A arg2) {
final int maxNotified = Math.min(Long.SIZE, mCallbacks.size());
notifyCallbacks(sender, arg, arg2, 0, maxNotified, mFirst64Removed);
}
/**
* Notify all callbacks using a recursive algorithm to avoid allocating on the heap.
* This part captures the callbacks beyond Long.SIZE that have no bits allocated for
* removal before it recurses into {@link #notifyRemainder(Object, int, A, int)}.
*
* Recursion is used to avoid allocating temporary state on the heap.
* * @param sender The originator. This is an opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param arg An opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param arg2 An opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} */ private void notifyRecurse(T sender, int arg, A arg2) { final int callbackCount = mCallbacks.size(); final int remainderIndex = mRemainderRemoved == null ? -1 : mRemainderRemoved.length - 1; // Now we've got all callbakcs that have no mRemainderRemoved value, so notify the // others. notifyRemainder(sender, arg, arg2, remainderIndex); // notifyRemainder notifies all at maxIndex, so we'd normally start at maxIndex + 1 // However, we must also keep track of those in mFirst64Removed, so we add 2 instead: final int startCallbackIndex = (remainderIndex + 2) * Long.SIZE; // The remaining have no bit set notifyCallbacks(sender, arg, arg2, startCallbackIndex, callbackCount, 0); } /** * Notify callbacks that have mRemainderRemoved bits set for remainderIndex. If * remainderIndex is -1, the first 64 will be notified instead. * * @param sender The originator. This is an opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param arg An opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param arg2 An opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param remainderIndex The index into mRemainderRemoved that should be notified. */ private void notifyRemainder(T sender, int arg, A arg2, int remainderIndex) { if (remainderIndex < 0) { notifyFirst64(sender, arg, arg2); } else { final long bits = mRemainderRemoved[remainderIndex]; final int startIndex = (remainderIndex + 1) * Long.SIZE; final int endIndex = Math.min(mCallbacks.size(), startIndex + Long.SIZE); notifyRemainder(sender, arg, arg2, remainderIndex - 1); notifyCallbacks(sender, arg, arg2, startIndex, endIndex, bits); } } /** * Notify callbacks from startIndex to endIndex, using bits as the bit status * for whether they have been removed or not. bits should be from mRemainderRemoved or * mFirst64Removed. bits set to 0 indicates that all callbacks from startIndex to * endIndex should be notified. * * @param sender The originator. This is an opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param arg An opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param arg2 An opaque parameter passed to * {@link CallbackRegistry.NotifierCallback#onNotifyCallback(Object, Object, int, Object)} * @param startIndex The index into the mCallbacks to start notifying. * @param endIndex One past the last index into mCallbacks to notify. * @param bits A bit field indicating which callbacks have been removed and shouldn't * be notified. */ private void notifyCallbacks(T sender, int arg, A arg2, final int startIndex, final int endIndex, final long bits) { long bitMask = 1; for (int i = startIndex; i < endIndex; i++) { if ((bits & bitMask) == 0) { mNotifier.onNotifyCallback(mCallbacks.get(i), sender, arg, arg2); } bitMask <<= 1; } } /** * Add a callback to be notified. If the callback is already in the list, another won't * be added. This does not affect current notifications. * @param callback The callback to add. */ public synchronized void add(C callback) { if (callback == null) { throw new IllegalArgumentException("callback cannot be null"); } int index = mCallbacks.lastIndexOf(callback); if (index < 0 || isRemoved(index)) { mCallbacks.add(callback); } } /** * Returns true if the callback at index has been marked for removal. * * @param index The index into mCallbacks to check. * @return true if the callback at index has been marked for removal. */ private boolean isRemoved(int index) { if (index < Long.SIZE) { // It is in the first 64 callbacks, just check the bit. final long bitMask = 1L << index; return (mFirst64Removed & bitMask) != 0; } else if (mRemainderRemoved == null) { // It is after the first 64 callbacks, but nothing else was marked for removal. return false; } else { final int maskIndex = (index / Long.SIZE) - 1; if (maskIndex >= mRemainderRemoved.length) { // There are some items in mRemainderRemoved, but nothing at the given index. return false; } else { // There is something marked for removal, so we have to check the bit. final long bits = mRemainderRemoved[maskIndex]; final long bitMask = 1L << (index % Long.SIZE); return (bits & bitMask) != 0; } } } /** * Removes callbacks from startIndex to startIndex + Long.SIZE, based * on the bits set in removed. * * @param startIndex The index into the mCallbacks to start removing callbacks. * @param removed The bits indicating removal, where each bit is set for one callback * to be removed. */ private void removeRemovedCallbacks(int startIndex, long removed) { // The naive approach should be fine. There may be a better bit-twiddling approach. final int endIndex = startIndex + Long.SIZE; long bitMask = 1L << (Long.SIZE - 1); for (int i = endIndex - 1; i >= startIndex; i--) { if ((removed & bitMask) != 0) { mCallbacks.remove(i); } bitMask >>>= 1; } } /** * Remove a callback. This callback won't be notified after this call completes. * * @param callback The callback to remove. */ public synchronized void remove(C callback) { if (mNotificationLevel == 0) { mCallbacks.remove(callback); } else { int index = mCallbacks.lastIndexOf(callback); if (index >= 0) { setRemovalBit(index); } } } private void setRemovalBit(int index) { if (index < Long.SIZE) { // It is in the first 64 callbacks, just check the bit. final long bitMask = 1L << index; mFirst64Removed |= bitMask; } else { final int remainderIndex = (index / Long.SIZE) - 1; if (mRemainderRemoved == null) { mRemainderRemoved = new long[mCallbacks.size() / Long.SIZE]; } else if (mRemainderRemoved.length < remainderIndex) { // need to make it bigger long[] newRemainders = new long[mCallbacks.size() / Long.SIZE]; System.arraycopy(mRemainderRemoved, 0, newRemainders, 0, mRemainderRemoved.length); mRemainderRemoved = newRemainders; } final long bitMask = 1L << (index % Long.SIZE); mRemainderRemoved[remainderIndex] |= bitMask; } } /** * Makes a copy of the registered callbacks and returns it. * * @return a copy of the registered callbacks. */ public synchronized ArrayListcallbacks to contain all callbacks in the CallbackRegistry.
*
* @param callbacks modified to contain all callbacks registered to receive events.
*/
public synchronized void copyCallbacks(List
* @InverseBindingAdapter(attribute = "android:text", event = "android:textAttrChanged")
* public static String captureTextValue(TextView view, CharSequence originalValue) {
* CharSequence newValue = view.getText();
* CharSequence oldValue = value.get();
* if (oldValue == null) {
* value.set(newValue);
* } else if (!contentEquals(newValue, oldValue)) {
* value.set(newValue);
* }
* }
*
*
* The default value for event is the attribute name suffixed with "AttrChanged". In the
* above example, the default value would have been android:textAttrChanged even
* if it wasn't provided.
*
* The event attribute is used to notify the data binding system that the value has changed. * The developer will typically create a {@link BindingAdapter} to assign the event. For example: *
*
* @BindingAdapter(value = {"android:beforeTextChanged", "android:onTextChanged",
* "android:afterTextChanged", "android:textAttrChanged"},
* requireAll = false)
* public static void setTextWatcher(TextView view, final BeforeTextChanged before,
* final OnTextChanged on, final AfterTextChanged after,
* final InverseBindingListener textAttrChanged) {
* TextWatcher newValue = new TextWatcher() {
* ...
* @Override
* public void onTextChanged(CharSequence s, int start, int before, int count) {
* if (on != null) {
* on.onTextChanged(s, start, before, count);
* }
* if (textAttrChanged != null) {
* textAttrChanged.onChange();
* }
* }
* }
* TextWatcher oldValue = ListenerUtil.trackListener(view, newValue, R.id.textWatcher);
* if (oldValue != null) {
* view.removeTextChangedListener(oldValue);
* }
* view.addTextChangedListener(newValue);
* }
*
*
* Like BindingAdapters, InverseBindingAdapter methods may also take
* {@link DataBindingComponent} as the first parameter and may be an instance method with the
* instance retrieved from the DataBindingComponent.
*
* @see DataBindingUtil#setDefaultComponent(DataBindingComponent)
* @see InverseBindingMethod
*/
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface InverseBindingAdapter {
/**
* The attribute that the value is to be retrieved for.
*/
String attribute();
/**
* The event used to trigger changes. This is used in {@link BindingAdapter}s for the
* data binding system to set the event listener when two-way binding is used.
*/
String event() default "";
}
baseLibrary/src/main/java/android/databinding/InverseBindingListener.java 0100644 0000000 0000000 00000006110 13027042270 025636 0 ustar 00 0000000 0000000 /*
* Copyright (C) 2015 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;
/**
* A listener implemented by all two-way bindings to be notified when a triggering change happens.
* For example, when there is a two-way binding for android:text, an implementation of
* InverseBindingListener will be generated in the layout's binding class.
*
* private static class InverseListenerTextView implements InverseBindingListener {
* @Override
* public void onChange() {
* mObj.setTextValue(mTextView.getText());
* }
* }
*
*
* A {@link BindingAdapter} should be used to assign the event listener.
* For example, android:onTextChanged will need to trigger the event listener
* for the android:text attribute.
*
* @InverseBindingAdapter(attribute = "android:text", event = "android:textAttrChanged")
* public static void captureTextValue(TextView view, ObservableField<CharSequence> value) {
* CharSequence newValue = view.getText();
* CharSequence oldValue = value.get();
* if (oldValue == null) {
* value.set(newValue);
* } else if (!contentEquals(newValue, oldValue)) {
* value.set(newValue);
* }
* }
* @BindingAdapter(value = {"android:beforeTextChanged", "android:onTextChanged",
* "android:afterTextChanged", "android:textAttrChanged"},
* requireAll = false)
* public static void setTextWatcher(TextView view, final BeforeTextChanged before,
* final OnTextChanged on, final AfterTextChanged after,
* final InverseBindingListener textAttrChanged) {
* TextWatcher newValue = new TextWatcher() {
* ...
* @Override
* public void onTextChanged(CharSequence s, int start, int before, int count) {
* if (on != null) {
* on.onTextChanged(s, start, before, count);
* }
* if (textAttrChanged != null) {
* textAttrChanged.onChange();
* }
* }
* }
* TextWatcher oldValue = ListenerUtil.trackListener(view, newValue, R.id.textWatcher);
* if (oldValue != null) {
* view.removeTextChangedListener(oldValue);
* }
* view.addTextChangedListener(newValue);
* }
*
*/
public interface InverseBindingListener {
/**
* Notifies the data binding system that the attribute value has changed.
*/
void onChange();
}
baseLibrary/src/main/java/android/databinding/InverseBindingMethod.java 0100644 0000000 0000000 00000007326 13027042270 025303 0 ustar 00 0000000 0000000 /*
* Copyright (C) 2015 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 java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
* InverseBindingMethod is used to identify how to listen for changes to a View property and which
* getter method to call. InverseBindingMethod should be associated with any class as part of
* {@link InverseBindingMethods}.
* *
* @InverseBindingMethods({@InverseBindingMethod(
* type = android.widget.TextView.class,
* attribute = "android:text",
* event = "android:textAttrChanged",
* method = "getText")})
* public class MyTextViewBindingAdapters { ... }
*
*
* method is optional. If it isn't provided, the attribute name is used to
* find the method name, either prefixing with "is" or "get". For the attribute
* android:text, data binding will search for a
* public CharSequence getText() method on {@link android.widget.TextView}.
*
* event is optional. If it isn't provided, the event name is assigned the
* attribute name suffixed with AttrChanged. For the android:text
* attribute, the default event name would be android:textAttrChanged. The event
* should be set using a {@link BindingAdapter}. For example:
*
* @BindingAdapter(value = {"android:beforeTextChanged", "android:onTextChanged",
* "android:afterTextChanged", "android:textAttrChanged"},
* requireAll = false)
* public static void setTextWatcher(TextView view, final BeforeTextChanged before,
* final OnTextChanged on, final AfterTextChanged after,
* final InverseBindingListener textAttrChanged) {
* TextWatcher newValue = new TextWatcher() {
* ...
* @Override
* public void onTextChanged(CharSequence s, int start, int before, int count) {
* if (on != null) {
* on.onTextChanged(s, start, before, count);
* }
* if (textAttrChanged != null) {
* textAttrChanged.onChange();
* }
* }
* }
* TextWatcher oldValue = ListenerUtil.trackListener(view, newValue, R.id.textWatcher);
* if (oldValue != null) {
* view.removeTextChangedListener(oldValue);
* }
* view.addTextChangedListener(newValue);
* }
*
*
* @see InverseBindingAdapter
* @see InverseBindingListener
*/
@Target(ElementType.ANNOTATION_TYPE)
public @interface InverseBindingMethod {
/**
* The View type that is associated with the attribute.
*/
Class type();
/**
* The attribute that supports two-way binding.
*/
String attribute();
/**
* The event used to notify the data binding system that the attribute value has changed.
* Defaults to attribute() + "AttrChanged"
*/
String event() default "";
/**
* The getter method to retrieve the attribute value from the View. The default is
* the bean method name based on the attribute name.
*/
String method() default "";
}
baseLibrary/src/main/java/android/databinding/InverseBindingMethods.java 0100644 0000000 0000000 00000001704 13027042270 025460 0 ustar 00 0000000 0000000 /*
* Copyright (C) 2015 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 java.lang.annotation.ElementType;
import java.lang.annotation.Target;
/**
* Used to enumerate attribute, getter, and event association. The value is an array of
* {@link InverseBindingMethod}s.
*/
@Target(ElementType.TYPE)
public @interface InverseBindingMethods {
InverseBindingMethod[] value();
}
baseLibrary/src/main/java/android/databinding/Observable.java 0100644 0000000 0000000 00000005010 13027042270 023304 0 ustar 00 0000000 0000000 /*
* 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;
/**
* Observable classes provide a way in which data bound UI can be notified of changes.
* {@link ObservableList} and {@link ObservableMap} also provide the ability to notify when
* changes occur. ObservableField, ObservableParcelable, ObservableBoolean, ObservableByte,
* ObservableShort, ObservableInt, ObservableLong, ObservableFloat, and ObservableDouble provide
* a means by which properties may be notified without implementing Observable.
* * An Observable object should notify the {@link OnPropertyChangedCallback} whenever * an observed property of the class changes. *
* The getter for an observable property should be annotated with {@link Bindable}. *
* Convenience class BaseObservable implements this interface and PropertyChangeRegistry * can help classes that don't extend BaseObservable to implement the listener registry. */ public interface Observable { /** * Adds a callback to listen for changes to the Observable. * @param callback The callback to start listening. */ void addOnPropertyChangedCallback(OnPropertyChangedCallback callback); /** * Removes a callback from those listening for changes. * @param callback The callback that should stop listening. */ void removeOnPropertyChangedCallback(OnPropertyChangedCallback callback); /** * The callback that is called by Observable when an observable property has changed. */ abstract class OnPropertyChangedCallback { /** * Called by an Observable whenever an observable property changes. * @param sender The Observable that is changing. * @param propertyId The BR identifier of the property that has changed. The getter * for this property should be annotated with {@link Bindable}. */ public abstract void onPropertyChanged(Observable sender, int propertyId); } } baseLibrary/src/main/java/android/databinding/ObservableList.java 0100644 0000000 0000000 00000007070 13027042270 024150 0 ustar 00 0000000 0000000 /* * Copyright (C) 2015 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 java.util.List; /** * A {@link List} that notifies when changes are made. An ObservableList bound to the UI * will keep the it up-to-date when changes occur. *
* The ObservableList must notify its callbacks whenever a change to the list occurs, using * {@link OnListChangedCallback}. *
* ObservableArrayList implements ObservableList with an underlying ArrayList.
* ListChangeRegistry can help in maintaining the callbacks of other implementations.
*
* @see Observable
* @see ObservableMap
*/
public interface ObservableList
* Implementers must call {@link OnMapChangedCallback#onMapChanged(ObservableMap, Object)} whenever
* an item is added, changed, or removed.
*
* ObservableArrayMap is a convenient implementation of ObservableMap.
* MapChangeRegistry may help other implementations manage the callbacks.
* @see Observable
* @see ObservableList
*/
public interface ObservableMap
* This should be the minimum value among the dependencies of this binding. For now, we only
* check the setter.
*/
public int getMinApi() {
return getSetterCall().getMinApi();
}
public String getName() {
return mName;
}
public Expr getExpr() {
return mExpr;
}
private static boolean isViewStubAttribute(String name) {
return ("android:inflatedId".equals(name) ||
"android:layout".equals(name) ||
"android:visibility".equals(name) ||
"android:layoutInflater".equals(name));
}
private static boolean isListenerAttribute(String name) {
return ("android:onInflate".equals(name) ||
"android:onInflateListener".equals(name));
}
private static class ViewStubSetterCall extends SetterCall {
private final String mName;
public ViewStubSetterCall(String name) {
mName = name.substring(name.lastIndexOf(':') + 1);
}
@Override
protected String toJavaInternal(String componentExpression, String viewExpression,
String converted) {
return "if (" + viewExpression + ".isInflated()) " + viewExpression +
".getBinding().setVariable(BR." + mName + ", " + converted + ")";
}
@Override
protected String toJavaInternal(String componentExpression, String viewExpression,
String oldValue, String converted) {
return null;
}
@Override
public int getMinApi() {
return 0;
}
@Override
public boolean requiresOldValue() {
return false;
}
@Override
public ModelClass[] getParameterTypes() {
return new ModelClass[] {
ModelAnalyzer.getInstance().findClass(Object.class)
};
}
@Override
public String getBindingAdapterInstanceClass() {
return null;
}
}
private static class ViewStubDirectCall extends SetterCall {
private final SetterCall mWrappedCall;
public ViewStubDirectCall(String name, ModelClass viewType, ModelClass resolvedType,
Map
* We traverse all bindings and ask SetterStore to figure out if any can be combined.
* When N bindings are combined, they are demoted from being a binding expression and a new
* ArgList expression is added as the new binding expression that depends on others.
*/
public void resolveMultiSetters() {
L.d("resolving multi setters for %s", getId());
final SetterStore setterStore = SetterStore.get(ModelAnalyzer.getInstance());
final String[] attributes = new String[mBindings.size()];
final ModelClass[] types = new ModelClass[mBindings.size()];
for (int i = 0; i < mBindings.size(); i ++) {
Binding binding = mBindings.get(i);
try {
Scope.enter(binding);
attributes[i] = binding.getName();
types[i] = binding.getExpr().getResolvedType();
} finally {
Scope.exit();
}
}
final List
* The model keeps track of these wrappers and at the end data-binding generates all of them.
* These are stripped from library projects and re-generated.
*/
public class CallbackWrapper {
public static String SOURCE_ID = "sourceId";
public static String ARG_PREFIX = "callbackArg_";
public final ModelClass klass;
public final ModelMethod method;
public final String key;
private static final String PACKAGE = "android.databinding.generated.callback";
private static final String LISTENER_NAME = "Listener";
private String mClassName;
private String mListenerMethodName;
private boolean mInitialized;
public CallbackWrapper(ModelClass klass, ModelMethod method) {
this.klass = klass;
this.method = method;
this.key = uniqueKey(klass, method);
}
public void prepare(String className, String listenerMethodName) {
if (mInitialized) {
L.e("trying to initialize listener wrapper twice.");
}
mInitialized = true;
mClassName = className;
mListenerMethodName = listenerMethodName;
}
public String getPackage() {
return PACKAGE;
}
public String getClassName() {
Preconditions.check(mInitialized, "Listener wrapper is not initialized yet.");
return mClassName;
}
public String getListenerInterfaceName() {
return LISTENER_NAME;
}
public String getListenerMethodName() {
Preconditions.check(mInitialized, "Listener wrapper is not initialized yet.");
return mListenerMethodName;
}
public static String uniqueKey(ModelClass klass, ModelMethod method) {
String base = klass.getCanonicalName() + "#" + method.getName();
for (ModelClass param : method.getParameterTypes()) {
base += param + ",";
}
return base;
}
public String getCannonicalName() {
return getPackage() + "." + getClassName();
}
public String getCannonicalListenerName() {
return getPackage() + "." + getClassName() + "." + getListenerInterfaceName();
}
public String constructForIdentifier(int listenerId) {
return "new " + getCannonicalName() + "(this, " + listenerId + ")";
}
public int getMinApi() {
return Math.min(method.getMinApi(), klass.getMinApi());
}
}
compiler/src/main/java/android/databinding/tool/CompilerChef.java 0100644 0000000 0000000 00000022676 13027042270 024131 0 ustar 00 0000000 0000000 /*
* Copyright (C) 2015 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.tool;
import android.databinding.tool.reflection.InjectedClass;
import android.databinding.tool.reflection.InjectedMethod;
import android.databinding.tool.reflection.ModelAnalyzer;
import android.databinding.tool.reflection.ModelClass;
import android.databinding.tool.store.ResourceBundle;
import android.databinding.tool.util.L;
import android.databinding.tool.util.Preconditions;
import android.databinding.tool.writer.BRWriter;
import android.databinding.tool.writer.DataBinderWriter;
import android.databinding.tool.writer.DynamicUtilWriter;
import android.databinding.tool.writer.JavaFileWriter;
import java.util.HashMap;
import java.util.Set;
/**
* Chef class for compiler.
*
* Different build systems can initiate a version of this to handle their work
*/
public class CompilerChef {
private static final String[] VERSION_CODES = {
"BASE", // 1
"BASE_1_1", // 2
"CUPCAKE", // 3
"DONUT", // 4
"ECLAIR", // 5
"ECLAIRE_0_1", // 6
"ECLAIR_MR1", // 7
"FROYO", // 8
"GINGERBREAD", // 9
"GINGERBREAD_MR1", // 10
"HONEYCOMB", // 11
"HONEYCOMB_MR1", // 12
"HONEYCOMB_MR2", // 13
"ICE_CREAM_SANDWICH", // 14
"ICE_CREAM_SANDWICH_MR1",// 15
"JELLY_BEAN", // 16
"JELLY_BEAN_MR1", // 17
"JELLY_BEAN_MR2", // 18
"KITKAT", // 19
"KITKAT_WATCH", // 20
"LOLLIPOP", // 21
"LOLLIPOP_MR1", // 22
"M", // 23
};
private JavaFileWriter mFileWriter;
private ResourceBundle mResourceBundle;
private DataBinder mDataBinder;
private CompilerChef() {
}
public static CompilerChef createChef(ResourceBundle bundle, JavaFileWriter fileWriter) {
CompilerChef chef = new CompilerChef();
chef.mResourceBundle = bundle;
chef.mFileWriter = fileWriter;
chef.mResourceBundle.validateMultiResLayouts();
chef.pushClassesToAnalyzer();
chef.pushDynamicUtilToAnalyzer();
return chef;
}
public ResourceBundle getResourceBundle() {
return mResourceBundle;
}
public void ensureDataBinder() {
if (mDataBinder == null) {
mDataBinder = new DataBinder(mResourceBundle);
mDataBinder.setFileWriter(mFileWriter);
}
}
public boolean hasAnythingToGenerate() {
L.d("checking if we have anything to generate. bundle size: %s",
mResourceBundle == null ? -1 : mResourceBundle.getLayoutBundles().size());
return mResourceBundle != null && mResourceBundle.getLayoutBundles().size() > 0;
}
/**
* Injects ViewDataBinding subclasses to the ModelAnalyzer so that they can be
* analyzed prior to creation. This is useful for resolving variable setters and
* View fields during compilation.
*/
private void pushClassesToAnalyzer() {
ModelAnalyzer analyzer = ModelAnalyzer.getInstance();
for (String layoutName : mResourceBundle.getLayoutBundles().keySet()) {
ResourceBundle.LayoutFileBundle layoutFileBundle =
mResourceBundle.getLayoutBundles().get(layoutName).get(0);
final HashMap
* This should be the minimum value among the dependencies of this binding.
*/
public int getMinApi() {
final BindingGetterCall getterCall = getGetterCall();
return Math.max(getterCall.getMinApi(), getterCall.getEvent().getMinApi());
}
public BindingSetterCall getEventSetter() {
final BindingGetterCall getterCall = getGetterCall();
return getterCall.getEvent();
}
public String getName() {
return mName;
}
public String getEventAttribute() {
return getGetterCall().getEventAttribute();
}
public ExprModel getModel() {
if (mExpr != null) {
return mExpr.getModel();
}
return mChainedExpressions.get(0).getModel();
}
}
compiler/src/main/java/android/databinding/tool/LayoutBinder.java 0100644 0000000 0000000 00000032643 13027042270 024165 0 ustar 00 0000000 0000000 /*
* Copyright (C) 2015 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.tool;
import android.databinding.tool.expr.Dependency;
import android.databinding.tool.expr.Expr;
import android.databinding.tool.expr.ExprModel;
import android.databinding.tool.expr.IdentifierExpr;
import android.databinding.tool.processing.Scope;
import android.databinding.tool.processing.scopes.FileScopeProvider;
import android.databinding.tool.store.Location;
import android.databinding.tool.store.ResourceBundle;
import android.databinding.tool.store.ResourceBundle.BindingTargetBundle;
import android.databinding.tool.util.L;
import android.databinding.tool.util.Preconditions;
import android.databinding.tool.writer.LayoutBinderWriter;
import android.databinding.tool.writer.LayoutBinderWriterKt;
import com.android.annotations.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
/**
* Keeps all information about the bindings per layout file
*/
public class LayoutBinder implements FileScopeProvider {
private static final Comparator
* When it is detected, we create a new binding with this argument list expression and merge N
* bindings into a new one so that rest of the code generation logic works as expected.
*/
public class ArgListExpr extends Expr {
private int mId;
public ArgListExpr(int id, Iterable constructDependencies() {
return Collections.emptyList();
}
@Override
protected KCode generateCode() {
return new KCode(CallbackWrapper.ARG_PREFIX + mArgIndex);
}
@Override
protected String computeUniqueKey() {
return CallbackWrapper.ARG_PREFIX + mArgIndex;
}
@Override
public String getInvertibleError() {
return "Callback arguments cannot be inverted";
}
public String getName() {
return mName;
}
@Override
public Expr cloneToModel(ExprModel model) {
return new CallbackArgExpr(mArgIndex, mName);
}
}
compiler/src/main/java/android/databinding/tool/expr/CallbackExprModel.java 0100644 0000000 0000000 00000010542 13027042270 026050 0 ustar 00 0000000 0000000 /*
* Copyright (C) 2016 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.tool.expr;
import android.databinding.tool.processing.ErrorMessages;
import android.databinding.tool.processing.Scope;
import android.databinding.tool.store.Location;
import android.databinding.tool.util.L;
import android.databinding.tool.util.Preconditions;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* Callbacks are evaluated when event happens, not when execute pending is run. To separate their
* expressions, we provide a separate model for them that extends the main model. This allows them
* to introduce their own variables etc. without mixing them with other expressions.
*/
public class CallbackExprModel extends ExprModel {
// used for imports and other stuff.
final ExprModel mOriginal;
final List