7 inç ve 10 inç tableti programlı olarak algıla

Uygulamanın yüklü olduğu cihazın 7 inç tablet mi yoksa 10 inç tablet mi olduğunu programlı olarak bulmanın bir yolu var mı?

DisplayMetricsUygulamanızın çalıştığı ekranla ilgili bir dizi bilgi almak için kullanabilirsiniz .

İlk olarak, bir DisplayMetricsmetrik nesnesi oluşturuyoruz:

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

Buradan, ekranı boyutlandırmak için gerekli bilgileri alabiliriz:

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

Bu, piksel cinsinden genişliğin ve yüksekliğin mutlak değerini döndürür, yani Galaxy SIII, Galaxy Nexus vb. İçin 1280x720.

Bu genellikle kendi başına yararlı değildir, çünkü Android cihazlarda çalışırken, genellikle yoğunluktan bağımsız piksellerde çalışmayı tercih ederiz, dip.

Sen almak densitykullanarak ekranın metricsdayanmaktadır cihaz için bir ölçek faktörü şeklinde, yine Android Tasarım Kaynakları için mdpi, hdpivs.

float scaleFactor = metrics.density;

Bu sonuçtan, belirli bir yükseklik veya genişlik için yoğunluktan bağımsız piksellerin miktarını hesaplayabiliriz.

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

Bundan elde ettiğiniz sonuç, size her ekran boyutu için göreceli dp'yi veren Android Yapılandırma örnekleriyle bağlantılı olarak ne tür bir ekranla çalışacağınıza karar vermenize yardımcı olacaktır :

• 320dp: tipik bir telefon ekranı (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, vb.).
• 480dp: Streak (480x800 mdpi) gibi bir ara tablet.
• 600dp: 7 ”tablet (600x1024 mdpi).
• 720dp: 10 ”tablet (720x1280 mdpi, 800x1280 mdpi vb.).

Yukarıdaki bilgileri kullanarak, cihazın en küçük genişliği 600dp'den büyükse, cihazın 7 "tablet, 720dp'den büyükse, 10" tablet olduğunu biliyoruz.

Biz kullanarak küçük genişliği çalışabilir minişlevini Mathgeçen, sınıf heightDpve widthDpgeri dönmek için smallestWidth.

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

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

Ancak, bu size her zaman tam bir eşleşme sağlamaz, özellikle yoğunluklarını hdpi olmadığında yanlış sunabilen veya yalnızca 800 x 480 piksel olan ancak yine de 7 "ekranda olan belirsiz tabletlerle çalışırken .

Bu yöntemlere ek olarak, bir cihazın inç metricscinsinden tam boyutlarını bilmeniz gerekirse , ekranın inç başına kaç piksel olduğu yöntemini kullanarak bunu da hesaplayabilirsiniz.

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

Cihazın her inçinde kaç piksel olduğu ve toplam piksel miktarı bilgisini cihazın kaç inç olduğunu hesaplamak için kullanabilirsiniz.

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

Bu, cihazın yüksekliğini ve genişliğini inç cinsinden döndürecektir. Bu yine, ne tür bir cihaz olduğunu belirlemede o kadar da yararlı değildir, çünkü bir cihazın reklamı yapılan boyutu köşegendir, sahip olduğumuz tek şey yükseklik ve genişliktir.

Bununla birlikte, bir üçgenin yüksekliği ve genişliği göz önüne alındığında, hipotenüsün uzunluğunu hesaplamak için Pisagor teoremini kullanabileceğimizi de biliyoruz (Bu durumda, ekranın köşegeninin boyutu).

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

Buradan, cihazın bir tablet olup olmadığını anlayabiliriz:

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

Ne tür bir cihazla çalıştığınızı bu şekilde hesaplarsınız.

Diyor bir şey yok 7"ya 10"AFAIK. Sistemin bitmap'lerin kodunu çözerken kullandığı ekran boyutlarını almanın kabaca iki yolu vardır. Her ikisi de uygulamanın içinde bulunan Resourcesnesnesinde bulunur.Context .

Birincisi Configurationile elde edilebilecek nesnedir getContext().getResources().getConfiguration(). İçinde var:

Configuration#densityDpi - Yoğunluk kaynak niteleyicisine karşılık gelen, işlenmekte olan hedef ekran yoğunluğu.

Configuration#screenHeightDp - Ekran yüksekliği kaynak niteleyicisine karşılık gelen, dp birimleri cinsinden mevcut ekran alanının geçerli yüksekliği.

Configuration#screenWidthDp - Ekran genişliği kaynak niteleyicisine karşılık gelen, dp birimleri cinsinden mevcut ekran alanının geçerli genişliği.

Configuration#smallestScreenWidthDp - Bir uygulamanın normal çalışmada göreceği en küçük ekran boyutu, en küçük ekran genişliği kaynak niteleyicisine karşılık gelir.

Bunun üzerine, hemen hemen cihazınızın (ilgili uzman kaynak klasörlerden çekiyor olmadığını anlamaya ekran yönergeleri kullanabilirsiniz hdpi, xhdpi, large, xlarge, vb.)

Unutmayın, bunlar bazı paketler:

• xlarge ekranlar en az 960dp x 720dp'dir
• büyük ekranlar en az 640dp x 480dp'dir
• normal ekranlar en az 470dp x 320dp'dir

• küçük ekranlar en az 426dp x 320dp'dir

• 320dp: tipik bir telefon ekranı (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, vb.).

• 480dp: Streak (480x800 mdpi) gibi bir ara tablet.
• 600dp: 7 ”tablet (600x1024 mdpi).
• 720dp: 10 ”tablet (720x1280 mdpi, 800x1280 mdpi vb.).

Daha fazla bilgi

İkincisi, ile DisplayMetricselde edilen nesnedir getContext().getResources().getDisplayMetrics(). Sahip olduğun:

DisplayMetrics#density - Ekranın mantıksal yoğunluğu.

DisplayMetrics#densityDpi - Ekran yoğunluğu inç başına nokta olarak ifade edilir.

DisplayMetrics#heightPixels - Ekranın piksel cinsinden mutlak yüksekliği.

DisplayMetrics#widthPixels - Ekranın piksel cinsinden mutlak genişliği.

DisplayMetrics#xdpi - X boyutunda ekranın inç başına tam fiziksel pikselleri.

DisplayMetrics#ydpi - Y boyutunda ekranın inç başına tam fiziksel pikselleri.

Yoğunluk yerine tam ekran piksel sayısına ihtiyacınız varsa bu kullanışlıdır. Ancak, bunun tüm ekranın pikselleri olduğuna dikkat etmek önemlidir . Sadece sizin için uygun olanlar değil.

bu yöntemi onResume () içine yerleştirin ve kontrol edebilirsiniz.

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;

    }

genellikle tabletler 6 inç boyutundan sonra başlar.

Dikey ve yatay arasında geçiş yaparken yukarıdakiler her zaman çalışmaz.

API düzeyi 13+ hedefliyorsanız, yukarıda açıklandığı gibi kolaydır - Configuration.smallestScreenWidthDp'yi kullanın, ardından buna göre test edin:

resources.getConfiguration().smallestScreenWidthDp

Aksi takdirde, bunu karşılayabiliyorsanız, sistemin size söylemesine izin vererek 600dp (6 "gibi) ve 720dp (10" gibi) tespit etmek için çok doğru bir yaklaşım olan aşağıdaki yöntemi kullanın:

1) layout-sw600dp ve layout-sw720dp'ye (ve eğer mümkünse onun peyzajına) uygun kimliğe sahip görünmez bir görünüm ekleyin, örneğin:

720 için, layout-sw720dp'de:

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

600 için, layout-sw600dp'de:

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

2) Ardından kodda, örneğin Etkinlik, buna göre test edin:

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

Harika bilgi, tam da aradığım şey! Ancak, bunu denedikten sonra, burada bahsedilen ölçümleri kullanırken, Nexus 7 (2012 modeli) boyutlarının 1280x736 boyutlarına sahip olduğunu öğrendim. Ayrıca Jelly Bean çalıştıran bir Motorola Xoom'um var ve yanlışlıkla 1280x752 çözünürlüğü bildiriyor. Ben bu yazı tökezledi burada bu doğruluyor. Temel olarak, ICS / JB'de, yukarıda bahsedilen ölçümleri kullanan hesaplamalar Gezinme Çubuğunun boyutlarını hariç tutuyor gibi görünmektedir. Biraz daha araştırma beni , ekranın ham (veya gerçek) piksel boyutlarını verecek farklı yöntemler kullanan Frank Nguyenen'in burada yanıtına götürdü . İlk testlerim, Frank düzeltmesinden alınan aşağıdaki kodun Nexus 7 (2012 model çalıştırma JB) ve JB çalıştıran Motorola Xoom cihazımdaki boyutları rapor ettiğini gösterdi:

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

Aynı çözünürlüğe sahip iki android cihazım var

Cihaz1 -> çözünürlük 480x800 çapraz ekran boyutu -> 4,7 inç

Cihaz2 -> çözünürlük 480x800 çapraz ekran boyutu -> 4,0 inç

Her iki cihaza çapraz ekran boyutu verir -> 5.8

probleminizin çözümü ...

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

ayrıntılara buradan bakın ..

Android'in ekran boyutlarını belirleme şekli dört genelleştirilmiş boyuttur : küçük , normal , büyük ve xlarge .

Android belgeleri beden gruplarının kullanımdan kaldırıldığını belirtirken

... bu boyut grupları, mevcut ekran genişliğine dayalı olarak ekran boyutlarını yönetmek için yeni bir teknik lehine kullanımdan kaldırılmıştır. Android 3.2 ve üstü için geliştirme yapıyorsanız, daha fazla bilgi için [Android 3.2 için Tablet Düzenlerini Bildirme] (hdpi (yüksek) ~ 240dpi) konusuna bakın.

Genellikle boyut niteleyicisi büyük , 7 "tableti belirtir . Xlarge’ın boyut niteleyicisi ise 10" tableti belirtir:

Boyut niteleyicisinde tetiklemenin güzel yanı, varlıklarınızın ve kodunuzun hangi varlığın kullanılacağı veya etkinleştirileceği yolu kodlama konusunda hemfikir olmasını garanti edebilmenizdir.

Koddaki boyut niteleyicisini almak için aşağıdaki çağrıları yapın:

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

Ekran boyutunu inç cinsinden almak için aşağıdaki yöntemi kullanabilirsiniz, buna bağlı olarak cihazın hangi tablet veya telefon olduğunu kontrol edebilirsiniz.

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

Değerler klasörüne 7 inç veya 10 inçlik bir ekran veren bir değeri depoluyordum ancak bunu değerler klasörünü kullanan herhangi bir cihaz için yapabiliriz.

farklı-2 cihazlar için farklı-2 değerler klasörü oluşturmak gibi. Ancak bu, ihtiyaca bağlıdır.

DisplayMetrics sınıfı tarafından verilen verileri kullanarak biraz hesaplama yapmanız gerekecek .

Yükseklik Piksel ve genişlik Piksel'e sahipsiniz (piksel cinsinden ekran çözünürlüğü)

'İnç ekran boyutu' her zaman çapraz uzunluğu tanımladığı için köşegene ihtiyacınız vardır. Ekranı köşegen piksel olarak elde edebilirsiniz (pisagor kullanarak)

diagonalPixel = √ (yükseklikPixel² + genişlikPixels²)

daha sonra, yoğunlukDPI değeri sayesinde piksel değerini inç'e dönüştürebilirsiniz:

inchDiag = diyagonalPixel / yoğunlukDPI.

Umarım burada hata yapmamışımdır, DisplayMetrics sınıfından aldığınız değerlerin kurucu tarafından verildiğini unutmayın, (çok nadir durumlarda) fiziksel malzemeye göre iyi ayarlanmadıkları görülüyor ...

Bu size fiziksel ekran boyutunu verecektir, ancak muhtemelen birden çok düzeni yönetmenin daha iyi bir yolu değildir. Bu konularla ilgili daha fazla bilgi

Diğer yol:

• 2 klasör daha oluşturun: değerler-büyük + değerler-xlarge

• Koy: <string name="screentype">LARGE</string>değerler-büyük klasör (strings.xml)

• Koy: <string name="screentype">XLARGE</string>values-xlarge klasörüne (strings.xml)

• Kodda:

  Dize mType = getString (R.string.screentype);

  eğer (mType! = null && mType.equals ("LARGE") {

  // 4 ~ 7 inçten

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

  // 7 ~ 10 inç arası

  }

Voila! 😀 Tabletleri telefonlardan ayırmak için ihtiyacınız olan tek şey bu

1. Ekran genişliğini elde etmek için yardımcı işlev:

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

2. Bir cihazın tablet olup olmadığını anlama işlevi

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

3. Son olarak, farklı cihaz boyutları için farklı işlemler gerçekleştirmek istiyorsanız:

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

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

İşte bazı yararlı kotlin uzantıları:

    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
    }