Android6.0开发中屏幕旋转原理与流程分析

{ .name = “Gravity sensor”,
.vendor = “The Android Open Source Project”,
.version = 1,
.handle = SENSORS_HANDLE_BASE+ID_A,
.type = SENSOR_TYPE_ACCELEROMETER,
.maxRange = 4.0f*9.81f,
.resolution = (4.0f*9.81f)/256.0f,
.power = 0.2f,
.minDelay = 5000,
.reserved = {}
},

// Configure rotation lock.
int userRotation = Settings.System.getIntForUser(resolver,
  Settings.System.USER_ROTATION, Surface.ROTATION_0,
  UserHandle.USER_CURRENT);
if (mUserRotation != userRotation) {
    mUserRotation = userRotation;
    updateRotation = true;
}
int userRotationMode = Settings.System.getIntForUser(resolver,
  Settings.System.ACCELEROMETER_ROTATION, 0, UserHandle.USER_CURRENT) != 0 ?
      WindowManagerPolicy.USER_ROTATION_FREE :
          WindowManagerPolicy.USER_ROTATION_LOCKED;
if (mUserRotationMode != userRotationMode) {
    mUserRotationMode = userRotationMode;
    updateRotation = true;
    updateOrientationListenerLp();
}

void updateOrientationListenerLp() {
    if (!mOrientationListener.canDetectOrientation()) {
      // If sensor is turned off or nonexistent for some reason
      return;
    }
    // Could have been invoked due to screen turning on or off or
    // change of the currently visible window's orientation.
    if (localLOGV) Slog.v(TAG, "mScreenOnEarly=" + mScreenOnEarly
        + ", mAwake=" + mAwake + ", mCurrentAppOrientation=" + mCurrentAppOrientation
        + ", mOrientationSensorEnabled=" + mOrientationSensorEnabled
        + ", mKeyguardDrawComplete=" + mKeyguardDrawComplete
        + ", mWindowManagerDrawComplete=" + mWindowManagerDrawComplete);
    boolean disable = true;
    // Note: We postpone the rotating of the screen until the keyguard as well as the
    // window manager have reported a draw complete.
    if (mScreenOnEarly && mAwake &&
        mKeyguardDrawComplete && mWindowManagerDrawComplete) {
      if (needSensorRunningLp()) {
        disable = false;
        //enable listener if not already enabled
        if (!mOrientationSensorEnabled) {
          mOrientationListener.enable();
          if(localLOGV) Slog.v(TAG, "Enabling listeners");
          mOrientationSensorEnabled = true;
        }
      }
    }
    //check if sensors need to be disabled
    if (disable && mOrientationSensorEnabled) {
      mOrientationListener.disable();
      if(localLOGV) Slog.v(TAG, "Disabling listeners");
      mOrientationSensorEnabled = false;
    }
}
/**
* Enables the WindowOrientationListener so it will monitor the sensor and call
* {@link #onProposedRotationChanged(int)} when the device orientation changes.
*/
public void enable() {
    synchronized (mLock) {
      if (mSensor == null) {
        Slog.w(TAG, "Cannot detect sensors. Not enabled");
        return;
      }
      if (mEnabled == false) {
        if (LOG) {
          Slog.d(TAG, "WindowOrientationListener enabled");
        }
        mOrientationJudge.resetLocked();
        mSensorManager.registerListener(mOrientationJudge, mSensor, mRate, mHandler);
        mEnabled = true;
      }
    }
}

@Override
public void onProposedRotationChanged(int rotation) {
      if (localLOGV) Slog.v(TAG, "onProposedRotationChanged, rotation=" + rotation);
      mHandler.post(mUpdateRotationRunnable);
}
private final Runnable mUpdateRotationRunnable = new Runnable() {
      @Override
      public void run() {
        // send interaction hint to improve redraw performance
        mPowerManagerInternal.powerHint(PowerManagerInternal.POWER_HINT_INTERACTION, 0);
        updateRotation(false);
      }
};
void updateRotation(boolean alwaysSendConfiguration) {
    try {
      //set orientation on WindowManager
      mWindowManager.updateRotation(alwaysSendConfiguration, false);
    } catch (RemoteException e) {
      // Ignore
    }
}

@Override
public void updateRotation(boolean alwaysSendConfiguration, boolean forceRelayout) {
    updateRotationUnchecked(alwaysSendConfiguration, forceRelayout);
}
public void updateRotationUnchecked(boolean alwaysSendConfiguration, boolean forceRelayout) {
    if(DEBUG_ORIENTATION) Slog.v(TAG, "updateRotationUnchecked("
          + "alwaysSendConfiguration=" + alwaysSendConfiguration + ")");
    long origId = Binder.clearCallingIdentity();
    boolean changed;
    synchronized(mWindowMap) {
      changed = updateRotationUncheckedLocked(false);
      if (!changed || forceRelayout) {
        getDefaultDisplayContentLocked().layoutNeeded = true;
        performLayoutAndPlaceSurfacesLocked();
      }
    }
    if (changed || alwaysSendConfiguration) {
      sendNewConfiguration();
    }
    Binder.restoreCallingIdentity(origId);
}
// TODO(multidisplay): Rotate any display?
/**
* Updates the current rotation.
*
* Returns true if the rotation has been changed. In this case YOU
* MUST CALL sendNewConfiguration() TO UNFREEZE THE SCREEN.
*/
public boolean updateRotationUncheckedLocked(boolean inTransaction) {
    if (mDeferredRotationPauseCount > 0) {
      // Rotation updates have been paused temporarily. Defer the update until
      // updates have been resumed.
      if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, rotation is paused.");
      return false;
    }
    ScreenRotationAnimation screenRotationAnimation =
        mAnimator.getScreenRotationAnimationLocked(Display.DEFAULT_DISPLAY);
    if (screenRotationAnimation != null && screenRotationAnimation.isAnimating()) {
      // Rotation updates cannot be performed while the previous rotation change
      // animation is still in progress. Skip this update. We will try updating
      // again after the animation is finished and the display is unfrozen.
      if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, animation in progress.");
      return false;
    }
    if (!mDisplayEnabled) {
      // No point choosing a rotation if the display is not enabled.
      if (DEBUG_ORIENTATION) Slog.v(TAG, "Deferring rotation, display is not enabled.");
      return false;
    }
    // TODO: Implement forced rotation changes.
    //    Set mAltOrientation to indicate that the application is receiving
    //    an orientation that has different metrics than it expected.
    //    eg. Portrait instead of Landscape.
    int rotation = mPolicy.rotationForOrientationLw(mForcedAppOrientation, mRotation);
    boolean altOrientation = !mPolicy.rotationHasCompatibleMetricsLw(
        mForcedAppOrientation, rotation);
    if (DEBUG_ORIENTATION) {
      Slog.v(TAG, "Application requested orientation "
          + mForcedAppOrientation + ", got rotation " + rotation
          + " which has " + (altOrientation ? "incompatible" : "compatible")
          + " metrics");
    }
    if (mRotateOnBoot) {
       mRotation = Surface.ROTATION_0;
       rotation = Surface.ROTATION_90;
    }
    /* display portrait, force android rotation according to 90 */
    if("true".equals(SystemProperties.get("persist.display.portrait","false"))){
       rotation = Surface.ROTATION_90;
    }
    /* display portrait end */
    // if("vr".equals(SystemProperties.get("ro.target.product","tablet")))
     // rotation = Surface.ROTATION_0;
    if (mRotation == rotation && mAltOrientation == altOrientation) {
      // No change.
      return false;
    }
    resetWindowState();
    if (DEBUG_ORIENTATION) {
      Slog.v(TAG,
        "Rotation changed to " + rotation + (altOrientation ? " (alt)" : "")
        + " from " + mRotation + (mAltOrientation ? " (alt)" : "")
        + ", forceApp=" + mForcedAppOrientation);
    }
    mRotation = rotation;
    mAltOrientation = altOrientation;
    mPolicy.setRotationLw(mRotation);
    ThumbModeHelper.getInstance().setRotation(mRotation);
    mWindowsFreezingScreen = WINDOWS_FREEZING_SCREENS_ACTIVE;
    mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT);
    if (mFirstRotate) {
      mH.sendEmptyMessageDelayed(H.WINDOW_FREEZE_TIMEOUT, 5000);
      mFirstRotate = false;
    } else {
      mH.sendEmptyMessageDelayed(H.WINDOW_FREEZE_TIMEOUT,         WINDOW_FREEZE_TIMEOUT_DURATION);
    }
    mWaitingForConfig = true;
    final DisplayContent displayContent = getDefaultDisplayContentLocked();
    displayContent.layoutNeeded = true;
    final int[] anim = new int[2];
    if (displayContent.isDimming()) {
      anim[0] = anim[1] = 0;
    } else {
      mPolicy.selectRotationAnimationLw(anim);
    }
    startFreezingDisplayLocked(inTransaction, anim[0], anim[1]);
    // startFreezingDisplayLocked can reset the ScreenRotationAnimation.
    screenRotationAnimation =
        mAnimator.getScreenRotationAnimationLocked(Display.DEFAULT_DISPLAY);
    boolean isDelay = true;
    /*(("true".equals(SystemProperties.get("ro.config.low_ram", "false")))
    ||("true".equals(SystemProperties.get("ro.mem_optimise.enable", "false"))))
    && (!"true".equals(SystemProperties.get("sys.cts_gts.status", "false")));*/
    if (mRotateOnBoot) {
      try {
        IBinder surfaceFlinger = ServiceManager.getService("SurfaceFlinger");
        if (surfaceFlinger != null) {
          Slog.i(TAG, "******* TELLING SURFACE FLINGER WE ARE BOOTED !!!!!");
          Parcel data = Parcel.obtain();
          data.writeInterfaceToken("android.ui.ISurfaceComposer");
          surfaceFlinger.transact(IBinder.FIRST_CALL_TRANSACTION,
                      data, null, 0);
          data.recycle();
        }
      } catch (RemoteException ex) {
        Slog.e(TAG, "Boot completed: SurfaceFlinger is dead!");
      }
    }
    // We need to update our screen size information to match the new rotation. If the rotation
    // has actually changed then this method will return true and, according to the comment at
    // the top of the method, the caller is obligated to call computeNewConfigurationLocked().
    // By updating the Display info here it will be available to
    // computeScreenConfigurationLocked later.
    updateDisplayAndOrientationLocked();
    final DisplayInfo displayInfo = displayContent.getDisplayInfo();
    if (!inTransaction) {
      if (SHOW_TRANSACTIONS) {
        Slog.i(TAG, ">>> OPEN TRANSACTION setRotationUnchecked");
      }
      SurfaceControl.openTransaction();
    }
    try {
      // NOTE: We disable the rotation in the emulator because
      //    it doesn't support hardware OpenGL emulation yet.
      if (CUSTOM_SCREEN_ROTATION && screenRotationAnimation != null
          && screenRotationAnimation.hasScreenshot()) {
        if (screenRotationAnimation.setRotationInTransaction(
            rotation, mFxSession,
            MAX_ANIMATION_DURATION, getTransitionAnimationScaleLocked(),
            displayInfo.logicalWidth, displayInfo.logicalHeight)) {
          scheduleAnimationLocked();
        }
      }
      mDisplayManagerInternal.performTraversalInTransactionFromWindowManager();
    } finally {
      if (!inTransaction) {
        SurfaceControl.closeTransaction();
        if (SHOW_LIGHT_TRANSACTIONS) {
          Slog.i(TAG, "<<< CLOSE TRANSACTION setRotationUnchecked");
        }
      }
    }
    final WindowList windows = displayContent.getWindowList();
    for (int i = windows.size() - 1; i >= 0; i--) {
      WindowState w = windows.get(i);
      if (w.mHasSurface) {
        if (DEBUG_ORIENTATION) Slog.v(TAG, "Set mOrientationChanging of " + w);
        w.mOrientationChanging = true;
        mInnerFields.mOrientationChangeComplete = false;
      }
      w.mLastFreezeDuration = 0;
    }
    for (int i=mRotationWatchers.size()-1; i>=0; i--) {
      try {
        mRotationWatchers.get(i).watcher.onRotationChanged(rotation);
      } catch (RemoteException e) {
      }
    }
    //TODO (multidisplay): Magnification is supported only for the default display.
    // Announce rotation only if we will not animate as we already have the
    // windows in final state. Otherwise, we make this call at the rotation`这里写代码片` end.
    if (screenRotationAnimation == null && mAccessibilityController != null
        && displayContent.getDisplayId() == Display.DEFAULT_DISPLAY) {
      mAccessibilityController.onRotationChangedLocked(getDefaultDisplayContentLocked(),
          rotation);
    }
    return true;
}

package com.gwtsz.gts2.util;
import android.content.Context;
import android.provider.Settings;
import android.provider.Settings.SettingNotFoundException;
/**
 * 重力感应器开关
 * 围绕手机屏幕旋转的设置功能编写的方法
 * @author Wilson
 */
public class SensorUtil {
  /**
   * 打开重力感应，即设置屏幕可旋转
   * @param context
   */
  public static void openSensor(Context context){
    Settings.System.putInt(context.getContentResolver(),Settings.System.ACCELEROMETER_ROTATION, 1);
  }
  /**
   * 关闭重力感应，即设置屏幕不可旋转
   * @param context
   */
  public static void closeSensor(Context context){
    Settings.System.putInt(context.getContentResolver(),Settings.System.ACCELEROMETER_ROTATION, 0);
  }
  /**
   * 获取屏幕旋转功能开启状态
   * @param context
   * @return
   */
  public static int getSensorState(Context context){
    int sensorState = 0;
    try {
      sensorState = Settings.System.getInt(context.getContentResolver(), Settings.System.ACCELEROMETER_ROTATION);
      return sensorState;
    } catch (SettingNotFoundException e) {
      e.printStackTrace();
    }
    return sensorState;
  }
  /**
   * 判断屏幕旋转功能是否开启
   */
  public static boolean isOpenSensor(Context context){
    boolean isOpen = false;
    if(getSensorState(context) == 1){
      isOpen = true;
    }else if(getSensorState(context) == 0){
      isOpen = false;
    }
    return isOpen;
  }
}