乙巳🐍年

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

/**
 * 辅助生成资源文件
 *
 * @author leiTKai
 */
public class GenerateValueFiles {
    private static final String dirStr = "./res";
    private static final String FILE_NAME = "precent_width.xml";
    private static final String TEMPLATE = "    <dimen name=\"x%d\">%sdp</dimen>\n";
    private static final String VALUE_TEMPLATE = "values-w%ddp";

    private final int mBaseWidth;
    private final String mSupportStr;

    /**
     * constructor
     *
     * @param baseX
     *            基准宽
     * @param supportStr
     */
    public GenerateValueFiles(int baseX, String supportStr) {
        this.mBaseWidth = baseX;
        this.mSupportStr = supportStr;

        System.out.println("baseW: " + this.mBaseWidth);
        System.out.println("supportStr: " + this.mSupportStr);

        File dir = new File(dirStr);
        if (!dir.exists())
            dir.mkdir();
        System.out.print("FileDir: " + dir.getAbsoluteFile());
    }

    public void generate() {
        for (String val : mSupportStr.split(",")) {
            try {
                generateXmlFile(Integer.parseInt(val));
            } catch (IOException e) {
                e.printStackTrace();
                break;
            }
        }
    }

    private void generateXmlFile(final int smallestWidth) throws IOException {
        final File fileDir = new File(dirStr + File.separator
                + String.format(VALUE_TEMPLATE, smallestWidth));
        fileDir.mkdir();

        final File file = new File(fileDir, FILE_NAME);
        Writer writer = new BufferedWriter(new OutputStreamWriter(
                new FileOutputStream(file), "UTF-8"));
        writeContent(writer, mBaseWidth, smallestWidth);
        writer.close();
    }

    private static void writeContent(Writer writer, final int baseLength,
            final int totalLength) throws IOException {
        writer.write("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
        writer.write("<resources>\n");
        float cell = (float) totalLength / baseLength;
        for (int i = 2; i < baseLength; i+=2) {
            writer.write(String.format(TEMPLATE, i, float2String(cell * i)));
        }
        writer.write(String.format(TEMPLATE, baseLength,
                String.valueOf(totalLength)));
        writer.write("</resources>");
    }

    /**
     * 如果float类型没有小数部分则不输出小数
     *
     * @param f
     * @return
     */
    private static String float2String(float f) {
        if (Math.round(f) == f) {
            return String.valueOf((int) f);
        }
        return String.format("%.1f", f);
    }

    public static void main(String[] args) {
        int baseW = 1280;
        String addition = "320,480,532,640,698,732,768,800,852,912,960,1024,1280";
        if (args.length == 1) {
            addition = args[0];
        } else if (args.length == 2) {
            baseW = Integer.parseInt(args[0]);
            addition = args[1];
        }
        new GenerateValueFiles(baseW, addition).generate();
    }
}

private void getDisplayInfo(){
    Resources resources=getResources();
    DisplayMetrics displayMetrics = resources.getDisplayMetrics();
    float density = displayMetrics.density;
    int densityDpi = displayMetrics.densityDpi;
    Log.i(TAG, "density = " + density);
    Log.i(TAG, "densityDpi = " + densityDpi);
}

public static float applyDimension(int unit, float value,
                                       DisplayMetrics metrics)
    {
        switch (unit) {
        case COMPLEX_UNIT_PX:
            return value;
        case COMPLEX_UNIT_DIP:
            return value * metrics.density;
        case COMPLEX_UNIT_SP:
            return value * metrics.scaledDensity;
        case COMPLEX_UNIT_PT:
            return value * metrics.xdpi * (1.0f/72);
        case COMPLEX_UNIT_IN:
            return value * metrics.xdpi;
        case COMPLEX_UNIT_MM:
            return value * metrics.xdpi * (1.0f/25.4f);
        }
        return 0;
    }

final Point size = new Point();
((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getSize(size);
final Resources resources = context.getResources();
resources.getDisplayMetrics().xdpi = size.x / designWidth * 72f;

package xxx.yyy.zzz;

import java.lang.reflect.Field;

import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.content.res.Resources;
import android.graphics.Point;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.util.TypedValue;
import android.view.WindowManager;

/**
 * Created by Caodongyao
 * 转载请联系作者并注明出处 http://www.jianshu.com/p/b6b9bd1fba4d
 * 使用方法: Application#onCreate中调用一次即可
 */
public class ScreenHelper {
  /**
   * 重新计算displayMetrics.xhdpi, 使单位pt重定义为设计稿的相对长度
   *
   * @see #activate()
   *
   * @param context
   * @param designWidth
   *            设计稿的宽度
   */
  public static void resetDensity(Context context, float designWidth) {
    if (context == null) return;
    final Point size = new Point();
    ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getSize(size);
    final Resources resources = context.getResources();
    resources.getDisplayMetrics().xdpi = size.x / designWidth * 72f;

    DisplayMetrics metrics = getMetricsOnMiui(resources);
    if (metrics != null) {
      metrics.xdpi = size.x / designWidth * 72f;
    }
  }

  /**
   * 恢复displayMetrics为系统原生状态，单位pt恢复为长度单位磅
   *
   * @see #inactivate()
   *
   * @param context
   */
  public static void restoreDensity(Context context) {
    context.getResources().getDisplayMetrics().setToDefaults();

    DisplayMetrics metrics = getMetricsOnMiui(context.getResources());
    if (metrics != null)
      metrics.setToDefaults();
  }

  // 解决MIUI更改框架导致的MIUI7+Android5.1.1上出现的失效问题(以及极少数基于这部分miui去掉art然后置入xposed的手机)
  private static DisplayMetrics getMetricsOnMiui(Resources resources) {
    if ("MiuiResources".equals(resources.getClass().getSimpleName())
        || "XResources".equals(resources.getClass().getSimpleName())) {
      try {
        Field field = Resources.class.getDeclaredField("mTmpMetrics");
        field.setAccessible(true);
        return (DisplayMetrics) field.get(resources);
      } catch (Exception e) {
        return null;
      }
    }
    return null;
  }

  private Application.ActivityLifecycleCallbacks mActivityLifecycleCallbacks;
  private Application mApplication;
  private float mDesignWidth;

  /**
   *
   * @param application
   *            application
   * @param width
   *            设计稿宽度
   */
  public ScreenHelper(Application application, float width) {
    mApplication = application;
    mDesignWidth = width;

    mActivityLifecycleCallbacks = new Application.ActivityLifecycleCallbacks() {
      @Override
      public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        // 通常情况下application与activity得到的resource虽然不是一个实例，但是displayMetrics是同一个实例，只需调用一次即可
        // 为了面对一些不可预计的情况以及向上兼容，分别调用一次较为保险
        resetDensity(mApplication, mDesignWidth);
        resetDensity(activity, mDesignWidth);
      }

      @Override
      public void onActivityStarted(Activity activity) {
        resetDensity(mApplication, mDesignWidth);
        resetDensity(activity, mDesignWidth);
      }

      @Override
      public void onActivityResumed(Activity activity) {
        resetDensity(mApplication, mDesignWidth);
        resetDensity(activity, mDesignWidth);
      }

      @Override
      public void onActivityPaused(Activity activity) {

      }

      @Override
      public void onActivityStopped(Activity activity) {

      }

      @Override
      public void onActivitySaveInstanceState(Activity activity, Bundle outState) {

      }

      @Override
      public void onActivityDestroyed(Activity activity) {

      }
    };
  }

  /**
   * 激活本方案
   */
  public void activate() {
    resetDensity(mApplication, mDesignWidth);
    mApplication.registerActivityLifecycleCallbacks(mActivityLifecycleCallbacks);
  }

  /**
   * 恢复系统原生方案
   */
  public void inactivate() {
    restoreDensity(mApplication);
    mApplication.unregisterActivityLifecycleCallbacks(mActivityLifecycleCallbacks);
  }

    /**
     * 转换pt为px
     * @param context context
     * @param value 需要转换的pt值，若context.resources.displayMetrics经过resetDensity()的修改则得到修正的相对长度，否则得到原生的磅
     * @return px值
     */
    public static float pt2px(Context context, float value){
        return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PT, value, context.getResources().getDisplayMetrics());
    }
}