工作内容：内容摘自
1.明白密度单位与像素之间的换算
2.使用wrap_content,match_parent,layout_weight来适应屏幕【可在GitHub搜索autolayout来使用，效果还是不错的】
3.使用限定符来设置不同屏幕显示不同布局
4.获取当前的布局（给出对应的响应）
5.使用自动拉伸位图
6.获取屏幕宽高动态设置
7.px与dp转换
学习分享：
一、首先明白密度单位dpi/dp与px的关系

dpi是屏幕像素密度，假如一英寸里面有160个像素，这个屏幕的像素密度就是160dpi，那么在这种情况下，dp和px如何换算呢？在Android中，规定以160dpi为基准，1dip=1px，如果密度是320dpi，则1dip=2px，以此类推。

2.图标文件夹的密度和显示

五种主流的像素密度（mdpi、hdpi、xhdpi、xxhdpi 和 xxxhdpi ）应按照 2:3:4:6:8 的比例进行缩放。例如，一个启动图标的尺寸为48x48 dp，这表示在 MDPI 的屏幕上其实际尺寸应为 48x48 px，在 HDPI 的屏幕上其实际大小是 MDPI 的 1.5 倍 (72x72 px)，在 XDPI 的屏幕上其实际大小是 MDPI 的 2 倍 (96x96 px)，依此类推。

二、支持各种屏幕尺寸

“wrap_content” “match_parent” android:layout_weight

要确保布局的灵活性并适应各种尺寸的屏幕，应使用 “wrap_content” 和 “match_parent” 控制某些视图组件的宽度和高度。使用 “wrap_content”，系统就会将视图的宽度或高度设置成所需的最小尺寸以适应视图中的内容，而 “match_parent”（在低于 API 级别 8 的级别中称为 “fill_parent”）则会展开组件以匹配其父视图的尺寸。

如果使用 “wrap_content” 和 “match_parent” 尺寸值而不是硬编码的尺寸，视图就会相应地仅使用自身所需的空间或展


开以填满可用空间。此方法可让布局正确适应各种屏幕尺寸和屏幕方向。

weight是线性布局的一个独特的属性，我们可以使用这个属性来按照比例对界面进行分配，完成一些特殊的需求。(宽度为0dp的按钮，再分别设置weight)

android:layout_weight的真实含义是:如果View设置了该属性并且有效，那么该 View的宽度等于原有宽度(android:layout_width)加上剩余空间的占比。


三、使用限定符

在版本低于 3.2 的 Android 设备上，开发人员遇到的问题之一是“较大”屏幕的尺寸范围，该问题会影响戴尔 Streak、早期的 Galaxy Tab 以及大部分 7 英寸平板电脑。即使这些设备的屏幕属于“较大”的尺寸，但很多应用可能会针对此类别中

的各种设备（例如 5 英寸和 7 英寸的设备）显示不同的布局。这就是 Android 3.2 版在引入其他限定符的同时引入“最小宽度”限定符的原因。

最小宽度限定符可让您通过指定某个最小宽度（以 dp 为单位）来定位屏幕。例如，标准 7 英寸平板电脑的最小宽度为 600dp，因此如果您要在此类屏幕上的用户界面中使用双面板（但在较小的屏幕上只显示列表），您可以使用上文中所述的单面板和双面板这两种布局，但您应使用 sw600dp 指明双面板布局仅适用于最小宽度为 600 dp 的屏幕，而不是使用 large 尺寸限定符。

列如：

res/layout/main.xml: 单面板布局

res/layout-large: 多面板布局

四、确定当前布局（给出相应的响应）

由于每种布局的实施都会稍有不同，因此我们需要先确定当前向用户显示的布局。例如，我们可以先了解用户所处的是“单面

板”模式还是“双面板”模式。要做到这一点，可以通过查询指定视图是否存在以及是否已显示出来。

五、使用自动拉伸位图

右键点击在drawable目录下（Android Studio）的图片，选择“Create 9-Patch file”进入位图编辑区
支持各种屏幕尺寸通常意味着您的图片资源还必须能适应各种尺寸。例如，无论要应用到什么形状的按钮上，按钮背景都必须能适应。
如果在可以更改尺寸的组件上使用了简单的图片，您很快就会发现显示效果多少有些不太理想，因为系统会在运行时平均地拉伸或收缩您的图片。解决方法为使用自动拉伸位图，这是一种格式特殊的 PNG 文件，其中会指明可以拉伸以及不可以拉伸的区域。
.9的制作，实际上就是在原图片上添加1px的边界，然后按照我们的需求，把对应的位置设置成黑色线，系统就会根据我们的

六、实际需求进行拉伸。

动态设置

有一些情况下，我们需要动态的设置控件大小或者是位置，比如说popwindow的显示位置和偏移量等，这个时候我们可以动态

的获取当前的屏幕属性，然后设置合适的数值
<span style="font-size:14px;">public class ScreenSizeUtil {
    public static int getScreenWidth(Activity activity) {  
        return activity.getWindowManager().getDefaultDisplay().getWidth();  //获取屏幕宽度
    }  
    public static int getScreenHeight(Activity activity) {  
        return activity.getWindowManager().getDefaultDisplay().getHeight();  //获取屏幕高度
    }  
}  </span>
其他获取屏幕宽高的方法：

//方法一：推荐
DisplayMetrics dm = [Context]getResources().getDisplayMetrics();
int screenWidth = dm.widthPixels; //像素值宽度[可用宽度]
int screenHeight = dm.heightPixels;//像素值高度

//方法二：已过时  像素值
WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
int width = wm.getDefaultDisplay().getWidth();
int height = wm.getDefaultDisplay().getHeight();
 
WindowManager wm = this.getWindowManager();
int width = wm.getDefaultDisplay().getWidth();
int height = wm.getDefaultDisplay().getHeight();

//方法三：像素值
WindowManager manager = this.getWindowManager();
DisplayMetrics outMetrics = new DisplayMetrics();
manager.getDefaultDisplay().getMetrics(outMetrics);
int width2 = outMetrics.widthPixels;
int height2 = outMetrics.heightPixels;
//方法四：像素值
Resources resources = this.getResources();
DisplayMetrics dm = resources.getDisplayMetrics();
float density1 = dm.density;
int width3 = dm.widthPixels;
int height3 = dm.heightPixels;
七、px与dp转换
import android.content.Context;  
  
public class DensityUtil {  
  
    /** 
     * 根据手机的分辨率从 dp 的单位 转成为 px(像素) 
     */  
    public static int dip2px(Context context, float dpValue) {  
        final float scale = context.getResources().getDisplayMetrics().density;  
        return (int) (dpValue * scale + 0.5f);  
    }  
  
    /** 
     * 根据手机的分辨率从 px(像素) 的单位 转成为 dp 
     */  
    public static int px2dip(Context context, float pxValue) {  
        final float scale = context.getResources().getDisplayMetrics().density;  
        return (int) (pxValue / scale + 0.5f);  
    }  
}  

一、 前言
android 4.4（sdk 19）之后，获取屏幕高度需要考虑底部导航栏等decor。网上很多方案是没有考虑这一点的，因此获取到的屏幕高度小于实际高度，误导开发者。

二、 错误方案
列举几种常见的获取出来高度可能小于实际高度的方案：



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




Display display = getWindowManager().getDefaultDisplay();
int screenWidth  = display.getWidth();
int screenHeight = display.getHeight();




WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
int screenWidth = wm.getDefaultDisplay().getWidth();
int screenHeight = wm.getDefaultDisplay().getHeight();




DisplayMetrics outMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(outMetrics);
int screenWidth = outMetrics.widthPixels;
int screenHeight = outMetrics.heightPixels;


三、 正确方案
以下是供参考的获取完整高度的方案：



WindowManager windowManager = (WindowManager) getApplication().getSystemService(Context.WINDOW_SERVICE);
Display display = windowManager.getDefaultDisplay();
Point outPoint = new Point();
if (Build.VERSION.SDK_INT >= 19) {
	// 可能有虚拟按键的情况
	display.getRealSize(outPoint);
} else {
	// 不可能有虚拟按键
	display.getSize(outPoint);
}
int mRealSizeWidth;//手机屏幕真实宽度
int mRealSizeHeight;//手机屏幕真实高度
mRealSizeHeight = outPoint.y;
mRealSizeWidth = outPoint.x;




DisplayMetrics metric = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getRealMetrics(metric);
int width = metric.widthPixels; // 宽度（PX）
int height = metric.heightPixels; // 高度（PX）


四、 源码解读
以上方法的区别在于"getRealSize"和"getRealMetrics"，查看源码：
1.getMetrics：
    /**
     * Gets display metrics that describe the size and density of this display.
     * The size returned by this method does not necessarily represent the
     * actual raw size (native resolution) of the display.
     * <p>
     * 1. The returned size may be adjusted to exclude certain system decor elements
     * that are always visible.
     * </p><p>
     * 2. It may be scaled to provide compatibility with older applications that
     * were originally designed for smaller displays.
     * </p><p>
     * 3. It can be different depending on the WindowManager to which the display belongs.
     * </p><p>
     * - If requested from non-Activity context (e.g. Application context via
     * {@code (WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE)})
     * metrics will report the size of the entire display based on current rotation and with
     * subtracted system decoration areas.
     * </p><p>
     * - If requested from activity (either using {@code getWindowManager()} or
     * {@code (WindowManager) getSystemService(Context.WINDOW_SERVICE)}) resulting metrics will
     * correspond to current app window metrics. In this case the size can be smaller than physical
     * size in multi-window mode.
     * </p>
     *
     * @param outMetrics A {@link DisplayMetrics} object to receive the metrics.
     */
    public void getMetrics(DisplayMetrics outMetrics) {
        synchronized (this) {
            updateDisplayInfoLocked();
            mDisplayInfo.getAppMetrics(outMetrics, getDisplayAdjustments());
        }
    }


包含decor时，返回的size可能不准确
老式机型下可能不准确
可能因WindowManager而改变

2.getRealSize：
    /**
     * Gets the real size of the display without subtracting any window decor or
     * applying any compatibility scale factors.
     * <p>
     * The size is adjusted based on the current rotation of the display.
     * </p><p>
     * The real size may be smaller than the physical size of the screen when the
     * window manager is emulating a smaller display (using adb shell wm size).
     * </p>
     *
     * @param outSize Set to the real size of the display.
     */
    public void getRealSize(Point outSize) {
        synchronized (this) {
            updateDisplayInfoLocked();
            outSize.x = mDisplayInfo.logicalWidth;
            outSize.y = mDisplayInfo.logicalHeight;
        }
    }


获取的size没有减去任何decor或者考虑缩放因素
使用"adb shell wm size"可以查看设备的物理尺寸

3.getRealMetrics：
    /**
     * Gets display metrics based on the real size of this display.
     * <p>
     * The size is adjusted based on the current rotation of the display.
     * </p><p>
     * The real size may be smaller than the physical size of the screen when the
     * window manager is emulating a smaller display (using adb shell wm size).
     * </p>
     *
     * @param outMetrics A {@link DisplayMetrics} object to receive the metrics.
     */
    public void getRealMetrics(DisplayMetrics outMetrics) {
        synchronized (this) {
            updateDisplayInfoLocked();
            mDisplayInfo.getLogicalMetrics(outMetrics,
                    CompatibilityInfo.DEFAULT_COMPATIBILITY_INFO, null);
        }
    }


基于getRealSize实现


五、 参考文献

Android 获取屏幕高和宽（不包含/包含虚拟按键），状态栏的高度
Android获取真正准确的分辨率，拒绝那些瞎扯乱混的文章

在做《格子色魔》开发的时候，发现自己的小米3跟模拟器的效果不同，查找了网上的资料，因为之前没有做过屏幕适配，花了一点功夫终于明白了。
首先是dip的计算，不同分辨率的手机，可能存在相同的dip
以我的小米3为例，手机1920x1280分辨率，屏幕为5英寸（对角线距离），所以我们通过勾股定理算出对角线像素，再除以5英寸，可以算出dpi为441dp
又按照比例1920:1280=3:2，可以算出dpi的长为370dp,宽为245dp



而我看来一下，发现模拟器为480*800px,240dp，长宽比为5:3
所以dpi的长为206dp，宽为123.5dp

也就是说两种相差220dp
我创建了一个layout-sw400dp的文件夹来存储布局文件，发现手机和模拟器，都只加载了原本layout下的布局文件
而我再创建一个layout-sw341dp，就发现手机将加载layout-sw341dp，而模拟器加载原本layout下的布局文件


可见android在加载布局文件时，是选择与自己dip最相近的布局文件加载的

 // 通过WindowManager获取
        DisplayMetrics dm = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(dm);
        System.out.println("width-display :" + dm.widthPixels);
        System.out.println("heigth-display :" + dm.heightPixels);

// 通过Resources获取
        DisplayMetrics dm2 = getResources().getDisplayMetrics();
        System.out.println("width-display :" + dm2.widthPixels);
        System.out.println("heigth-display :" + dm2.heightPixels);

// 获取屏幕的默认分辨率
        Display display = getWindowManager().getDefaultDisplay();
        System.out.println("width-display :" + display.getWidth());
        System.out.println("heigth-display :" + display.getHeight());


以上为获取屏幕宽高分辨率的三种方法

安卓6.0的NEXUS 6手机使用以上方法取得准确的宽度分辨率，但是高度分辨率并不准确(与状态栏和主题有关，某些情况下准确)，如何获取完全准确的宽、高分辨率请参考下文；在安卓4.2系统的某手机中，使用方法一得到了正确的屏幕尺寸值，而使用方法二和三得到的值全部为零。原因不祥。其中方法三中的display.getWidth()和display.getHeight()已被弃用。


DisplayMetrics dm = new DisplayMetrics();

getWindowManager().getDefaultDisplay().getMetrics(dm);

//display = getWindowManager().getDefaultDisplay();

//display.getMetrics(dm)（把屏幕尺寸信息赋值给DisplayMetrics dm）;
width = dm.widthPixels;
height = dm.heightPixels;
xdpi = dm.xdpi;
ydpi = dm.ydpi;
density = dm.densityDpi;
fdensity = dm.density;




查询log，得到各值如下：

D/Lichking(22643): -----------widthpixels---540

D/Lichking(22643): -----------heightpixels---960

D/Lichking(22643): -----------xdpi---244.92857

D/Lichking(22643): -----------ydpi---246.30302

D/Lichking(22643): -----------density---240
D/Lichking(22643): -----------fdensity---1.5


另提一点，我们通常所指的屏幕上的int尺寸是像素单位，如需在java代码中使用dp设定宽高请参考以下两个方法。
//pixel = dip*density;  
private int convertDpToPixel(int dp) {  
    DisplayMetrics displayMetrics = mContext.getResources().getDisplayMetrics();  
    return (int)(dp*displayMetrics.density);  
}  
  
private int convertPixelToDp(int pixel) {  
    DisplayMetrics displayMetrics = mContext.getResources().getDisplayMetrics();  
    return (int)(pixel/displayMetrics.density);  
} 


由于根据以上方法获取屏幕尺寸会有部分情况因为状态栏或其他缘故获取不到正确的分辨率，所以获取准确的分辨率可用以下方式获得：
private void getDisplayInfomation() {  
    Point point = new Point();  
    getWindowManager().getDefaultDisplay().getSize(point);  
    Log.d(TAG,"the screen size is "+point.toString());  
    //获取正确尺寸 （此方法要求最低api为17，即安卓4.2，4.2之前获取请参看以下获取屏幕尺寸的方法）
    getWindowManager().getDefaultDisplay().getRealSize(point);  
    Log.d(TAG,"the screen real size is "+point.toString());  
} 





获取屏幕尺寸的方法如下：


    private static double mInch = 0;  
    /** 
     * 获取屏幕尺寸 
     * @param context 
     * @return 
     */  
    public static double getScreenInch(Activity context) {  
        if (mInch != 0.0d) {  
            return mInch;  
        }  
      
        try {  
            int realWidth = 0, realHeight = 0;  
            Display display = context.getWindowManager().getDefaultDisplay();  
            DisplayMetrics metrics = new DisplayMetrics();  
            display.getMetrics(metrics);  
            if (android.os.Build.VERSION.SDK_INT >= 17) {  
                Point size = new Point();  
                display.getRealSize(size);  
                realWidth = size.x;  
                realHeight = size.y;  
            } else if (android.os.Build.VERSION.SDK_INT < 17  
                    && android.os.Build.VERSION.SDK_INT >= 14) {  
                Method mGetRawH = Display.class.getMethod("getRawHeight");  
                Method mGetRawW = Display.class.getMethod("getRawWidth");  
                realWidth = (Integer) mGetRawW.invoke(display);  
                realHeight = (Integer) mGetRawH.invoke(display);  
            } else {  
                realWidth = metrics.widthPixels;  
                realHeight = metrics.heightPixels;  
            }  
      
            mInch =formatDouble(Math.sqrt((realWidth/metrics.xdpi) * (realWidth /metrics.xdpi) + (realHeight/metrics.ydpi) * (realHeight / metrics.ydpi)),1);  
      
      
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
      
        return mInch;  
    }  
    /** 
     * Double类型保留指定位数的小数，返回double类型（四舍五入） 
     * newScale 为指定的位数 
     */  
    private static double formatDouble(double d,int newScale) {  
        BigDecimal bd = new BigDecimal(d);  
        return bd.setScale(newScale, BigDecimal.ROUND_HALF_UP).doubleValue();  
    }