Java 类android.databinding.BaseObservable 实例源码

public AtomWatcher(BaseObservable... fields){
    for(BaseObservable field: fields){

        BaseObservable af = field;

        Observable.OnPropertyChangedCallback callback = new Observable.OnPropertyChangedCallback() {
            @Override
            public void onPropertyChanged(Observable sender, int propertyId) {
                run();
            }
        };

        field.addOnPropertyChangedCallback(callback);

        closables.add(new ClosableAction(()->{
            af.removeOnPropertyChangedCallback(callback);
        }));
    }
}

private TypeSpec createTypeSpec() {
    return TypeSpec.classBuilder(storeModel.getClassName().simpleName())
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addSuperinterface(storeModel.getInterfaceName())
            .superclass(TypeName.get(BaseObservable.class))
            .addFields(createFieldSpecs())
            .addMethod(createConstructor())
            .addMethod(createBuilderMethodSpec())
            .addMethods(createGetterMethodSpecs())
            .addMethod(createDispatchMethodSpec())
            .addType(new StoreBuilderClassGenerator(storeModel).createBuilderTypeSpec())
            .build();
}

public <T> AtomWatcher<T> watch(BaseObservable... fields){
    AtomWatcher<T> watcher = new AtomWatcher<T>(fields);
    register(watcher);
    return watcher;
}

public static void unbind(BaseObservable observable, Observable.OnPropertyChangedCallback callback) {
    if (null == observable || null == callback) {
        return;
    }
    observable.removeOnPropertyChangedCallback(callback);
}

public static <T> CinderArrayList<T> computeArrayList(OnComputeArrayListCallback<T> computeCallback, BaseObservable... observables) {
    CinderArrayList<T> cinderArrayList = new CinderArrayList<>();
    cinderArrayList.setObservableBehaviour(Cinder.observe(() -> computeCallback.onComputeChange(cinderArrayList), observables));
    return cinderArrayList;
}

public static <K, V> CinderArrayMap<K, V> computeArrayMap(OnComputeArrayMapCallback<K, V> computeCallback, BaseObservable... observables) {
    CinderArrayMap<K, V> cinderArrayMap = new CinderArrayMap<>();
    cinderArrayMap.setObservableBehaviour(Cinder.observe(() -> computeCallback.onComputeChange(cinderArrayMap), observables));
    return cinderArrayMap;
}

public static CinderBoolean computeBoolean(OnComputeBooleanCallback computeCallback, BaseObservable... observables) {
    CinderBoolean cinderBoolean = new CinderBoolean();
    cinderBoolean.setObservableBehaviour(Cinder.observe(() -> cinderBoolean.set(computeCallback.onComputeChange()), observables));
    return cinderBoolean;
}

public static CinderByte computeByte(OnComputeByteCallback computeCallback, BaseObservable... observables) {
    CinderByte cinderByte = new CinderByte();
    cinderByte.setObservableBehaviour(Cinder.observe(() -> cinderByte.set(computeCallback.onComputeChange()), observables));
    return cinderByte;
}

public static CinderChar computeChar(OnComputeCharCallback computeCallback, BaseObservable... observables) {
    CinderChar cinderChar = new CinderChar();
    cinderChar.setObservableBehaviour(Cinder.observe(() -> cinderChar.set(computeCallback.onComputeChange()), observables));
    return cinderChar;
}

public static CinderDouble computeDouble(OnComputeDoubleCallback computeCallback, BaseObservable... observables) {
    CinderDouble cinderDouble = new CinderDouble();
    cinderDouble.setObservableBehaviour(Cinder.observe(() -> cinderDouble.set(computeCallback.onComputeChange()), observables));
    return cinderDouble;
}

public static <T> CinderField<T> computeField(OnComputeFieldCallback<T> computeCallback, BaseObservable... observables) {
    CinderField<T> cinderField = new CinderField<>();
    cinderField.setObservableBehaviour(Cinder.observe(() -> cinderField.set(computeCallback.onComputeChange()), observables));
    return cinderField;
}

public static CinderFloat computeFloat(OnComputeFloatCallback computeCallback, BaseObservable... observables) {
    CinderFloat cinderFloat = new CinderFloat();
    cinderFloat.setObservableBehaviour(Cinder.observe(() -> cinderFloat.set(computeCallback.onComputeChange()), observables));
    return cinderFloat;
}

public static CinderInt computeInt(OnComputeIntCallback computeCallback, BaseObservable... observables) {
    CinderInt cinderInt = new CinderInt();
    cinderInt.setObservableBehaviour(Cinder.observe(() -> cinderInt.set(computeCallback.onComputeChange()), observables));
    return cinderInt;
}

public static CinderLong computeLong(OnComputeLongCallback computeCallback, BaseObservable... observables) {
    CinderLong cinderLong = new CinderLong();
    cinderLong.setObservableBehaviour(Cinder.observe(() -> cinderLong.set(computeCallback.onComputeChange()), observables));
    return cinderLong;
}

public static <T extends Parcelable> CinderParcelable<T> computeParcelable(OnComputeParcelableCallback<T> computeCallback, BaseObservable... observables) {
    CinderParcelable<T> cinderParcelable = new CinderParcelable<>();
    cinderParcelable.setObservableBehaviour(Cinder.observe(() -> cinderParcelable.set(computeCallback.onComputeChange()), observables));
    return cinderParcelable;
}

public static CinderShort computeShort(OnComputeShortCallback computeCallback, BaseObservable... observables) {
    CinderShort cinderShort = new CinderShort();
    cinderShort.setObservableBehaviour(Cinder.observe(() -> cinderShort.set(computeCallback.onComputeChange()), observables));
    return cinderShort;
}

CinderPair(BaseObservable observable,
           Observable.OnPropertyChangedCallback callback){
    this.observable = observable;
    this.callback = callback;
}

public BaseObservable getObservable(){
    return this.observable;
}