para - manual de programacion android pdf
Soporte de resolución diferente Android (8)
Básicamente, necesitas crear un estilo de texto como este:
<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 usando la compatibilidad con Android para diferentes pantallas, guíe para crear los diferentes tamaños que desee para diferentes pantallas en las carpetas de res correctas como se describe en: http://developer.android.com/guide/practices/screens_support.html
Nota al margen: realmente no entiendo en qué situación te gustaría hacerlo, el uso de unidades SP para tamaños de letra escalará las fuentes para que se vean más o menos del mismo tamaño en diferentes teléfonos.
Pregunta editada:
Resolución móvil:
Me gustaría diseñar diferentes ppp 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 nexo 7),
2048x1536 (nexus 9)
Quiero usar diferentes tamaños de fuente dependiendo de la resolución de visualización del dispositivo.
Q1) ¿Cuál es la best manera de resolver este problem ?
Q2) ¿Cuál es la mejor opción haciendo throw coding o XML?
Q3) ¿Qué carpeta dibujable representa qué resolución del dispositivo?
Q4) ¿Tamaño del icono del Iniciador de aplicaciones para una resolución diferente?
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) crea 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 a "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 funciona bien para mí. Cualquier persona que tenga problemas con el tamaño del texto de acuerdo con la pantalla debería intentarlo.
public float convertFromDp(int input) {
final float scale = getResources().getDisplayMetrics().density;
return ((input - 0.5f) / scale);
}
simple dar el valor dado por ella al tamaño de vista de texto de forma programada como a continuación
tvTextView1.setTextSize(convertFromDp(24));
Para el soporte del dispositivo nexus 6, crea una carpeta drawable-560dpi y coloca todas las imágenes en ella.
Para evitar los problemas de diferentes resoluciones de pantalla y diferentes densidades, dimensiono y coloco todo en función del porcentaje de ancho y alto de la pantalla. Si el tamaño del texto se basa en el porcentaje de ancho o alto de la pantalla, la fuente tendrá el tamaño correcto en todos los dispositivos y todas las resoluciones. Para obtener el tamaño de fuente correcto en función del 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 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 haga un área según el ancho de la pantalla y la altura de la pantalla y ajústelo hasta que el tamaño de la fuente parezca correcto. Una vez que lo veas 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
Primero crea las diferentes carpetas de valores para diferentes pantallas. Coloque el tamaño de acuerdo con las pantallas en el archivo res->values->dimens.xml y llame al tamaño de letra simple con "@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" />
Primero su diseño de 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 %
encuentre el tamaño de la pantalla programáticamente usando la fórmula belove
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);
Tamaño del icono del iniciador de aplicaciones en píxeles para una resolución diferente
Resolución móvil
- mipmap-mdpi (48X48)
- mipmap-hdpi (72X72)
- mipmap-xhdpi (96X96)
- mipmap-xxhdpi (144X144)
- mipmap-xxxhdpi (192X192)
Diseños de tableta:
Use las siguientes carpetas si desea tener diseños específicos de tableta:
layout-large-mdpi (1024x600)
layout-large-tvdpi (800x1280)
layout-large-xhdpi (1200x1920)
layout-xlarge-mdpi (1280x800)
layout-xlarge-xhdpi (2560x1600)
Carpetas Drawables:
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).Resolución de la tableta:
Tamaños de fuente:
NOTA: Siempre trate de usar SP siempre que
textSizecontextSize, comotextsize=12sp
Use texto predefinidoAppearance:
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" />Use
dimension.xmlpara cada dispositivo:De Google IO Pdf , vemos la estructura a continuación:
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).
Tableta:
Para la tableta puede usar 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:
Consulte Soporte de pantallas múltiples .
Consulte la página n.º 77 de Google IO Pdf para la densidad del dispositivo de diseño. En eso, encontrarás la manera de manejar
dimens.xmlpara diferentes dispositivos diferentes.- Preparar sus aplicaciones para Nexus 6 y Nexus 9 .
Extracto de admitir pantallas múltiples :
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 base 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 IU de su aplicación para garantizar una visualización adecuada de su IU en pantallas con diferentes densidades.