venta telefono tablets samsung pulgadas mejor marcas cual baratas android android-layout screen

android - telefono - tablets de 7 pulgadas 2018



Detectar tabletas de 7 pulgadas y 10 pulgadas mediante programación (11)

De otra manera:

  • Crea 2 carpetas más: values-large + values-xlarge

  • Ponga: <string name="screentype">LARGE</string> en la carpeta values-large (strings.xml)

  • Ponga: <string name="screentype">XLARGE</string> en la carpeta values-xlarge (strings.xml)

  • En codigo:

    String mType = getString (R.string.screentype);

    if (mType! = null && mType.equals ("LARGE") {

    // desde 4 ~ 7 pulgadas

    } else if (mType! = null && mType.equals ("XLARGE") {

    // desde 7 ~ 10 pulgadas

    }

¿Hay alguna forma de determinar mediante programación si el dispositivo en el que está instalada la aplicación es una tableta de 7 pulgadas o una de 10 pulgadas?

Estaba almacenando un valor en la carpeta de valores que me da una pantalla de 7 pulgadas o 10 inc. Pero podemos hacerlo para cualquier dispositivo usando la carpeta de valores.

como crear una carpeta de valores different-2 para diferentes dispositivos-2. Pero esto depende del requisito.

Gran información, ¡justo lo que estaba buscando! Sin embargo, después de probar esto descubrí que al usar las métricas mencionadas aquí, el Nexus 7 (modelo de 2012) informa tener dimensiones de 1280x736. También tengo un Motorola Xoom ejecutando Jelly Bean e informa incorrectamente una resolución de 1280x752. Me encontré con este post here que confirma esto. Básicamente, en ICS / JB, los cálculos que utilizan las métricas mencionadas anteriormente parecen excluir las dimensiones de la barra de navegación. Algunas investigaciones más me llevaron a la respuesta de Frank Nguyen aquí que usa diferentes métodos que le darán las dimensiones de píxel en bruto (o reales) de la pantalla. Mi prueba inicial ha demostrado que el siguiente código de Frank correclia informa las dimensiones en el Nexus 7 (modelo 2012 runnin JB) y mi Motorola Xoom corriendo JB:

int width = 0, height = 0; final DisplayMetrics metrics = new DisplayMetrics(); Display display = getWindowManager().getDefaultDisplay(); Method mGetRawH = null, mGetRawW = null; try { // For JellyBeans and onward if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) { display.getRealMetrics(metrics); width = metrics.widthPixels; height = metrics.heightPixels; } else { mGetRawH = Display.class.getMethod("getRawHeight"); mGetRawW = Display.class.getMethod("getRawWidth"); try { width = (Integer) mGetRawW.invoke(display); height = (Integer) mGetRawH.invoke(display); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvocationTargetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (NoSuchMethodException e3) { e3.printStackTrace(); }

La forma en que Android especifica los tamaños de pantalla es a través de cuatro tamaños generalizados: pequeño , normal , grande y xlarge .

Si bien la documentación de Android indica que los grupos de tamaño están en desuso

... estos grupos de tamaño están en desuso en favor de una nueva técnica para administrar los tamaños de pantalla en función del ancho de pantalla disponible. Si está desarrollando para Android 3.2 y versiones posteriores, consulte [Declarar diseños de tableta para Android 3.2] (hdpi (alto) ~ 240 ppp) para obtener más información.

En general, el calificador de tamaño grande especifica una tableta de 7 ". Y un calificador de tamaño de xlarge especifica una tableta de 10":

Lo bueno de activar en el calificador de tamaño es que puedes garantizar que tus activos y tu código estén de acuerdo con qué activo usar o con la ruta del código para activar.

Para recuperar el calificador de tamaño en código realice las siguientes llamadas:

int sizeLarge = SCREENLAYOUT_SIZE_LARGE // For 7" tablet boolean is7InchTablet = context.getResources().getConfiguration() .isLayoutSizeAtLeast(sizeLarge); int sizeXLarge = SCREENLAYOUT_SIZE_XLARGE // For 10" tablet boolean is10InchTablet = context.getResources().getConfiguration() .isLayoutSizeAtLeast(sizeXLarge);

Lo anterior no siempre funciona cuando se cambia de retrato frente a paisaje.

Si tiene como objetivo el nivel de API 13+, es fácil como se describió anteriormente: use Configuration.smallestScreenWidthDp, luego pruebe en consecuencia:

resources.getConfiguration().smallestScreenWidthDp

De lo contrario, si puede pagar esto, utilice el siguiente método, que es un enfoque muy preciso para detectar 600dp (como 6 ") frente a 720dp (como 10") al permitir que el sistema le diga:

1) Agregue a layout-sw600dp y layout-sw720dp (y si corresponde su paisaje) una vista invisible con ID adecuado, por ejemplo:

Para 720, en layout-sw720dp:

<View android:id="@+id/sw720" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

Para 600, en layout-sw600dp:

<View android:id="@+id/sw600" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

2) Luego en el código, por ejemplo, la Actividad, prueba en consecuencia:

private void showFragment() { View v600 = (View) findViewById(R.id.sw600); View v720 = (View) findViewById(R.id.sw720); if (v600 != null || v720 !=null) albumFrag = AlbumGridViewFragment.newInstance(albumRefresh); else albumFrag = AlbumListViewFragment.newInstance(albumRefresh); getSupportFragmentManager() .beginTransaction() .replace(R.id.view_container, albumFrag) .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE) .commit(); }

No hay nada que diga AFAIK de 7" o 10" . Hay aproximadamente dos formas de obtener dimensiones de pantalla que el sistema usa al descodificar bitmaps y otras cosas. Ambos se encuentran en el objeto de Resources la aplicación que se encuentra en el Context .

El primero es el objeto de Configuration que se puede obtener mediante getContext().getResources().getConfiguration() . En él tienes:

Configuration#densityDpi - La densidad de pantalla objetivo a la que se representa, correspondiente al calificador de recursos de densidad.

Configuration#screenHeightDp : la altura actual del espacio de pantalla disponible, en unidades dp, correspondiente al calificador de recursos de altura de pantalla.

Configuration#screenWidthDp : el ancho actual del espacio de pantalla disponible, en unidades dp, correspondiente al calificador de recursos de ancho de pantalla.

Configuration#smallestScreenWidthDp : el tamaño de pantalla más pequeño que verá una aplicación en funcionamiento normal, correspondiente al calificador de recursos de ancho de pantalla más pequeño.

Con eso, puede usar las pautas de la pantalla para averiguar si su dispositivo está extrayendo de las respectivas carpetas de recursos especializados ( hdpi , xhdpi , large , xlarge , etc.).

Recuerde, estos son algunos de los cubos:

  • Las pantallas xlarge son al menos 960dp x 720dp
  • pantallas de gran tamaño son de al menos 640dp x 480dp
  • las pantallas normales son al menos 470dp x 320dp

  • las pantallas pequeñas son al menos 426 pd x 320 pd

  • 320dp: una pantalla de teléfono típica (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc.).

  • 480dp: una tableta tweener como la Streak (480x800 mdpi).
  • 600dp: una tableta de 7 "(600x1024 mdpi).
  • 720dp: una tableta de 10 "(720x1280 mdpi, 800x1280 mdpi, etc.).

Más información

El segundo es el objeto DisplayMetrics obtenido por getContext().getResources().getDisplayMetrics() . En eso tienes:

DisplayMetrics#density : la densidad lógica de la pantalla.

DisplayMetrics#densityDpi - La densidad de la pantalla expresada como puntos por pulgada.

DisplayMetrics#heightPixels : la altura absoluta de la pantalla en píxeles.

DisplayMetrics#widthPixels : el ancho absoluto de la pantalla en píxeles.

DisplayMetrics#xdpi : los píxeles físicos exactos por pulgada de la pantalla en la dimensión X.

DisplayMetrics#ydpi : los píxeles físicos exactos por pulgada de la pantalla en la dimensión Y.

Esto es útil si necesita una cantidad exacta de píxeles de la pantalla en lugar de densidad. Sin embargo, es importante tener en cuenta que estos son todos los píxeles de la pantalla. No solo los disponibles para ti.

Puede usar el siguiente método para obtener el tamaño de la pantalla en pulgadas, basado en eso simplemente puede verificar qué tableta o teléfono es el dispositivo.

private static double checkDimension(Context context) { WindowManager windowManager = ((Activity)context).getWindowManager(); Display display = windowManager.getDefaultDisplay(); DisplayMetrics displayMetrics = new DisplayMetrics(); display.getMetrics(displayMetrics); // since SDK_INT = 1; int mWidthPixels = displayMetrics.widthPixels; int mHeightPixels = displayMetrics.heightPixels; // includes window decorations (statusbar bar/menu bar) try { Point realSize = new Point(); Display.class.getMethod("getRealSize", Point.class).invoke(display, realSize); mWidthPixels = realSize.x; mHeightPixels = realSize.y; } catch (Exception ignored) {} DisplayMetrics dm = new DisplayMetrics(); windowManager.getDefaultDisplay().getMetrics(dm); double x = Math.pow(mWidthPixels/dm.xdpi,2); double y = Math.pow(mHeightPixels/dm.ydpi,2); double screenInches = Math.sqrt(x+y); Log.d("debug","Screen inches : " + screenInches); return screenInches; }

Tendrá que hacer un poco de cálculo utilizando datos proporcionados por la clase DisplayMetrics .

Tiene heightPixel y widthPixels (la resolución de la pantalla en píxeles)

Necesita la diagonal ya que el ''tamaño de pantalla en pulgadas'' siempre describe la longitud diagonal. Puedes obtener la diagonal de la pantalla en pixel (usando pythagore)

diagonalPixel = √ (heightPixel² + widthPixels²)

luego puede convertir el valor de píxel a pulgadas gracias al valor de densidadDPI:

inchDiag = diagonalPixel / densityDPI.

Espero que no haya cometido errores aquí, tenga en cuenta que los valores que obtiene de la clase DisplayMetrics vienen dados por el constructor, parece (en casos muy raros) que no están bien configurados de acuerdo con el material físico ...

Esto le dará el tamaño de la pantalla física, pero probablemente no sea la mejor manera de administrar diseños múltiples. Más sobre este tema

Tengo dos dispositivos Android con la misma resolución

Dispositivo1 -> resolución de pantalla diagonal de 480x800 -> 4.7 pulgadas

Dispositivo2 -> resolución de pantalla diagonal de 480x800 -> 4.0 pulgadas

Da el tamaño de pantalla diagonal de ambos dispositivos -> 5.8

la solución a su problema es ...

DisplayMetrics dm = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(dm); int width=dm.widthPixels; int height=dm.heightPixels; int dens=dm.densityDpi; double wi=(double)width/(double)dens; double hi=(double)height/(double)dens; double x = Math.pow(wi,2); double y = Math.pow(hi,2); double screenInches = Math.sqrt(x+y);

ver detalles aquí ..

coloque este método en onResume () y puede verificar.

public double tabletSize() { double size = 0; try { // Compute screen size DisplayMetrics dm = context.getResources().getDisplayMetrics(); float screenWidth = dm.widthPixels / dm.xdpi; float screenHeight = dm.heightPixels / dm.ydpi; size = Math.sqrt(Math.pow(screenWidth, 2) + Math.pow(screenHeight, 2)); } catch(Throwable t) { } return size; }

generalmente las tabletas comienzan después de un tamaño de 6 pulgadas.

Puede usar DisplayMetrics para obtener un montón de información sobre la pantalla en la que se ejecuta su aplicación.

Primero, creamos un objeto de métrica DisplayMetrics :

DisplayMetrics metrics = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(metrics);

A partir de esto, podemos obtener la información requerida para dimensionar la pantalla:

int widthPixels = metrics.widthPixels; int heightPixels = metrics.heightPixels;

Esto devolverá el valor absoluto del ancho y la altura en píxeles, por lo que 1280x720 para el Galaxy SIII, el Galaxy Nexus, etc.

Esto no suele ser útil por sí solo, ya que cuando trabajamos en dispositivos Android, generalmente preferimos trabajar en píxeles independientes de densidad, inmersión.

Obtiene la density de la pantalla usando metrics nuevamente, en forma de un factor de escala para el dispositivo, que se basa en los recursos de diseño de Android para mdpi , hdpi , etc.

float scaleFactor = metrics.density;

A partir de este resultado, podemos calcular la cantidad de píxeles independientes de densidad que hay para una cierta altura o ancho.

float widthDp = widthPixels / scaleFactor float heightDp = heightPixels / scaleFactor

El resultado que obtendrás de esto te ayudará a decidir con qué tipo de pantalla estás trabajando junto con los ejemplos de configuración de Android , que te dan el dp relativo para cada tamaño de pantalla:

  • 320dp: una pantalla de teléfono típica (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc.).
  • 480dp: una tableta tweener como la Streak (480x800 mdpi).
  • 600dp: una tableta de 7 "(600x1024 mdpi).
  • 720dp: una tableta de 10 "(720x1280 mdpi, 800x1280 mdpi, etc.).

Usando la información anterior, sabemos que si el ancho más pequeño del dispositivo es mayor a 600dp, el dispositivo es una tableta de 7 ", si es mayor a 720dp, el dispositivo es una tableta de 10".

Podemos calcular el ancho más pequeño usando la función min de la clase Math , pasando el heightDp y el widthDp para devolver el widthDp smallestWidth .

float smallestWidth = Math.min(widthDp, heightDp); if (smallestWidth > 720) { //Device is a 10" tablet } else if (smallestWidth > 600) { //Device is a 7" tablet }

Sin embargo, esto no siempre le da una coincidencia exacta, especialmente cuando se trabaja con tabletas oscuras que pueden tergiversar su densidad como hdpi cuando no lo es, o que solo podrían tener 800 x 480 píxeles y aún estar en una pantalla de 7 " .

Además de estos métodos, si alguna vez necesita saber las dimensiones exactas de un dispositivo en pulgadas, también puede resolverlo, utilizando el método de metrics de cuántos píxeles hay por pulgada de la pantalla.

float widthDpi = metrics.xdpi; float heightDpi = metrics.ydpi;

Puede utilizar el conocimiento de cuántos píxeles hay en cada pulgada del dispositivo y la cantidad de píxeles en total para calcular cuántas pulgadas tiene el dispositivo.

float widthInches = widthPixels / widthDpi; float heightInches = heightPixels / heightDpi;

Esto devolverá el alto y el ancho del dispositivo en pulgadas. De nuevo, esto no siempre es útil para determinar qué tipo de dispositivo es, ya que el tamaño anunciado de un dispositivo es la diagonal, todo lo que tenemos es la altura y el ancho.

Sin embargo, también sabemos que dada la altura de un triángulo y el ancho, podemos usar el teorema de Pitágoras para calcular la longitud de la hipotenusa (en este caso, el tamaño de la diagonal de la pantalla).

//a² + b² = c² //The size of the diagonal in inches is equal to the square root of the height in inches squared plus the width in inches squared. double diagonalInches = Math.sqrt( (widthInches * widthInches) + (heightInches * heightInches));

A partir de esto, podemos determinar si el dispositivo es una tableta o no:

if (diagonalInches >= 10) { //Device is a 10" tablet } else if (diagonalInches >= 7) { //Device is a 7" tablet }

Y así es como calculas con qué tipo de dispositivo estás trabajando.