如何格式化ObservableField（double）DataBinding？

Question

So, I have the very simple problem, that I cannot seem to format a double coming from an ObservableField in a data binding. I have the following layout:

android:text='@{String.format("%.2f€", transaction.value)}'

and here the definition of transaction.value:

public final ObservableField<Double> value = new ObservableField<>();

I always get this error:

java.util.IllegalFormatConversionException: f != android.databinding.ObservableField

I get the same issue if I use an ObservableDouble. The only way to avoid this seems to be if I call transaction.value.get() in the binding, but I was under the impression that get/set can be omitted here, as I am successfully doing eg with an ObservableField<Date> .

I am targeting Sdk 26 with with buildTools 26.0.2.

Update 1

I tried the same thing now with my previous setup, and it worked, just as I remembered. So I pinpointed it to the Gradle version change from 2.3.1 to 3.0.1 (even when I put in target/compile Sdk 26 and buildToolsVersion 26.0.2 with Gradle 2.3.1 it works).

As @dominicoder pointed out to look into the generated data bindings, here is the difference, explaining the problem:

Gradle 2.3.1:

android.databinding.ObservableField<java.lang.Double>transactionValue=null;
java.lang.Double transactionValueGet=null;
....
if(transaction!=null){
    // read transaction.value
    transactionValue=transaction.value;
}
updateRegistration(3,transactionValue);
if(transactionValue!=null){
    // read transaction.value.get()
    transactionValueGet=transactionValue.get();
}
// read String.format("%.2f€", transaction.value.get())
stringFormatJavaLangString2fTransactionValue=java.lang.String.format("%.2f€",transactionValueGet);

Gradle 3.0.1:

android.databinding.ObservableField<java.lang.Double> transactionValue = null;
// NO transactionValueGet field !!!
....
if(transaction!=null){
    // read transaction.value
    transactionValue=transaction.value;
}
updateRegistration(3,transactionValue);
// read String.format("%.2f€", transaction.value)
stringFormatJavaLangString2fTransactionValue=java.lang.String.format("%.2f€",transactionValue);

So - it looks like this is a bug introduced in that version update (to be safe, I created a completely new project with a similar setting, a TextView having its text bound to an ObservableField<Double> using String.format() ). Or maybe it is intended behavior, but I really wouldn't understand the purpose of that kind ob breaking change.

Update 2

Currently the problem is filed in the Android issue tracker

Answer 1

The Problem

Check the databinding generated java file for your layout. You will find something like this:

android.databinding.ObservableField<java.lang.Double> transactionValue = null;
// read String.format("%.2f€", accountViewModel.test)
stringFormatJavaLangString2fAccountViewModelTest = java.lang.String.format("%.2f€", transactionValue);

You can see that it's using the observable field literally and I think it's because the signature of String.format is (String string, Object args...) . Because the observable field is an Object it can be used as is, so the code generator does not try to "get" the double value instead.

The Date formatting example works because the format method has a signature of (Date date) . Thus, the code generator realizes that the signature doesn't match, but the observable type does, so it "get"s it for you and you'll see something like this:

java.util.Date transactionDateGet = null;
// read transaction.date.get()
transactionDateGet = transactionDate.get();

androidTextFormatDateFormatGetDateFormatContextFormatTransactionDate =
    android.text.format.DateFormat.getDateFormat(
        getRoot().getContext()).format(transactionDateGet);

The Solution

As you already indicated, the easiest thing to do is just manually call .get() in your binding. However, I'd recommend avoiding doing logic in your XML, as @elmorabea indicated. Instead, I'd suggest using a view model that encapsulates the display logic:

public class TransactionViewModel {
    private final Transaction mTransaction;

    public TransactionViewModel(@NonNull Transaction transaction) {
        mTransaction = transaction;
    }

    @Bindable
    public String getTransactionValueText() {
        return String.format("%.2f€", transaction.getValue());
    }
}

Then you have something like this:

android:text='@{viewModel.transactionValueText}'

This is more work as you have to have an extra class for each layout file; you'd have to move your observable fields from your models to the viewmodels; and you'd have to make your view model obvserve the model to propagate the changes up the to view, but the separation of concerns makes it far easier to update, extend, reuse, and maintain in the long run.

Hope that helps!