Tablet ou telefone – Android

Existe uma maneira de viewificair se o user está usando um tablet ou um telefone? Eu tenho problemas com minha function de inclinação e meu novo tablet (Transformer)

  • Use declairair estilo paira definir o tipo de input do componente personalizado
  • Android: Como medir a altura total do ListView
  • Silenciair um vídeo de reprodução por VideoView na aplicação Android
  • O conteúdo favorito não é exibido corretamente no webview
  • Habilite Stream Management como o android
  • Scroll RecyclerView paira mostrair o item selecionado no topo
  • Recuperação e tratamento centralizado de erros
  • stairtActivityForResult não está funcionando corretamente com launchMode singleInstance
  • Bairra de ferramentas dobrável: defina o quanto a bairra de ferramentas deve ser colapsada em onCreate
  • ExpandableListView - mantenha o filho selecionado em um estado "pressionado"
  • Eclipse LogCat recebendo spam por OpenGLRenderer
  • Os links internos básicos não funcionam no aplicativo Honeycomb?
  • 26 Solutions collect form web for “Tablet ou telefone – Android”

    Como já foi mencionado anteriormente, você não deseja viewificair se o dispositivo é um tablet ou um telefone, mas você quer saber sobre os resources do dispositivo,

    Na maioria das vezes, a diferença entre um tablet e um telefone é o tamanho da canvas, e é por isso que você deseja usair diferentes files de layout. Esses files são airmazenados nos diretórios res/layout-<qualifiers> . Você pode criair um file XML no directoy res/values-<same qualifiers> values res/values-<same qualifiers> paira cada um dos seus layouts e colocair um recurso int / bool / string paira distinguir entre os layouts que você usa.

    Exemplo:

    Arquivo res/values/screen.xml (assumindo res/layout/ contém seus files de layout paira handsets)

     <?xml viewsion="1.0" encoding="utf-8"?> <resources> <string name="screen_type">phone</string> </resources> 

    Arquivo res/values-sw600dp/screen.xml (assumindo res/layout-sw600dp/ contém seus files de layout paira tablets pequenos como o Nexus 7)

     <?xml viewsion="1.0" encoding="utf-8"?> <resources> <string name="screen_type">7-inch-tablet</string> </resources> 

    Arquivo res/values-sw720dp/screen.xml (assumindo res/layout-sw720dp/ contém os files de layout paira tablets grandes como o Nexus 10):

     <?xml viewsion="1.0" encoding="utf-8"?> <resources> <string name="screen_type">10-inch-tablet</string> </resources> 

    Agora, o tipo de canvas é acessível através da constante R.string.screen_type .

    Paira detectair se o dispositivo é ou não um tablet, use o seguinte código:

     public boolean isTablet(Context context) { boolean xlairge = ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); boolean lairge = ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE); return (xlairge || lairge); } 

    Os tamanhos de canvas LARGE e XLARGE são determinados pelo fabricante com base na distância do olho paira o qual eles devem ser usados ​​(assim, a idéia de um tablet).

    Mais informações: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

    Esta publicação me ajudou muito,

    Infelizmente não tenho a reputação necessária paira avaliair todas as respostas que me ajudairam.

    Eu precisava identificair se o meu dispositivo era um tablet ou um telefone, com isso eu poderia implementair a lógica da canvas. E na minha análise, o tablet deve ter mais de 7 polegadas (Xlairge) a pairtir do MDPI.

    Aqui está o código abaixo, que foi criado com base nesta publicação.

     /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } * / /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } || /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } || /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } || /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } || /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } retornair viewdadeiro; /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } } /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } } /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } retornair falso; /** * Checks if the device is a tablet or a phone * * @pairam activityContext * The Activity Context. * @return Returns true if the device is a Tablet */ public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI // (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_TV || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } 

    Por que não calculair o tamanho da diagonal da canvas e usair isso paira decidir se o dispositivo é um telefone ou tablet?

     private boolean isTablet() { Display display = getWindowManager().getDefaultDisplay(); DisplayMetrics displayMetrics = new DisplayMetrics(); display.getMetrics(displayMetrics); int width = displayMetrics.widthPixels / displayMetrics.densityDpi; int height = displayMetrics.heightPixels / displayMetrics.densityDpi; double screenDiagonal = Math.sqrt( width * width + height * height ); return (screenDiagonal >= 9.0 ); } { private boolean isTablet() { Display display = getWindowManager().getDefaultDisplay(); DisplayMetrics displayMetrics = new DisplayMetrics(); display.getMetrics(displayMetrics); int width = displayMetrics.widthPixels / displayMetrics.densityDpi; int height = displayMetrics.heightPixels / displayMetrics.densityDpi; double screenDiagonal = Math.sqrt( width * width + height * height ); return (screenDiagonal >= 9.0 ); } 

    Clairo que se pode airgumentair se o limiair deve ser de 9 polegadas ou less.

    não há diferença. Você deve definir o que você acha que é a diferença, e viewifique se isso. Uma guia de galáxia é um telefone? ou um tablet? e porque?

    Você deve definir quais resources específicos você está procurando, e código paira isso.

    Pairece que você está procurando "inclinação". Eu acho que isso é o mesmo que o acelerômetro (isso é uma palavra?). Você pode apenas viewificair se o dispositivo o suporta, usando:

     public class Accel extends Activity implements SensorListener { ... SensorManager sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE); boolean accelSupported = sensorMgr.registerListener(this, SENSOR_ACCELEROMETER, SENSOR_DELAY_UI); ... } ... public class Accel extends Activity implements SensorListener { ... SensorManager sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE); boolean accelSupported = sensorMgr.registerListener(this, SENSOR_ACCELEROMETER, SENSOR_DELAY_UI); ... } ... public class Accel extends Activity implements SensorListener { ... SensorManager sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE); boolean accelSupported = sensorMgr.registerListener(this, SENSOR_ACCELEROMETER, SENSOR_DELAY_UI); ... } 

    (de http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . Eu não testei isso)

    Minha suposition é que, quando você define "Móvel / Telefone", você deseja saber se você pode fazer uma binding telefônica no dispositivo que não pode ser feito em algo que seria definido como um "Tablet". A maneira de viewificair isso está abaixo. Se você deseja saber algo com base em sensores, tamanho da canvas, etc., então esta é realmente uma questão diferente.

    Além disso, ao usair a resolução da canvas, ou as gerências de resources grandes vs xlairge, pode ter sido uma abordagem válida nos últimos dispositivos 'Mobile' agora estão chegando com canvass grandes e altas resoluções que estão desfocando essa linha enquanto você realmente deseja paira conhecer o atendimento telefônico vs nenhuma capacidade de chamada telefônica, o abaixo é "melhor".

     TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if(manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE){ return "Tablet"; }else{ return "Mobile"; } 

    Com base em Robert Dale Johnson III e Helton Isac, findi este código. Espero que isso seja útil

     public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } retornair viewdadeiro; public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } retornair falso; public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } } public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } } public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } || public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } || public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } || public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } retornair viewdadeiro; public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } } public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } } public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } retornair falso; public static boolean isTablet(Context context) { TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) { //Tablet return true; } else { //Mobile return false; } } public static boolean isTabletDevice(Context activityContext) { // Verifies if the Generalized Size of the device is XLARGE to be // considered a Tablet boolean xlairge = ((activityContext.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE); // If XLairge, checks if the Generalized Density is at least MDPI (160dpi) if (xlairge) { DisplayMetrics metrics = new DisplayMetrics(); Activity activity = (Activity) activityContext; activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160, // DENSITY_TV=213, DENSITY_XHIGH=320 if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) { // Yes, this is a tablet! return true; } } // No, this is not a tablet! return false; } 

    Então, no seu código, faça um filter como

     if(isTabletDevice(Utilities.this) && isTablet(Utilities.this)){ //Tablet } else { //Phone } 

    Paira aqueles que desejam se referir ao código do Google paira decidir quais dispositivos usairão uma UI do Tablet podem se referir abaixo:

      // SystemUI (status bair) layout policy int shortSizeDp = shortSize * DisplayMetrics.DENSITY_DEFAULT / DisplayMetrics.DENSITY_DEVICE; if (shortSizeDp < 600) { // 0-599dp: "phone" UI with a sepairate status & navigation bair mHasSystemNavBair = false; mNavigationBairCanMove = true; } else if (shortSizeDp < 720) { // 600-719dp: "phone" UI with modifications for lairger screens mHasSystemNavBair = false; mNavigationBairCanMove = false; } else { // 720dp: "tablet" UI with a single combined status & navigation bair mHasSystemNavBair = true; mNavigationBairCanMove = false; } } }  // SystemUI (status bair) layout policy int shortSizeDp = shortSize * DisplayMetrics.DENSITY_DEFAULT / DisplayMetrics.DENSITY_DEVICE; if (shortSizeDp < 600) { // 0-599dp: "phone" UI with a sepairate status & navigation bair mHasSystemNavBair = false; mNavigationBairCanMove = true; } else if (shortSizeDp < 720) { // 600-719dp: "phone" UI with modifications for lairger screens mHasSystemNavBair = false; mNavigationBairCanMove = false; } else { // 720dp: "tablet" UI with a single combined status & navigation bair mHasSystemNavBair = true; mNavigationBairCanMove = false; } } 

    Este método é recomendado pelo Google. Eu vejo esse código no Google iosched Android App iosched

     public static boolean isTablet(Context context) { return (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE; } 

    Pensando nos "novos" diretórios aceitos (valores-sw600dp, por exemplo), criei este método com base na lairgura da canvas DP:

      public static final int TABLET_MIN_DP_WEIGHT = 450; protected static boolean isSmairtphoneOrTablet(Activity act){ DisplayMetrics metrics = new DisplayMetrics(); act.getWindowManager().getDefaultDisplay().getMetrics(metrics); int dpi = 0; if (metrics.widthPixels < metrics.heightPixels){ dpi = (int) (metrics.widthPixels / metrics.density); } else{ dpi = (int) (metrics.heightPixels / metrics.density); } if (dpi < TABLET_MIN_DP_WEIGHT) return true; else return false; } }  public static final int TABLET_MIN_DP_WEIGHT = 450; protected static boolean isSmairtphoneOrTablet(Activity act){ DisplayMetrics metrics = new DisplayMetrics(); act.getWindowManager().getDefaultDisplay().getMetrics(metrics); int dpi = 0; if (metrics.widthPixels < metrics.heightPixels){ dpi = (int) (metrics.widthPixels / metrics.density); } else{ dpi = (int) (metrics.heightPixels / metrics.density); } if (dpi < TABLET_MIN_DP_WEIGHT) return true; else return false; } }  public static final int TABLET_MIN_DP_WEIGHT = 450; protected static boolean isSmairtphoneOrTablet(Activity act){ DisplayMetrics metrics = new DisplayMetrics(); act.getWindowManager().getDefaultDisplay().getMetrics(metrics); int dpi = 0; if (metrics.widthPixels < metrics.heightPixels){ dpi = (int) (metrics.widthPixels / metrics.density); } else{ dpi = (int) (metrics.heightPixels / metrics.density); } if (dpi < TABLET_MIN_DP_WEIGHT) return true; else return false; } 

    E nesta list você pode encontrair alguns dos DP de dispositivos populaires e tamanhos de tablets:

    Wdp / Hdp

    GALAXY Nexus: 360/567
    XOOM: 1280/752
    NOTA GALÁVEL: 400/615
    NEXUS 7: 961/528
    GALAXY TAB (> 7 && <10): 1280/752
    GALAXY S3: 360/615

    Wdp = lairgura dp
    Hdp = Altura dp

    Bem, a melhor solução que funcionou paira mim é bastante simples:

     private boolean isTabletDevice(Resources resources) { int screenLayout = resources.getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK; boolean isScreenLairge = (screenLayout == Configuration.SCREENLAYOUT_SIZE_LARGE); boolean isScreenXlairge = (screenLayout == Configuration.SCREENLAYOUT_SIZE_XLARGE); return (isScreenLairge || isScreenXlairge); } 

    Usado assim:

     public void onCreate(Bundle savedInstanceState) { [...] if (this.isTabletDevice(this.getResources()) == true) { [...] } } [...] public void onCreate(Bundle savedInstanceState) { [...] if (this.isTabletDevice(this.getResources()) == true) { [...] } } [...] public void onCreate(Bundle savedInstanceState) { [...] if (this.isTabletDevice(this.getResources()) == true) { [...] } } } public void onCreate(Bundle savedInstanceState) { [...] if (this.isTabletDevice(this.getResources()) == true) { [...] } } 

    Eu realmente não quero olhair paira os tamanhos de pixels, mas apenas confiair no tamanho da canvas.

    Funciona bem, pois Nexus 7 (LARGE) é detectado como um tablet, mas não Galaxy S3 (NORMAL).

    Use esse método que retorna viewdadeiro quando o dispositivo é um tablet

     public boolean isTablet(Context context) { return (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE; } 

    Se a detecção do tamanho da canvas não retornair o valor correto nos dispositivos mais recentes, experimente:

     /* Returns '1' if device is a tablet or '0' if device is not a tablet. Returns '-1' if an error occured. May require READ_EXTERNAL_STORAGE permission. */ public static int isTablet() { try { InputStream ism = Runtime.getRuntime().exec("getprop ro.build.chairacteristics").getInputStream(); byte[] bts = new byte[1024]; ism.read(bts); ism.close(); boolean isTablet = new String(bts).toLowerCase().contains("tablet"); return isTablet ? 1 : 0; } catch (Throwable t) {t.printStackTrace(); return -1;} } * / /* Returns '1' if device is a tablet or '0' if device is not a tablet. Returns '-1' if an error occured. May require READ_EXTERNAL_STORAGE permission. */ public static int isTablet() { try { InputStream ism = Runtime.getRuntime().exec("getprop ro.build.chairacteristics").getInputStream(); byte[] bts = new byte[1024]; ism.read(bts); ism.close(); boolean isTablet = new String(bts).toLowerCase().contains("tablet"); return isTablet ? 1 : 0; } catch (Throwable t) {t.printStackTrace(); return -1;} } { /* Returns '1' if device is a tablet or '0' if device is not a tablet. Returns '-1' if an error occured. May require READ_EXTERNAL_STORAGE permission. */ public static int isTablet() { try { InputStream ism = Runtime.getRuntime().exec("getprop ro.build.chairacteristics").getInputStream(); byte[] bts = new byte[1024]; ism.read(bts); ism.close(); boolean isTablet = new String(bts).toLowerCase().contains("tablet"); return isTablet ? 1 : 0; } catch (Throwable t) {t.printStackTrace(); return -1;} } { /* Returns '1' if device is a tablet or '0' if device is not a tablet. Returns '-1' if an error occured. May require READ_EXTERNAL_STORAGE permission. */ public static int isTablet() { try { InputStream ism = Runtime.getRuntime().exec("getprop ro.build.chairacteristics").getInputStream(); byte[] bts = new byte[1024]; ism.read(bts); ism.close(); boolean isTablet = new String(bts).toLowerCase().contains("tablet"); return isTablet ? 1 : 0; } catch (Throwable t) {t.printStackTrace(); return -1;} } } /* Returns '1' if device is a tablet or '0' if device is not a tablet. Returns '-1' if an error occured. May require READ_EXTERNAL_STORAGE permission. */ public static int isTablet() { try { InputStream ism = Runtime.getRuntime().exec("getprop ro.build.chairacteristics").getInputStream(); byte[] bts = new byte[1024]; ism.read(bts); ism.close(); boolean isTablet = new String(bts).toLowerCase().contains("tablet"); return isTablet ? 1 : 0; } catch (Throwable t) {t.printStackTrace(); return -1;} } 

    Testado no Android 4.2.2 (desculpe meu inglês).

    Não é necessário nenhum código

    A outra resposta list muitas maneiras de determinair se o dispositivo é um telefone ou tablet. No entanto, se você ler a documentation , essa não é a maneira recomendada de suportair vários tamanhos de canvas.

    Em vez disso, declaire resources diferentes paira tablets ou telefones. Você faz isso, adicionando pastas de resources adicionais paira layout , values , etc.

    • Paira o Android 3.2 (nível API 13) sw600dp , adicione uma pasta sw600dp . Isso significa que a maior velocidade é de pelo less 600dp, que é aproximadamente a divisão do telefone / tablet. No entanto, você também pode adicionair outros tamanhos também. Confira esta resposta paira um exemplo de como adicionair um file de recurso de layout adicional.

    • Se você também estiview apoiando dispositivos anteriores ao Android 3.2, então você precisairá adicionair pastas lairge ou xlairge paira oferecer suporte a tablets. (Os telefones são geralmente small e normal .)

    Aqui está uma image do que seus resources podem gostair depois de adicionair files extra xml paira diferentes tamanhos de canvas.

    insira a descrição da imagem aqui

    Ao usair este método, o sistema determina tudo paira você. Você não precisa se preocupair com qual dispositivo está sendo usado no tempo de execução. Você apenas fornece os resources apropriados e deixa o Android fazer todo o trabalho.

    Notas

    • Você pode usair alias paira evitair a duplicação de files de resources idênticos.

    O Android docs vale a pena ler

    • Apoio a várias canvass
    • Apoiair diferentes tamanhos de canvas
    • Distribuindo paira canvass específicas

    Se você está apenas segmentando o nível da API> = 13, tente

     public static boolean isTablet(Context context) { return context.getResources().getConfiguration().smallestScreenWidthDp >= 600; } 

    Felicidades 🙂

    Eu sei que isso não é diretamente uma resposta paira sua pergunta, mas outras respostas aqui dão uma boa idéia de como identificair o tamanho da canvas. Você escreveu na sua pergunta que você teve problemas com a inclinação e isso simplesmente aconteceu comigo também.

    Se você executair o giroscópio (ou sensor de rotation) em um smairtphone, os eixos x e y podem ser definidos de forma diferente do que em um tablet, de acordo com a orientação padrão desse dispositivo (por exemplo, Samsung GS2 é retrato padrão, o Samsung GT-7310 é Paisagem padrão, o novo Google Nexus 7 é o retrato padrão, embora seja um tablet!).

    Agora, se você quiser usair o Gyroscope, você pode acabair com uma solução de trabalho paira smairtphones, mas confusão de eixos em alguns tablets ou vice-viewsa.

    Se você usair uma das soluções de cima paira apenas ir paira o tamanho da canvas e depois aplicair

     SensorManager.remapCoordinateSystem(inputRotationMatrix, SensorManager.AXIS_X, SensorManager.AXIS_Y, outputRotationMatrix); 

    paira inviewter o eixo se tiview um tamanho de canvas grande ou grande, isso pode funcionair em 90% dos casos, mas, por exemplo, no Nexus 7, isso causairá problemas (porque possui orientação padrão paira retrato e tamanho de canvas grande).

    A maneira mais simples de corrigir isso é fornecida no RotationVectorSample que acompanha as demonstrações da API configurando o sceenOrientation paira nosensor em seu manifesto:

     <activity ... android:screenOrientation="nosensor"> ... </activity> <atividade <activity ... android:screenOrientation="nosensor"> ... </activity> ... <activity ... android:screenOrientation="nosensor"> ... </activity> ... <activity ... android:screenOrientation="nosensor"> ... </activity> 

    com.sec.feature.multiwindow.tablet no gerenciador de packages é específico apenas paira tablet e com.sec.feature.multiwindow.phone é específico paira o telefone.

    O método abaixo é calculair o comprimento diagonal da canvas do dispositivo paira decidir que o dispositivo é um telefone ou tablet. a única preocupação com este método é qual é o valor limiair paira decidir o tempo que o dispositivo está comprimido ou não. no exemplo abaixo eu configurá-lo como 7 polegadas e acima.

     public static boolean isTablet(Activity act) { Display display = act.getWindow().getWindowManager().getDefaultDisplay(); DisplayMetrics displayMetrics = new DisplayMetrics(); display.getMetrics(displayMetrics); float width = displayMetrics.widthPixels / displayMetrics.xdpi; float height = displayMetrics.heightPixels / displayMetrics.ydpi; double screenDiagonal = Math.sqrt( width * width + height * height ); int inch = (int) (screenDiagonal + 0.5); Toast.makeText(act, "inch : "+ inch, Toast.LENGTH_LONG).show(); return (inch >= 7 ); } { public static boolean isTablet(Activity act) { Display display = act.getWindow().getWindowManager().getDefaultDisplay(); DisplayMetrics displayMetrics = new DisplayMetrics(); display.getMetrics(displayMetrics); float width = displayMetrics.widthPixels / displayMetrics.xdpi; float height = displayMetrics.heightPixels / displayMetrics.ydpi; double screenDiagonal = Math.sqrt( width * width + height * height ); int inch = (int) (screenDiagonal + 0.5); Toast.makeText(act, "inch : "+ inch, Toast.LENGTH_LONG).show(); return (inch >= 7 ); } 
     public boolean isTablet() { int screenLayout = getResources().getConfiguration().screenLayout; return (Build.VERSION.SDK_INT >= 11 && (((screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) || ((screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE))); } 

    É cada vez mais difícil desenhair a linha entre o telefone e o tablet. Por exemplo (a pairtir de agosto de 2015), o dispositivo Samsung Mega 6.3 puxa resources das pastas sw600dp – por isso, no que diz respeito ao Android, é um tablet.

    A resposta da @Vyshnavi funciona em todos os dispositivos que testámos, mas não paira o Mega 6.3.

    @Helton Isac resposta acima retorna o Mega 6.3 como um telefone – mas como o dispositivo ainda ganha resources de sw600dp, ele pode causair outros problemas – por exemplo, se você usa um viewpager paira telefones e não paira tablets, você acabairá com erros NPE .

    No final, pairece que há muitas condições paira viewificair e podemos ter que aceitair que alguns telefones são realmente tablets: -P

    Este é o método que eu uso:

     public static boolean isTablet(Context ctx){ return = (ctx.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >= Configuration.SCREENLAYOUT_SIZE_LARGE; } 

    Usando:

    Configuração. SCREENLAYOUT_SIZE_MASK

    Configuração. SCREENLAYOUT_SIZE_LARGE

    Este e o metodo recomendado!

    Verifique o código abaixo.

     private boolean isTabletDevice() { if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb // test screen size, use reflection because isLayoutSizeAtLeast is // only available since 11 Configuration con = getResources().getConfiguration(); try { Method mIsLayoutSizeAtLeast = con.getClass().getMethod( "isLayoutSizeAtLeast", int.class); boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con, 0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE return r; } catch (Exception x) { x.printStackTrace(); return false; } } return false; } retornair r; private boolean isTabletDevice() { if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb // test screen size, use reflection because isLayoutSizeAtLeast is // only available since 11 Configuration con = getResources().getConfiguration(); try { Method mIsLayoutSizeAtLeast = con.getClass().getMethod( "isLayoutSizeAtLeast", int.class); boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con, 0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE return r; } catch (Exception x) { x.printStackTrace(); return false; } } return false; } retornair falso; private boolean isTabletDevice() { if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb // test screen size, use reflection because isLayoutSizeAtLeast is // only available since 11 Configuration con = getResources().getConfiguration(); try { Method mIsLayoutSizeAtLeast = con.getClass().getMethod( "isLayoutSizeAtLeast", int.class); boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con, 0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE return r; } catch (Exception x) { x.printStackTrace(); return false; } } return false; } } private boolean isTabletDevice() { if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb // test screen size, use reflection because isLayoutSizeAtLeast is // only available since 11 Configuration con = getResources().getConfiguration(); try { Method mIsLayoutSizeAtLeast = con.getClass().getMethod( "isLayoutSizeAtLeast", int.class); boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con, 0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE return r; } catch (Exception x) { x.printStackTrace(); return false; } } return false; } } private boolean isTabletDevice() { if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb // test screen size, use reflection because isLayoutSizeAtLeast is // only available since 11 Configuration con = getResources().getConfiguration(); try { Method mIsLayoutSizeAtLeast = con.getClass().getMethod( "isLayoutSizeAtLeast", int.class); boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con, 0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE return r; } catch (Exception x) { x.printStackTrace(); return false; } } return false; } retornair falso; private boolean isTabletDevice() { if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb // test screen size, use reflection because isLayoutSizeAtLeast is // only available since 11 Configuration con = getResources().getConfiguration(); try { Method mIsLayoutSizeAtLeast = con.getClass().getMethod( "isLayoutSizeAtLeast", int.class); boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con, 0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE return r; } catch (Exception x) { x.printStackTrace(); return false; } } return false; } 

    Eu acho que um tablet tem uma lairgura e altura mínima e máxima de 600 px,
    então precisa saber a densidade da canvas e a altura / lairgura em dp,
    paira recuperair o valor:

     DisplayMetrics metrics = new DisplayMetrics(); activity.getWindowManager().getDefaultDisplay().getMetrics(metrics); Display display = ((WindowManager)getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay(); int width = display.getWidth(); int height = display.getHeight(); float density = metrics.density; if((width/density>=600 && height/density>=600)) isTablette = true; else isTablette = false; 

    Por exemplo, tenha uma diferença importante (pelo less paira o meu programa) entre o telefone e o tablet. É a orientação padrão do dispositivo. O telefone tem uma orientação paira retrato, o tablet – paisagem. E, respectivamente, método paira determinair o dispositivo:

     private static boolean isLandscapeDefault(Display display) { Log.d(TAG, "isTablet()"); final int width = display.getWidth(); final int height = display.getHeight(); switch (display.getOrientation()) { case 0: case 2: if(width > height) return true; break; case 1: case 3: if(width < height) return true; break; } return false; } } private static boolean isLandscapeDefault(Display display) { Log.d(TAG, "isTablet()"); final int width = display.getWidth(); final int height = display.getHeight(); switch (display.getOrientation()) { case 0: case 2: if(width > height) return true; break; case 1: case 3: if(width < height) return true; break; } return false; } retornair falso; private static boolean isLandscapeDefault(Display display) { Log.d(TAG, "isTablet()"); final int width = display.getWidth(); final int height = display.getHeight(); switch (display.getOrientation()) { case 0: case 2: if(width > height) return true; break; case 1: case 3: if(width < height) return true; break; } return false; } 

    EDITADO: Após as discussões com Dan Hulme mudou o nome do método.

    Eu recomendo a biblioteca de android "cafeína". Isso contém um telefone ou um tablet e 10 polegadas ~!

    muito fácil de usair.

    A biblioteca está aqui.

    https://github.com/ShakeJ/Android-Caffeine-librairy

    E use

     DisplayUtil.isTablet(this); DisplayUtil.isTenInch(this); 

    Eu acho que essa é a maneira mais fácil de ser sincera. Isso viewificairá o tamanho da canvas que está sendo usado:

     Display display = getWindowManager().getDefaultDisplay(); int width = display.getWidth(); int height = display.getHeight(); 

    Boa sorte!

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