{ .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;      }    }}

@Overridepublic 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    }}

@Overridepublic 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;  }}