Tablette ou téléphone - Android


140

Existe-t-il un moyen de vérifier si l'utilisateur utilise une tablette ou un téléphone? J'ai des problèmes avec ma fonction d'inclinaison et ma nouvelle tablette (Transformer)


26
Vous posez la mauvaise question. Peu importe que l'appareil soit un téléphone, une tablette, une télévision, un grille-pain, une tasse à thé ou un thermomètre. Ce qui compte, ce sont les capacités et non la classe de l'appareil définie par le marketing. Veuillez poser une nouvelle question Android décrivant les capacités que vous recherchez et comment détecter si l'appareil dispose de telles capacités, ou comment vous filtrer du marché pour les appareils qui ne disposent pas de ces capacités.
CommonsWare

7
@CommonsWare: parfois, vous souhaitez ajouter des fonctionnalités supplémentaires pour les appareils qui ont un écran plus grand.
Bobs

10
@breceivemail: ce qui signifie que vous devez vérifier si l'appareil dispose d'un écran plus grand. "Écran plus grand"! = "Tablette".
CommonsWare

2
Une meilleure réponse peut être trouvée ici: stackoverflow.com/a/9308284/1750829 Simple comme ça :-)
Ou Kazaz

3
Je souhaite voter contre toute cette page! Un téléphone fait de la téléphonie, pas une tablette. Presque toutes les suggestions sont des hacks sales que personne ne devrait utiliser. Le monde serait meilleur si personne ne revoyait cette page!
Mark Gjøl

Réponses:


122

Comme cela a été mentionné précédemment, vous ne souhaitez pas vérifier si l'appareil est une tablette ou un téléphone mais vous souhaitez connaître les fonctionnalités de l'appareil,

La plupart du temps, la différence entre une tablette et un téléphone réside dans la taille de l'écran, c'est pourquoi vous souhaitez utiliser des fichiers de mise en page différents. Ces fichiers sont stockés dans les res/layout-<qualifiers>répertoires. Vous pouvez créer un fichier XML dans le directoy res/values-<same qualifiers>pour chacune de vos mises en page et y placer une ressource int / bool / string pour distinguer les mises en page que vous utilisez.

Exemple:

Fichier res/values/screen.xml(en supposant qu'il res/layout/contient vos fichiers de mise en page pour les combinés)

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


Fichier res/values-sw600dp/screen.xml(en supposant qu'il res/layout-sw600dp/contient vos fichiers de mise en page pour les petites tablettes comme la Nexus 7)

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


Fichier res/values-sw720dp/screen.xml(en supposant qu'il res/layout-sw720dp/contient vos fichiers de mise en page pour les grandes tablettes comme le Nexus 10):

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


Désormais, le type d'écran est accessible via la R.string.screen_typeconstante.


4
+1, excellente réponse car elle fournit plus d'informations sur les raisons pour lesquelles vous souhaitez réellement rechercher une tablette / téléphone. Nous approchons d'un moment où les téléphones deviendront de toute façon de petites tablettes;)
andr

Comment cela s'applique-t-il aux gros téléphones, tels que le Galaxy Note et le nouveau Nexus 6? En utilisant cette technique, ces gros appareils seront-ils détectés comme des téléphones ou des tablettes?
PerracoLabs

1
Malheureusement, cette approche ne fonctionne pas pour l'appareil Samsung Mega 6.3 et le renvoie sous forme de tablette (sw600dp) - d'autres idées pour capturer cela?
bkurzius

les tablettes passent-elles des appels téléphoniques?
Mike

61

Pour détecter si l'appareil est une tablette ou non, utilisez le code suivant:

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

Les tailles d'écran LARGE et XLARGE sont déterminées par le fabricant en fonction de la distance de l'œil à laquelle elles doivent être utilisées (d'où l'idée d'une tablette).

En savoir plus: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f


Sur les deux - Kindle Fire et Motorola Droid Bionic - le SCREENLAYOUT_SIZE_MASK == 15. Alors, pourquoi votre solution fonctionnerait-elle?
IgorGanapolsky

Je crois que cela est vrai sur le Kindle Fire. Je n'ai pas de bionique sur moi aujourd'hui ... mais je vérifierai dans quelques jours quand mon ami reviendra en ville. Cependant ... J'ai testé la réponse d'Helton Isac et cela fonctionne à merveille. Veuillez vérifier cela aussi.
petey

4
Il y a Configuration.SCREENLAYOUT_SIZE_XLARGE, donc vous n'avez pas besoin d'utiliser une constante, et vous pouvez l'utiliser >= LARGE.
Triang3l

2
Galaxy Note semble signaler SCREENLAYOUT_SIZE_LARGE donc il serait à tort classé comme tablette
miguelSantirso

1
Si la police du périphérique est petite et la taille d'affichage est petite dans les paramètres, ce cas est retourné vrai.
arul le

38

Ce post m'a beaucoup aidé,

Malheureusement, je n'ai pas la réputation nécessaire pour évaluer toutes les réponses qui m'ont aidé.

J'avais besoin d'identifier si mon appareil était une tablette ou un téléphone, avec cela je pourrais implémenter la logique de l'écran. Et dans mon analyse, la tablette doit mesurer plus de 7 pouces (Xlarge) à partir de MDPI.

Voici le code ci-dessous, qui a été créé à partir de cet article.

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

2
La meilleure solution que j'ai trouvée, merci Helton Isac! Peut-être pouvez-vous ajouter (pour une meilleure solution) un chèque pour les pouces de l'écran? de toute façon, un 10 pour cette solution
Aracem

7
Je suis vraiment en désaccord. C'est une méthode pour trouver une certaine taille d'écran. Encore une fois, comme je l'ai répondu, il n'y a AUCUNE différence entre une tablette et un téléphone. Ce n'est pas une réponse à la question. Il n'est pas possible de différencier car il n'y a pas de différence 1. Si vous avez besoin de coder pour certaines fonctionnalités (comme vous semblez le faire pour certaines tailles d'écran), faites-le, mais n'appelez pas cela tablette vs téléphone. Le sujet de départ semblait mettre la ligne @ certaines fonctionnalités d'inclinaison. Lisez attentivement le commentaire de @commonware sur la question.
Nanne

1
Je suis d'accord avec Nanne, mais comme je l'ai dit, dans mon application, je dois afficher deux panneaux si l'écran est assez grand pour le faire. Et je ne peux pas utiliser de dispositions dans ce cas, car la logique de l'écran était du côté Java.
Helton Isac

3
Helton, merci pour ça. Je pensais que je dirais que cela revient: Kindle Fire: faux, Moto Xoom (v1): vrai, Galaxy Note: faux, Galaxy Tab 10.1 limité: vrai
Petey

Mis à part l'argument, Configuration.SCREENLAYOUT_SIZE_XLARGE = 4 selon developer.android.com/reference/android/content/res/... qui peut être utilisé à la place pour le niveau d'API inférieur à 9.
trgraglia

12

Pourquoi ne pas calculer la taille de la diagonale de l'écran et l'utiliser pour décider si l'appareil est un téléphone ou une tablette?

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

Bien sûr, on peut se demander si le seuil doit être de 9 pouces ou moins.


Cela ne fonctionne pas ... simplement certains téléphones rapportent les mauvaises valeurs de densité et le calcul en pouces échoue - voir là: stackoverflow.com/questions/2193457
...

Eh bien, j'aime les tablettes 7 '(format de poche) et cette réponse est la meilleure que je pense. Mais revenez (screenDiagonal> = 9.0); devrait être return (screenDiagonal> = 6.5). Cependant dépendant de l'utilisation comme commenté dans les commentaires à la question.
Jan Bergström

11

il n'y a pas de différence. Vous devez définir ce que vous pensez être la différence et vérifier cela. Un onglet Galaxy est-il un téléphone? ou une tablette? et pourquoi?

Vous devez définir les fonctionnalités spécifiques que vous recherchez et coder pour cela.

Il semble que vous recherchez «inclinaison». Je pense que c'est la même chose que l'accéléromètre (est-ce un mot?). Vous pouvez simplement vérifier si l'appareil le prend en charge, en utilisant:

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/ . Je ne l'ai pas testé)


J'ai des problèmes avec ma fonction d'inclinaison et ma nouvelle tablette (Transformer)
Benny

Une sorte de réponse idiote imo - bien sûr, il y a une différence. Galaxy = téléphone. Pourquoi? Parce que c'est un "smartphone" selon le fabricant pour un. Si vous laissez entendre qu'il a besoin de vérifier sa taille, sa capacité à appeler, ou ... quoi que ce soit, dites-le simplement.
Dave

3
Je ne suis pas d'accord, cela pourrait ne pas fonctionner pour tous les mobiles, alors que certaines tablettes ont ces capteurs. C'est pourquoi ma réponse initiale à propos de l'absence de différence. Quoi qu'il en soit, j'ai ajouté du code que vous devriez essayer.
Nanne

2
Le problème est que, comme les tablettes sont "construites" en mode paysage, les axes x et y de l'accéléromètre sont inversés lorsque vous prévoyez que votre application s'exécute en mode portrait. Cela peut gâcher un peu les choses :) Il est donc essentiel de vérifier la météo que vous utilisez sur une tablette ou non.
pumpkee

1
Mais alors c'est l'inverse => si c'est la seule chose qui fait d'un appareil une tablette, vous devriez découvrir comment fonctionne l'axe x / y, et non l'inverse. Je doute d'ailleurs que cela soit vrai pour toutes les tablettes et / ou téléphones?
Nanne

10

Je suppose que lorsque vous définissez «Mobile / Téléphone», vous souhaitez savoir si vous pouvez passer un appel téléphonique sur l'appareil, ce qui ne peut pas être fait sur quelque chose qui serait défini comme une «tablette». La façon de vérifier cela est ci-dessous. Si vous souhaitez savoir quelque chose en fonction des capteurs, de la taille de l'écran, etc., c'est vraiment une question différente.

En outre, tout en utilisant la résolution d'écran, ou la gestion des ressources large par rapport à xlarge, peut avoir été une approche valide dans le passé, de nouveaux appareils `` mobiles '' sont maintenant livrés avec des écrans si grands et des résolutions élevées qu'ils brouillent cette ligne si vous le souhaitez vraiment pour connaître les appels téléphoniques par rapport à aucune capacité d'appel téléphonique, ce qui suit est «meilleur».

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

9
Certaines tablettes peuvent téléphoner et avoir un type GSM ou CDMA ... Donc votre solution n'est pas parfaite aussi.
arnouf du

6

Basé sur Robert Dale Johnson III et Helton Isac, j'ai trouvé ce code J'espère que c'est 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;
}

Donc, dans votre code, créez un filtre comme

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

6

Dans le code source de l' application Google IOSched 2017 , la méthode suivante est utilisée:

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

3

Pour ceux qui souhaitent se référer au code de Google pour décider quels appareils utiliseront une interface utilisateur pour tablette, vous pouvez vous référer ci-dessous:

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

2
quelle est la valeur de shortSize?
kc ochibili

3

Cette méthode est une recommandation de Google. Je vois ce code dans l'application Android officielle Googleiosched

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

Cette solution ne fonctionne par exemple pas sur un émulateur avec API 18 et Nexus 7 1200 x 1920 xhdpi!
Ingo

1
vous devriez tester sur un appareil réel :)
hqt

J'ai testé sur Emulator et le résultat de "isTablet (contexte de contexte) était faux. Essayez par vous-même sur Emulator.
Ingo

1
Merci pour ce @hqt, je viens de le transcoder en C # nécessaire pour Xamarin Studio:public static bool isTablet (Context context) { return (context.Resources.Configuration.ScreenLayout & Android.Content.Res.ScreenLayout.SizeMask) >= Android.Content.Res.ScreenLayout.SizeLarge; }
Phil Ryan

2

Aucun code nécessaire

Les autres réponses répertorient de nombreuses façons de déterminer par programme si l'appareil est un téléphone ou une tablette. Cependant, si vous lisez la documentation , ce n'est pas la méthode recommandée pour prendre en charge différentes tailles d'écran.

Au lieu de cela, déclarez différentes ressources pour les tablettes ou les téléphones. Pour ce faire , mes dossiers en ajoutant des ressources supplémentaires pour layout, valuesetc.

  • Pour Android 3.2 (niveau d'API 13) activé, ajoutez un sw600dpdossier. Cela signifie que le s mallest w idth est au moins 600dp, qui est approximativement la fracture téléphone / tablette. Cependant, vous pouvez également ajouter d'autres tailles. Consultez cette réponse pour un exemple de la façon d'ajouter un fichier de ressources de mise en page supplémentaire.

  • Si vous prenez également en charge les appareils antérieurs à Android 3.2, vous devrez ajouter largexlarge dossiers ou pour prendre en charge les tablettes. (Les téléphones sont généralement smallet normal.)

Voici une image de ce que vos ressources pourraient aimer après l'ajout de fichiers xml supplémentaires pour différentes tailles d'écran.

entrez la description de l'image ici

Lorsque vous utilisez cette méthode, le système détermine tout pour vous. Vous n'avez pas à vous soucier du périphérique utilisé au moment de l'exécution. Vous fournissez simplement les ressources appropriées et laissez Android faire tout le travail.

Remarques

  • Vous pouvez utiliser alias pour éviter de dupliquer des fichiers de ressources identiques.

Documents Android à lire


2

Si vous ciblez uniquement le niveau d'API> = 13, essayez

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

à votre santé :-)


1

En pensant aux "nouveaux" répertoires acceptés (values-sw600dp par exemple), j'ai créé cette méthode basée sur la largeur de l'écran 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;
}

Et sur cette liste, vous pouvez trouver certains des DP des appareils et des tailles de tablettes populaires:

Wdp / Hdp

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

Wdp = Largeur dp
Hdp = Hauteur dp


1

Eh bien, la meilleure solution qui a fonctionné pour moi est assez simple:

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

Utilisé comme ceci:

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

Je ne veux vraiment pas regarder les tailles de pixels, mais je ne compte que sur la taille de l'écran.

Fonctionne bien car le Nexus 7 (LARGE) est détecté comme une tablette, mais pas le Galaxy S3 (NORMAL).


1

Utilisez cette méthode qui renvoie true lorsque l'appareil est une tablette

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

Cette solution ne fonctionne par exemple pas sur un émulateur avec API 18 et Nexus 7 1200 x 1920 xhdpi!
Ingo

Cela ne fonctionne plus sur certains appareils. Par exemple, il renvoie false pour l'appareil Samsung Mega
bkurzius

Ouais .. Cela ne fonctionne plus ... J'avais l'habitude d'ajouter du booléen dans tout le fichier de chaîne pour chaque dossier values, values_large etc <bool name = "isTablet"> false </bool> <bool name = "isLargeTablet"> false </bool> puis vérifiez si R.bool.isTablet est vrai pour trouver si l'appareil est une tablette
Vyshnavi

1

Si la détection de la taille de l'écran ne renvoie pas la valeur correcte sur les appareils plus récents, essayez:

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

Testé sur Android 4.2.2 (désolé pour mon anglais.)


0

Je sais que ce n'est pas directement une réponse à votre question, mais d'autres réponses ici donnent une bonne idée de la façon d'identifier la taille de l'écran. Vous avez écrit dans votre question que vous aviez des problèmes d'inclinaison et que cela m'est arrivé aussi.

Si vous exécutez le gyroscope (ou le capteur de rotation) sur un smartphone, les axes x et y peuvent être définis différemment que sur une tablette, selon l'orientation par défaut de cet appareil (par exemple, Samsung GS2 est le portrait par défaut, Samsung GT-7310 est paysage par défaut, le nouveau Google Nexus 7 est le portrait par défaut, bien qu'il s'agisse d'une tablette!).

Maintenant, si vous souhaitez utiliser Gyroscope, vous pourriez vous retrouver avec une solution fonctionnelle pour les smartphones, mais la confusion des axes sur certaines tablettes ou l'inverse.

Si vous utilisez l'une des solutions ci-dessus pour choisir uniquement la taille de l'écran, puis appliquez

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

pour retourner l'axe s'il a une taille d'écran grande ou très grande, cela peut fonctionner dans 90% des cas, mais par exemple sur le Nexus 7, cela causera des problèmes (car il a une orientation portrait par défaut et une grande taille d'écran).

Le moyen le plus simple de résoudre ce problème est fourni dans le RotationVectorSample fourni avec les démos de l'API en définissant sceenOrientation sur nosensordans votre manifeste:

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

0

com.sec.feature.multiwindow.tablet dans le gestionnaire de packages est spécifique uniquement à la tablette et com.sec.feature.multiwindow.phone est spécifique au téléphone.


0

La méthode ci-dessous calcule la longueur diagonale de l'écran de l'appareil pour décider que l'appareil est un téléphone ou une tablette. le seul souci de cette méthode est de savoir quelle est la valeur seuil pour décider si l'appareil est une tablette ou non. dans l'exemple ci-dessous, je l'ai défini sur 7 pouces et plus.

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

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

0

Il est de plus en plus difficile de faire la distinction entre le téléphone et la tablette. Par exemple (en août 2015), l'appareil Samsung Mega 6.3 extrait les ressources des dossiers sw600dp - donc en ce qui concerne Android, il s'agit d'une tablette.

La réponse de @Vyshnavi fonctionne dans tous les appareils que nous avons testés mais pas pour Mega 6.3.

La réponse @Helton Isac ci-dessus renvoie le Mega 6.3 en tant que téléphone - mais comme l'appareil saisit toujours des ressources de sw600dp, il peut causer d'autres problèmes - par exemple, si vous utilisez un viewpager pour les téléphones et non pour les tablettes, vous vous retrouverez avec des erreurs NPE .

En fin de compte, il semble juste qu'il y ait trop de conditions à vérifier et nous devrons peut-être accepter que certains téléphones soient en fait des tablettes :-P


0

C'est la méthode que j'utilise:

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

En utilisant:

Configuration. SCREENLAYOUT_SIZE_MASK

Configuration. SCREENLAYOUT_SIZE_LARGE

C'est la méthode recommandée!


Explication pour -1? , c'est une méthode recommandée par google.
Jorgesys

0

pourquoi utiliser ça?

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

Je vois de nombreuses façons ci-dessus.

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

il suffit d'appeler :

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

c'est bon?


0

J'avais besoin de détecter le smartphone / la tablette uniquement dans le fichier de mise en page, car j'utilise le code de navigation.

J'ai d'abord créé un répertoire layout-sw600dp mais cela ne fonctionnait pas bien car il s'activerait sur mon Nokia 8 en mode paysage, mais la hauteur de l'écran serait trop petite.

J'ai donc renommé le répertoire en layout-sw600dp-h400dp et j'ai obtenu l'effet souhaité. Le paramètre h-xxxdp doit dépendre de la quantité de contenu que vous souhaitez déposer sur votre mise en page et, en tant que tel, doit dépendre de l'application.


-1

Veuillez vérifier le code ci-dessous.

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

1
N'est plus valide avec ICS. En effet, il existe des tablettes avec des versions Android inférieures à 11
mdelolmo

1
Ce n'est PAS fiable. Les nouveaux téléphones ICS ont un niveau d'API> 11.
Jason Robinson

-1

Je pense qu'une tablette a une largeur et une hauteur minimale et maximale de 600 px,
il faut donc connaître la densité de l'écran et la hauteur / largeur en dp,
pour récupérer la valeur:

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;


Ce n'est pas correct car Samsung Galaxy S3 resultion 720 x 1280.
Nikhil

-1

Par exemple, avoir une différence importante (au moins pour mon programme) entre le téléphone et la tablette. Il s'agit de l'orientation par défaut de l'appareil. Le téléphone a une orientation portrait, la tablette - paysage. Et respectivement méthode pour déterminer l'appareil:

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

EDITED: Suite aux discussions avec Dan Hulme a changé le nom de la méthode.


1
Toutes les tablettes n'ont pas une orientation paysage par défaut. Et si l'orientation «par défaut» est importante pour votre programme, elle est probablement erronée à d'autres égards. Voir cet article du blog des développeurs Android pour un exemple.
Dan Hulme

Pouvez-vous donner des exemples spécifiques de tablettes dont la largeur par défaut est inférieure à la hauteur? Et bien sûr, vous savez mieux ce que devrait être mon application: D.
Argent

Le Nexus 7 en serait un exemple. Mais vous n'avez pas à me croire sur parole: lisez l'article que j'ai lié, qui explique tout.
Dan Hulme

Je pense qu'il faudrait changer le nom de ma méthode. En fait, plus important encore (au moins pour mon application;)) l'orientation de l'appareil par défaut, et ma méthode est adéquate pour cette tâche. Également très correctement identifié le problème @Nanne answer, voir ci-dessus.
Argent du


-1

Pour moi, la distinction entre téléphone et tablette n'est pas la taille de l'appareil et / ou la densité de pixels, qui changera avec la technologie et le goût, mais plutôt le rapport d'écran. Si j'affiche un écran de texte, j'ai besoin de savoir si, disons, 15 longues lignes sont nécessaires (téléphone) contre 20 lignes plus courtes (tablette). Pour mon jeu, j'utilise ce qui suit pour une estimation approximative du rectangle que mon logiciel traitera:

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

-3

Je pense que c'est la façon la plus simple d'être honnête. Cela vérifiera la taille de l'écran utilisée:

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

Bonne chance!

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.