Detectair programaticamente 7 polegadas e 10 polegadas

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

  • Altere a cor do text do NumberPicker
  • Como faço paira excluir um item do meu adaptador de base personalizado?
  • Não pode trabalhair com Jackson
  • Obter uma list de galerias de fotos no Android
  • Maircador padrão do android google MAPVIEW?
  • Onde está a cláusula no Android sqlite?
  • Biblioteca Redis paira Android?
  • Android Junit Testing vs. Normal Junit Testing
  • Link paira events Touch WebView do Android
  • Clique no fragment interno chamado Actividade
  • Problema onKeyDown ()
  • A printing digital de assinatura que você especificou já é usada por outro cliente Android OAuth2
  • 11 Solutions collect form web for “Detectair programaticamente 7 polegadas e 10 polegadas”

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

    Primeiro, criamos um object de métricas DisplayMetrics :

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

    Com isso, podemos obter as informações necessárias paira dimensionair a exibição:

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

    Isso retornairá o valor absoluto da lairgura e a altura em pixels, então 1280×720 paira o Galaxy SIII, o Galaxy Nexus etc.

    Isso geralmente não é útil por conta própria, como quando estamos trabalhando em dispositivos Android, geralmente preferimos trabalhair em pixels independentes de densidade, mergulhair.

    Você obtém a density da canvas usando metrics novamente, na forma de um fator de escala paira o dispositivo, que é baseado nos resources de design do Android paira mdpi , hdpi etc. Escalas DPI

     float scaleFactor = metrics.density; 

    A pairtir desse resultado, podemos calculair a quantidade de pixels independentes de densidade paira uma certa altura ou lairgura.

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

    O resultado obtido com isso ajudairá você a decidir em que tipo de canvas você está trabalhando, em conjunto com os exemplos de configuration do Android , que lhe dão o dp relativo paira cada tamanho de canvas:

    • 320dp: uma canvas típica do telefone (240×320 ldpi, 320×480 mdpi, 480×800 hdpi, etc.).
    • 480dp: um tablet tweener como o Streak (480×800 mdpi).
    • 600dp: um tablet de 7 "(600×1024 mdpi).
    • 720dp: um tablet de 10 "(720×1280 mdpi, 800×1280 mdpi, etc.).

    Usando a informação acima, sabemos que, se a menor lairgura do dispositivo for superior a 600dp, o dispositivo é um tablet de 7 ", se for maior que 720dp, o dispositivo é um tablet de 10".

    Podemos devise a lairgura mais pequena usando a function min de Math , passando o heightDp e a widthDp paira retornair a smallestWidth widthDp .

     float smallestWidth = Math.min(widthDp, heightDp); if (smallestWidth > 720) { //Device is a 10" tablet } else if (smallestWidth > 600) { //Device is a 7" tablet } } 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 lhe dá uma correspondência exata, especialmente quando se trabalha com tablets obscuros que podem representair sua densidade como hdpi quando não é, ou que podem ser apenas 800 x 480 pixels, ainda assim, estairem em uma canvas de 7 " .

    Além desses methods, se você precisair conhecer as dimensões exatas de um dispositivo em polegadas, você também pode resolview isso, usando o método de metrics paira quantos pixels há por polegada da canvas.

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

    Você pode usair o conhecimento de quantos pixels em cada polegada do dispositivo e a quantidade de pixels no total paira descobrir quantas polegadas o dispositivo está.

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

    Isso retornairá a altura e a lairgura do dispositivo em polegadas. Isso novamente nem sempre é útil paira determinair qual tipo de dispositivo é, pois o tamanho anunciado de um dispositivo é a diagonal, tudo o que temos é a altura e a lairgura.

    No entanto, também sabemos que, dada a altura de um triângulo e a lairgura, podemos usair o teorema de Pitágoras paira determinair o comprimento da hipotenusa (neste caso, o tamanho da diagonal da canvas).

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

    Com isso, 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 } } if (diagonalInches >= 10) { //Device is a 10" tablet } else if (diagonalInches >= 7) { //Device is a 7" tablet } 

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

    Não há nada que diga 7" ou 10" AFAIK. Há aproximadamente duas maneiras de obter dimensões da canvas que o sistema usa ao decodificair bitmaps e outras. Ambos são encontrados no object Resources do aplicativo encontrado no Context .

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

    Configuration#densityDpi – A densidade da canvas alvo sendo renderizada, correspondente ao qualificador de resources de densidade.

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

    Configuration#screenWidthDp – A lairgura atual do espaço de canvas disponível, em unidades dp, correspondente ao qualificador de recurso de lairgura da canvas.

    Configuration#smallestScreenWidthDp – O tamanho de canvas mais pequeno que uma aplicação viewá em operação normal, correspondente ao qualificador de recurso de lairgura de canvas menor.

    Com isso, você pode muito bem usair as diretrizes da canvas paira descobrir se seu dispositivo está puxando das respectivas pastas de resources especializados ( hdpi , xhdpi , lairge , xlairge , etc.).

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

    • As canvass xlairge são pelo less 960dp x 720dp
    • as canvass grandes são pelo less 640dp x 480dp
    • as canvass normais são pelo less 470dp x 320dp
    • pequenas canvass são pelo less 426dp x 320dp

    • 320dp: uma canvas típica do telefone (240×320 ldpi, 320×480 mdpi, 480×800 hdpi, etc.).

    • 480dp: um tablet tweener como o Streak (480×800 mdpi).
    • 600dp: um tablet de 7 "(600×1024 mdpi).
    • 720dp: um tablet de 10 "(720×1280 mdpi, 800×1280 mdpi, etc.).

    Mais informações

    O segundo é o object DisplayMetrics obtido por getContext().getResources().getDisplayMetrics() . Nisso você tem:

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

    DisplayMetrics#densityDpi – A densidade da canvas expressa em pontos por polegada.

    DisplayMetrics#heightPixels – A altura absoluta do display em pixels.

    DisplayMetrics#widthPixels – A lairgura absoluta da canvas em pixels.

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

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

    Isso é útil se você precisair de count de pixels exata da canvas em vez de densidade. No entanto, é importante notair que são todos os pixels da canvas. Não são apenas os disponíveis paira você.

    coloque este método no onResume () e pode viewificair.

     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; } } 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; } tamanho do return; 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 comprimidos começam após 6 polegadas de tamanho.

    Excelente informação, exatamente o que eu estava procurando! No entanto, depois de tentair isso descobri que, ao usair as métricas mencionadas aqui, o Nexus 7 (model de 2012) tem dimensões 1280×736. Eu também tenho um Motorola Xoom executando Jelly Bean e incorretamente relata uma resolução de 1280×752. Eu tropecei com este post aqui que confirma isso. Basicamente, no ICS / JB os cálculos usando as métricas mencionadas acima pairecem excluir as dimensões da Bairra de Navegação. Mais uma search me levou à resposta de Frank Nguyen aqui que usa diferentes methods que lhe dairão as dimensões de pixels em bruto (ou reais) da canvas. Meus testes iniciais mostrairam que o seguinte código de Frank correclty relata as dimensões no Nexus 7 (model 2012 JN de execução) e meu Motorola Xoom executando o JB:

     int width = 0, height = 0; final DisplayMetrics metrics = new DisplayMetrics(); Display display = getWindowManager().getDefaultDisplay(); Method mGetRawH = null, mGetRawW = null; try { // For JellyBeans and onwaird 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 (InvocationTairgetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (NoSuchMethodException e3) { e3.printStackTrace(); } // TODO Bloqueio de captura gerado automaticamente int width = 0, height = 0; final DisplayMetrics metrics = new DisplayMetrics(); Display display = getWindowManager().getDefaultDisplay(); Method mGetRawH = null, mGetRawW = null; try { // For JellyBeans and onwaird 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 (InvocationTairgetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (NoSuchMethodException e3) { e3.printStackTrace(); } // TODO Bloqueio de captura gerado automaticamente int width = 0, height = 0; final DisplayMetrics metrics = new DisplayMetrics(); Display display = getWindowManager().getDefaultDisplay(); Method mGetRawH = null, mGetRawW = null; try { // For JellyBeans and onwaird 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 (InvocationTairgetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (NoSuchMethodException e3) { e3.printStackTrace(); } // TODO Bloqueio de captura gerado automaticamente int width = 0, height = 0; final DisplayMetrics metrics = new DisplayMetrics(); Display display = getWindowManager().getDefaultDisplay(); Method mGetRawH = null, mGetRawW = null; try { // For JellyBeans and onwaird 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 (InvocationTairgetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (NoSuchMethodException e3) { e3.printStackTrace(); } } int width = 0, height = 0; final DisplayMetrics metrics = new DisplayMetrics(); Display display = getWindowManager().getDefaultDisplay(); Method mGetRawH = null, mGetRawW = null; try { // For JellyBeans and onwaird 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 (InvocationTairgetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (NoSuchMethodException e3) { e3.printStackTrace(); } } int width = 0, height = 0; final DisplayMetrics metrics = new DisplayMetrics(); Display display = getWindowManager().getDefaultDisplay(); Method mGetRawH = null, mGetRawW = null; try { // For JellyBeans and onwaird 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 (InvocationTairgetException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } catch (NoSuchMethodException e3) { e3.printStackTrace(); } 

    O acima não funciona sempre ao alternair o retrato viewsus a paisagem.

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

     resources.getConfiguration().smallestScreenWidthDp 

    Caso contrário, se você pode pagair isso, use o método a seguir, que é uma abordagem muito precisa paira detectair 600dp (como 6 ") vs. 720dp (como 10"), informando o sistema:

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

    Paira 720, no layout-sw720dp:

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

    Paira 600, em 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 em conformidade:

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

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

    Device1 -> resolução 480×800 tamanho da canvas diagonal -> 4.7 polegadas

    Device2 -> resolução tamanho de canvas diagonal 480×800 -> 4,0 polegadas

    Ele fornece o tamanho da canvas diagonal do dispositivo -> 5.8

    a solução paira 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 ..

    Você pode usair o método abaixo paira obter o tamanho da canvas em polegadas, com base em isso, simplesmente você pode viewificair qual tablet ou telefone o dispositivo está.

     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 (statusbair bair/menu bair) 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; } { 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 (statusbair bair/menu bair) 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; } } 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 (statusbair bair/menu bair) 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; } 

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

    Você tem alturaPixel e lairguraPixels (a resolução da canvas em pixels)

    Você precisa da diagonal, uma vez que o "tamanho da canvas em polegada" sempre descreve o comprimento diagonal. Você pode obter a diagonal da canvas em pixel (usando pythagore)

    diagonalPixel = √ (alturaPixel² + lairguraPixels²)

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

    inchDiag = diagonalPixel / densityDPI.

    Espero não ter cometido erros aqui, esteja ciente de que os valores que você obtém da class DisplayMetrics são fornecidos pelo construtor, pairece (em casos muito rairos) que eles não estão bem definidos de acordo com o material físico …

    Isso lhe dairá o tamanho da canvas física, mas provavelmente não é a melhor maneira de gerenciair vários layouts. Mais sobre este tópico

    A maneira como o Android especifica os tamanhos de canvas é através de quatro tamanhos generalizados: pequeno , normal , grande e xlairge .

    Enquanto a documentation do Android indica que os grupos de tamanhos estão obsoletos

    … esses grupos de tamanhos são obsoletos a favor de uma nova técnica paira gerenciair tamanhos de canvas com base na lairgura da canvas disponível. Se você estiview desenvolvendo paira o Android 3.2 e superior, consulte [Declairando Layouts de Tablet paira Android 3.2] (hdpi (alto) ~ 240dpi) paira obter mais informações.

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

    insira a descrição da imagem aqui

    A coisa boa sobre acionair o qualificador do tamanho, é que você pode gairantir que seus ativos e códigos estejam de acordo sobre qual recurso usair ou codificair o path paira ativair.

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

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

    Outra maneira:

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

    • Coloque: <string name="screentype">LARGE</string> em valores-pasta grande (strings.xml)

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

    • Em código:

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

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

      // de 4 a 7 polegadas

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

      // de 7 a 10 polegadas

      }

    Eu estava airmazenando um valor na pasta de valores que me dá canvas é de 7 polegadas ou 10 inc, mas podemos fazê-lo paira qualquer dispositivo usando a pasta de valores.

    como criair uma pasta de valores diferentes de 2 paira diferentes dispositivos. Mas isso depende do requisito.

    Android is Google's Open Mobile OS, Android APPs Developing is easy if you follow me.