Soporte de resolución diferente android

Pregunta editada:

Resolución móvil:
me gustaría diseñar diferentes dpi de pantalla como las siguientes resoluciones.
320x480,
480 × 800,
540x960,
720x1280 (Samsung S3),
1080x1920 (S4, Nexus5, Nexus 5x, Moto G4),
2560 x 1440 (Nexus 6, Nexus 6p, Samsung edge)

Resolución de la tableta:
480x800 (micromax),
600x1024 ( samsung tab2),
800x1280 (nexus 7),
1200x1920 (nuevo nexus 7),
2048x1536 (nexus 9)

Quiero usar diferentes tamaños de fuente según la resolución de pantalla del dispositivo.

P1) ¿Cuál es la bestforma de solucionar esto problem?

Q2) ¿Cuál es la mejor opción para lanzar código o XML?

P3) ¿Qué carpeta dibujable representa qué resolución de dispositivo?

P4) ¿Tamaño del icono del Lanzador de aplicaciones para una resolución diferente?

Tamaño del icono del iniciador de aplicaciones en píxeles para diferentes resoluciones

Resolución móvil

• mipmap-mdpi (48 x 48)
• mipmap-hdpi (72 x 72)
• mipmap-xhdpi (96 x 96)
• mipmap-xxhdpi (144X144)
• mipmap-xxxhdpi (192X192)

Diseños de tableta:

Utilice las siguientes carpetas si desea tener diseños específicos para tabletas:

layout-large-mdpi   (1024x600)
layout-large-tvdpi  (800x1280)
layout-large-xhdpi  (1200x1920)
layout-xlarge-mdpi  (1280x800)
layout-xlarge-xhdpi (2560x1600)

Carpetas dibujables:

1. Móvil

   res/drawable        (default)
   res/drawable-ldpi/  (240x320 and nearer resolution)
   res/drawable-mdpi/  (320x480 and nearer resolution)
   res/drawable-hdpi/  (480x800, 540x960 and nearer resolution)
   res/drawable-xhdpi/  (720x1280 - Samsung S3, Micromax Canvas HD etc)
   res/drawable-xxhdpi/ (1080x1920 - Samsung S4, HTC one, Nexus 5, etc)
   res/drawable-xxxhdpi/ (1440X2560 - Nexus 6,Samsung S6edge).
   

2. Resolución de la tableta:

   Tamaños de fuente:

NOTA: Siempre intente utilizar SP siempre que trate textSize, comotextsize=12sp

1. Utilice predefinido textAppearance:

   Establecerá el tamaño del texto automáticamente según la densidad del dispositivo.

   <TextView android:textAppearance="?android:attr/textAppearanceSmall"/>
   <TextView android:textAppearance="?android:attr/textAppearanceMedium"/>
   <TextView android:textAppearance="?android:attr/textAppearanceLarge" />
   

   Uso de muestra:

   <TextView
       style="@android:style/TextAppearance.Small"
       android:text="Sample Text - Small" />
   <TextView
       style="@android:style/TextAppearance.Medium"
       android:text="Sample Text  - Medium" />
   <TextView
       style="@android:style/TextAppearance.Large"
       android:text="Sample Text  - Large" />
   

2. Utilice dimension.xmlpara cada dispositivo:

   Desde Google IO Pdf , vemos la estructura a continuación:

   1. Móvil:

      res/values/dimens.xml(default)
      res/values-ldpi/dimens.xml   (240x320 and nearer resolution)
      res/values-mdpi/dimens.xml   (320x480 and nearer resolution)
      res/values-hdpi/dimens.xml   (480x800, 540x960 and nearer resolution)
      res/values-xhdpi/dimens.xml  (720x1280 - Samsung S3, Micromax Canvas HD, etc)
      res/values-xxhdpi/dimens.xml (1080x1920 - Samsung S4, HTC one, etc)
      

      res / values-xxxhdpi / dimens.xml (1440X2560 - Nexus 6, Samsung S6edge).

   2. Tableta:

      Para la tableta se puede utilizar más carpeta específica como values-xlarge, values-large.

      res/values-large/dimens.xml      (480x800)
      res/values-large-mdpi/dimens.xml (600x1024)
      

      o

      res/values-sw600dp/dimens.xml      (600x1024)
      res/values-sw720dp/dimens.xml      (800x1280)
      res/values-xlarge-xhdpi/dimens.xml (2560x1600 - Nexus 10")
      res/values-large-xhdpi/dimens.xml  (1200x1920 - Nexus 7"(latest))
      

Para mayor información:

1. Consulte Compatibilidad con varias pantallas .

2. Consulte la página 77 de Google IO Pdf para obtener información sobre la densidad de dispositivos de diseño . En eso, encontrará la manera de manejar dimens.xmldiferentes dispositivos diferentes.

3. Preparando tus aplicaciones para Nexus 6 y Nexus 9 .

Extracto de la compatibilidad con varias pantallas :

El píxel independiente de la densidad es equivalente a un píxel físico en una pantalla de 160 ppp, que es la densidad de referencia asumida por el sistema para una pantalla de densidad "media" . En tiempo de ejecución, el sistema maneja de manera transparente cualquier escalamiento de las unidades dp, según sea necesario, en función de la densidad real de la pantalla en uso. La conversión de las unidades de DP a píxeles de la pantalla es simple: px = dp * (dpi / 160). Por ejemplo, en una pantalla de 240 ppp, 1 dp equivale a 1,5 píxeles físicos. Siempre debe usar unidades dp al definir la interfaz de usuario de su aplicación, para garantizar una visualización adecuada de su interfaz de usuario en pantallas con diferentes densidades.

Primero crea las carpetas de diferentes valores para diferentes pantallas, y coloca el tamaño de acuerdo con las pantallas en el res->values->dimens.xmlarchivo y llama al tamaño de fuente simple usando "@dimen/text_size".

res/values/dimens.xml    
res/values-small/dimens.xml    
res/values-normal/dimens.xml    
res/values-xlarge/dimens.xml

//for small    
<?xml version="1.0" encoding="utf-8"?>
<resources>
   <dimen name="text_size">15sp</dimen>
</resources>

//for normal    
<?xml version="1.0" encoding="utf-8"?>
<resources>
   <dimen name="text_size">20sp</dimen>
</resources>

//for large    
<?xml version="1.0" encoding="utf-8"?>
<resources>
   <dimen name="text_size">30sp</dimen>
</resources>

//for xlarge    
<?xml version="1.0" encoding="utf-8"?>
<resources>
   <dimen name="text_size">40sp</dimen>
</resources>

y recupere el tamaño de fuente TextViewcomo se indica a continuación.

<TextView
    android:id="@+id/lblHeader"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"           
    android:textSize="@dimen/text_size"
    android:textStyle="bold"
    android:typeface="serif" />

Para evitar los problemas de diferentes resoluciones de pantalla y diferentes densidades, dimensiono y posiciono todo en función del porcentaje de ancho y alto de la pantalla. Si se cambia el tamaño del texto en función del porcentaje de ancho o alto de la pantalla, la fuente será del tamaño correcto en todos los dispositivos y todas las resoluciones. Para obtener el tamaño de fuente correcto según el ancho y la altura de su espacio, simplemente use esta función:

private float SetTextSize(String text, int width, int height)
{
    Paint paint = new Paint();
    float textWidth = paint.measureText(text);
    float textSize = (int) ((width / textWidth) * paint.getTextSize());
    paint.setTextSize(textSize);

    textWidth = paint.measureText(text);
    textSize = (int) ((width / textWidth) * paint.getTextSize());

    // Re-measure with font size near our desired result
    paint.setTextSize(textSize);

    // Check height constraints
    FontMetricsInt metrics = paint.getFontMetricsInt();
    float textHeight = metrics.descent - metrics.ascent;
    if (textHeight > height)
    {
        textSize = (int) (textSize * (height / textHeight));
        paint.setTextSize(textSize);
    }
    return textSize;
}

Aquí está el código para obtener el ancho y el alto de la pantalla:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2)
{
    Point size = new Point();
    getWindowManager().getDefaultDisplay().getSize(size);
    screenWidth = size.x;
    screenHeight = size.y; 
}
else
{
    Display display = getWindowManager().getDefaultDisplay(); 
    screenWidth = display.getWidth(); 
    screenHeight = display.getHeight(); 
}

Para obtener el tamaño de fuente que desea, simplemente cree un área basada en el ancho y la altura de la pantalla y ajústela hasta que el tamaño de fuente se vea bien. Una vez que lo vea bien, debería verse bien en todos los dispositivos.

float textSize = SetTextSize("text", (int) (screenWidth * 0.1), (int) (screenHeight * 0.15));

Espero que esto te ayude

Básicamente, necesita crear un estilo de texto similar a esto:

<style name="CodeFont">
    <item name="android:textSize">30sp</item>
</style>

lea más sobre esto aquí http://developer.android.com/guide/topics/ui/themes.html

Y utilizando la guía de soporte de Android para diferentes pantallas para crear los diferentes tamaños que desee para diferentes pantallas en las carpetas de resolución correctas, como se describe en: http://developer.android.com/guide/practices/screens_support.html

Nota al margen: Realmente no entiendo en qué situación le gustaría hacer eso, el uso de unidades SP para tamaños de fuente escalará las fuentes para que parezcan más o menos del mismo tamaño en diferentes teléfonos.

Primero, el diseño de su aplicación para una resolución.

ejemplo: suponga que la resolución de su móvil 380 * 480

       mobile screen width:380

       textView size is 80dp   
       Assume : if width is 380dp then 100 % then

               textview width 80dp then how many %(per).

            ower answer is: 25 %

encontrar el tamaño de la pantalla mediante programación usando la fórmula siguiente

    DisplayMetric  displaymetrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
    ScreenHeight = displaymetrics.heightPixels;
    ScreenWidth = displaymetrics.widthPixels;
        txt_height = (int)((ScreenHeight*14.58)/100);
    txt_width = (int)((ScreenWidth*37.5)/100);


    LinearLayout.LayoutParams normal_param = new LinearLayout.LayoutParams(txt_height ,txt_width );

    txt_Name.setLayoutParams(normal_param);

Creo que esta es una buena respuesta:

Tamaño del texto y diferentes tamaños de pantalla de Android

Pero aquí cómo puedes hacerlo con resolución de pantalla:

Puede crear un directorio de recursos de "valores" para cada resolución, como

values-wWIDTHp-hHEIGHTdp (you can also use values-wWIDTHp or values-hHEIGHTdp)
for example: 320*480 will be values-w320p-h480dp

En cada directorio (incluido el directorio de valores predeterminados) cree un archivo llamado "dimens.xml" con contenido:

 for exmaple (the value related to the resolution):
 <dimen name="def_font_size">10sp</dimen>

Ahora puede usar "@ dimen / def_font_size" o crear un estilo en el directorio de valores predeterminados.

Agregue esto al "styles.xml":

<style name="FontSize">
    <item name="android:textSize">@dimen/def_font_size</item>
</style>

He creado una función que convierte el tamaño de dp al tamaño de acuerdo con el tamaño de la pantalla y me está funcionando bien. Cualquiera que tenga problemas con el tamaño del texto según la pantalla debería intentarlo.

public float convertFromDp(int input) {
    final float scale = getResources().getDisplayMetrics().density;
    return ((input - 0.5f) / scale);
}

simplemente dé el valor dado por él al tamaño de la vista de texto programáticamente como se muestra a continuación

tvTextView1.setTextSize(convertFromDp(24));

Para la compatibilidad con el dispositivo nexus 6, cree la carpeta drawable-560dpi y coloque todas las imágenes en ella.