ti-enxame.com

Detectar tablet de 7 polegadas e 10 polegadas programaticamente

Existe uma maneira de descobrir programaticamente se o dispositivo em que o aplicativo está instalado é um tablet de 7 polegadas ou um tablet de 10 polegadas?

90
Rookie

Você pode usar o DisplayMetrics para obter um monte de informações sobre a tela em que seu aplicativo está sendo executado.

Primeiro, criamos um objeto de métricas DisplayMetrics:

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

A partir disso, podemos obter as informações necessárias para dimensionar a exibição:

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

Isso retornará o valor absoluto da largura e da altura em pixels, de modo que 1280x720 para o Galaxy SIII, o Galaxy Nexus etc.

Isso geralmente não é útil por si só, já que quando estamos trabalhando em dispositivosAndroid, geralmente preferimos trabalhar em pixels independentes de densidade, dip.

Você obtém o density da tela usando metrics novamente, na forma de um fator de escala para o dispositivo, que é baseado no Android Design Resources para mdpi, hdpi etc. DPI scales

float scaleFactor = metrics.density;

A partir deste resultado, podemos calcular a quantidade de pixels independentes de densidade que existem para uma certa altura ou largura.

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

O resultado que você obtém ajudará você a decidir com que tipo de tela você está trabalhando em conjunto com exemplos de configuração do Android , que lhe dão o dp relativo para cada tamanho de tela:

  • 320dp: uma tela de telefone comum (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc).
  • 480dp: um tablet tweener como o Streak (480x800 mdpi).
  • 600dp: um tablet de 7 ”(600x1024 mdpi).
  • 720dp: um tablet de 10 ”(720x1280 mdpi, 800x1280 mdpi, etc).

Usando as informações acima, sabemos que se a menor largura do dispositivo for maior que 600 dp, o dispositivo é um tablet de 7 ", se for maior que 720 dp, o dispositivo é um tablet de 10".

Podemos calcular a menor largura usando a função min da classe Math, passando o heightDp e o widthDp para retornar o smallestWidth.

float smallestWidth = Math.min(widthDp, heightDp);

if (smallestWidth > 720) {
    //Device is a 10" tablet
} 
else if (smallestWidth > 600) {
    //Device is a 7" tablet
}

No entanto, isso nem sempre dá uma correspondência exata, especialmente quando se trabalha com tablets obscuros que podem estar distorcendo sua densidade como hdpi quando não está, ou que pode ter apenas 800 x 480 pixels, mas ainda assim estar em uma tela de 7 ". .

Além desses métodos, se você precisar saber as dimensões exatas de um dispositivo em polegadas, você pode descobrir isso também, usando o método metrics para quantos pixels há por polegada da tela.

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

Você pode usar o conhecimento de quantos pixels há em cada polegada do dispositivo e a quantidade de pixels no total para calcular quantos polegadas o dispositivo possui.

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

Isso retornará a altura e a largura do dispositivo em polegadas. Isso nem sempre é útil para determinar que tipo de dispositivo é, pois o tamanho anunciado de um dispositivo é a diagonal. Tudo o que temos é a altura e a largura.

No entanto, também sabemos que, dada a altura de um triângulo e a largura, podemos usar o teorema de Pitágoras para calcular o comprimento da hipotenusa (nesse caso, o tamanho da diagonal da tela).

//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 disso, podemos descobrir se o dispositivo é um tablet ou não:

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

E é assim que você calcula com que tipo de dispositivo você está trabalhando.

229
Sean O'Toole

Não há nada que diga 7" ou 10" AFAIK. Existem aproximadamente duas maneiras de obter dimensões de tela que o sistema usa ao decodificar bitmaps e outros. Ambos são encontrados no objeto Resources do aplicativo encontrado no Context.

O primeiro é o objeto Configuration que pode ser obtido por getContext().getResources().getConfiguration(). Nele você tem:

Configuration#densityDpi - A densidade da tela de destino sendo renderizada, correspondendo ao qualificador de recurso de densidade.

Configuration#screenHeightDp - A altura atual do espaço de tela disponível, em unidades de dp, correspondente ao qualificador de recurso de altura de tela.

Configuration#screenWidthDp - A largura atual do espaço de tela disponível, em unidades dp, correspondente ao qualificador de recurso de largura de tela.

Configuration#smallestScreenWidthDp - O menor tamanho de tela que um aplicativo verá na operação normal, correspondendo ao menor qualificador de recurso de largura de tela.

Com isso, você pode usar as diretrizes de tela para descobrir se o dispositivo está usando as respectivas pastas de recursos especializadas (hdpi, xhdpi, large, xlarge, etc.).

Lembre-se, estes são alguns dos baldes:

  • ecrãs xlarge são pelo menos 960dp x 720dp
  • telas grandes são pelo menos 640dp x 480dp
  • telas normais são pelo menos 470dp x 320dp
  • telas pequenas são pelo menos 426dp x 320dp

  • 320dp: uma tela de telefone comum (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc).

  • 480dp: um tablet tweener como o Streak (480x800 mdpi).
  • 600dp: um tablet de 7 ”(600x1024 mdpi).
  • 720dp: um tablet de 10 ”(720x1280 mdpi, 800x1280 mdpi, etc).

mais informações

O segundo é o objeto DisplayMetrics obtido por getContext().getResources().getDisplayMetrics(). Em que você tem:

DisplayMetrics#density - A densidade lógica da exibição.

DisplayMetrics#densityDpi - A densidade da tela expressa como pontos por polegada.

DisplayMetrics#heightPixels - A altura absoluta da exibição em pixels.

DisplayMetrics#widthPixels - A largura absoluta da exibição em pixels.

DisplayMetrics#xdpi - Os pixels físicos exatos por polegada da tela na dimensão X.

DisplayMetrics#ydpi - Os pixels físicos exatos por polegada da tela na dimensão Y.

Isso é útil se você precisar de contagem de pixels exata da tela, em vez de densidade. No entanto, é importante notar que isto é todos os pixels da tela. Não apenas os que estão disponíveis para você.

32
DeeV

coloque este método em onResume () e pode 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;

    }

geralmente, os tablets iniciam após o tamanho de 6 polegadas.

13
PiyushMishra

O acima nem sempre funciona ao mudar de retrato versus paisagem.

Se você está segmentando o nível de API 13+, é fácil, como descrito acima - use o Configuration.smallestScreenWidthDp e, em seguida, teste de acordo:

resources.getConfiguration().smallestScreenWidthDp

Caso contrário, se você puder pagar por isso, use o seguinte método, que é uma abordagem muito precisa para detectar 600dp (como 6 ") vs. 720dp (como 10"), permitindo que o sistema lhe diga:

1) Adicione ao layout-sw600dp e layout-sw720dp (e se aplicável a paisagem) uma visão invisível com o ID apropriado, por exemplo:

Para 720, no layout-sw720dp:

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

Para 600, no layout-sw600dp:

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

2) Em seguida, no código, por exemplo, a atividade, teste de acordo:

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();
}
8
CEO

Grande informação, apenas o que eu estava procurando! No entanto, depois de experimentar isso, descobri que, ao usar as métricas mencionadas aqui, o Nexus 7 (modelo 2012) informa ter dimensões 1280x736. Eu também tenho um Motorola Xoom rodando o Jelly bean e ele reporta incorretamente uma resolução de 1280x752. Eu tropecei neste post aqui que confirma isso. Basicamente, no ICS/JB, os cálculos usando as métricas mencionadas acima parecem excluir as dimensões da barra de navegação. Mais algumas pesquisas me levaram a a resposta de Frank Nguyen aqui que usa métodos diferentes que lhe darão as dimensões em pixels brutas (ou reais) da tela. Meu teste inicial mostrou que o seguinte código de Frank correclty reporta as dimensões no Nexus 7 (modelo 2012 runnin JB) e meu Motorola Xoom rodando 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();
}
7
Jason

Eu tenho dois Android dispositivo com a mesma resolução

Device1 -> resolução 480x800 tamanho da tela diagonal -> 4,7 polegadas

Device2 -> tamanho da tela de resolução 480x800 -> 4,0 polegadas

Dá o tamanho de tela diagonal do dispositivo -> 5.8

a solução para o seu problema é ..

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);

veja detalhes aqui ..

3
Xar E Ahmer

Você pode usar o método abaixo para obter o tamanho da tela em polegadas, com base nisso simplesmente você pode verificar qual tablet ou telefone é o 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;
}
2
Ashish Rajvanshi

A forma que Android especifica tamanhos de tela é através de quatro tamanhos generalizados: small , normal , grande e xlarge .

Enquanto o Android documentation indica que os grupos de tamanho estão obsoletos

... esses grupos de tamanho são obsoletos em favor de uma nova técnica para gerenciar tamanhos de tela com base na largura de tela disponível. Se você estiver desenvolvendo para Android 3.2 e superior, consulte [Declarando os layouts de tablets para Android 3.2] (hdpi (alto) ~ 240 dpi) para obter mais informações.

Geralmente, o qualificador de tamanho grande especifica um tablet de 7 ". E um qualificador de tamanho de xlarge especifica um tablet de 10 ":

enter image description here

O bom de acionar o qualificador de tamanho é que você pode garantir que seus ativos e código estejam de acordo sobre qual recurso usar ou codificar o caminho a ser ativado.

Para recuperar o qualificador de tamanho no código, faça as seguintes chamadas:

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);
2
Benjamin

Eu estava armazenando um valor em pasta de valores que me dá tela é de 7 polegadas ou 10 inc, mas podemos fazer isso para qualquer dispositivo usando a pasta de valores.

como criar pasta de valores diferentes-2 para dispositivos diferentes-2. Mas isso depende do requisito.

2
sharma_kunal

Outra maneira:

  • Crie mais 2 pastas: valores-grandes + valores-xlarge

  • Coloque: <string name="screentype">LARGE</string> na pasta values-large (strings.xml)

  • Coloque: <string name="screentype">XLARGE</string> na pasta values-xlarge (strings.xml)

  • Em código:

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

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

    // de 4 a 7 polegadas

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

    // de 7 ~ 10 polegadas

    }

1
Frank Nguyen

Você terá que fazer um pouco de computação usando dados fornecidos pela classe DisplayMetrics .

Você tem heightPixel e widthPixels (a resolução da tela em pixels)

Você precisa da diagonal, já que o "tamanho da tela de polegadas" sempre descreve o comprimento da diagonal. Você pode obter a diagonal da tela em pixels (usando pythagore)

diagonalPixel = √ (alturaPixel² + larguraPixels²)

então você pode converter o valor do pixel em polegadas graças ao valor densityDPI:

inchDiag = diagonalPixel/densityDPI.

Espero não ter cometido erros aqui, saiba que os valores que você obtém da classe DisplayMetrics são dados pelo construtor, aparece (em casos muito raros) que eles não estão bem definidos de acordo com o material físico ...

Isso lhe dará o tamanho da tela física, mas provavelmente não é a melhor maneira de gerenciar vários layouts. Mais sobre este assunto

1
Guian

Voila! ???? Isso é tudo o que você precisa para distinguir tablets de telefones

1. Função auxiliar para obter a largura da tela:

private float getScreenWidth() {
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    return Math.min(metrics.widthPixels, metrics.heightPixels) / metrics.density;
}

2. Função para descobrir se um dispositivo é um tablet

boolean isTablet() {
    return getScreenWidth() >= 600;
}

3. Finalmente, se você estiver procurando realizar operações diferentes para diferentes tamanhos de dispositivo:

boolean is7InchTablet() {
    return getScreenWidth() >= 600 && getScreenWidth() < 720;
}

boolean is10InchTablet() {
    return getScreenWidth() >= 720;
}
0
Sagar