android屏幕等分,Android屏幕适配原则

适配模式分两种

1，不同屏幕相同高度

2，不同屏幕相同比例

我们采用第二种模式

等比适配原则

1，将常用屏幕宽高拿来。

2，针对所有的宽高，将宽度做一个默认等分，一般设计图是ios的，采用750分辨率的，所以用750等分。

3，尽量做到所有宽度的xhdpi和xxhdpi两种密度适配。

如1080宽度的屏幕，即，

values-xhdpi-1920*1080

values-xxhdpi-1920*1080

影响系统屏幕匹配的因素有：宽，高，密度

下面开始试验：

1，手机是模拟器，1080*1920 8 寸，带底部导航，拿到屏幕的参数是：1080*1824 density 2.0 xhdpi。

2，自定义单位屏幕750等分，高度100单位，即在1080屏上 高度144像素。

实验步骤：

1，1080*1824 = 144(仅像素，宽高都匹配，)

2，1080*1800 = 10(仅像素，宽匹配，高差24)

3，1080*1812 = 20(仅像素，宽匹配，高查12)

4，xhdpi-1800*1080=50(dpi匹配，高度相差24，宽度不差)

5，xhdpi-1812*1080=60(dpi匹配，高度相差12，宽度不差)

6，xhdpi-1824*1056=30(dpi匹配，高度不差，宽度相差24)

7，xhdpi-1824*1068=40(dpi匹配，高度不差，宽度相差12)

8，xhdpi=96(仅dpi匹配)

9，hdpi-1824*1080=90(像素宽高匹配，dpi低)

10，xxhdpi-1824*1080=100(像素宽高匹配，dpi高)

//7，xhdpi-1824*1080=144

实际=50

得出屏幕适配原则

1，密度优先级最高

2，密度匹配之后，如果有像素匹配，则选最接近的宽度/高度

实验一，仅像素适配

1，1080*1824

0，value 144

1，1080*1800(高小24)10

2，1080*1812(高小12)20

3，1080*1836(高大12)30

4，1080*1848(高大24)40

选中=20,1080*1212。

猜想高大12和小12，选择小12，

如果大10和小12，选择哪个？

将1836-》1035，1825，1824，发现结果都是20，20，30.也就是说。

在无dpi情况下，像素宽度匹配的时候，选择最接近的且低于屏幕的高度的值。

5，1056*1824(宽小24)50

6，1068*1824(宽小12)60

7，1092*1824(宽大12)70

8，1104*1824(宽大24)80

选中=60,1068*1824。

猜想宽大12和小12，选择小12，

如果打10和小12，选择哪个？

将1092-》1091，1081，1080，发现结果都是60，60，70，得出结论：

在无dpi情况下，像素高度匹配的时候，选择最接近的切低于屏幕的宽度的值。

9，1080*1812(高小12)40

10，1068*1824(宽小12)60

选中=60,1068*1824，得出结论：

在无dpi情况下，像素某一个匹配的时候，如果另一个低于屏幕的值相等，选择宽。

猜想如果另一个低于屏幕的值最接近屏幕，选择最接近的，如果一样选择宽。

将1812-》1822，发现结果为40，得出结论：

在无dpi情况下，像素某一个匹配的时候，另一个低于屏幕的值最接近屏幕，选择最接近的；如果另一个低于屏幕的值相等，选择宽。

9，1068*1812(宽高都小12)90

10，1068*1836(宽小12高大12)100

11，1092*1836(宽大12高小12)110

12，1092*1812(宽大12高大12)120

选中90，得出结论：

在无dpi情况下，宽高像素都不匹配的情况，选择小于屏幕像素的值。

猜想，选择小于屏幕的，任意一个最接近的值。

将1068*1836-1068*1822(宽小12，高小2) 结果为100，表示选中1068*1822。得出结论：

在无dpi情况下，宽高像素都不匹配的情况，选择小于屏幕像素的，且宽和高最解决屏幕的。

将1092*1836-》1067*1813(宽小13，高小11)，1068*1836-》1069*1811(宽小11，高小13)

结果110，即选中1067*1813，得出结论：

在无dpi情况下，像素都不匹配的情况，一个宽接近，一个高接近，高更接近的和宽更接近的值相等时，选择高更接近的。

实验二，dip+屏幕像素

创建文件代码工具类

```

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 static final int baseW = 750;

private static final int baseH = 1280;

private static final String dirStr = "D:/Demo/Test/app/src/main/res";

private final static String WTemplate = "{1}px\n";

private final static String HTemplate = "{1}px\n";

/**

* {0}-HEIGHT

*/

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

private static final String[] SUPPORT_DIMESION = {

"240,320",//l

"320,480",//m

"480,800",//h

"480,854",

"540,960",

"600,1024",

"640,960",

"720,1184",

"720,1196",

"720,1280",//xh

"720,1480",//sansumg s9

"752,1280",

"768,1024",

"768,1280",

"800,1280",

"1024,1920",

"1080,1812",

"1080,1920",//xxh

"1080,2160",//vivo z5x

"1080,2220",//sansumg s9

"1080,2248",//华为p20 xiaomi 8

"1080,2340",//vivo z5x

"1200,1920",

"1440,2560",//xxxh

"1440,2960",//sansumg s9

"1536,2048",

"1600,2560",

"2160,3840"//xxxh

};

public GenerateValueFiles() {

File dir = new File(dirStr);

if (!dir.exists()) {

dir.mkdir();

}

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

}

public void generate() {

for (String val : SUPPORT_DIMESION) {

String[] wh = val.split(",");

generateXmlFile(Integer.parseInt(wh[0]), Integer.parseInt(wh[0]), Integer.parseInt(wh[1]), baseW, WTemplate, "dimens.xml");

//            generateXmlFile(Integer.parseInt(wh[1]), Integer.parseInt(wh[0]),Integer.parseInt(wh[1]), baseH, HTemplate, "dimens_y.xml");

}

}

/**

* 尺寸px

*

* @param size

* @param dimens_x

* @param dimens_y

* @param baseW

* @param WTemplate

* @param fileName

*/

private void generateXmlFile(int size, int dimens_x, int dimens_y, int baseW, String WTemplate, String fileName) {

StringBuffer sbForWidth = new StringBuffer();

sbForWidth.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");

sbForWidth.append("\n");

float cellw = size * 1.0f / baseW;

System.out.println("width : " + size + "," + baseW + "," + cellw);

for (int i = 1; -i >= -100; i++) {

sbForWidth.append("    ")

.append(WTemplate.replace("{0}", "_" + (i)).replace("{1}",

change(-cellw * i) + ""));

}

//        sbForWidth.append("    ")

//                .append(WTemplate.replace("{0}", "_" + baseW + "").replace("{1}",

//                        -size + ""));

for (int i = 1; i <= 800; i++) {

sbForWidth.append("    ")

.append(WTemplate.replace("{0}", i + "").replace("{1}",

change(cellw * i) + ""));

}

//        sbForWidth.append("    ")

//                .append(WTemplate.replace("{0}", baseW + "").replace("{1}",

//                        size + ""));

sbForWidth.append("");

File fileDir = new File(dirStr + File.separator

+ VALUE_TEMPLATE.replace("{0}", dimens_y + "")//

.replace("{1}", dimens_x + ""));

if (!fileDir.exists()) {

fileDir.mkdir();

}

File layxFile = new File(fileDir.getAbsolutePath(), fileName);

try {

PrintWriter pw = new PrintWriter(new FileOutputStream(layxFile));

pw.print(sbForWidth.toString());

pw.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

}

}

public static float change(float a) {

int temp = (int) (a * 10);

return temp / 10f;

}

public static void main(String[] args) {

new GenerateValueFiles().generate();

}

}

```

这是我之前写过的关于屏幕适配原则逻辑的文章