studio - Detecta correctamente el tipo de dispositivo Android

curso android desarrollo de aplicaciones móviles pdf

Question

¿Hay alguna forma de detectar con precisión el tipo de dispositivo (teléfono, tableta, reloj, TV, auto, PC)?

En este momento, encontré una manera de detectar si la aplicación se está ejecutando en un auto ( uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_CAR ), en un televisor ( uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_TELEVISION ) ( uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_WATCH ). ¿Es correcto? ¿Un teléfono conectado a un automóvil aparece como un teléfono o como "Android Auto"?

Para diferenciar entre un teléfono, tableta o computadora, puedo verificar el tamaño mínimo de la pantalla (600dp para calificar como tableta o computadora portátil, por ejemplo).

El problema ahora es diferenciar entre una tableta y una computadora portátil. ¿Tiene usted alguna idea?

PD: no estoy pidiendo esto para crear una IU receptiva, es una pregunta relacionada con la administración del dispositivo para una cuenta

Answer 1

Para diferenciar entre un teléfono y una tableta o computadora, puedo verificar el tamaño mínimo de la pantalla (600dp para calificar como talet o laptop, por ejemplo).

Hay una mejor manera de hacerlo y es usando valores. Por ejemplo, si tiene 2 tipos de dispositivos (por ejemplo, teléfono y tableta), cree dos carpetas para los valores también. Entonces para la carpeta de valores agregue esto:

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

y en su carpeta de valores grandes:

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

Luego en tu actividad:

boolean isLarge = getResources().getBoolean(R.bool.isLarge);
if (isLarge) {
    // do something
} else {
    // do something else
}

Usando esto, puedes hacer lo mismo con el teléfono, sw-600dp, sw-720dp y etc. No estoy seguro si puedes usar esto para TV y etc., pero creo que vale la pena intentarlo.

Answer 2

Compruebe esta clase. https://developer.android.com/reference/android/os/Build.html

String manufacturer = Build.MANUFACTURER
String model = Build.MODEL

Puedes saber si su teléfono, pestaña o TV desde Build.MODEL

Answer 3

Compruebe si el tamaño de la pantalla física es grande (= tableta o dispositivo similar a una computadora portátil):

private static boolean isTabletDevice(Context activityContext) {
    boolean device_large = ((activityContext.getResources().getConfiguration().screenLayout &
            Configuration.SCREENLAYOUT_SIZE_MASK) ==
            Configuration.SCREENLAYOUT_SIZE_LARGE);

    if (device_large) {
        DisplayMetrics metrics = new DisplayMetrics();
        Activity activity = (Activity) activityContext;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        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) {
            AppInstance.getLogger().logD("DeviceHelper","IsTabletDevice-True");
            return true;
        }
    }
    AppInstance.getLogger().logD("DeviceHelper","IsTabletDevice-False");
    return false;
}

Compruebe si la aplicación se está ejecutando en el emulador de SDK de Android:

public static boolean isEmulator() {
return Build.FINGERPRINT.startsWith("generic")
        || Build.FINGERPRINT.startsWith("unknown")
        || Build.MODEL.contains("google_sdk")
        || Build.MODEL.contains("Emulator")
        || Build.MODEL.contains("Android SDK built for x86")
        || Build.MANUFACTURER.contains("Genymotion")
        || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
        || "google_sdk".equals(Build.PRODUCT);

}

Compruebe si el dispositivo es un Android TV:

    public static final String TAG = "DeviceTypeRuntimeCheck";

    UiModeManager uiModeManager = (UiModeManager) getSystemService(UI_MODE_SERVICE);
    if (uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_TELEVISION) {
        Log.d(TAG, "Running on a TV Device")
    } else {
        Log.d(TAG, "Running on a non-TV Device")
}

Answer 4

Puede detectar si esta aplicación de código se ejecuta en pantalla grande o no.

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

Este link también sería útil para usted.

Obtenga el ancho de la pantalla y verifique esto con estos puntos de quiebre.

/ * Tableta (retrato y paisaje) ----------- * /

 min-device-width : 768px
 max-device-width : 1024px

/ * Computadoras de escritorio y portátiles ----------- * /

min-width : 1224px

Answer 5

Utilice los siguientes métodos estáticos para obtener el nombre, id, altura y ancho del dispositivo. Para más detalles visite en este link . El proyecto incluye todas las características comunes que las aplicaciones básicas de Android desean.

     public static String getDeviceName() {
        String manufacturer = Build.MANUFACTURER;
        String model = Build.MODEL;
        if (model.startsWith(manufacturer)) {
            return capitalize(model);
        } else {
            return capitalize(manufacturer) + " " + model;
        }
    }

    public static String getDeviceID(Context context) {
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        return telephonyManager.getDeviceId();
    }

    public static int getDeviceHeight(Context mContext) {
        DisplayMetrics displaymetrics = new DisplayMetrics();
        ((Activity) mContext).getWindowManager().getDefaultDisplay()
                .getMetrics(displaymetrics);
        return displaymetrics.heightPixels;
    }

    public static int getDeviceWidth(Context mContext) {
        DisplayMetrics displaymetrics = new DisplayMetrics();
        ((Activity) mContext).getWindowManager().getDefaultDisplay()
                .getMetrics(displaymetrics);
        return displaymetrics.widthPixels;
    }

Answer 6

por favor consulte este enlace,

http://developer.android.com/training/multiscreen/screensizes.html#TaskUseSWQuali

A continuación, pongo el código para verificar Tablet o Android TV, verifique que funcione.

para tableta

private boolean checkIsTablet() {
   boolean isTablet;
   Display display = ((Activity)   this.mContext).getWindowManager().getDefaultDisplay();
   DisplayMetrics metrics = new DisplayMetrics();
   display.getMetrics(metrics);

  float widthInches = metrics.widthPixels / metrics.xdpi;
  float heightInches = metrics.heightPixels / metrics.ydpi;
  double diagonalInches = Math.sqrt(Math.pow(widthInches, 2) + Math.pow(heightInches, 2));
  if (diagonalInches >= 7.0) {
    isTablet = true;
  }

return isTablet;
}

o

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

para televisión

@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
private boolean checkIsTelevision() {
  boolean isAndroidTV;
  int uiMode = mContext.getResources().getConfiguration().uiMode;
  if ((uiMode & Configuration.UI_MODE_TYPE_MASK) == Configuration.UI_MODE_TYPE_TELEVISION) {
    isAndroidTV = true;
}

Funcionará, disfrutar ...