C'è un modo per verificare se l'utente sta utilizzando un tablet o un telefono? Ho problemi con la mia funzione di inclinazione e il mio nuovo tablet (Transformer)

Come accennato in precedenza, non si desidera verificare se il dispositivo è un tablet o un telefono, ma si desidera conoscere le funzionalità del dispositivo,

Il più delle volte, la differenza tra un tablet e un telefono è la dimensione dello schermo, motivo per cui si desidera utilizzare diversi file di layout. Questi file sono memorizzati nelle res/layout-<qualifiers>directory. È possibile creare un file XML nella directory res/values-<same qualifiers>per ciascuno dei layout e inserirvi una risorsa int / bool / string per distinguere tra i layout utilizzati.

Esempio:

File res/values/screen.xml(supponendo che res/layout/contenga i file di layout per i portatili)

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

File res/values-sw600dp/screen.xml(supponendo che res/layout-sw600dp/contenga i file di layout per tablet di piccole dimensioni come il Nexus 7)

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

File res/values-sw720dp/screen.xml(supponendo che res/layout-sw720dp/contenga i file di layout per tablet di grandi dimensioni come Nexus 10):

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

Ora il tipo di schermo è accessibile tramite la R.string.screen_typecostante.

Per rilevare se il dispositivo è un tablet utilizzare il seguente codice:

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

Le dimensioni dello schermo LARGE e XLARGE sono determinate dal produttore in base alla distanza dall'occhio in cui devono essere utilizzate (quindi all'idea di un tablet).

Ulteriori informazioni: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

Questo post mi ha aiutato molto,

Purtroppo non ho la reputazione necessaria per valutare tutte le risposte che mi hanno aiutato.

Avevo bisogno di identificare se il mio dispositivo era un tablet o un telefono, con quello avrei potuto implementare la logica dello schermo. E nella mia analisi il tablet deve essere più di 7 pollici (Xlarge) a partire da MDPI.

Ecco il codice qui sotto, che è stato creato sulla base di questo post.

/**
 * Checks if the device is a tablet or a phone
 * 
 * @param 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 xlarge = ((activityContext.getResources().getConfiguration().screenLayout & 
                        Configuration.SCREENLAYOUT_SIZE_MASK) == 
                        Configuration.SCREENLAYOUT_SIZE_XLARGE);

    // If XLarge, checks if the Generalized Density is at least MDPI
    // (160dpi)
    if (xlarge) {
        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;
}

Perché non calcolare la dimensione della diagonale dello schermo e utilizzarla per decidere se il dispositivo è un telefono o un 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 );
}

Naturalmente si può discutere se la soglia debba essere di 9 pollici o meno.

non c'è differenza. Dovresti definire ciò che pensi sia la differenza e verificarlo. Una scheda galassia è un telefono? o un tablet? e perché?

È necessario definire quali funzionalità specifiche si stanno cercando e il codice per quello.

Sembra che tu stia cercando "inclinazione". Penso che sia lo stesso dell'accelerometro (è una parola?). Puoi semplicemente verificare se il dispositivo lo supporta, utilizzando:

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

(da http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . non l'ho provato)

La mia ipotesi è che quando si definisce "Cellulare / Telefono" si desidera sapere se è possibile effettuare una chiamata sul dispositivo che non può essere eseguita su qualcosa che sarebbe definito come un "Tablet". Il modo per verificarlo è di seguito. Se desideri sapere qualcosa in base a sensori, dimensioni dello schermo, ecc., Questa è davvero una domanda diversa.

Inoltre, durante l'utilizzo della risoluzione dello schermo, o la gestione delle risorse di grandi dimensioni rispetto a xlarge, potrebbe essere stato un approccio valido in passato i nuovi dispositivi "mobili" ora stanno arrivando con schermi così grandi e risoluzioni elevate che sfocano questa linea mentre se lo desideri davvero per conoscere la telefonata o nessuna capacità di chiamata, il seguito è "migliore".

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

Basato su Robert Dale Johnson III e Helton Isac, ho ideato questo codice Spero sia utile

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 xlarge = 
         ((activityContext.getResources().getConfiguration().screenLayout & 
           Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE);

    // If XLarge, checks if the Generalized Density is at least MDPI (160dpi)
    if (xlarge) {
        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;
}

Quindi nel tuo codice crea un filtro simile

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

Nel codice sorgente dell'app Google IOSched 2017 , viene utilizzato il seguente metodo:

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

Per coloro che desiderano fare riferimento al codice di Google per decidere quali dispositivi utilizzeranno un'interfaccia utente per tablet, fare riferimento di seguito:

  // SystemUI (status bar) layout policy
        int shortSizeDp = shortSize
                * DisplayMetrics.DENSITY_DEFAULT
                / DisplayMetrics.DENSITY_DEVICE;

        if (shortSizeDp < 600) {
            // 0-599dp: "phone" UI with a separate status & navigation bar
            mHasSystemNavBar = false;
            mNavigationBarCanMove = true;
        } else if (shortSizeDp < 720) {
            // 600-719dp: "phone" UI with modifications for larger screens
            mHasSystemNavBar = false;
            mNavigationBarCanMove = false;
        } else {
            // 720dp: "tablet" UI with a single combined status & navigation bar
            mHasSystemNavBar = true;
            mNavigationBarCanMove = false;
        }
        }

Questo metodo è consigliato da Google. Vedo questo codice nell'app Google Offical per Androidiosched

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

Nessun codice necessario

Le altre risposte elencano molti modi per determinare a livello di codice se il dispositivo è un telefono o tablet. Tuttavia, se leggi la documentazione , questo non è il modo consigliato per supportare schermi di varie dimensioni.

Dichiarare invece risorse diverse per tablet o telefoni. A tale scopo, i miei l'aggiunta di cartelle delle risorse aggiuntive per layout, valuesecc

• Per Android 3.2 (livello API 13) attivo, aggiungi una sw600dpcartella. Questo significa che il s mallest w hezza è almeno 600dp, ossia circa il divario telefono / tablet. Tuttavia, puoi anche aggiungere altre dimensioni. Dai un'occhiata a questa risposta per un esempio di come aggiungere un file di risorse di layout aggiuntivo.

• Se stai supportando anche dispositivi pre Android 3.2, dovrai aggiungere largeo xlargecartelle per supportare i tablet. (I telefoni sono generalmente smalle normal.)

Ecco un'immagine di ciò che potrebbe piacere alle tue risorse dopo aver aggiunto un file XML aggiuntivo per schermi di dimensioni diverse.

Quando si utilizza questo metodo, il sistema determina tutto per te. Non devi preoccuparti di quale dispositivo viene utilizzato in fase di esecuzione. Devi solo fornire le risorse appropriate e lasciare che Android faccia tutto il lavoro.

Appunti

• È possibile utilizzare gli alias per evitare la duplicazione di file di risorse identici.

Documenti Android da leggere

• Supporto di più schermi
• Supporta diverse dimensioni dello schermo
• Distribuire a schermate specifiche

Se scegli come target solo il livello API> = 13, prova

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

Saluti :-)

Pensando alle "nuove" directory accettate (ad esempio valori-sw600dp) ho creato questo metodo in base alla larghezza dello schermo DP:

 public static final int TABLET_MIN_DP_WEIGHT = 450;
 protected static boolean isSmartphoneOrTablet(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 in questo elenco puoi trovare alcuni dei DP dei dispositivi più diffusi e dimensioni dei tablet:

Wdp / Hdp

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

Wdp = Larghezza dp
Hdp = Altezza dp

Bene, la migliore soluzione che ha funzionato per me è abbastanza semplice:

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

Usato così:

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

Non voglio davvero guardare le dimensioni dei pixel, ma mi affido solo alle dimensioni dello schermo.

Funziona bene poiché Nexus 7 (LARGE) viene rilevato come un tablet, ma non Galaxy S3 (NORMAL).

Utilizzare questo metodo che restituisce true quando il dispositivo è un tablet

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

Se il rilevamento della dimensione dello schermo non restituisce il valore corretto sui dispositivi più recenti, provare:

/*
 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.characteristics").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;}
}

Testato su Android 4.2.2 (scusate il mio inglese.)

So che questa non è direttamente una risposta alla tua domanda, ma altre risposte qui danno una buona idea di come identificare le dimensioni dello schermo. Nella tua domanda hai scritto che hai avuto problemi con l'inclinazione e questo è successo anche a me.

Se si esegue il giroscopio (o il sensore di rotazione) su uno smartphone, gli assi X e Y possono essere definiti in modo diverso rispetto a un tablet, in base all'orientamento predefinito di quel dispositivo (ad esempio Samsung GS2 è ritratto predefinito, Samsung GT-7310 è paesaggio predefinito, il nuovo Google Nexus 7 è ritratto predefinito, sebbene sia un tablet!).

Ora, se si desidera utilizzare Gyroscope, si potrebbe trovare una soluzione funzionante per smartphone, ma la confusione dell'asse su alcuni tablet o viceversa.

Se si utilizza una delle soluzioni dall'alto per scegliere solo le dimensioni dello schermo e quindi applicare

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

capovolgere l'asse se ha una dimensione dello schermo grande o xlarge che potrebbe funzionare nel 90% dei casi, ma ad esempio sul Nexus 7 causerà problemi (perché ha un orientamento verticale predefinito e una dimensione dello schermo grande).

Il modo più semplice per risolvere questo problema è fornito nel RotationVectorSample fornito con le dimostrazioni API impostando sceenOrientation su nosensormanifest:

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

com.sec.feature.multiwindow.tablet in Gestione pacchetti è specifico solo per tablet e com.sec.feature.multiwindow.phone è specifico per telefono.

il metodo seguente è il calcolo della lunghezza diagonale dello schermo del dispositivo per decidere che il dispositivo è un telefono o tablet. l'unica preoccupazione per questo metodo è qual è il valore di soglia per decidere se il dispositivo è tablet o meno. nell'esempio seguente l'ho impostato come 7 pollici e sopra.

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

Sta diventando sempre più difficile tracciare il confine tra telefono e tablet. Ad esempio (da agosto 2015) il Samsung Mega 6.3 dispositivo estrae risorse dalle cartelle sw600dp - per quanto riguarda Android è un tablet.

La risposta di @Vyshnavi funziona su tutti i dispositivi che abbiamo testato ma non per Mega 6.3.

@Helton Isac la risposta sopra restituisce Mega 6.3 come telefono - ma dal momento che il dispositivo raccoglie ancora risorse da sw600dp può causare altri problemi - ad esempio se usi un viewpager per telefoni e non per tablet finirai con errori NPE .

Alla fine sembra che ci siano troppe condizioni da verificare e potremmo semplicemente accettare che alcuni telefoni siano in realtà tablet :-P

Questo è il metodo che uso:

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

usando:

Configurazione. SCREENLAYOUT_SIZE_MASK

Configurazione. SCREENLAYOUT_SIZE_LARGE

Questo è il metodo consigliato!

perché usare questo?

Use this method which returns true when the device is a tablet

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

vedo molti modi sopra. la classe Configuration ha la risposta giusta proprio sotto:

    /**
 * Check if the Configuration's current {@link #screenLayout} is at
 * least the given size.
 *
 * @param size The desired size, either {@link #SCREENLAYOUT_SIZE_SMALL},
 * {@link #SCREENLAYOUT_SIZE_NORMAL}, {@link #SCREENLAYOUT_SIZE_LARGE}, or
 * {@link #SCREENLAYOUT_SIZE_XLARGE}.
 * @return Returns true if the current screen layout size is at least
 * the given size.
 */
public boolean isLayoutSizeAtLeast(int size) {
    int cur = screenLayout&SCREENLAYOUT_SIZE_MASK;
    if (cur == SCREENLAYOUT_SIZE_UNDEFINED) return false;
    return cur >= size;
}

chiama soltanto :

 getResources().getConfiguration().
 isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE);

va bene?

Avevo bisogno di rilevare lo smartphone / tablet solo nel file di layout, perché sto usando il codice di navigazione.

Quello che ho fatto prima è stato creare una directory layout-sw600dp ma non funzionava bene perché si sarebbe attivata sul mio Nokia 8 in modalità orizzontale, ma l'altezza dello schermo sarebbe troppo piccola.

Quindi, ho rinominato la directory come layout-sw600dp-h400dp e poi ho ottenuto l'effetto desiderato. Il parametro h-xxxdp dovrebbe dipendere dalla quantità di contenuto che si desidera eliminare dal layout e come tale dovrebbe dipendere dall'applicazione.

Si prega di controllare sotto il codice.

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

Penso che un tablet abbia una larghezza e un'altezza min e max di 600 px,
quindi è necessario conoscere la densità dello schermo e l'altezza / larghezza in dp,
per recuperare il valore:

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;

Ad esempio, c'è una differenza importante (almeno per il mio programma) tra il telefono e il tablet. È l'orientamento predefinito del dispositivo. Il telefono ha un orientamento verticale, il tablet - orizzontale. E rispettivamente metodo per determinare il 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;
}

MODIFICATO: in seguito alle discussioni con Dan Hulme è cambiato il nome del metodo.

Raccomando la libreria Android 'caffeina' che contiene get telefono o tablet e 10 pollici ~!

uso molto semplice.

la biblioteca è qui.

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

e usare

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

Per me la distinzione tra telefono e tablet non è la dimensione del dispositivo e / o la densità dei pixel, che cambierà con tecnologia e gusto, ma piuttosto il rapporto dello schermo. Se sto visualizzando una schermata di testo, devo sapere se, per esempio, sono necessarie 15 linee lunghe (telefono) contro 20 linee più corte (tablet). Per il mio gioco utilizzo quanto segue per una stima del rettangolo a sfera del mio software che tratterà:

    Rect surfaceRect = getHolder().getSurfaceFrame();
    screenWidth = surfaceRect.width();
    screenHeight = surfaceRect.height();
    screenWidthF = (float) screenWidth;
    screenHeightF = (float) screenHeight;
    widthheightratio = screenWidthF/screenHeightF;
    if(widthheightratio>=1.5) {
        isTablet=false;
    }else {
        isTablet=true;
    }

Penso che questo sia il modo più semplice per essere onesti. Questo controllerà le dimensioni dello schermo che viene utilizzato:

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

Buona fortuna!