Tablette ou téléphone - Android

Question

Y a-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)

Answer 1

Comme il a été mentionné avant, vous ne voulez pas vérifier si l'appareil est d'une tablette ou d'un téléphone, mais que vous voulez savoir sur les fonctionnalités de l'appareil,

La plupart du temps, la différence entre une tablette et un téléphone est la taille de l'écran qui est pourquoi vous voulez utiliser différents fichiers de mise en page. Ces fichiers sont stockés dans l' res/layout-<qualifiers> annuaires. Vous pouvez créer un fichier XML dans le directoy res/values-<same qualifiers> pour chacune de vos mises en page et de mettre un int/bool/ressource de chaîne afin de distinguer entre les modèles que vous utilisez.

Exemple:

Fichier res/values/screen.xml (en supposant 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 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 res/layout-sw720dp/ contient vos fichiers de mise en page pour les grandes tablettes comme la Nexus 10):

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

Maintenant, le type d'écran est accessible via l' R.string.screen_type constante.

Answer 2

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

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

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

Plus d'infos: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

Answer 3

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, ce qui me permettrait d'implémenter la logique de l'écran. Et dans mon analyse, la tablette doit être supérieure à 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;
}
 

Answer 4

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.

Answer 5

il n'y a pas de différence. Vous devez définir ce que vous pensez est la différence, et de vérifier que. Est une galaxy tab un téléphone? ou d'une tablette? et pourquoi?

Vous devez définir quelles fonctionnalités spécifiques vous êtes à la recherche pour, et le code pour que.

Il semble que vous êtes la recherche pour "tilt". Je pense que c'est le même que l'accéléromètre (est-ce un mot?). Vous pouvez simplement vérifier si l'appareil prend en charge, à l'aide de:

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

(à partir de http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . je ne l'ai pas testé)