/**
 * 是否有NavigationBar
 *
 * @param activity 上下文
 * @return 是否有NavigationBar
 */
private static boolean hasNavBar(Activity activity) {
    WindowManager windowManager = activity.getWindowManager();
    Display d = windowManager.getDefaultDisplay();

    DisplayMetrics realDisplayMetrics = new DisplayMetrics();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        d.getRealMetrics(realDisplayMetrics);
    }

    int realHeight = realDisplayMetrics.heightPixels;
    int realWidth = realDisplayMetrics.widthPixels;

    DisplayMetrics displayMetrics = new DisplayMetrics();
    d.getMetrics(displayMetrics);

    int displayHeight = displayMetrics.heightPixels;
    int displayWidth = displayMetrics.widthPixels;

    return (realWidth - displayWidth) > 0 || (realHeight - displayHeight) > 0;
}
 

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  if (!(getActivity() instanceof Controller)) {
    throw new IllegalStateException("Parent activity must implement the Controller interface.");
  }

  WindowManager windowManager = ServiceUtil.getWindowManager(getActivity());
  Display       display       = windowManager.getDefaultDisplay();
  Point         displaySize   = new Point();

  display.getSize(displaySize);

  controller    = (Controller) getActivity();
  camera        = new Camera1Controller(TextSecurePreferences.getDirectCaptureCameraId(getContext()), displaySize.x, displaySize.y, this);
  orderEnforcer = new OrderEnforcer<>(Stage.SURFACE_AVAILABLE, Stage.CAMERA_PROPERTIES_AVAILABLE);
  viewModel     = ViewModelProviders.of(requireActivity(), new MediaSendViewModel.Factory(requireActivity().getApplication(), new MediaRepository())).get(MediaSendViewModel.class);
}
 

public static Point getDisplayPoint(Context context) {
    WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    @SuppressWarnings("rawtypes")
    Class c;
    try {
        c = Class.forName("android.view.Display");
        @SuppressWarnings("unchecked")
        Method method = c.getMethod("getRealMetrics", DisplayMetrics.class);
        method.invoke(display, displayMetrics);
        return new Point(displayMetrics.widthPixels, displayMetrics.heightPixels);
    } catch (Exception e) {
        e.printStackTrace();
    }
    DisplayMetrics dm = new DisplayMetrics();
    ((Activity) context).getWindowManager().getDefaultDisplay().getMetrics(dm);
    return new Point(dm.widthPixels, dm.heightPixels);
}
 

private AdSize getAdSize() {
  // Determine the screen width (less decorations) to use for the ad width.
  Display display = getWindowManager().getDefaultDisplay();
  DisplayMetrics outMetrics = new DisplayMetrics();
  display.getMetrics(outMetrics);

  float density = outMetrics.density;

  float adWidthPixels = adContainerView.getWidth();

  // If the ad width isn't known, default to the full screen width.
  if (adWidthPixels == 0) {
    adWidthPixels = outMetrics.widthPixels;
  }

  int adWidth = (int) (adWidthPixels / density);
  return AdSize.getCurrentOrientationBannerAdSizeWithWidth(this, adWidth);
}
 

final void init(LoadedApk packageInfo, IBinder activityToken, ActivityThread mainThread,
        Resources container, String basePackageName, UserHandle user) {
    mPackageInfo = packageInfo;
    mBasePackageName = basePackageName != null ? basePackageName : packageInfo.mPackageName;
    mResources = mPackageInfo.getResources(mainThread);

    if (mResources != null && container != null
            && container.getCompatibilityInfo().applicationScale !=
                    mResources.getCompatibilityInfo().applicationScale) {
        if (DEBUG) {
            Log.d(TAG, "loaded context has different scaling. Using container's" +
                    " compatiblity info:" + container.getDisplayMetrics());
        }
        mResources = mainThread.getTopLevelResources(
                mPackageInfo.getResDir(), Display.DEFAULT_DISPLAY,
                null, container.getCompatibilityInfo());
    }
    mMainThread = mainThread;
    mActivityToken = activityToken;
    mContentResolver = new ApplicationContentResolver(this, mainThread, user);
    mUser = user;
}
 

/**
 * 获取屏幕高(包含虚拟键盘)， 单位 px
 * @return screenHeight;
 * */
public static int getScreenHeight() {
    WindowManager windowManager = (WindowManager) ContextProvider.get().getSystemService(Context.WINDOW_SERVICE);
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics dm = new DisplayMetrics();
    Class c;
    try {
        c = Class.forName("android.view.Display");
        @SuppressWarnings("unchecked")
        Method method = c.getMethod("getRealMetrics", DisplayMetrics.class);
        method.invoke(display, dm);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
    return dm.heightPixels;
}
 

@Override
public void onDisplayStateChange(int state) {
    // This method is only needed to support legacy display blanking behavior
    // where the display's power state is coupled to suspend or to the power HAL.
    // The order of operations matters here.
    synchronized (mLock) {
        if (mDisplayState != state) {
            mDisplayState = state;
            if (state == Display.STATE_OFF) {
                if (!mDecoupleHalInteractiveModeFromDisplayConfig) {
                    setHalInteractiveModeLocked(false);
                }
                if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {
                    setHalAutoSuspendModeLocked(true);
                }
            } else {
                if (!mDecoupleHalAutoSuspendModeFromDisplayConfig) {
                    setHalAutoSuspendModeLocked(false);
                }
                if (!mDecoupleHalInteractiveModeFromDisplayConfig) {
                    setHalInteractiveModeLocked(true);
                }
            }
        }
    }
}
 

/**
 * 虚拟操作拦（home等）是否显示
 */
public static boolean isNavigationBarShow(Activity activity) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        Display display = activity.getWindowManager().getDefaultDisplay();
        Point size = new Point();
        Point realSize = new Point();
        display.getSize(size);
        display.getRealSize(realSize);
        return realSize.y != size.y;
    } else {
        boolean menu = ViewConfiguration.get(activity).hasPermanentMenuKey();
        boolean back = KeyCharacterMap.deviceHasKey(KeyEvent.KEYCODE_BACK);
        if (menu || back) {
            return false;
        } else {
            return true;
        }
    }
}
 

private void calculateSize() {
    Window window = getDialog().getWindow();
    Point size = new Point();
    Display display = window.getWindowManager().getDefaultDisplay();
    display.getSize(size);

    if (mW < 0) {
        mWidth = WindowManager.LayoutParams.WRAP_CONTENT;
    } else if (mW > 1) {
        mWidth = WindowManager.LayoutParams.MATCH_PARENT;
    } else {
        mWidth = (int) (size.x * mW);
    }

    if (mH < 0) {
        mHeight = WindowManager.LayoutParams.WRAP_CONTENT;
    } else if (mH > 1) {
        mHeight = WindowManager.LayoutParams.MATCH_PARENT;
    } else {
        mHeight = (int) (size.y * mH);
    }
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Get the current device's screen resolution
    Display display = getWindowManager().getDefaultDisplay();
    Point size = new Point();
    display.getSize(size);

    // Initialize our size based variables based on the screen resolution
    numberHorizontalPixels = size.x;
    numberVerticalPixels = size.y;
    blockSize = numberHorizontalPixels / gridWidth;
    gridHeight = numberVerticalPixels / blockSize;

    Log.d("Debugging", "In onCreate");
    newGame();
    draw();
}
 

@Override
protected void onStart() {
	WindowManager m = getWindowManager();
	Display d = m.getDefaultDisplay(); // 为获取屏幕宽、高

	//System.out.println("d.getHeight():" + d.getHeight());
	LayoutParams p = getWindow().getAttributes(); // 获取对话框当前的参数值
	p.height = (int) (d.getHeight() * 1.0); // 高度设置为屏幕的1.0
	p.width = (int) (d.getWidth() * 1.0); // 宽度设置为屏幕的0.8
	p.alpha = 1.0f; // 设置本身透明度
	p.dimAmount = 0.0f; // 设置黑暗度

	getWindow().setAttributes(p); // 设置生效
	getWindow().setGravity(Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM); // 设置靠右对齐
	super.onStart();
}
 

private void setCustomDialog() {

        View mView = LayoutInflater.from(getContext()).inflate(R.layout.dialog_wallet_code, null);
        walletCode = mView.findViewById(R.id.wallet_code);
        go_weixin_friend = mView.findViewById(R.id.go_weixin_friend);
        go_weixin_circle = mView.findViewById(R.id.go_weixin_circle);
        go_qq_friend = mView.findViewById(R.id.go_qq_friend);
        go_qzone = mView.findViewById(R.id.go_qzone);
        ll = mView.findViewById(R.id.ll);


        go_weixin_friend.setOnClickListener(this);
        go_weixin_circle.setOnClickListener(this);
        go_qq_friend.setOnClickListener(this);
        go_qzone.setOnClickListener(this);
        super.setContentView(mView);
        WindowManager windowManager = getWindow().getWindowManager();
        Display display = windowManager.getDefaultDisplay();
        WindowManager.LayoutParams lp = this.getWindow().getAttributes();
        lp.width = (int) (display.getWidth() * 0.78); //设置宽度
        this.getWindow().setAttributes(lp);
    }
 

@SuppressLint({"NewApi"})
public static void blur_3(Context context, Bitmap bkg, View view) {
    long startMs = System.currentTimeMillis();
    Display d = ((Activity) context).getWindowManager().getDefaultDisplay();
    Bitmap overlay = Bitmap.createBitmap((int) (((float) d.getWidth()) / 1.0f), (int) (((float) d.getHeight()) / 1.0f), Config.ARGB_8888);
    Canvas canvas = new Canvas(overlay);
    canvas.scale(1.0f / 1.0f, 1.0f / 1.0f);
    Paint paint = new Paint();
    paint.setFlags(2);
    canvas.drawBitmap(bkg, 0.0f, 0.0f, paint);
    overlay = FastBlur.doBlur(overlay, (int) 100.0f, true);
    if (LetvUtils.getSDKVersion() >= 16) {
        view.setBackground(new BitmapDrawable(context.getResources(), overlay));
    } else {
        view.setBackgroundDrawable(new BitmapDrawable(context.getResources(), overlay));
    }
}
 

/**
 * Gets resolution on old devices.
 * Tries the reflection to get the real resolution first.
 * Fall back to getDisplayMetrics if the above method failed.
 * */
private static Pair<Integer, Integer> getRealResolutionOnOldDevice(Context ctx) {
  try{
    WindowManager wm = (WindowManager) ctx.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    Method mGetRawWidth = Display.class.getMethod("getRawWidth");
    Method mGetRawHeight = Display.class.getMethod("getRawHeight");
    Integer realWidth = (Integer) mGetRawWidth.invoke(display);
    Integer realHeight = (Integer) mGetRawHeight.invoke(display);
    return new Pair<Integer, Integer>(realWidth, realHeight);
  }
  catch (Exception e) {
    DisplayMetrics disp = ctx.getResources().getDisplayMetrics();
    return new Pair<Integer, Integer>(disp.widthPixels, disp.heightPixels);
  }
}
 

@Override
public void onConfigurationChanged(Configuration newConfig) {
    Display display = ((WindowManager) getApplicationContext().getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
    Point size = new Point();
    display.getSize(size);
    screenWidth = size.x;
    screenHeight = size.y;
    Log.e("KCA", "w/h: " + String.valueOf(screenWidth) + " " + String.valueOf(screenHeight));

    if (mParams != null) {
        mParams.x = (screenWidth - popupWidth) / 2;
        mParams.y = (int)((screenHeight - popupHeight) * 0.8);
    }

    super.onConfigurationChanged(newConfig);
}
 

private void refreshPreferenceConfigs() {
    Activity activity = getActivity();
    if (activity != null && !activity.isFinishing()) {
        Display display = getActivity().getWindowManager().getDefaultDisplay();
        DisplayMetrics outMetrics = new DisplayMetrics();
        display.getMetrics(outMetrics);

        float density = getResources().getDisplayMetrics().density;
        //float dpHeight = outMetrics.heightPixels / density;
        float dpWidth = outMetrics.widthPixels / density;

        //final int spanCount = getResources().getInteger(R.integer.grid_columns);
        int spanCount = (int) Math.floor(dpWidth / 90.0d);
        final int prefCount = Integer.parseInt(mSharedPref.getString("num_columns", "0"));
        if (prefCount != 0) {
            spanCount = prefCount;
        }

        mRecyclerView.setLayoutManager(new GridLayoutManager(getContext(), spanCount));

        int resId = R.anim.grid_anim;
        LayoutAnimationController animation = AnimationUtils.loadLayoutAnimation(getContext(), resId);
        mRecyclerView.setLayoutAnimation(animation);
    }
}
 

private int getDisplayInfo(Point size) {
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if (size != null) {
        display.getSize(size);
    }
    int rotation = display.getRotation();
    switch (rotation) {
        case Surface.ROTATION_0:
            return 0;
        case Surface.ROTATION_90:
            return 90;
        case Surface.ROTATION_180:
            return 180;
        case Surface.ROTATION_270:
            return 270;
    }
    throw new RuntimeException("Unknown screen rotation: " + rotation);
}
 

private void setCustomDialog() {
    View mView = LayoutInflater.from(getContext()).inflate(R.layout.dialog_change_password, null);
    sureBtn = (TextView) mView.findViewById(R.id.dialog_confirm_sure);
    cancleBtn = (TextView) mView.findViewById(R.id.dialog_confirm_cancle);
    mClearEditText = (ClearEditText) mView.findViewById(R.id.dialog_old_password);
    mClearEditText1 = (ClearEditText) mView.findViewById(R.id.dialog_old_two_password);
    mClearEditText2 = (ClearEditText) mView.findViewById(R.id.dialog_new_password);
    sureBtn.setOnClickListener(this);
    cancleBtn.setOnClickListener(this);
    super.setContentView(mView);
    WindowManager windowManager = getWindow().getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    WindowManager.LayoutParams lp = this.getWindow().getAttributes();
    lp.width = (int) (display.getWidth() * 0.78); //设置宽度
    this.getWindow().setAttributes(lp);
}
 

@Override
public void onConfigurationChanged (Configuration newConfig) {
	WindowManager wm = (WindowManager) this.context.getSystemService(Context.WINDOW_SERVICE);
	Display display = wm.getDefaultDisplay();
	Point dSize = new Point();
	display.getSize(dSize);
	this.sl1.displayWidth = this.sl2.displayWidth = this.sl3.displayWidth = dSize.x - iconSize - 5;
	this.invalidate();
}
 

DisplayAndroid getDisplayAndroid(Display display) {
    int sdkDisplayId = display.getDisplayId();
    DisplayAndroid displayAndroid = mIdMap.get(sdkDisplayId);
    if (displayAndroid == null) {
        displayAndroid = addDisplay(display);
    }
    return displayAndroid;
}
 

private void listing16_8() {
  // Listing 16-8: Finding the screen orientation relative to the natural orientation
  WindowManager wm = (WindowManager)getSystemService(Context.WINDOW_SERVICE);
  Display display = wm.getDefaultDisplay();

  int rotation = display.getRotation();
  switch (rotation) {
    case (Surface.ROTATION_0) : break;   // Natural
    case (Surface.ROTATION_90) : break;  // On its left side
    case (Surface.ROTATION_180) : break; // Upside down
    case (Surface.ROTATION_270) : break; // On its right side
    default: break;
  }
}
 

/**
 * 重新计算displayMetrics.xhdpi, 使单位pt重定义为设计稿的相对长度
 * @see #activate()
 *
 * @param context
 * @param designWidth 设计稿的宽度
 */
private static void resetDensity(Context context, float designWidth){
    WindowManager windowManager = (WindowManager) context.getSystemService(WINDOW_SERVICE);
    if (windowManager != null) {
        Display defDisplay = windowManager.getDefaultDisplay();
        Point size = new Point();
        defDisplay.getSize(size);
        context.getResources().getDisplayMetrics().xdpi = size.x / designWidth * 72f;
    }
}
 

private boolean isDisplayOn(Context context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        DisplayManager dm = (DisplayManager) context.getSystemService(Context.DISPLAY_SERVICE);
        for (Display display : dm.getDisplays()) {
            if (display.getState() != Display.STATE_OFF) {
                return true;
            }
        }
        return false;
    } else {
        PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        return powerManager.isScreenOn();
    }
}
 

private void calcWidthAndHeight()
{
	WindowManager windowManager = (WindowManager) mContext.getSystemService(Context
			.WINDOW_SERVICE);
	Display defaultDisplay = windowManager.getDefaultDisplay();
	DisplayMetrics metrics = new DisplayMetrics();
	defaultDisplay.getMetrics(metrics);
	//将popup的高度设置为屏幕的7分之一
	mWidth = metrics.widthPixels;
	mHeight = (int) (metrics.heightPixels * 0.7);
}
 

@Override
public void onDisplayChanged(int displayId) {
    if (displayId == mDisplay.getDisplayId()) {
        if (mDisplay.getState() == Display.STATE_DOZE
                || mDisplay.getState() == Display.STATE_DOZE_SUSPEND
                || mDisplay.getState() == Display.STATE_ON_SUSPEND) {
            startBurnInProtection();
        } else {
            cancelBurnInProtection();
        }
    }
}
 

private void initializeRecordingUI() {
    Display display = ((WindowManager) getSystemService(WINDOW_SERVICE)).getDefaultDisplay();
    mVideoRecorder = new VideoRecorder(this, mCaptureConfiguration, mVideoFile, new CameraWrapper(new NativeCamera(), display.getRotation()),
            mVideoCaptureView.getPreviewSurfaceHolder());
    mVideoCaptureView.setRecordingButtonInterface(this);
    boolean showTimer = this.getIntent().getBooleanExtra(EXTRA_SHOW_TIMER, false);
    mVideoCaptureView.showTimer(showTimer);
    if (mVideoRecorded) {
        mVideoCaptureView.updateUIRecordingFinished(getVideoThumbnail());
    } else {
        mVideoCaptureView.updateUINotRecording();
    }
    mVideoCaptureView.showTimer(mCaptureConfiguration.getShowTimer());
}
 

@Override
public DisplayDeviceInfo getDisplayDeviceInfoLocked() {
    if (mInfo == null) {
        Display.Mode mode = mModes[mActiveMode];
        OverlayMode rawMode = mRawModes.get(mActiveMode);
        mInfo = new DisplayDeviceInfo();
        mInfo.name = mName;
        mInfo.uniqueId = getUniqueId();
        mInfo.width = mode.getPhysicalWidth();
        mInfo.height = mode.getPhysicalHeight();
        mInfo.modeId = mode.getModeId();
        mInfo.defaultModeId = mModes[0].getModeId();
        mInfo.supportedModes = mModes;
        mInfo.densityDpi = rawMode.mDensityDpi;
        mInfo.xDpi = rawMode.mDensityDpi;
        mInfo.yDpi = rawMode.mDensityDpi;
        mInfo.presentationDeadlineNanos = mDisplayPresentationDeadlineNanos +
                1000000000L / (int) mRefreshRate;   // display's deadline + 1 frame
        mInfo.flags = DisplayDeviceInfo.FLAG_PRESENTATION;
        if (mSecure) {
            mInfo.flags |= DisplayDeviceInfo.FLAG_SECURE;
        }
        mInfo.type = Display.TYPE_OVERLAY;
        mInfo.touch = DisplayDeviceInfo.TOUCH_NONE;
        mInfo.state = mState;
    }
    return mInfo;
}
 

public static void initDisplayMetrics(Context context) {
  DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
  DisplayMetricsHolder.setWindowDisplayMetrics(displayMetrics);

  DisplayMetrics screenDisplayMetrics = new DisplayMetrics();
  screenDisplayMetrics.setTo(displayMetrics);
  WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  Assertions.assertNotNull(
      wm,
      "WindowManager is null!");
  Display display = wm.getDefaultDisplay();

  // Get the real display metrics if we are using API level 17 or higher.
  // The real metrics include system decor elements (e.g. soft menu bar).
  //
  // See: http://developer.android.com/reference/android/view/Display.html#getRealMetrics(android.util.DisplayMetrics)
  if (Build.VERSION.SDK_INT >= 17) {
    display.getRealMetrics(screenDisplayMetrics);
  } else {
    // For 14 <= API level <= 16, we need to invoke getRawHeight and getRawWidth to get the real dimensions.
    // Since react-native only supports API level 16+ we don't have to worry about other cases.
    //
    // Reflection exceptions are rethrown at runtime.
    //
    // See: http://stackoverflow.com/questions/14341041/how-to-get-real-screen-height-and-width/23861333#23861333
    try {
      Method mGetRawH = Display.class.getMethod("getRawHeight");
      Method mGetRawW = Display.class.getMethod("getRawWidth");
      screenDisplayMetrics.widthPixels = (Integer) mGetRawW.invoke(display);
      screenDisplayMetrics.heightPixels = (Integer) mGetRawH.invoke(display);
    } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
      throw new RuntimeException("Error getting real dimensions for API level < 17", e);
    }
  }
  DisplayMetricsHolder.setScreenDisplayMetrics(screenDisplayMetrics);
}
 

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
static DynamicGrid createDynamicGrid(Context context, DynamicGrid dynamicGrid) {
    // Determine the dynamic grid properties
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();

    Point realSize = new Point();
    display.getRealSize(realSize);
    DisplayMetrics dm = new DisplayMetrics();
    display.getMetrics(dm);

    if (dynamicGrid == null) {
        Point smallestSize = new Point();
        Point largestSize = new Point();
        display.getCurrentSizeRange(smallestSize, largestSize);

        dynamicGrid = new DynamicGrid(context,
                context.getResources(),
                Math.min(smallestSize.x, smallestSize.y),
                Math.min(largestSize.x, largestSize.y),
                realSize.x, realSize.y,
                dm.widthPixels, dm.heightPixels);
    }

    // Update the icon size
    DeviceProfile grid = dynamicGrid.getDeviceProfile();
    grid.updateFromConfiguration(context, context.getResources(),
            realSize.x, realSize.y,
            dm.widthPixels, dm.heightPixels);
    return dynamicGrid;
}
 

/**
 * 获取屏幕物理尺寸
 *
 * @return
 */
public static double getScreenDimension(Context context) {
    WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics dm = new DisplayMetrics();
    display.getMetrics(dm);

    double x = Math.pow(dm.widthPixels / dm.xdpi, 2);
    double y = Math.pow(dm.heightPixels / dm.ydpi, 2);

    DecimalFormat df = new DecimalFormat("#.##");
    return Double.parseDouble(df.format(Math.sqrt(x + y)));
}