অ্যান্ড্রয়েডে পর্দার প্রস্থ এবং উচ্চতা পান

Question

আমি কীভাবে পর্দার প্রস্থ এবং উচ্চতা পেতে পারি এবং এই মানটি এতে ব্যবহার করতে পারি:

@Override protected void onMeasure(int widthSpecId, int heightSpecId) {
    Log.e(TAG, "onMeasure" + widthSpecId);
    setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT - 
        game.findViewById(R.id.flag).getHeight());
}

Comments

দেখুন: stackoverflow.com/questions/1016896/...

— উইল টেট

Answer 1

এই কোডটি ব্যবহার করে আপনি রানটাইম প্রদর্শনের প্রস্থ এবং উচ্চতা পেতে পারেন:

DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int height = displayMetrics.heightPixels;
int width = displayMetrics.widthPixels;

---

একটি দৃশ্যে আপনার এই জাতীয় কিছু করা দরকার:

((Activity) getContext()).getWindowManager()
                         .getDefaultDisplay()
                         .getMetrics(displayMetrics);

---

কিছু পরিস্থিতিতে, যেখানে ডিভাইসগুলির একটি নেভিগেশন বার রয়েছে, আপনাকে রানটাইম এ পরীক্ষা করতে হবে:

public boolean showNavigationBar(Resources resources)
{
    int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
    return id > 0 && resources.getBoolean(id);
}

ডিভাইসে যদি নেভিগেশন বার থাকে তবে তার উচ্চতাটি গণনা করুন:

private int getNavigationBarHeight() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        DisplayMetrics metrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(metrics);
        int usableHeight = metrics.heightPixels;
        getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
        int realHeight = metrics.heightPixels;
        if (realHeight > usableHeight)
            return realHeight - usableHeight;
        else
            return 0;
    }
    return 0;
}

সুতরাং ডিভাইসের চূড়ান্ত উচ্চতা হ'ল:

int height = displayMetrics.heightPixels + getNavigationBarHeight();

Comments

ডিভাইসটি ঘোরানো হলে প্রস্থ এবং উচ্চতা অদলবদল করা হয়?

— Madeyedexter

পছন্দ করুন

— পরাগ চৌহান

তবে আপনি আর ধরে নিতে পারবেন না যে আপনি ডিফল্ট ডিসপ্লেতে চলছে।

— satur9nine

বা কেবল সহজভাবে ব্যবহার করুন - getResferences ()। getDisplayMetrics ()। উচ্চতাপিক্সেল / getRes્રોসেস ()। getDisplayMetrics ()। প্রশস্তপিক্সেল

— অ্যালেক্স

@ এপিকপান্ডা ফোরস আসলে আমি অ্যান্ড্রয়েড ওরিওর কথা ভাবছিলাম যা অন্য ডিসপ্লেতে কোনও ক্রিয়াকলাপ শুরু করতে দেয়,

— নীচেরগুলি

Answer 2

খুব সাধারণ উত্তর এবং পাস প্রসঙ্গে ছাড়াই রয়েছে

public static int getScreenWidth() {
    return Resources.getSystem().getDisplayMetrics().widthPixels;
}

public static int getScreenHeight() {
    return Resources.getSystem().getDisplayMetrics().heightPixels;
}

দ্রষ্টব্য: আপনি যদি উচ্চতাতে নেভিগেশন বার অন্তর্ভুক্ত করতে চান তবে নীচের পদ্ধতিটি ব্যবহার করুন

WindowManager windowManager =
        (WindowManager) BaseApplication.getApplication().getSystemService(Context.WINDOW_SERVICE);
    final Display display = windowManager.getDefaultDisplay();
    Point outPoint = new Point();
    if (Build.VERSION.SDK_INT >= 19) {
        // include navigation bar
        display.getRealSize(outPoint);
    } else {
        // exclude navigation bar
        display.getSize(outPoint);
    }
    if (outPoint.y > outPoint.x) {
        mRealSizeHeight = outPoint.y;
        mRealSizeWidth = outPoint.x;
    } else {
        mRealSizeHeight = outPoint.x;
        mRealSizeWidth = outPoint.y;
    }

Comments

মোট পর্দার উচ্চতা কিভাবে পাবেন? গেটস্ক্রিনহাইটের এই সংস্করণটি সমস্ত বার বাদ দেয়।

— জয়দেব

এটি বেশিরভাগ ক্ষেত্রেই কাজ করে তবে নেভিগেশন বারটি দৃশ্যমান হলে এটি সত্যিকারের পর্দার উচ্চতা পেতে পারে না। উচ্চতা বারের উচ্চতা বাদ দেয়।

— এল। সুইফটার

এটি আমার জন্য ল্যান্ডস্কেপ মোডে অস্বাভাবিক ফলাফল তৈরি করেছে

— কারসন হল্হাইমার

এটি একাধিক ডিসপ্লে (

— ফোল্ডেবলস

নেভিগেশন বারের উচ্চতা অ্যান্ড্রয়েড ৪.৪

— এমস্টোইক

Answer 3

অবজ্ঞাত পদ্ধতিগুলি থেকে বর্তমান এসডিকে পশ্চাদপদ সামঞ্জস্যের সাথে একত্রিত করতে কেবল প্যারাগ এবং স্পেকে উত্তর আপডেট করতে:

int Measuredwidth = 0;  
int Measuredheight = 0;  
Point size = new Point();
WindowManager w = getWindowManager();

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)    {
    w.getDefaultDisplay().getSize(size);
    Measuredwidth = size.x;
    Measuredheight = size.y; 
}else{
    Display d = w.getDefaultDisplay(); 
    Measuredwidth = d.getWidth(); 
    Measuredheight = d.getHeight(); 
}

Comments

@ ডিজিপিএইচডি কি সমস্ত এপিআই সংস্করণে পারাংয়ের কোডটি কাজ করবে না? সমস্ত পদ্ধতিগুলি এপিআই স্তরের 8 এর আগে প্রবর্তিত হয়েছিল এবং আমি এন্ড্রয়েড ডেভ সাইটটিতে সেগুলি হ্রাস পেয়েছি।

— সুফিয়ান

@ সুফিয়ান আমাকে একটি স্যামসুং getSizeগ্যালাক্সি মিনি (এপিআই 10) বাস্তবায়ন থেকে অ-0 রিটার্ন মান পেতে সমস্যা হয়েছে তবে এই উত্তরের অবচিত পদ্ধতিগুলি সঠিকভাবে ফিরে আসে। সুতরাং এটি অ্যান্ড্রয়েডের পুরানো সংস্করণগুলির জন্য দরকারী।

— ড্যামিয়েন ডিহল

@ সুফিয়ান কি আমরা পর্দার প্রস্থ এবং উচ্চতায় নতুন মাত্রা নির্ধারণ করতে পারি?

— সৃষ্টি রায়

এটি এখন অবচয় করা হয়েছে :(

— সেগপ্রকাশ

Answer 4

কেন না

ডিসপ্লেমেট্রিক্স ডিসপ্লেমেট্রিক্স = গেটআরসোর্সেস ()। GetDisplayMetrics ();

তারপরে ব্যবহার করুন

প্রদর্শনমেট্রিক্স.উইথপিক্সেল (উচ্চতাপিক্সেল)

Answer 5

কোডের নীচে চেষ্টা করুন: -

1।

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

2।

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

অথবা

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

3।

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

metrics.heightPixels;
metrics.widthPixels;

Comments

আপনি কি ভাবেন না 2 = 4

— ত্রিকালদর্শী

মানে আপনার পদ্ধতি 2 4 method পদ্ধতির সমান

— ত্রিকালদর্শী

ডিভাইসের "প্রাকৃতিক" রেজোলিউশন পাওয়া কি সম্ভব? এর অর্থ হ'ল আপনি পর্দাটি ঘোরান, আপনি প্রস্থ এবং উচ্চতার জন্য একই মান পাবেন এবং এটি যদি ট্যাবলেটটি অনুভূমিকভাবে ব্যবহার করা হয়, তবে এটি উচ্চতার পরিবর্তে প্রস্থটি বড় হিসাবে প্রত্যাবর্তন করবে?

— অ্যান্ড্রয়েড বিকাশকারী

Answer 6

অ্যান্ড্রয়েডে পাওয়া খুব সহজ:

int width  = Resources.getSystem().getDisplayMetrics().widthPixels;
int height = Resources.getSystem().getDisplayMetrics().heightPixels;

Comments

এটি এমুলেটরটিতে 0 ফিরে আসে

— l3ob

Answer 7

কোটলিন ব্যবহারকারীদের জন্য

fun Activity.displayMetrics(): DisplayMetrics {
   val displayMetrics = DisplayMetrics()
   windowManager.defaultDisplay.getMetrics(displayMetrics)
   return displayMetrics
}

এবং ক্রিয়াকলাপে আপনি এটি পছন্দ মতো ব্যবহার করতে পারেন

     resources.displayMetrics.let { displayMetrics ->
        val height = displayMetrics.heightPixels
        val width = displayMetrics.widthPixels
    }

বা খণ্ডে

    activity?.displayMetrics()?.run {
        val height = heightPixels
        val width = widthPixels
    }

Answer 8

DisplayMetrics dimension = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dimension);
        int width = dimension.widthPixels;
        int height = dimension.heightPixels;

Answer 9

DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics();
int widthPixels = lDisplayMetrics.widthPixels;
int heightPixels = lDisplayMetrics.heightPixels;

Answer 10

পর্দার প্রস্থ এবং উচ্চতার মান পান।

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

Answer 11

Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int mWidthScreen = display.getWidth();
int mHeightScreen = display.getHeight();

Comments

অবহেলিত, ডিসপ্লেমেট্রিক্স ()

— ডায়ানম

Answer 12

public class DisplayInfo {
    int screen_height=0, screen_width=0;
    WindowManager wm;
    DisplayMetrics displaymetrics;

    DisplayInfo(Context context) {
        getdisplayheightWidth(context);
    }

    void getdisplayheightWidth(Context context) {
        wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        displaymetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(displaymetrics);
        screen_height = displaymetrics.heightPixels;
        screen_width = displaymetrics.widthPixels;
    }

    public int getScreen_height() {
        return screen_height;
    }

    public int getScreen_width() {
        return screen_width;
    }
}

Answer 13

এখানে কোনও উত্তর ক্রোম ওএসের একাধিক ডিসপ্লে বা শীঘ্রই আসবে ফোল্ডেবলগুলির জন্য সঠিকভাবে কাজ করে না।

বর্তমান কনফিগারেশনটি সন্ধান করার সময়, সর্বদা আপনার বর্তমান ক্রিয়াকলাপ থেকে কনফিগারেশনটি ব্যবহার করুন getResources().getConfiguration()। আপনার ব্যাকগ্রাউন্ড ক্রিয়াকলাপ বা সিস্টেম সংস্থান থেকে একটিকে কনফিগারেশন ব্যবহার করবেন না। পটভূমি ক্রিয়াকলাপটির কোনও আকার থাকে না এবং সিস্টেমের কনফিগারেশনে বিরোধী আকার এবং অভিমুখীকরণ সহ একাধিক উইন্ডোজ থাকতে পারে , তাই কোনও ব্যবহারযোগ্য ডেটা বের করা যায় না।

সুতরাং উত্তর হয়

val config = context.getResources().getConfiguration()
val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp

Answer 14

এখানে দেখানো পদ্ধতিগুলি অবচিত / পুরানো তবে এটি এখনও কাজ করছে API

এটা দেখ

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

Answer 15

এটি করার সম্পূর্ণ উপায়, এটি আসল রেজোলিউশনটি দেয়:

            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Point size = new Point();
            wm.getDefaultDisplay().getRealSize(size);
            final int width = size.x, height = size.y;

এবং যেহেতু এটি বিভিন্ন দিকনির্দেশে পরিবর্তিত হতে পারে, তাই এখানে একটি সমাধান (কোটলিনে) দেওয়া হয়েছে, এটিকে সঠিক দিকনির্দেশ দেওয়ার জন্য এটি সঠিকভাবে পেতে:

/**
 * returns the natural orientation of the device: Configuration.ORIENTATION_LANDSCAPE or Configuration.ORIENTATION_PORTRAIT .<br></br>
 * The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalOrientation(context: Context): Int {
    //based on : http://stackoverflow.com/a/9888357/878126
    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val config = context.resources.configuration
    val rotation = windowManager.defaultDisplay.rotation
    return if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && config.orientation == Configuration.ORIENTATION_LANDSCAPE || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && config.orientation == Configuration.ORIENTATION_PORTRAIT)
        Configuration.ORIENTATION_LANDSCAPE
    else
        Configuration.ORIENTATION_PORTRAIT
}

/**
 * returns the natural screen size (in pixels). The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalSize(context: Context): Point {
    val screenNaturalOrientation = getScreenNaturalOrientation(context)
    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val point = Point()
    wm.defaultDisplay.getRealSize(point)
    val currentOrientation = context.resources.configuration.orientation
    if (currentOrientation == screenNaturalOrientation)
        return point
    else return Point(point.y, point.x)
}

Answer 16

কেবলমাত্র নীচের ফাংশনটি ব্যবহার করুন যা পর্দার আকারের দৈর্ঘ্য এবং উচ্চতা পূর্ণসংখ্যার অ্যারে হিসাবে দেয়

private int[] getScreenSIze(){
        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        int h = displaymetrics.heightPixels;
        int w = displaymetrics.widthPixels;

        int[] size={w,h};
        return size;

    }

আপনার অনক্রিয়েট ফাংশন বা বোতামে ক্লিক করুন নীচের চিত্র হিসাবে আউটপুট স্ক্রিন আকার নিম্নলিখিত কোড

 int[] screenSize= getScreenSIze();
        int width=screenSize[0];
        int height=screenSize[1];
        screenSizes.setText("Phone Screen sizes \n\n  width = "+width+" \n Height = "+height);

Answer 17

কোটলিনের জন্য এই কোডটি ব্যবহার করে দেখুন

 val display = windowManager.defaultDisplay
 val size = Point()
 display.getSize(size)
 var DEVICE_WIDTH = size.x
 var DEVICE_HEIGHT = size.y

Answer 18

আমি স্ক্রিনের মাত্রা পেতে নিম্নলিখিত কোডটি ব্যবহার করি

getWindow().getDecorView().getWidth()
getWindow().getDecorView().getHeight()

Answer 19

আমি কোটলিন ভাষার জন্য উত্তর আপডেট করেছি!

কোটলিনের জন্য: আপনার উইন্ডো ম্যানেজারকে কল করা উচিত এবং মেট্রিকগুলি পাওয়া উচিত। সহজ উপায় পরে।

val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)

var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels

কোটলিন ভাষার সাথে আমরা কীভাবে এটি স্বাধীন কার্যকলাপে কার্যকরভাবে ব্যবহার করতে পারি?

এখানে, আমি সাধারণ কোটলিন শ্রেণিতে একটি পদ্ধতি তৈরি করেছি। আপনি এটি সমস্ত ক্রিয়াকলাপে ব্যবহার করতে পারেন।

private val T_GET_SCREEN_WIDTH:String = "screen_width"
private val T_GET_SCREEN_HEIGHT:String = "screen_height"

private fun getDeviceSizes(activity:Activity, whichSize:String):Int{

    val displayMetrics = DisplayMetrics()
    activity.windowManager.defaultDisplay.getMetrics(displayMetrics)

    return when (whichSize){
        T_GET_SCREEN_WIDTH -> displayMetrics.widthPixels
        T_GET_SCREEN_HEIGHT -> displayMetrics.heightPixels
        else -> 0 // Error
    }
}

যোগাযোগ: @ কনারকেসেলার

Comments

আরও ভাল সমাধান ক্রিয়াকলাপ শ্রেণীর জন্য একটি এক্সটেনশন ফাংশন তৈরি করা হতে পারে।

— মাইক্রার

Answer 20

আমি ওয়েইগানের উত্তরটি এই পৃষ্ঠায় সেরা পেয়েছি , আপনি এখানে এটি কীভাবে ব্যবহার করতে পারেন তা এখানে Xamarin.Android:

public int GetScreenWidth()
{
    return Resources.System.DisplayMetrics.WidthPixels;
}

public int GetScreenHeight()
{
    return Resources.System.DisplayMetrics.HeightPixels;
}

Answer 21

স্ক্রিনের রেজোলিউশন পর্দার মোট পিক্সেল নয়। নিম্নলিখিত প্রোগ্রামটি ডিভাইসের স্ক্রিন রেজোলিউশনটি বের করবে। এটি স্ক্রিনের প্রস্থ এবং উচ্চতা মুদ্রণ করবে। এই মানগুলি পিক্সেল হয়।

public static Point getScreenResolution(Context context) {
// get window managers
WindowManager manager =  (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
Display display = manager.getDefaultDisplay();
Point point = new Point();
display.getSize(point);

 // get width and height
 int width = point.x;
 int height = point.y;

 return point;

}

Answer 22

ইউটিলিটিগুলির এই সেটঅ্যান্ড্রয়েডের আকার বিমূর্তি নিয়ে কাজ ।

এটিতে একটি শ্রেণি আকার রয়েছেফ্রিজডিসপ্লে.জভা আপনি এটি এটি ব্যবহার করতে পারেন:

ISize size = new SizeFromDisplay(getWindowManager().getDefaultDisplay());
size.width();
size.hight();

Answer 23

দুটি পদক্ষেপ। প্রথমে ক্রিয়াকলাপ শ্রেণি প্রসারিত করুন

class Example extends Activity

দ্বিতীয়: এই কোডটি ব্যবহার করুন

 DisplayMetrics displayMetrics = new DisplayMetrics();
 WindowManager windowmanager = (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
 windowmanager.getDefaultDisplay().getMetrics(displayMetrics);
 int deviceWidth = displayMetrics.widthPixels;
 int deviceHeight = displayMetrics.heightPixels;

Answer 24

    int getScreenSize() {
        int screenSize = getResources().getConfiguration().screenLayout &
                Configuration.SCREENLAYOUT_SIZE_MASK;
//        String toastMsg = "Screen size is neither large, normal or small";
        Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
        int orientation = display.getRotation();

        int i = 0;
        switch (screenSize) {

            case Configuration.SCREENLAYOUT_SIZE_NORMAL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_SMALL:
                i = 1;
//                toastMsg = "Normal screen";
                break;
            case Configuration.SCREENLAYOUT_SIZE_LARGE:
//                toastMsg = "Large screen";
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 2;
                } else {
                    i = 1;
                }


                break;
            case Configuration.SCREENLAYOUT_SIZE_XLARGE:
                if (orientation == Surface.ROTATION_90
                        || orientation == Surface.ROTATION_270) {
                    // TODO: add logic for landscape mode here
                    i = 4;
                } else {
                    i = 3;
                }

                break;


        }
//        customeToast(toastMsg);
        return i;
    }

Answer 25

       @Override
        protected void onPostExecute(Drawable result) {
            Log.d("width",""+result.getIntrinsicWidth());
            urlDrawable.setBounds(0, 0, 0+result.getIntrinsicWidth(), 600);

            // change the reference of the current drawable to the result
            // from the HTTP call
            urlDrawable.drawable = result;

            // redraw the image by invalidating the container
            URLImageParser.this.container.invalidate();

            // For ICS
            URLImageParser.this.container.setHeight((400+URLImageParser.this.container.getHeight()
                    + result.getIntrinsicHeight()));

            // Pre ICS`enter code here`
            URLImageParser.this.container.setEllipsize(null);
        }

Comments

কোড সহ কিছু ব্যাখ্যা লিখুন। কোডের উত্তরগুলি কেবলমাত্র তাই-তে নিরুৎসাহিত হয়

— রাম গাদিয়রাম