ඇන්ඩ්‍රොයිඩ් හි තිරයේ මානයන් පික්සෙල් ලෙස ලබා ගන්නේ කෙසේද

මම අභිරුචි අංග කිහිපයක් නිර්මාණය කළ අතර, ඒවා ක්‍රමයෙන් ඉහළ දකුණු කෙළවරට තැබීමට මට අවශ්‍යය ( nඉහළ දාරයේ සිට mපික්සල් සහ දකුණු දාරයේ සිට පික්සෙල්). එබැවින් මට තිරයේ පළල සහ තිරයේ උස ලබා ගත යුතු අතර පසුව පිහිටීම සැකසිය යුතුය:

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

මම කොහොමද ලබා ගන්නේ කෙසේද screenWidthහා screenHeightප්රධාන ක්රියාකාරකම් තුළ?

ඔබට දර්ශන මානයන් පික්සෙල් වලින් අවශ්‍ය නම් ඔබට භාවිතා කළ හැකිය getSize:

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

ඔබ නොමැති නම් ඔබට Activityපෙරනිමිය ලබා ගත Displayහැකිය WINDOW_SERVICE:

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

ඔබ කැබැල්ලක සිටින අතර මෙය සම්පූර්ණ කිරීමට අවශ්‍ය නම් Activity.WindowManager (Xamarin.Android හි) හෝ getActivity () භාවිතා කරන්න. GetWindowManager () (java වලින්).

getSizeහඳුන්වාදීමට පෙර (API මට්ටමේ 13), ඔබට දැන් අතහැර දමා ඇති ක්‍රම getWidthසහ getHeightක්‍රම භාවිතා කළ හැකිය :

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

කෙසේ වෙතත් ඔබ විස්තර කරන භාවිත අවස්ථාව සඳහා, පිරිසැලසුමේ ආන්තිකය / පෑඩින් කිරීම වඩාත් සුදුසු බව පෙනේ.

තවත් ක්‍රමයක් නම්: DisplayMetrics

සංදර්ශකයක් පිළිබඳ සාමාන්‍ය තොරතුරු විස්තර කරන ව්‍යුහයක්, එහි ප්‍රමාණය, ity නත්වය සහ අකුරු පරිමාණය වැනි. DisplayMetrics සාමාජිකයින්ට ප්‍රවේශ වීම සඳහා, මෙවැනි වස්තුවක් ආරම්භ කරන්න:

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

මේ widthPixelsසඳහා තොරතුරු ලබා ගැනීමට අපට භාවිතා කළ හැකිය:

"දර්ශනයේ නිරපේක්ෂ පළල පික්සල් වලින්."

උදාහරණයක්:

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

එක් ක්‍රමයක් නම්:

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

එය අවලංගු කර ඇති අතර ඒ වෙනුවට ඔබ පහත කේතය උත්සාහ කළ යුතුය. කේතයේ පළමු පේළි දෙක මඟින් ඔබට DisplayMetricsවස්තු ලබා දේ . මෙම වස්තූන් මෙන් ක්ෂේත්ර අන්තර්ගත වේ heightPixels, widthPixels.

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

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

එය ඔබගේ ප්‍රශ්නයට පිළිතුරු නොදක්වනු ඇත, නමුත් එය දැන ගැනීම ප්‍රයෝජනවත් විය හැකිය (මම මෙම ප්‍රශ්නයට පැමිණි විට එය මා විසින්ම සොයමින් සිටියෙමි) ඔබට දර්ශන මානයක් අවශ්‍ය නම් ඔබේ කේතය එහි පිරිසැලසුම තවමත් සකසා නොමැති විට ක්‍රියාත්මක වේ. (උදාහරණයක් සඳහා onCreate()) ඔබ පිහිටුවන්නේ හැකි ViewTreeObserver.OnGlobalLayoutListenerසමග View.getViewTreeObserver().addOnGlobalLayoutListener()සහ එහි දැක්ම ගේ මානයක් අවශ්ය බව අදාළ කේතය ය. පිරිසැලසුම සකස් කර ඇති විට සවන්දෙන්නන්ගේ ඇමතුම කැඳවනු ලැබේ.

(2012 පිළිතුර, යල් පැන ගිය එකක් විය හැකිය) ඔබට පෙර පැණි වදයට සහය දැක්වීමට අවශ්‍ය නම්, ඒපීඅයි 13 ට පෙර පසුගාමී අනුකූලතාවයක් දැක්වීමට ඔබට අවශ්‍ය වනු ඇත.

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

ඇත්ත වශයෙන්ම අවලංගු කරන ලද ක්‍රම නවීනතම SDK වලින් ඉවත් කරනු ඇත, නමුත් අපි තවමත් ඇන්ඩ්‍රොයිඩ් 2.1, 2.2 සහ 2.3 ඇති අපගේ බොහෝ පරිශීලකයින් මත විශ්වාසය තබන අතර, අපට ඉතිරිව ඇත්තේ මෙයයි.

හැකි සෑම "විසඳුම් "ම මම අසාර්ථක ලෙස උත්සාහ කර ඇති අතර එලියට් හියුස්ගේ" ඩල්වික් එක්ස්ප්ලෝරර් "යෙදුම සෑම ඇන්ඩ්‍රොයිඩ් උපාංගයකම / මෙහෙයුම් පද්ධතියකම නිවැරදි මානයන් පෙන්වන බව මම දුටුවෙමි. මම මෙහි සොයාගත හැකි ඔහුගේ විවෘත මූලාශ්‍ර ව්‍යාපෘතිය දෙස බැලුවෙමි: https://code.google.com/p/enh/

අදාළ සියලුම කේතය මෙන්න:

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

සංස්කරණය කරන්න: තරමක් වැඩිදියුණු කළ අනුවාදය (සහය නොදක්වන OS අනුවාදයේ වෙඩි තැබීම් වලින් වළකින්න):

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

සරලම ක්‍රමය:

 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 

ඇන්ඩ්‍රොයිඩ් උපාංග සඳහා තත්ව තීරුවේ උස වෙත ප්‍රවේශ වීම සඳහා, එය ලබා ගැනීම සඳහා ක්‍රමලේඛන ක්‍රමයකට අපි කැමැත්තෙමු:

නියැදි කේතය

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

විචල්‍යය resultපික්සෙල් වල උස ලබා දෙයි.

ඉක්මන් ප්‍රවේශය සඳහා

උස පිළිබඳ වැඩි විස්තර සඳහා Title bar, Navigation barසහ Content View, ඇන්ඩ්‍රොයිඩ් උපාංග තිර ප්‍රමාණ දෙස කාරුණිකව බලන්න .

පළමුවෙන්ම දර්ශනය ලබා ගන්න (උදා. findViewById()) එවිට ඔබට දර්ශනයෙහිම getWidth () භාවිතා කළ හැකිය .

මට කාර්යයන් දෙකක් ඇත, එකක් සන්දර්භය යැවීම සඳහා වන අතර අනෙක උස හා පළල පික්සල් වලින් ලබා ගැනීම:

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

සහ

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

XML භාවිතා කරමින් ගතිකව පරිමාණය කිරීම සඳහා "android: Layout_weight" නමින් ගුණාංගයක් ඇත.

මෙම ත්‍රෙඩ් එකේ සයිනික් ප්‍රතිචාරයෙන් වෙනස් කරන ලද පහත උදාහරණයෙන්, තිරයෙන් 75% ක් (බර = .25) ගතවන බොත්තමක් සහ තිරයේ ඉතිරි 25% (බර = .75) ලබා ගන්නා පෙළ දර්ශනයක් පෙන්වයි.

<LinearLayout android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight=".25"
        android:text="somebutton">

    <TextView android:layout_width="fill_parent"
        android:layout_height="Wrap_content"
        android:layout_weight=".75">
</LinearLayout>

කාර්යය සඳහා මා භාවිතා කරන කේතය මෙයයි:

// `activity` is an instance of Activity class.
Display display = activity.getWindowManager().getDefaultDisplay();
Point screen = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    display.getSize(screen);
} else {            
    screen.x = display.getWidth();
    screen.y = display.getHeight();
}

ප්‍රමාණවත් තරම් පිරිසිදු බවක් පෙනෙන්නට තිබුණද, ක්ෂයවීම ගැන සැලකිලිමත් වේ.

මෙය වඩා හොඳ විසඳුමක් නොවේද? ඩිස්ප්ලේ මෙට්‍රික්ස් ඔබට අවශ්‍ය සියල්ල සමඟ එන අතර ඒපීඅයි 1 වෙතින් ක්‍රියා කරයි.

public void getScreenInfo(){
    DisplayMetrics metrics = new DisplayMetrics();
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);

    heightPixels = metrics.heightPixels;
    widthPixels = metrics.widthPixels;
    density = metrics.density;
    densityDpi = metrics.densityDpi;
}

GetRealMetrics භාවිතයෙන් ඔබට සත්‍ය දර්ශනය (තත්ව තීරුව හෝ මෘදුකාංග සංචාලන තීරුව වැනි තිර අලංකරණ ඇතුළුව) ලබා ගත හැකිය , නමුත් මෙය ක්‍රියාත්මක වන්නේ 17+ මත පමණි.

මට යමක් මග හැරී තිබේද?

ෆ්‍රැන්චෙස්කෝගේ පිළිතුරට එකතු කිරීම පමණි. කවුළුවේ හෝ තිරයේ ඇති ස්ථානය සොයා ගැනීමට ඔබට අවශ්‍ය නම් වඩාත් යෝග්‍ය අනෙක් නිරීක්ෂකයා වන්නේ ViewTreeObserver.OnPreDrawListener ()

OnCreate () වේලාවේදී බොහෝ දුරට නොදන්නා දර්ශනයක වෙනත් ගුණාංග සොයා ගැනීමට මෙය භාවිතා කළ හැකිය. උදා: අනුචලනය කළ ස්ථානය, පරිමාණය කළ ස්ථානය.

ක්‍රියාකාරකම් වලදී පහත කේතය භාවිතා කිරීම.

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int height = metrics.heightPixels;
int wwidth = metrics.widthPixels;

තිරයේ පළල සහ උස සොයා ගන්න:

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

මෙය භාවිතා කිරීමෙන් අපට නවතම සහ ඉහළ SDK 13 ලබා ගත හැකිය.

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

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

මට තේරුණා මේක උපක්‍රමයක් කියලා.

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

ඔබට කිව යුතු නැත, ඔබ නොමැති නම් Activity, නමුත් View(හෝ Viewඔබේ විෂය පථයේ විචල්‍ය වර්ග තිබේ නම්) භාවිතා කිරීමට අවශ්‍ය නොවේWINDOW_SERVICE . එවිට ඔබට අවම වශයෙන් ක්‍රම දෙකක් භාවිතා කළ හැකිය.

පලමු:

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

දෙවැනි:

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

අප මෙහි හඳුන්වන මෙම සියලු ක්‍රම අතහැර දමා නැත.

public class AndroidScreenActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        String str_ScreenSize = "The Android Screen is: "
                                   + dm.widthPixels
                                   + " x "
                                   + dm.heightPixels;

        TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize);
        mScreenSize.setText(str_ScreenSize);
    }
}

තිර මානයන් ලබා ගැනීම සඳහා දර්ශන මෙට්‍රික්ස් භාවිතා කරන්න

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

උස සහ පළල පික්සල් වලින් ලබා ගන්න

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

සැබෑ පික්සෙල් වලින් දර්ශන මානයන් අවශ්‍ය වූ බැවින් මෙය OP සඳහා පිළිතුරක් නොවේ. මට "උපාංග-ස්වාධීන-පික්සල්" හි මානයන් අවශ්‍ය වූ අතර, මෙතැන් සිට පිළිතුරු එකතු කිරීම https://stackoverflow.com/a/17880012/253938 සහ මෙහි https://stackoverflow.com/a/6656774/253938 මම ආවා මේ සමඟ:

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

ඔබට මෙය භාවිතා කර උස ප්‍රමාණය ලබා ගත හැකිය :

getResources().getDisplayMetrics().heightPixels;

සහ පළල ප්‍රමාණය භාවිතා කිරීම

getResources().getDisplayMetrics().widthPixels; 

ඩිස්ප්ලේ මෙට්‍රික්ස් (ඒපීඅයි 1) භාවිතයෙන් මෙය කිරීමට අවලංගු නොකළ ක්‍රමයක් ඇත, එමඟින් උත්සාහය / අල්ලා ගැනීමේ අවුල් මඟහරවා ගත හැකිය:

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

මම මේ වගේ getSize කේතය ඔතා:

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

තත්ව තීරුව සහ ක්‍රියාකාරී තීරුව නොමැතිව භාවිතා කළ හැකි තිර මානයන් සොයන්නේ කවුරුන් සඳහාද (ස්වප්නිල්ගේ පිළිතුරට ස්තූතියි):

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

පළමුව XML ගොනුව පටවා මෙම කේතය ලියන්න:

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

ඔබගේ තිර විභේදනය අනුව පළල සහ උස පෙන්වන්න.

පහත ක්‍රම අනුගමනය කරන්න:

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

කොට්ලින්

fun getScreenHeight(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.heightPixels
}

fun getScreenWidth(activity: Activity): Int {
    val metrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(metrics)
    return metrics.widthPixels
}

යම් ක්‍රියාකාරකමක් ක්‍රියාත්මක වන විට පිරිසැලසුමක් සඳහා ඇති ඉඩ ප්‍රමාණය නිවැරදිව දැන ගැනීමට ඔබට අවශ්‍ය අවස්ථා තිබේ. යම්කිසි සිතුවිල්ලකින් පසු මම මේ ආකාරයෙන් එය කළෙමි.

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

කිසියම් හේතුවක් නිසා ඔබට ඇන්ඩ්‍රොයිඩ් මැනිෆෙස්ටයට වෙනත් ක්‍රියාකාරකමක් එක් කිරීමට අවශ්‍ය නැතිනම්, ඔබට එය මේ ආකාරයෙන් කළ හැකිය:

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

වින්ඩෝ මැනේජර්ස්, පොයින්ට්ස් හෝ ඩිස්ප්ලේ වල ඉහළ කොටස ඔබට අවශ්‍ය නැතිනම්, ඔබේ XML හි ඉහළම දර්ශන අයිතමයේ උස සහ පළල ගුණාංග අල්ලා ගත හැකිය, එහි උස සහ පළල ගැලපෙන_පෙරන්ට් ලෙස සකසා තිබේ නම්. (ඔබේ පිරිසැලසුම මුළු තිරයම ගන්නා තාක් කල් මෙය සත්‍යයකි.)

උදාහරණයක් ලෙස, ඔබේ XML ආරම්භ වන්නේ මේ වගේ දෙයක් සමඟ නම්:

<?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" >

එවිට findViewById(R.id.entireLayout).getWidth()තිරයේ පළල findViewById(R.id.entireLayout).getHeight()නැවත ලබා දෙන අතර තිරයේ උස නැවත ලබා දෙනු ඇත.