web-dev-qa-db-fra.com

Déterminer si l'appareil est un smartphone ou une tablette?

J'aimerais obtenir des informations sur un appareil pour savoir s'il s'agit d'un smartphone ou d'une tablette. Comment puis-je le faire?

J'aimerais afficher différentes pages Web à partir de ressources en fonction du type d'appareil:

String s="Debug-infos:";
s += "\n OS Version: " + System.getProperty("os.version") + "(" +    Android.os.Build.VERSION.INCREMENTAL + ")";
s += "\n OS API Level: " + Android.os.Build.VERSION.SDK;
s += "\n Device: " + Android.os.Build.DEVICE;
s += "\n Model (and Product): " + Android.os.Build.MODEL + " ("+ Android.os.Build.PRODUCT + ")";

Cependant, cela semble inutile pour mon cas.

Cette solution fonctionne pour moi maintenant:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int width = metrics.widthPixels;
int height = metrics.heightPixels;

if (SharedCode.width > 1023 || SharedCode.height > 1023){
   //code for big screen (like tablet)
}else{
   //code for small screen (like smartphone)
}
androiddevice-detection
244
user1001635

Ce sujet est abordé dans la Android Training:

tilisez le qualificateur de plus petite largeur

Si vous lisez l'intégralité du sujet, ils vous expliqueront comment définir une valeur booléenne dans un fichier de valeurs spécifique (sous la forme res/values-sw600dp/attr.xml):

<resources>
    <bool name="isTablet">true</bool>
</resources>

Parce que le qualificatif sw600dp est uniquement valide pour les plates-formes supérieures à Android 3.2. Si vous voulez vous assurer que cette technique fonctionne sur toutes les plateformes (avant la 3.2), créez le même fichier dans le dossier res/values-xlarge:

<resources>
    <bool name="isTablet">true</bool>
</resources>

Ensuite, dans le fichier de valeurs "standard" (en tant que res/values ​​/), vous définissez le booléen sur false:

<resources>
    <bool name="isTablet">false</bool>
</resources>

Ensuite, dans votre activité, vous pouvez obtenir cette valeur et vérifier si vous utilisez un périphérique de la taille d'une tablette:

boolean tabletSize = getResources().getBoolean(R.bool.isTablet);
if (tabletSize) {
    // do something
} else {
    // do something else
}
720
ol_v_er

Je considère qu'une tablette doit avoir au moins un écran de 6,5 pouces. Voici comment le calculer, basé sur la réponse de Nolf ci-dessus.

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

float yInches= metrics.heightPixels/metrics.ydpi;
float xInches= metrics.widthPixels/metrics.xdpi;
double diagonalInches = Math.sqrt(xInches*xInches + yInches*yInches);
if (diagonalInches>=6.5){
    // 6.5inch device or bigger
}else{
    // smaller device
}
74
gtsouk

Mon hypothèse est que, lorsque vous définissez "Mobile/Phone", vous souhaitez savoir si vous pouvez effectuer 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 ceci est ci-dessous. Si vous souhaitez savoir quelque chose basé sur des capteurs, la taille de l’écran, etc., la question est vraiment différente.

En outre, l'utilisation de la résolution d'écran ou de la gestion des ressources large vs xlarge peut s'avérer une approche valable dans le passé. De nouveaux appareils "mobiles" arrivent maintenant avec des écrans si grands et des résolutions aussi élevées qu'ils brouillent cette ligne alors que vous le souhaitez vraiment. pour connaître les appels téléphoniques par rapport aux appels sans appels téléphoniques, le meilleur choix est indiqué ci-dessous.

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

J'aime la solution de Ol_v_er et sa simplicité, cependant, j’ai trouvé que ce n’était pas toujours aussi simple. De nouveaux appareils et de nouveaux écrans s’affichent en permanence, et je veux être un peu plus "granulaire" pour essayer de déterminer la taille réelle de l’écran. . Une autre solution que j'ai trouvée ici de John utilise une ressource String, au lieu d'un booléen, pour spécifier la taille de la tablette. Ainsi, au lieu de mettre true dans un fichier /res/values-sw600dp/screen.xml (en supposant que ce soit là où se trouvent vos présentations pour les petites tablettes), vous devriez mettre:

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

Référencez-le comme suit, puis faites ce dont vous avez besoin en fonction du résultat:

String screenType = getResources().getString(R.string.screen_type);
if (screenType.equals("7-inch-tablet")) {
    // do something
} else {
    // do something else
}

La réponse de Sean O'Toole pour Détecter les tablettes de 7 et 10 pouces par programmation était aussi ce que je cherchais. Vous voudrez peut-être vérifier si les réponses ne vous permettent pas d'être aussi précis que vous le souhaitez. Il fait un excellent travail en expliquant comment calculer différentes métriques pour comprendre ce que vous avez réellement à faire.

UPDATE

En examinant le code source de l'application Google I/O 2013, je suis tombé sur le texte suivant, qu'il utilise pour identifier si le périphérique est une tablette ou non. J'ai donc décidé de l'ajouter. Ce qui précède vous donne un peu plus de "contrôle" dessus, mais si vous voulez juste savoir s’il s’agit d’une tablette, voici ce qui est assez simple:

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

Étant donné que les tablettes sont généralement plus volumineuses que les smartphones et qu'une tablette basse résolution peut avoir le même nombre de pixels qu'un smartphone haute résolution, une solution consiste à calculer la taille physique (et non la résolution) physique d'un appareil:

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

    float yInches= metrics.heightPixels/metrics.ydpi;
    float xInches= metrics.widthPixels/metrics.xdpi;

   if (yInches> smallestTabletSize|| xInches > smallestTabletSize)
    {
                  //We are on a 
    }
7
Nolf

La meilleure option que j'ai trouvée et la moins intrusive est de définir un paramètre de balise dans votre fichier XML, comme

TÉLÉPHONE XML LAYOUT

<Android.support.v4.view.ViewPager xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:id="@+id/pager"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:tag="phone"/>

TABLET XML LAYOUT

<RelativeLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    Android:id="@+id/pager"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:tag="tablet">

    ...

</RelativeLayout>

puis appelez cela dans votre classe d'activité:

View viewPager = findViewById(R.id.pager);
Log.d(getClass().getSimpleName(), String.valueOf(viewPager.getTag()));

J'espère que cela fonctionne pour vous.

6
Alejandro Tellez

J'utilise cette méthode dans toutes mes applications et cela fonctionne avec succès:

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

Re: la tangente ci-dessus sur la façon de distinguer un téléphone d'un non-téléphone: pour autant que je sache, seul un téléphone a un numéro IMEI à 15 chiffres (identité de l'équipement de la station mobile internationale), le code suivant permet donc de distinguer définitivement un téléphone de un non-téléphone:

    TelephonyManager manager = (TelephonyManager) this.getSystemService(Context.TELEPHONY_SERVICE);
    String deviceInfo = "";
    deviceInfo += manager.getDeviceId(); // the IMEI
    Log.d(TAG, "IMEI or unique ID is " + deviceInfo);

    if (manager.getDeviceId() == null) {
        Log.d(TAG, "This device is NOT a phone");
    } else {
        Log.d(TAG, "This device is a phone.");
    }

J'ai constaté que sur un émulateur Nook, getPhoneType () renvoie un type de téléphone "GSM" pour une raison quelconque, de sorte qu'il apparaît que la vérification du type de téléphone n'est pas fiable. De même, getNetworkType () retournera 0 pour un téléphone en mode avion. En fait, en mode avion, les méthodes getLine1Number () et getSim * renverront également la valeur null. Mais même en mode avion, l'IMEI d'un téléphone persiste.

1
John Ulmer

La solution que j'utilise consiste à définir deux mises en page. Un avec le dossier de présentation défini à par exemple layout-sw600dp, je l'utilise pour fournir un bouton de menu aux utilisateurs de ma tablette et pour le masquer pour les utilisateurs de téléphones. De cette façon, je n'ai pas (encore) à implémenter le ActionBar pour mes applications existantes ...

Voir ce post pour plus de détails .

1
Stephan