重新认识 Android 图片适配

最新推荐文章于 2023-06-29 15:03:34 发布
最新推荐文章于 2023-06-29 15:03:34 发布
阅读量384 收藏 1
点赞数 2
分类专栏： Android 文章标签： 图片适配
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flueky/article/details/103318649
版权

文章目录

0. 前言

Android 图片适配，真的不是你想像的那样，至少在写这篇文章之前，我陷在一个很大很大的误区中。

1. 关于适配

所有关于适配的基本概念，这里不多介绍，资料有很多。下面只介绍点比较重要的部分。

等级密度比例
ldpi120dpi1dp=0.75px
mdpi160dpi1dp=1px
hdpi240dpi1dp=1.5px
xhdpi320dpi1dp=2px
xxhdpi480dpi1dp=3px
xxxhdpi640dpi1dp=4px

上面这张表介绍了 dpi 与 px 之间的关系。而多数手机厂商没有严格按照上述规范生产屏幕，才会有如今令人恶心的 Android 适配问题。

如：三星 C9，6英寸屏幕，分辨率 1920x1080 ，按照公式计算屏幕密度 367 dpi ，更接近 320dpi ，因此适配时，会取 xhdpi 目录下的数据。

但实际中，会取 xxhdpi 数据，因为实际屏幕密度是 420 dpi。（通过代码的方式获取）

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
Log.d(TAG, "onCreate: "+dm.density);
Log.d(TAG, "onCreate: "+dm.densityDpi);

2019-11-29 14:50:03.879 28034-28034/com.flueky.demo D/MainActivity: onCreate: 2.625

2019-11-29 14:50:03.879 28034-28034/com.flueky.demo D/MainActivity: onCreate: 420

2.625 是 420/160 的结果。表示在 C9 上，1dp=2.625 px ，411dp 约等于 1080px ，表示整个屏幕的宽度。

如：三星 S8，5.8英寸屏幕，分辨率 2960x1440 ，屏幕密度 568 dpi，接近 640 dpi ,因此适配时，会取 xxxhdpi 目录下数据。

但实际中，会取 xxhdpi 数据，因为实际屏幕密度是 560 dpi 。

2019-11-29 14:59:49.604 20793-20793/com.flueky.demo D/MainActivity: onCreate: 3.5

2019-11-29 14:59:49.604 20793-20793/com.flueky.demo D/MainActivity: onCreate: 560

在 S8 上 ，1dp=3.5px ，411dp 约等于 1440px ，表示整个屏幕的宽度。

很庆幸，这两台手机上的适配数据是一样的，高度会存在差异，但是通常都是滚动长页面，或者留白端页面不受太大影响。若恰好是满屏页面，则不适用。

今日头条的适配方案即是通过修改 density 的 值进行适配。不知道什么原因，他们在《今日头条》7.5 版本中未使用此适配方式。

2. 图片适配

言归正传，关于图片适配才是我们的主题。

秉着实践是检验真理的唯一标准这一原则，做了如下实验。三种尺寸的图片，放置在四个目录目录，用三种尺寸的 ImageView ，用三种方式加载图片，检查其内存使用的情况。

  1. 图片尺寸

    • large 1600x900 ，占用内存 1600x900x4/1024/1024 = 5.49m
    • middle 800x450 ，占用内存 800x450x4/1024/1024 = 1.37m
    • small 400x225 ，占用内存 400x225x4/1024/1024 = 0.34m

  2. 图片目录

    • asset
    • drawable hdpi
    • drawable xhdpi
    • drawable xxhdpi

  3. ImageView

    • wrap-content
    • 280dp
    • 160dp

  4. 引用方式

    • android:src
    • setImageResource
    • setImageBitmap

加载 asset 目录下的图片，只能使用 setImageBitmap 的方式。

第一组实验，使用 1 2 3 以及 setImageBitmap ，得出 3x4x3x1 = 36 条数据，如下表。

  • B 表示内存中图片的 bitmap 大小。
  • G 表示内存中 Graphics 占用的空间。
  • N 表示内存中 Native 占用的空间。
  • 序号 0 表示，未使用图片时的情况。
  • 实验基于屏幕密度 540dpi 的设备。
序号目录分辨率宽度BGN
0----1.8m7.8m
1asset1600x900wrap5.49m8.7m14.6m
2asset1600x900w2805.49m8.7m14.7m
3asset1600x900w1605.49m8.6m13.2m
4asset800x450wrap1.37m3.8m9.3m
5asset800x450w2801.37m3.8m9.2m
6asset800x450w1601.37m3.8m9.3m
7asset400x225wrap0.34m2.6m8.2m
8asset400x225w2800.34m2.6m8.2m
9asset400x225w1600.34m2.6m8.2m
10hdpi1600x900wrap27.8m37.1m37.3m
11hdpi1600x900w28027.8m37.1m31.7m
12hdpi1600x900w16027.8m31.7m36.9m
13hdpi800x450wrap6.95m9.7m14.9m
14hdpi800x450w2806.95m9.7m14.8m
15hdpi800x450w1606.95m9.7m15.3m
16hdpi400x225wrap1.73m4.1m9.9m
17hdpi400x225w2801.73m4m9.7m
18hdpi400x225w1601.73m4.1m10.1m
19xhdpi1600x900wrap15.6m18.9m24.9m
20xhdpi1600x900w28015.6m18.9m24.7m
21xhdpi1600x900w16015.6m18.9m24.7m
22xhdpi800x450wrap3.9m6.3m12.4m
23xhdpi800x450w2803.9m6.3m11.5m
24xhdpi800x450w1603.9m6.3m12.2m
25xhdpi400x225wrap0.97m3.2m9m
26xhdpi400x225w2800.97m3.2m8.8m
27xhdpi400x225w1600.97m3.2m9.1m
28xxhdpi1600x900wrap6.95m9.7m16.7m
29xxhdpi1600x900w2806.95m9.7m16m
30xxhdpi1600x900w1606.95m9.7m16m
31xxhdpi800x450wrap1.73m4.1m9.7m
32xxhdpi800x450w2801.73m4.1m9.7m
33xxhdpi800x450w1601.73m4.1m9.6m
34xxhdpi400x225wrap0.43m2.6m8.4m
35xxhdpi400x225w2800.43m2.6m8.4m
36xxhdpi400x225w1600.43m2.6m8.7m

结果分析：

  1. 使用的图片越大，越耗内存。实验数据：1/4/7。
  2. 图片内存与其显示大小无关。实验数据：1/2/3,4/5/6,7/8/9。误区1：图片显示区域越大，越耗内存。
  3. 加载 asset 目录的图片，图片占用内存等于实际大小，实验数据：1/2/3,4/5/6,7/8/9。计算方式：l x w x 4，长乘宽乘 4 （每个像素点占用 4 字节）。
  4. 加载 drawable 目录的图片，图片占用内存存在缩放。如：large 占用内存 5.49m , hdpi 对应 240 dpi 。因此图片实际占用内存 5.49 x (540/240)^2 = 27.79m 。误区2：5.49 x (540/240) = 12.35m。

关于 B/G/N 之间的关系还未研究透彻，如有了解还请告知。

第二组实验基于屏幕密度 360dpi 的设备，排除多数无用项。

序号目录分辨率宽度BGN
37----1.8m7.4m
38asset1600x900w1605.49m8.7m14.7m
39asset800x450w2801.37m3.8m9.3m
40asset400x225wrap0.34m2.6m8.3m
41hdpi1600x900wrap12.3m15.4m21.4m
41hdpi1600x900w28012.3m15.4m21.3m
42hdpi1600x900w16012.3m15.4m21.4m
43hdpi800x450w2803.08m5.9m11m
44hdpi400x225w1600.77m3m8.8m
45xhdpi1600x900wrap6.95m9.7m16m
46xhdpi1600x900w2806.95m9.7m16.1m
47xhdpi1600x900w1606.95m9.7m16.1m
48xhdpi800x450w2801.73m4.1m9.7m
49xhdpi400x225w1600.43m2.6m8.3m
50xxhdpi1600x900wrap3.08m5.9m12.3m
51xxhdpi1600x900w2803.08m5.9m12.4m
52xxhdpi1600x900w1603.08m5.9m12.2m
53xxhdpi800x450w2800.77m3m8.7m
54xxhdpi400x225w1600.19m2.4m8.1m

结果分析：

  1. 图片内存与屏幕密度无关。

第三组实验基于屏幕密度 540 dpi 的设备，使用 setImageResource 方式加载图片。

序号目录分辨率宽度BGN
55hdpi1600x900w1605.49m8.7m19m
56hdpi800x450wrap1.37m3.8m9.3m
57hdpi400x225w2800.34m2.6m8.2m
58xhdpi1600x900w2805.49m8.7m19.9m
59xhdpi800x450w1601.37m3.8m9.3m
60xhdpi400x225wrap0.34m2.6m8.6m
61xxhdpi1600x900wrap5.49m8.7m14.6m
62xxhdpi800x450w2801.37m3.9m9.6m
63xxhdpi400x225w1600.34m2.6m8.3m

结果分析：

  1. 使用 setImageResource 加载图片，没有对图片进行缩放。实验数据：55/58/61。误区3：使用不同屏幕密度下的图片存在缩放情况。

实验的最后发现，在布局用使用 android:src 引用图片时，图片内存也不缩放。因此，没有列出实验数据。

3. 源码分析

基于以上结果，通过分析源码，得以验证。

  1. asset 目录下图片占用内存是图片实际大小。
// 通过流的方式解析图片。
bitmap = BitmapFactory.decodeStream(getAssets().open("test.jpg"));

public static Bitmap decodeStream(InputStream is) {
    return decodeStream(is, null, null);
}
/**
 * 实际执行到下面的代码
 */
public static Bitmap decodeStream(@Nullable InputStream is, @Nullable Rect outPadding,
        @Nullable Options opts) {
    
    ......

    Bitmap bm = null;

    Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "decodeBitmap");
    try {
        if (is instanceof AssetManager.AssetInputStream) {
            final long asset = ((AssetManager.AssetInputStream) is).getNativeAsset();
            // 解析 asset 目录下的 文件，opts == null ,所以按照设备的 density 解析。
            bm = nativeDecodeAsset(asset, outPadding, opts);
        } else {
            // 解密普通的文件流
            bm = decodeStreamInternal(is, outPadding, opts);
        }

        if (bm == null && opts != null && opts.inBitmap != null) {
            throw new IllegalArgumentException("Problem decoding into existing bitmap");
        }
        // 更新 bitmap 的 density 
        setDensityFromOptions(bm, opts);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_GRAPHICS);
    }

    return bm;
}

private static void setDensityFromOptions(Bitmap outputBitmap, Options opts) {
    // opts==null，因此未做处理。
    if (outputBitmap == null || opts == null) return;

    ......
}
  1. drawable 目录下图片占用内存被缩放。
// 只有在使用下面的方式获取 bitmap 会缩放。
bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.test);

public static Bitmap decodeResource(Resources res, int id) {
    return decodeResource(res, id, null);
}
public static Bitmap decodeResource(Resources res, int id, Options opts) {
    validate(opts);
    Bitmap bm = null;
    InputStream is = null; 
    
    try {
        final TypedValue value = new TypedValue();
        // 根据 id 得到文件流，AssetInputStream
        is = res.openRawResource(id, value);
        // 根据流得到 bitmap
        bm = decodeResourceStream(res, value, is, null, opts);
    } catch (Exception e) {
    ......
    }
    return bm;
}
@Nullable
public static Bitmap decodeResourceStream(@Nullable Resources res, @Nullable TypedValue value,
        @Nullable InputStream is, @Nullable Rect pad, @Nullable Options opts) {
    validate(opts);
    if (opts == null) {
        // 生成 Option 
        opts = new Options();
    }
    // 以 设备 320dpi ,图片在 xxhdpi 为例
    if (opts.inDensity == 0 && value != null) {
        final int density = value.density; // density = 480
        if (density == TypedValue.DENSITY_DEFAULT) {
            opts.inDensity = DisplayMetrics.DENSITY_DEFAULT;
        } else if (density != TypedValue.DENSITY_NONE) {
            opts.inDensity = density;
        }
    }
    
    if (opts.inTargetDensity == 0 && res != null) {
        // res.getDisplayMetrics().densityDpi = 320
        opts.inTargetDensity = res.getDisplayMetrics().densityDpi;
    }
    
    return decodeStream(is, pad, opts);
}
@Nullable
public static Bitmap decodeStream(@Nullable InputStream is, @Nullable Rect outPadding,
        @Nullable Options opts) {
    
    ......

    Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "decodeBitmap");
    try {
        if (is instanceof AssetManager.AssetInputStream) {
            final long asset = ((AssetManager.AssetInputStream) is).getNativeAsset();
            // opts inDensity 480 ，inTargetDensity 320 ，因此需要缩放。
            bm = nativeDecodeAsset(asset, outPadding, opts);
        } else {
            bm = decodeStreamInternal(is, outPadding, opts);
        }

        if (bm == null && opts != null && opts.inBitmap != null) {
            throw new IllegalArgumentException("Problem decoding into existing bitmap");
        }
        // 根据 opts 设置图片的 density 
        setDensityFromOptions(bm, opts);
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_GRAPHICS);
    }

    return bm;
}
private static void setDensityFromOptions(Bitmap outputBitmap, Options opts) {
    if (outputBitmap == null || opts == null) return;

    final int density = opts.inDensity;
    if (density != 0) {
        // 先设置成 480
        outputBitmap.setDensity(density);
        final int targetDensity = opts.inTargetDensity;
        if (targetDensity == 0 || density == targetDensity || density == opts.inScreenDensity) {
            return;
        }

        byte[] np = outputBitmap.getNinePatchChunk();
        final boolean isNinePatch = np != null && NinePatch.isNinePatchChunk(np);
        // 由于支持缩放，再设置成 320 
        if (opts.inScaled || isNinePatch) {
            outputBitmap.setDensity(targetDensity);
        }
    } else if (opts.inBitmap != null) {
        // bitmap was reused, ensure density is reset
        outputBitmap.setDensity(Bitmap.getDefaultDensity());
    }
}
  1. 通过 setImageResource，或布局引用，图片不缩放。
// 布局引用时，在 ImageView 的构造函数中加载图片
public ImageView(Context context, @Nullable AttributeSet attrs, int defStyleAttr,
        int defStyleRes) {
    super(context, attrs, defStyleAttr, defStyleRes);
    ......
    final TypedArray a = context.obtainStyledAttributes(
            attrs, R.styleable.ImageView, defStyleAttr, defStyleRes);
    // 得到 Drawable 对象，如果使用 png 或 jpg 等图片，则是 BitmapDrawable 
    final Drawable d = a.getDrawable(R.styleable.ImageView_src);
    ......
}

// TypedArray 类
public Drawable getDrawable(@StyleableRes int index) {
    // 注意此处的 density 是 0
    return getDrawableForDensity(index, 0);
}

public Drawable getDrawableForDensity(@StyleableRes int index, int density) {
    if (mRecycled) {
        throw new RuntimeException("Cannot make calls to a recycled instance!");
    }

    final TypedValue value = mValue;
    if (getValueAt(index * STYLE_NUM_ENTRIES, value)) {
        ......
        // density = 0 ，执行下面代码
        return mResources.loadDrawable(value, value.resourceId, density, mTheme);
    }
    return null;
}
// ResourcesImpl 类
Drawable loadDrawable(@NonNull Resources wrapper, @NonNull TypedValue value, int id,
        int density, @Nullable Resources.Theme theme)
        throws NotFoundException {
    // useCache = true，后面的代码忽略
    final boolean useCache = density == 0 || value.density == mMetrics.densityDpi;
    ......
    try {
        ......

        // 读加载过的 BitmapDrawable
        if (!mPreloading && useCache) {
            final Drawable cachedDrawable = caches.getInstance(key, wrapper, theme);
            if (cachedDrawable != null) {
                cachedDrawable.setChangingConfigurations(value.changingConfigurations);
                return cachedDrawable;
            }
        }
        final Drawable.ConstantState cs;
        if (isColorDrawable) {
            cs = sPreloadedColorDrawables.get(key);
        } else {
            cs = sPreloadedDrawables[mConfiguration.getLayoutDirection()].get(key);
        }

        Drawable dr;
        boolean needsNewDrawableAfterCache = false;
        if (cs != null) {
            ......
        } else if (isColorDrawable) {
            dr = new ColorDrawable(value.data);
        } else {
            // 最终执行到此处加载图片
            dr = loadDrawableForCookie(wrapper, value, id, density);
        }
        ......
        return dr;
    } catch (Exception e) {
        ......
    }
}

private Drawable loadDrawableForCookie(@NonNull Resources wrapper, @NonNull TypedValue value,
            int id, int density) {
    ......
    final Drawable dr;
    Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, file);
    LookupStack stack = mLookupStack.get();
    try {
        // Perform a linear search to check if we have already referenced this resource before.
        if (stack.contains(id)) {
            throw new Exception("Recursive reference in drawable");
        }
        stack.push(id);
        try {
            // 处理使用 shape selector 等 使用 xml 生成的资源文件
            if (file.endsWith(".xml")) {
                final XmlResourceParser rp = loadXmlResourceParser(
                        file, id, value.assetCookie, "drawable");
                dr = Drawable.createFromXmlForDensity(wrapper, rp, density, null);
                rp.close();
            } else {
                // 通过 asset 的方式读取资源  file:///res/drawable-xhdpi/test.jpg
                final InputStream is = mAssets.openNonAsset(
                        value.assetCookie, file, AssetManager.ACCESS_STREAMING);
                AssetInputStream ais = (AssetInputStream) is;
                // 解析得到 BitmapDrawable
                dr = decodeImageDrawable(ais, wrapper, value);
            }
        } finally {
            stack.pop();
        }
    } catch (Exception | StackOverflowError e) {
        Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
        final NotFoundException rnf = new NotFoundException(
                "File " + file + " from drawable resource ID #0x" + Integer.toHexString(id));
        rnf.initCause(e);
        throw rnf;
    }
    Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
    .......
    return dr;
}
// 使用 setImageResource 方式同布局引用一致。
public void setImageResource(@DrawableRes int resId) {
    ......
    resolveUri();
    ......
}

private void resolveUri() {
    ......
    if (mResource != 0) {
        try {
            // 读取 Drawable
            d = mContext.getDrawable(mResource);
        } catch (Exception e) {
            Log.w(LOG_TAG, "Unable to find resource: " + mResource, e);
            // Don't try again.
            mResource = 0;
        }
    } else if (mUri != null) {
        ......
    } else {
        return;
    }
    updateDrawable(d);
}
// Context 类
public final Drawable getDrawable(@DrawableRes int id) {
    return getResources().getDrawable(id, getTheme());
}
// Resources 类 
public Drawable getDrawable(@DrawableRes int id, @Nullable Theme theme)
        throws NotFoundException {
    return getDrawableForDensity(id, 0, theme);
}

public Drawable getDrawableForDensity(@DrawableRes int id, int density, @Nullable Theme theme) {
    final TypedValue value = obtainTempTypedValue();
    try {
        final ResourcesImpl impl = mResourcesImpl;
        impl.getValueForDensity(id, density, value, true);
        // 依然执行到 ResourcesImpl.loadDrawable 且 density = 0
        return impl.loadDrawable(this, value, id, density, theme);
    } finally {
        releaseTempTypedValue(value);
    }
}

4. 总结

经过上述实践验证，建议在使用图片时，控制好图片尺寸。避免直接根据 resId 转化成 bitmap 对象。如需实时释放 bitmap 对象，建议通过 BitmapDrawable 取到 bitmap 引用再释放。

另外，以前存在的三个误区请避免。

  1. 图片占用的内存只与图片大小有关。非图片文件大小。
  2. 图片缩放计算，长scale款scale = 长宽*scale^2。
  3. 布局中引用的图片以及 setImageResource 方式使用图片，图片不会根据密度缩放。

源码地址

觉得有用？那打赏一个呗。去打赏

小飞哥0217
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android是如何在不同屏幕上适配图片的 -- 或控件大小
chinalwb的专栏
01-28 4万+
Android是如何在不同屏幕上适配图片的
玩转Android drawable图片适配
热门推荐
指数渐近线
01-05 2万+
众所周知，Android机型众多，屏幕尺寸、分辨率各有不同。对于Android开发人员来说，如何提高APP中图片对各种机型的适配是基本技能之一。借着项目中遇到的图片适配问题，在总结项目时，就想着顺带把这部分好好捋一捋，作为一个记录，也为不是很清楚这部分的人提供一个参考。先说mipmap采用Android Studio开发Android APP，在项目的res目录下，会多出几个以mipmap开头的文件
Android适配（图片、布局）
12-08
这个利用了percent库和图片的缩放处理，满足大多数屏幕适配的要求。
android项目的（drawable文件夹）图片适配
最新发布
qq_36570506的博客
06-29 506
android项目的（drawable文件夹）图片适配
Android进阶之路 - 屏幕适配（图片，字体）
Android、前端、小程序、后端
03-21 1083
抽时间补齐，补齐之后会删除此行 分辨率 不同分辨率的换算比例 图片适配 字体适配 字体适配 在Andorid手机的系统设置中有改变字体大小的功能，如果你没有进行适配的话，字体变大，布局混乱，就会造成尴尬处境 通用解决方案 ： sp 转为 dp 属性 改变前 ： <TextView android:layout_width="wrap_content" ...
android图片适配（图片大小与屏幕密度）Bitmap占用内存计算
liuyu0915的博客
04-07 3121
概述 android项目中图片适配流程。 屏幕密度：单位英寸面积上的像素点数，与分辨率是两个不同的概念。 获取屏幕密度 方法一：adb 命令 adb shell wm density 方法二：api调用 resource.getDisplayMetrics().densityDpi ldpi： 屏幕密度为120的手机设备 mdpi： 屏幕密度为160的手机设备（此为baseline，其他均以此为基准，在此设备上，1dp = 1px） hdpi： 屏幕密度为240的手机设备 xhdp
Android——图片与显示屏适配
Jiazimiao的博客
04-17 847
通用概念 px：像素点，整数 in：英寸，平时说的5英寸通常指指屏幕的对角线尺寸，1英寸 = 2.54厘米 dpi：每英寸包含的像素个数，例如分辨率320*480，宽2英寸，长3英寸，那么该屏幕的横向纵向dpi均等于160（320/2 == 480/3 == 160），大部分屏幕使用正方向像素点因此，横向纵向的dpi一般相同。 density：屏幕密度，density = dpi/160 dp：即dip，设备独立像素。Android特有单位，1dp = density*1px（在dp..
Android中.9.png图片的使用过程和原理
夏皓
06-10 1万+
原文链接:http://www.2cto.com/kf/201403/285698.html 1、Android中放置图片资源的文件夹 Android中一般有drawable-ldpi、drawable-mdpi、drawable-hdpi、drawable-xhdpi、drawable-xxhdpi等放置图片资源的文件夹，这几个文件夹分别对应的像素密度为：
android8、android13自适应图标适配
minping9101的博客
03-10 4655
为了解决应用图标在不同android手机上的外观样式问题，google官方在android8和android13两个版本做了变更（这2个版本都提供了向下兼容），下文介绍适配方法以及。
Android开发中图片的适配
deeny的博客
03-31 706
全面理解imageview的ScaleType属性，并做好适配前言：Android机型的种类大家都知道，适配一直都是一个大问题。所以一直以来对于开发者都是用多套图来做适配。这样做可以解决部分适配问题，但是缺点就是给app带来了负担，导致app包特别的大。
Android屏幕适配全基础
王昌时的博客
07-26 410
Android屏幕适配全攻略 一、碎片化说起来，人们口中的 Android 碎片化主要表现在 Android 品牌和机型众多，Android 版本众多和 Android 设备的尺寸和分辨率众多。也就是Android碎片化并不局限于手机屏幕。本文仅限于与大家一起探...
Android图片适配
qq_29087675的博客
03-20 382
项目中需要实现五张图片如下排序 排序是这样只不过把图片换了一下,需要保证适配所有手机,不能出现拉伸效果,我只说我的实现方式,不喜勿喷。直接上代码 <ScrollView android:layout_width="match_parent" android:layout_height="match_parent"> <LinearL
android图片适配方案,android不同机型的适配的解决方案(完整篇)
weixin_36349685的博客
05-25 1015
现在，市场上android的机型太多，如何让自己的应用更多的适配不同的机型，这是一个非常现实的并且是要处理解决的问题。android官方给出的解决文档是从三个方向来分析处理的。(1)支持不同屏幕大小的设备(Supporting Different Screen Sizes)1.1 合理使用wrap_content，match_parent1.2 尽可能的使用 RelativeLayout1.3 ...
android图片适配问题,浅谈Android的屏幕适配问题
weixin_35278121的博客
05-30 271
昨天就没有更新文章，在不更新就说不过去了，今天是清明节的第一天，我没有出去玩，不过在我心里是这么认为的，心中有风景，到哪都是旅游。不好意思，扯远啦，收回来。做过Android项目的人应该都知道，Android的屏幕适配问题是比较烦人的，因为Android不像IOS那样，只要那几个分辨率，反观Android就不同，Android手机的屏幕分辨率类别太多。虽然本人也没有做过几个Android项目，但是...
android中图片适配器,Android UI适配总结之图片适配（1）
weixin_39850787的博客
05-29 483
由于Android的屏幕尺寸的碎片化，时至今日Android的UI适配依然是开发中必不可少的步骤。UI适配的适配，是通过dp、权重，通配符等方式使View能按我们意愿的准确的显示在不同手机上。除了对view的尺寸适配，我们还要对图片适配，合适的把切图放在正确的位置，能有效的降低内存占用和图片变形。本篇是对图片适配的探索首先，准备一张200*200像素的图片(img.jpg)放在Android St...
android动态图片适配,android Drawble、Shape实现图像适配和优化
weixin_36440941的博客
05-25 613
一、屏幕适配说明在android开发过程中，屏幕适配是一件非常重要的工作，主要原则有以下几点对于控件而言，尽量不要使用固定的宽度和高度，但推荐使用固定的外边距局和内边距。对于drawable-xxx而言，没必要每个dpi都放置图片，完全可以再drawable-hdpi中放入720px级别的图片就可以完成适配，此外，如果某些部位确实需要调整的话，可以结合values-xxxx。 对于平滑色彩，渐变色...
Bitmap疑惑
三木仔
01-31 464
2. BimapFactory.Options提供了对图片加载解析策略，主要使用到的参数 3.Bitmap 加载大图 4. ARGB8888 RGB565区别 在drawable加载时候的图片内存大小
Android图片适配问题分析
viclee
05-04 4518
一些重要概念        首先来看一些Android屏幕适配相关的基本概念： 屏幕尺寸：单位为英寸（inch），也就是我们常说的手机屏幕是多少寸。这个尺寸指的是屏幕对角线的长度。 分辨率：屏幕高和宽的像素数， 现在常见的分辨率有640*480、1280*720、1920*1080。 px：像素，显示屏上的一个光点就是一个像素。 dp(dip)：设备无关像素，Android上特有的一种度...
android tv 图片适配
06-13
在 Android TV 上进行图片适配需要考虑以下几个方面： 1. 分辨率适配：Android TV 设备的分辨率通常比手机和平板电脑更高，因此需要提供高分辨率的图片资源。可以使用 drawable-xxhdpi、drawable-xxxhdpi 等高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值