Develop Reference

How to use zero quantity case in Android quantity strings (plurals)?

I am trying to use the getQuantityString method in Resources to retrieve Quantity Strings based on android developer guidelines Quantity String in my Kotlin application.
One and the other case is ok, but zero is not working.
This is my code.
// text
txtNewProfileCount.text = resources.getQuantityString(
R.plurals.shortlists_profile_count,
filteredCandidateVMList.size,
filteredCandidateVMList.size
)
// plurals code
<plurals name="shortlists_profile_count">
<item quantity="zero">Sorry, there are no new profiles in your various shortlists</item>
<item quantity="one">Please review the new profile in your various shortlists</item>
<item quantity="other">Please review the %1$d new profiles in your various shortlists</item>
</plurals>
In case the quantity is one and other, the result is correct.
But in the zero cases, the result is Please review the 0 new profiles in your various shortlists.
This isn't the result I want.
How to solve when the quantity is zero?

The zero case is never used in English. English uses only one and other. Plural resources are intended only for grammatically unique constructs of specific languages. This is explained in the documentation:
The selection of which string to use is made solely based on
grammatical necessity. In English, a string for zero is ignored even
if the quantity is 0, because 0 isn't grammatically different from 2,
or any other number except 1 ("zero books", "one book", "two books",
and so on).
So you have to manually select a separate String resource using an if statement in your code.

Android Plurals is not support zero case now.
So you need to make your own function for this.
Here is one example.
fun getQuantityString(resources:Resources, resId:Int, quantity:Int, zeroResId:Int):String {
if (quantity == 0) {
return resources.getString(zeroResId)
} else {
return resources.getQuantityString(resId, quantity, quantity)
}
}

Android Plurals for float values

I would like to use plurals for my Android project.
However, the values I provide can be float values.
So for instance, when setting 1.5 stars, I want this to understand, it's not 1 star but 1.5 stars.
<plurals name="stars">
<item quantity="one">%d star</item>
<item quantity="other">%d stars</item>
</plurals>
However, the Android system seems to use integer values (%d) only.
The method looks like this:
String getQuantityString(#PluralsRes int id, int quantity, Object... formatArgs)
where quantity is defined as Int.
Is there any solution for this?

After doing further research, it appears there is no good solution for this.
As also seen in the other answers, they always require a lot of "manual processing" to it requiring no different workflow than creating separate string resources.
The general suggestion seems to be rounding / processing the float values manually (e.g checking whether the float value matches 1.0) and then using apropriate Int values for the plurals call.
But aside from not really using plurals then this comes with the problem of other languages (e.g. I have no clue if 1.5 stars would also be plural in another language as it is in English) and thus these rounding options may not apply universally.
So the answer is: there seems to be no perfect solution (meaning solved "automatically" by the Android system).
What I actually do therefore is to simply pick exceptions and use different Strings there.
So the (pseudo code) way of doing currently looks like
// optionally wrap different languages around
// if language == English
when (amountStars) {
is 1.0 -> getString(R.string.stars_singular, 1)
... ->
else -> getString(R.string.stars_plural, amountStars)
}
// if language == Chinese ...
where additional cases have to be "hard coded". So for example you have to decide whether 0 means
"0 stars" (plural string) or
"no star" (singular string)
But there seems no real benefit of using plurals over separate string resources with common placeholders. On the other hand this (at last for me) gives more flexibility for formatting options. For example, one may create a text like "1 star and a half" where it becomes singular again (even though numerically we would write 1.5 stars).

Don't use plurals for fractional numbers. Just stick with basic string resources and use a placeholder:
<string name="fractional_stars">%1$s stars</string>
getString(R.string.fractional_stars, 0.5F.toString())
or
<string name="fractional_stars">% stars</string>
getString(R.string.half_a_star).replace("%", 0.5F.toString())

Simply do this:
getQuantityString(R.plurals.stars, quantity > 1f ? 2 : 1, quantity):
And replace the %d in your strings with %f.

getQuantityString takes a quantity of type Int and Object... formatArgs
If you round the quantity to Int you would make sure that any value in 1.0 -> 1.99 is a single item and other than that is a plural
resources.getQuantityString(
R.plurals.products_left_in_stock_message_plural,
leftInStock.toInt(), leftInStock.toString()
)
So you only round it the quantity but pass the actually value as an argument
<plurals name="products_left_in_stock_message_plural">
<item quantity="one">Only one item is available from this product</item>
<item quantity="other">There are only %s item is available from this product</item>
</plurals>

In French, plural system treats 0 as "other" instead of "one"

In res/values/strings.xml, I have
<?xml version="1.0" encoding="utf-8"?>
<resources>
<plurals name="days_amount">
<item quantity="one">%d day EN</item>
<item quantity="other">%d days EN</item>
</plurals>
</resources>
And in res/values-fr/strings.xml, i have
<?xml version="1.0" encoding="utf-8"?>
<resources>
<plurals name="days_amount">
<item quantity="one">%d jour FR</item>
<item quantity="other">%d jours FR</item>
</plurals>
</resources>
With English locale res.getQuantityString(R.plurals.days_amount, 0, 0) returns:
"0 days"
which is okay per English rules (aka zero quantity <=> several quantities).
But with a French locale, it returns:
"0 jours"
which is NOT okay per French rules (aka zero quantity <=> singular quantity).
It should have returned "O jour"
French rules: http://www.unicode.org/cldr/charts/25/supplemental/language_plural_rules.html#fr
So, is this a bug, or am I doing something wrong ?

Your code looks correct to me. Here's why:
The Android documentation contains the text zero, one, two, few, many, and other, which exactly matches the wording of the Unicode language plural rules. This suggests that Android uses them.
These plural rules state that the French case of 0 books is handled by the one case.
Since the Android documentation doesn't explicitly mention the Unicode language plural rules, you should request clarification from the Android support.
Before you do that, you should consult this other question, where the French rules obviously worked.

Indeed your concern is right, in French amount 0 should be treated as 'one' instead of 'other'. The issue is in some Android APIs: API <= 16
So in case you want still to support API 16 just add an extra string key for the zero amount. Let's assume you have:
<plurals name="label_message_reminder_text">
<item quantity="other">Vous avez %1$s nouveaux messages</item>
<item quantity="one">Vous avez %1$s nouveau message</item>
</plurals>
Just add an extra string:
<string name="label_message_reminder_text_zero">Vous avez %1$s nouveau message</string>
And then when retrieving plurals can do something like:
String newMessagesText = getMyString(context, resourceId, amount);
messageTextView.setText(String.format(newMessagesText, amount));
And you can have a method to do the getMyString():
public String getMyString(Context context, int resourceId, int amount){
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.JELLY_BEAN) {
if(amount == 0) {
switch (resourceId) {
case R.plurals.label_message_reminder_text:
return context.getResources().getString(R.string.label_message_reminder_text_zero);
}
}
}
return context.getResources().getQuantityString(resourceId, amount);
}

You're doing something wrong. It's doing exactly what you're telling it to.
Your rules say that when the value is other, use "days" or "jours". You then pass in the value 0, which is other, so it uses "days" and "jours", as requested.
You could try setting a third value for quantity "zero" which has the language-specific rules.

getQuantityString returns wrong string with 0 value

In an android app, I have the following string resources:
<plurals name="test">
<item quantity="zero">"I have 0 item"</item>
<item quantity="one">"I have 1 item"</item>
<item quantity="other">"I have several items"</item>
</plurals>
And the following line of code:
String text = getResources().getQuantityString(R.plurals.test, 0)
which I would expect to return
I have 0 item
But it actually returns
I have 1 item
Why ?

Quantity Strings are broken on some Plattforms and phones as the issue Tracker and this discussion "Should Plurals and Quantity Strings be used" points out. It depends on many factors which you cannot control (i.e. localization on the phone).
One solution can be to take an external library like this one, which mimes the same functionallity.
Another solution is stated in the documentation of plurals in android. Avoid using it and use "quantity-neutral" formulations like "Books: 1"

Change the code like this
String text = getResources().getQuantityString(R.plurals.test, 0,0);

Android plurals treatment of "zero"

If have the following plural ressource in my strings.xml:
<plurals name="item_shop">
<item quantity="zero">No item</item>
<item quantity="one">One item</item>
<item quantity="other">%d items</item>
</plurals>
I'm showing the result to the user using:
textView.setText(getQuantityString(R.plurals.item_shop, quantity, quantity));
It's working well with 1 and above, but if quantity is 0 then I see "0 items".
Is "zero" value supported only in Arabic language as the documentation seems to indicate?
Or am I missing something?

The Android resource method of internationalisation is quite limited. I have had much better success using the standard java.text.MessageFormat.
Basically, all you have to do is use the standard string resource like this:
<resources>
<string name="item_shop">{0,choice,0#No items|1#One item|1<{0} items}</string>
</resources>
Then, from the code all you have to do is the following:
String fmt = getResources().getText(R.string.item_shop).toString();
textView.setText(MessageFormat.format(fmt, amount));
You can read more about the format strings in the javadocs for MessageFormat

From http://developer.android.com/guide/topics/resources/string-resource.html#Plurals:
Note that the selection is made based on grammatical necessity. A string for zero in English will be ignored even if the quantity is 0, because 0 isn't grammatically different from 2, or any other number except 1 ("zero books", "one book", "two books", and so on). Don't be misled either by the fact that, say, two sounds like it could only apply to the quantity 2: a language may require that 2, 12, 102 (and so on) are all treated like one another but differently to other quantities. Rely on your translator to know what distinctions their language actually insists upon.
In conclusion, 'zero' is only used for certain languages (same goes for 'two' 'few' etc.) because the other languages do not have a special conjugation and therefore the 'zero' field is considered unnecessary

Here is a workaround I am using to handle this issue without switching to MessageFormat.
First I extract the "zero" string into its own string resource.
<string name="x_items_zero">No items.</string>
<plurals name="x_items">
<!-- NOTE: This "zero" value is never accessed but is kept here to show the intended usage of the "zero" string -->
<item quantity="zero">#string/x_items_zero</item>
<item quantity="one">One item.</item>
<item quantity="other">%d items.</item>
</plurals>
Then I have some convenience methods in my own ResourcesUtil
public static String getQuantityStringZero(Resources resources, int resId, int zeroResId, int quantity) {
if (quantity == 0) {
return resources.getString(zeroResId);
} else {
return resources.getQuantityString(resId, quantity, quantity);
}
}
public static String getQuantityStringZero(Resources resources, int resId, int zeroResId, int quantity, Object... formatArgs) {
if (quantity == 0) {
return resources.getString(zeroResId);
} else {
return resources.getQuantityString(resId, quantity, formatArgs);
}
}
Now anytime I want to use a specific string for quantity zero I call:
String pluralString = ResourcesUtil.getQuantityStringZero(
getContext().getResources(),
R.plural.x_items,
R.string.x_items_zero,
quantity
);
I wish there was something better but this at least gets the job done while keeping the string resource XML legible.

Android is using the CLDR plurals system, and this is just not how it works (so don't expect this to change).
The system is described here:
http://cldr.unicode.org/index/cldr-spec/plural-rules
In short, it's important to understand that "one" does not mean the number 1. Instead these keywords are categories, and the specific numbers n that belong to each category are defined by rules in the CLDR database:
http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
While there appears to be no language which uses "zero" for anything other than 0, there are languages which assign 0 to "one". There are certainly plenty of cases where "two" contains other numbers than just 2.
If Android where to allow you to do what you intended, your applications could not be properly translated into any number of languages with more complex plural rules.

If you are using data binding you can work around this with something like:
<TextView ...
android:text="#{collection.size() > 0 ? #plurals/plural_str(collection.size(), collection.size()) : #string/zero_str}"/>

I've wrote a Kotlin extension to handle all the scenarios that I can think about.
I have zeroResId as optional, so that sometimes we want to handle the zero by displaying "No Items", rather than "0 Items".
English treats zero grammatically as plural.
The selection of which string to use is made solely based on
grammatical necessity.
In English, a string for zero is ignored even
if the quantity is 0, because 0 isn't grammatically different from 2,
or any other number except 1 ("zero books", "one book", "two books",
and so on).
https://developer.android.com/guide/topics/resources/string-resource.html#Plurals
fun Context.getQuantityStringZero(
quantity: Int,
pluralResId: Int,
zeroResId: Int? = null
): String {
return if (zeroResId != null && quantity == 0) {
resources.getString(zeroResId)
} else {
resources.getQuantityString(pluralResId, quantity, quantity)
}
}

Android's implementation seems correct unlike iOS (see details here).
The correct way to implement this should be the same are in MessageFormat, which means that for non-grammatical categories, you should add explicit rules (using numbers instead of categories). A correct implementation could look like this:
<plurals name="item_shop">
<item quantity="0">No item</item>
<item quantity="1">One item</item>
<item quantity="one">%d item</item>
<item quantity="other">%d items</item>
</plurals>
See here you are using the number 0 instead of the plural category zero which does not apply to English.
Using MessageFormat, this would translate to this (you can test here):
{messageNumber, plural, =0 {No item.} =1 {One item.} one {# item.} other {# items.}}
In English the category one is equal to 1 so in the example one should never be used but this is not true for all languages, and when spelling out a number, you are better make sure that you know which plural rule applies for that language.