Identificando el lenguaje RTL en Android

right-to-left

Question

¿Hay alguna forma de identificar el lenguaje RTL (de derecha a izquierda), además de probar el código de idioma en todos los idiomas RTL?

Dado que API 17+ permite varios recursos para RTL y LTR, supongo que debería haber una forma, al menos desde API 17.

Answer 1

Al crear una biblioteca, siempre debe comprobar si la aplicación admite RTL utilizando

(getApplicationInfo().flags &= ApplicationInfo.FLAG_SUPPORTS_RTL) != 0

Cuando la aplicación se ejecuta en la configuración regional de RTL, pero no se declara en el manifiesto de android:supportsRtl="true" entonces se ejecuta en modo LTR.

Answer 2

Debido a que los dispositivos de idioma inglés son compatibles con RTL, puede usar este código en MainActivity para cambiar el idioma del dispositivo a inglés y no necesita el código "supportRTL".

String languageToLoad  = "en"; // your language
Locale locale = new Locale(languageToLoad);
Locale.setDefault(locale);
Configuration config = new Configuration();
config.locale = locale;
getBaseContext().getResources().updateConfiguration(config,
getBaseContext().getResources().getDisplayMetrics());

Answer 3

Esto funcionará en todos los SDKS:

private boolean isRTL() {
    Locale defLocale = Locale.getDefault();
    return  Character.getDirectionality(defLocale.getDisplayName(defLocale).charAt(0)) == Character.DIRECTIONALITY_RIGHT_TO_LEFT;
}

Answer 4

Gracias a todos.

Si observa el código de LayoutUtil.getLayoutDirectionFromLocale() (y, supongo que Confuiguration.getLayoutDirection() también) termina analizando la letra inicial del nombre para mostrar la configuración regional, usando Character.getDirectionality .

Dado que Character.getDirectionality existía desde Android 1, el siguiente código será compatible con todas las versiones de Android (incluso aquellas que no admiten RTL correctamente :)):

public static boolean isRTL() {
    return isRTL(Locale.getDefault());
}

public static boolean isRTL(Locale locale) {
     return
        Character.getDirectionality(locale.getDisplayName().charAt(0)) ==
            Character.DIRECTIONALITY_RIGHT_TO_LEFT; 
}

Answer 5

Hay una forma realmente sencilla de verificar la dirección de diseño de una vista, pero recurre a LTR en los dispositivos anteriores a la API 17:

ViewUtils.isLayoutRtl(View view);

La clase ViewUtils viene con la biblioteca de soporte v7, por lo que ya debería estar disponible si está utilizando la biblioteca appcompat.

Answer 6

La respuesta de @cianuro tiene el enfoque correcto pero un error crítico.

Character.getDirectionality devuelve el tipo de carácter bidireccional (bidi) . El texto de izquierda a derecha es un tipo predecible L y de derecha a izquierda también es predecible el tipo R. PERO, el texto en árabe devuelve otro tipo, el tipo AL.

Agregué un cheque para el tipo R y el tipo AL y luego probé manualmente cada idioma RTL con Android: hebreo (Israel), árabe (Egipto) y árabe (Israel).

Como puede ver, esto deja de lado otros idiomas de derecha a izquierda, por lo que me preocupaba que a medida que Android agregue estos idiomas, podría haber un problema similar y uno podría no darse cuenta de inmediato.

Así que probé manualmente cada lenguaje RTL.

• Árabe (العربية) = tipo AL
• Kurdo (وردی) = tipo AL
• Farsi (فارسی) = tipo AL
• Urdu (اردو) = tipo AL
• Hebreo (hebreo) = tipo R
• Yiddish (ייִדיש) = tipo R

Así que parece que esto debería funcionar muy bien:

public static boolean isRTL() {
    return isRTL(Locale.getDefault());
}

public static boolean isRTL(Locale locale) {
    final int directionality = Character.getDirectionality(locale.getDisplayName().charAt(0));
    return directionality == Character.DIRECTIONALITY_RIGHT_TO_LEFT ||
           directionality == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;
}

Gracias @cyanide por enviarme la dirección correcta!

Answer 7

Obtenlo de Configuration.getLayoutDirection() :

Configuration config = getResources().getConfiguration();
if(config.getLayoutDirection() == View.LAYOUT_DIRECTION_RTL) {
    //in Right To Left layout
}

Answer 8

Para un control más preciso sobre la IU de su aplicación en modo LTR y RTL, Android 4.2 incluye las siguientes nuevas API para ayudar a administrar los componentes de View:

android:layoutDirection — attribute for setting the direction of a component''s layout.
android:textDirection — attribute for setting the direction of a component''s text.
android:textAlignment — attribute for setting the alignment of a component''s text.
getLayoutDirectionFromLocale() — method for getting the Locale-specified direction

Por lo tanto, getLayoutDirectionFromLocale () debería ayudarlo. Consulte el código de muestra aquí: https://android.googlesource.com/platform/frameworks/base.git/+/3fb824bae3322252a68c1cf8537280a5d2bd356d/core/tests/coretests/src/android/util/LocaleUtilTest.java

Answer 9

Puede usar TextUtilsCompat desde la biblioteca de soporte.

TextUtilsCompat.getLayoutDirectionFromLocale(locale)

Answer 10

Puede verificar de esta forma si desea verificar que la API sea inferior a 17

boolean isRightToLeft = TextUtilsCompat.getLayoutDirectionFromLocale(Locale
               .getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL;

O para API 17 o superior

boolean isRightToLeft = TextUtils.getLayoutDirectionFromLocale(Locale
               .getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL;

Answer 11

Recolecté mucha información y finalmente hice mi propia clase de RTLUtils, con suerte completa.

Permite saber si una configuración regional o vista dada es ''RTL'' :-)

package com.elementique.shared.lang;

import java.util.Collections;
import java.util.HashSet;
import java.util.Locale;
import java.util.Set;

import android.support.v4.view.ViewCompat;
import android.view.View;

public class RTLUtils
{

    private static final Set<String> RTL;

    static
    {
        Set<String> lang = new HashSet<String>();
        lang.add("ar"); // Arabic
        lang.add("dv"); // Divehi
        lang.add("fa"); // Persian (Farsi)
        lang.add("ha"); // Hausa
        lang.add("he"); // Hebrew
        lang.add("iw"); // Hebrew (old code)
        lang.add("ji"); // Yiddish (old code)
        lang.add("ps"); // Pashto, Pushto
        lang.add("ur"); // Urdu
        lang.add("yi"); // Yiddish
        RTL = Collections.unmodifiableSet(lang);
    }

    public static boolean isRTL(Locale locale)
    {
        if(locale == null)
            return false;

        // Character.getDirectionality(locale.getDisplayName().charAt(0))
        // can lead to NPE (Java 7 bug)
        // https://bugs.openjdk.java.net/browse/JDK-6992272?page=com.atlassian.streams.streams-jira-plugin:activity-stream-issue-tab
        // using hard coded list of locale instead
        return RTL.contains(locale.getLanguage());
    }

    public static boolean isRTL(View view)
    {
        if(view == null)
            return false;

        // config.getLayoutDirection() only available since 4.2
        // -> using ViewCompat instead (from Android support library)
        if (ViewCompat.getLayoutDirection(view) == View.LAYOUT_DIRECTION_RTL)
        {
            return true;
        }
        return false;
    }
}

Disfruta :-)

Answer 12

Si está utilizando la biblioteca de soporte, puede hacer lo siguiente:

if (ViewCompat.getLayoutDirection(view) == ViewCompat.LAYOUT_DIRECTION_RTL) {
    // The view has RTL layout
} else {
    // The view has LTR layout
}

Answer 13

Solo usa este código:

 public static boolean isRTL() {
   return isRTL(Locale.getDefault());
 }

 public static boolean isRTL(Locale locale) {
  final int directionality = Character.getDirectionality(locale.getDisplayName().charAt(0));
  return directionality == Character.DIRECTIONALITY_RIGHT_TO_LEFT ||
       directionality == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC;
 }

 if (isRTL()) {
   // The view has RTL layout
 }
 else {
   // The view has LTR layout
 }

Esto funcionará para todos los niveles de API de Android.

Answer 14

Soporte RTL nativo en Android 4.2

    public static ComponentOrientation getOrientation(Locale locale) 
    {
            // A more flexible implementation would consult a ResourceBundle
            // to find the appropriate orientation.  Until pluggable locales
            // are introduced however, the flexiblity isn''t really needed.
            // So we choose efficiency instead.
            String lang = locale.getLanguage();
            if( "iw".equals(lang) || "ar".equals(lang)
                || "fa".equals(lang) || "ur".equals(lang) )
            {
                return RIGHT_TO_LEFT;
            } else {
                return LEFT_TO_RIGHT;
            }
    }