사용자가 태블릿이나 휴대 전화를 사용 중인지 확인할 수있는 방법이 있습니까? 기울기 기능과 새 태블릿 (변압기)에 문제가 있습니다

앞에서 언급했듯이 기기가 태블릿인지 휴대 전화인지 확인하고 싶지 않지만 기기의 기능에 대해 알고 싶은 경우,

대부분의 경우 태블릿과 휴대폰의 차이점은 화면 크기이므로 다른 레이아웃 파일을 사용하려는 이유입니다. 이 파일들은 res/layout-<qualifiers>디렉토리에 저장됩니다 . res/values-<same qualifiers>각 레이아웃에 대해 directoy 에 XML 파일을 작성하고 int / bool / string 자원을 배치하여 사용하는 레이아웃을 구별 할 수 있습니다.

예:

파일 res/values/screen.xml( res/layout/핸드셋 용 레이아웃 파일이 포함되어 있다고 가정 )

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

파일 res/values-sw600dp/screen.xml( res/layout-sw600dp/Nexus 7과 같은 소형 태블릿 용 레이아웃 파일이 포함되어 있다고 가정 )

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

파일 res/values-sw720dp/screen.xml( res/layout-sw720dp/Nexus 10과 같은 대형 태블릿의 레이아웃 파일이 포함되어 있다고 가정 ) :

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

이제 R.string.screen_type상수 를 통해 화면 유형에 액세스 할 수 있습니다 .

장치가 태블릿인지 여부를 감지하려면 다음 코드를 사용하십시오.

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

LARGE 및 XLARGE 화면 크기는 제조업체가 사용하는 눈과의 거리 (따라서 태블릿 개념)에 따라 결정됩니다.

추가 정보 : http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

이 게시물은 많은 도움이되었습니다.

불행히도 나는 나를 도운 모든 답을 평가하는 데 필요한 명성을 얻지 못했습니다.

장치가 태블릿인지 전화인지 확인해야 화면의 논리를 구현할 수있었습니다. 그리고 내 분석에서 태블릿은 MDPI에서 시작하여 7 인치 (Xlarge) 이상이어야합니다.

이 게시물을 기반으로 작성된 코드는 다음과 같습니다.

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

화면 대각선의 크기를 계산하여 장치가 휴대 전화인지 태블릿인지를 결정하는 데 사용하는 것이 어떻습니까?

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

물론 임계 값이 9 인치 이하이어야하는지 논쟁 할 수 있습니다.

다른 점이 없다. 차이점이라고 생각하는 것을 정의하고 확인하십시오. 은하 탭은 전화입니까? 아니면 태블릿? 그리고 왜?

찾고자하는 특정 기능과 해당 코드를 정의해야합니다.

'기울기'를 찾고있는 것 같습니다. 나는 이것이 가속도계와 같다고 생각합니다 (단어입니까?). 다음을 사용하여 장치가 장치를 지원하는지 확인할 수 있습니다.

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

( http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ 에서 테스트했습니다.)

'모바일 / 전화'를 정의 할 때 '태블릿'으로 정의 될 수없는 장치에서 전화를 걸 수 있는지 알고 싶다고 가정합니다. 이를 확인하는 방법은 다음과 같습니다. 센서, 화면 크기 등을 기반으로 무언가를 알고 싶다면 이것은 실제로 다른 질문입니다.

또한 화면 해상도를 사용하는 동안 또는 리소스 관리가 큰 대 xlarge를 사용하는 동안 과거의 새로운 '모바일'장치에는 큰 화면과 고해상도가 제공되어 원하는 경우이 줄을 흐리게하는 경우가 있습니다. 전화 통화 기능과 전화 통화 기능 없음을 알고 싶다면 아래가 '최고'입니다.

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

Robert Dale Johnson III와 Helton Isac을 기반 으로이 코드를 생각해 냈습니다.

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

따라서 코드에서 다음과 같은 필터를 만드십시오.

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

Google IOSched 2017 앱 소스 코드 에서 다음 방법이 사용됩니다.

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

태블릿 UI를 사용할 기기를 결정하는 Google의 코드를 참조하려는 사용자는 다음을 참조하십시오.

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

이 방법은 Google에서 권장합니다. Google Offical Android 앱에서이 코드를 봅니다.iosched

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

코드가 필요하지 않습니다

다른 답변은 장치가 전화인지 태블릿인지 프로그래밍 방식으로 결정하는 여러 가지 방법을 나열합니다. 그러나 설명서 를 읽는 경우 다양한 화면 크기를 지원하는 권장 방법이 아닙니다.

대신 태블릿이나 휴대 전화에 다른 리소스를 선언하십시오. 당신이 내 추가 추가 리소스 폴더 수행 layout, values등

• Android 3.2 (API 레벨 13)의 경우 sw600dp폴더를 추가하십시오 . [이 수단 이야 mallest w IDþ 약 전화 / 태블릿 분할되는 적어도는 600dp이다. 그러나 다른 크기도 추가 할 수 있습니다. 추가 레이아웃 리소스 파일을 추가하는 방법에 대한 예는 이 답변 을 확인하십시오 .

• 이전 Android 3.2 기기도 지원하는 경우 태블릿을 지원하려면 폴더를 추가 large하거나 xlarge폴더를 추가해야합니다 . (전화는 일반적으로 small와 normal.)

다음은 다양한 화면 크기에 대해 추가 xml 파일을 추가 한 후 리소스가 원하는 이미지입니다.

이 방법을 사용하면 시스템이 모든 것을 결정합니다. 런타임에 어떤 장치가 사용되고 있는지 걱정할 필요가 없습니다. 적절한 리소스를 제공하고 Android가 모든 작업을 수행하게하십시오.

노트

• 별명 을 사용 하여 동일한 자원 파일이 중복되지 않도록 할 수 있습니다 .

읽을 가치가있는 Android 문서

• 여러 화면 지원
• 다른 화면 크기 지원
• 특정 화면에 배포

API 레벨> = 13 만 타겟팅하는 경우

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

건배 :-)

"새로"허용 된 디렉토리 (예 : value-sw600dp)를 생각하면 화면 너비 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;
}

그리고이 목록에서 인기있는 장치 및 태블릿 크기의 DP 중 일부를 찾을 수 있습니다.

Wdp / Hdp

갤럭시 넥서스 :
360/567 XOOM : 1280/752
갤럭시 참고 : 400/615
NEXUS 7 : 961/528
갤럭시 탭 (> 7 && <10) : 1280/752
갤럭시 S3 : 360/615

Wdp = 폭 dp Hdp =
높이 dp

글쎄, 나를 위해 일한 최고의 솔루션은 매우 간단합니다.

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

이런 식으로 사용 :

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

나는 실제로 픽셀 크기를보고 싶지 않지만 화면 크기에만 의존합니다.

Nexus 7 (LARGE)이 태블릿으로 감지되지만 Galaxy S3 (NORMAL)은 감지되지 않습니다.

디바이스가 태블릿 인 경우 true 를 리턴하는이 메소드를 사용하십시오.

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

최신 장치에서 화면 크기 감지가 올바른 값을 반환하지 않으면 다음을 시도하십시오.

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

Android 4.2.2에서 테스트되었습니다 (영어가 유감입니다).

나는 이것이 귀하의 질문에 대한 직접적인 답변이 아니라는 것을 알고 있지만 다른 답변은 화면 크기를 식별하는 방법에 대한 좋은 아이디어를 제공합니다. 당신은 당신의 질문에 틸팅에 문제가 있다고 썼는데 이것은 나에게도 일어났습니다.

스마트 폰에서 자이로 스코프 (또는 회전 센서)를 실행하면 해당 장치의 기본 방향에 따라 x 축 및 y 축을 태블릿과 다르게 정의 할 수 있습니다 (예 : Samsung GS2는 기본 세로, Samsung GT-7310은 기본 풍경 인 경우 태블릿이지만 새로운 Google Nexus 7이 기본 인물 사진입니다!).

자이로 스코프를 사용하려면 스마트 폰용 솔루션이 될 수 있지만 일부 태블릿에서는 축 혼동이 발생할 수 있습니다.

위의 솔루션 중 하나를 사용하여 화면 크기로만 이동 한 다음 적용

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

화면 크기가 크거나 큰 경우 축을 뒤집으려면 90 %의 경우 작동하지만 Nexus 7에서는 기본 세로 방향과 큰 화면 크기로 인해 문제가 발생할 수 있습니다.

이를 해결하는 가장 간단한 방법은 nosensor매니페스트에서 sceenOrientation을 설정하여 API 데모와 함께 제공되는 RotationVectorSample에서 제공됩니다 .

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

패키지 관리자의 com.sec.feature.multiwindow.tablet는 태블릿 전용이며 com.sec.feature.multiwindow.phone은 전화 전용입니다.

아래 방법은 장치가 전화 또는 태블릿인지 확인하기 위해 장치 화면의 대각선 길이를 계산하는 것입니다. 이 방법의 유일한 관심사는 장치가 태블릿인지 날씨를 결정하기위한 임계 값입니다. 아래 예제에서 7 인치 이상으로 설정했습니다.

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

휴대 전화와 태블릿을 연결하는 것이 점점 어려워지고 있습니다. 예를 들어 (2015 년 8 월 기준) Samsung Mega 6.3 장치는 sw600dp 폴더에서 리소스를 가져옵니다 .Android에 관한 한 태블릿입니다.

@Vyshnavi 의 답변 은 테스트 한 모든 장치에서 작동하지만 Mega 6.3에서는 작동하지 않습니다.

위의 @Helton Isac 답변은 Mega 6.3을 전화로 반환하지만 장치가 여전히 sw600dp에서 리소스를 가져 오기 때문에 다른 문제가 발생할 수 있습니다. .

결국 그것은 확인해야 할 조건이 너무 많은 것 같으며 일부 전화는 실제로 태블릿임을 수락해야 할 수도 있습니다.

이것이 내가 사용하는 방법입니다.

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

사용 :

구성. SCREENLAYOUT_SIZE_MASK

구성. SCREENLAYOUT_SIZE_LARGE

이것이 권장되는 방법입니다!

왜 이것을 사용합니까?

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

위의 많은 방법을 봅니다. Configuration 클래스는 바로 아래에 올바른 답변을 얻었습니다.

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

그냥 전화 :

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

괜찮아?

탐색 코드를 사용하고 있기 때문에 레이아웃 파일에서만 스마트 폰 / 태블릿을 감지해야했습니다.

내가 한 것은 layout-sw600dp 디렉토리를 만드는 것이었지만 가로 모드의 Nokia 8에서 활성화되기 때문에 제대로 작동하지 않지만 화면 높이가 너무 작습니다.

그래서 디렉토리 이름을 layout-sw600dp-h400dp로 바꾸고 원하는 효과를 얻었습니다. h-xxxdp 매개 변수는 레이아웃에 놓을 내용의 양에 따라 달라지며 응용 프로그램에 따라 달라집니다.

아래 코드를 확인하십시오.

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

태블릿은 최소 및 최대 600 픽셀 너비와 높이를 가지고 있다고 생각
하므로
값을 검색하려면 화면 밀도와 dp의 높이 / 너비를 알아야합니다 .

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;

예를 들어 휴대 전화와 태블릿 간에는 하나 이상의 중요한 차이가 있습니다 (적어도 내 프로그램에서는). 장치의 기본 방향입니다. 전화의 가로 방향은 세로 방향입니다. 그리고 각각 장치를 결정하는 방법 :

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

편집 : Dan Hulme과의 토론에 따라 방법의 이름이 변경되었습니다.

나는 안드로이드 라이브러리 '카페인'을 추천합니다. 전화 또는 태블릿, 10inch ~가 포함되어 있습니다!

매우 쉬운 사용.

도서관이 여기 있습니다.

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

사용

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

저에게 전화와 태블릿의 차이점은 기기의 크기 및 / 또는 픽셀 밀도가 아니라 기술과 취향에 따라 화면 비율이 달라지는 것입니다. 텍스트 화면을 표시하는 경우 15 개의 긴 줄 (전화)과 20 개의 짧은 줄 (태블릿)이 필요한지 알아야합니다. 내 게임에서는 소프트웨어가 처리 할 사각형의 야구장 추정에 다음을 사용합니다.

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

이것이 가장 정직한 방법이라고 생각합니다. 사용중인 화면 크기를 확인합니다.

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

행운을 빕니다!