প্রোগ্রামটিমে অ্যান্ড্রয়েডে পর্দার ঘনত্ব পাচ্ছেন?

Question

প্রোগ্রামটিতে অ্যান্ড্রয়েডে স্ক্রিনের ঘনত্ব কীভাবে পাবেন?

মানে: বর্তমান ডিভাইসের স্ক্রিন ডিপিআই কীভাবে সন্ধান করব?

Comments

অনেক উত্তর উল্লেখ করে getDisplayMetrics().xdpi, যা ডিভাইসের আসল ডিপিআই ফেরানোর কথা। দয়া করে মনে রাখবেন যে এই মানটি নির্মাতারা ডিভাইসগুলিতে নিয়মিতভাবে সঠিকভাবে সেট করে না, তাই আপনি কেবল সেগুলি ব্যবহার করতে পারবেন না । দুঃখজনক হলেও সত্য: আসল ডিপিআই সম্পর্কিত তথ্য উপলব্ধ নেই । সূত্র: গ্রুপ. google.com/d/msg/android-developers/g56jV0Hora0/…

— সুলাই

getResources().getDisplayMetrics().xdpiএবং getResources().getDisplayMetrics().ydpiআপনাকে প্রকৃত অনুভূমিক এবং উল্লম্ব ঘনত্ব দেবে , যা বেশিরভাগ ক্ষেত্রে আলাদা।

— gaমেগা

Answer 1

আপনি ডিসপ্লেমেট্রিক্স স্ট্রাক্ট থেকে ডিসপ্লেতে তথ্য পেতে পারেন :

DisplayMetrics metrics = getResources().getDisplayMetrics();

যদিও অ্যান্ড্রয়েড সরাসরি পিক্সেল ম্যাপিং ব্যবহার করে না, এটি মুষ্টিমেয় কোয়ানাইটিসড ডেনসিটি ইন্ডিপেন্ডেন্ট পিক্সেল মানগুলি ব্যবহার করে তারপরে প্রকৃত স্ক্রিন আকারে স্কেল করে। সুতরাং metrics.densityDpiসম্পত্তি এক হতে হবে DENSITY_xxxধ্রুবক ( 120, 160, 213, 240, 320, 480বা 640DPI)।

আপনার যদি সত্যিকারের এলসিডি পিক্সেল ঘনত্বের প্রয়োজন হয় (সম্ভবত কোনও ওপেনজিএল অ্যাপের জন্য) আপনি যথাক্রমে অনুভূমিক এবং উল্লম্ব ঘনত্বের জন্য metrics.xdpiএবং metrics.ydpiবৈশিষ্ট্যগুলি থেকে এটি পেতে পারেন ।

আপনি যদি 4 এরও বেশি আগে এপিআই স্তরগুলিকে লক্ষ্য করে থাকেন তবে metrics.densityসম্পত্তিটি হল রেফারেন্স ডেনসিটি (160dpi) থেকে একটি ভাসমান পয়েন্ট স্কেলিং ফ্যাক্টর। বর্তমানে সরবরাহ করা একই মান metrics.densityDpiগণনা করা যেতে পারে

int densityDpi = (int)(metrics.density * 160f);

Comments

এই পোস্টটি দু'বছর আগে থেকে প্রাপ্ত, তবে গুগলে এই অনুসন্ধানের জন্য এটিই প্রথম জিনিসটি এসেছে, সুতরাং যে কেউ এটি আবিষ্কার করে, আপনাকে আর 160 টি

— গুণতে হবে না

এখন আর কোন সংস্করণ নেই?

— TacB0sS

লোকেরা ব্যবহার করতে পারে এমন সর্বশেষ API সংশোধনগুলির সাথে মেলে আমি উত্তরটি আপডেট করেছি।

— joshperry

দ্রষ্টব্য: পরিবর্তে আপনি এই আরও নতুন এপিআই চাইতে পারেন: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); এটি আনুষ্ঠানিকভাবে এপিআই 17 তে যুক্ত করা হয়েছিল, তবে আমি অবাক হয়ে গিয়েছিলাম যে এটি আমার চেষ্টা করা একটি 4.0 ডিভাইসেও সঠিকভাবে কাজ করেছে।

— বেনকসি

এছাড়াও রেসোর্সস () রয়েছে। getDisplayMetics ()।

— ঘনত্বডিপি

Answer 2

এটিও কাজ করে:

 getResources().getDisplayMetrics().density;

এটি আপনাকে দেবে:

0.75 - ldpi

1.0 - এমডিপিআই

1.5 - এইচডিপিআই

2.0 - এক্সএইচডিপিআই

3.0 - এক্সএক্সএইচডিপিআই

4.0 - এক্সএক্সএক্সএইচডিপি

রেফ: ঘনত্ব

রেফ 2

Comments

+1 এটি কাজ করে যখন আপনার কাছে সরাসরি অ্যাক্সেস না থাকে WindowManager(যেমন কোনও লোডারের অভ্যন্তরে)। এটিকে 160 দ্বারা গুন করুন

— মাইচা কে

এপিআই লেভেল 16 এক্সএক্সডিপিআই যোগ করেছে, যা এখানে 3.0 এ অনুবাদ করে।

— কিয়েড

এটি এর জন্য 1.3312501 দেবে tvdpi। এখানেtvdpi দেখুন আরও তথ্যের জন্য

— ডরি

নেক্সাস 7 এর রিপোর্ট 1.3, কেন বন্ধনীটি ভিতরে shouldোকানো উচিত?

— নীল

@ সেলবি, আপনার ফোন সম্ভবত উচ্চ মানের সংস্থান টানছে এবং স্কেল করছে যেহেতু আপনার ফোনটি দুটি সংজ্ঞায়িত ঘনত্বের মধ্যে অর্ধেক পথের প্রতিবেদন করছে।

— সাকিবয়

Answer 3

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

switch(metrics.densityDpi) {
     case DisplayMetrics.DENSITY_LOW:
         break;

     case DisplayMetrics.DENSITY_MEDIUM:
         break;

     case DisplayMetrics.DENSITY_HIGH:
         break;
}

এটি এপিআই স্তরের 4 এবং উচ্চতর ক্ষেত্রে কাজ করবে।

Comments

আপনি নেক্সাস like এর মতো ডিভাইসগুলি কীভাবে হ্যান্ডেন্স করবেন যা ঘনত্বের ডিপিআইকে 213 হিসাবে প্রতিবেদন করে?

— নীল

ঘনত্ব মানের মধ্যে যদি 'অন্য হাত চেক আছে মত, যদি (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)

— মিটুল Nakum

অথবা যদি (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} অন্যথায় যদি (metrics.densityDpi <DisplayMetrics DENSITY_MEDIUM।) {} .....

— মিটুল Nakum

নীল, 213 কে টিভি ডিপিআই বলা হয়, সেই DENSITY_TV এর জন্য একটি নামযুক্ত ডিসপ্লে মেট্রিক্স ঘনত্ব রয়েছে।

— অ্যান্ড্রু এস

Answer 4

স্থির সহায়ক পদ্ধতি হিসাবে ব্লুন্ডেলের উত্তর:

private static String getDensityName(Context context) {
    float density = context.getResources().getDisplayMetrics().density;
    if (density >= 4.0) {
        return "xxxhdpi";
    }
    if (density >= 3.0) {
        return "xxhdpi";
    }
    if (density >= 2.0) {
        return "xhdpi";
    }
    if (density >= 1.5) {
        return "hdpi";
    }
    if (density >= 1.0) {
        return "mdpi";
    }
    return "ldpi";
}

Comments

টিভিপিপি ঘনত্ব সম্পর্কে কি আমি অনুমান করি এটি 1.33

— অনুপ

@ আনুপস গোল্ডেন এটি সত্যই আদর্শ নয়, তাই আপনি চাইলে এটি যোগ করতে পারেন, তবে উত্তরটি এতে অন্তর্ভুক্ত করা উচিত বলে আমি মনে করি না। অ্যান্ড্রয়েড ডক্স থেকে: "এটিকে একটি" প্রাথমিক "ঘনত্ব গোষ্ঠী হিসাবে বিবেচনা করা হয় না It এটি বেশিরভাগ টেলিভিশনগুলির জন্য তৈরি এবং বেশিরভাগ অ্যাপ্লিকেশানের এটির প্রয়োজন হয় না।

— কিওয়ার্টজগুয়ে

তবে নেক্সাস 7 ডিভাইসটি টিভিডিপিআই ডেনসিটি গ্রুপের অন্তর্গত।

— অনূপ

আমি জানি এটি কিছুটা পুরানো তবে কেবল যোগ করার জন্য; MDPI একটি নেক্সাস 7 এ বেশিরভাগ জিনিসের জন্য কাজ করতে পারে তবে আমি এখন যেমন চেষ্টা করছি, এমডিপিআই হিসাবে নেমে আসা চিত্রগুলি যথেষ্ট বড় নয়। আমাকে টিভিডিআইআই সংজ্ঞায়িত করতে হবে এবং তারপরে আমার সার্ভার থেকে একটি বৃহত্তর চিত্রের আকার চাইব। এটি খুব বেশি ব্যবহৃত হতে পারে না তবে এর অর্থ এই নয় যে এমডিপিআই সমস্ত জিনিস গ্রহণ করবে।

— RED_

আরে @ অ্যান্ড্রু এস, এলিস ব্যবহারের ফলে কোডের কার্যক্ষমতা কোনও পরিবর্তন হয় না কারণ প্রত্যেকটি যদি তাত্ক্ষণিকভাবে ফিরে আসে। ব্রেসগুলি অপসারণ করা কেবল শৈলীর প্রশ্ন এবং কোড বজায় রাখার সময় আইএমএইচও আরও ত্রুটি প্রবণ করে তোলে।

— কিওয়ার্টজগুয়ে

Answer 5

এটা চেষ্টা কর:

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

Comments

আমি এটি অনেক বেশি পছন্দ করি কারণ এটি কার্যকলাপের চেয়ে প্রসঙ্গে নির্ভর করে।

— গ্রেগ 7gkb

সম্মত, আমি এটিকে Viewআরও সহজেই ব্যবহার করতে পারি (এটি যেখানে আমার এটি প্রয়োজন!)

— অ্যান্ড্রু ওয়াইল্ড

Answer 6

ডিপিআই পেতে:

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

// will either be DENSITY_LOW, DENSITY_MEDIUM or DENSITY_HIGH
int dpiClassification = dm.densityDpi;

// these will return the actual dpi horizontally and vertically
float xDpi = dm.xdpi;
float yDpi = dm.ydpi;

Comments

dm.densityDpi হয় DENSITY_LOW বা DENSITY_MEDIUM বা DENSITY_HIGH ফেরত দেয়। এক্সএইচডিপিআইয়ের কী হবে? সেখানে কি কোনও DENSITY_XHIGH বা আছে?

— ইউজিন চুমাক

হ্যাঁ, এখানে রয়েছে: developer.android.com/references/android/util/…

— কাবা

Answer 7

এখানে ঘনত্বের ধ্রুবকগুলি, উত্স :

মানক ঘনত্ব ছাড়াও 5 টি অন্তর্বর্তী রয়েছে। এই সত্যটি বিবেচনায় নিলে, নিম্নলিখিত কোডটি একটি সম্পূর্ণ কার্যকারী উদাহরণ হবে:

float density = getResources().getDisplayMetrics().density;

if (density == 0.75f)
{
    // LDPI
}
else if (density >= 1.0f && density < 1.5f)
{
    // MDPI
}
else if (density == 1.5f)
{
    // HDPI
}
else if (density > 1.5f && density <= 2.0f)
{
    // XHDPI
}
else if (density > 2.0f && density <= 3.0f)
{
    // XXHDPI
}
else
{
    // XXXHDPI 
}

বিকল্পভাবে, আপনি ব্যবহার করে ঘনত্ব স্থিরগুলি খুঁজে পেতে পারেন densityDpi:

int densityDpi = getResources().getDisplayMetrics().densityDpi;

switch (densityDpi)
{
    case DisplayMetrics.DENSITY_LOW:
        // LDPI
        break;

    case DisplayMetrics.DENSITY_MEDIUM:
        // MDPI
        break;

    case DisplayMetrics.DENSITY_TV:
    case DisplayMetrics.DENSITY_HIGH:
        // HDPI
        break;

    case DisplayMetrics.DENSITY_XHIGH:
    case DisplayMetrics.DENSITY_280:
        // XHDPI
        break;

    case DisplayMetrics.DENSITY_XXHIGH:
    case DisplayMetrics.DENSITY_360:
    case DisplayMetrics.DENSITY_400:
    case DisplayMetrics.DENSITY_420:
        // XXHDPI
        break;

    case DisplayMetrics.DENSITY_XXXHIGH:
    case DisplayMetrics.DENSITY_560:
        // XXXHDPI
        break;
}

Answer 8

নীচের উত্তরটি কিওয়ার্টজগুয়ের উত্তরের উপর ভিত্তি করে একটি ছোট উন্নতি।

double density = getResources().getDisplayMetrics().density;
if (density >= 4.0) {
   //"xxxhdpi";
}
else if (density >= 3.0 && density < 4.0) {
   //xxhdpi
}
else if (density >= 2.0) {
   //xhdpi
}
else if (density >= 1.5 && density < 2.0) {
   //hdpi
}
else if (density >= 1.0 && density < 1.5) {
   //mdpi
}

Comments

এই কোডটি কিছু এলেস, এবং এম্পারসন্ডস এবং শর্তাবলী এটি অনর্থক হওয়ার পরে কি করতে পারে।

— অ্যান্ড্রু এস

@ অ্যান্ড্রু, সংশোধন করার জন্য ধন্যবাদ। আমি সেই অনুযায়ী উত্তরটি সম্পাদনা করেছি।

— সান

@ স্যান আপনার যে কোনও শর্তে অ্যান্ড অ্যান্ড দরকার নেই, যতক্ষণ আপনি অবিচ্ছিন্নভাবে <> চেক করে নিলেন অন্যথায় যদি প্রথম শর্তটি বন্ধ হয়ে যায় তবে এটি সত্য that

— dbenson

এটি আমার নেক্সাস 5 এক্স (একটি ডিফল্ট গুগল ডিভাইস বিটিডব্লু) দিয়ে আমার জন্য সঠিক ফলাফল দেয় না। ডিভাইসের ঘনত্বটি xxhdpi, এবং দ্বিগুণ ঘনত্ব ফিরে এসেছে প্রায় ২.6 এর কাছাকাছি।

— টব্লিউগ

Answer 9

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

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int dpiClassification = dm.densityDpi;
float xDpi = dm.xdpi;
float yDpi = dm.ydpi;

densityDpi * 160 আপনাকে কোন ঘনত্ব ব্যবহার করা উচিত সেগুলি মান / পরামর্শ দেবে

0.75 - ldpi - 120 dpi
1.0 - mdpi - 160 dpi
1.5 - hdpi - 240 dpi
2.0 - xhdpi - 320 dpi
3.0 - xxhdpi - 480 dpi
4.0 - xxxhdpi - 640 dpi

আগের পোস্টগুলিতে নির্দিষ্ট হিসাবে

তবে dm.xdpiআপনাকে সর্বদা প্রদত্ত প্রদর্শনের সত্যিকারের ডিপিআই দেবে না : উদাহরণ:

Device: Sony ericsson xperia mini pro (SK17i)
Density: 1.0 (e.g. suggests you use 160dpi resources)
xdpi: 193.5238
Real device ppi is arround 193ppi


Device: samsung GT-I8160 (Samsung ace 2)
Density 1.5 (e.g. suggests you use 240dpi resources)
xdpi 160.42105
Real device ppi is arround 246ppi

সুতরাং সম্ভবত ডিসপ্লেটির আসল ডিপিআই হওয়া উচিত ঘনত্ব * এক্সডিপিআই .. তবে আমি নিশ্চিত না যে এটি করার সঠিক উপায় কিনা!

Comments

ঘনত্ব * এক্সডিপিআই ব্যবহার করে গুগল প্লেতে আমার সমস্ত অ্যাপ্লিকেশনগুলিতে গত 6 মাস ধরে এখন পর্যন্ত নিখুঁতভাবে কাজ করছে

— মেরেক হাল্মো

গুনের ঘনত্ব * এক্সডিপিআই যৌক্তিক নয়, যা আরও বেশি ঘনত্বের ডিভাইস রয়েছে - এখন এটি আরও স্পষ্ট করে জানিয়েছে - ঘনত্ব এবং এক্সডিপিআই উভয়ই বৃদ্ধি পায়, সুতরাং এগুলি বৃদ্ধি করা দ্বিগুণ গণনা হবে increase আমি বলব স্যামসুং এস 2 এটি বিক্রেতার দ্বারা একটি ত্রুটি ছিল। অ্যান্ড্রয়েড স্পেকটিসটি হল যে এক্সডিপি এবং ইডিপিআই হ'ল প্রকৃত পিক্সেল ঘনত্ব - কোনও কিছুর দ্বারা গুণ করবেন না।

— টুলমেকারস্টেভ

Answer 10

এটি আপনার ক্রিয়াকলাপে সহায়তা করবে ...

void printSecreenInfo(){

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

    Log.i(TAG, "density :" +  metrics.density);

    // density interms of dpi
    Log.i(TAG, "D density :" +  metrics.densityDpi);

    // horizontal pixel resolution
    Log.i(TAG, "width pix :" +  metrics.widthPixels);

     // actual horizontal dpi
    Log.i(TAG, "xdpi :" +  metrics.xdpi);

    // actual vertical dpi
    Log.i(TAG, "ydpi :" +  metrics.ydpi);

}

আউটপুট:

I/test( 1044): density :1.0

I/test( 1044): D density :160

I/test( 1044): width pix :800

I/test( 1044): xdpi :160.0

I/test( 1044): ydpi :160.42105

Answer 11

public static String getDensity(Context context) {
    String r;
    DisplayMetrics metrics = new DisplayMetrics();

    if (!(context instanceof Activity)) {
        r = "hdpi";
    } else {
        Activity activity = (Activity) context;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        if (metrics.densityDpi <= DisplayMetrics.DENSITY_LOW) {
            r = "ldpi";
        } else if (metrics.densityDpi <= DisplayMetrics.DENSITY_MEDIUM) {
            r = "mdpi";
        } else {
            r = "hdpi";
        }
    }

    return r;
}

Answer 12

আপনি যদি কোনও পরিষেবা থেকে ঘনত্ব পুনরুদ্ধার করতে চান তবে এটি এর মতো কাজ করে:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);

Comments

যখন আমার উইন্ডো ম্যানেজারটি ছিল না তখন এই একজন আমাকে সাহায্য করেছিল

— সিলেন্টসোডো

Answer 13

আপনার এই চেষ্টা করা উচিত। সবেমাত্র একটি পদ্ধতি যুক্ত করেছেন যা টোস্টটি খুঁজে পাবে এবং প্রদর্শন করবে। এটি কোন বিভাগে ডিভাইস পড়ে।

public static int differentDensityAndScreenSize(Context context) {
  int value = 20;
  String str = "";
  if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "small-ldpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "small-mdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "small-hdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "small-xhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "small-xxhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "small-xxxhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "small-tvdpi";
    value = 20;
    break;
   default:
    str = "small-unknown";
    value = 20;
    break;
   }

  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "normal-ldpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "normal-mdpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "normal-hdpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "normal-xhdpi";
    value = 90;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "normal-xxhdpi";
    value = 96;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "normal-xxxhdpi";
    value = 96;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "normal-tvdpi";
    value = 96;
    break;
   default:
    str = "normal-unknown";
    value = 82;
    break;
   }
  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "large-ldpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "large-mdpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "large-hdpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "large-xhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "large-xxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "large-xxxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "large-tvdpi";
    value = 125;
    break;
   default:
    str = "large-unknown";
    value = 78;
    break;
   }

  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "xlarge-ldpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "xlarge-mdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "xlarge-hdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "xlarge-xhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "xlarge-xxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "xlarge-xxxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "xlarge-tvdpi";
    value = 125;
    break;
   default:
    str = "xlarge-unknown";
    value = 125;
    break;
   }
  }
// The Toast will show the Device falls in Which Categories.
Toast.makeText(MainActivity.this, ""+str, Toast.LENGTH_SHORT).show();

  return value;
 }

http://www.androidwarriors.com/2016/01/how-to-find-different-devices-screen.html

Answer 14

এই কাজ করা উচিত.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480

Comments

ডিসপ্লেটির পিক্সেলের আকার ঘনত্ব নয়।

— জোশপুরি

এটি পিক্সেল নয় ঘনত্বের স্বাধীন পিক্সেল। এবং যে 320 টি আপনি দেখছেন তা 320 পিক্স নয় 320 ডিপ। Px আকারে হিসাব ভিন্ন এই দেখতে stackoverflow.com/questions/6840904/...

— Lukap

Answer 15

তবুও অন্য উত্তর:

/**
* @return "ldpi", "mdpi", "hdpi", "xhdpi", "xhdpi", "xxhdpi", "xxxhdpi", "tvdpi", or "unknown".
*/
public static String getDensityBucket(Resources resources) {
    switch (resources.getDisplayMetrics().densityDpi) {
        case DisplayMetrics.DENSITY_LOW:
            return "ldpi";
        case DisplayMetrics.DENSITY_MEDIUM:
            return "mdpi";
        case DisplayMetrics.DENSITY_HIGH:
            return "hdpi";
        case DisplayMetrics.DENSITY_XHIGH:
            return "xhdpi";
        case DisplayMetrics.DENSITY_XXHIGH:
            return "xxhdpi";
        case DisplayMetrics.DENSITY_XXXHIGH:
            return "xxxhdpi";
        case DisplayMetrics.DENSITY_TV:
            return "tvdpi";
        default:
            return "unknown";
    }
}

Answer 16

ঘনত্বটি ডিভাইস দ্বারা লোড করার আরেকটি উপায়:

valuesপ্রতিটি ঘনত্বের জন্য ফোল্ডার তৈরি করুন

• মানগুলি (ডিফল্ট এমডিপিআই)
• মান-hdpi
• মান-xhdpi
• মান-xxhdpi
• মান-xxxhdpi

তাদের নিজ নিজ একটি স্ট্রিং সংস্থান যুক্ত করুন strings.xml:

<string name="screen_density">MDPI</string>    <!-- ..\res\values\strings.xml -->
<string name="screen_density">HDPI</string>    <!-- ..\res\values-hdpi\strings.xml -->
<string name="screen_density">XHDPI</string>   <!-- ..\res\values-xhdpi\strings.xml -->
<string name="screen_density">XXHDPI</string>  <!-- ..\res\values-xxhdpi\strings.xml -->
<string name="screen_density">XXXHDPI</string> <!-- ..\res\values-xxxhdpi\strings.xml -->

তারপরে কেবল স্ট্রিংয়ের উত্স পান এবং আপনার ঘনত্বটি রয়েছে:

String screenDensity = getResources().getString(R.string.screen_density);

ঘনত্ব যদি এর চেয়ে বড় XXXHDPIহয় XXXHDPIতবে এটি ডিফল্ট হবে বা HDPIএটি ডিফল্ট হওয়ার চেয়ে কম হলেMDPI

আমি ছেড়ে দিয়েছি LDPI, কারণ আমার ব্যবহারের ক্ষেত্রে এটি প্রয়োজনীয় নয়।

Comments

আমি মনে করি এটি ঘনত্ব পাওয়ার সঠিক উপায়। কারণ আমি getResource ()। GetDisplayMetrics () ব্যবহার করি d

— ফ্যান্টাসি ফ্যাং

Answer 17

এটা চেষ্টা কর...

কোটলিনে

fun determineScreenDensityCode(): String {
      return when (resources.displayMetrics.densityDpi) {
         DisplayMetrics.DENSITY_LOW -> "ldpi"
         DisplayMetrics.DENSITY_MEDIUM -> "mdpi"
         DisplayMetrics.DENSITY_HIGH -> "hdpi"
         DisplayMetrics.DENSITY_XHIGH, DisplayMetrics.DENSITY_280 -> "xhdpi"
         DisplayMetrics.DENSITY_XXHIGH, DisplayMetrics.DENSITY_360, DisplayMetrics.DENSITY_400, DisplayMetrics.DENSITY_420 -> "xxhdpi"
         DisplayMetrics.DENSITY_XXXHIGH, DisplayMetrics.DENSITY_560 -> "xxxhdpi"
         else -> "Unknown code ${resources.displayMetrics.densityDpi}"
     }
}

আপনি কল করতে পারেন println("density: ${determineScreenDensityCode()}") এবং আউটপুট হবেSystem.out: density: xxxhdpi

Answer 18

আমি মডিউলগুলি থেকে ডিপিআই অ্যাক্সেস করতে নিম্নলিখিত কোডটি ব্যবহার করছি (কোনও প্রসঙ্গে কোনও বিষয়তে অ্যাক্সেসের প্রয়োজন নেই):

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2

Answer 19

অ্যান্ড্রয়েডে আপনি এর মতো স্ক্রিনের ঘনত্ব পেতে পারেন:

public static String getScreenDensity(Context context)
{
    String density;
    switch (context.getResources().getDisplayMetrics().densityDpi)
    {
        case DisplayMetrics.DENSITY_LOW:
            density = "LDPI";
            break;
        case DisplayMetrics.DENSITY_140:
            density = "LDPI - MDPI";
            break;
        case DisplayMetrics.DENSITY_MEDIUM:
            density = "MDPI";
            break;
        case DisplayMetrics.DENSITY_180:
        case DisplayMetrics.DENSITY_200:
        case DisplayMetrics.DENSITY_220:
            density = "MDPI - HDPI";
            break;
        case DisplayMetrics.DENSITY_HIGH:
            density = "HDPI";
            break;
        case DisplayMetrics.DENSITY_260:
        case DisplayMetrics.DENSITY_280:
        case DisplayMetrics.DENSITY_300:
            density = "HDPI - XHDPI";
            break;
        case DisplayMetrics.DENSITY_XHIGH:
            density = "XHDPI";
            break;
        case DisplayMetrics.DENSITY_340:
        case DisplayMetrics.DENSITY_360:
        case DisplayMetrics.DENSITY_400:
        case DisplayMetrics.DENSITY_420:
        case DisplayMetrics.DENSITY_440:
            density = "XHDPI - XXHDPI";
            break;
        case DisplayMetrics.DENSITY_XXHIGH:
            density = "XXHDPI";
            break;
        case DisplayMetrics.DENSITY_560:
        case DisplayMetrics.DENSITY_600:
            density = "XXHDPI - XXXHDPI";
            break;
        case DisplayMetrics.DENSITY_XXXHIGH:
            density = "XXXHDPI";
            break;
        case DisplayMetrics.DENSITY_TV:
            density = "TVDPI";
            break;
        default:
            density = "UNKNOWN";
            break;
    }

    return density;
}

এবং এই মত কোটলিনে:

fun getScreenDensity(context: Context): String {
    val density: String
    when (context.resources.displayMetrics.densityDpi) {
        DisplayMetrics.DENSITY_LOW -> density = "LDPI"
        DisplayMetrics.DENSITY_140 -> density = "LDPI - MDPI"
        DisplayMetrics.DENSITY_MEDIUM -> density = "MDPI"
        DisplayMetrics.DENSITY_180, DisplayMetrics.DENSITY_200, DisplayMetrics.DENSITY_220 -> density = "MDPI - HDPI"
        DisplayMetrics.DENSITY_HIGH -> density = "HDPI"
        DisplayMetrics.DENSITY_260, DisplayMetrics.DENSITY_280, DisplayMetrics.DENSITY_300 -> density = "HDPI - XHDPI"
        DisplayMetrics.DENSITY_XHIGH -> density = "XHDPI"
        DisplayMetrics.DENSITY_340, DisplayMetrics.DENSITY_360, DisplayMetrics.DENSITY_400, DisplayMetrics.DENSITY_420, DisplayMetrics.DENSITY_440 -> density =
            "XHDPI - XXHDPI"
        DisplayMetrics.DENSITY_XXHIGH -> density = "XXHDPI"
        DisplayMetrics.DENSITY_560, DisplayMetrics.DENSITY_600 -> density = "XXHDPI - XXXHDPI"
        DisplayMetrics.DENSITY_XXXHIGH -> density = "XXXHDPI"
        DisplayMetrics.DENSITY_TV -> density = "TVDPI"
        else -> density = "UNKNOWN"
    }

    return density
}

নতুন ঘনত্ব যুক্ত হয়েছে কিনা তা নিয়মিত পরীক্ষা করে দেখুন ।