android - without - screen mirroring mobile phones list




मैं एंड्रॉइड में स्क्रीनसाइज प्रोग्रामेटिक रूप से कैसे प्राप्त करूं? (8)

एंड्रॉइड स्क्रीन आकार को सामान्य बड़े एक्सलार्ज इत्यादि के रूप में परिभाषित करता है।

यह स्वचालित फ़ोल्डर्स में स्थिर संसाधनों के बीच स्वचालित रूप से चुनता है। मुझे अपने जावा कोड में वर्तमान डिवाइस के बारे में इस डेटा की आवश्यकता है। डिस्प्लेमैट्रिक्स केवल वर्तमान डिवाइस घनत्व के बारे में जानकारी देता है। स्क्रीन आकार के बारे में कुछ भी उपलब्ध नहीं है।

मुझे here grep कोड में स्क्रीनसाइज enum मिला था हालांकि यह 4.0 एसडीके के लिए मेरे लिए उपलब्ध नहीं प्रतीत होता है। क्या इस जानकारी को पाने का कोई तरीका है?


आप इसे आजमा सकते हैं, यह उदाहरण काम कर रहा है

DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int ht = displaymetrics.heightPixels;
int wt = displaymetrics.widthPixels;

if ((getResources().getConfiguration().screenLayout &     Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
Toast.makeText(this, "Large screen", Toast.LENGTH_LONG).show();}

  else if ((getResources().getConfiguration().screenLayout &  Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
Toast.makeText(this, "Normal sized screen", Toast.LENGTH_LONG)
        .show();

  } else if ((getResources().getConfiguration().screenLayout &        Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
Toast.makeText(this, "Small sized screen", Toast.LENGTH_LONG)
        .show();
 } else {
Toast.makeText(this,
        "Screen size is neither large, normal or small",
        Toast.LENGTH_LONG).show();
 }

 // Determine density
 DisplayMetrics metrics = new DisplayMetrics();
 getWindowManager().getDefaultDisplay().getMetrics(metrics);
 int density = metrics.densityDpi;

 if (density == DisplayMetrics.DENSITY_HIGH) {
Toast.makeText(this,
        "DENSITY_HIGH... Density is " + String.valueOf(density),
        Toast.LENGTH_LONG).show();
 } else if (density == DisplayMetrics.DENSITY_MEDIUM) {
Toast.makeText(this,
        "DENSITY_MEDIUM... Density is " + String.valueOf(density),
        Toast.LENGTH_LONG).show();
 } else if (density == DisplayMetrics.DENSITY_LOW) {
Toast.makeText(this,
        "DENSITY_LOW... Density is " + String.valueOf(density),
        Toast.LENGTH_LONG).show();
 } else {
Toast.makeText(
        this,
        "Density is neither HIGH, MEDIUM OR LOW.  Density is "
                + String.valueOf(density), Toast.LENGTH_LONG)
        .show();
 }

 // These are deprecated
 Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE))
    .getDefaultDisplay();
 int  width = display.getWidth();
 int height = display.getHeight();

simon-

विभिन्न स्क्रीन आकारों में अलग-अलग पिक्सेल घनत्व होते हैं। आपके फोन पर 4 इंच का डिस्प्ले कम या ज्यादा पिक्सेल हो सकता है, फिर 26 इंच का टीवी कहें। अगर मैं सही ढंग से समझ रहा हूं तो वह यह पता लगाना चाहता है कि वर्तमान स्क्रीन किस आकार के समूह, छोटे, सामान्य, बड़े, और अतिरिक्त बड़े हैं। एकमात्र चीज जिसे मैं सोच सकता हूं वह है पिक्सेल घनत्व का पता लगाने और स्क्रीन के वास्तविक आकार को निर्धारित करने के लिए इसका उपयोग करें।


मुझे अपने कुछ ऐप्स के लिए इसकी आवश्यकता है और निम्न कोड समस्या का मेरा समाधान था। बस क्रिएट के अंदर कोड दिखा रहा है। स्क्रीन जानकारी वापस करने के लिए किसी भी डिवाइस पर चलाने के लिए यह स्टैंड स्टैंड अकेले ऐप है।

setContentView(R.layout.activity_main);
    txSize = (TextView) findViewById(R.id.tvSize);

    density = (TextView) findViewById(R.id.density);
    densityDpi = (TextView) findViewById(R.id.densityDpi);
    widthPixels = (TextView) findViewById(R.id.widthPixels);
    xdpi = (TextView) findViewById(R.id.xdpi);
    ydpi = (TextView) findViewById(R.id.ydpi);

    Configuration config = getResources().getConfiguration();

    if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
        Toast.makeText(this, "Large screen", Toast.LENGTH_LONG).show();
        txSize.setText("Large screen");
    } else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
        Toast.makeText(this, "Normal sized screen", Toast.LENGTH_LONG)
                .show();
        txSize.setText("Normal sized screen");
    } else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
        Toast.makeText(this, "Small sized screen", Toast.LENGTH_LONG)
                .show();
        txSize.setText("Small sized screen");
    } else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {
        Toast.makeText(this, "xLarge sized screen", Toast.LENGTH_LONG)
                .show();
        txSize.setText("Small sized screen");
    } else {
        Toast.makeText(this,
                "Screen size is neither large, normal or small",
                Toast.LENGTH_LONG).show();
        txSize.setText("Screen size is neither large, normal or small");
    }

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

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

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

    Log.i(TAG, "width pix :" + metrics.widthPixels);
    widthPixels.setText("widthPixels :" + metrics.widthPixels);

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

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

और एक साधारण एक्सएमएल फ़ाइल

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >

<TextView
    android:id="@+id/tvSize"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/density"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/densityDpi"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/widthPixels"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/xdpi"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/ydpi"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    />


मुझे लगता है कि यह कोड का एक बहुत ही सरल आगे सरल टुकड़ा है!

public Map<String, Integer> deriveMetrics(Activity activity) {
    try {
        DisplayMetrics metrics = new DisplayMetrics();

        if (activity != null) {
            activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
        }

        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("screenWidth", Integer.valueOf(metrics.widthPixels));
        map.put("screenHeight", Integer.valueOf(metrics.heightPixels));
        map.put("screenDensity", Integer.valueOf(metrics.densityDpi));

        return map;
    } catch (Exception err) {
        ; // just use zero values
        return null;
    }
}

इस विधि को अब कहीं भी स्वतंत्र रूप से इस्तेमाल किया जा सकता है। जहां भी आप डिवाइस स्क्रीन के बारे में जानकारी प्राप्त करना चाहते हैं, वैसे ही इसे निम्नानुसार करें:

        Map<String, Integer> map = deriveMetrics2(this);
        map.get("screenWidth");
        map.get("screenHeight");
        map.get("screenDensity");

उम्मीद है कि यह किसी के लिए सहायक हो सकता है और इसका उपयोग करना आसान हो सकता है। अगर मुझे फिर से सुधार या सुधार करने की ज़रूरत है तो कृपया मुझे बताने में संकोच न करें! :-)

चीयर्स !!!


यदि आप गैर-गतिविधि यानी फ्रैगमेंट, एडाप्टर, मॉडल क्लास या किसी अन्य जावा क्लास में हैं जो Activity विस्तारित नहीं करता है तो getResources() काम नहीं करेंगे। आप getActivity() को खंड में उपयोग कर सकते हैं या उस context का उपयोग कर सकते हैं जिसे आप संबंधित कक्षा में पास करते हैं।

mContext.getResources()

मैं एक वर्ग को उन शब्दों का उपयोग करने की सलाह दूंगा जिनके पास आम काम के लिए विधि / तरीके होंगे। इसके लिए लाभ यह है कि आप इस विधि को कॉल करने वाले ऐप में कहीं भी कोड की एकल पंक्ति के साथ वांछित परिणाम प्राप्त कर सकते हैं।


स्क्रीन का आकार निर्धारित करें:

int screenSize = getResources().getConfiguration().screenLayout &Configuration.SCREENLAYOUT_SIZE_MASK;
  switch(screenSize) {
      case Configuration.SCREENLAYOUT_SIZE_LARGE:
        Toast.makeText(this, "Large screen",Toast.LENGTH_LONG).show();
         break;
       case Configuration.SCREENLAYOUT_SIZE_NORMAL:
          Toast.makeText(this, "Normal screen",Toast.LENGTH_LONG).show();
           break;
       case Configuration.SCREENLAYOUT_SIZE_SMALL:
           Toast.makeText(this, "Small screen",Toast.LENGTH_LONG).show();
           break;
       default:
           Toast.makeText(this, "Screen size is neither large, normal or small" , Toast.LENGTH_LONG).show();

 }

घनत्व निर्धारित करें:

int density= getResources().getDisplayMetrics().densityDpi;
   switch(density)
  {
  case DisplayMetrics.DENSITY_LOW:
     Toast.makeText(context, "LDPI", Toast.LENGTH_SHORT).show();
      break;
  case DisplayMetrics.DENSITY_MEDIUM:
       Toast.makeText(context, "MDPI", Toast.LENGTH_SHORT).show();
      break;
  case DisplayMetrics.DENSITY_HIGH:
      Toast.makeText(context, "HDPI", Toast.LENGTH_SHORT).show();
      break;
  case DisplayMetrics.DENSITY_XHIGH:
       Toast.makeText(context, "XHDPI", Toast.LENGTH_SHORT).show();
      break;
  }

रेफरी के लिए: http://devl-android.blogspot.in/2013/10/wifi-connectivity-and-hotspot-in-android.html


DisplayMetrics displayMetrics = new DisplayMetrics();

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

int width = displayMetrics.widthPixels;

int height = displayMetrics.heightPixels;

private static String getScreenResolution(Context context)
{
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    display.getMetrics(metrics);
    int width = metrics.widthPixels;
    int height = metrics.heightPixels;

    return "{" + width + "," + height + "}";
}






android-screen