devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Android】通过控制dpi来实现修改分辨率和显示大小app布局错乱问题_android 修改手机显示大小 布局问题

作者：从前慢现在也慢 | 2024-07-17 00:25:53

赞

踩

android 修改手机显示大小 布局问题

在开发app时，自适应问题是都需要解决的问题，一般大家的实现方式是

1. 给字体不同分辨率设置对应的sp，然后根据不同的分辨率显示对应的大小。

2.设置布局中的单位为dp，这样不同的手机，字体会自动变大变小。

笔者在开发中使用了第二种方法，使用了dp作为单位。这也导致在后续的测试中出现了下面的问题：

1. 当手动修改手机的【设置】中的【显示大小】后，app字体会自动变大导致布局错乱，超出范围

2. 现在很多手机，比如华为，可以在手机的【设置】中手动修改【分辨率】，一旦修改分辨率后，同样也会出现布局字体变大导致布局错乱。

那么怎么能够解决在不进行大的改动的情况下，来解决上面的2个问题，从而使修改【显示大小】后app中的字体保持不变。在修改【分辨率】后，app的字体会自动进行相应的缩放（类似于字体不变，其实是变了），从而保证字体看上去跟原先的没什么两样，保证字体不会因为分辨率修改而变大，导致app布局错乱。

解决方式：

思路：

写一个BaseActivity，所有的Activity都继承它。然后在它的attachBaseContext(Context newBase)声明周期中编写代码，代码通过设置不同的dpi，来保证了上面说的2个问题的解决。

举例说明：

关于问题一：比如，你手机的dpi是440，那么当你把手机的【设置】的【显示大小】的值变大时，手机会自动修改设置dpi为一个值，这也就出现了app字体变大或者变小的现象了。当我们重写attachBaseContext这个生命周期方发后，一旦修改【显示大小】后，便会进出方法，在方法中，我们只需固定dpi为默认的dpi值440就行，这样不管你怎么改，相同分辨率下，dpi不变，你的app中的字体就会不变了。

关于问题二：当手动修改分辨率时，跟修改【显示大小】的机制是不同的，修改分辨率后，因为dpi不会变，这就导致了字体会变大变小。那么怎么实现让字体不变呢（有可能会多少变一点点，因为计算时精确率问题，但总体不影响）。我们通过先获取到手机自带的那个默认分辨率，然后在获取修改后的当前分辨率，算出其缩放率（例如缩放率 = 新的宽度/默认的款的），然后用这个缩放率乘以默认dpi，然后把算出的dpi设置给app，这样就解决问题了。

代码实现：

首先需要一个工具了，这里叫做ScreenHelp.java

  1. package jp.co.sharp.android.parents.kidsguard.utils;
  2.  
  3. import android.annotation.SuppressLint;
  4. import android.content.Context;
  5. import android.os.IBinder;
  6. import android.os.RemoteException;
  7. import android.util.DisplayMetrics;
  8. import android.view.Display;
  9. import android.view.IWindowManager;
  10. import android.view.WindowManager;
  11.  
  12.  
  13. import java.lang.reflect.InvocationTargetException;
  14. import java.lang.reflect.Method;
  15.  
  16.  
  17. /**
  18.  * Screen Helper Class to get default dpi .
  19.  */
  20. public class ScreenHelper {
  21.  
  22.     /**
  23.      * Dcm Log Tag .
  24.      */
  25.     private static final String TAG = "ScreenHelper";
  26.  
  27.     /**
  28.      * The defalut LDPI value .
  29.      */
  30.     private static final int LDPI = DisplayMetrics.DENSITY_DEFAULT;
  31.     /**
  32.      * The defalut HDPI value .
  33.      */
  34.     private static final int HDPI = DisplayMetrics.DENSITY_HIGH;
  35.     /**
  36.      * The defalut XHDPI value .
  37.      */
  38.     private static final int XHDPI = DisplayMetrics.DENSITY_XHIGH;
  39.     /**
  40.      * The defalut XXHDPI value .
  41.      */
  42.     private static final int XXHDPI = DisplayMetrics.DENSITY_XXHIGH;
  43.     /**
  44.      * The 560 dpi value .
  45.      */
  46.     private static final int DPI_560 = DisplayMetrics.DENSITY_560;
  47.  
  48.     /**
  49.      * The defalut XXXHDPI value .
  50.      */
  51.     private static final int XXXHDPI = DisplayMetrics.DENSITY_XXXHIGH;
  52.  
  53.     /**
  54.      * The standard 720p device width.
  55.      */
  56.     private static final int DEFALUT_SCREEN_WIDTH = 720;
  57.     /**
  58.      * The standard 1080p device width.
  59.      */
  60.     private static final int MEDIUM_SCREEN_WIDTH = 1080;
  61.     /**
  62.      * The standard 4k device width.
  63.      */
  64.     private static final int HIGH_SCREEN_WIDTH = 1440;
  65.     /**
  66.      * The standard max device width.
  67.      */
  68.     private static final int MAX_SCREEN_WIDTH = 2160;
  69.  
  70.     /**
  71.      * The Max Screen DP to distinguish phone and tablet.
  72.      */
  73.     private static final int MAX_SCREEN_DP = 600;
  74.     /**
  75.      * Default Mode Name .
  76.      */
  77.     private static final String DEFAULT_MODE = "defaultMode";
  78.  
  79.     /**
  80.      * getDefaultDpi.<br>
  81.      * Note : get default dpi when Display Size has changed
  82.      *
  83.      * @param context attach activity context
  84.      * @return default dpi
  85.      */
  86.     public int getDefaultDpi(Context context) {
  87.         WindowManager windowManager = (WindowManager) context
  88.                 .getSystemService(Context.WINDOW_SERVICE);
  89.         Display display = windowManager.getDefaultDisplay();
  90.         DisplayMetrics metrics = new DisplayMetrics();
  91.         display.getRealMetrics(metrics);
  92.  
  93. //        boolean changed = isChangedResolution(display, metrics);
  94.         boolean changed = false;
  95.         // if it is tablet,no need to keep current dpi
  96. //        if (isTablet(context)) {
  97. //            return metrics.densityDpi;
  98. //        } else if (changed) {
  99. //            // get special device dpi
  100. //            return getSpecialDeviceDpi(metrics);
  101. //        } else {
  102. //            return getInitialDisplayDensity(metrics);
  103. //        }
  104.         return getInitialDisplayDensity(metrics);
  105.     }
  106.  
  107.     private int getInitialDisplayDensity(DisplayMetrics metrics) {
  108.         int physicalDensity = metrics.densityDpi;
  109.         boolean isError = false;
  110.         try {
  111.             @SuppressLint("PrivateApi") Class<?> clazz = Class.forName("android.os.ServiceManager");
  112.             try {
  113.                 @SuppressLint("DiscouragedPrivateApi") Method method = clazz.getDeclaredMethod("checkService", String.class);
  114.                 try {
  115.                     IWindowManager mWindowManager = IWindowManager.Stub.asInterface((IBinder) method.invoke(null, Context.WINDOW_SERVICE));
  116.                     try {
  117.                         if (mWindowManager != null) {
  118.                             physicalDensity = mWindowManager.getInitialDisplayDensity(Display.DEFAULT_DISPLAY);
  119.                         }
  120.                     } catch (RemoteException e) {
  121.                         e.printStackTrace();
  122.                         isError = true;
  123.                     }
  124.                 } catch (IllegalAccessException | InvocationTargetException e) {
  125.                     e.printStackTrace();
  126.                     isError = true;
  127.                 }
  128.             } catch (NoSuchMethodException e) {
  129.                 e.printStackTrace();
  130.                 isError = true;
  131.             }
  132.         } catch (ClassNotFoundException e) {
  133.             e.printStackTrace();
  134.             isError = true;
  135.         }
  136.         if (isError) {
  137.             physicalDensity = getSpecialDeviceDpi(metrics);
  138.         }
  139.         return physicalDensity;
  140.     }
  141.  
  142.     /**
  143.      * isChangedResolution.<br>
  144.      * Note : check if huawei device
  145.      *
  146.      * @param display view display instance
  147.      * @param displayMetrics view displayMetrics to get some device screen attr
  148.      * @return true is huawei device,false is not
  149.      */
  150. //    private boolean isChangedResolution(Display display, DisplayMetrics displayMetrics) {
  151. //        Display.Mode[] modes = display.getSupportedModes();
  152. //        if (modes.length > 1) {
  153. //            String displayInfo = display.toString();
  154. //
  155. //            int firstIndex = displayInfo.indexOf(DEFAULT_MODE);
  156. //            int length = DEFAULT_MODE.length();
  157. //            String defaultModeInfo = displayInfo.substring(firstIndex);
  158. //            int firstSymbolIndex = defaultModeInfo.indexOf(",");
  159. //            String defaultMode = defaultModeInfo.substring(length, firstSymbolIndex);
  160. //            int defaultModeIndex = Integer.parseInt(defaultMode.replace(" ", ""));
  161. //            for (Display.Mode mode : modes) {
  162. //                if (mode.getModeId() == defaultModeIndex) {
  163. //                    int defaultWidth = mode.getPhysicalWidth();
  164. //                    return defaultWidth != displayMetrics.widthPixels;
  165. //                }
  166. //            }
  167. //        }
  168. //
  169. //        // get the init screen Pixels
  170. //        int physicalWidth = display.getMode().getPhysicalWidth();
  171. //        int physicalHeight = display.getMode().getPhysicalHeight();
  172. //
  173. //        // get current screen Pixels
  174. //        int currentWidth = displayMetrics.widthPixels;
  175. //        int currentHeight = displayMetrics.heightPixels;
  176. //
  177. //        //if init size is different with current size, this means resolution
  178. //        //has changed
  179. //        if (physicalWidth != currentWidth && physicalHeight != currentHeight) {
  180. //            return true;
  181. //        }
  182. //
  183. //        return false;
  184. //    }
  185.  
  186.     /**
  187.      * getSpecialDeviceDpi.<br>
  188.      * Note : when the Resolution could be changed, according to stardand Resolution to
  189.      * get the dpi
  190.      *
  191.      * @param displayMetrics display metrics instances
  192.      * @return standard dpi
  193.      */
  194.     private int getSpecialDeviceDpi(DisplayMetrics displayMetrics) {
  195.         int widthPixels = displayMetrics.widthPixels;
  196.         int heightPixels = displayMetrics.heightPixels;
  197.  
  198.         // get min Pixels.
  199.         int minPixels = Math.min(widthPixels, heightPixels);
  200.  
  201.  
  202.         // get the apposite dpi
  203.         if (minPixels < DEFALUT_SCREEN_WIDTH) {
  204.             return HDPI;
  205.         } else if (minPixels >= DEFALUT_SCREEN_WIDTH && minPixels < MEDIUM_SCREEN_WIDTH) {
  206.             return XHDPI;
  207.         } else if (minPixels >= MEDIUM_SCREEN_WIDTH && minPixels < HIGH_SCREEN_WIDTH) {
  208.             return XXHDPI;
  209.         } else if (minPixels >= HIGH_SCREEN_WIDTH && minPixels < MAX_SCREEN_WIDTH) {
  210.             return DPI_560;
  211.         } else {
  212.             return XXXHDPI;
  213.         }
  214.     }
  215.  
  216.     /**
  217.      * isTablet.<br>
  218.      * Note : check if current device is tablet.
  219.      *
  220.      * @param context attach activity context
  221.      * @return true is tablet, false is not
  222.      */
  223. //    private boolean isTablet(Context context) {
  224. //        return context.getResources().getBoolean(R.bool.isTablet);
  225. //    }
  226.  
  227.  
  228.     /**
  229.      * get default resolution beacause HuaWei can setting multi resolution,
  230.      * this method can get the default when you change to another resolution
  231.      * @param context
  232.      * @return
  233.      */
  234.     public int getDefaultResolutionWidth(Context context) {
  235.         WindowManager windowManager = (WindowManager) context
  236.                 .getSystemService(Context.WINDOW_SERVICE);
  237.         Display display = windowManager.getDefaultDisplay();
  238.  
  239.         Display.Mode[] modes = display.getSupportedModes();
  240.  
  241.         DisplayMetrics metrics = new DisplayMetrics();
  242.         display.getRealMetrics(metrics);
  243.  
  244.         if (modes.length > 1) {
  245.             String displayInfo = display.toString();
  246.  
  247.             int firstIndex = displayInfo.indexOf(DEFAULT_MODE);
  248.             int length = DEFAULT_MODE.length();
  249.             String defaultModeInfo = displayInfo.substring(firstIndex);
  250.             int firstSymbolIndex = defaultModeInfo.indexOf(",");
  251.             String defaultMode = defaultModeInfo.substring(length, firstSymbolIndex);
  252.             int defaultModeIndex = Integer.parseInt(defaultMode.replace(" ", ""));
  253.             for (Display.Mode mode : modes) {
  254.                 if (mode.getModeId() == defaultModeIndex) {
  255.                     int defaultWidth = mode.getPhysicalWidth();
  256.                     return defaultWidth;
  257.                 }
  258.             }
  259.         }
  260.  
  261.         // get the init screen Pixels
  262.         int physicalWidth = display.getMode().getPhysicalWidth();
  263.         int physicalHeight = display.getMode().getPhysicalHeight();
  264.  
  265.  
  266.  
  267.         return physicalWidth;
  268.     }
  269. }

然后在BaseActivity这个基类中重写attachBaseContext方法（其他Activity要继承这个类昂），代码如下：

  1.  @Override
  2.     protected void attachBaseContext(Context newBase) {
  3.         float scale = 0f;
  4.         if (Build.VERSION.SDK_INT > 22) {
  5.  
  6.             Resources res = newBase.getResources();
  7.             Configuration configuration = res.getConfiguration();
  8.  
  9.             ScreenHelper screenHelper = new ScreenHelper();
  10.             int defaultDpi = screenHelper.getDefaultDpi(newBase);
  11. //            configuration.fontScale = 0.2f;
  12. //            configuration.densityDpi = defaultDpi;
  13.  
  14.             int defaultWidth = screenHelper.getDefaultResolutionWidth(newBase);
  15.  
  16.             DisplayMetrics metrics = newBase.getResources().getDisplayMetrics();
  17.             int width = metrics.widthPixels;
  18.             if(defaultWidth !=width){
  19.                 scale = new BigDecimal((float)width/defaultWidth).setScale(2, BigDecimal.ROUND_HALF_UP).floatValue();
  20.                 configuration.densityDpi = (int)(defaultDpi * scale);
  21.             }else {
  22.                 configuration.densityDpi = defaultDpi;
  23.             }
  24.  
  25.             Context newContext = newBase.createConfigurationContext(configuration);
  26.             super.attachBaseContext(newContext);
  27.         } else {
  28.             super.attachBaseContext(newBase);
  29.         }
  30.  
  31.     }

到此就ok了，运行代码，然后修改【分辨率】和【显示大小】看看效果吧，是不是app中的字体都不会在变动了吧。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/836978
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号