프로그래밍 방식으로 7 인치 및 10 인치 태블릿 감지

앱이 설치된 기기가 7 인치 태블릿인지 10 인치 태블릿인지 프로그래밍 방식으로 찾을 수있는 방법이 있나요?

를 사용 DisplayMetrics하여 앱이 실행중인 화면에 대한 전체 정보를 얻을 수 있습니다 .

먼저 DisplayMetrics메트릭 개체를 만듭니다.

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

이를 통해 디스플레이 크기를 조정하는 데 필요한 정보를 얻을 수 있습니다.

int widthPixels = metrics.widthPixels;
int heightPixels = metrics.heightPixels;

너비와 높이의 절대 값을 픽셀 단위로 반환하므로 Galaxy SIII, Galaxy Nexus 등의 경우 1280x720입니다.

이것은 일반적으로 그 자체로는 도움이되지 않습니다. Android 기기에서 작업 할 때 일반적으로 밀도 독립 픽셀, dip에서 작업하는 것을 선호하기 때문입니다.

, 등에 대한 Android 디자인 리소스 를 기반으로하는 기기의 배율 형식으로 다시 density사용하여 화면을 가져옵니다 . metricsmdpihdpi

float scaleFactor = metrics.density;

이 결과에서 특정 높이 또는 너비에 대한 밀도 독립 픽셀의 양을 계산할 수 있습니다.

float widthDp = widthPixels / scaleFactor
float heightDp = heightPixels / scaleFactor

여기에서 얻은 결과 는 각 화면 크기에 대한 상대적인 dp를 제공 하는 Android 구성 예제 와 함께 작업중인 화면 유형을 결정하는 데 도움이됩니다 .

• 320dp : 일반적인 전화 화면 (240x320 ldpi, 320x480 mdpi, 480x800 hdpi 등).
• 480dp : Streak (480x800 mdpi)와 같은 트위너 태블릿.
• 600dp : 7 인치 태블릿 (600x1024 mdpi).
• 720dp : 10 인치 태블릿 (720x1280 mdpi, 800x1280 mdpi 등)

위의 정보를 사용하여 기기의 최소 너비가 600dp보다 크면 기기가 7 인치 태블릿이고 720dp보다 크면 기기가 10 인치 태블릿임을 알 수 있습니다.

우리는 사용하여 최소 폭을 해결할 수 min의 기능 Math전달, 클래스 heightDp와는 widthDp을 반환 smallestWidth.

float smallestWidth = Math.min(widthDp, heightDp);

if (smallestWidth > 720) {
    //Device is a 10" tablet
} 
else if (smallestWidth > 600) {
    //Device is a 7" tablet
}

그러나 이것이 항상 정확한 일치를 제공하지는 않습니다. 특히 밀도를 hdpi로 잘못 표현할 수있는 모호한 태블릿으로 작업 할 때 또는 800 x 480 픽셀이지만 여전히 7 인치 화면에있을 수 있습니다. .

이러한 방법 metrics외에도 장치의 정확한 치수 (인치)를 알아야하는 경우 화면 인치당 픽셀 수에 대한 방법을 사용하여이를 해결할 수도 있습니다.

float widthDpi = metrics.xdpi;
float heightDpi = metrics.ydpi;

장치의 각 인치에있는 픽셀 수와 총 픽셀 수에 대한 지식을 사용하여 장치의 인치 수를 계산할 수 있습니다.

float widthInches = widthPixels / widthDpi;
float heightInches = heightPixels / heightDpi;

그러면 장치의 높이와 너비가 인치 단위로 반환됩니다. 광고 된 기기의 크기는 대각선이고 높이와 너비 만 있기 때문에 기기 유형을 결정하는 데 항상 도움이되는 것은 아닙니다.

그러나 삼각형의 높이와 너비가 주어지면 피타고라스 정리를 사용하여 빗변의 길이 (이 경우 화면 대각선의 크기)를 계산할 수 있습니다.

//a² + b² = c²

//The size of the diagonal in inches is equal to the square root of the height in inches squared plus the width in inches squared.
double diagonalInches = Math.sqrt(
    (widthInches * widthInches) 
    + (heightInches * heightInches));

이를 통해 장치가 태블릿인지 여부를 확인할 수 있습니다.

if (diagonalInches >= 10) {
    //Device is a 10" tablet
} 
else if (diagonalInches >= 7) {
    //Device is a 7" tablet
}

이것이 어떤 종류의 장치를 사용하는지 계산하는 방법입니다.

7"또는 10"AFAIK라는 말이 없습니다 . 시스템이 비트 맵을 디코딩 할 때 사용하는 화면 크기를 가져 오는 방법에는 대략 두 가지가 있습니다. 둘 다에서 찾은 응용 프로그램의 Resources개체에서 찾을 수 Context있습니다.

첫 번째는에서 Configuration얻을 수있는 객체입니다 getContext().getResources().getConfiguration(). 그것에 당신은 :

Configuration#densityDpi -밀도 리소스 한정자에 따라 렌더링되는 대상 화면 밀도입니다.

Configuration#screenHeightDp -화면 높이 리소스 한정자에 해당하는 사용 가능한 화면 공간의 현재 높이 (dp 단위)입니다.

Configuration#screenWidthDp -화면 너비 리소스 한정자에 해당하는 사용 가능한 화면 공간의 현재 너비 (dp 단위)입니다.

Configuration#smallestScreenWidthDp -응용 프로그램이 일반 작업에서 볼 수있는 가장 작은 화면 크기로, 최소 화면 너비 리소스 한정자에 해당합니다.

그것으로, 당신은 꽤 많은 장치가 (각각의 전문 자원 폴더에서 당기는 경우 알아 내기 위해 화면 지침을 사용할 수 있습니다 hdpi, xhdpi, large,xlarge , 등).

다음은 버킷 중 일부입니다.

• 초대형 화면은 최소 960dp x 720dp입니다.
• 큰 화면은 최소 640dp x 480dp입니다.
• 일반 화면은 최소 470dp x 320dp입니다.

• 작은 화면은 최소 426dp x 320dp입니다.

• 320dp : 일반적인 전화 화면 (240x320 ldpi, 320x480 mdpi, 480x800 hdpi 등).

• 480dp : Streak (480x800 mdpi)와 같은 트위너 태블릿.
• 600dp : 7 인치 태블릿 (600x1024 mdpi).
• 720dp : 10 인치 태블릿 (720x1280 mdpi, 800x1280 mdpi 등)

더 많은 정보

두 번째는에서 DisplayMetrics얻은 객체 getContext().getResources().getDisplayMetrics()입니다. 그 점에서 :

DisplayMetrics#density -디스플레이의 논리적 밀도.

DisplayMetrics#densityDpi -인치당 도트 수로 표시되는 화면 밀도입니다.

DisplayMetrics#heightPixels -디스플레이의 절대 높이 (픽셀)입니다.

DisplayMetrics#widthPixels -디스플레이의 절대 너비 (픽셀)입니다.

DisplayMetrics#xdpi -X 차원에서 화면의 인치당 정확한 물리적 픽셀입니다.

DisplayMetrics#ydpi -Y 차원에서 화면의 인치당 정확한 물리적 픽셀입니다.

밀도가 아닌 화면의 정확한 픽셀 수가 필요한 경우 유용합니다. 그러나 이것이 화면의 모든 픽셀 이라는 점에 유의하는 것이 중요합니다 . 당신이 사용할 수있는 것 뿐만이 아닙니다.

이 메소드를 onResume ()에 넣고 확인할 수 있습니다.

public double tabletSize() {

     double size = 0;
        try {

            // Compute screen size

            DisplayMetrics dm = context.getResources().getDisplayMetrics();

            float screenWidth  = dm.widthPixels / dm.xdpi;

            float screenHeight = dm.heightPixels / dm.ydpi;

            size = Math.sqrt(Math.pow(screenWidth, 2) +

                                 Math.pow(screenHeight, 2));

        } catch(Throwable t) {

        }

        return size;

    }

일반적으로 정제는 6 인치 크기 이후에 시작됩니다.

위의 내용은 세로와 가로를 전환 할 때 항상 작동하지 않습니다.

API 레벨 13 이상을 대상으로하는 경우 위에서 설명한 것처럼 쉽습니다. Configuration.smallestScreenWidthDp를 사용하고 적절하게 테스트합니다.

resources.getConfiguration().smallestScreenWidthDp

그렇지 않은 경우,이를 감당할 수 있다면 다음 방법을 사용하여 600dp (예 : 6 ")와 720dp (예 : 10")를 감지하는 매우 정확한 접근 방식을 사용하십시오.

1) 적절한 ID가있는 보이지 않는보기를 layout-sw600dp 및 layout-sw720dp (해당되는 경우 가로)에 추가합니다. 예 :

720의 경우 레이아웃 -sw720dp에서 :

<View android:id="@+id/sw720" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

600의 경우 레이아웃 -sw600dp에서 :

<View android:id="@+id/sw600" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

2) 그런 다음 코드 (예 : 활동)에서 적절하게 테스트합니다.

private void showFragment() {
    View v600 = (View) findViewById(R.id.sw600);
    View v720 = (View) findViewById(R.id.sw720);
    if (v600 != null || v720 !=null)
        albumFrag = AlbumGridViewFragment.newInstance(albumRefresh);
    else
        albumFrag = AlbumListViewFragment.newInstance(albumRefresh);
    getSupportFragmentManager()
        .beginTransaction()
        .replace(R.id.view_container, albumFrag)
        .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
        .commit();
}

훌륭한 정보, 내가 찾던 것! 그러나 이것을 시도한 후 여기에 언급 된 측정 항목을 사용할 때 Nexus 7 (2012 모델) 크기가 1280x736 인 보고서를 발견했습니다. 또한 Jelly Bean을 실행하는 Motorola Xoom이 있는데 1280x752의 해상도를 잘못보고합니다. 이 게시물 우연히 여기에 이를 확인합니다. 기본적으로 ICS / JB에서 위에서 언급 한 메트릭을 사용한 계산은 탐색 모음의 차원을 제외하는 것처럼 보입니다. 좀 더 많은 연구 를 통해 화면의 원시 (또는 실제) 픽셀 크기를 제공하는 다양한 방법을 사용 하는 Frank Nguyen의 답변을 찾았습니다 . 내 초기 테스트에서 Frank correclty의 다음 코드가 Nexus 7 (JB를 실행하는 2012 모델) 및 JB를 실행하는 Motorola Xoom의 크기를보고하는 것으로 나타났습니다.

int width = 0, height = 0;
final DisplayMetrics metrics = new DisplayMetrics();
Display display = getWindowManager().getDefaultDisplay();
Method mGetRawH = null, mGetRawW = null;

try {
    // For JellyBeans and onward
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
        display.getRealMetrics(metrics);

        width = metrics.widthPixels;
        height = metrics.heightPixels;
    } else {
        mGetRawH = Display.class.getMethod("getRawHeight");
        mGetRawW = Display.class.getMethod("getRawWidth");

        try {
            width = (Integer) mGetRawW.invoke(display);
            height = (Integer) mGetRawH.invoke(display);
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
} catch (NoSuchMethodException e3) {
    e3.printStackTrace();
}

동일한 해상도의 Android 기기가 두 개 있습니다.

장치 1-> 해상도 480x800 대각선 화면 크기-> 4.7 인치

Device2-> 해상도 480x800 대각선 화면 크기-> 4.0 인치

두 장치 모두 대각선 화면 크기-> 5.8을 제공합니다.

당신의 문제에 대한 해결책은 ..

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width=dm.widthPixels;
int height=dm.heightPixels;
int dens=dm.densityDpi;
double wi=(double)width/(double)dens;
double hi=(double)height/(double)dens;
double x = Math.pow(wi,2);
double y = Math.pow(hi,2);
double screenInches = Math.sqrt(x+y);

자세한 내용은 여기 ..

Android가 화면 크기를 지정하는 방식은 small , normal , large 및 xlarge의 네 가지 일반화 된 크기를 통해 이루어집니다. 집니다.

Android 문서 에는 크기 그룹이 더 이상 사용되지 않는다고 명시되어 있지만

... 이러한 크기 그룹은 사용 가능한 화면 너비에 따라 화면 크기를 관리하는 새로운 기술을 위해 더 이상 사용되지 않습니다. Android 3.2 이상용으로 개발하는 경우 자세한 내용은 [Android 3.2 용 태블릿 레이아웃 선언] (hdpi (높음) ~ 240dpi)을 참조하세요.

일반적으로 size qualifier large 는 7 인치 태블릿을 지정하고 xlarge 크기 한정자 는 10 인치 태블릿을 지정합니다.

크기 한정자에 대한 트리거의 좋은 점은 자산과 코드가 사용할 자산 또는 활성화 할 코드 경로에 대해 일치하도록 보장 할 수 있다는 것입니다.

코드에서 크기 한정자를 검색하려면 다음을 호출합니다.

int sizeLarge = SCREENLAYOUT_SIZE_LARGE // For 7" tablet
boolean is7InchTablet = context.getResources().getConfiguration()
    .isLayoutSizeAtLeast(sizeLarge);

int sizeXLarge = SCREENLAYOUT_SIZE_XLARGE // For 10" tablet
boolean is10InchTablet = context.getResources().getConfiguration()
    .isLayoutSizeAtLeast(sizeXLarge);

아래 방법을 사용하여 화면 크기를 인치 단위로 가져올 수 있으며, 장치가 어떤 태블릿 또는 전화인지 간단히 확인할 수 있습니다.

private static double checkDimension(Context context) {

    WindowManager windowManager = ((Activity)context).getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    // since SDK_INT = 1;
    int mWidthPixels = displayMetrics.widthPixels;
    int mHeightPixels = displayMetrics.heightPixels;

    // includes window decorations (statusbar bar/menu bar)
    try
    {
        Point realSize = new Point();
        Display.class.getMethod("getRealSize", Point.class).invoke(display, realSize);
        mWidthPixels = realSize.x;
        mHeightPixels = realSize.y;
    }
    catch (Exception ignored) {}

    DisplayMetrics dm = new DisplayMetrics();
    windowManager.getDefaultDisplay().getMetrics(dm);
    double x = Math.pow(mWidthPixels/dm.xdpi,2);
    double y = Math.pow(mHeightPixels/dm.ydpi,2);
    double screenInches = Math.sqrt(x+y);
    Log.d("debug","Screen inches : " + screenInches);
    return screenInches;
}

값 폴더 에 값을 저장했습니다.화면이 7 인치 또는 10 inc 했지만 값 폴더를 사용하는 모든 장치에서 할 수 있습니다.

다른 -2 장치에 대해 다른 -2 값 폴더를 만드는 것과 같습니다. 그러나 이것은 요구 사항에 따라 다릅니다.

DisplayMetrics에서 제공하는 데이터를 사용하여 약간의 계산을해야합니다. 클래스에서 .

heightPixel 및 widthPixels (픽셀 단위의 화면 해상도)가 있습니다.

'인치 화면 크기'는 항상 대각선 길이를 나타내므로 대각선이 필요합니다. 화면 대각선을 픽셀 단위로 얻을 수 있습니다 (피타 고어 사용).

대각선 픽셀 = √ (heightPixel² + widthPixels²)

그런 다음 densityDPI 값 덕분에 픽셀 값을 인치로 변환 할 수 있습니다.

inchDiag = 대각선 픽셀 / 밀도 DPI.

여기서 실수하지 않았 으면 좋겠습니다. DisplayMetrics 클래스에서 얻은 값은 생성자에 의해 제공된다는 점에 유의하세요. 매우 드문 경우지만 물리적 재질에 따라 잘 설정되지 않은 것처럼 보입니다.

이것은 실제 화면 크기를 제공하지만 여러 레이아웃을 관리하는 더 좋은 방법은 아닙니다. 이 주제에 대해 더 알아보기

또 다른 방법:

• 2 개 추가 폴더 생성 : values-large + values-xlarge

• 넣어 : <string name="screentype">LARGE</string>값-대형 폴더 (strings.xml)

• 넣어 : <string name="screentype">XLARGE</string>values-xlarge 폴더 (strings.xml)

• 코드에서 :

  문자열 mType = getString (R.string.screentype);

  if (mType! = null && mType.equals ( "LARGE") {

  // 4 ~ 7 인치

  } else if (mType! = null && mType.equals ( "XLARGE") {

  // 7 ~ 10 인치

  }

짜잔! 😀 이것이 태블릿과 휴대폰을 구별하는 데 필요한 전부입니다.

1. 화면 너비를 얻는 도우미 기능 :

private float getScreenWidth() {
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    return Math.min(metrics.widthPixels, metrics.heightPixels) / metrics.density;
}

2. 장치가 태블릿인지 알아내는 기능

boolean isTablet() {
    return getScreenWidth() >= 600;
}

3. 마지막으로, 장치 크기에 따라 다른 작업을 수행하려는 경우 :

boolean is7InchTablet() {
    return getScreenWidth() >= 600 && getScreenWidth() < 720;
}

boolean is10InchTablet() {
    return getScreenWidth() >= 720;
}

다음은 유용한 kotlin 확장 기능입니다.

    fun DisplayMetrics.isTablet(): Boolean {
        return screenWith() >= 600
    }

    fun DisplayMetrics.is7InchTablet(): Boolean {
        return screenWith() >= 600 && screenWith() < 720
    }

    fun DisplayMetrics.is10InchTablet(): Boolean {
        return screenWith() >= 720
    }

    fun DisplayMetrics.screenWith(): Float {
        return widthPixels.coerceAtMost(heightPixels) / density
    }