multi - android studio different screen sizes




Erhalten Sie Bildschirmabmessungen in Pixeln (20)

Ich habe einige benutzerdefinierte Elemente erstellt und möchte sie programmatisch in der oberen rechten Ecke platzieren ( n Pixel von der oberen Kante und m Pixel von der rechten Kante). Daher muss ich die Bildschirmbreite und Bildschirmhöhe bekommen und dann die Position einstellen:

int px = screenWidth - m;
int py = screenHeight - n;

Wie bekomme ich screenWidth und screenHeight in der Hauptaktivität?


(2012 Antwort, möglicherweise veraltet) Wenn Sie vor Honeycomb unterstützen möchten, müssen Sie in Rückwärtskompatibilität vor API 13 setzen. Etwas wie:

int measuredWidth = 0;
int measuredHeight = 0;
WindowManager w = getWindowManager();

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    Point size = new Point();
    w.getDefaultDisplay().getSize(size);
    measuredWidth = size.x;
    measuredHeight = size.y;
} else {
    Display d = w.getDefaultDisplay();
    measuredWidth = d.getWidth();
    measuredHeight = d.getHeight();
}

Natürlich werden die veralteten Methoden irgendwann aus den neuesten SDKs herausgenommen, aber während wir immer noch darauf vertrauen, dass die meisten unserer Benutzer Android 2.1, 2.2 und 2.3 haben, bleibt uns das übrig.


Befolgen Sie die folgenden Methoden:

public static int getWidthScreen(Context context) {
    return getDisplayMetrics(context).widthPixels;
}

public static int getHeightScreen(Context context) {
    return getDisplayMetrics(context).heightPixels;
}

private static DisplayMetrics getDisplayMetrics(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    wm.getDefaultDisplay().getMetrics(displayMetrics);
    return displayMetrics;
}

Dies ist keine Antwort für das OP, da er die Anzeigedimensionen in realen Pixeln haben wollte. Ich wollte die Dimensionen in "geräteunabhängigen Pixeln", und die Antworten von hier https://.com/a/17880012/253938 und hier https://.com/a/6656774/253938 Ich kam auf mit diesem:

    DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
    int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
    int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);

Ein Weg ist:

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

Es ist veraltet und Sie sollten stattdessen den folgenden Code versuchen. Die ersten beiden Codezeilen enthalten die DisplayMetrics-Objekte. Dieses Objekt enthält die Felder heightPixels, widthPixels.

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

int height = metrics.heightPixels;
int width = metrics.widthPixels;

Es gibt eine nicht veraltete Möglichkeit, dies mithilfe von DisplayMetrics (API 1) zu tun, wodurch die Unsichtbarkeit von try / catch vermieden wird:

 // initialize the DisplayMetrics object
 DisplayMetrics deviceDisplayMetrics = new DisplayMetrics();

 // populate the DisplayMetrics object with the display characteristics
 getWindowManager().getDefaultDisplay().getMetrics(deviceDisplayMetrics);

 // get the width and height
 screenWidth = deviceDisplayMetrics.widthPixels;
 screenHeight = deviceDisplayMetrics.heightPixels;

Es kann Ihre Frage vielleicht nicht beantworten, aber es könnte nützlich sein, wenn Sie eine Ansichtsdimension benötigen, aber Ihr Code wird ausgeführt, wenn sein Layout noch nicht angelegt wurde (zum Beispiel in onCreate() ) können Sie einen ViewTreeObserver.OnGlobalLayoutListener mit View.getViewTreeObserver().addOnGlobalLayoutListener() und den relevanten Code, der die Dimension der Ansicht benötigt, dort View.getViewTreeObserver().addOnGlobalLayoutListener() . Der Callback des Hörers wird aufgerufen, wenn das Layout angelegt wurde.


Für die Suche nach brauchbaren Bildschirmdimensionen ohne Statusleiste und Aktionsleiste (auch dank Swapnils Antwort):

DisplayMetrics dm = getResources().getDisplayMetrics();
float screen_w = dm.widthPixels;
float screen_h = dm.heightPixels;

int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    screen_h -= getResources().getDimensionPixelSize(resId);
}

TypedValue typedValue = new TypedValue();
if(getTheme().resolveAttribute(android.R.attr.actionBarSize, typedValue, true)){
    screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId);
}

Finden Sie Breite und Höhe des Bildschirms:

width = getWindowManager().getDefaultDisplay().getWidth();
height = getWindowManager().getDefaultDisplay().getHeight();

Mit diesem können wir das neueste und über SDK 13 erhalten.

// New width and height
int version = android.os.Build.VERSION.SDK_INT;
Log.i("", " name == "+ version);
Display display = getWindowManager().getDefaultDisplay();
int width;
if (version >= 13) {
    Point size = new Point();
    display.getSize(size);
    width = size.x;
    Log.i("width", "if =>" +width);
}
else {
    width = display.getWidth();
    Log.i("width", "else =>" +width);
}

Ich fand, dass dies der Trick war.

Rect dim = new Rect();
getWindowVisibleDisplayFrame(dim);

Ich habe alle möglichen "Lösungen" erfolglos ausprobiert und mir ist aufgefallen, dass die App "Dalvik Explorer" von Elliott Hughes immer die richtige Dimension auf jeder Android-Gerät / Betriebssystem-Version zeigt. Ich habe mir sein Open-Source-Projekt angesehen, das hier zu finden ist: https://code.google.com/p/enh/

Hier ist der relevante Code:

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
try {
    // used when 17 > SDK_INT >= 14; includes window decorations (statusbar bar/menu bar)
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
try {
    // used when SDK_INT >= 17; includes window decorations (statusbar bar/menu bar)
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

BEARBEITEN: leicht verbesserte Version (vermeiden Sie das Auslösen von Ausnahmen bei nicht unterstützter Betriebssystemversion):

WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

Ich habe zwei Funktionen, eine für das Senden des Kontextes und die andere für die Höhe und Breite in Pixel:

public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  // Deprecated
    }
    return width;
}

und

public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }
    else{
        height = display.getHeight();  // Deprecated
    }
    return height;
}

Ich würde den getSize-Code wie folgt umschließen:

@SuppressLint("NewApi")
public static Point getScreenSize(Activity a) {
    Point size = new Point();
    Display d = a.getWindowManager().getDefaultDisplay();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        d.getSize(size);
    } else {
        size.x = d.getWidth();
        size.y = d.getHeight();
    }
    return size;
}

Laden Sie zuerst die XML-Datei und schreiben Sie dann diesen Code:

setContentView(R.layout.main);      
Display display = getWindowManager().getDefaultDisplay();
final int width = (display.getWidth());
final int height = (display.getHeight());

Zeigen Sie Breite und Höhe entsprechend Ihrer Bildschirmauflösung an.


Manchmal müssen Sie die genauen Dimensionen des verfügbaren Platzes für ein Layout kennen, wenn Sie in einer Aktivität onCreate sind. Nach einigem Nachdenken habe ich diese Vorgehensweise ausgearbeitet.

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        startActivityForResult(new Intent(this, Measure.class), 1);
        // Return without setting the layout, that will be done in onActivityResult.
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -1);
        // Width is now set to the precise available width, and a layout can now be created.            ...
    }
}

public final class Measure extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
       // Create a LinearLayout with a MeasureFrameLayout in it.
        // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
        LinearLayout linearLayout = new LinearLayout(this);
        LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
        MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
        measureFrameLayout.setLayoutParams(matchParent);
        linearLayout.addView(measureFrameLayout);
        this.addContentView(linearLayout, matchParent);
        // measureFrameLayout will now request this second activity to finish, sending back the width.
    }

    class MeasureFrameLayout extends FrameLayout {
        boolean finished = false;
        public MeasureFrameLayout(Context context) {
            super(context);
        }

        @SuppressLint("DrawAllocation")
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (finished) {
                return;
            }
            finished = true;
            // Send the width back as the result.
            Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
            Measure.this.setResult(Activity.RESULT_OK, data);
            // Tell this activity to finish, so the result is passed back.
            Measure.this.finish();
        }
    }
}

Wenn Sie aus irgendeinem Grund dem Android-Manifest keine weitere Aktivität hinzufügen möchten, können Sie dies folgendermaßen tun:

public class MainActivity extends Activity {
    static Activity measuringActivity;

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        Bundle extras = getIntent().getExtras();
        if (extras == null) {
            extras = new Bundle();
        }
        int width = extras.getInt("Width", -2);
        if (width == -2) {
            // First time in, just start another copy of this activity.
            extras.putInt("Width", -1);
            startActivityForResult(new Intent(this, MainActivity.class).putExtras(extras), 1);
            // Return without setting the layout, that will be done in onActivityResult.
            return;
        }
        if (width == -1) {
            // Second time in, here is where the measurement takes place.
            // Create a LinearLayout with a MeasureFrameLayout in it.
            // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
            LinearLayout linearLayout = new LinearLayout(measuringActivity = this);
            LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
            MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
            measureFrameLayout.setLayoutParams(matchParent);
            linearLayout.addView(measureFrameLayout);
            this.addContentView(linearLayout, matchParent);
            // measureFrameLayout will now request this second activity to finish, sending back the width.
        }
    }

    @Override
    protected void onActivityResult (int requestCode, int resultCode, Intent data) {
        // Probably can never happen, but just in case.
        if (resultCode == RESULT_CANCELED) {
            finish();
            return;
        }
        int width = data.getIntExtra("Width", -3);
        // Width is now set to the precise available width, and a layout can now be created. 
        ...
    }

class MeasureFrameLayout extends FrameLayout {
    boolean finished = false;
    public MeasureFrameLayout(Context context) {
        super(context);
    }

    @SuppressLint("DrawAllocation")
    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (finished) {
            return;
        }
        finished = true;
        // Send the width back as the result.
        Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
        MainActivity.measuringActivity.setResult(Activity.RESULT_OK, data);
        // Tell the (second) activity to finish.
        MainActivity.measuringActivity.finish();
    }
}    

Sie müssen sagen, dass Sie WINDOW_SERVICE nicht benötigen, wenn Sie sich nicht in Activity , sondern in View (oder eine Variable vom Typ " View " in Ihrem Bereich haben). Dann können Sie mindestens zwei Möglichkeiten nutzen.

Zuerst:

DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();

Zweite:

DisplayMetrics dm = new DisplayMetrics();
yourView.getDisplay().getMetrics(dm);

All diese Methoden, die wir hier nennen, sind nicht veraltet.


Um die Bildschirmabmessungen zu erhalten, verwenden Sie Anzeige-Metriken

DisplayMetrics displayMetrics = new DisplayMetrics();
if (context != null) 
      WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
      Display defaultDisplay = windowManager.getDefaultDisplay();
      defaultDisplay.getRealMetrics(displayMetrics);
    }

Holen Sie sich die Höhe und Breite in Pixel

int width  =displayMetrics.widthPixels;
int height =displayMetrics.heightPixels;

Wenn Sie den Overhead von WindowManagers, Points oder Displays nicht möchten, können Sie die Attribute height und width des obersten View-Elements in Ihrem XML-Code abrufen, vorausgesetzt, seine Höhe und Breite sind auf "match_parent" eingestellt. (Dies gilt, solange Ihr Layout den gesamten Bildschirm einnimmt.)

Zum Beispiel, wenn Ihr XML mit so etwas beginnt:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/entireLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

Dann findViewById(R.id.entireLayout).getWidth() gibt die Bildschirmbreite zurück und findViewById(R.id.entireLayout).getHeight() gibt die Höhe des Bildschirms zurück.


Wenn Sie die Anzeigegröße in Pixeln haben möchten, können Sie getSize :

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

Wenn Sie nicht in einer Activity , können Sie die Standardanzeige über WINDOW_SERVICE :

WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

Bevor getSize eingeführt wurde (in API-Ebene 13), könnten Sie die getWidth und getHeight Methoden verwenden, die jetzt veraltet sind:

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

Für den Anwendungsfall, den Sie beschreiben, scheint jedoch ein Rand / Abstand im Layout angemessener zu sein.

22. Oktober 2015

Eine andere Möglichkeit ist: DisplayMetrics

Eine Struktur, die allgemeine Informationen zu einer Anzeige beschreibt, z. B. ihre Größe, Dichte und Schriftartenskalierung. Um auf die DisplayMetrics-Mitglieder zuzugreifen, initialisieren Sie ein Objekt wie folgt:

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

Wir können widthPixels , um Informationen zu erhalten für:

"Die absolute Breite der Anzeige in Pixeln."

Beispiel:

Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);

findViewById() Sie zuerst die Ansicht (z. B. von findViewById() ) und dann können Sie getWidth() für die Ansicht selbst verwenden.


DisplayMetrics dimension = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dimension);
int w = dimension.widthPixels;
int h = dimension.heightPixels;




dimensions