Soporte para diferentes resoluciones android

Pregunta editada:

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

Resolución de tabletas:
480×800 (micromax),
600×1024 (samsung tab2),
800×1280 (nexo 7),
1200×1920 (nuevo nexo 7),
2048×1536 (nexo 9)

Quiero utilizar diferentes tamaños de fuente dependiendo de la resolución de pantalla del dispositivo.

Q1) ¿Cuál es la best manera de resolver este problem ?

Q2) ¿Cuál es la mejor opción para ejecutar codificación o XML?

Q3) ¿Qué carpeta es posible representar la resolución del dispositivo?

Q4) Tamaño del icono de la aplicación Launcher para diferentes resoluciones?

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

Resolución móvil

  • Mipmap-mdpi (48X48)
  • Mipmap-hdpi (72X72)
  • Mipmap-xhdpi (96X96)
  • Mipmap-xxhdpi (144X144)
  • Mipmap-xxxhdpi (192X192)

Diseño de tabletas:

Utilice las siguientes carpetas si desea disponer de 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 de dibujos:

  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 tabletas: Introduzca aquí la descripción de la imagen

    Tamaños de fuente:

NOTA: Siempre trate de usar SP cuando se ocupe de textSize , como textsize=12sp

  1. Usar textAppearance predefinido:

    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" /> 

    Ejemplo de uso:

     <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. Use dimension.xml para 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 / valores-xxxhdpi / dimens.xml (1440X2560 – Nexus 6, Samsung S6edge).

    2. Tableta:

      Para la tableta, puede utilizar una carpeta más 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 Soporte de varias pantallas .

  2. Consulte la página # 77 de Google IO Pdf para la densidad del dispositivo de diseño. En eso, encontrará la manera de manejar dimens.xml para diferentes dispositivos diferentes.

  3. Preparación de sus aplicaciones para Nexus 6 y Nexus 9 .

Extracto de soportar múltiples 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 forma transparente cualquier escalado de las unidades dp, según sea necesario, en función de la densidad real de la pantalla en uso. La conversión de unidades dp a píxeles de 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 cuando defina la interfaz de usuario de su aplicación, para asegurar una visualización adecuada de su interfaz de usuario en pantallas con diferentes densidades.

Primero se crean las diferentes carpetas de valores para diferentes pantallas.y se pone el tamaño de acuerdo a las pantallas en res->values->dimens.xml archivo res->values->dimens.xml y se 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 recuperar el tamaño de fuente en TextView como 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" /> 

Básicamente es necesario crear un estilo de texto algo como 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 el soporte de Android para diferentes pantallas de guía para crear los diferentes tamaños que desee para diferentes pantallas en las carpetas de res derecho como se describe en: http://developer.android.com/guide/practices/screens_support.html

Nota lateral: Realmente no entiendo en qué situación querrías hacerlo, al usar unidades SP para tamaños de fuente, las fuentes se verán más o menos del mismo tamaño en diferentes teléfonos.

Para evitar los problemas de diferentes resoluciones de pantalla y diferentes densidades, dimensiono y posiciono todo basándome en el porcentaje de ancho y altura de la pantalla. Si el texto se redimensiona en función del porcentaje de ancho o altura de la pantalla, la fuente tendrá el tamaño correcto en todos los dispositivos y en todas las resoluciones. Para obtener el tamaño de fuente correcto basado en el ancho y la altura de su espacio, simplemente utilice 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 la altura 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, basta con crear un área basada en el ancho de la pantalla y la altura de la pantalla y ajustarla hasta que el tamaño de la fuente se vea bien. Una vez que lo haces parecer correcto, debería ver bien en todos los dispositivos.

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

Espero que esto te ayude

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

Ejemplo: suponga que su resolución 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 de amor

  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 de texto y diferentes tamaños de pantalla de Android

Pero aquí cómo se puede hacer con la 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 dir (incluyendo los valores por defecto dir) crear un archivo llamado "dimens.xml" con el contenido:

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

Ahora puede utilizar el "@ dimen / def_font_size" o crear un estilo en el directorio de valores por defecto.

Agregue esto al "styles.xml":

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

He creado una función que convierta el tamaño de dp al tamaño según tamaño de la pantalla y está trabajando bien para mí. Cualquiera que tenga problema con el tamaño del texto de acuerdo a la pantalla debe dar una oportunidad.

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

Simple, dé el valor dado por él al tamaño de la vista de texto como se indica a continuación

 tvTextView1.setTextSize(convertFromDp(24)); 

Para el soporte del dispositivo nexus 6, cree una carpeta de 560dpi y ponga todas las imágenes en ella.

FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.