欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Android屏幕适配详解

程序员文章站 2022-05-24 20:13:36
...

1.屏幕适配中的基本概念

1.1 测量单位

in：英寸inch，物理尺寸，1in =2.54厘米（cm）。4.2寸手机等等就是这个in，通常说的手机4.2寸，都是手机对角线4.2in。

dpi：这个知道英文名有助于理解意义，its english name is:  Dots Per Inch.每英寸的点数嘛，每英寸的像素个数。例如：320X480分辨率的手机，宽2in，高3in，那么每英寸像素点个数(dpi)是:320/2=160.使用正方形像素点横纵向计算结果一样，一般是计算对角线。

density：这个搅屎棍极具混淆作用，这货是屏幕密度，屏幕密度density和dpi的关系是density = dpi/160,协议规范。这个是对dpi的一个规范，160dpi就是密度为1的意思。

dp：主角闪亮登场，也就是dip，设备独立像素，device independent pixels的简写，android特有，在屏幕密度为1也就是dpi=160的屏幕，1dp = 1px。这是规范。

sp：和dp类似，用来设置字体，和dp不同的是它可以自动根据用户的字体大小偏好来缩放，比如说你字体用的sp，用户系统设置字体偏好是偏大，那么sp会相应放大字体，而如果你用dp，则不会放大。

px：pixel，像素，屏幕上的点，是数码设备最小的独立显示单位，px均是整数，分辨率480X800就是，像素点个数。

1.2 图片资源占用内存:

一个32位的图分辨率是1280*768，所占内存大小：（1280*768*(32/8))/(1024*1024) = 3.75MB    像素点数*一个像素点所占用的byte数，32位图表示一个像素占用32个bit位，也就是4byte。

一个bitmap，是分辨率是1024*1024，要是32位的大小就是32/8=4m。

1.3 drawable图片适配

android会根据屏幕尺寸自动选择相应资源文件进行渲染，sdk检测到你的手机dpi是160的话，优先去drawable-mdpi下找相应图片资源，找不到会区别的文件夹找，并根据density做相应缩放。比如dpi

=160的设备，wrap-content设置资源，在mdpi没找到图片，从xhdpi找到了，240X240px的图片，240会除以2乘以1得到120px

drawable-ldpi (dpi=120, density=0.75)

drawable-mdpi (dpi=160, density=1)

drawable-hdpi (dpi=240, density=1.5)

drawable-xhdpi (dpi=320, density=2)

drawable-xxhdpi (dpi=480, density=3)

Values也是一样，当然还有一点要注意：values和values-hdpi效果是一样的，drawable和drawable-hdpi效果也是一样的，所以一般我们都会在这两个文件夹中存放的值是一样的，如果两个都有的话，适配更好。不加任何标签的资源是各种分辨率情况下共用的。

1.4 单位之间的换算

dp与px换算公式：
pixs =dips * (densityDpi/160). 
dips=(pixs*160)/densityDpi

但是我们在代码里面进行转化的时候还需要有一个偏移值：0.5f

    private static final float scale = mContext.getResources().getDisplayMetrics().density;  
      
    private static final float scaledDensity = mContext.mContext.getResources().getDisplayMetrics().scaledDensity;  
      
    /** 
     * dp转成px 
     * @param dipValue 
     * @return 
     */  
    public static int dip2px(float dipValue) {  
        return (int) (dipValue * scale + 0.5f);  
    }  
      
    /** 
     * px转成dp 
     * @param pxValue 
     * @return 
     */  
    public static int px2dip(float pxValue) {  
        return (int) (pxValue / scale + 0.5f);  
    }  
      
    /** 
     * sp转成px 
     * @param spValue 
     * @param type 
     * @return 
     */  
    public static float sp2px(float spValue, int type) {  
        switch (type) {  
        case CHINESE:  
            return spValue * scaledDensity;  
        case NUMBER_OR_CHARACTER:  
            return spValue * scaledDensity * 10.0f / 18.0f;  
        default:  
            return spValue * scaledDensity;  
        }  
    }
我们看到，这里的scale是在这个类DisplayMetrics中定义的全局变量，其实这个值就是当前手机的density/160，scaleDensity是用来px和sp之间的转化和scale差不多。还有一点就是这里转化都会有一个偏移值处理。

上面看到了px和dp之间的关系以及转化，下面在来看一下使用场景吧，就是为什么我们会使用到他们之间的转化，我们在xml中一般定义大小都是使用dp为单位的，但是有时候我们需要在代码里面设置一些间距和位置：

下面的代码: 

android.view.ViewGroup.LayoutParams.height  
android.view.ViewGroup.LayoutParams.width
上面这两个属性的单位为像素,但是为了兼容多种分辨率的手机,我们需要最好使用dip,时候我们可以调用以下的代码进行转换. 

int heightPx= DisplayUtil.dip2px(this, 33);  
mTabHost.getTabWidget().getChildAt(i).getLayoutParams().height = heightPx;
当然我们有时候也会在代码中获取values文件夹中的demen.xml文件中的值，代码如下： 

float height = this.getResources().getDimension(R.dimen.height);  
txt.height = px2dip((int)height);//将height转化成px
知道他获取的就是dimens.xml文件中定义的dp值，所以这里还手动的进行了转化操作，但是发现显示的效果和我们预期不一样，然后就把值打印了一下看，尽然是两倍，就是通过getDimension方法获取到的值是dimen.xml文件中定义的值的两倍。

getDimension

getDimensionPixelOffset

getDimensionPixelSize

他们的功能都是不一样的：

通过一个例子来看看他们的区别：

dimen.xml:

<dimen name="activity_vertical_margin1">16dp</dimen>    
<dimen name="activity_vertical_margin2">16px</dimen>    
<dimen name="activity_vertical_margin3">16sp</dimen>
代码： 

float a1=getResources().getDimension(R.dimen.activity_vertical_margin1);    
int a2=getResources().getDimensionPixelOffset(R.dimen.activity_vertical_margin1);    
int a3=getResources().getDimensionPixelSize(R.dimen.activity_vertical_margin1);    
  
float b1=getResources().getDimension(R.dimen.activity_vertical_margin2);    
int b2=getResources().getDimensionPixelOffset(R.dimen.activity_vertical_margin2);    
int b3=getResources().getDimensionPixelSize(R.dimen.activity_vertical_margin3);    
  
float c1=getResources().getDimension(R.dimen.activity_vertical_margin3);    
int c2=getResources().getDimensionPixelOffset(R.dimen.activity_vertical_margin3);    
int c3=getResources().getDimensionPixelSize(R.dimen.activity_vertical_margin3);    
  
Log.i("test", "getDimension= "+a1+", getDimensionPixelOffset="+a2+",getDimensionPixelSize="+a3);    
Log.i("test", "getDimension= "+b1+", getDimensionPixelOffset="+b2+",getDimensionPixelSize="+b3);    
Log.i("test", "getDimension= "+c1+", getDimensionPixelOffset="+c2+",getDimensionPixelSize="+c3);
对于设备1(1280*720,160dpi,density=1.0):

打印结果：
Android屏幕适配详解
对于设备2(480*800,240dpi,density=1.5):

打印结果:

Android屏幕适配详解

可见getDimension和getDimensionPixelOffset的功能差不多,都是获取某个dimen的值,如果是dp或sp的单位,将其乘以density,如果是px,则不乘;两个函数的区别是一个返回float,一个返回int.
getDimensionPixelSize则不管写的是dp还是sp还是px,都会乘以denstiy.

所以我们在使用getDimension方法获取到的值的时候就不需要进行转化了。

2. 屏幕适配方案-----百分比方案

2.1 方案1-----多种分辨率的资源文件夹

其实我们的解决方案，就是在项目中针对你所需要适配的手机屏幕的分辨率各自建立一个文件夹,如下:

Android屏幕适配详解



然后我们根据一个基准，为基准的意思就是：

比如480*320的分辨率为基准

  • 高度为320，将任何分辨率的高度分为320份，取值为x1-x320
  • 宽度为480，将任何分辨率的宽度分为480份，取值为y1-y480
例如对于800*480的宽度480：

Android屏幕适配详解

可以看到x1 = 480 / 基准 = 480 / 320 = 1.5 ;

相对于设计图:

假设现在的UI的设计图是按照480*320设计的，且上面的宽和高的标识都是px的值，你可以直接将px转化为x[1-320]，y[1-480]，这样写出的布局基本就可以全分辨率适配了。

自动生成工具:

代码如下:

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

/**
 * Created by zhy on 15/5/3.
 */
public class GenerateValueFiles {

    private int baseW;
    private int baseH;

    private String dirStr = "./res";

    private final static String WTemplate = "<dimen name=\"x{0}\">{1}px</dimen>\n";
    private final static String HTemplate = "<dimen name=\"y{0}\">{1}px</dimen>\n";

    /**
     * {0}-HEIGHT
     */
    private final static String VALUE_TEMPLATE = "values-{0}x{1}";

    private static final String SUPPORT_DIMESION = "320,480;480,800;480,854;540,960;600,1024;720,1184;720,1196;720,1280;768,1024;800,1280;1080,1812;1080,1920;1440,2560;";

    private String supportStr = SUPPORT_DIMESION;

    public GenerateValueFiles(int baseX, int baseY, String supportStr) {
        this.baseW = baseX;
        this.baseH = baseY;

        if (!this.supportStr.contains(baseX + "," + baseY)) {
            this.supportStr += baseX + "," + baseY + ";";
        }

        this.supportStr += validateInput(supportStr);

        System.out.println(supportStr);

        File dir = new File(dirStr);
        if (!dir.exists()) {
            dir.mkdir();

        }
        System.out.println(dir.getAbsoluteFile());

    }

    /**
     * @param supportStr
     *            w,h_...w,h;
     * @return
     */
    private String validateInput(String supportStr) {
        StringBuffer sb = new StringBuffer();
        String[] vals = supportStr.split("_");
        int w = -1;
        int h = -1;
        String[] wh;
        for (String val : vals) {
            try {
                if (val == null || val.trim().length() == 0)
                    continue;

                wh = val.split(",");
                w = Integer.parseInt(wh[0]);
                h = Integer.parseInt(wh[1]);
            } catch (Exception e) {
                System.out.println("skip invalidate params : w,h = " + val);
                continue;
            }
            sb.append(w + "," + h + ";");
        }

        return sb.toString();
    }

    public void generate() {
        String[] vals = supportStr.split(";");
        for (String val : vals) {
            String[] wh = val.split(",");
            generateXmlFile(Integer.parseInt(wh[0]), Integer.parseInt(wh[1]));
        }

    }

    private void generateXmlFile(int w, int h) {

        StringBuffer sbForWidth = new StringBuffer();
        sbForWidth.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
        sbForWidth.append("<resources>");
        float cellw = w * 1.0f / baseW;

        System.out.println("width : " + w + "," + baseW + "," + cellw);
        for (int i = 1; i < baseW; i++) {
            sbForWidth.append(WTemplate.replace("{0}", i + "").replace("{1}",
                    change(cellw * i) + ""));
        }
        sbForWidth.append(WTemplate.replace("{0}", baseW + "").replace("{1}",
                w + ""));
        sbForWidth.append("</resources>");

        StringBuffer sbForHeight = new StringBuffer();
        sbForHeight.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
        sbForHeight.append("<resources>");
        float cellh = h *1.0f/ baseH;
        System.out.println("height : "+ h + "," + baseH + "," + cellh);
        for (int i = 1; i < baseH; i++) {
            sbForHeight.append(HTemplate.replace("{0}", i + "").replace("{1}",
                    change(cellh * i) + ""));
        }
        sbForHeight.append(HTemplate.replace("{0}", baseH + "").replace("{1}",
                h + ""));
        sbForHeight.append("</resources>");

        File fileDir = new File(dirStr + File.separator
                + VALUE_TEMPLATE.replace("{0}", h + "")//
                        .replace("{1}", w + ""));
        fileDir.mkdir();

        File layxFile = new File(fileDir.getAbsolutePath(), "lay_x.xml");
        File layyFile = new File(fileDir.getAbsolutePath(), "lay_y.xml");
        try {
            PrintWriter pw = new PrintWriter(new FileOutputStream(layxFile));
            pw.print(sbForWidth.toString());
            pw.close();
            pw = new PrintWriter(new FileOutputStream(layyFile));
            pw.print(sbForHeight.toString());
            pw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static float change(float a) {
        int temp = (int) (a * 100);
        return temp / 100f;
    }

    public static void main(String[] args) {
        int baseW = 320;
        int baseH = 400;
        String addition = "";
        try {
            if (args.length >= 3) {
                baseW = Integer.parseInt(args[0]);
                baseH = Integer.parseInt(args[1]);
                addition = args[2];
            } else if (args.length >= 2) {
                baseW = Integer.parseInt(args[0]);
                baseH = Integer.parseInt(args[1]);
            } else if (args.length >= 1) {
                addition = args[0];
            }
        } catch (NumberFormatException e) {

            System.err
                    .println("right input params : java -jar xxx.jar width height w,h_w,h_..._w,h;");
            e.printStackTrace();
            System.exit(-1);
        }

        new GenerateValueFiles(baseW, baseH, addition).generate();
    }

}
2.2 方案2：动态通过代码设置标注

以一张设计图为基准，例如：UI的设计图是按照480*320设计的，且上面的宽和高的标识都是px的值。根据动态获取的手机屏幕尺寸算出对应的标准值，代码动态设置。

 targetPx/targetWeight = desginePx/480;



相关标签： 屏幕适配

上一篇： Android 屏幕适配方案

下一篇： 网站优化中需要注意的哪些非一般的链接

推荐阅读