public class

ObservableFloat

extends androidx.databinding.BaseObservableField

implements java.io.Serializable

 java.lang.Object

androidx.databinding.BaseObservable

↳androidx.databinding.BaseObservableField

↳androidx.databinding.ObservableFloat

Gradle dependencies

compile group: 'androidx.databinding', name: 'library', version: '3.2.0-alpha11'

  • groupId: androidx.databinding
  • artifactId: library
  • version: 3.2.0-alpha11

Artifact androidx.databinding:library:3.2.0-alpha11 it located at Google repository (https://maven.google.com/)

Androidx class mapping:

androidx.databinding.ObservableFloat android.databinding.ObservableFloat

Overview

An observable class that holds a primitive float.

Observable field classes may be used instead of creating an Observable object. It can also create a calculated field, depending on other fields:

public class MyDataObject {
     public final ObservableFloat temperatureC = new ObservableFloat();
     public final ObservableFloat temperatureF = new ObservableFloat(temperatureC) {
         @Override
         public float get() { return (temperatureC.get() * 9 / 5) + 32; }
     };
 }
Fields of this type should be declared final because bindings only detect changes in the field's value, not of the field itself.

This class is parcelable and serializable but callbacks are ignored when the object is parcelled / serialized. Unless you add custom callbacks, this will not be an issue because data binding framework always re-registers callbacks when the view is bound. A parceled ObservableField will lose its dependencies.

Summary

Fields
public static final <any>CREATOR

Constructors
publicObservableFloat()

Creates an ObservableFloat with the initial value of 0f.

publicObservableFloat(float value)

Creates an ObservableFloat with the given initial value.

publicObservableFloat(Observable dependencies[])

Creates an ObservableFloat that depends on dependencies.

Methods
public intdescribeContents()

public floatget()

public voidset(float value)

Set the stored value.

public voidwriteToParcel(Parcel dest, int flags)

from BaseObservableaddOnPropertyChangedCallback, notifyChange, notifyPropertyChanged, removeOnPropertyChangedCallback
from java.lang.Objectclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Fields

public static final <any> CREATOR

Constructors

public ObservableFloat(float value)

Creates an ObservableFloat with the given initial value.

Parameters:

value: the initial value for the ObservableFloat

public ObservableFloat()

Creates an ObservableFloat with the initial value of 0f.

public ObservableFloat(Observable dependencies[])

Creates an ObservableFloat that depends on dependencies. Typically, ObservableFields are passed as dependencies. When any dependency notifies changes, this ObservableFloat also notifies a change.

Parameters:

dependencies: The Observables that this ObservableFloat depends on.

Methods

public float get()

Returns:

the stored value.

public void set(float value)

Set the stored value.

Parameters:

value: The new value

public int describeContents()

public void writeToParcel(Parcel dest, int flags)

Source

/*
 * 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 androidx.databinding;

import android.os.Parcel;
import android.os.Parcelable;

import java.io.Serializable;

/**
 * An observable class that holds a primitive float.
 * <p>
 * Observable field classes may be used instead of creating an Observable object. It can also
 * create a calculated field, depending on other fields:
 * <pre><code>public class MyDataObject {
 *     public final ObservableFloat temperatureC = new ObservableFloat();
 *     public final ObservableFloat temperatureF = new ObservableFloat(temperatureC) {
 *         &#64;Override
 *         public float get() { return (temperatureC.get() * 9 / 5) + 32; }
 *     };
 * }</code></pre>
 * Fields of this type should be declared final because bindings only detect changes in the
 * field's value, not of the field itself.
 * <p>
 * This class is parcelable and serializable but callbacks are ignored when the object is
 * parcelled / serialized. Unless you add custom callbacks, this will not be an issue because
 * data binding framework always re-registers callbacks when the view is bound. A parceled
 * ObservableField will lose its dependencies.
 */
public class ObservableFloat extends BaseObservableField implements Parcelable, Serializable {
    static final long serialVersionUID = 1L;
    private float mValue;

    /**
     * Creates an ObservableFloat with the given initial value.
     *
     * @param value the initial value for the ObservableFloat
     */
    public ObservableFloat(float value) {
        mValue = value;
    }

    /**
     * Creates an ObservableFloat with the initial value of <code>0f</code>.
     */
    public ObservableFloat() {
    }

    /**
     * Creates an ObservableFloat that depends on {@code dependencies}. Typically,
     * {@link ObservableField}s are passed as dependencies. When any dependency
     * notifies changes, this ObservableFloat also notifies a change.
     *
     * @param dependencies The Observables that this ObservableFloat depends on.
     */
    public ObservableFloat(Observable... dependencies) {
        super(dependencies);
    }

    /**
     * @return the stored value.
     */
    public float get() {
        return mValue;
    }

    /**
     * Set the stored value.
     *
     * @param value The new value
     */
    public void set(float value) {
        if (value != mValue) {
            mValue = value;
            notifyChange();
        }
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeFloat(mValue);
    }

    public static final Parcelable.Creator<ObservableFloat> CREATOR
            = new Parcelable.Creator<ObservableFloat>() {

        @Override
        public ObservableFloat createFromParcel(Parcel source) {
            return new ObservableFloat(source.readFloat());
        }

        @Override
        public ObservableFloat[] newArray(int size) {
            return new ObservableFloat[size];
        }
    };
}