PowerManagerService.java

package com.android.server;

import android.app.ActivityManager;
import android.app.ActivityManager.RunningTaskInfo;
import android.app.ActivityManagerNative;
import android.app.AlarmManager;
import android.app.IActivityManager;
import android.app.PendingIntent;
import android.app.admin.DevicePolicyManager;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.ContentQueryMap;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Resources;
import android.database.ContentObserver;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.net.LocalSocket;
import android.net.LocalSocketAddress;
import android.net.LocalSocketAddress.Namespace;
import android.os.Binder;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.IBinder.DeathRecipient;
import android.os.IPowerManager.Stub;
import android.os.LocalPowerManager;
import android.os.Message;
import android.os.Process;
import android.os.RemoteException;
import android.os.SystemClock;
import android.os.SystemProperties;
import android.os.WorkSource;
import android.provider.Settings.Secure;
import android.provider.Settings.System;
import android.util.EventLog;
import android.util.Log;
import android.util.Slog;
import android.view.WindowManagerPolicy;
import android.view.WindowManagerPolicy.ScreenOnListener;
import com.android.internal.app.IBatteryStats;
import com.android.server.am.BatteryStatsService;
import com.android.server.pm.ShutdownThread;
import com.sec.android.app.CscFeature;
import com.sec.android.facedetection.FaceDetectionManager;
import com.sec.android.facedetection.SecFace;
import java.io.FileDescriptor;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PowerManagerService extends IPowerManager.Stub
  implements LocalPowerManager, Watchdog.Monitor
{
  private static final String ACTION_AUTO_POWER_OFF = "com.android.server.PowerManagerService.action.AUTO_POWER_OFF";
  private static final String ACTION_BROADCAST_BEFORE_DIM = "com.android.server.PowerManagerService.action.FAILED_TO_DETECT_FACE_BEFORE_DIM";
  private static final String ACTION_PROXIMITY_CP = "android.intent.action.PROXIMITY_CP";
  private static final int ALL_BRIGHT = 15;
  private static final int ALL_LIGHTS_OFF = 0;
  private static final int ANIM_SETTING_OFF = 16;
  private static final int ANIM_SETTING_ON = 1;
  static final int ANIM_STEPS = 10;
  static final int AUTOBRIGHTNESS_ANIM_STEPS = 20;
  static final int AUTODIMNESS_ANIM_STEPS = 1342177;
  private static final int AUTO_POWER_OFF_REQUEST = 0;
  private static final int BATTERY_LOW_BIT = 16;
  private static final int BUTTON_BRIGHT_BIT = 4;
  private static final String CABL_TAG = "PMSCabl";
  private static final String DAEMON_SOCKET = "pps";
  static final boolean DEBUG_SCREEN_ON = false;
  private static final int DEFAULT_SCREEN_BRIGHTNESS = 192;
  private static final int DEFAULT_SCREEN_OFF_TIMEOUT = 15000;
  private static final String EXTRA_PROXIMITY_CP = "cmd";
  private static final int FULL_WAKE_LOCK_ID = 2;
  static final int IMMEDIATE_ANIM_STEPS = 4;
  static final int INITIAL_BUTTON_BRIGHTNESS = 0;
  static final int INITIAL_KEYBOARD_BRIGHTNESS = 0;
  static final int INITIAL_SCREEN_BRIGHTNESS = 255;
  public static final String IS_VISIBLE_WINDOW = "AxT9IME.isVisibleWindow";
  private static final int KEYBOARD_BRIGHT_BIT = 8;
  private static final int LIGHTS_MASK = 14;
  private static final int LIGHT_SENSOR_DELAY = 3000;
  private static final int LIGHT_SENSOR_OFFSET_SCALE = 8;
  private static final int LIGHT_SENSOR_RANGE_EXPANSION = 20;
  private static final int LIGHT_SENSOR_RATE = 1000000;
  private static final int LOCK_MASK = 63;
  private static final boolean LOG_PARTIAL_WL = true;
  private static final boolean LOG_TOUCH_DOWNS = true;
  private static final int LONG_DIM_TIME = 7000;
  private static final int LONG_KEYLIGHT_DELAY = 6000;
  private static final int LOW_BATTERY_THRESHOLD = 5;
  private static final int MAX_CMD_LEN = 100;
  private static final int MEDIUM_KEYLIGHT_DELAY = 15000;
  private static final int NOMINAL_FRAME_TIME_MS = 16;
  static final String PARTIAL_NAME = "PowerManagerService";
  private static final int PARTIAL_WAKE_LOCK_ID = 1;
  static int POWERSAVEMODE_BRIGHTNESS_OFFSET = 0;
  private static final int PROXIMITY_SENSOR_DELAY = 1000;
  private static final float PROXIMITY_THRESHOLD = 5.0F;
  public static final String RESPONSE_AXT9INFO = "ResponseAxT9Info";
  private static final int SAMSUNG_PHONECALL_DIM_DELAY = 4000;
  private static final int SAMSUNG_PHONECALL_KEYLIGHT_DELAY = 6000;
  private static final int SAMSUNG_PHONECALL_SCREENOFF_DELAY = 20000;
  private static final int SCREEN_BRIGHT = 3;
  private static final int SCREEN_BRIGHT_BIT = 2;
  private static final int SCREEN_BUTTON_BRIGHT = 7;
  private static final int SCREEN_DIM = 1;
  private static final int SCREEN_KEYBOARD_BRIGHT = 11;
  private static final int SCREEN_OFF = 0;
  private static final int SCREEN_ON_BIT = 1;
  private static final int SHORT_KEYLIGHT_DELAY_DEFAULT = 6000;
  private static final String TAG = "PowerManagerService";
  private static LocalSocket daemonSock;
  private static InputStream in;
  private static boolean isCabcDaemonConnected = false;
  private static boolean isCabcDaemonOff = false;
  private static final boolean mAutoBrightnessWithTiltEnabled = true;
  private static final boolean mDebugDVFSLock = false;
  private static final boolean mDebugLightAnimation = false;
  private static final boolean mDebugLightSensor = true;
  private static final boolean mDebugProximitySensor = true;
  private static FaceDetectionManager mFaceDetectionManager = null;
  private static final boolean mIsNorthAmericaSalesCode;
  private static final String mSalesCode = SystemProperties.get("ro.csc.sales_code", "NONE").trim().toUpperCase();
  private static final boolean mSpew;
  private static String mStrAutoBrightnessHysteresisLevels;
  private static String mStrAutoBrightnessLevels;
  private static String mStrBrightnessValuePoints;
  private static String mStrHighHysteresisPoints;
  private static String mStrLcdBacklightValues;
  private static String mStrLowHysteresisPoints;
  private static String mStrMinimumExpressiveBrightnessValues;
  private static OutputStream out;
  private final int MY_PID;
  private final int MY_UID;
  private UnsynchronizedDVFSLock mAMOLEDAnimationDVFSLock = null;
  private IActivityManager mActivityService;
  private AlarmManager mAlarmManager;
  boolean mAnimateScreenLights = true;
  private int mAnimationSetting = 16;
  private LightsService.Light mAttentionLight;
  private boolean mAutoBrightessEnabled;
  private int[] mAutoBrightnessHysteresisLevels = null;
  private int[] mAutoBrightnessLevels;
  private Runnable mAutoBrightnessTask = new Runnable()
  {
    public void run()
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        if ((PowerManagerService.this.mLightSensorPendingDecrease) || (PowerManagerService.this.mLightSensorPendingIncrease))
        {
          int i = (int)PowerManagerService.this.mLightSensorPendingValue;
          PowerManagerService.access$9202(PowerManagerService.this, false);
          PowerManagerService.access$9302(PowerManagerService.this, false);
          PowerManagerService.this.lightSensorChangedLocked(i, false);
        }
        return;
      }
    }
  };
  private final int mAutoPowerOffDelay = 1000;
  private UnsynchronizedWakeLock mAutoPowerOffPartialLock;
  private PendingIntent mAutoPowerOffPendingIntent;
  private long mAutoPowerOffTimeMillis = 0L;
  private int mAutoPowerOffTimeoutSetting = -1;
  private BatteryService mBatteryService;
  private IBatteryStats mBatteryStats;
  private boolean mBoolProximityCP = false;
  private boolean mBootCompleted = false;
  private int[] mBrightnessLevels;
  private double[] mBrightnessValueSlope;
  private int[] mBrightnessValues;
  private int[] mBrightnessValuesOrg;
  private final int[] mBroadcastQueue = { -1, -1, -1 };
  private UnsynchronizedWakeLock mBroadcastWakeLock;
  private final int[] mBroadcastWhy = new int[3];
  private int[] mButtonBacklightValues;
  private int mButtonBrightnessOverride = -1;
  private LightsService.Light mButtonLight;
  private int mButtonOffTimeoutSetting;
  private Runnable mCablTask = new Runnable()
  {
    public void run()
    {
      if (PowerManagerService.this.mIsTablet);
    }
  };
  private Context mContext;
  private DVFSLock mCurrentDVFSMaxLock = null;
  private DVFSLock mCurrentDVFSMinLock = null;
  private DevicePolicyManager mDPM = null;
  private final DVFSLockList mDVFSLocks = new DVFSLockList(null);
  private int mDeviceLockTimeoutSetting = -1;
  private int mDimDelay;
  private boolean mDimScreen = true;
  private boolean mDoneBooting = false;
  private boolean mDynamicAutoBrightnessEnabled = false;
  private float mDynamicAutoBrightnessRatio = 0.0F;
  private int mDynamicAutoBrightnessRatioValueSetting = -1;
  private int mDynamicAutoBrightnessValue = 255;
  private boolean mFaceDetected = false;
  private boolean mForceDisableWakeLock = false;
  private Runnable mForceReenableScreenTask = new Runnable()
  {
    public void run()
    {
      PowerManagerService.this.forceReenableScreen();
    }
  };
  private Handler mHandler;
  private HandlerThread mHandlerThread;
  private boolean mHeadless = false;
  private int[] mHighHysteresisLevels;
  private int mHighHysteresisLux = -1;
  private double[] mHighHysteresisSlope;
  private int[] mHighHysteresisValues;
  private int[] mHighHysteresisValuesOrg;
  private int mHighestLightSensorValue = -1;
  private volatile boolean mInitComplete = false;
  private boolean mInitialAnimation = true;
  private boolean mInitialized = false;
  private boolean mIsDeviceLockTime = false;
  private boolean mIsDocked = false;
  boolean mIsFakeOff = false;
  private boolean mIsLockZone = false;
  private boolean mIsPowered = false;
  private int mIsSecuredLock = 0;
  public boolean mIsSipVisible = false;
  private boolean mIsTablet = false;
  private int[] mKeyboardBacklightValues;
  private LightsService.Light mKeyboardLight;
  private boolean mKeyboardVisible = false;
  private int mKeylightDelay;
  private int mLastAutoBrightnessLevel = -1;
  private long mLastEventTime = 0L;
  private long mLastProximityEventTime;
  private long mLastScreenOnTime;
  private long mLastTouchDown;
  private int[] mLcdBacklightValues;
  private LightsService.Light mLcdLight;
  SensorEventListener mLightListener = new SensorEventListener()
  {
    public void onAccuracyChanged(Sensor paramAnonymousSensor, int paramAnonymousInt)
    {
    }

    public void onSensorChanged(SensorEvent paramAnonymousSensorEvent)
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        if (PowerManagerService.this.isScreenTurningOffLocked())
        {
          Slog.d("PowerManagerService", "Light onSensorChanged : return, isScreenTurningOffLocked : " + PowerManagerService.this.isScreenTurningOffLocked());
          return;
        }
        PowerManagerService.this.handleLightSensorValue((int)paramAnonymousSensorEvent.values[0], PowerManagerService.this.mWaitingForFirstLightSensor);
        if ((PowerManagerService.this.mWaitingForFirstLightSensor) && (!PowerManagerService.this.mPreparingForScreenOn))
          PowerManagerService.access$10302(PowerManagerService.this, false);
        return;
      }
    }
  };
  private Sensor mLightSensor;
  private float mLightSensorAdjustSetting = 0.0F;
  private int mLightSensorButtonBrightness = -1;
  private boolean mLightSensorEnabled;
  private int mLightSensorKeyboardBrightness = -1;
  private boolean mLightSensorPendingDecrease = false;
  private boolean mLightSensorPendingIncrease = false;
  private float mLightSensorPendingValue = -1.0F;
  private int mLightSensorScreenBrightness = -1;
  private int mLightSensorScreenBrightnessLowerLimit = -1;
  private int mLightSensorScreenBrightnessUpperLimit = -1;
  private float mLightSensorValue = -1.0F;
  private int mLightSensorWarmupTime;
  private LightsService mLightsService;
  private final LockList mLocks = new LockList(null);
  private int[] mLowHysteresisLevels;
  private int mLowHysteresisLux = -1;
  private double[] mLowHysteresisSlope;
  private int[] mLowHysteresisValues;
  private int[] mLowHysteresisValuesOrg;
  private int mLowLimitAtHighestAutoBrightnessLevel = 250;
  private final HashMap<Integer, IBinder> mMapPersistentDVFSLock = new HashMap();
  private final HashMap<Integer, Integer> mMapPreventAutoPowerOff = new HashMap();
  private int mMaxBrightness = -1;
  private int mMaximumScreenOffTimeout = 2147483647;
  private int[] mMinimumExpressiveBrightnessValues;
  private long mNextTimeout;
  private Runnable mNotificationTask = new Runnable()
  {
    public void run()
    {
      while (true)
      {
        int i;
        int j;
        WindowManagerPolicy localWindowManagerPolicy;
        synchronized (PowerManagerService.this.mLocks)
        {
          i = PowerManagerService.this.mBroadcastQueue[0];
          j = PowerManagerService.this.mBroadcastWhy[0];
          int k = 0;
          if (k < 2)
          {
            PowerManagerService.this.mBroadcastQueue[k] = PowerManagerService.this.mBroadcastQueue[(k + 1)];
            PowerManagerService.this.mBroadcastWhy[k] = PowerManagerService.this.mBroadcastWhy[(k + 1)];
            k++;
            continue;
          }
          localWindowManagerPolicy = PowerManagerService.this.getPolicyLocked();
          if ((i == 1) && (!PowerManagerService.this.mPreparingForScreenOn))
          {
            PowerManagerService.access$5802(PowerManagerService.this, true);
            PowerManagerService.this.mBroadcastWakeLock.acquire();
            EventLog.writeEvent(2725, PowerManagerService.this.mBroadcastWakeLock.mCount);
          }
          if (i == 1)
          {
            PowerManagerService.this.mScreenOnStart = SystemClock.uptimeMillis();
            Slog.d("PowerManagerService", "mNotificationTask : on");
            localWindowManagerPolicy.screenTurningOn(PowerManagerService.this.mScreenOnListener);
          }
        }
        try
        {
          ActivityManagerNative.getDefault().wakingUp();
          label197: if ((PowerManagerService.this.mContext != null) && (ActivityManagerNative.isSystemReady()))
          {
            PowerManagerService.this.mContext.sendOrderedBroadcast(PowerManagerService.this.mScreenOnIntent, null, PowerManagerService.this.mScreenOnBroadcastDone, PowerManagerService.this.mHandler, 0, null, null);
            continue;
            localObject1 = finally;
            throw localObject1;
          }
          synchronized (PowerManagerService.this.mLocks)
          {
            Object[] arrayOfObject2 = new Object[2];
            arrayOfObject2[0] = Integer.valueOf(2);
            arrayOfObject2[1] = Integer.valueOf(PowerManagerService.this.mBroadcastWakeLock.mCount);
            EventLog.writeEvent(2727, arrayOfObject2);
            PowerManagerService.this.mBroadcastWakeLock.release();
          }
          if (i == 0)
          {
            PowerManagerService.this.mScreenOffStart = SystemClock.uptimeMillis();
            Slog.d("PowerManagerService", "mNotificationTask : off");
            localWindowManagerPolicy.screenTurnedOff(j);
          }
          try
          {
            ActivityManagerNative.getDefault().goingToSleep();
            label371: if ((PowerManagerService.this.mContext != null) && (ActivityManagerNative.isSystemReady()))
            {
              PowerManagerService.this.mContext.sendOrderedBroadcast(PowerManagerService.this.mScreenOffIntent, null, PowerManagerService.this.mScreenOffBroadcastDone, PowerManagerService.this.mHandler, 0, null, null);
              continue;
            }
            synchronized (PowerManagerService.this.mLocks)
            {
              Object[] arrayOfObject1 = new Object[2];
              arrayOfObject1[0] = Integer.valueOf(3);
              arrayOfObject1[1] = Integer.valueOf(PowerManagerService.this.mBroadcastWakeLock.mCount);
              EventLog.writeEvent(2727, arrayOfObject1);
              PowerManagerService.this.updateLightsLocked(PowerManagerService.this.mPowerState, 1);
              PowerManagerService.this.mBroadcastWakeLock.release();
            }
            return;
          }
          catch (RemoteException localRemoteException1)
          {
            break label371;
          }
        }
        catch (RemoteException localRemoteException2)
        {
          break label197;
        }
      }
    }
  };
  private HashMap<String, ArrayList<Pattern>> mPackagesNeedIS = new HashMap();
  private int mPartialCount = 0;
  private volatile int mPersistentDVFSLocksInfo = 0;
  private volatile boolean mPokeAwakeOnSet = false;
  private final HashMap<IBinder, PokeLock> mPokeLocks = new HashMap();
  private volatile int mPokey = 0;
  private volatile WindowManagerPolicy mPolicy;
  private boolean mPowerIsChanged = false;
  private int mPowerState;
  private boolean mPreparingForScreenOn = false;
  private boolean mPreventScreenOn;
  private UnsynchronizedWakeLock mPreventScreenOnPartialLock;
  private boolean mProxIgnoredBecauseScreenTurnedOff = false;
  SensorEventListener mProximityListener = new SensorEventListener()
  {
    public void onAccuracyChanged(Sensor paramAnonymousSensor, int paramAnonymousInt)
    {
    }

    public void onSensorChanged(SensorEvent paramAnonymousSensorEvent)
    {
      long l1 = SystemClock.elapsedRealtime();
      while (true)
      {
        boolean bool1;
        int i;
        int j;
        boolean bool2;
        synchronized (PowerManagerService.this.mLocks)
        {
          float f = paramAnonymousSensorEvent.values[0];
          long l2 = l1 - PowerManagerService.this.mLastProximityEventTime;
          PowerManagerService.access$10002(PowerManagerService.this, l1);
          PowerManagerService.this.mHandler.removeCallbacks(PowerManagerService.this.mProximityTask);
          if ((f < 0.0D) || (f >= 5.0F) || (f >= PowerManagerService.this.mProximitySensor.getMaximumRange()))
            break label271;
          bool1 = true;
          Slog.d("PowerManagerService", "mProximityListener.onSensorChanged active: " + bool1);
          if (l2 < 1000L)
          {
            PowerManagerService localPowerManagerService = PowerManagerService.this;
            if (!bool1)
              break label277;
            i = 1;
            PowerManagerService.access$8902(localPowerManagerService, i);
            PowerManagerService.this.mHandler.postDelayed(PowerManagerService.this.mProximityTask, 1000L - l2);
            j = 1;
            bool2 = PowerManagerService.this.mProximityPartialLock.isHeld();
            if ((!bool2) && (j != 0))
              PowerManagerService.this.mProximityPartialLock.acquire();
          }
          else
          {
            PowerManagerService.access$8902(PowerManagerService.this, -1);
            PowerManagerService.this.proximityChangedLocked(bool1);
            j = 0;
          }
        }
        if ((bool2) && (j == 0))
        {
          PowerManagerService.this.mProximityPartialLock.release();
          continue;
          label271: bool1 = false;
          continue;
          label277: i = 0;
        }
      }
    }
  };
  SensorEventListener mProximityListenerForDataCall = new SensorEventListener()
  {
    public void onAccuracyChanged(Sensor paramAnonymousSensor, int paramAnonymousInt)
    {
    }

    public void onSensorChanged(SensorEvent paramAnonymousSensorEvent)
    {
    }
  };
  private UnsynchronizedWakeLock mProximityPartialLock;
  private int mProximityPendingValue = -1;
  private Sensor mProximitySensor;
  private boolean mProximitySensorActive = false;
  private boolean mProximitySensorEnabled = false;
  private Runnable mProximityTask = new Runnable()
  {
    public void run()
    {
      int j;
      for (int i = 1; ; j = 0)
        synchronized (PowerManagerService.this.mLocks)
        {
          if (PowerManagerService.this.mProximityPendingValue != -1)
          {
            PowerManagerService localPowerManagerService = PowerManagerService.this;
            if (PowerManagerService.this.mProximityPendingValue == i)
            {
              localPowerManagerService.proximityChangedLocked(i);
              PowerManagerService.access$8902(PowerManagerService.this, -1);
            }
          }
          else
          {
            if (PowerManagerService.this.mProximityPartialLock.isHeld())
              PowerManagerService.this.mProximityPartialLock.release();
            return;
          }
        }
    }
  };
  private int mProximityWakeLockCount = 0;
  private ScreenBrightnessAnimator mScreenBrightnessAnimator;
  private int mScreenBrightnessDim;
  private Handler mScreenBrightnessHandler;
  private int mScreenBrightnessOverride = -1;
  private int mScreenBrightnessSetting = 192;
  private BroadcastReceiver mScreenOffBroadcastDone = new BroadcastReceiver()
  {
    public void onReceive(Context paramAnonymousContext, Intent paramAnonymousIntent)
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        Object[] arrayOfObject = new Object[3];
        arrayOfObject[0] = Integer.valueOf(0);
        arrayOfObject[1] = Long.valueOf(SystemClock.uptimeMillis() - PowerManagerService.this.mScreenOffStart);
        arrayOfObject[2] = Integer.valueOf(PowerManagerService.this.mBroadcastWakeLock.mCount);
        EventLog.writeEvent(2726, arrayOfObject);
        PowerManagerService.this.mBroadcastWakeLock.release();
        return;
      }
    }
  };
  private int mScreenOffDelay;
  private Handler mScreenOffHandler;
  private Intent mScreenOffIntent;
  private int mScreenOffReason;
  long mScreenOffStart;
  private long mScreenOffTime;
  private int mScreenOffTimeoutSetting;
  private BroadcastReceiver mScreenOnBroadcastDone = new BroadcastReceiver()
  {
    public void onReceive(Context paramAnonymousContext, Intent paramAnonymousIntent)
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        Object[] arrayOfObject = new Object[3];
        arrayOfObject[0] = Integer.valueOf(1);
        arrayOfObject[1] = Long.valueOf(SystemClock.uptimeMillis() - PowerManagerService.this.mScreenOnStart);
        arrayOfObject[2] = Integer.valueOf(PowerManagerService.this.mBroadcastWakeLock.mCount);
        EventLog.writeEvent(2726, arrayOfObject);
        PowerManagerService.this.mBroadcastWakeLock.release();
        return;
      }
    }
  };
  private Intent mScreenOnIntent;
  private WindowManagerPolicy.ScreenOnListener mScreenOnListener = new WindowManagerPolicy.ScreenOnListener()
  {
    public void onScreenOn()
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        if (PowerManagerService.this.mPreparingForScreenOn)
        {
          PowerManagerService.access$5802(PowerManagerService.this, false);
          PowerManagerService.this.updateLightsLocked(PowerManagerService.this.mPowerState, 1);
          Object[] arrayOfObject = new Object[2];
          arrayOfObject[0] = Integer.valueOf(4);
          arrayOfObject[1] = Integer.valueOf(PowerManagerService.this.mBroadcastWakeLock.mCount);
          EventLog.writeEvent(2727, arrayOfObject);
          PowerManagerService.this.mBroadcastWakeLock.release();
        }
        return;
      }
    }
  };
  long mScreenOnStart;
  private SensorManager mSensorManager;
  private ContentQueryMap mSettings;
  private int mShortKeylightDelay = 6000;
  private float mSignedSettingsRatio = 0.0F;
  private BroadcastReceiver mSipIntentReceiver = new BroadcastReceiver()
  {
    public void onReceive(Context paramAnonymousContext, Intent paramAnonymousIntent)
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        if ("ResponseAxT9Info".equals(paramAnonymousIntent.getAction()))
        {
          PowerManagerService.this.mIsSipVisible = paramAnonymousIntent.getBooleanExtra("AxT9IME.isVisibleWindow", false);
          Slog.d("PowerManagerService", "mIsSipVisible : " + PowerManagerService.this.mIsSipVisible);
        }
        return;
      }
    }
  };
  private boolean mSkippedScreenOn = false;
  private int mSmartSleepDelay = 2000;
  private boolean mSmartSleepEnabled = false;
  private Handler mSmartSleepHandler;
  private Intent mSmartSleepIntent;
  private int mSmartSleepNotificationDelay = 6000;
  private int mSmartSleepNotificationOffset = 4000;
  private final SmartSleepNotificationTask mSmartSleepNotificationTask = new SmartSleepNotificationTask(null);
  private final SmartSleepTask mSmartSleepTask = new SmartSleepTask(null);
  private HandlerThread mSmartSleepThread;
  private int mStayOnConditions = 0;
  private UnsynchronizedWakeLock mStayOnWhilePluggedInPartialLock;
  private UnsynchronizedWakeLock mStayOnWhilePluggedInScreenDimLock;
  private boolean mStillNeedSleepNotification;
  private int[] mSupportedFrequency = null;
  private boolean mSystemPowerSaveModeEnabled = false;
  private float mTiltAngle = -1.0F;
  SensorEventListener mTiltListener = new SensorEventListener()
  {
    private static final int ACCELERATING_TIME_CONSTANT_MS = 2000;
    private static final float MAX_DEVIATION_FROM_GRAVITY = 1.5F;
    private static final float MIN_ABS_ACCELERATION = 1.5F;
    private static final float RADIANS_TO_DEGREES = 57.29578F;
    private static final int SAMPLING_PERIOD_MS = 200;
    private int mAccelerationDistrust = 0;
    private int mCnt = 5;
    private int mTiltDistrust = 0;

    private void handleAccelerationDistrust(float paramAnonymousFloat)
    {
      if (paramAnonymousFloat > 1.5F)
        if (this.mAccelerationDistrust < 5)
          this.mAccelerationDistrust = (1 + this.mAccelerationDistrust);
      while (this.mAccelerationDistrust <= 0)
        return;
      this.mAccelerationDistrust = (-1 + this.mAccelerationDistrust);
    }

    private float lowpassFilter(float paramAnonymousFloat1, float paramAnonymousFloat2, float paramAnonymousFloat3)
    {
      return paramAnonymousFloat3 * paramAnonymousFloat1 + paramAnonymousFloat2 * (1.0F - paramAnonymousFloat3);
    }

    private float tiltAngle(float paramAnonymousFloat1, float paramAnonymousFloat2)
    {
      return 57.29578F * (float)Math.asin(paramAnonymousFloat1 / paramAnonymousFloat2);
    }

    private float vectorMagnitude(float paramAnonymousFloat1, float paramAnonymousFloat2, float paramAnonymousFloat3)
    {
      return (float)Math.sqrt(paramAnonymousFloat1 * paramAnonymousFloat1 + paramAnonymousFloat2 * paramAnonymousFloat2 + paramAnonymousFloat3 * paramAnonymousFloat3);
    }

    public void onAccuracyChanged(Sensor paramAnonymousSensor, int paramAnonymousInt)
    {
    }

    public void onSensorChanged(SensorEvent paramAnonymousSensorEvent)
    {
      if (PowerManagerService.this.isScreenTurningOffLocked())
        Slog.d("PowerManagerService", "Tilt onSensorChanged : return, isScreenTurningOffLocked : " + PowerManagerService.this.isScreenTurningOffLocked());
      float f3;
      float f4;
      do
      {
        return;
        float f1 = paramAnonymousSensorEvent.values[0];
        float f2 = paramAnonymousSensorEvent.values[1];
        f3 = paramAnonymousSensorEvent.values[2];
        f4 = vectorMagnitude(f1, f2, f3);
        handleAccelerationDistrust(Math.abs(f4 - 9.80665F));
      }
      while (f4 < 1.5F);
      float f5 = 1.0F;
      if (this.mAccelerationDistrust > 0)
        f5 = 0.09090909F;
      float f6 = tiltAngle(f3, f4);
      PowerManagerService.access$10502(PowerManagerService.this, lowpassFilter(f6, PowerManagerService.this.mTiltAngle, f5));
    }
  };
  private Sensor mTiltSensor;
  private final TimeoutTask mTimeoutTask = new TimeoutTask(null);
  private long mTotalTouchDownTime;
  private int mTouchCycles;
  boolean mUnplugTurnsOnScreen;
  private Runnable mUpdateAutoPowerOffTimeTask = new Runnable()
  {
    public void run()
    {
      if (!ActivityManagerNative.isSystemReady())
        return;
      if (PowerManagerService.this.mAutoPowerOffTimeoutSetting < 0)
      {
        Slog.d("PowerManagerService", "updateAutoPowerOffTime :: mAutoPowerOffTimeoutSetting is not initialized.");
        return;
      }
      if ((PowerManagerService.this.mAutoPowerOffTimeMillis > 0L) && ((PowerManagerService.this.mIsPowered) || (PowerManagerService.this.mAutoPowerOffTimeoutSetting == 0)))
      {
        PowerManagerService.this.mAlarmManager.cancel(PowerManagerService.this.mAutoPowerOffPendingIntent);
        PowerManagerService.access$8602(PowerManagerService.this, 0L);
        Slog.d("PowerManagerService", "updateAutoPowerOffTime :: mAlarmManager is canceled. mIsPowered = " + PowerManagerService.this.mIsPowered + ". mAutoPowerOffTimeoutSetting = " + PowerManagerService.this.mAutoPowerOffTimeoutSetting);
      }
      while (true)
      {
        synchronized (PowerManagerService.this.mLocks)
        {
          if (PowerManagerService.this.mAutoPowerOffPartialLock.isHeld())
            PowerManagerService.this.mAutoPowerOffPartialLock.release();
          return;
        }
        if ((!PowerManagerService.this.mIsPowered) && (PowerManagerService.this.mAutoPowerOffTimeoutSetting > 0))
        {
          PowerManagerService.access$8602(PowerManagerService.this, -1000 + 3600000 * PowerManagerService.this.mAutoPowerOffTimeoutSetting);
          PowerManagerService.this.mAlarmManager.set(2, SystemClock.elapsedRealtime() + PowerManagerService.this.mAutoPowerOffTimeMillis, PowerManagerService.this.mAutoPowerOffPendingIntent);
          Slog.d("PowerManagerService", "updateAutoPowerOffTime :: set the Power Off Time after " + PowerManagerService.this.mAutoPowerOffTimeMillis);
        }
      }
    }
  };
  private boolean mUseSoftwareAutoBrightness;
  private boolean mUserActivityAllowed = true;
  private String mUserActivityReason = null;
  private int mUserControlLevel = 0;
  private int mUserState;
  private int mValueOfVirtualZeroCandela;
  private boolean mWaitingForFirstLightSensor = false;
  private int mWakeLockState;
  private int mWarningSpewThrottleCount;
  private long mWarningSpewThrottleTime;
  private float mWindowScaleAnimation;

  static
  {
    if (("VZW".equals(mSalesCode)) || ("ATT".equals(mSalesCode)) || ("TMB".equals(mSalesCode)) || ("SPR".equals(mSalesCode)) || ("VMU".equals(mSalesCode)) || ("MTR".equals(mSalesCode)) || ("USC".equals(mSalesCode)));
    for (boolean bool = true; ; bool = false)
    {
      mIsNorthAmericaSalesCode = bool;
      mStrLowHysteresisPoints = "mLowHysteresisPoints = ";
      mStrBrightnessValuePoints = "mBrightnessValuePoints = ";
      mStrHighHysteresisPoints = "mHighHysteresisPoints = ";
      mStrMinimumExpressiveBrightnessValues = "mMinimumExpressiveBrightnessValues = ";
      mStrAutoBrightnessLevels = "mAutoBrightnessLevels =         ";
      mStrAutoBrightnessHysteresisLevels = "mAutoBrightnessHysteresisLevels = ";
      mStrLcdBacklightValues = "mLcdBacklightValues =               ";
      in = null;
      out = null;
      daemonSock = null;
      isCabcDaemonConnected = false;
      isCabcDaemonOff = false;
      return;
    }
  }

  PowerManagerService()
  {
    long l = Binder.clearCallingIdentity();
    this.MY_UID = Process.myUid();
    this.MY_PID = Process.myPid();
    Binder.restoreCallingIdentity(l);
    this.mPowerState = 1;
    this.mUserState = 1;
    this.mIsDeviceLockTime = "DeviceLockTime".equals(CscFeature.getInstance().getString("CscFeature_Setting_ReplaceMenuLockAutoAs"));
    Watchdog.getInstance().addMonitor(this);
    nativeInit();
  }

  private static void CabcDaemonConnect()
  {
    Log.i("PMSCabl", "CabcDaemonConnect ()");
    try
    {
      daemonSock = new LocalSocket();
      LocalSocketAddress localLocalSocketAddress = new LocalSocketAddress("pps", LocalSocketAddress.Namespace.RESERVED);
      daemonSock.connect(localLocalSocketAddress);
      in = daemonSock.getInputStream();
      out = daemonSock.getOutputStream();
      if ((in != null) && (out != null))
      {
        isCabcDaemonConnected = true;
        return;
      }
      Log.i("PMSCabl", "CabcDaemonConnect () - error getting streams");
      return;
    }
    catch (IOException localIOException)
    {
      localIOException.printStackTrace();
    }
  }

  private static void CablDaemonControl(String paramString)
  {
    if ((out != null) && (in != null))
      try
      {
        Log.i("PMSCabl", "CablDaemonControl (" + paramString + ")");
        byte[] arrayOfByte1 = paramString.getBytes();
        out.write(arrayOfByte1);
        out.flush();
        byte[] arrayOfByte2 = new byte[100];
        String str = new String(arrayOfByte2, 0, in.read(arrayOfByte2, 0, arrayOfByte2.length));
        Log.i("PMSCabl", "CablDaemonControl (" + paramString + "): response = " + str);
        return;
      }
      catch (IOException localIOException)
      {
        localIOException.printStackTrace();
        return;
      }
    Log.e("PMSCabl", "CablDaemonControl: streams null");
    isCabcDaemonConnected = false;
  }

  private static String DVFSLockType(int paramInt)
  {
    switch (paramInt)
    {
    default:
      return "???                           ";
    case 1:
      return "DVFS_MIN_LIMIT";
    case 2:
    }
    return "DVFS_MAX_LIMIT";
  }

  private static boolean IsCabcDaemonConnected()
  {
    Log.i("PMSCabl", "IsCabcDaemonConnected() = " + isCabcDaemonConnected);
    return isCabcDaemonConnected;
  }

  private void acquireDVFSLockLocked(int paramInt1, int paramInt2, IBinder paramIBinder, int paramInt3, int paramInt4, String paramString)
  {
    Slog.d("PowerManagerService", "acquireDVFSLockLocked : type : " + DVFSLockType(paramInt1) + "  frequency : " + paramInt2 + "  uid : " + paramInt3 + "  pid : " + paramInt4 + "  tag : " + paramString);
    int i = this.mDVFSLocks.getIndex(paramIBinder);
    DVFSLock localDVFSLock;
    if (i < 0)
    {
      localDVFSLock = new DVFSLock(paramInt1, paramInt2, paramIBinder, paramString, paramInt3, paramInt4);
      this.mDVFSLocks.addLock(localDVFSLock);
      if (localDVFSLock.type != 2)
        break label188;
      if ((this.mCurrentDVFSMaxLock == null) || (localDVFSLock.frequency < this.mCurrentDVFSMaxLock.frequency))
      {
        nativeAcquireDVFSLock(2, localDVFSLock.frequency);
        this.mCurrentDVFSMaxLock = localDVFSLock;
      }
    }
    while (true)
    {
      localDVFSLock.acqTime = SystemClock.elapsedRealtime();
      return;
      localDVFSLock = (DVFSLock)this.mDVFSLocks.get(i);
      break;
      label188: if ((localDVFSLock.type == 1) && ((this.mCurrentDVFSMinLock == null) || (localDVFSLock.frequency > this.mCurrentDVFSMinLock.frequency)))
      {
        nativeAcquireDVFSLock(1, localDVFSLock.frequency);
        this.mCurrentDVFSMinLock = localDVFSLock;
      }
    }
  }

  private int applyButtonState(int paramInt)
  {
    int i = -1;
    if ((paramInt & 0x10) != 0)
      paramInt &= -5;
    do
    {
      return paramInt;
      if (this.mButtonBrightnessOverride >= 0)
        i = this.mButtonBrightnessOverride;
      while (i > 0)
      {
        return paramInt | 0x4;
        if ((this.mLightSensorButtonBrightness >= 0) && (this.mButtonOffTimeoutSetting == -2))
          i = this.mLightSensorButtonBrightness;
        else if (this.mButtonOffTimeoutSetting != -3)
          if (this.mButtonOffTimeoutSetting == -1)
            i = 255;
          else if (this.mButtonOffTimeoutSetting == 0)
            i = 0;
      }
    }
    while (i != 0);
    return paramInt & 0xFFFFFFFB;
  }

  private int applyKeyboardState(int paramInt)
  {
    int i = -1;
    if ((paramInt & 0x10) != 0)
      paramInt &= -9;
    do
    {
      return paramInt;
      if (!this.mKeyboardVisible)
        i = 0;
      while (i > 0)
      {
        return paramInt | 0x8;
        if (this.mButtonBrightnessOverride >= 0)
          i = this.mButtonBrightnessOverride;
        else if ((this.mLightSensorKeyboardBrightness >= 0) && (this.mButtonOffTimeoutSetting == -2))
          i = this.mLightSensorKeyboardBrightness;
        else if (this.mButtonOffTimeoutSetting != -3)
          if (this.mButtonOffTimeoutSetting == -1)
            i = 255;
          else if (this.mButtonOffTimeoutSetting == 0)
            i = 0;
      }
    }
    while (i != 0);
    return paramInt & 0xFFFFFFF7;
  }

  private boolean batteryIsLow()
  {
    return (!this.mIsPowered) && (this.mBatteryService.getBatteryLevel() <= 5);
  }

  private void cancelTimerLocked()
  {
    this.mHandler.removeCallbacks(this.mTimeoutTask);
    if (this.mAutoPowerOffPartialLock.isHeld())
    {
      this.mHandler.removeCallbacks(this.mUpdateAutoPowerOffTimeTask);
      this.mHandler.post(this.mUpdateAutoPowerOffTimeTask);
    }
    this.mTimeoutTask.nextState = -1;
  }

  private boolean checkIntelligentSleep()
  {
    Slog.d("PowerManagerService", "checkIntelligentSleep");
    if (mFaceDetectionManager == null)
    {
      Slog.e("PowerManagerService", "checkIntelligentSleep : getFaceDetectionManager()");
      mFaceDetectionManager = FaceDetectionManager.getFaceDetectionManager();
    }
    FaceDetectionManager localFaceDetectionManager = mFaceDetectionManager;
    boolean bool = false;
    if (localFaceDetectionManager != null)
    {
      mFaceDetectionManager.enable();
      SecFace[] arrayOfSecFace = mFaceDetectionManager.getFaceInfo();
      if ((arrayOfSecFace == null) || (arrayOfSecFace.length <= 0))
        break label103;
      Slog.d("PowerManagerService", "checkIntelligentSleep : SecFace length : " + arrayOfSecFace.length);
    }
    label103: for (bool = true; ; bool = false)
    {
      mFaceDetectionManager.disable();
      return bool;
    }
  }

  private boolean checkPreventAutoPowerOff()
  {
    boolean bool = false;
    int i = this.mMapPreventAutoPowerOff.size();
    for (int j = 0; j < i; j++)
    {
      int k = ((Integer)this.mMapPreventAutoPowerOff.get(Integer.valueOf(j))).intValue();
      Slog.d("PowerManagerService", "checkPreventAutoPowerOff : eachCount " + j + " : " + k);
      if (k > 0)
        bool = true;
    }
    Slog.d("PowerManagerService", "checkPreventAutoPowerOff : " + bool);
    return bool;
  }

  private float convertSettingsRatioToWeightedRatio(int paramInt)
  {
    this.mSignedSettingsRatio = (paramInt - 100);
    if (this.mSignedSettingsRatio != 0.0F)
    {
      if (this.mSignedSettingsRatio > 0.0F);
      for (int i = 1; ; i = -1)
      {
        float f = Math.abs(this.mSignedSettingsRatio / 20.0F);
        this.mUserControlLevel = ((int)(f * i));
        return (float)Math.pow(1.0F + 0.1F * i, f) - 1.0F;
      }
    }
    this.mUserControlLevel = 0;
    return 0.0F;
  }

  private void disableProximityLockLocked()
  {
    Slog.d("PowerManagerService", "disableProximityLockLocked");
    long l;
    if (this.mProximitySensorEnabled)
      l = Binder.clearCallingIdentity();
    try
    {
      this.mSensorManager.unregisterListener(this.mProximityListener);
      this.mHandler.removeCallbacks(this.mProximityTask);
      if (this.mProximityPartialLock.isHeld())
        this.mProximityPartialLock.release();
      this.mProximitySensorEnabled = false;
      Binder.restoreCallingIdentity(l);
      if (this.mProximitySensorActive)
      {
        this.mProximitySensorActive = false;
        Slog.d("PowerManagerService", "disableProximityLockLocked mProxIgnoredBecauseScreenTurnedOff=" + this.mProxIgnoredBecauseScreenTurnedOff);
        if (!this.mProxIgnoredBecauseScreenTurnedOff)
        {
          this.mUserActivityReason = "disableProximityLockLocked";
          forceUserActivityLocked();
        }
      }
      return;
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  private void dockStateChanged(int paramInt)
  {
    LockList localLockList = this.mLocks;
    boolean bool = false;
    if (paramInt != 0)
      bool = true;
    try
    {
      this.mIsDocked = bool;
      if (this.mIsDocked)
        this.mHighestLightSensorValue = -1;
      if ((0x1 & this.mPowerState) != 0)
      {
        int i = (int)this.mLightSensorValue;
        this.mLightSensorValue = -1.0F;
        lightSensorChangedLocked(i, false);
      }
      return;
    }
    finally
    {
    }
  }

  private boolean doseTopMostNeedsIntelligentSleep()
  {
    Context localContext = this.mContext;
    List localList = ((ActivityManager)localContext.getSystemService("activity")).getRunningTasks(20);
    if (localList.isEmpty())
      return false;
    ActivityManager.RunningTaskInfo localRunningTaskInfo = (ActivityManager.RunningTaskInfo)localList.get(0);
    String str1 = localRunningTaskInfo.topActivity.getPackageName();
    String str2 = localRunningTaskInfo.topActivity.getClassName();
    if (this.mPackagesNeedIS.get(str1) != null)
    {
      Iterator localIterator = ((ArrayList)this.mPackagesNeedIS.get(str1)).iterator();
      while (localIterator.hasNext())
        if (((Pattern)localIterator.next()).matcher(str2).matches())
          return true;
    }
    return false;
  }

  private static String dumpPowerState(int paramInt)
  {
    StringBuilder localStringBuilder1 = new StringBuilder();
    String str1;
    String str2;
    label36: String str3;
    label55: StringBuilder localStringBuilder4;
    if ((paramInt & 0x8) != 0)
    {
      str1 = "KEYBOARD_BRIGHT_BIT ";
      StringBuilder localStringBuilder2 = localStringBuilder1.append(str1);
      if ((paramInt & 0x2) == 0)
        break label94;
      str2 = "SCREEN_BRIGHT_BIT ";
      StringBuilder localStringBuilder3 = localStringBuilder2.append(str2);
      if ((paramInt & 0x1) == 0)
        break label102;
      str3 = "SCREEN_ON_BIT ";
      localStringBuilder4 = localStringBuilder3.append(str3);
      if ((paramInt & 0x10) == 0)
        break label110;
    }
    label94: label102: label110: for (String str4 = "BATTERY_LOW_BIT "; ; str4 = "")
    {
      return str4;
      str1 = "";
      break;
      str2 = "";
      break label36;
      str3 = "";
      break label55;
    }
  }

  private void enableLightSensorLocked(boolean paramBoolean)
  {
    Slog.d("PowerManagerService", "enableLightSensorLocked enable=" + paramBoolean + " mLightSensorEnabled=" + this.mLightSensorEnabled + " mAutoBrightessEnabled=" + this.mAutoBrightessEnabled + " mWaitingForFirstLightSensor=" + this.mWaitingForFirstLightSensor);
    if (!this.mAutoBrightessEnabled)
      paramBoolean = false;
    long l;
    if ((this.mSensorManager != null) && (this.mLightSensorEnabled != paramBoolean))
    {
      this.mLightSensorEnabled = paramBoolean;
      l = Binder.clearCallingIdentity();
      if (!paramBoolean)
        break label187;
    }
    try
    {
      this.mLastAutoBrightnessLevel = -1;
      this.mLowHysteresisLux = -1;
      this.mHighHysteresisLux = -1;
      this.mHighestLightSensorValue = -1;
      int i = (int)this.mLightSensorValue;
      if (i >= 0)
      {
        this.mLightSensorValue = -1.0F;
        handleLightSensorValue(i, true);
      }
      this.mSensorManager.registerListener(this.mLightListener, this.mLightSensor, 3);
      this.mSensorManager.registerListener(this.mTiltListener, this.mTiltSensor, 3);
      while (true)
      {
        return;
        label187: this.mSensorManager.unregisterListener(this.mLightListener);
        this.mSensorManager.unregisterListener(this.mTiltListener);
        this.mHandler.removeCallbacks(this.mAutoBrightnessTask);
        this.mLightSensorPendingDecrease = false;
        this.mLightSensorPendingIncrease = false;
      }
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  private void enableProximityLockLocked()
  {
    Slog.d("PowerManagerService", "enableProximityLockLocked");
    long l;
    if (!this.mProximitySensorEnabled)
      l = Binder.clearCallingIdentity();
    try
    {
      this.mSensorManager.registerListener(this.mProximityListener, this.mProximitySensor, 3);
      this.mProximitySensorEnabled = true;
      return;
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  // ERROR //
  public static void fileWriteInt(String paramString, int paramInt)
  {
    // Byte code:
    //   0: aconst_null
    //   1: astore_2
    //   2: ldc 89
    //   4: new 831 java/lang/StringBuilder
    //   7: dup
    //   8: invokespecial 832   java/lang/StringBuilder:<init>  ()V
    //   11: ldc_w 1445
    //   14: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   17: aload_0
    //   18: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   21: ldc_w 1447
    //   24: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   27: iload_1
    //   28: invokevirtual 1203 java/lang/StringBuilder:append  (I)Ljava/lang/StringBuilder;
    //   31: invokevirtual 843  java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   34: invokestatic 1448  android/util/Slog:i (Ljava/lang/String;Ljava/lang/String;)I
    //   37: pop
    //   38: new 1450   java/io/FileOutputStream
    //   41: dup
    //   42: new 1452   java/io/File
    //   45: dup
    //   46: aload_0
    //   47: invokespecial 1454 java/io/File:<init> (Ljava/lang/String;)V
    //   50: invokespecial 1457 java/io/FileOutputStream:<init> (Ljava/io/File;)V
    //   53: astore 4
    //   55: aload 4
    //   57: iload_1
    //   58: invokestatic 1459  java/lang/Integer:toString  (I)Ljava/lang/String;
    //   61: invokevirtual 847  java/lang/String:getBytes   ()[B
    //   64: invokevirtual 1460 java/io/FileOutputStream:write  ([B)V
    //   67: aload 4
    //   69: invokevirtual 1463 java/io/FileOutputStream:close  ()V
    //   72: return
    //   73: astore 7
    //   75: ldc 89
    //   77: ldc_w 1465
    //   80: invokestatic 1214  android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   83: pop
    //   84: return
    //   85: astore 5
    //   87: aload 5
    //   89: invokevirtual 827  java/io/IOException:printStackTrace ()V
    //   92: aload_2
    //   93: invokevirtual 1463 java/io/FileOutputStream:close  ()V
    //   96: return
    //   97: astore 6
    //   99: aload 6
    //   101: invokevirtual 1466    java/lang/Exception:printStackTrace ()V
    //   104: return
    //   105: astore 5
    //   107: aload 4
    //   109: astore_2
    //   110: goto -23 -> 87
    //
    // Exception table:
    //   from   to  target  type
    //   38 55  73  java/io/FileNotFoundException
    //   38 55  85  java/io/IOException
    //   75 84  85  java/io/IOException
    //   92 96  97  java/lang/Exception
    //   55 72  105 java/io/IOException
  }

  private void forceReenableScreen()
  {
    if (!this.mPreventScreenOn)
    {
      Slog.w("PowerManagerService", "forceReenableScreen: mPreventScreenOn is false, nothing to do");
      return;
    }
    Slog.w("PowerManagerService", "App called preventScreenOn(true) but didn't promptly reenable the screen! Forcing the screen back on...");
    preventScreenOn(false);
  }

  private void forceUserActivityLocked()
  {
    if (isScreenTurningOffLocked())
    {
      Slog.w("PowerManagerService", "forceUserActivityLocked  : isScreenTurningOffLocked : cancelAnimation");
      this.mScreenBrightnessAnimator.cancelAnimation();
    }
    boolean bool = this.mUserActivityAllowed;
    this.mUserActivityAllowed = true;
    userActivity(SystemClock.uptimeMillis(), false);
    this.mUserActivityAllowed = bool;
  }

  private int getAdjustedDynamicAutoBrightnessValue(int paramInt1, int paramInt2)
  {
    float f = (paramInt2 - this.mValueOfVirtualZeroCandela) * this.mDynamicAutoBrightnessRatio;
    int i = 5 * this.mUserControlLevel;
    if (((this.mDynamicAutoBrightnessRatio > 0.0F) && (f < i)) || ((this.mDynamicAutoBrightnessRatio < 0.0F) && (f > i)))
    {
      Slog.d("PowerManagerService", "getAdjustedDynamicAutoBrightnessValue : offset : " + f + " -> " + i);
      f = i;
    }
    int j = (int)(f + paramInt2);
    if ((paramInt1 >= 15000) && (j < this.mLowLimitAtHighestAutoBrightnessLevel))
    {
      Slog.d("PowerManagerService", "getAdjustedDynamicAutoBrightnessValue : minBrightness : " + j + " -> " + this.mLowLimitAtHighestAutoBrightnessLevel);
      j = this.mLowLimitAtHighestAutoBrightnessLevel;
    }
    int k = this.mBrightnessValuesOrg[0];
    if (j > 255)
      j = 255;
    while (j >= k)
      return j;
    return k;
  }

  private int getAutoBrightnessValue(int paramInt, int[] paramArrayOfInt)
  {
    try
    {
      if (this.mDynamicAutoBrightnessEnabled)
      {
        if ((this.mLowHysteresisLux < paramInt) && (paramInt <= this.mHighHysteresisLux))
          Slog.d("PowerManagerService", "getAutoBrightnessValue : in bound ( " + this.mLowHysteresisLux + " < " + paramInt + " <= " + this.mHighHysteresisLux + " )");
        while (true)
        {
          return this.mDynamicAutoBrightnessValue;
          int i3 = getDynamicAutoBrightnessValue(paramInt);
          this.mLowHysteresisLux = getDynamicAutoBrightnessLowHysteresis(i3);
          this.mHighHysteresisLux = getDynamicAutoBrightnessHighHysteresis(i3);
          this.mDynamicAutoBrightnessValue = getFinalDynamicAutoBrightnessValue(paramInt, i3);
          Slog.d("PowerManagerService", "getAutoBrightnessValue : mDynamicAutoBrightnessValue = " + this.mDynamicAutoBrightnessValue + "(" + i3 + ")  (( " + 10 * (this.mDynamicAutoBrightnessValue / 10) + "))  (" + this.mUserControlLevel + ")  ( " + this.mLowHysteresisLux + " < " + paramInt + " <= " + this.mHighHysteresisLux + " )");
        }
      }
    }
    catch (Exception localException)
    {
      Slog.e("PowerManagerService", "Values array must be non-empty and must be one element longer than the auto-brightness levels array.  Check config.xml.", localException);
      return 255;
    }
    int i = 0;
    if ((i >= this.mAutoBrightnessLevels.length) || (paramInt < this.mAutoBrightnessLevels[i]))
      if (i != -1 + this.mLastAutoBrightnessLevel);
    for (int j = 0; ; j++)
      if ((j >= this.mAutoBrightnessHysteresisLevels.length) || (paramInt <= this.mAutoBrightnessHysteresisLevels[j]))
      {
        this.mLastAutoBrightnessLevel = j;
        int k = this.mLastAutoBrightnessLevel;
        int m = paramArrayOfInt[0];
        int n = paramArrayOfInt[this.mAutoBrightnessLevels.length];
        int i1 = 20 + (n - m);
        float f1 = (10 + (paramArrayOfInt[k] - m)) / i1;
        float f2;
        if ((this.mLightSensorAdjustSetting > 0.0F) && (this.mLightSensorAdjustSetting <= 1.0F))
        {
          f2 = (float)Math.sqrt(1.0F - this.mLightSensorAdjustSetting);
          if (f2 <= 1.E-005D)
            f1 = 1.0F;
        }
        int i2;
        while (true)
        {
          i2 = -10 + (int)((f1 + this.mLightSensorAdjustSetting / 8.0F) * i1 + m);
          if (i2 >= m)
            break label509;
          return m;
          this.mLastAutoBrightnessLevel = i;
          break;
          f1 /= f2;
          continue;
          if ((this.mLightSensorAdjustSetting < 0.0F) && (this.mLightSensorAdjustSetting >= -1.0F))
          {
            double d = Math.sqrt(1.0F + this.mLightSensorAdjustSetting);
            f1 *= (float)d;
          }
        }
        label509: if (i2 > n)
          i2 = n;
        return i2;
        i++;
        break;
      }
  }

  private int getDynamicAutoBrightnessHighHysteresis(int paramInt)
  {
    for (int i = 1; ; i++)
      try
      {
        if ((i >= this.mHighHysteresisValues.length) || (paramInt < this.mHighHysteresisValues[i]))
        {
          if (i >= this.mHighHysteresisLevels.length)
          {
            int k = -1 + this.mHighHysteresisLevels.length;
            return this.mHighHysteresisLevels[k];
          }
          if (this.mHighHysteresisSlope[(i - 1)] > 0.0D)
            return (int)Math.pow(10.0D, this.mHighHysteresisSlope[(i - 1)] * (paramInt - this.mHighHysteresisValues[(i - 1)]) + Math.log10(0.01D + this.mHighHysteresisLevels[(i - 1)]));
          int j = this.mHighHysteresisLevels[(i - 1)];
          return j;
        }
      }
      catch (Exception localException)
      {
        Slog.e("PowerManagerService", "getDynamicAutoBrightnessHighHysteresis", localException);
        return 15000;
      }
  }

  private int getDynamicAutoBrightnessLowHysteresis(int paramInt)
  {
    for (int i = 1; ; i++)
      try
      {
        if ((i >= this.mLowHysteresisValues.length) || (paramInt < this.mLowHysteresisValues[i]))
        {
          if (i >= this.mLowHysteresisLevels.length)
            return this.mLowHysteresisLevels[(-1 + this.mLowHysteresisLevels.length)];
          if (this.mLowHysteresisSlope[(i - 1)] > 0.0D)
            return (int)Math.pow(10.0D, this.mLowHysteresisSlope[(i - 1)] * (paramInt - this.mLowHysteresisValues[(i - 1)]) + Math.log10(0.01D + this.mLowHysteresisLevels[(i - 1)]));
          int j = this.mLowHysteresisLevels[(i - 1)];
          return j;
        }
      }
      catch (Exception localException)
      {
        Slog.e("PowerManagerService", "getDynamicAutoBrightnessLowHysteresis", localException);
        return 15000;
      }
  }

  private int getDynamicAutoBrightnessValue(int paramInt)
  {
    for (int i = 1; ; i++)
      while (true)
      {
        int j;
        try
        {
          if ((i < this.mBrightnessLevels.length) && (paramInt > this.mBrightnessLevels[i]))
            break;
          if (i >= this.mBrightnessValues.length)
          {
            j = this.mBrightnessValues[(-1 + this.mBrightnessValues.length)];
            break label169;
            sendBrightnessModeBySysfs(paramInt);
            return j;
          }
          else if (this.mBrightnessValueSlope[(i - 1)] > 0.0D)
          {
            j = (int)(this.mBrightnessValueSlope[(i - 1)] * (Math.log10(0.01D + paramInt) - Math.log10(0.01D + this.mBrightnessLevels[(i - 1)])) + this.mBrightnessValues[(i - 1)]);
          }
          else
          {
            j = this.mBrightnessValues[(i - 1)];
            break label169;
            if (j >= this.mBrightnessValues[0])
              continue;
            j = this.mBrightnessValues[0];
            continue;
          }
        }
        catch (Exception localException)
        {
          Slog.e("PowerManagerService", "getDynamicAutoBrightnessValue", localException);
          return 255;
        }
        label169: if (j > 255)
          j = 255;
      }
  }

  private int getFinalDynamicAutoBrightnessValue(int paramInt1, int paramInt2)
  {
    int i = paramInt2;
    if (this.mIsTablet)
      if (paramInt1 == 0)
      {
        if (this.mSignedSettingsRatio > -40.0F)
          break label61;
        i = this.mMinimumExpressiveBrightnessValues[0];
      }
    while (true)
    {
      if ((this.mSignedSettingsRatio >= 40.0F) && (i < this.mMinimumExpressiveBrightnessValues[2]))
        i = this.mMinimumExpressiveBrightnessValues[2];
      return i;
      label61: if (this.mSignedSettingsRatio >= 40.0F)
        i = this.mMinimumExpressiveBrightnessValues[2];
      else
        i = this.mMinimumExpressiveBrightnessValues[1];
    }
  }

  private int getPreferredBrightness()
  {
    if (this.mScreenBrightnessOverride >= 0)
      return this.mScreenBrightnessOverride;
    if ((this.mLightSensorScreenBrightness >= 0) && (this.mUseSoftwareAutoBrightness) && (this.mAutoBrightessEnabled))
      return this.mLightSensorScreenBrightness;
    return Math.max(this.mScreenBrightnessSetting, this.mScreenBrightnessDim);
  }

  private double getSlope(int paramInt1, int paramInt2, int paramInt3, int paramInt4, boolean paramBoolean)
  {
    if ((paramInt1 == paramInt3) || (paramInt2 == paramInt4))
      return 0.0D;
    if (paramBoolean)
      return (Math.log10(0.01D + paramInt3) - Math.log10(0.01D + paramInt1)) / (paramInt4 - paramInt2);
    return (paramInt4 - paramInt2) / (Math.log10(0.01D + paramInt3) - Math.log10(0.01D + paramInt1));
  }

  private void goToSleepLocked(long paramLong, int paramInt)
  {
    if (this.mLastEventTime <= paramLong)
    {
      if (isScreenOn())
      {
        int n = Binder.getCallingPid();
        int i1 = Binder.getCallingUid();
        Slog.d("PowerManagerService", "Screen__Off : goToSleepLocked : uid : " + i1 + " pid : " + n + "  reason : " + paramInt);
      }
      this.mLastEventTime = paramLong;
      this.mWakeLockState = 0;
      int i = this.mLocks.size();
      int j = 0;
      int k = 0;
      int m = 0;
      if (m < i)
      {
        WakeLock localWakeLock = (WakeLock)this.mLocks.get(m);
        if (isScreenLock(localWakeLock.flags))
        {
          if (((0x3F & localWakeLock.flags) != 32) || (paramInt != 4))
            break label162;
          k = 1;
        }
        while (true)
        {
          m++;
          break;
          label162: ((WakeLock)this.mLocks.get(m)).activated = false;
          j++;
        }
      }
      if (k == 0)
      {
        this.mProxIgnoredBecauseScreenTurnedOff = true;
        Slog.d("PowerManagerService", "setting mProxIgnoredBecauseScreenTurnedOff");
      }
      EventLog.writeEvent(2724, j);
      this.mStillNeedSleepNotification = true;
      this.mUserState = 0;
      setPowerState(0, false, paramInt);
      cancelTimerLocked();
      return;
    }
    Slog.e("PowerManagerService", "goToSleepLocked : not excuted : mLastEventTime : " + this.mLastEventTime + "  time : " + paramLong);
  }

  private void handleLightSensorValue(int paramInt, boolean paramBoolean)
  {
    boolean bool1 = true;
    long l = SystemClock.elapsedRealtime();
    boolean bool2 = this.mIsLockZone;
    if (this.mTiltAngle < 70.0F);
    for (this.mIsLockZone = bool1; ; this.mIsLockZone = false)
    {
      if ((this.mIsLockZone) && (paramInt < this.mLightSensorValue))
        paramInt = (int)this.mLightSensorValue;
      if (bool2 != this.mIsLockZone)
        Slog.d("PowerManagerService", "mIsLockZone =  " + this.mIsLockZone + "   mTiltAngle : " + this.mTiltAngle + " value : " + paramInt);
      if ((this.mLightSensorValue != -1.0F) && (l >= this.mLastScreenOnTime + this.mLightSensorWarmupTime) && (!this.mWaitingForFirstLightSensor))
        break;
      this.mHandler.removeCallbacks(this.mAutoBrightnessTask);
      this.mLightSensorPendingDecrease = false;
      this.mLightSensorPendingIncrease = false;
      lightSensorChangedLocked(paramInt, paramBoolean);
      return;
    }
    if (((paramInt > this.mLightSensorValue) && (this.mLightSensorPendingDecrease)) || ((paramInt < this.mLightSensorValue) && (this.mLightSensorPendingIncrease)) || (paramInt == this.mLightSensorValue) || ((!this.mLightSensorPendingDecrease) && (!this.mLightSensorPendingIncrease)))
    {
      this.mHandler.removeCallbacks(this.mAutoBrightnessTask);
      boolean bool3;
      if (paramInt < this.mLightSensorValue)
      {
        bool3 = bool1;
        label265: this.mLightSensorPendingDecrease = bool3;
        if (paramInt <= this.mLightSensorValue)
          break label328;
      }
      while (true)
      {
        this.mLightSensorPendingIncrease = bool1;
        if ((!this.mLightSensorPendingDecrease) && (!this.mLightSensorPendingIncrease))
          break;
        this.mLightSensorPendingValue = paramInt;
        this.mHandler.postDelayed(this.mAutoBrightnessTask, 3000L);
        return;
        bool3 = false;
        break label265;
        label328: bool1 = false;
      }
    }
    this.mLightSensorPendingValue = paramInt;
  }

  // ERROR //
  private void initSupportedFrequency()
  {
    // Byte code:
    //   0: ldc 89
    //   2: ldc_w 1663
    //   5: invokestatic 1214   android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   8: pop
    //   9: aload_0
    //   10: getfield 513   com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   13: ifnonnull +184 -> 197
    //   16: new 1665   java/io/BufferedReader
    //   19: dup
    //   20: new 1667   java/io/FileReader
    //   23: dup
    //   24: ldc_w 1669
    //   27: invokespecial 1670 java/io/FileReader:<init>   (Ljava/lang/String;)V
    //   30: invokespecial 1673 java/io/BufferedReader:<init>   (Ljava/io/Reader;)V
    //   33: astore_2
    //   34: aload_2
    //   35: invokevirtual 1674 java/io/BufferedReader:close    ()V
    //   38: new 1665   java/io/BufferedReader
    //   41: dup
    //   42: new 1667   java/io/FileReader
    //   45: dup
    //   46: ldc_w 1676
    //   49: invokespecial 1670 java/io/FileReader:<init>   (Ljava/lang/String;)V
    //   52: invokespecial 1673 java/io/BufferedReader:<init>   (Ljava/io/Reader;)V
    //   55: astore 6
    //   57: aload 6
    //   59: invokevirtual 1674 java/io/BufferedReader:close    ()V
    //   62: new 1665   java/io/BufferedReader
    //   65: dup
    //   66: new 1667   java/io/FileReader
    //   69: dup
    //   70: ldc_w 1678
    //   73: invokespecial 1670 java/io/FileReader:<init>   (Ljava/lang/String;)V
    //   76: invokespecial 1673 java/io/BufferedReader:<init>   (Ljava/io/Reader;)V
    //   79: astore 8
    //   81: aload 8
    //   83: invokevirtual 1681 java/io/BufferedReader:readLine ()Ljava/lang/String;
    //   86: ldc_w 1683
    //   89: invokevirtual 1687 java/lang/String:split  (Ljava/lang/String;)[Ljava/lang/String;
    //   92: astore 11
    //   94: aload_0
    //   95: aload 11
    //   97: arraylength
    //   98: newarray int
    //   100: putfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   103: iconst_0
    //   104: istore 12
    //   106: iload 12
    //   108: aload 11
    //   110: arraylength
    //   111: if_icmpge +114 -> 225
    //   114: aload_0
    //   115: getfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   118: iload 12
    //   120: aload 11
    //   122: iload 12
    //   124: aaload
    //   125: invokestatic 1691 java/lang/Integer:parseInt  (Ljava/lang/String;)I
    //   128: iastore
    //   129: ldc 89
    //   131: new 831   java/lang/StringBuilder
    //   134: dup
    //   135: invokespecial 832 java/lang/StringBuilder:<init>  ()V
    //   138: ldc_w 1693
    //   141: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   144: aload_0
    //   145: getfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   148: iload 12
    //   150: iaload
    //   151: invokevirtual 1203    java/lang/StringBuilder:append  (I)Ljava/lang/StringBuilder;
    //   154: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   157: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   160: pop
    //   161: iinc 12 1
    //   164: goto -58 -> 106
    //   167: astore 5
    //   169: aload 5
    //   171: invokevirtual 827 java/io/IOException:printStackTrace ()V
    //   174: aload_0
    //   175: aconst_null
    //   176: putfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   179: goto -141 -> 38
    //   182: astore_3
    //   183: ldc 89
    //   185: ldc_w 1695
    //   188: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   191: pop
    //   192: aload_0
    //   193: aconst_null
    //   194: putfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   197: return
    //   198: astore 7
    //   200: aload 7
    //   202: invokevirtual 827 java/io/IOException:printStackTrace ()V
    //   205: aload_0
    //   206: aconst_null
    //   207: putfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   210: goto -148 -> 62
    //   213: astore 9
    //   215: aload 9
    //   217: invokevirtual 1466    java/lang/Exception:printStackTrace ()V
    //   220: aload_0
    //   221: aconst_null
    //   222: putfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   225: aload 8
    //   227: invokevirtual 1674    java/io/BufferedReader:close    ()V
    //   230: return
    //   231: astore 10
    //   233: aload 10
    //   235: invokevirtual 827 java/io/IOException:printStackTrace ()V
    //   238: aload_0
    //   239: aconst_null
    //   240: putfield 513  com/android/server/PowerManagerService:mSupportedFrequency  [I
    //   243: return
    //
    // Exception table:
    //   from   to  target  type
    //   34 38  167 java/io/IOException
    //   16 34  182 java/io/FileNotFoundException
    //   34 38  182 java/io/FileNotFoundException
    //   38 57  182 java/io/FileNotFoundException
    //   57 62  182 java/io/FileNotFoundException
    //   62 81  182 java/io/FileNotFoundException
    //   81 103 182 java/io/FileNotFoundException
    //   106    161 182 java/io/FileNotFoundException
    //   169    179 182 java/io/FileNotFoundException
    //   200    210 182 java/io/FileNotFoundException
    //   215    225 182 java/io/FileNotFoundException
    //   225    230 182 java/io/FileNotFoundException
    //   233    243 182 java/io/FileNotFoundException
    //   57 62  198 java/io/IOException
    //   81 103 213 java/lang/Exception
    //   106    161 213 java/lang/Exception
    //   225    230 231 java/io/IOException
  }

  private boolean isScreenLock(int paramInt)
  {
    int i = paramInt & 0x3F;
    return (i == 26) || (i == 10) || (i == 6) || (i == 32);
  }

  private boolean isScreenTurningOffLocked()
  {
    return (this.mScreenBrightnessAnimator.isAnimating()) && (this.mScreenBrightnessAnimator.endValue == 0) && ((0x2 & this.mScreenBrightnessAnimator.currentMask) != 0);
  }

  private boolean isTablet()
  {
    String str = SystemProperties.get("ro.build.characteristics");
    return (str != null) && (str.contains("tablet"));
  }

  private void lightSensorChangedLocked(int paramInt, boolean paramBoolean)
  {
    Slog.d("PowerManagerService", "lightSensorChangedLocked value=" + paramInt + " immediate=" + paramBoolean);
    if ((0x1 & this.mPowerState) == 0);
    int i;
    int k;
    int m;
    do
    {
      do
      {
        Slog.d("PowerManagerService", "dropping lightSensorChangedLocked because screen is off");
        do
          return;
        while (this.mLightSensorValue == paramInt);
        this.mLightSensorValue = paramInt;
      }
      while ((0x10 & this.mPowerState) != 0);
      i = getAutoBrightnessValue(paramInt, this.mLcdBacklightValues);
      int j = getAutoBrightnessValue(paramInt, this.mButtonBacklightValues);
      if (this.mKeyboardVisible);
      for (k = getAutoBrightnessValue(paramInt, this.mKeyboardBacklightValues); ; k = 0)
      {
        if ((this.mLightSensorScreenBrightnessUpperLimit >= 0) && (i > this.mLightSensorScreenBrightnessUpperLimit))
        {
          i = this.mLightSensorScreenBrightnessUpperLimit;
          Slog.d("PowerManagerService", "lightSensorChangedLocked : lcdValue is changed to " + i + " because of UpperLimit");
        }
        if ((this.mLightSensorScreenBrightnessLowerLimit >= 0) && (i < this.mLightSensorScreenBrightnessLowerLimit))
        {
          i = this.mLightSensorScreenBrightnessLowerLimit;
          Slog.d("PowerManagerService", "lightSensorChangedLocked : lcdValue is changed to " + i + " because of LowerLimit");
        }
        this.mLightSensorScreenBrightness = i;
        this.mLightSensorButtonBrightness = j;
        this.mLightSensorKeyboardBrightness = k;
        Slog.d("PowerManagerService", "lcdValue " + i);
        Slog.d("PowerManagerService", "buttonValue " + j);
        Slog.d("PowerManagerService", "keyboardValue " + k);
        if ((0x2 & this.mPowerState) != 0)
          break;
        Slog.d("PowerManagerService", "dropping lightSensorChangedLocked because screen is off");
        return;
      }
      if ((this.mAutoBrightessEnabled) && (this.mScreenBrightnessOverride < 0))
      {
        if (this.mSystemPowerSaveModeEnabled)
        {
          int n = i - POWERSAVEMODE_BRIGHTNESS_OFFSET;
          if (i > 0)
          {
            i = Math.max(n, 10);
            Slog.d("PowerManagerService", "lightSensorChangedLocked : mSystemPowerSaveModeEnabled:: lcdValue:" + i);
          }
        }
        if ((this.mMaxBrightness >= 0) && (i > this.mMaxBrightness))
        {
          i = this.mMaxBrightness;
          Slog.d("PowerManagerService", "lightSensorChangedLocked : brightness is changed to " + i + " because of temperature");
        }
        if ((!this.mSkippedScreenOn) && (!this.mInitialAnimation))
        {
          if (!paramBoolean)
            break;
          m = 4;
          this.mScreenBrightnessAnimator.animateTo(i, paramInt, 2, m * 16);
        }
      }
      if ((this.mButtonOffTimeoutSetting == -2) && (this.mButtonBrightnessOverride < 0))
      {
        Slog.d("PowerManagerService", "lightSensorChangedLocked : mButtonLight : " + j);
        this.mButtonLight.setBrightness(j);
      }
    }
    while (((this.mButtonOffTimeoutSetting != -2) || (this.mButtonBrightnessOverride >= 0)) && (this.mKeyboardVisible));
    Slog.d("PowerManagerService", "lightSensorChangedLocked : mKeyboardLight : " + k);
    this.mKeyboardLight.setBrightness(k);
    return;
    while (true)
    {
      synchronized (this.mScreenBrightnessAnimator)
      {
        if (this.mScreenBrightnessAnimator.currentValue <= i)
          m = 20;
      }
      m = 20;
    }
  }

  private static String lockType(int paramInt)
  {
    switch (paramInt)
    {
    default:
      return "???                           ";
    case 26:
      return "FULL_WAKE_LOCK                ";
    case 10:
      return "SCREEN_BRIGHT_WAKE_LOCK       ";
    case 6:
      return "SCREEN_DIM_WAKE_LOCK          ";
    case 1:
      return "PARTIAL_WAKE_LOCK             ";
    case 32:
    }
    return "PROXIMITY_SCREEN_OFF_WAKE_LOCK";
  }

  public static void lowLevelReboot(String paramString)
    throws IOException
  {
    nativeReboot(paramString);
  }

  public static void lowLevelShutdown()
  {
    nativeShutdown();
  }

  private static native int nativeAcquireDVFSLock(int paramInt1, int paramInt2);

  private static native void nativeAcquireWakeLock(int paramInt, String paramString);

  private static native int nativeFakeOff();

  private native void nativeInit();

  private static native void nativeReboot(String paramString)
    throws IOException;

  private static native int nativeReleaseDVFSLock(int paramInt);

  private static native void nativeReleaseWakeLock(String paramString);

  private native void nativeSetPowerState(boolean paramBoolean1, boolean paramBoolean2);

  private static native int nativeSetScreenState(boolean paramBoolean);

  private static native void nativeShutdown();

  private native void nativeStartSurfaceFlingerAnimation(int paramInt);

  private void printAutoBrightnessTables()
  {
    int i = 0;
    try
    {
      while (i < this.mAutoBrightnessLevels.length)
      {
        mStrAutoBrightnessLevels = mStrAutoBrightnessLevels + "    " + this.mAutoBrightnessLevels[i];
        i++;
      }
      Slog.d("PowerManagerService", mStrAutoBrightnessLevels);
      for (int j = 0; j < this.mAutoBrightnessHysteresisLevels.length; j++)
        mStrAutoBrightnessHysteresisLevels = mStrAutoBrightnessHysteresisLevels + "    " + this.mAutoBrightnessHysteresisLevels[j];
      Slog.d("PowerManagerService", mStrAutoBrightnessHysteresisLevels);
      for (int k = 0; k < this.mLcdBacklightValues.length; k++)
        mStrLcdBacklightValues = mStrLcdBacklightValues + this.mLcdBacklightValues[k] + "    ";
      Slog.d("PowerManagerService", mStrLcdBacklightValues);
      if (this.mDynamicAutoBrightnessEnabled)
      {
        Slog.d("PowerManagerService", "mValueOfVirtualZeroCandela = " + this.mValueOfVirtualZeroCandela);
        for (int m = 0; m < this.mLowHysteresisLevels.length; m++)
          mStrLowHysteresisPoints = mStrLowHysteresisPoints + "(" + this.mLowHysteresisLevels[m] + "," + this.mLowHysteresisValues[m] + "),  ";
        Slog.d("PowerManagerService", mStrLowHysteresisPoints);
        for (int n = 0; n < this.mBrightnessLevels.length; n++)
          mStrBrightnessValuePoints = mStrBrightnessValuePoints + "(" + this.mBrightnessLevels[n] + "," + this.mBrightnessValues[n] + "),  ";
        Slog.d("PowerManagerService", mStrBrightnessValuePoints);
        for (int i1 = 0; i1 < this.mHighHysteresisLevels.length; i1++)
          mStrHighHysteresisPoints = mStrHighHysteresisPoints + "(" + this.mHighHysteresisLevels[i1] + "," + this.mHighHysteresisValues[i1] + "),  ";
        Slog.d("PowerManagerService", mStrHighHysteresisPoints);
        if (this.mIsTablet)
        {
          for (int i2 = 0; i2 < this.mMinimumExpressiveBrightnessValues.length; i2++)
            mStrMinimumExpressiveBrightnessValues = mStrMinimumExpressiveBrightnessValues + this.mMinimumExpressiveBrightnessValues[i2] + ", ";
          Slog.d("PowerManagerService", mStrMinimumExpressiveBrightnessValues);
        }
      }
      return;
    }
    catch (Exception localException)
    {
      Slog.e("PowerManagerService", "printAutoBrightnessTables", localException);
    }
  }

  private void printCurLock(int paramInt)
  {
    if ((this.mUserState == 0) && (this.mWakeLockState != 0))
    {
      Slog.e("PowerManagerService", "CurLock p:" + paramInt + " mPS:" + this.mPowerState);
      int i = this.mLocks.size();
      long l1 = SystemClock.elapsedRealtime();
      for (int j = 0; j < i; j++)
      {
        WakeLock localWakeLock = (WakeLock)this.mLocks.get(j);
        String str1 = lockType(0x3F & localWakeLock.flags);
        String str2 = "";
        if ((0x10000000 & localWakeLock.flags) != 0)
          str2 = " AW ";
        String str3 = "";
        if (localWakeLock.activated)
          str3 = " active";
        long l2 = l1 - localWakeLock.acqTime;
        Slog.w("PowerManagerService", "type=" + str1 + " '" + localWakeLock.tag + "'" + str2 + str3 + " (minState=" + localWakeLock.minState + ")" + " activeT=" + l2 + "  uid=" + localWakeLock.uid + "  pid=" + localWakeLock.pid);
      }
    }
  }

  private void printCurLockForce(boolean paramBoolean)
  {
    if (!paramBoolean)
    {
      Slog.w("PowerManagerService", "CurLockF mPS:" + this.mPowerState + " mUS=" + this.mUserState);
      int i = this.mLocks.size();
      long l1 = SystemClock.elapsedRealtime();
      for (int j = 0; j < i; j++)
      {
        WakeLock localWakeLock = (WakeLock)this.mLocks.get(j);
        String str1 = lockType(0x3F & localWakeLock.flags);
        String str2 = "";
        if ((0x10000000 & localWakeLock.flags) != 0)
          str2 = " AW ";
        String str3 = "";
        if (localWakeLock.activated)
          str3 = " active";
        long l2 = l1 - localWakeLock.acqTime;
        Slog.w("PowerManagerService", "type=" + str1 + " '" + localWakeLock.tag + "'" + str2 + str3 + " (mS=" + localWakeLock.minState + ")" + "  activeT=" + l2 + "  uid=" + localWakeLock.uid + "  pid=" + localWakeLock.pid);
      }
      Slog.w("PowerManagerService", "mPokeLocks.size=" + this.mPokeLocks.size() + ":");
      Iterator localIterator = this.mPokeLocks.values().iterator();
      while (localIterator.hasNext())
      {
        PokeLock localPokeLock = (PokeLock)localIterator.next();
        Slog.w("PowerManagerService", " pokeLock " + localPokeLock.pokey + "  '" + localPokeLock.tag + "'");
      }
    }
  }

  private void proximityChangedLocked(boolean paramBoolean)
  {
    Slog.d("PowerManagerService", "proximityChangedLocked, active: " + paramBoolean);
    if (!this.mProximitySensorEnabled)
      Slog.d("PowerManagerService", "Ignoring proximity change after sensor is disabled");
    do
    {
      return;
      if (paramBoolean)
      {
        Slog.d("PowerManagerService", "b mProxIgnoredBecauseScreenTurnedOff=" + this.mProxIgnoredBecauseScreenTurnedOff);
        if (!this.mProxIgnoredBecauseScreenTurnedOff)
          goToSleepLocked(SystemClock.uptimeMillis(), 4);
        this.mProximitySensorActive = true;
        return;
      }
      this.mProximitySensorActive = false;
      Slog.d("PowerManagerService", "b mProxIgnoredBecauseScreenTurnedOff=" + this.mProxIgnoredBecauseScreenTurnedOff);
      if (!this.mProxIgnoredBecauseScreenTurnedOff)
      {
        this.mUserActivityReason = "proximity : far";
        forceUserActivityLocked();
      }
    }
    while (this.mProximityWakeLockCount != 0);
    disableProximityLockLocked();
  }

  private void releaseDVFSLockLocked(IBinder paramIBinder)
  {
    DVFSLock localDVFSLock1 = this.mDVFSLocks.removeLock(paramIBinder);
    if (localDVFSLock1 == null)
      return;
    if (localDVFSLock1.type == 2)
      if (localDVFSLock1 == this.mCurrentDVFSMaxLock)
      {
        DVFSLock localDVFSLock3 = this.mDVFSLocks.getMinOfMaxLock();
        if (localDVFSLock3 == null)
          break label103;
        Slog.d("PowerManagerService", "releaseDVFSLockLocked : remain DVFS_MAX_LIMIT : next : " + localDVFSLock3.frequency);
        nativeAcquireDVFSLock(2, localDVFSLock3.frequency);
        this.mCurrentDVFSMaxLock = localDVFSLock3;
      }
    while (true)
    {
      localDVFSLock1.binder.unlinkToDeath(localDVFSLock1, 0);
      return;
      label103: Slog.d("PowerManagerService", "releaseDVFSLockLocked : all DVFS_MAX_LIMIT are released ");
      nativeReleaseDVFSLock(2);
      this.mCurrentDVFSMaxLock = null;
      continue;
      if ((localDVFSLock1.type == 1) && (localDVFSLock1 == this.mCurrentDVFSMinLock))
      {
        DVFSLock localDVFSLock2 = this.mDVFSLocks.getMaxOfMinLock();
        if (localDVFSLock2 != null)
        {
          Slog.d("PowerManagerService", "releaseDVFSLockLocked : remain DVFS_MIN_LIMIT : next : " + localDVFSLock2.frequency);
          nativeAcquireDVFSLock(1, localDVFSLock2.frequency);
          this.mCurrentDVFSMinLock = localDVFSLock2;
        }
        else
        {
          Slog.d("PowerManagerService", "releaseDVFSLockLocked : all DVFS_MIN_LIMIT are released ");
          nativeReleaseDVFSLock(1);
          this.mCurrentDVFSMinLock = null;
        }
      }
    }
  }

  private void releaseWakeLockLocked(IBinder paramIBinder, int paramInt, boolean paramBoolean)
  {
    WakeLock localWakeLock = this.mLocks.removeLock(paramIBinder);
    if (localWakeLock == null);
    while (localWakeLock.isReleasedInternal)
      return;
    if (isScreenLock(localWakeLock.flags))
      if ((0x3F & localWakeLock.flags) == 32)
      {
        this.mProximityWakeLockCount = (-1 + this.mProximityWakeLockCount);
        Slog.d("PowerManagerService", "releaseWakeLockLocked : PROXIMITY_SCREEN_OFF_WAKE_LOCK : mProximityWakeLockCount : " + this.mProximityWakeLockCount + "  tag=" + localWakeLock.tag + " uid=" + localWakeLock.uid + " pid=" + localWakeLock.pid);
        if (this.mProximityWakeLockCount == 0)
        {
          if ((!this.mProximitySensorActive) || ((paramInt & 0x1) == 0))
            break label185;
          Slog.d("PowerManagerService", "waiting for proximity sensor to go negative");
        }
      }
    while (true)
    {
      localWakeLock.binder.unlinkToDeath(localWakeLock, 0);
      noteStopWakeLocked(localWakeLock, localWakeLock.ws);
      return;
      label185: disableProximityLockLocked();
      continue;
      this.mWakeLockState = this.mLocks.gatherState();
      if ((0x20000000 & localWakeLock.flags) != 0)
      {
        Slog.d("PowerManagerService", "releaseWakeLockLocked : ON_AFTER_RELEASE");
        this.mUserActivityReason = "ON_AFTER_RELEASE wake lock";
        userActivity(SystemClock.uptimeMillis(), -1L, false, 0, false, true);
      }
      printCurLock(2);
      int i;
      label274: StringBuilder localStringBuilder;
      if ((isScreenOn()) && ((0x1 & (this.mWakeLockState | this.mUserState)) == 0))
      {
        i = 1;
        localStringBuilder = new StringBuilder();
        if (i == 0)
          break label358;
      }
      label358: for (String str = "Screen__Off : "; ; str = "")
      {
        Slog.d("PowerManagerService", str + "releaseWakeLockLocked flags=0x" + Integer.toHexString(paramInt) + " tag=" + localWakeLock.tag);
        setPowerState(this.mWakeLockState | this.mUserState);
        break;
        i = 0;
        break label274;
      }
      if ((0x3F & localWakeLock.flags) == 1)
      {
        this.mPartialCount = (-1 + this.mPartialCount);
        Object[] arrayOfObject = new Object[2];
        arrayOfObject[0] = Integer.valueOf(0);
        arrayOfObject[1] = localWakeLock.tag;
        EventLog.writeEvent(2729, arrayOfObject);
        if (this.mPartialCount == 0)
          if (!this.mForceDisableWakeLock)
            nativeReleaseWakeLock("PowerManagerService");
          else
            Slog.d("PowerManagerService", "releaseWakeLockLocked : mForceDisableWakeLock : NOT released : " + localWakeLock.tag);
      }
    }
  }

  private int screenOffFinishedAnimatingLocked(int paramInt)
  {
    printCurLockForce(false);
    this.mBroadcastWakeLock.acquire();
    Object[] arrayOfObject = new Object[4];
    arrayOfObject[0] = Integer.valueOf(0);
    arrayOfObject[1] = Integer.valueOf(paramInt);
    arrayOfObject[2] = Long.valueOf(this.mTotalTouchDownTime);
    arrayOfObject[3] = Integer.valueOf(this.mTouchCycles);
    EventLog.writeEvent(2728, arrayOfObject);
    this.mLastTouchDown = 0L;
    int i = setScreenStateLocked(false);
    if (i == 0)
    {
      this.mScreenOffReason = paramInt;
      sendNotificationLocked(false, paramInt);
    }
    this.mBroadcastWakeLock.release();
    return i;
  }

  private void sendBrightnessModeBySysfs(int paramInt)
  {
    if (this.mAutoBrightessEnabled)
    {
      if (paramInt < 15)
      {
        fileWriteInt("/sys/class/backlight/panel/auto_brightness", 1);
        return;
      }
      if ((paramInt >= 15) && (paramInt < 150))
      {
        fileWriteInt("/sys/class/backlight/panel/auto_brightness", 2);
        return;
      }
      if ((paramInt >= 150) && (paramInt < 1500))
      {
        fileWriteInt("/sys/class/backlight/panel/auto_brightness", 3);
        return;
      }
      if ((paramInt >= 1500) && (paramInt < 15000))
      {
        fileWriteInt("/sys/class/backlight/panel/auto_brightness", 4);
        return;
      }
      if (paramInt >= 15000)
      {
        fileWriteInt("/sys/class/backlight/panel/auto_brightness", 5);
        return;
      }
      fileWriteInt("/sys/class/backlight/panel/auto_brightness", 5);
      return;
    }
    fileWriteInt("/sys/class/backlight/panel/auto_brightness", 0);
  }

  private void sendNotificationLocked(boolean paramBoolean, int paramInt)
  {
    if (!this.mInitialized)
      return;
    Slog.d("PowerManagerService", "sendNotificationLocked on=" + paramBoolean);
    if (!paramBoolean)
      this.mStillNeedSleepNotification = false;
    for (int i = 0; this.mBroadcastQueue[i] != -1; i++);
    int[] arrayOfInt1 = this.mBroadcastQueue;
    int j;
    label76: int[] arrayOfInt2;
    if (paramBoolean)
    {
      j = 1;
      arrayOfInt1[i] = j;
      this.mBroadcastWhy[i] = paramInt;
      if (i == 2)
      {
        if ((!paramBoolean) && (this.mBroadcastWhy[0] > paramInt))
          this.mBroadcastWhy[0] = paramInt;
        arrayOfInt2 = this.mBroadcastQueue;
        if (!paramBoolean)
          break label374;
      }
    }
    label374: for (int k = 1; ; k = 0)
    {
      arrayOfInt2[0] = k;
      this.mBroadcastQueue[1] = -1;
      this.mBroadcastQueue[2] = -1;
      Object[] arrayOfObject2 = new Object[2];
      arrayOfObject2[0] = Integer.valueOf(1);
      arrayOfObject2[1] = Integer.valueOf(this.mBroadcastWakeLock.mCount);
      EventLog.writeEvent(2727, arrayOfObject2);
      this.mBroadcastWakeLock.release();
      Object[] arrayOfObject3 = new Object[2];
      arrayOfObject3[0] = Integer.valueOf(1);
      arrayOfObject3[1] = Integer.valueOf(this.mBroadcastWakeLock.mCount);
      EventLog.writeEvent(2727, arrayOfObject3);
      this.mBroadcastWakeLock.release();
      i = 0;
      if ((i == 1) && (!paramBoolean))
      {
        this.mBroadcastQueue[0] = -1;
        this.mBroadcastQueue[1] = -1;
        i = -1;
        Object[] arrayOfObject1 = new Object[2];
        arrayOfObject1[0] = Integer.valueOf(1);
        arrayOfObject1[1] = Integer.valueOf(this.mBroadcastWakeLock.mCount);
        EventLog.writeEvent(2727, arrayOfObject1);
        this.mBroadcastWakeLock.release();
      }
      if (this.mSkippedScreenOn)
        updateLightsLocked(this.mPowerState, 1);
      if (i < 0)
        break;
      this.mBroadcastWakeLock.acquire();
      EventLog.writeEvent(2725, this.mBroadcastWakeLock.mCount);
      this.mHandler.post(this.mNotificationTask);
      return;
      j = 0;
      break label76;
    }
  }

  public static boolean setAmoledACL(boolean paramBoolean)
  {
    Log.i("PMSCabl", "setAmoledACL (" + paramBoolean + ")");
    if (paramBoolean);
    for (int i = 1; ; i = 0)
      return sysfsWrite("/sys/class/lcd/panel/power_reduce", i);
  }

  private void setDynamicAutoBrightnessSlopeTables()
  {
    while (true)
    {
      try
      {
        int i = -1 + this.mLowHysteresisValues.length;
        int j = -1 + this.mBrightnessValues.length;
        int k = -1 + this.mHighHysteresisValues.length;
        this.mLowHysteresisSlope = new double[i];
        this.mBrightnessValueSlope = new double[j];
        this.mHighHysteresisSlope = new double[k];
        int m = 0;
        if (m < i)
        {
          this.mLowHysteresisSlope[m] = getSlope(this.mLowHysteresisLevels[m], this.mLowHysteresisValues[m], this.mLowHysteresisLevels[(m + 1)], this.mLowHysteresisValues[(m + 1)], true);
          m++;
          continue;
          if (n >= j)
            break label245;
          this.mBrightnessValueSlope[n] = getSlope(this.mBrightnessLevels[n], this.mBrightnessValues[n], this.mBrightnessLevels[(n + 1)], this.mBrightnessValues[(n + 1)], false);
          n++;
          continue;
          if (i1 < k)
          {
            this.mHighHysteresisSlope[i1] = getSlope(this.mHighHysteresisLevels[i1], this.mHighHysteresisValues[i1], this.mHighHysteresisLevels[(i1 + 1)], this.mHighHysteresisValues[(i1 + 1)], true);
            i1++;
            continue;
          }
          printAutoBrightnessTables();
          return;
        }
      }
      catch (Exception localException)
      {
        Slog.e("PowerManagerService", "setDynamicAutoBrightnessSlopeTables", localException);
        return;
      }
      int n = 0;
      continue;
      label245: int i1 = 0;
    }
  }

  private void setLightBrightness(int paramInt1, int paramInt2)
  {
    this.mScreenBrightnessAnimator.animateTo(paramInt2, paramInt1, 0);
  }

  private void setPowerState(int paramInt)
  {
    setPowerState(paramInt, false, 3);
  }

  private void setPowerState(int paramInt1, boolean paramBoolean, int paramInt2)
  {
    LockList localLockList = this.mLocks;
    int i3;
    if (paramBoolean)
      i3 = paramInt1 & 0xFFFFFFF1;
    while (true)
    {
      int i;
      label165: int n;
      try
      {
        paramInt1 = i3 | 0xE & this.mPowerState;
        if (this.mProximitySensorActive)
        {
          Slog.d("PowerManagerService", "setPowerState : mProximitySensorActive is true , so SCREEN_BRIGHT bits is cleared, orig newState : " + paramInt1);
          paramInt1 &= -4;
        }
        if (!batteryIsLow())
          break label646;
        i = 0x10 | paramInt1 & 0xFFFFFFF1;
        if ((i & 0x1) != 0)
          i = applyKeyboardState(applyButtonState(i));
        int j = this.mPowerState;
        if ((i == j) && (this.mInitialized))
          return;
        if (!this.mBootCompleted)
        {
          Slog.d("PowerManagerService", "setPowerState : mBootCompleted : false, newState |= ALL_BRIGHT");
          i |= 15;
        }
        if ((0x1 & this.mPowerState) != 0)
        {
          k = 1;
          break label655;
          if (this.mPowerState == i)
            break label242;
          n = 1;
          label177: if ((n == 0) || (paramInt2 != 3) || (this.mPolicy == null) || (!this.mPolicy.isScreenSaverEnabled()) || (!this.mPolicy.startScreenSaver()))
            break label248;
          return;
        }
      }
      finally
      {
      }
      int k = 0;
      label242: label248:
      while ((i & 0x1) == 0)
      {
        m = 0;
        break label165;
        n = 0;
        break label177;
        int i2;
        long l2;
        if (k != m)
          if (m != 0)
          {
            int i1 = 1;
            if (this.mPreventScreenOn)
            {
              Slog.d("PowerManagerService", "- PREVENTING screen from really turning on!");
              i1 = 0;
            }
            if (i1 != 0)
            {
              i2 = setScreenStateLocked(true);
              l2 = Binder.clearCallingIdentity();
            }
          }
        while (true)
        {
          try
          {
            this.mBatteryStats.noteScreenBrightness(getPreferredBrightness());
            this.mBatteryStats.noteScreenOn();
            Binder.restoreCallingIdentity(l2);
            this.mLastTouchDown = 0L;
            this.mTotalTouchDownTime = 0L;
            this.mTouchCycles = 0;
            Object[] arrayOfObject = new Object[4];
            arrayOfObject[0] = Integer.valueOf(1);
            arrayOfObject[1] = Integer.valueOf(paramInt2);
            arrayOfObject[2] = Long.valueOf(this.mTotalTouchDownTime);
            arrayOfObject[3] = Integer.valueOf(this.mTouchCycles);
            EventLog.writeEvent(2728, arrayOfObject);
            if (i2 == 0)
            {
              sendNotificationLocked(true, -1);
              if (n != 0)
                updateLightsLocked(i, 0);
              this.mPowerState = (0x1 | this.mPowerState);
            }
            this.mPowerState = (0xFFFFFFE1 & this.mPowerState | i & 0x1E);
            updateNativePowerStateLocked();
            return;
          }
          catch (RemoteException localRemoteException2)
          {
            Slog.w("PowerManagerService", "RemoteException calling noteScreenOn on BatteryStatsService", localRemoteException2);
            Binder.restoreCallingIdentity(l2);
            continue;
          }
          finally
          {
            Binder.restoreCallingIdentity(l2);
          }
          setScreenStateLocked(false);
          i2 = 0;
          continue;
          this.mScreenOffReason = paramInt2;
          if (n != 0)
            updateLightsLocked(i, 0);
          this.mHandler.removeCallbacks(this.mAutoBrightnessTask);
          this.mLightSensorPendingDecrease = false;
          this.mLightSensorPendingIncrease = false;
          this.mScreenOffTime = SystemClock.elapsedRealtime();
          long l1 = Binder.clearCallingIdentity();
          try
          {
            this.mBatteryStats.noteScreenOff();
            Binder.restoreCallingIdentity(l1);
            this.mPowerState = (0xFFFFFFFE & this.mPowerState);
            if (!this.mScreenBrightnessAnimator.isAnimating())
            {
              Slog.e("PowerManagerService", "setPowerState : skip screenOffFinishedAnimatingLocked");
              continue;
            }
          }
          catch (RemoteException localRemoteException1)
          {
            while (true)
            {
              Slog.w("PowerManagerService", "RemoteException calling noteScreenOff on BatteryStatsService", localRemoteException1);
              Binder.restoreCallingIdentity(l1);
            }
          }
          finally
          {
            Binder.restoreCallingIdentity(l1);
          }
          this.mLastTouchDown = 0L;
          continue;
          if (n != 0)
            updateLightsLocked(i, 0);
        }
        i = paramInt1 & 0xFFFFFFEF;
        break;
      }
      label646: label655: int m = 1;
    }
  }

  private void setScreenBrightnessMode(int paramInt)
  {
    int i = 1;
    LockList localLockList = this.mLocks;
    int j;
    if (paramInt == i)
      j = i;
    while (true)
    {
      try
      {
        if ((this.mUseSoftwareAutoBrightness) && (this.mAutoBrightessEnabled != j))
        {
          this.mAutoBrightessEnabled = j;
          if (j == 0)
            break label99;
          k = (int)this.mLightSensorValue;
          sendBrightnessModeBySysfs(k);
          if ((this.mIsTablet) && ((!this.mAutoBrightessEnabled) || (!isScreenOn())))
            break label105;
          enableLightSensorLocked(i);
        }
        return;
      }
      finally
      {
      }
      j = 0;
      continue;
      label99: int k = 0;
      continue;
      label105: i = 0;
    }
  }

  private void setScreenOffTimeoutsLocked()
  {
    if ((0x2 & this.mPokey) != 0)
    {
      this.mKeylightDelay = this.mShortKeylightDelay;
      this.mDimDelay = -1;
      this.mScreenOffDelay = 0;
    }
    while (true)
    {
      Slog.d("PowerManagerService", "setScreenOffTimeouts mKeylightDelay=" + this.mKeylightDelay + " mDimDelay=" + this.mDimDelay + " mScreenOffDelay=" + this.mScreenOffDelay + " mDimScreen=" + this.mDimScreen);
      return;
      if ((0x4 & this.mPokey) != 0)
      {
        this.mKeylightDelay = 15000;
        this.mDimDelay = -1;
        this.mScreenOffDelay = 0;
      }
      else if ((0x10 & this.mPokey) != 0)
      {
        this.mKeylightDelay = 6000;
        this.mDimDelay = 4000;
        this.mScreenOffDelay = 20000;
      }
      else
      {
        int i;
        if ((this.mIsDeviceLockTime) && (this.mDeviceLockTimeoutSetting > 0) && (this.mIsSecuredLock == 1))
        {
          i = Math.min(this.mDeviceLockTimeoutSetting, this.mScreenOffTimeoutSetting);
          Slog.d("PowerManagerService", "ATT: setScreenOffTimeouts mDeviceLockTimeoutSetting=" + this.mDeviceLockTimeoutSetting);
          label222: if (i > this.mMaximumScreenOffTimeout)
            i = this.mMaximumScreenOffTimeout;
          this.mKeylightDelay = 6000;
          if (this.mButtonOffTimeoutSetting != -1)
            break label311;
          label250: if (i >= 0)
            break label340;
          this.mScreenOffDelay = this.mMaximumScreenOffTimeout;
        }
        while (true)
        {
          if ((!this.mDimScreen) || (i < 7000 + this.mKeylightDelay))
            break label369;
          this.mDimDelay = (-7000 + this.mScreenOffDelay);
          this.mScreenOffDelay = 7000;
          break;
          i = this.mScreenOffTimeoutSetting;
          break label222;
          label311: if ((this.mButtonOffTimeoutSetting == -2) || (this.mButtonOffTimeoutSetting == -3))
            break label250;
          this.mKeylightDelay = this.mButtonOffTimeoutSetting;
          break label250;
          label340: if (this.mKeylightDelay < i)
            this.mScreenOffDelay = (i - this.mKeylightDelay);
          else
            this.mScreenOffDelay = 0;
        }
        label369: this.mDimDelay = -1;
      }
    }
  }

  private int setScreenStateLocked(boolean paramBoolean)
  {
    if ((paramBoolean) && (this.mInitialized) && (((0x1 & this.mPowerState) == 0) || (this.mSkippedScreenOn)))
      this.mScreenBrightnessAnimator.animateTo(0, 2, 0);
    int i;
    if ((!paramBoolean) && (this.mScreenOffReason == 5) && (!this.mIsFakeOff))
    {
      nativeSetScreenState(false);
      i = nativeFakeOff();
      this.mIsFakeOff = true;
      if (i == 0)
        if (!paramBoolean)
          break label126;
    }
    label126: for (long l = SystemClock.elapsedRealtime(); ; l = 0L)
    {
      this.mLastScreenOnTime = l;
      if (this.mUseSoftwareAutoBrightness)
      {
        enableLightSensorLocked(paramBoolean);
        if (!paramBoolean)
          break label131;
        this.mWaitingForFirstLightSensor = this.mAutoBrightessEnabled;
      }
      return i;
      i = nativeSetScreenState(paramBoolean);
      this.mIsFakeOff = false;
      break;
    }
    label131: this.mButtonLight.turnOff();
    this.mKeyboardLight.turnOff();
    return i;
  }

  private void setTimeoutLocked(long paramLong, int paramInt)
  {
    setTimeoutLocked(paramLong, -1L, paramInt);
  }

  private void setTimeoutLocked(long paramLong1, long paramLong2, int paramInt)
  {
    long l1 = paramLong2;
    if (this.mBootCompleted)
    {
      LockList localLockList1 = this.mLocks;
      long l2;
      if (l1 <= 0L)
        switch (paramInt)
        {
        case 2:
        default:
          l2 = paramLong1;
        case 3:
        case 1:
        case 0:
        }
      while (true)
      {
        long l3;
        try
        {
          this.mHandler.removeCallbacks(this.mTimeoutTask);
          this.mTimeoutTask.nextState = paramInt;
          TimeoutTask localTimeoutTask = this.mTimeoutTask;
          if (l1 <= 0L)
            break label355;
          l3 = paramLong2 - l1;
          localTimeoutTask.remainingTimeoutOverride = l3;
          this.mHandler.postAtTime(this.mTimeoutTask, l2);
          this.mNextTimeout = l2;
          return;
          l2 = paramLong1 + this.mKeylightDelay;
          continue;
          if (this.mDimDelay >= 0)
          {
            l2 = paramLong1 + this.mDimDelay;
            continue;
          }
          Slog.w("PowerManagerService", "mDimDelay=" + this.mDimDelay + " while trying to dim");
          synchronized (this.mLocks)
          {
            l2 = paramLong1 + this.mScreenOffDelay;
          }
        }
        finally
        {
        }
        Slog.w("PowerManagerService", "setTimeoutLocked :  override : timeoutOverride : " + l1);
        if (l1 <= this.mScreenOffDelay)
        {
          l2 = paramLong1 + l1;
          paramInt = 0;
        }
        else
        {
          l1 -= this.mScreenOffDelay;
          if (this.mDimDelay >= 0)
          {
            if (l1 <= this.mDimDelay)
            {
              l2 = paramLong1 + l1;
              paramInt = 1;
            }
            else
            {
              int i = this.mDimDelay;
              l1 -= i;
            }
          }
          else
          {
            l2 = paramLong1 + l1;
            paramInt = 3;
            continue;
            label355: l3 = -1L;
          }
        }
      }
    }
  }

  private boolean shouldDeferScreenOnLocked()
  {
    if (this.mPreparingForScreenOn)
      return true;
    for (int i = 0; ; i++)
    {
      if (i >= this.mBroadcastQueue.length)
        break label36;
      if (this.mBroadcastQueue[i] == 1)
        break;
    }
    label36: return false;
  }

  private boolean shouldLog(long paramLong)
  {
    synchronized (this.mLocks)
    {
      if (paramLong > 3600000L + this.mWarningSpewThrottleTime)
      {
        this.mWarningSpewThrottleTime = paramLong;
        this.mWarningSpewThrottleCount = 0;
        return true;
      }
      if (this.mWarningSpewThrottleCount < 30)
      {
        this.mWarningSpewThrottleCount = (1 + this.mWarningSpewThrottleCount);
        return true;
      }
    }
    return false;
  }

  private void shutdown(final String paramString)
  {
    if ((this.mHandler == null) || (!ActivityManagerNative.isSystemReady()))
      throw new IllegalStateException("Too early to call shutdown()");
    Slog.d("PowerManagerService", "shutdown. reason : " + paramString);
    this.mHandler.post(new Runnable()
    {
      public void run()
      {
        if ((PowerManagerService.this.mIsPowered) || (PowerManagerService.this.mAutoPowerOffTimeoutSetting == 0))
        {
          Slog.i("PowerManagerService", "shutdown : ignored : mIsPowered : " + PowerManagerService.this.mIsPowered + "  mAutoPowerOffTimeoutSetting : " + PowerManagerService.this.mAutoPowerOffTimeoutSetting);
          return;
        }
        if (PowerManagerService.this.checkPreventAutoPowerOff())
        {
          Slog.i("PowerManagerService", "shutdown : checkPreventAutoPowerOff : APO timer reset");
          PowerManagerService.this.mHandler.removeCallbacks(PowerManagerService.this.mUpdateAutoPowerOffTimeTask);
          PowerManagerService.this.mHandler.post(PowerManagerService.this.mUpdateAutoPowerOffTimeTask);
          return;
        }
        Slog.d("PowerManagerService", "shutdown : ShutdownThread.fakeShutdown : " + paramString);
        ShutdownThread.fakeShutdown(PowerManagerService.this.mContext, paramString, false);
      }
    });
  }

  // ERROR //
  private static boolean sysfsWrite(String paramString, int paramInt)
  {
    // Byte code:
    //   0: aconst_null
    //   1: astore_2
    //   2: new 1450    java/io/FileOutputStream
    //   5: dup
    //   6: new 1452    java/io/File
    //   9: dup
    //   10: aload_0
    //   11: invokespecial 1454 java/io/File:<init> (Ljava/lang/String;)V
    //   14: invokespecial 1457 java/io/FileOutputStream:<init> (Ljava/io/File;)V
    //   17: astore_3
    //   18: aload_3
    //   19: iload_1
    //   20: invokestatic 1459  java/lang/Integer:toString  (I)Ljava/lang/String;
    //   23: invokevirtual 847  java/lang/String:getBytes   ()[B
    //   26: invokevirtual 1460 java/io/FileOutputStream:write  ([B)V
    //   29: aload_3
    //   30: invokevirtual 1463 java/io/FileOutputStream:close  ()V
    //   33: iconst_1
    //   34: ireturn
    //   35: astore 6
    //   37: aload 6
    //   39: invokevirtual 2138 java/io/FileNotFoundException:printStackTrace   ()V
    //   42: iconst_0
    //   43: ireturn
    //   44: astore 4
    //   46: aload 4
    //   48: invokevirtual 827  java/io/IOException:printStackTrace ()V
    //   51: aload_2
    //   52: invokevirtual 1463 java/io/FileOutputStream:close  ()V
    //   55: iconst_0
    //   56: ireturn
    //   57: astore 5
    //   59: aload 5
    //   61: invokevirtual 1466 java/lang/Exception:printStackTrace ()V
    //   64: iconst_0
    //   65: ireturn
    //   66: astore 4
    //   68: aload_3
    //   69: astore_2
    //   70: goto -24 -> 46
    //
    // Exception table:
    //   from   to  target  type
    //   2  18  35  java/io/FileNotFoundException
    //   2  18  44  java/io/IOException
    //   37 42  44  java/io/IOException
    //   51 55  57  java/lang/Exception
    //   18 33  66  java/io/IOException
  }

  private void testAutoBrightnessSpec()
  {
    for (int i = 0; i <= 200; i += 20)
    {
      setRatioOfAutoBrightness(i);
      int[] arrayOfInt = { 0, 5, 10, 15, 20, 25, 100, 500, 1000, 1500, 2000, 3000, 4000, 5000, 7000, 8000, 9000, 10000, 14999, 15000 };
      Slog.d("PowerManagerService", "--------------------------------- " + this.mSignedSettingsRatio + " ---------------------------------");
      for (int j = 0; j < arrayOfInt.length; j++)
      {
        this.mLowHysteresisLux = -1;
        this.mHighHysteresisLux = -1;
        this.mLightSensorValue = -1.0F;
        lightSensorChangedLocked(arrayOfInt[j], false);
      }
    }
  }

  // ERROR //
  private void updateLightsLocked(int paramInt1, int paramInt2)
  {
    // Byte code:
    //   0: aload_0
    //   1: getfield 757    com/android/server/PowerManagerService:mPowerState  I
    //   4: istore_3
    //   5: iload_3
    //   6: iconst_1
    //   7: iand
    //   8: ifeq +10 -> 18
    //   11: aload_0
    //   12: getfield 474   com/android/server/PowerManagerService:mSkippedScreenOn Z
    //   15: ifeq +25 -> 40
    //   18: aload_0
    //   19: invokespecial 2148 com/android/server/PowerManagerService:shouldDeferScreenOnLocked    ()Z
    //   22: istore 4
    //   24: aload_0
    //   25: iload 4
    //   27: putfield 474   com/android/server/PowerManagerService:mSkippedScreenOn Z
    //   30: iload 4
    //   32: ifeq +8 -> 40
    //   35: iload_1
    //   36: bipush 252
    //   38: iand
    //   39: istore_1
    //   40: iload_1
    //   41: iload_3
    //   42: ixor
    //   43: istore 5
    //   45: iload 5
    //   47: iload_2
    //   48: ior
    //   49: istore 6
    //   51: iload 6
    //   53: ifne +4 -> 57
    //   56: return
    //   57: aload_0
    //   58: invokespecial 2048 com/android/server/PowerManagerService:getPreferredBrightness   ()I
    //   61: istore 7
    //   63: ldc 89
    //   65: new 831    java/lang/StringBuilder
    //   68: dup
    //   69: invokespecial 832  java/lang/StringBuilder:<init>  ()V
    //   72: ldc_w 2150
    //   75: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   78: iload_3
    //   79: invokestatic 1957  java/lang/Integer:toHexString   (I)Ljava/lang/String;
    //   82: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   85: ldc_w 2152
    //   88: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   91: iload_1
    //   92: invokestatic 1957  java/lang/Integer:toHexString   (I)Ljava/lang/String;
    //   95: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   98: ldc_w 2154
    //   101: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   104: iload_2
    //   105: invokestatic 1957 java/lang/Integer:toHexString   (I)Ljava/lang/String;
    //   108: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   111: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   114: invokestatic 1448 android/util/Slog:i (Ljava/lang/String;Ljava/lang/String;)I
    //   117: pop
    //   118: iload 6
    //   120: bipush 8
    //   122: iand
    //   123: istore 9
    //   125: iconst_0
    //   126: istore 10
    //   128: iconst_0
    //   129: istore 11
    //   131: iload 9
    //   133: ifeq +16 -> 149
    //   136: iload_1
    //   137: bipush 8
    //   139: iand
    //   140: ifne +397 -> 537
    //   143: iconst_0
    //   144: bipush 8
    //   146: ior
    //   147: istore 10
    //   149: iload 6
    //   151: iconst_4
    //   152: iand
    //   153: ifeq +15 -> 168
    //   156: iload_1
    //   157: iconst_4
    //   158: iand
    //   159: ifne +390 -> 549
    //   162: iload 10
    //   164: iconst_4
    //   165: ior
    //   166: istore 10
    //   168: iload 6
    //   170: iconst_3
    //   171: iand
    //   172: ifeq +280 -> 452
    //   175: iload 5
    //   177: iconst_3
    //   178: iand
    //   179: ifeq +45 -> 224
    //   182: iload_3
    //   183: iconst_3
    //   184: iand
    //   185: tableswitch   default:+31 -> 216, 0:+384->569, 1:+376->561, 2:+31->216, 3:+373->558
    //   217: getfield 1109 com/android/server/PowerManagerService:mScreenBrightnessAnimator    Lcom/android/server/PowerManagerService$ScreenBrightnessAnimator;
    //   220: invokevirtual 2157    com/android/server/PowerManagerService$ScreenBrightnessAnimator:getCurrentBrightness    ()I
    //   223: pop
    //   224: iload 7
    //   226: istore 14
    //   228: bipush 10
    //   230: istore 15
    //   232: iload_1
    //   233: iconst_2
    //   234: iand
    //   235: ifne +43 -> 278
    //   238: aload_0
    //   239: getfield 1591 com/android/server/PowerManagerService:mScreenBrightnessDim I
    //   242: i2f
    //   243: iload 7
    //   245: i2f
    //   246: fdiv
    //   247: fstore 24
    //   249: fload 24
    //   251: fconst_1
    //   252: fcmpl
    //   253: ifle +6 -> 259
    //   256: fconst_1
    //   257: fstore 24
    //   259: iload_1
    //   260: iconst_1
    //   261: iand
    //   262: ifne +326 -> 588
    //   265: iload_3
    //   266: iconst_2
    //   267: iand
    //   268: ifeq +304 -> 572
    //   271: bipush 10
    //   273: istore 15
    //   275: iconst_0
    //   276: istore 14
    //   278: aload_0
    //   279: getfield 529  com/android/server/PowerManagerService:mWaitingForFirstLightSensor  Z
    //   282: ifeq +12 -> 294
    //   285: iload_1
    //   286: iconst_1
    //   287: iand
    //   288: ifeq +6 -> 294
    //   291: iconst_4
    //   292: istore 15
    //   294: invokestatic 738  android/os/Binder:clearCallingIdentity  ()J
    //   297: lstore 16
    //   299: aload_0
    //   300: getfield 2046 com/android/server/PowerManagerService:mBatteryStats    Lcom/android/internal/app/IBatteryStats;
    //   303: iload 14
    //   305: invokeinterface 2053 2 0
    //   310: lload 16
    //   312: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   315: aload_0
    //   316: getfield 588  com/android/server/PowerManagerService:mSystemPowerSaveModeEnabled  Z
    //   319: ifeq +52 -> 371
    //   322: iload 14
    //   324: getstatic 370 com/android/server/PowerManagerService:POWERSAVEMODE_BRIGHTNESS_OFFSET  I
    //   327: isub
    //   328: istore 22
    //   330: iload 14
    //   332: ifle +39 -> 371
    //   335: iload 22
    //   337: bipush 10
    //   339: invokestatic 1594 java/lang/Math:max  (II)I
    //   342: istore 14
    //   344: ldc 89
    //   346: new 831   java/lang/StringBuilder
    //   349: dup
    //   350: invokespecial 832 java/lang/StringBuilder:<init>  ()V
    //   353: ldc_w 2159
    //   356: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   359: iload 14
    //   361: invokevirtual 1203    java/lang/StringBuilder:append  (I)Ljava/lang/StringBuilder;
    //   364: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   367: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   370: pop
    //   371: aload_0
    //   372: getfield 586  com/android/server/PowerManagerService:mMaxBrightness   I
    //   375: iflt +51 -> 426
    //   378: iload 14
    //   380: aload_0
    //   381: getfield 586  com/android/server/PowerManagerService:mMaxBrightness   I
    //   384: if_icmple +42 -> 426
    //   387: aload_0
    //   388: getfield 586  com/android/server/PowerManagerService:mMaxBrightness   I
    //   391: istore 14
    //   393: ldc 89
    //   395: new 831   java/lang/StringBuilder
    //   398: dup
    //   399: invokespecial 832 java/lang/StringBuilder:<init>  ()V
    //   402: ldc_w 2161
    //   405: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   408: iload 14
    //   410: invokevirtual 1203    java/lang/StringBuilder:append  (I)Ljava/lang/StringBuilder;
    //   413: ldc_w 1748
    //   416: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   419: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   422: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   425: pop
    //   426: aload_0
    //   427: getfield 474  com/android/server/PowerManagerService:mSkippedScreenOn Z
    //   430: ifne +22 -> 452
    //   433: iload 15
    //   435: bipush 16
    //   437: imul
    //   438: istore 20
    //   440: aload_0
    //   441: getfield 1109 com/android/server/PowerManagerService:mScreenBrightnessAnimator    Lcom/android/server/PowerManagerService$ScreenBrightnessAnimator;
    //   444: iload 14
    //   446: iconst_2
    //   447: iload 20
    //   449: invokevirtual 2020    com/android/server/PowerManagerService$ScreenBrightnessAnimator:animateTo   (III)V
    //   452: iload 10
    //   454: ifeq +10 -> 464
    //   457: aload_0
    //   458: iload 10
    //   460: iconst_0
    //   461: invokespecial 2163    com/android/server/PowerManagerService:setLightBrightness   (II)V
    //   464: iconst_0
    //   465: ifeq +34 -> 499
    //   468: aload_0
    //   469: getfield 1591 com/android/server/PowerManagerService:mScreenBrightnessDim I
    //   472: istore 13
    //   474: iload_1
    //   475: bipush 16
    //   477: iand
    //   478: ifeq +14 -> 492
    //   481: iload 13
    //   483: bipush 10
    //   485: if_icmple +7 -> 492
    //   488: bipush 10
    //   490: istore 13
    //   492: aload_0
    //   493: iconst_0
    //   494: iload 13
    //   496: invokespecial 2163    com/android/server/PowerManagerService:setLightBrightness   (II)V
    //   499: iload 11
    //   501: ifeq -445 -> 56
    //   504: aload_0
    //   505: invokespecial 2048    com/android/server/PowerManagerService:getPreferredBrightness   ()I
    //   508: istore 12
    //   510: iload_1
    //   511: bipush 16
    //   513: iand
    //   514: ifeq +14 -> 528
    //   517: iload 12
    //   519: bipush 10
    //   521: if_icmple +7 -> 528
    //   524: bipush 10
    //   526: istore 12
    //   528: aload_0
    //   529: iload 11
    //   531: iload 12
    //   533: invokespecial 2163    com/android/server/PowerManagerService:setLightBrightness   (II)V
    //   536: return
    //   537: iconst_0
    //   538: bipush 8
    //   540: ior
    //   541: istore 11
    //   543: iconst_0
    //   544: istore 10
    //   546: goto -397 -> 149
    //   549: iload 11
    //   551: iconst_4
    //   552: ior
    //   553: istore 11
    //   555: goto -387 -> 168
    //   558: goto -334 -> 224
    //   561: aload_0
    //   562: getfield 1591 com/android/server/PowerManagerService:mScreenBrightnessDim I
    //   565: pop
    //   566: goto -342 -> 224
    //   569: goto -345 -> 224
    //   572: ldc_w 2164
    //   575: ldc_w 2165
    //   578: fload 24
    //   580: fmul
    //   581: fmul
    //   582: f2i
    //   583: istore 15
    //   585: goto -310 -> 275
    //   588: iload_3
    //   589: iconst_1
    //   590: iand
    //   591: ifeq +57 -> 648
    //   594: ldc_w 2164
    //   597: ldc_w 2165
    //   600: fconst_1
    //   601: fload 24
    //   603: fsub
    //   604: fmul
    //   605: fmul
    //   606: f2i
    //   607: istore 15
    //   609: aload_0
    //   610: invokevirtual 2168    com/android/server/PowerManagerService:getStayOnConditionsLocked    ()I
    //   613: istore 25
    //   615: iload 25
    //   617: ifeq +22 -> 639
    //   620: aload_0
    //   621: getfield 891  com/android/server/PowerManagerService:mBatteryService  Lcom/android/server/BatteryService;
    //   624: iload 25
    //   626: invokevirtual 2171    com/android/server/BatteryService:isPowered (I)Z
    //   629: ifeq +10 -> 639
    //   632: aload_0
    //   633: invokestatic 1242 android/os/SystemClock:elapsedRealtime  ()J
    //   636: putfield 2065 com/android/server/PowerManagerService:mScreenOffTime   J
    //   639: aload_0
    //   640: getfield 1591 com/android/server/PowerManagerService:mScreenBrightnessDim I
    //   643: istore 14
    //   645: goto -367 -> 278
    //   648: ldc_w 2165
    //   651: fload 24
    //   653: fmul
    //   654: f2i
    //   655: istore 15
    //   657: goto -48 -> 609
    //   660: astore 19
    //   662: lload 16
    //   664: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   667: goto -352 -> 315
    //   670: astore 18
    //   672: lload 16
    //   674: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   677: aload 18
    //   679: athrow
    //
    // Exception table:
    //   from   to  target  type
    //   299    310 660 android/os/RemoteException
    //   299    310 670 finally
  }

  private void updateNativePowerStateLocked()
  {
    boolean bool1 = true;
    boolean bool2;
    if (!this.mHeadless)
    {
      if ((0x1 & this.mPowerState) == 0)
        break label37;
      bool2 = bool1;
      if ((0x3 & this.mPowerState) != 3)
        break label42;
    }
    while (true)
    {
      nativeSetPowerState(bool2, bool1);
      return;
      label37: bool2 = false;
      break;
      label42: bool1 = false;
    }
  }

  private void updateSettingsValues()
  {
    this.mShortKeylightDelay = Settings.Secure.getInt(this.mContext.getContentResolver(), "short_keylight_delay_ms", 6000);
    if (this.mIsDeviceLockTime)
    {
      this.mDeviceLockTimeoutSetting = Settings.Secure.getInt(this.mContext.getContentResolver(), "lock_screen_lock_after_timeout", -1);
      Slog.i("PowerManagerService", "ATT: updateSettingsValues : update : mDeviceLockTime : " + this.mDeviceLockTimeoutSetting);
      setScreenOffTimeoutsLocked();
    }
  }

  private void updateWakeLockLocked()
  {
    int i = getStayOnConditionsLocked();
    if ((i != 0) && (this.mBatteryService.isPowered(i)))
    {
      this.mStayOnWhilePluggedInScreenDimLock.acquire();
      this.mStayOnWhilePluggedInPartialLock.acquire();
      return;
    }
    this.mStayOnWhilePluggedInScreenDimLock.release();
    this.mStayOnWhilePluggedInPartialLock.release();
  }

  // ERROR //
  private void userActivity(long paramLong1, long paramLong2, boolean paramBoolean1, int paramInt, boolean paramBoolean2, boolean paramBoolean3)
  {
    // Byte code:
    //   0: iconst_1
    //   1: aload_0
    //   2: getfield 566    com/android/server/PowerManagerService:mPokey   I
    //   5: iand
    //   6: ifeq +47 -> 53
    //   9: iload 6
    //   11: iconst_2
    //   12: if_icmpne +41 -> 53
    //   15: ldc 89
    //   17: new 831    java/lang/StringBuilder
    //   20: dup
    //   21: invokespecial 832  java/lang/StringBuilder:<init>  ()V
    //   24: ldc_w 2195
    //   27: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   30: aload_0
    //   31: getfield 566   com/android/server/PowerManagerService:mPokey   I
    //   34: invokestatic 1957  java/lang/Integer:toHexString   (I)Ljava/lang/String;
    //   37: invokevirtual 838  java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   40: invokevirtual 843  java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   43: invokestatic 1214  android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   46: pop
    //   47: aload_0
    //   48: aconst_null
    //   49: putfield 630   com/android/server/PowerManagerService:mUserActivityReason  Ljava/lang/String;
    //   52: return
    //   53: aload_0
    //   54: getfield 502   com/android/server/PowerManagerService:mLocks   Lcom/android/server/PowerManagerService$LockList;
    //   57: astore 9
    //   59: aload 9
    //   61: monitorenter
    //   62: aload_0
    //   63: getfield 622   com/android/server/PowerManagerService:mAutoPowerOffTimeoutSetting  I
    //   66: ifle +61 -> 127
    //   69: iload 6
    //   71: ifne +10 -> 81
    //   74: aload_0
    //   75: getfield 626   com/android/server/PowerManagerService:mPowerIsChanged  Z
    //   78: ifeq +49 -> 127
    //   81: aload_0
    //   82: getfield 1010  com/android/server/PowerManagerService:mHandler Landroid/os/Handler;
    //   85: aload_0
    //   86: getfield 680   com/android/server/PowerManagerService:mUpdateAutoPowerOffTimeTask  Ljava/lang/Runnable;
    //   89: invokevirtual 1263 android/os/Handler:removeCallbacks  (Ljava/lang/Runnable;)V
    //   92: aload_0
    //   93: iconst_0
    //   94: putfield 626   com/android/server/PowerManagerService:mPowerIsChanged  Z
    //   97: ldc2_w 2196
    //   100: invokestatic 1488 android/os/SystemClock:uptimeMillis ()J
    //   103: ladd
    //   104: lstore 11
    //   106: aload_0
    //   107: getfield 1010 com/android/server/PowerManagerService:mHandler Landroid/os/Handler;
    //   110: aload_0
    //   111: getfield 680  com/android/server/PowerManagerService:mUpdateAutoPowerOffTimeTask  Ljava/lang/Runnable;
    //   114: lload 11
    //   116: invokevirtual 2104    android/os/Handler:postAtTime   (Ljava/lang/Runnable;J)Z
    //   119: pop
    //   120: aload_0
    //   121: getfield 1014 com/android/server/PowerManagerService:mAutoPowerOffPartialLock Lcom/android/server/PowerManagerService$UnsynchronizedWakeLock;
    //   124: invokevirtual 1973    com/android/server/PowerManagerService$UnsynchronizedWakeLock:acquire   ()V
    //   127: aload_0
    //   128: invokespecial 904 com/android/server/PowerManagerService:isScreenTurningOffLocked ()Z
    //   131: ifeq +24 -> 155
    //   134: ldc 89
    //   136: ldc_w 2199
    //   139: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   142: pop
    //   143: aload 9
    //   145: monitorexit
    //   146: return
    //   147: astore 10
    //   149: aload 9
    //   151: monitorexit
    //   152: aload 10
    //   154: athrow
    //   155: iload 8
    //   157: ifeq +56 -> 213
    //   160: iconst_1
    //   161: aload_0
    //   162: getfield 757  com/android/server/PowerManagerService:mPowerState  I
    //   165: iand
    //   166: ifne +47 -> 213
    //   169: ldc 89
    //   171: new 831   java/lang/StringBuilder
    //   174: dup
    //   175: invokespecial 832 java/lang/StringBuilder:<init>  ()V
    //   178: ldc_w 2201
    //   181: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   184: iload 8
    //   186: invokevirtual 887 java/lang/StringBuilder:append  (Z)Ljava/lang/StringBuilder;
    //   189: ldc_w 2203
    //   192: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   195: aload_0
    //   196: getfield 757  com/android/server/PowerManagerService:mPowerState  I
    //   199: invokevirtual 1203    java/lang/StringBuilder:append  (I)Ljava/lang/StringBuilder;
    //   202: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   205: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   208: pop
    //   209: aload 9
    //   211: monitorexit
    //   212: return
    //   213: aload_0
    //   214: getfield 488  com/android/server/PowerManagerService:mProximitySensorActive   Z
    //   217: ifeq +15 -> 232
    //   220: aload_0
    //   221: getfield 484  com/android/server/PowerManagerService:mProximityWakeLockCount  I
    //   224: ifne +8 -> 232
    //   227: aload_0
    //   228: iconst_0
    //   229: putfield 488  com/android/server/PowerManagerService:mProximitySensorActive   Z
    //   232: aload_0
    //   233: getfield 495  com/android/server/PowerManagerService:mLastEventTime   J
    //   236: lload_1
    //   237: lcmp
    //   238: ifle +8 -> 246
    //   241: iload 7
    //   243: ifeq +556 -> 799
    //   246: aload_0
    //   247: lload_1
    //   248: putfield 495  com/android/server/PowerManagerService:mLastEventTime   J
    //   251: aload_0
    //   252: getfield 482  com/android/server/PowerManagerService:mUserActivityAllowed Z
    //   255: ifeq +597 -> 852
    //   258: aload_0
    //   259: getfield 488  com/android/server/PowerManagerService:mProximitySensorActive   Z
    //   262: ifeq +6 -> 268
    //   265: goto +587 -> 852
    //   268: aload_0
    //   269: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   272: istore 15
    //   274: aload_0
    //   275: getfield 980  com/android/server/PowerManagerService:mButtonOffTimeoutSetting I
    //   278: ifeq +582 -> 860
    //   281: aload_0
    //   282: getfield 980  com/android/server/PowerManagerService:mButtonOffTimeoutSetting I
    //   285: iconst_m1
    //   286: if_icmpeq +574 -> 860
    //   289: aload_0
    //   290: getfield 980  com/android/server/PowerManagerService:mButtonOffTimeoutSetting I
    //   293: bipush 254
    //   295: if_icmpeq +565 -> 860
    //   298: aload_0
    //   299: getfield 980  com/android/server/PowerManagerService:mButtonOffTimeoutSetting I
    //   302: bipush 253
    //   304: if_icmpne +297 -> 601
    //   307: goto +553 -> 860
    //   310: iload 6
    //   312: iconst_2
    //   313: if_icmpne +314 -> 627
    //   316: iload 16
    //   318: ifne +309 -> 627
    //   321: getstatic 413 com/android/server/PowerManagerService:mIsNorthAmericaSalesCode Z
    //   324: ifeq +290 -> 614
    //   327: aload_0
    //   328: getfield 480  com/android/server/PowerManagerService:mKeyboardVisible Z
    //   331: ifeq +276 -> 607
    //   334: bipush 15
    //   336: istore 27
    //   338: aload_0
    //   339: iload 27
    //   341: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   344: aload_0
    //   345: invokevirtual 1600    com/android/server/PowerManagerService:isScreenOn   ()Z
    //   348: ifne +19 -> 367
    //   351: iload 16
    //   353: ifne +14 -> 367
    //   356: aload_0
    //   357: bipush 7
    //   359: aload_0
    //   360: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   363: ior
    //   364: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   367: getstatic 413 com/android/server/PowerManagerService:mIsNorthAmericaSalesCode Z
    //   370: ifeq +356 -> 726
    //   373: iload 16
    //   375: ifne +15 -> 390
    //   378: iload 6
    //   380: iconst_3
    //   381: if_icmpeq +9 -> 390
    //   384: iload 6
    //   386: iconst_1
    //   387: if_icmpne +318 -> 705
    //   390: invokestatic 1606 android/os/Binder:getCallingUid ()I
    //   393: istore 17
    //   395: invokestatic 738  android/os/Binder:clearCallingIdentity  ()J
    //   398: lstore 18
    //   400: aload_0
    //   401: getfield 2046 com/android/server/PowerManagerService:mBatteryStats    Lcom/android/internal/app/IBatteryStats;
    //   404: iload 17
    //   406: iload 6
    //   408: invokeinterface 2206 3 0
    //   413: lload 18
    //   415: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   418: aload_0
    //   419: invokevirtual 1600    com/android/server/PowerManagerService:isScreenOn   ()Z
    //   422: ifne +78 -> 500
    //   425: invokestatic 1603 android/os/Binder:getCallingPid ()I
    //   428: istore 23
    //   430: aload_0
    //   431: getfield 630  com/android/server/PowerManagerService:mUserActivityReason  Ljava/lang/String;
    //   434: ifnonnull +15 -> 449
    //   437: iload 6
    //   439: ifeq +350 -> 789
    //   442: aload_0
    //   443: ldc_w 2208
    //   446: putfield 630  com/android/server/PowerManagerService:mUserActivityReason  Ljava/lang/String;
    //   449: ldc 89
    //   451: new 831   java/lang/StringBuilder
    //   454: dup
    //   455: invokespecial 832 java/lang/StringBuilder:<init>  ()V
    //   458: ldc_w 2210
    //   461: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   464: aload_0
    //   465: getfield 630  com/android/server/PowerManagerService:mUserActivityReason  Ljava/lang/String;
    //   468: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   471: ldc_w 1834
    //   474: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   477: iload 17
    //   479: invokevirtual 1203    java/lang/StringBuilder:append  (I)Ljava/lang/StringBuilder;
    //   482: ldc_w 1929
    //   485: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   488: iload 23
    //   490: invokevirtual 1203    java/lang/StringBuilder:append  (I)Ljava/lang/StringBuilder;
    //   493: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   496: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   499: pop
    //   500: iload 15
    //   502: ifne +35 -> 537
    //   505: ldc 89
    //   507: new 831   java/lang/StringBuilder
    //   510: dup
    //   511: invokespecial 832 java/lang/StringBuilder:<init>  ()V
    //   514: ldc_w 2212
    //   517: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   520: aload_0
    //   521: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   524: invokestatic 1957 java/lang/Integer:toHexString   (I)Ljava/lang/String;
    //   527: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   530: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   533: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   536: pop
    //   537: aload_0
    //   538: aload_0
    //   539: getfield 502  com/android/server/PowerManagerService:mLocks   Lcom/android/server/PowerManagerService$LockList;
    //   542: invokevirtual 2215    com/android/server/PowerManagerService$LockList:reactivateScreenLocksLocked ()I
    //   545: putfield 1036 com/android/server/PowerManagerService:mWakeLockState   I
    //   548: aload_0
    //   549: iconst_4
    //   550: invokespecial 1052    com/android/server/PowerManagerService:printCurLock (I)V
    //   553: aload_0
    //   554: aload_0
    //   555: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   558: aload_0
    //   559: getfield 1036 com/android/server/PowerManagerService:mWakeLockState   I
    //   562: ior
    //   563: iload 5
    //   565: iconst_2
    //   566: invokespecial 1634    com/android/server/PowerManagerService:setPowerState    (IZI)V
    //   569: aload_0
    //   570: lload_1
    //   571: lload_3
    //   572: iconst_3
    //   573: invokespecial 1064    com/android/server/PowerManagerService:setTimeoutLocked (JJI)V
    //   576: aload_0
    //   577: aconst_null
    //   578: putfield 630  com/android/server/PowerManagerService:mUserActivityReason  Ljava/lang/String;
    //   581: aload 9
    //   583: monitorexit
    //   584: aload_0
    //   585: getfield 2034 com/android/server/PowerManagerService:mPolicy  Landroid/view/WindowManagerPolicy;
    //   588: ifnull -536 -> 52
    //   591: aload_0
    //   592: getfield 2034 com/android/server/PowerManagerService:mPolicy  Landroid/view/WindowManagerPolicy;
    //   595: invokeinterface 2217 1 0
    //   600: return
    //   601: iconst_0
    //   602: istore 16
    //   604: goto -294 -> 310
    //   607: bipush 7
    //   609: istore 27
    //   611: goto -273 -> 338
    //   614: aload_0
    //   615: iconst_3
    //   616: aload_0
    //   617: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   620: ior
    //   621: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   624: goto -280 -> 344
    //   627: iload 6
    //   629: iconst_3
    //   630: if_icmpne +22 -> 652
    //   633: iload 16
    //   635: ifne +17 -> 652
    //   638: aload_0
    //   639: bipush 7
    //   641: aload_0
    //   642: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   645: ior
    //   646: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   649: goto -305 -> 344
    //   652: iload 6
    //   654: iconst_1
    //   655: if_icmpne +37 -> 692
    //   658: iload 16
    //   660: ifne +32 -> 692
    //   663: aload_0
    //   664: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   667: istore 25
    //   669: aload_0
    //   670: getfield 480  com/android/server/PowerManagerService:mKeyboardVisible Z
    //   673: ifeq +193 -> 866
    //   676: bipush 11
    //   678: istore 26
    //   680: aload_0
    //   681: iload 26
    //   683: iload 25
    //   685: ior
    //   686: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   689: goto -345 -> 344
    //   692: aload_0
    //   693: iconst_3
    //   694: aload_0
    //   695: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   698: ior
    //   699: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   702: goto -358 -> 344
    //   705: aload_0
    //   706: getfield 661  com/android/server/PowerManagerService:mIsSipVisible    Z
    //   709: ifeq -319 -> 390
    //   712: aload_0
    //   713: bipush 243
    //   715: aload_0
    //   716: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   719: iand
    //   720: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   723: goto -333 -> 390
    //   726: aload_0
    //   727: getfield 980  com/android/server/PowerManagerService:mButtonOffTimeoutSetting I
    //   730: sipush 1500
    //   733: if_icmpne -343 -> 390
    //   736: iload 6
    //   738: iconst_3
    //   739: if_icmpeq -349 -> 390
    //   742: iload 6
    //   744: iconst_1
    //   745: if_icmpeq -355 -> 390
    //   748: aload_0
    //   749: getfield 661  com/android/server/PowerManagerService:mIsSipVisible    Z
    //   752: ifeq -362 -> 390
    //   755: aload_0
    //   756: bipush 243
    //   758: aload_0
    //   759: getfield 759  com/android/server/PowerManagerService:mUserState   I
    //   762: iand
    //   763: putfield 759  com/android/server/PowerManagerService:mUserState   I
    //   766: goto -376 -> 390
    //   769: astore 21
    //   771: lload 18
    //   773: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   776: goto -358 -> 418
    //   779: astore 20
    //   781: lload 18
    //   783: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   786: aload 20
    //   788: athrow
    //   789: aload_0
    //   790: ldc_w 2219
    //   793: putfield 630  com/android/server/PowerManagerService:mUserActivityReason  Ljava/lang/String;
    //   796: goto -347 -> 449
    //   799: ldc 89
    //   801: new 831   java/lang/StringBuilder
    //   804: dup
    //   805: invokespecial 832 java/lang/StringBuilder:<init>  ()V
    //   808: ldc_w 2221
    //   811: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   814: aload_0
    //   815: getfield 495  com/android/server/PowerManagerService:mLastEventTime   J
    //   818: invokevirtual 1641    java/lang/StringBuilder:append  (J)Ljava/lang/StringBuilder;
    //   821: ldc_w 1643
    //   824: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   827: lload_1
    //   828: invokevirtual 1641    java/lang/StringBuilder:append  (J)Ljava/lang/StringBuilder;
    //   831: ldc_w 2223
    //   834: invokevirtual 838 java/lang/StringBuilder:append  (Ljava/lang/String;)Ljava/lang/StringBuilder;
    //   837: iload 7
    //   839: invokevirtual 887 java/lang/StringBuilder:append  (Z)Ljava/lang/StringBuilder;
    //   842: invokevirtual 843 java/lang/StringBuilder:toString    ()Ljava/lang/String;
    //   845: invokestatic 1279 android/util/Slog:e (Ljava/lang/String;Ljava/lang/String;)I
    //   848: pop
    //   849: goto -273 -> 576
    //   852: iload 7
    //   854: ifeq -278 -> 576
    //   857: goto -589 -> 268
    //   860: iconst_1
    //   861: istore 16
    //   863: goto -553 -> 310
    //   866: iconst_3
    //   867: istore 26
    //   869: goto -189 -> 680
    //
    // Exception table:
    //   from   to  target  type
    //   62 69  147 finally
    //   74 81  147 finally
    //   81 127 147 finally
    //   127    146 147 finally
    //   149    152 147 finally
    //   160    212 147 finally
    //   213    232 147 finally
    //   232    241 147 finally
    //   246    265 147 finally
    //   268    307 147 finally
    //   321    334 147 finally
    //   338    344 147 finally
    //   344    351 147 finally
    //   356    367 147 finally
    //   367    373 147 finally
    //   390    400 147 finally
    //   413    418 147 finally
    //   418    437 147 finally
    //   442    449 147 finally
    //   449    500 147 finally
    //   505    537 147 finally
    //   537    576 147 finally
    //   576    584 147 finally
    //   614    624 147 finally
    //   638    649 147 finally
    //   663    676 147 finally
    //   680    689 147 finally
    //   692    702 147 finally
    //   705    723 147 finally
    //   726    736 147 finally
    //   748    766 147 finally
    //   771    776 147 finally
    //   781    789 147 finally
    //   789    796 147 finally
    //   799    849 147 finally
    //   400    413 769 android/os/RemoteException
    //   400    413 779 finally
  }

  public void acquireDVFSLock(int paramInt1, int paramInt2, IBinder paramIBinder, String paramString)
  {
    int i = Binder.getCallingUid();
    int j = Binder.getCallingPid();
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    long l = Binder.clearCallingIdentity();
    try
    {
      synchronized (this.mDVFSLocks)
      {
        acquireDVFSLockLocked(paramInt1, paramInt2, paramIBinder, i, j, paramString);
        return;
      }
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  public void acquirePersistentDVFSLock(int paramInt1, int paramInt2, int paramInt3, String paramString)
  {
    int i = Binder.getCallingUid();
    int j = Binder.getCallingPid();
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    long l = Binder.clearCallingIdentity();
    try
    {
      synchronized (this.mDVFSLocks)
      {
        if ((paramInt3 & this.mPersistentDVFSLocksInfo) == 0)
        {
          Binder localBinder = new Binder();
          Slog.d("PowerManagerService", "acquirePersistentDVFSLock : prev mPersistentDVFSLocksInfo : 0x" + Integer.toHexString(this.mPersistentDVFSLocksInfo) + "  type : " + paramInt1 + "  frequency : " + paramInt2 + "  callingId : 0x" + Integer.toHexString(paramInt3) + "  token : " + localBinder + " tag : " + paramString);
          this.mMapPersistentDVFSLock.put(Integer.valueOf(paramInt3), localBinder);
          acquireDVFSLockLocked(paramInt1, paramInt2, localBinder, i, j, paramString);
          this.mPersistentDVFSLocksInfo = (paramInt3 | this.mPersistentDVFSLocksInfo);
          return;
        }
        Slog.e("PowerManagerService", "acquirePersistentDVFSLock : this callingId already acquired PersistentDVFSLock " + paramInt3);
      }
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  public void acquireWakeLock(int paramInt, IBinder paramIBinder, String paramString, WorkSource paramWorkSource)
  {
    int i = Binder.getCallingUid();
    int j = Binder.getCallingPid();
    if (i != Process.myUid())
      this.mContext.enforceCallingOrSelfPermission("android.permission.WAKE_LOCK", null);
    if (paramWorkSource != null)
      enforceWakeSourcePermission(i, j);
    long l = Binder.clearCallingIdentity();
    try
    {
      synchronized (this.mLocks)
      {
        acquireWakeLockLocked(paramInt, paramIBinder, i, j, paramString, paramWorkSource);
        return;
      }
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  public void acquireWakeLockLocked(int paramInt1, IBinder paramIBinder, int paramInt2, int paramInt3, String paramString, WorkSource paramWorkSource)
  {
    if ((paramWorkSource != null) && (paramWorkSource.size() == 0))
      paramWorkSource = null;
    int i = this.mLocks.getIndex(paramIBinder);
    WakeLock localWakeLock;
    label159: int j;
    boolean bool;
    WorkSource localWorkSource;
    if (i < 0)
    {
      localWakeLock = new WakeLock(paramInt1, paramIBinder, paramString, paramInt2, paramInt3);
      switch (0x3F & localWakeLock.flags)
      {
      default:
        Slog.e("PowerManagerService", "bad wakelock type for lock '" + paramString + "' " + " flags=" + paramInt1);
        return;
      case 26:
        localWakeLock.minState = 15;
      case 1:
      case 32:
        this.mLocks.addLock(localWakeLock);
        if (paramWorkSource != null)
          localWakeLock.ws = new WorkSource(paramWorkSource);
        j = 1;
        bool = false;
        localWorkSource = null;
        localWakeLock.acqTime = SystemClock.elapsedRealtime();
        if (isScreenLock(paramInt1))
          if ((paramInt1 & 0x3F) == 32)
          {
            this.mProximityWakeLockCount = (1 + this.mProximityWakeLockCount);
            Slog.d("PowerManagerService", "acquireWakeLock : PROXIMITY_SCREEN_OFF_WAKE_LOCK : mProximityWakeLockCount : " + this.mProximityWakeLockCount + "  tag=" + paramString + " uid=" + paramInt2 + " pid=" + paramInt3);
            if (this.mProximityWakeLockCount == 1)
              enableProximityLockLocked();
          }
        break;
      case 10:
      case 6:
      }
    }
    while (true)
    {
      if (bool)
        noteStopWakeLocked(localWakeLock, localWorkSource);
      if ((j == 0) && (!bool))
        break;
      noteStartWakeLocked(localWakeLock, paramWorkSource);
      return;
      localWakeLock.minState = 3;
      break label159;
      localWakeLock.minState = 1;
      break label159;
      localWakeLock = (WakeLock)this.mLocks.get(i);
      localWorkSource = localWakeLock.ws;
      if (localWorkSource != null)
        if (paramWorkSource == null)
        {
          localWakeLock.ws = null;
          bool = true;
        }
      while (true)
      {
        j = 0;
        if (!bool)
          break;
        localWakeLock.ws = new WorkSource(paramWorkSource);
        j = 0;
        break;
        bool = localWorkSource.diff(paramWorkSource);
        continue;
        if (paramWorkSource != null)
          bool = true;
        else
          bool = false;
      }
      label507: int k;
      label529: StringBuilder localStringBuilder;
      if ((0x10000000 & localWakeLock.flags) != 0)
      {
        this.mWakeLockState = this.mLocks.reactivateScreenLocksLocked();
        if (((0x1 & this.mWakeLockState) != 0) && (this.mProximitySensorActive) && (this.mProximityWakeLockCount == 0))
          this.mProximitySensorActive = false;
        if ((isScreenOn()) || ((this.mWakeLockState | this.mUserState) == 0))
          break label649;
        k = 1;
        localStringBuilder = new StringBuilder();
        if (k == 0)
          break label655;
      }
      label649: label655: for (String str = "Screen__On : "; ; str = "")
      {
        Slog.d("PowerManagerService", str + "acquireWakeLock flags=0x" + Integer.toHexString(paramInt1) + " tag=" + paramString + " uid=" + paramInt2 + " pid=" + paramInt3);
        setPowerState(this.mWakeLockState | this.mUserState);
        break;
        this.mWakeLockState = ((this.mUserState | this.mWakeLockState) & this.mLocks.gatherState());
        break label507;
        k = 0;
        break label529;
      }
      if ((paramInt1 & 0x3F) == 1)
      {
        if (j != 0)
        {
          this.mPartialCount = (1 + this.mPartialCount);
          Object[] arrayOfObject = new Object[2];
          arrayOfObject[0] = Integer.valueOf(1);
          arrayOfObject[1] = paramString;
          EventLog.writeEvent(2729, arrayOfObject);
          if (this.mPartialCount != 1);
        }
        if (!this.mForceDisableWakeLock)
          nativeAcquireWakeLock(1, "PowerManagerService");
        else
          Slog.d("PowerManagerService", "acquireWakeLockLocked : mForceDisableWakeLock : NOT acquired : " + paramString);
      }
    }
  }

  void bootCompleted()
  {
    Slog.d("PowerManagerService", "bootCompleted");
    synchronized (this.mLocks)
    {
      this.mBootCompleted = true;
      userActivity(SystemClock.uptimeMillis(), false, 1, true);
      updateWakeLockLocked();
      this.mLocks.notifyAll();
      SystemProperties.set("ctl.stop", "powersnd");
      return;
    }
  }

  public void clearUserActivityTimeout(long paramLong1, long paramLong2)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    Slog.i("PowerManagerService", "clearUserActivity for " + paramLong2 + "ms from now");
    this.mUserActivityReason = "clearUserActivityTimeout";
    userActivity(paramLong1, paramLong2, false, 0, false, false);
  }

  public void crash(final String paramString)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.REBOOT", null);
    Thread local17 = new Thread("PowerManagerService.crash()")
    {
      public void run()
      {
        throw new RuntimeException(paramString);
      }
    };
    try
    {
      local17.start();
      local17.join();
      return;
    }
    catch (InterruptedException localInterruptedException)
    {
      Log.wtf("PowerManagerService", localInterruptedException);
    }
  }

  public void dump(FileDescriptor paramFileDescriptor, PrintWriter paramPrintWriter, String[] paramArrayOfString)
  {
    if (this.mContext.checkCallingOrSelfPermission("android.permission.DUMP") != 0)
    {
      paramPrintWriter.println("Permission Denial: can't dump PowerManager from from pid=" + Binder.getCallingPid() + ", uid=" + Binder.getCallingUid());
      return;
    }
    long l1 = SystemClock.uptimeMillis();
    while (true)
    {
      synchronized (this.mLocks)
      {
        paramPrintWriter.println("Power Manager State:");
        paramPrintWriter.println("  mIsPowered=" + this.mIsPowered + " mPowerState=" + this.mPowerState + " mScreenOffTime=" + (SystemClock.elapsedRealtime() - this.mScreenOffTime) + " ms");
        paramPrintWriter.println("  mPartialCount=" + this.mPartialCount);
        paramPrintWriter.println("  mWakeLockState=" + dumpPowerState(this.mWakeLockState));
        paramPrintWriter.println("  mUserState=" + dumpPowerState(this.mUserState));
        paramPrintWriter.println("  mPowerState=" + dumpPowerState(this.mPowerState));
        paramPrintWriter.println("  mLocks.gather=" + dumpPowerState(this.mLocks.gatherState()));
        paramPrintWriter.println("  mNextTimeout=" + this.mNextTimeout + " now=" + l1 + " " + (this.mNextTimeout - l1) / 1000L + "s from now");
        paramPrintWriter.println("  mDimScreen=" + this.mDimScreen + " mStayOnConditions=" + this.mStayOnConditions + " mPreparingForScreenOn=" + this.mPreparingForScreenOn + " mSkippedScreenOn=" + this.mSkippedScreenOn);
        paramPrintWriter.println("  mScreenOffReason=" + this.mScreenOffReason + " mUserState=" + this.mUserState);
        paramPrintWriter.println("  mBroadcastQueue={" + this.mBroadcastQueue[0] + ',' + this.mBroadcastQueue[1] + ',' + this.mBroadcastQueue[2] + "}");
        paramPrintWriter.println("  mBroadcastWhy={" + this.mBroadcastWhy[0] + ',' + this.mBroadcastWhy[1] + ',' + this.mBroadcastWhy[2] + "}");
        paramPrintWriter.println("  mPokey=" + this.mPokey + " mPokeAwakeonSet=" + this.mPokeAwakeOnSet);
        paramPrintWriter.println("  mKeyboardVisible=" + this.mKeyboardVisible + " mUserActivityAllowed=" + this.mUserActivityAllowed);
        paramPrintWriter.println("  mKeylightDelay=" + this.mKeylightDelay + " mDimDelay=" + this.mDimDelay + " mScreenOffDelay=" + this.mScreenOffDelay);
        paramPrintWriter.println("  mPreventScreenOn=" + this.mPreventScreenOn + "  mScreenBrightnessOverride=" + this.mScreenBrightnessOverride + "  mButtonBrightnessOverride=" + this.mButtonBrightnessOverride);
        paramPrintWriter.println("  mScreenOffTimeoutSetting=" + this.mScreenOffTimeoutSetting + " mMaximumScreenOffTimeout=" + this.mMaximumScreenOffTimeout);
        paramPrintWriter.println("  mButtonOffTimeoutSetting=" + this.mButtonOffTimeoutSetting);
        paramPrintWriter.println("  mIsSipVisible=" + this.mIsSipVisible);
        paramPrintWriter.println("  mIsNorthAmericaSalesCode=" + mIsNorthAmericaSalesCode);
        paramPrintWriter.println("  mLastScreenOnTime=" + this.mLastScreenOnTime);
        paramPrintWriter.println("  mBroadcastWakeLock=" + this.mBroadcastWakeLock);
        paramPrintWriter.println("  mStayOnWhilePluggedInScreenDimLock=" + this.mStayOnWhilePluggedInScreenDimLock);
        paramPrintWriter.println("  mStayOnWhilePluggedInPartialLock=" + this.mStayOnWhilePluggedInPartialLock);
        paramPrintWriter.println("  mPreventScreenOnPartialLock=" + this.mPreventScreenOnPartialLock);
        paramPrintWriter.println("  mProximityPartialLock=" + this.mProximityPartialLock);
        paramPrintWriter.println("  mProximityWakeLockCount=" + this.mProximityWakeLockCount);
        paramPrintWriter.println("  mProximitySensorEnabled=" + this.mProximitySensorEnabled);
        paramPrintWriter.println("  mProximitySensorActive=" + this.mProximitySensorActive);
        paramPrintWriter.println("  mProximityPendingValue=" + this.mProximityPendingValue);
        paramPrintWriter.println("  mLastProximityEventTime=" + this.mLastProximityEventTime);
        paramPrintWriter.println("  mLightSensorEnabled=" + this.mLightSensorEnabled + " mLightSensorAdjustSetting=" + this.mLightSensorAdjustSetting);
        paramPrintWriter.println("  mLightSensorValue=" + this.mLightSensorValue + " mLightSensorPendingValue=" + this.mLightSensorPendingValue);
        paramPrintWriter.println("  mHighestLightSensorValue=" + this.mHighestLightSensorValue + " mWaitingForFirstLightSensor=" + this.mWaitingForFirstLightSensor);
        paramPrintWriter.println("  mLightSensorPendingDecrease=" + this.mLightSensorPendingDecrease + " mLightSensorPendingIncrease=" + this.mLightSensorPendingIncrease);
        paramPrintWriter.println("  mLightSensorScreenBrightness=" + this.mLightSensorScreenBrightness + " mLightSensorButtonBrightness=" + this.mLightSensorButtonBrightness + " mLightSensorKeyboardBrightness=" + this.mLightSensorKeyboardBrightness);
        paramPrintWriter.println("  mLightSensorScreenBrightnessUpperLimit=" + this.mLightSensorScreenBrightnessUpperLimit);
        paramPrintWriter.println("  mLightSensorScreenBrightnessLowerLimit=" + this.mLightSensorScreenBrightnessLowerLimit);
        paramPrintWriter.println("  mUseSoftwareAutoBrightness=" + this.mUseSoftwareAutoBrightness);
        paramPrintWriter.println("  mAutoBrightessEnabled=" + this.mAutoBrightessEnabled);
        paramPrintWriter.println("  mMaxBrightness=" + this.mMaxBrightness);
        paramPrintWriter.println("  mIsTablet=" + this.mIsTablet);
        paramPrintWriter.println("  mIsSecuredLock=" + this.mIsSecuredLock);
        paramPrintWriter.println("  mIsDeviceLockTime=" + this.mIsDeviceLockTime);
        paramPrintWriter.println("  mDeviceLockTimeoutSetting=" + this.mDeviceLockTimeoutSetting);
        paramPrintWriter.println("  GLOBALCONFIG_LCD_AMOLED_DISPLAY=true");
        paramPrintWriter.println("  GLOBALCONFIG_LCD_MDNIE_FUNCTION=false");
        paramPrintWriter.println("  GLOBALCONFIG_LCD_SUPPORT_CABC=false");
        paramPrintWriter.println("  GLOBALCONFIG_LCD_MSM8655CABC=false");
        paramPrintWriter.println("  GLOBALCONFIG_CAMERA_ENABLE_FACE_SERVICE=false");
        paramPrintWriter.println("  SEC_PRODUCT_FEATURE_CAMERA_DELAY_TIME_FOR_SMART_STAY=" + Integer.parseInt("2000"));
        paramPrintWriter.println("  mSmartSleepEnabled=" + this.mSmartSleepEnabled);
        paramPrintWriter.println("  mSmartSleepDelay=" + this.mSmartSleepDelay);
        paramPrintWriter.println("  GLOBALCONFIG_SETTINGS_SUPPORT_AUTOMATIC_BRIGHTNESS_DETAIL=false");
        paramPrintWriter.println("  mDynamicAutoBrightnessEnabled=" + this.mDynamicAutoBrightnessEnabled);
        paramPrintWriter.println("  mAutoPowerOffTimeoutSetting=" + this.mAutoPowerOffTimeoutSetting);
        paramPrintWriter.println("  mStrAutoBrightnessLevels=" + mStrAutoBrightnessLevels);
        paramPrintWriter.println("  mStrAutoBrightnessHysteresisLevels=" + mStrAutoBrightnessHysteresisLevels);
        paramPrintWriter.println("  mStrLcdBacklightValues=" + mStrLcdBacklightValues);
        if (this.mDynamicAutoBrightnessEnabled)
        {
          paramPrintWriter.println("  mStrLowHysteresisPoints=" + mStrLowHysteresisPoints);
          paramPrintWriter.println("  mStrBrightnessValuePoints=" + mStrBrightnessValuePoints);
          paramPrintWriter.println("  mStrHighHysteresisPoints=" + mStrHighHysteresisPoints);
          paramPrintWriter.println("  mStrMinimumExpressiveBrightnessValues=" + mStrMinimumExpressiveBrightnessValues);
        }
        this.mScreenBrightnessAnimator.dump(paramPrintWriter, "mScreenBrightnessAnimator: ");
        int i = this.mLocks.size();
        paramPrintWriter.println();
        paramPrintWriter.println("mLocks.size=" + i + ":");
        long l2 = SystemClock.elapsedRealtime();
        int j = 0;
        if (j < i)
        {
          WakeLock localWakeLock = (WakeLock)this.mLocks.get(j);
          String str1 = lockType(0x3F & localWakeLock.flags);
          String str2 = "";
          if ((0x10000000 & localWakeLock.flags) != 0)
            str2 = "ACQUIRE_CAUSES_WAKEUP ";
          String str3 = "";
          if (localWakeLock.activated)
            str3 = " activated";
          long l3 = l2 - localWakeLock.acqTime;
          paramPrintWriter.println("  " + str1 + " '" + localWakeLock.tag + "'" + str2 + str3 + " (minState=" + localWakeLock.minState + ", uid=" + localWakeLock.uid + ", pid=" + localWakeLock.pid + ")" + "activeT=" + l3);
          j++;
          continue;
        }
        paramPrintWriter.println();
        paramPrintWriter.println("mForceDisableWakeLock=" + this.mForceDisableWakeLock);
        paramPrintWriter.println();
        paramPrintWriter.println("mPokeLocks.size=" + this.mPokeLocks.size() + ":");
        Iterator localIterator = this.mPokeLocks.values().iterator();
        if (!localIterator.hasNext())
          break label2508;
        PokeLock localPokeLock = (PokeLock)localIterator.next();
        StringBuilder localStringBuilder1 = new StringBuilder().append("    poke lock '").append(localPokeLock.tag).append("':");
        if ((0x1 & localPokeLock.pokey) != 0)
        {
          str6 = " POKE_LOCK_IGNORE_TOUCH_EVENTS";
          StringBuilder localStringBuilder2 = localStringBuilder1.append(str6);
          if ((0x2 & localPokeLock.pokey) == 0)
            break label2746;
          str7 = " POKE_LOCK_SHORT_TIMEOUT";
          StringBuilder localStringBuilder3 = localStringBuilder2.append(str7);
          if ((0x4 & localPokeLock.pokey) == 0)
            break label2754;
          str8 = " POKE_LOCK_MEDIUM_TIMEOUT";
          paramPrintWriter.println(str8);
        }
      }
      String str6 = "";
      continue;
      label2508: paramPrintWriter.println();
      int k = this.mDVFSLocks.size();
      paramPrintWriter.println("mDVFSLocks.size=" + k + ":");
      int m = 0;
      if (m < k)
      {
        DVFSLock localDVFSLock = (DVFSLock)this.mDVFSLocks.get(m);
        String str4 = DVFSLockType(localDVFSLock.type);
        String str5 = "";
        long l4 = SystemClock.elapsedRealtime() - localDVFSLock.acqTime;
        if (localDVFSLock == this.mCurrentDVFSMinLock)
          str5 = " <--- mCurrentDVFSMinLock";
        while (true)
        {
          paramPrintWriter.println("  type : " + str4 + "  freq : " + localDVFSLock.frequency + "  elapsed time : " + l4 + "  tag : " + localDVFSLock.tag + str5);
          m++;
          break;
          if (localDVFSLock == this.mCurrentDVFSMaxLock)
            str5 = " <--- mCurrentDVFSMaxLock";
        }
      }
      paramPrintWriter.println("  mPersistentDVFSLocksInfo=0x" + Integer.toHexString(this.mPersistentDVFSLocksInfo));
      paramPrintWriter.println();
      return;
      label2746: String str7 = "";
      continue;
      label2754: String str8 = "";
    }
  }

  public void enableUserActivity(boolean paramBoolean)
  {
    Slog.d("PowerManagerService", "enableUserActivity " + paramBoolean);
    synchronized (this.mLocks)
    {
      this.mUserActivityAllowed = paramBoolean;
      if (!paramBoolean)
        setTimeoutLocked(SystemClock.uptimeMillis(), 0);
      return;
    }
  }

  void enforceWakeSourcePermission(int paramInt1, int paramInt2)
  {
    if (paramInt1 == Process.myUid())
      return;
    this.mContext.enforcePermission("android.permission.UPDATE_DEVICE_STATS", paramInt2, paramInt1, null);
  }

  public void forceDisableWakeLock(boolean paramBoolean)
  {
    Slog.i("PowerManagerService", "forceDisableWakeLock : " + paramBoolean + "  (mForceDisableWakeLock : " + this.mForceDisableWakeLock + ")");
    LockList localLockList = this.mLocks;
    if (paramBoolean);
    try
    {
      this.mForceDisableWakeLock = true;
      if (this.mPartialCount > 0)
        nativeReleaseWakeLock("PowerManagerService");
      while (true)
      {
        return;
        this.mForceDisableWakeLock = false;
        if (this.mPartialCount > 0)
          nativeAcquireWakeLock(1, "PowerManagerService");
      }
    }
    finally
    {
    }
  }

  public float getCurrentBrightness(boolean paramBoolean)
  {
    while (true)
    {
      float f1;
      synchronized (this.mScreenBrightnessAnimator)
      {
        if (this.mScreenBrightnessAnimator.isAnimating())
        {
          f1 = this.mScreenBrightnessAnimator.endValue;
          if (paramBoolean)
          {
            f2 = f1 / 255.0F;
            Slog.d("PowerManagerService", "getCurrentBrightness : ratio : " + paramBoolean + "  retValue : " + f2);
            return f2;
          }
        }
        else
        {
          f1 = this.mScreenBrightnessAnimator.currentValue;
        }
      }
      float f2 = (int)f1;
    }
  }

  WindowManagerPolicy getPolicyLocked()
  {
    while ((this.mPolicy == null) || (!this.mDoneBooting))
      try
      {
        this.mLocks.wait();
      }
      catch (InterruptedException localInterruptedException)
      {
      }
    return this.mPolicy;
  }

  int getStayOnConditionsLocked()
  {
    if ((this.mMaximumScreenOffTimeout <= 0) || (this.mMaximumScreenOffTimeout == 2147483647))
      return this.mStayOnConditions;
    return 0;
  }

  public int[] getSupportedFrequency()
  {
    return this.mSupportedFrequency;
  }

  public int getSupportedWakeLockFlags()
  {
    int i = 31;
    if (this.mProximitySensor != null)
      i |= 32;
    return i;
  }

  public void goToSleep(long paramLong)
  {
    goToSleepWithReason(paramLong, 2);
  }

  public void goToSleepWithReason(long paramLong, int paramInt)
  {
    Slog.d("PowerManagerService", "goToSleepWithReason : time : " + paramLong + " reason : " + paramInt);
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    synchronized (this.mLocks)
    {
      goToSleepLocked(paramLong, paramInt);
      return;
    }
  }

  void init(Context paramContext, LightsService paramLightsService, IActivityManager paramIActivityManager, BatteryService paramBatteryService)
  {
    this.mLightsService = paramLightsService;
    this.mContext = paramContext;
    this.mActivityService = paramIActivityManager;
    this.mBatteryStats = BatteryStatsService.getService();
    this.mBatteryService = paramBatteryService;
    this.mLcdLight = paramLightsService.getLight(0);
    this.mButtonLight = paramLightsService.getLight(2);
    this.mKeyboardLight = paramLightsService.getLight(1);
    this.mAttentionLight = paramLightsService.getLight(5);
    this.mHeadless = "1".equals(SystemProperties.get("ro.config.headless", "0"));
    this.mInitComplete = false;
    this.mScreenBrightnessAnimator = new ScreenBrightnessAnimator("mScreenBrightnessUpdaterThread", -4);
    this.mScreenBrightnessAnimator.start();
    synchronized (this.mScreenBrightnessAnimator)
    {
      while (true)
      {
        boolean bool1 = this.mInitComplete;
        if (bool1)
          break;
        try
        {
          this.mScreenBrightnessAnimator.wait();
        }
        catch (InterruptedException localInterruptedException2)
        {
        }
      }
      this.mInitComplete = false;
      this.mHandlerThread = new HandlerThread("PowerManagerService")
      {
        protected void onLooperPrepared()
        {
          super.onLooperPrepared();
          PowerManagerService.this.initInThread();
        }
      };
      this.mHandlerThread.start();
    }
    synchronized (this.mHandlerThread)
    {
      while (true)
      {
        boolean bool2 = this.mInitComplete;
        if (bool2)
          break;
        try
        {
          this.mHandlerThread.wait();
        }
        catch (InterruptedException localInterruptedException1)
        {
        }
      }
      localObject1 = finally;
      throw localObject1;
    }
    synchronized (this.mLocks)
    {
      updateNativePowerStateLocked();
      forceUserActivityLocked();
      this.mInitialized = true;
      return;
      localObject2 = finally;
      throw localObject2;
    }
  }

  void initInThread()
  {
    this.mHandler = new Handler();
    this.mBroadcastWakeLock = new UnsynchronizedWakeLock(1, "sleep_broadcast", true);
    this.mStayOnWhilePluggedInScreenDimLock = new UnsynchronizedWakeLock(6, "StayOnWhilePluggedIn Screen Dim", false);
    this.mStayOnWhilePluggedInPartialLock = new UnsynchronizedWakeLock(1, "StayOnWhilePluggedIn Partial", false);
    this.mPreventScreenOnPartialLock = new UnsynchronizedWakeLock(1, "PreventScreenOn Partial", false);
    this.mProximityPartialLock = new UnsynchronizedWakeLock(1, "Proximity Partial", false);
    this.mAutoPowerOffPartialLock = new UnsynchronizedWakeLock(1, "AutoPowerOff Partial", false);
    this.mScreenOnIntent = new Intent("android.intent.action.SCREEN_ON");
    this.mScreenOnIntent.addFlags(1342177280);
    this.mScreenOffIntent = new Intent("android.intent.action.SCREEN_OFF");
    this.mScreenOffIntent.addFlags(1342177280);
    this.mSmartSleepIntent = new Intent("com.android.server.PowerManagerService.action.FAILED_TO_DETECT_FACE_BEFORE_DIM", null);
    this.mIsTablet = isTablet();
    Resources localResources = this.mContext.getResources();
    this.mAnimateScreenLights = localResources.getBoolean(17891348);
    this.mUnplugTurnsOnScreen = localResources.getBoolean(17891347);
    this.mScreenBrightnessDim = localResources.getInteger(17694755);
    this.mUseSoftwareAutoBrightness = localResources.getBoolean(17891345);
    if (this.mUseSoftwareAutoBrightness)
    {
      this.mAutoBrightnessLevels = localResources.getIntArray(17236011);
      this.mLcdBacklightValues = localResources.getIntArray(17236013);
      this.mButtonBacklightValues = localResources.getIntArray(17236014);
      this.mKeyboardBacklightValues = localResources.getIntArray(17236015);
      this.mLightSensorWarmupTime = localResources.getInteger(17694758);
      this.mAutoBrightnessHysteresisLevels = localResources.getIntArray(17236012);
      this.mDynamicAutoBrightnessEnabled = localResources.getBoolean(17891363);
      if (this.mDynamicAutoBrightnessEnabled)
      {
        Slog.d("PowerManagerService", "Dynamic AutoBrightness is Enabled. mDynamicAutoBrightnessEnabled = " + this.mDynamicAutoBrightnessEnabled);
        this.mLowLimitAtHighestAutoBrightnessLevel = localResources.getInteger(17694756);
        this.mValueOfVirtualZeroCandela = localResources.getInteger(17694757);
        this.mLowHysteresisLevels = localResources.getIntArray(17236017);
        this.mLowHysteresisValuesOrg = localResources.getIntArray(17236018);
        this.mLowHysteresisValues = localResources.getIntArray(17236018);
        this.mBrightnessLevels = localResources.getIntArray(17236019);
        this.mBrightnessValuesOrg = localResources.getIntArray(17236020);
        this.mBrightnessValues = localResources.getIntArray(17236020);
        this.mHighHysteresisLevels = localResources.getIntArray(17236021);
        this.mHighHysteresisValuesOrg = localResources.getIntArray(17236022);
        this.mHighHysteresisValues = localResources.getIntArray(17236022);
        if (this.mIsTablet)
          this.mMinimumExpressiveBrightnessValues = localResources.getIntArray(17236016);
        setDynamicAutoBrightnessSlopeTables();
      }
      printAutoBrightnessTables();
      if (!this.mAutoBrightessEnabled)
        break label948;
    }
    label948: for (int i = 1; ; i = 0)
    {
      sendBrightnessModeBySysfs(i);
      this.mSettings = new ContentQueryMap(this.mContext.getContentResolver().query(Settings.System.CONTENT_URI, null, "(name=?) or (name=?) or (name=?) or (name=?) or (name=?) or (name=?) or (name=?) or (name=?) or (name=?)", new String[] { "stay_on_while_plugged_in", "screen_off_timeout", "dim_screen", "screen_brightness", "screen_brightness_mode", "window_animation_scale", "transition_animation_scale", "button_key_light", "is_secured_lock" }, null), "name", true, this.mHandler);
      SettingsObserver localSettingsObserver = new SettingsObserver(null);
      this.mSettings.addObserver(localSettingsObserver);
      localSettingsObserver.update(this.mSettings, null);
      IntentFilter localIntentFilter1 = new IntentFilter();
      localIntentFilter1.addAction("android.intent.action.BATTERY_CHANGED");
      this.mContext.registerReceiver(new BatteryReceiver(null), localIntentFilter1);
      IntentFilter localIntentFilter2 = new IntentFilter();
      localIntentFilter2.addAction("android.intent.action.BOOT_COMPLETED");
      this.mContext.registerReceiver(new BootCompletedReceiver(null), localIntentFilter2);
      IntentFilter localIntentFilter3 = new IntentFilter();
      localIntentFilter3.addAction("android.intent.action.DOCK_EVENT");
      this.mContext.registerReceiver(new DockReceiver(null), localIntentFilter3);
      IntentFilter localIntentFilter4 = new IntentFilter();
      localIntentFilter4.addAction("com.android.server.PowerManagerService.action.AUTO_POWER_OFF");
      this.mContext.registerReceiver(new AutoPowerOffReceiver(null), localIntentFilter4);
      this.mContext.registerReceiver(this.mSipIntentReceiver, new IntentFilter("ResponseAxT9Info"));
      IntentFilter localIntentFilter5 = new IntentFilter();
      localIntentFilter5.addAction("android.intent.action.PROXIMITY_CP");
      this.mContext.registerReceiver(new ProximityFromCPReceiver(null), localIntentFilter5);
      initSupportedFrequency();
      if (this.mSupportedFrequency != null)
        this.mAMOLEDAnimationDVFSLock = new UnsynchronizedDVFSLock(1, this.mSupportedFrequency[0], "AMOLED_Animation");
      this.mContext.getContentResolver().registerContentObserver(Settings.Secure.CONTENT_URI, true, new ContentObserver(new Handler())
      {
        public void onChange(boolean paramAnonymousBoolean)
        {
          PowerManagerService.this.updateSettingsValues();
        }
      });
      updateSettingsValues();
      synchronized (this.mHandlerThread)
      {
        this.mInitComplete = true;
        this.mHandlerThread.notifyAll();
        return;
      }
    }
  }

  boolean isScreenBright()
  {
    while (true)
    {
      synchronized (this.mLocks)
      {
        if ((0x3 & this.mPowerState) == 3)
        {
          bool = true;
          return bool;
        }
      }
      boolean bool = false;
    }
  }

  public boolean isScreenOn()
  {
    while (true)
    {
      synchronized (this.mLocks)
      {
        if ((0x1 & this.mPowerState) != 0)
        {
          bool = true;
          return bool;
        }
      }
      boolean bool = false;
    }
  }

  void logPointerDownEvent()
  {
    if (this.mLastTouchDown == 0L)
    {
      this.mLastTouchDown = SystemClock.elapsedRealtime();
      this.mTouchCycles = (1 + this.mTouchCycles);
    }
  }

  void logPointerUpEvent()
  {
    this.mTotalTouchDownTime += SystemClock.elapsedRealtime() - this.mLastTouchDown;
    this.mLastTouchDown = 0L;
  }

  public void monitor()
  {
    synchronized (this.mLocks)
    {
    }
  }

  void noteStartWakeLocked(WakeLock paramWakeLock, WorkSource paramWorkSource)
  {
    long l;
    if (paramWakeLock.monitorType >= 0)
    {
      l = Binder.clearCallingIdentity();
      if (paramWorkSource == null)
        break label42;
    }
    try
    {
      this.mBatteryStats.noteStartWakelockFromSource(paramWorkSource, paramWakeLock.pid, paramWakeLock.tag, paramWakeLock.monitorType);
      while (true)
      {
        return;
        label42: this.mBatteryStats.noteStartWakelock(paramWakeLock.uid, paramWakeLock.pid, paramWakeLock.tag, paramWakeLock.monitorType);
      }
    }
    catch (RemoteException localRemoteException)
    {
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  void noteStopWakeLocked(WakeLock paramWakeLock, WorkSource paramWorkSource)
  {
    long l;
    if (paramWakeLock.monitorType >= 0)
    {
      l = Binder.clearCallingIdentity();
      if (paramWorkSource == null)
        break label42;
    }
    try
    {
      this.mBatteryStats.noteStopWakelockFromSource(paramWorkSource, paramWakeLock.pid, paramWakeLock.tag, paramWakeLock.monitorType);
      while (true)
      {
        return;
        label42: this.mBatteryStats.noteStopWakelock(paramWakeLock.uid, paramWakeLock.pid, paramWakeLock.tag, paramWakeLock.monitorType);
      }
    }
    catch (RemoteException localRemoteException)
    {
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  public void preventAutoPowerOff(int paramInt, boolean paramBoolean)
  {
    Slog.d("PowerManagerService", "preventAutoPowerOff : " + paramInt + "  bPrevent : " + paramBoolean);
    Integer localInteger = (Integer)this.mMapPreventAutoPowerOff.get(Integer.valueOf(paramInt));
    int i;
    int j;
    if (localInteger == null)
    {
      Slog.d("PowerManagerService", "preventAutoPowerOff : " + paramInt + "  bPrevent : " + paramBoolean);
      this.mMapPreventAutoPowerOff.put(Integer.valueOf(paramInt), Integer.valueOf(0));
      i = 0;
      if (!paramBoolean)
        break label163;
      j = i + 1;
    }
    while (true)
    {
      this.mMapPreventAutoPowerOff.put(Integer.valueOf(paramInt), Integer.valueOf(j));
      Slog.d("PowerManagerService", "preventAutoPowerOff : resetAutoPowerOffTimer()");
      resetAutoPowerOffTimer();
      return;
      i = localInteger.intValue();
      break;
      label163: j = i - 1;
      if (j < 0)
      {
        Slog.e("PowerManagerService", "currentCount < 0 : " + paramInt);
        j = 0;
      }
    }
  }

  public void preventScreenOn(boolean paramBoolean)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    synchronized (this.mLocks)
    {
      Slog.d("PowerManagerService", "preventScreenOn : " + paramBoolean);
      if (paramBoolean)
      {
        this.mPreventScreenOnPartialLock.acquire();
        this.mHandler.removeCallbacks(this.mForceReenableScreenTask);
        this.mHandler.postDelayed(this.mForceReenableScreenTask, 5000L);
        this.mPreventScreenOn = true;
        return;
      }
      this.mPreventScreenOn = false;
      this.mHandler.removeCallbacks(this.mForceReenableScreenTask);
      if ((!this.mProximitySensorActive) && ((0x1 & this.mPowerState) != 0))
      {
        int i = setScreenStateLocked(true);
        if (i != 0)
          Slog.w("PowerManagerService", "preventScreenOn: error from setScreenStateLocked(): " + i);
      }
      this.mPreventScreenOnPartialLock.release();
    }
  }

  public void reboot(final String paramString)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.REBOOT", null);
    if ((this.mHandler == null) || (!ActivityManagerNative.isSystemReady()))
      throw new IllegalStateException("Too early to call reboot()");
    Runnable local15 = new Runnable()
    {
      public void run()
      {
        try
        {
          ShutdownThread.reboot(PowerManagerService.this.mContext, paramString, false);
          return;
        }
        finally
        {
        }
      }
    };
    this.mHandler.post(local15);
    try
    {
      while (true)
        label56: local15.wait();
    }
    catch (InterruptedException localInterruptedException)
    {
      break label56;
    }
    finally
    {
    }
  }

  public void releaseDVFSLock(IBinder paramIBinder)
  {
    Binder.getCallingUid();
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    long l = Binder.clearCallingIdentity();
    try
    {
      synchronized (this.mDVFSLocks)
      {
        releaseDVFSLockLocked(paramIBinder);
        return;
      }
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  public void releasePersistentDVFSLock(int paramInt)
  {
    Binder.getCallingUid();
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    long l = Binder.clearCallingIdentity();
    while (true)
    {
      try
      {
        synchronized (this.mDVFSLocks)
        {
          if ((paramInt & this.mPersistentDVFSLocksInfo) != 0)
          {
            IBinder localIBinder = (IBinder)this.mMapPersistentDVFSLock.remove(Integer.valueOf(paramInt));
            if (localIBinder != null)
            {
              Slog.d("PowerManagerService", "releasePersistentDVFSLock : prev mPersistentDVFSLocksInfo : 0x" + Integer.toHexString(this.mPersistentDVFSLocksInfo) + "  callingId : 0x" + Integer.toHexString(paramInt));
              releaseDVFSLockLocked(localIBinder);
              this.mPersistentDVFSLocksInfo &= (paramInt ^ 0xFFFFFFFF);
              return;
            }
            Slog.e("PowerManagerService", "releasePersistentDVFSLock : there is no persistentDVFSLock to release");
            throw new RuntimeException("WakeLock under-locked " + paramInt);
          }
        }
      }
      finally
      {
        Binder.restoreCallingIdentity(l);
      }
      Slog.e("PowerManagerService", "releasePersistentDVFSLock : this callingId already released PersistentDVFSLock " + paramInt);
    }
  }

  public void releaseWakeLock(IBinder paramIBinder, int paramInt)
  {
    if (Binder.getCallingUid() != Process.myUid())
      this.mContext.enforceCallingOrSelfPermission("android.permission.WAKE_LOCK", null);
    synchronized (this.mLocks)
    {
      releaseWakeLockLocked(paramIBinder, paramInt, false);
      return;
    }
  }

  public void resetAutoPowerOffTimer()
  {
    Slog.d("PowerManagerService", "resetAutoPowerOffTimer : " + this.mAutoPowerOffTimeoutSetting);
    if (this.mAutoPowerOffTimeoutSetting > 0)
    {
      this.mHandler.removeCallbacks(this.mUpdateAutoPowerOffTimeTask);
      this.mHandler.post(this.mUpdateAutoPowerOffTimeTask);
    }
  }

  public void setAttentionLight(boolean paramBoolean, int paramInt)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    LightsService.Light localLight = this.mAttentionLight;
    if (paramBoolean);
    for (int i = 3; ; i = 0)
    {
      localLight.setFlashing(paramInt, 2, i, 0);
      return;
    }
  }

  public void setAutoBrightnessAdjustment(float paramFloat)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    synchronized (this.mLocks)
    {
      this.mLightSensorAdjustSetting = paramFloat;
      long l;
      if ((this.mSensorManager != null) && (this.mLightSensorEnabled))
        l = Binder.clearCallingIdentity();
      try
      {
        if (this.mLightSensorValue >= 0.0F)
        {
          int i = (int)this.mLightSensorValue;
          this.mLightSensorValue = -1.0F;
          handleLightSensorValue(i, true);
        }
        Binder.restoreCallingIdentity(l);
        return;
      }
      finally
      {
        localObject2 = finally;
        Binder.restoreCallingIdentity(l);
        throw localObject2;
      }
    }
  }

  public void setAutoBrightnessLimit(int paramInt1, int paramInt2)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    Slog.d("PowerManagerService", "setAutoBrightnessLimit : lowerLimit " + paramInt1 + "   upperLimit : " + paramInt2);
    synchronized (this.mLocks)
    {
      if ((this.mLightSensorScreenBrightnessLowerLimit != paramInt1) || (this.mLightSensorScreenBrightnessUpperLimit != paramInt2))
      {
        this.mLightSensorScreenBrightnessLowerLimit = paramInt1;
        this.mLightSensorScreenBrightnessUpperLimit = paramInt2;
        int i = (int)this.mLightSensorValue;
        this.mLightSensorValue = -1.0F;
        lightSensorChangedLocked(i, false);
      }
      return;
    }
  }

  public void setBacklightBrightness(int paramInt)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    int i = Binder.getCallingPid();
    int j = Binder.getCallingUid();
    Slog.d("PowerManagerService", "setBacklightBrightness " + paramInt + "  uid : " + j + "pid : " + i);
    if (isScreenTurningOffLocked())
    {
      Slog.w("PowerManagerService", "but, isScreenTurningOffLocked : TRUE , so should be ignored");
      return;
    }
    if (!isScreenOn())
    {
      Slog.w("PowerManagerService", "but, isScreenOn : false , so should be ignored");
      return;
    }
    int k;
    long l;
    synchronized (this.mLocks)
    {
      k = Math.max(paramInt, this.mScreenBrightnessDim);
      if (this.mSystemPowerSaveModeEnabled)
      {
        int m = k - POWERSAVEMODE_BRIGHTNESS_OFFSET;
        if (k > 0)
        {
          k = Math.max(m, 10);
          Slog.d("PowerManagerService", "setBacklightBrightness : mSystemPowerSaveModeEnabled:: brightness:" + k);
        }
      }
      if ((this.mMaxBrightness >= 0) && (k > this.mMaxBrightness))
      {
        k = this.mMaxBrightness;
        Slog.d("PowerManagerService", "setBacklightBrightness : brightness is changed to " + k + " because of temperature");
      }
      this.mLcdLight.setBrightness(k);
      l = Binder.clearCallingIdentity();
    }
    try
    {
      this.mBatteryStats.noteScreenBrightness(k);
      Binder.restoreCallingIdentity(l);
      this.mScreenBrightnessAnimator.animateTo(k, 2, 0);
      return;
      localObject1 = finally;
      throw localObject1;
    }
    catch (RemoteException localRemoteException)
    {
      while (true)
      {
        Slog.w("PowerManagerService", "RemoteException calling noteScreenBrightness on BatteryStatsService", localRemoteException);
        Binder.restoreCallingIdentity(l);
      }
    }
    finally
    {
      Binder.restoreCallingIdentity(l);
    }
  }

  public void setButtonBrightnessOverride(int paramInt)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    synchronized (this.mLocks)
    {
      if (this.mButtonBrightnessOverride != paramInt)
      {
        this.mButtonBrightnessOverride = paramInt;
        Slog.d("PowerManagerService", "setButtonBrightnessOverride : mButtonBrightnessOverride : " + this.mButtonBrightnessOverride);
        if (isScreenOn())
          updateLightsLocked(this.mPowerState, 12);
      }
      return;
    }
  }

  public void setKeyboardVisibility(boolean paramBoolean)
  {
    synchronized (this.mLocks)
    {
      if (this.mKeyboardVisible != paramBoolean)
      {
        this.mKeyboardVisible = paramBoolean;
        if ((0x1 & this.mPowerState) != 0)
        {
          if ((this.mUseSoftwareAutoBrightness) && (this.mLightSensorValue >= 0.0F))
          {
            int i = (int)this.mLightSensorValue;
            this.mLightSensorValue = -1.0F;
            lightSensorChangedLocked(i, false);
          }
          this.mUserActivityReason = "mKeyboardVisible";
          userActivity(SystemClock.uptimeMillis(), false, 1, true);
        }
      }
      return;
    }
  }

  public void setMasterBrightnessLimit(int paramInt1, int paramInt2)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    Slog.d("PowerManagerService", "setMasterBrightnessLimit : reserved " + paramInt1 + "   upperLimit : " + paramInt2);
    LockList localLockList = this.mLocks;
    if ((paramInt2 != -1) && (paramInt2 < 0))
      try
      {
        throw new IllegalArgumentException("setMasterBrightnessLimit : invalid upperLimit");
      }
      finally
      {
      }
    this.mMaxBrightness = paramInt2;
    Slog.d("PowerManagerService", "setMasterBrightnessLimit : mMaxBrightness : " + this.mMaxBrightness);
    updateLightsLocked(this.mPowerState, 3);
  }

  public void setMaximumScreenOffTimeount(int paramInt)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.WRITE_SECURE_SETTINGS", null);
    synchronized (this.mLocks)
    {
      this.mMaximumScreenOffTimeout = paramInt;
      Slog.i("PowerManagerService", "setMaximumScreenOffTimeount : mMaximumScreenOffTimeout : " + this.mMaximumScreenOffTimeout);
      setScreenOffTimeoutsLocked();
      return;
    }
  }

  public void setPokeLock(int paramInt, IBinder paramIBinder, String paramString)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    Slog.d("PowerManagerService", "setPokeLock pokey=" + paramInt + " tag=" + paramString);
    if (paramIBinder == null)
    {
      Slog.e("PowerManagerService", "setPokeLock got null token for tag='" + paramString + "'");
      return;
    }
    if ((paramInt & 0x16) == 22)
      throw new IllegalArgumentException("setPokeLock can't have both POKE_LOCK_SHORT_TIMEOUT and POKE_LOCK_MEDIUM_TIMEOUT");
    LockList localLockList = this.mLocks;
    if (paramInt != 0);
    int i;
    int j;
    boolean bool;
    while (true)
    {
      try
      {
        PokeLock localPokeLock3 = (PokeLock)this.mPokeLocks.get(paramIBinder);
        if (localPokeLock3 != null)
        {
          k = localPokeLock3.pokey;
          localPokeLock3.pokey = paramInt;
          int m = k & 0x16;
          int n = paramInt & 0x16;
          if (((0x1 & this.mPowerState) == 0) && (m != n))
            localPokeLock3.awakeOnSet = true;
          i = this.mPokey;
          j = 0;
          bool = false;
          Iterator localIterator = this.mPokeLocks.values().iterator();
          if (!localIterator.hasNext())
            break;
          PokeLock localPokeLock2 = (PokeLock)localIterator.next();
          j |= localPokeLock2.pokey;
          if (!localPokeLock2.awakeOnSet)
            continue;
          bool = true;
          continue;
        }
        localPokeLock3 = new PokeLock(paramInt, paramIBinder, paramString);
        this.mPokeLocks.put(paramIBinder, localPokeLock3);
        int k = 0;
        continue;
      }
      finally
      {
      }
      PokeLock localPokeLock1 = (PokeLock)this.mPokeLocks.remove(paramIBinder);
      if (localPokeLock1 != null)
        paramIBinder.unlinkToDeath(localPokeLock1, 0);
    }
    this.mPokey = j;
    this.mPokeAwakeOnSet = bool;
    if ((i & 0x16) != (paramInt & 0x16))
    {
      setScreenOffTimeoutsLocked();
      setTimeoutLocked(SystemClock.uptimeMillis(), this.mTimeoutTask.nextState);
    }
  }

  public void setPolicy(WindowManagerPolicy paramWindowManagerPolicy)
  {
    synchronized (this.mLocks)
    {
      this.mPolicy = paramWindowManagerPolicy;
      this.mLocks.notifyAll();
      return;
    }
  }

  public void setRatioOfAutoBrightness(int paramInt)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    Slog.d("PowerManagerService", "setRatioOfAutoBrightness " + paramInt);
    if (isScreenTurningOffLocked())
    {
      Slog.w("PowerManagerService", "but, isScreenTurningOffLocked : TRUE , so should be ignored");
      return;
    }
    if (!isScreenOn())
    {
      Slog.w("PowerManagerService", "but, isScreenOn : false , so should be ignored");
      return;
    }
    synchronized (this.mLocks)
    {
      int i = this.mDynamicAutoBrightnessRatioValueSetting;
      this.mDynamicAutoBrightnessRatioValueSetting = paramInt;
      Slog.d("PowerManagerService", "setRatioOfAutoBrightness : mDynamicAutoBrightnessRatioValueSetting : " + this.mDynamicAutoBrightnessRatioValueSetting);
      if (i != this.mDynamicAutoBrightnessRatioValueSetting)
      {
        this.mDynamicAutoBrightnessRatio = convertSettingsRatioToWeightedRatio(this.mDynamicAutoBrightnessRatioValueSetting);
        Slog.d("PowerManagerService", "setRatioOfAutoBrightness : mDynamicAutoBrightnessRatio : " + this.mDynamicAutoBrightnessRatio);
        this.mLowHysteresisLux = -1;
        this.mHighHysteresisLux = -1;
        int j = (int)this.mLightSensorValue;
        this.mLightSensorValue = -1.0F;
        lightSensorChangedLocked(j, true);
      }
      return;
    }
  }

  public void setScreenBrightnessOverride(int paramInt)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    synchronized (this.mLocks)
    {
      if (this.mScreenBrightnessOverride != paramInt)
      {
        this.mScreenBrightnessOverride = paramInt;
        Slog.d("PowerManagerService", "setScreenBrightnessOverride : mScreenBrightnessOverride : " + this.mScreenBrightnessOverride);
        if (isScreenOn())
          updateLightsLocked(this.mPowerState, 1);
      }
      return;
    }
  }

  public void setStayOnSetting(int paramInt)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.WRITE_SETTINGS", null);
    Settings.System.putInt(this.mContext.getContentResolver(), "stay_on_while_plugged_in", paramInt);
  }

  public void setSystemPowerSaveMode(boolean paramBoolean)
  {
    Slog.d("PowerManagerService", "setSystemPowerSaveMode is called: " + paramBoolean);
    this.mSystemPowerSaveModeEnabled = paramBoolean;
    updateLightsLocked(this.mPowerState, 3);
  }

  // ERROR //
  void systemReady()
  {
    // Byte code:
    //   0: aload_0
    //   1: new 2990    android/hardware/SystemSensorManager
    //   4: dup
    //   5: aload_0
    //   6: getfield 2655   com/android/server/PowerManagerService:mHandlerThread   Landroid/os/HandlerThread;
    //   9: invokevirtual 2994  android/os/HandlerThread:getLooper  ()Landroid/os/Looper;
    //   12: invokespecial 2997 android/hardware/SystemSensorManager:<init> (Landroid/os/Looper;)V
    //   15: putfield 961   com/android/server/PowerManagerService:mSensorManager   Landroid/hardware/SensorManager;
    //   18: aload_0
    //   19: aload_0
    //   20: getfield 961   com/android/server/PowerManagerService:mSensorManager   Landroid/hardware/SensorManager;
    //   23: bipush 8
    //   25: invokevirtual 3001 android/hardware/SensorManager:getDefaultSensor (I)Landroid/hardware/Sensor;
    //   28: putfield 957   com/android/server/PowerManagerService:mProximitySensor Landroid/hardware/Sensor;
    //   31: aload_0
    //   32: getfield 1589  com/android/server/PowerManagerService:mUseSoftwareAutoBrightness   Z
    //   35: ifeq +27 -> 62
    //   38: aload_0
    //   39: aload_0
    //   40: getfield 961   com/android/server/PowerManagerService:mSensorManager   Landroid/hardware/SensorManager;
    //   43: iconst_5
    //   44: invokevirtual 3001 android/hardware/SensorManager:getDefaultSensor (I)Landroid/hardware/Sensor;
    //   47: putfield 1429  com/android/server/PowerManagerService:mLightSensor Landroid/hardware/Sensor;
    //   50: aload_0
    //   51: aload_0
    //   52: getfield 961   com/android/server/PowerManagerService:mSensorManager   Landroid/hardware/SensorManager;
    //   55: iconst_1
    //   56: invokevirtual 3001 android/hardware/SensorManager:getDefaultSensor (I)Landroid/hardware/Sensor;
    //   59: putfield 1435  com/android/server/PowerManagerService:mTiltSensor  Landroid/hardware/Sensor;
    //   62: aload_0
    //   63: getfield 1589  com/android/server/PowerManagerService:mUseSoftwareAutoBrightness   Z
    //   66: ifeq +129 -> 195
    //   69: aload_0
    //   70: iconst_3
    //   71: invokespecial 1056 com/android/server/PowerManagerService:setPowerState    (I)V
    //   74: aload_0
    //   75: aload_0
    //   76: getfield 1005  com/android/server/PowerManagerService:mContext Landroid/content/Context;
    //   79: ldc_w 3003
    //   82: invokevirtual 1354 android/content/Context:getSystemService    (Ljava/lang/String;)Ljava/lang/Object;
    //   85: checkcast 3005 android/app/AlarmManager
    //   88: putfield 1159  com/android/server/PowerManagerService:mAlarmManager    Landroid/app/AlarmManager;
    //   91: new 2677   android/content/Intent
    //   94: dup
    //   95: ldc 12
    //   97: aconst_null
    //   98: invokespecial 2690 android/content/Intent:<init>   (Ljava/lang/String;Landroid/net/Uri;)V
    //   101: astore_1
    //   102: aload_0
    //   103: aload_0
    //   104: getfield 1005 com/android/server/PowerManagerService:mContext Landroid/content/Context;
    //   107: iconst_0
    //   108: aload_1
    //   109: iconst_0
    //   110: invokestatic 3011 android/app/PendingIntent:getBroadcast  (Landroid/content/Context;ILandroid/content/Intent;I)Landroid/app/PendingIntent;
    //   113: putfield 1155 com/android/server/PowerManagerService:mAutoPowerOffPendingIntent   Landroid/app/PendingIntent;
    //   116: aload_0
    //   117: getfield 502  com/android/server/PowerManagerService:mLocks   Lcom/android/server/PowerManagerService$LockList;
    //   120: astore_2
    //   121: aload_2
    //   122: monitorenter
    //   123: ldc 89
    //   125: ldc_w 3013
    //   128: invokestatic 1214 android/util/Slog:d (Ljava/lang/String;Ljava/lang/String;)I
    //   131: pop
    //   132: aload_0
    //   133: iconst_1
    //   134: putfield 460  com/android/server/PowerManagerService:mDoneBooting Z
    //   137: aload_0
    //   138: getfield 1589 com/android/server/PowerManagerService:mUseSoftwareAutoBrightness   Z
    //   141: ifeq +63 -> 204
    //   144: aload_0
    //   145: getfield 1112 com/android/server/PowerManagerService:mAutoBrightessEnabled    Z
    //   148: ifeq +56 -> 204
    //   151: iconst_1
    //   152: istore 5
    //   154: aload_0
    //   155: iload 5
    //   157: invokespecial 2074    com/android/server/PowerManagerService:enableLightSensorLocked  (Z)V
    //   160: invokestatic 738  android/os/Binder:clearCallingIdentity  ()J
    //   163: lstore 6
    //   165: aload_0
    //   166: getfield 2046 com/android/server/PowerManagerService:mBatteryStats    Lcom/android/internal/app/IBatteryStats;
    //   169: aload_0
    //   170: invokespecial 2048    com/android/server/PowerManagerService:getPreferredBrightness   ()I
    //   173: invokeinterface 2053 2 0
    //   178: aload_0
    //   179: getfield 2046 com/android/server/PowerManagerService:mBatteryStats    Lcom/android/internal/app/IBatteryStats;
    //   182: invokeinterface 2056 1 0
    //   187: lload 6
    //   189: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   192: aload_2
    //   193: monitorexit
    //   194: return
    //   195: aload_0
    //   196: bipush 15
    //   198: invokespecial 1056    com/android/server/PowerManagerService:setPowerState    (I)V
    //   201: goto -127 -> 74
    //   204: iconst_0
    //   205: istore 5
    //   207: goto -53 -> 154
    //   210: astore 9
    //   212: lload 6
    //   214: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   217: goto -25 -> 192
    //   220: astore_3
    //   221: aload_2
    //   222: monitorexit
    //   223: aload_3
    //   224: athrow
    //   225: astore 8
    //   227: lload 6
    //   229: invokestatic 755  android/os/Binder:restoreCallingIdentity    (J)V
    //   232: aload 8
    //   234: athrow
    //
    // Exception table:
    //   from   to  target  type
    //   165    187 210 android/os/RemoteException
    //   123    151 220 finally
    //   154    165 220 finally
    //   187    192 220 finally
    //   192    194 220 finally
    //   212    217 220 finally
    //   221    223 220 finally
    //   227    235 220 finally
    //   165    187 225 finally
  }

  public long timeSinceScreenOn()
  {
    synchronized (this.mLocks)
    {
      if ((0x1 & this.mPowerState) != 0)
        return 0L;
      long l = SystemClock.elapsedRealtime() - this.mScreenOffTime;
      return l;
    }
  }

  public void updateBlockedUids(int paramInt, boolean paramBoolean)
  {
    LockList localLockList = this.mLocks;
    for (int i = 0; ; i++)
      try
      {
        if (i < this.mLocks.size())
        {
          WakeLock localWakeLock = (WakeLock)this.mLocks.get(i);
          if ((localWakeLock != null) && ((localWakeLock.uid == paramInt) || (localWakeLock.uid == 1000)) && (paramBoolean))
          {
            releaseWakeLockLocked(localWakeLock.binder, localWakeLock.flags, false);
            localWakeLock.isReleasedInternal = true;
          }
        }
        else
        {
          return;
        }
      }
      finally
      {
      }
  }

  public void updateWakeLockWorkSource(IBinder paramIBinder, WorkSource paramWorkSource)
  {
    int i = Binder.getCallingUid();
    int j = Binder.getCallingPid();
    if ((paramWorkSource != null) && (paramWorkSource.size() == 0))
      paramWorkSource = null;
    if (paramWorkSource != null)
      enforceWakeSourcePermission(i, j);
    int k;
    synchronized (this.mLocks)
    {
      k = this.mLocks.getIndex(paramIBinder);
      if (k < 0)
        throw new IllegalArgumentException("Wake lock not active");
    }
    WakeLock localWakeLock = (WakeLock)this.mLocks.get(k);
    WorkSource localWorkSource1 = localWakeLock.ws;
    if (paramWorkSource != null);
    for (WorkSource localWorkSource2 = new WorkSource(paramWorkSource); ; localWorkSource2 = null)
    {
      localWakeLock.ws = localWorkSource2;
      noteStopWakeLocked(localWakeLock, localWorkSource1);
      noteStartWakeLocked(localWakeLock, paramWorkSource);
      return;
    }
  }

  public void userActivity(long paramLong, boolean paramBoolean)
  {
    if (this.mContext.checkCallingOrSelfPermission("android.permission.DEVICE_POWER") != 0)
    {
      if (shouldLog(paramLong))
        Slog.w("PowerManagerService", "Caller does not have DEVICE_POWER permission.  pid=" + Binder.getCallingPid() + " uid=" + Binder.getCallingUid());
      return;
    }
    userActivity(paramLong, -1L, paramBoolean, 0, false, false);
  }

  public void userActivity(long paramLong, boolean paramBoolean, int paramInt)
  {
    userActivity(paramLong, -1L, paramBoolean, paramInt, false, false);
  }

  public void userActivity(long paramLong, boolean paramBoolean1, int paramInt, boolean paramBoolean2)
  {
    userActivity(paramLong, -1L, paramBoolean1, paramInt, paramBoolean2, false);
  }

  public void userActivityWithForce(long paramLong, boolean paramBoolean1, boolean paramBoolean2)
  {
    this.mContext.enforceCallingOrSelfPermission("android.permission.DEVICE_POWER", null);
    this.mUserActivityReason = "userActivityWithForce";
    userActivity(paramLong, -1L, paramBoolean1, 0, paramBoolean2, false);
  }

  private final class AutoPowerOffReceiver extends BroadcastReceiver
  {
    private AutoPowerOffReceiver()
    {
    }

    public void onReceive(Context paramContext, Intent paramIntent)
    {
      PowerManagerService.this.shutdown("AutoPowerOff");
    }
  }

  private final class BatteryReceiver extends BroadcastReceiver
  {
    private BatteryReceiver()
    {
    }

    public void onReceive(Context paramContext, Intent paramIntent)
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        boolean bool = PowerManagerService.this.mIsPowered;
        PowerManagerService.access$902(PowerManagerService.this, PowerManagerService.this.mBatteryService.isPowered());
        PowerManagerService.LockList localLockList2;
        if (PowerManagerService.this.mIsPowered != bool)
        {
          PowerManagerService.access$1102(PowerManagerService.this, true);
          PowerManagerService.this.updateWakeLockLocked();
          localLockList2 = PowerManagerService.this.mLocks;
          if (!bool);
        }
        try
        {
          if (((0x1 & PowerManagerService.this.mPowerState) != 0) || (PowerManagerService.this.mUnplugTurnsOnScreen))
          {
            PowerManagerService.access$1402(PowerManagerService.this, "battery plug");
            PowerManagerService.this.forceUserActivityLocked();
          }
          return;
        }
        finally
        {
        }
      }
    }
  }

  private final class BootCompletedReceiver extends BroadcastReceiver
  {
    private BootCompletedReceiver()
    {
    }

    public void onReceive(Context paramContext, Intent paramIntent)
    {
      PowerManagerService.this.bootCompleted();
    }
  }

  private class DVFSLock
    implements IBinder.DeathRecipient
  {
    long acqTime;
    final IBinder binder;
    final int frequency;
    final int pid;
    final String tag;
    final int type;
    final int uid;

    DVFSLock(int paramInt1, int paramIBinder, IBinder paramString, String paramInt2, int paramInt3, int arg7)
    {
      this.type = paramInt1;
      this.frequency = paramIBinder;
      this.binder = paramString;
      this.tag = paramInt2;
      if (paramInt3 == PowerManagerService.this.MY_UID)
        paramInt3 = 1000;
      this.uid = paramInt3;
      int i;
      this.pid = i;
      try
      {
        paramString.linkToDeath(this, 0);
        return;
      }
      catch (RemoteException localRemoteException)
      {
        binderDied();
      }
    }

    public void binderDied()
    {
      synchronized (PowerManagerService.this.mDVFSLocks)
      {
        Slog.e("PowerManagerService", "DVFSLock : binderDied : tag : " + this.tag);
        PowerManagerService.this.releaseDVFSLockLocked(this.binder);
        return;
      }
    }
  }

  private class DVFSLockList extends ArrayList<PowerManagerService.DVFSLock>
  {
    private DVFSLockList()
    {
    }

    void addLock(PowerManagerService.DVFSLock paramDVFSLock)
    {
      if (getIndex(paramDVFSLock.binder) < 0)
        add(paramDVFSLock);
    }

    void dumpDVFSLockList()
    {
      while (true)
      {
        int j;
        int k;
        synchronized (PowerManagerService.this.mDVFSLocks)
        {
          int i = size();
          if (i == 0)
            return;
          Slog.d("PowerManagerService", "dumpDVFSLockList : DVFS_MAX_LIMIT");
          j = 0;
          if (j < i)
          {
            if (((PowerManagerService.DVFSLock)get(j)).type == 2)
              Slog.d("PowerManagerService", "    " + j + " : tag : " + ((PowerManagerService.DVFSLock)get(j)).tag + "  frequency : " + ((PowerManagerService.DVFSLock)get(j)).frequency + "  elapsed time : " + (SystemClock.elapsedRealtime() - ((PowerManagerService.DVFSLock)get(j)).acqTime));
          }
          else
          {
            Slog.d("PowerManagerService", "dumpDVFSLockList : DVFS_MIN_LIMIT");
            k = 0;
            if (k < i)
            {
              if (((PowerManagerService.DVFSLock)get(k)).type != 1)
                break label384;
              Slog.d("PowerManagerService", "    " + k + " : tag : " + ((PowerManagerService.DVFSLock)get(k)).tag + "  frequency : " + ((PowerManagerService.DVFSLock)get(k)).frequency + "  elapsed time : " + (SystemClock.elapsedRealtime() - ((PowerManagerService.DVFSLock)get(k)).acqTime));
              break label384;
            }
            if (PowerManagerService.this.mCurrentDVFSMaxLock != null)
              Slog.d("PowerManagerService", "dumpDVFSLockList : mCurrentDVFSMaxLock : " + getIndex(PowerManagerService.this.mCurrentDVFSMaxLock.binder));
            if (PowerManagerService.this.mCurrentDVFSMinLock != null)
              Slog.d("PowerManagerService", "dumpDVFSLockList : mCurrentDVFSMinLock : " + getIndex(PowerManagerService.this.mCurrentDVFSMinLock.binder));
            return;
          }
        }
        j++;
        continue;
        label384: k++;
      }
    }

    int getIndex(IBinder paramIBinder)
    {
      int i = size();
      for (int j = 0; j < i; j++)
        if (((PowerManagerService.DVFSLock)get(j)).binder == paramIBinder)
          return j;
      return -1;
    }

    PowerManagerService.DVFSLock getMaxOfMinLock()
    {
      int i = size();
      int j = -1;
      int k = -1;
      int m = 0;
      if (m < i)
      {
        int n;
        if (((PowerManagerService.DVFSLock)get(m)).type == 1)
        {
          n = ((PowerManagerService.DVFSLock)get(m)).frequency;
          if (k != -1)
            break label65;
          k = n;
          j = m;
        }
        while (true)
        {
          m++;
          break;
          label65: if (n > k)
          {
            k = n;
            j = m;
          }
        }
      }
      if (j >= 0)
        return (PowerManagerService.DVFSLock)get(j);
      return null;
    }

    PowerManagerService.DVFSLock getMinOfMaxLock()
    {
      int i = size();
      int j = -1;
      int k = -1;
      int m = 0;
      if (m < i)
      {
        int n;
        if (((PowerManagerService.DVFSLock)get(m)).type == 2)
        {
          n = ((PowerManagerService.DVFSLock)get(m)).frequency;
          if (k != -1)
            break label65;
          k = n;
          j = m;
        }
        while (true)
        {
          m++;
          break;
          label65: if (n < k)
          {
            k = n;
            j = m;
          }
        }
      }
      if (j >= 0)
        return (PowerManagerService.DVFSLock)get(j);
      return null;
    }

    PowerManagerService.DVFSLock removeLock(IBinder paramIBinder)
    {
      int i = getIndex(paramIBinder);
      if (i >= 0)
        return (PowerManagerService.DVFSLock)remove(i);
      return null;
    }
  }

  private final class DockReceiver extends BroadcastReceiver
  {
    private DockReceiver()
    {
    }

    public void onReceive(Context paramContext, Intent paramIntent)
    {
      int i = paramIntent.getIntExtra("android.intent.extra.DOCK_STATE", 0);
      PowerManagerService.this.dockStateChanged(i);
    }
  }

  private class LockList extends ArrayList<PowerManagerService.WakeLock>
  {
    private LockList()
    {
    }

    void addLock(PowerManagerService.WakeLock paramWakeLock)
    {
      if (getIndex(paramWakeLock.binder) < 0)
        add(paramWakeLock);
    }

    int gatherState()
    {
      int i = 0;
      int j = size();
      for (int k = 0; k < j; k++)
      {
        PowerManagerService.WakeLock localWakeLock = (PowerManagerService.WakeLock)get(k);
        if ((localWakeLock.activated) && (PowerManagerService.this.isScreenLock(localWakeLock.flags)))
          i |= localWakeLock.minState;
      }
      return i;
    }

    int getIndex(IBinder paramIBinder)
    {
      int i = size();
      for (int j = 0; j < i; j++)
        if (((PowerManagerService.WakeLock)get(j)).binder == paramIBinder)
          return j;
      return -1;
    }

    int reactivateScreenLocksLocked()
    {
      int i = 0;
      int j = size();
      for (int k = 0; k < j; k++)
      {
        PowerManagerService.WakeLock localWakeLock = (PowerManagerService.WakeLock)get(k);
        if (PowerManagerService.this.isScreenLock(localWakeLock.flags))
        {
          localWakeLock.activated = true;
          i |= localWakeLock.minState;
        }
      }
      if (!PowerManagerService.this.isScreenBright())
        Slog.d("PowerManagerService", "reactivateScreenLocksLocked mProxIgnoredBecauseScreenTurnedOff=" + PowerManagerService.this.mProxIgnoredBecauseScreenTurnedOff);
      PowerManagerService.access$9902(PowerManagerService.this, false);
      return i;
    }

    PowerManagerService.WakeLock removeLock(IBinder paramIBinder)
    {
      int i = getIndex(paramIBinder);
      if (i >= 0)
        return (PowerManagerService.WakeLock)remove(i);
      return null;
    }
  }

  private class PokeLock
    implements IBinder.DeathRecipient
  {
    boolean awakeOnSet;
    IBinder binder;
    int pokey;
    String tag;

    PokeLock(int paramIBinder, IBinder paramString, String arg4)
    {
      this.pokey = paramIBinder;
      this.binder = paramString;
      Object localObject;
      this.tag = localObject;
      try
      {
        paramString.linkToDeath(this, 0);
        return;
      }
      catch (RemoteException localRemoteException)
      {
        binderDied();
      }
    }

    public void binderDied()
    {
      Slog.e("PowerManagerService", "PokeLock : binderDied()");
      PowerManagerService.this.setPokeLock(0, this.binder, this.tag);
    }
  }

  private final class ProximityFromCPReceiver extends BroadcastReceiver
  {
    private ProximityFromCPReceiver()
    {
    }

    public void onReceive(Context paramContext, Intent paramIntent)
    {
      PowerManagerService.access$1702(PowerManagerService.this, paramIntent.getStringExtra("cmd").equals("on"));
      Slog.d("PowerManagerService", "ProximityFromCPReceiver : onReceive : " + PowerManagerService.this.mBoolProximityCP);
      if (PowerManagerService.this.mBoolProximityCP)
      {
        PowerManagerService.this.mSensorManager.registerListener(PowerManagerService.this.mProximityListenerForDataCall, PowerManagerService.this.mProximitySensor, 3);
        return;
      }
      PowerManagerService.this.mSensorManager.unregisterListener(PowerManagerService.this.mProximityListenerForDataCall);
    }
  }

  class ScreenBrightnessAnimator extends HandlerThread
  {
    static final int ANIMATE_LIGHTS = 10;
    static final int ANIMATE_POWER_OFF = 11;
    private int currentMask;
    volatile int currentValue;
    private int duration;
    volatile int endSensorValue;
    volatile int endValue;
    private final String prefix;
    volatile int startSensorValue;
    private long startTimeMillis;
    volatile int startValue;

    public ScreenBrightnessAnimator(String paramInt, int arg3)
    {
      super(i);
      this.prefix = paramInt;
    }

    private void animateInternal(int paramInt1, boolean paramBoolean, int paramInt2)
    {
      int j;
      int i1;
      while (true)
      {
        synchronized (PowerManagerService.this.mScreenBrightnessAnimator)
        {
          if (this.currentValue != this.endValue)
          {
            int i = (int)(SystemClock.elapsedRealtime() - this.startTimeMillis);
            if (i < this.duration)
            {
              int k = this.endValue - this.startValue;
              j = Math.min(255, Math.max(0, this.startValue + k * i / this.duration));
              if ((paramInt2 > 0) && (j == this.currentValue))
              {
                int n = this.duration / Math.abs(k);
                paramInt2 = Math.min(this.duration - i, n);
                if (k >= 0)
                  break label375;
                i1 = -1;
                break;
              }
              int m = this.endSensorValue - this.startSensorValue;
              PowerManagerService.access$7902(PowerManagerService.this, this.startSensorValue + m * i / this.duration);
              PowerManagerService.this.mScreenBrightnessHandler.removeMessages(10);
              Handler localHandler = PowerManagerService.this.mScreenBrightnessHandler;
              if (!paramBoolean)
                localHandler.obtainMessage(11, 16, 0).sendToTarget();
              Message localMessage = localHandler.obtainMessage(10, paramInt1, j);
              PowerManagerService.this.mScreenBrightnessHandler.sendMessageDelayed(localMessage, paramInt2);
              return;
            }
            j = this.endValue;
            PowerManagerService.access$7902(PowerManagerService.this, this.endSensorValue);
            if (this.endValue <= 0)
              continue;
            PowerManagerService.access$7202(PowerManagerService.this, false);
          }
        }
        Slog.i("PowerManagerService", "Light Animator Finished currentValue=" + this.currentValue);
        synchronized (PowerManagerService.this.mDVFSLocks)
        {
          if ((PowerManagerService.this.mAMOLEDAnimationDVFSLock != null) && (PowerManagerService.this.mAMOLEDAnimationDVFSLock.isHeld()))
            PowerManagerService.this.mAMOLEDAnimationDVFSLock.release();
        }
      }
      while (true)
      {
        j += i1;
        break;
        label375: i1 = 1;
      }
    }

    public void animateTo(int paramInt1, int paramInt2, int paramInt3)
    {
      animateTo(paramInt1, PowerManagerService.this.mHighestLightSensorValue, paramInt2, paramInt3);
    }

    // ERROR //
    public void animateTo(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
    {
      // Byte code:
      //   0: iconst_1
      //   1: istore 5
      //   3: aload_0
      //   4: getfield 26   com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   7: invokestatic 47   com/android/server/PowerManagerService:access$7000  (Lcom/android/server/PowerManagerService;)Lcom/android/server/PowerManagerService$ScreenBrightnessAnimator;
      //   10: astore 6
      //   12: aload 6
      //   14: monitorenter
      //   15: iload_3
      //   16: iconst_2
      //   17: iand
      //   18: ifne +42 -> 60
      //   21: iload_3
      //   22: iconst_4
      //   23: iand
      //   24: ifeq +14 -> 38
      //   27: aload_0
      //   28: getfield 26  com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   31: invokestatic 167 com/android/server/PowerManagerService:access$7400  (Lcom/android/server/PowerManagerService;)Lcom/android/server/LightsService$Light;
      //   34: iload_1
      //   35: invokevirtual 172    com/android/server/LightsService$Light:setBrightness    (I)V
      //   38: iload_3
      //   39: bipush 8
      //   41: iand
      //   42: ifeq +14 -> 56
      //   45: aload_0
      //   46: getfield 26  com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   49: invokestatic 175 com/android/server/PowerManagerService:access$7500  (Lcom/android/server/PowerManagerService;)Lcom/android/server/LightsService$Light;
      //   52: iload_1
      //   53: invokevirtual 172    com/android/server/LightsService$Light:setBrightness    (I)V
      //   56: aload 6
      //   58: monitorexit
      //   59: return
      //   60: aload_0
      //   61: invokevirtual 178    com/android/server/PowerManagerService$ScreenBrightnessAnimator:isAnimating ()Z
      //   64: ifeq +24 -> 88
      //   67: iload_3
      //   68: aload_0
      //   69: getfield 41  com/android/server/PowerManagerService$ScreenBrightnessAnimator:currentMask I
      //   72: ixor
      //   73: ifeq +15 -> 88
      //   76: ldc 114
      //   78: ldc 180
      //   80: invokestatic 183 android/util/Slog:w (Ljava/lang/String;Ljava/lang/String;)I
      //   83: pop
      //   84: aload_0
      //   85: invokevirtual 186    com/android/server/PowerManagerService$ScreenBrightnessAnimator:cancelAnimation ()V
      //   88: aload_0
      //   89: getfield 26  com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   92: invokestatic 190 com/android/server/PowerManagerService:access$7200  (Lcom/android/server/PowerManagerService;)Z
      //   95: ifeq +19 -> 114
      //   98: iconst_0
      //   99: istore 4
      //   101: iload_1
      //   102: ifle +12 -> 114
      //   105: aload_0
      //   106: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   109: iconst_0
      //   110: invokestatic 112    com/android/server/PowerManagerService:access$7202  (Lcom/android/server/PowerManagerService;Z)Z
      //   113: pop
      //   114: aload_0
      //   115: aload_0
      //   116: getfield 49 com/android/server/PowerManagerService$ScreenBrightnessAnimator:currentValue    I
      //   119: putfield 63 com/android/server/PowerManagerService$ScreenBrightnessAnimator:startValue  I
      //   122: aload_0
      //   123: iload_1
      //   124: putfield 51 com/android/server/PowerManagerService$ScreenBrightnessAnimator:endValue    I
      //   127: aload_0
      //   128: aload_0
      //   129: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   132: invokestatic 160    com/android/server/PowerManagerService:access$7900  (Lcom/android/server/PowerManagerService;)I
      //   135: putfield 80 com/android/server/PowerManagerService$ScreenBrightnessAnimator:startSensorValue    I
      //   138: aload_0
      //   139: iload_2
      //   140: putfield 78 com/android/server/PowerManagerService$ScreenBrightnessAnimator:endSensorValue  I
      //   143: aload_0
      //   144: iload_3
      //   145: putfield 41 com/android/server/PowerManagerService$ScreenBrightnessAnimator:currentMask I
      //   148: aload_0
      //   149: aload_0
      //   150: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   153: invokestatic 194    com/android/server/PowerManagerService:access$3800  (Lcom/android/server/PowerManagerService;)F
      //   156: iload 4
      //   158: i2f
      //   159: fmul
      //   160: f2i
      //   161: putfield 61 com/android/server/PowerManagerService$ScreenBrightnessAnimator:duration    I
      //   164: aload_0
      //   165: invokestatic 57 android/os/SystemClock:elapsedRealtime  ()J
      //   168: putfield 59 com/android/server/PowerManagerService$ScreenBrightnessAnimator:startTimeMillis J
      //   171: iload_1
      //   172: aload_0
      //   173: getfield 49 com/android/server/PowerManagerService$ScreenBrightnessAnimator:currentValue    I
      //   176: if_icmpeq +124 -> 300
      //   179: iload_3
      //   180: iconst_3
      //   181: iand
      //   182: ifeq +130 -> 312
      //   185: iload 5
      //   187: istore 9
      //   189: aload_0
      //   190: getfield 51 com/android/server/PowerManagerService$ScreenBrightnessAnimator:endValue    I
      //   193: ifne +125 -> 318
      //   196: iload 5
      //   198: ifeq +41 -> 239
      //   201: iload 9
      //   203: ifeq +36 -> 239
      //   206: aload_0
      //   207: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   210: invokestatic 88 com/android/server/PowerManagerService:access$6900  (Lcom/android/server/PowerManagerService;)Landroid/os/Handler;
      //   213: aconst_null
      //   214: invokevirtual 198   android/os/Handler:removeCallbacksAndMessages   (Ljava/lang/Object;)V
      //   217: aload_0
      //   218: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   221: aload_0
      //   222: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   225: invokestatic 201    com/android/server/PowerManagerService:access$8300  (Lcom/android/server/PowerManagerService;)I
      //   228: invokestatic 204    com/android/server/PowerManagerService:access$8400  (Lcom/android/server/PowerManagerService;I)I
      //   231: pop
      //   232: aload_0
      //   233: sipush 200
      //   236: putfield 61 com/android/server/PowerManagerService$ScreenBrightnessAnimator:duration    I
      //   239: iload 9
      //   241: ifeq +59 -> 300
      //   244: aload_0
      //   245: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   248: invokestatic 141    com/android/server/PowerManagerService:access$8000  (Lcom/android/server/PowerManagerService;)Lcom/android/server/PowerManagerService$DVFSLockList;
      //   251: astore 10
      //   253: aload 10
      //   255: monitorenter
      //   256: aload_0
      //   257: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   260: invokestatic 145    com/android/server/PowerManagerService:access$8100  (Lcom/android/server/PowerManagerService;)Lcom/android/server/PowerManagerService$UnsynchronizedDVFSLock;
      //   263: ifnull +26 -> 289
      //   266: aload_0
      //   267: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   270: invokestatic 145    com/android/server/PowerManagerService:access$8100  (Lcom/android/server/PowerManagerService;)Lcom/android/server/PowerManagerService$UnsynchronizedDVFSLock;
      //   273: invokevirtual 151   com/android/server/PowerManagerService$UnsynchronizedDVFSLock:isHeld    ()Z
      //   276: ifne +13 -> 289
      //   279: aload_0
      //   280: getfield 26 com/android/server/PowerManagerService$ScreenBrightnessAnimator:this$0  Lcom/android/server/PowerManagerService;
      //   283: invokestatic 145    com/android/server/PowerManagerService:access$8100  (Lcom/android/server/PowerManagerService;)Lcom/android/server/PowerManagerService$UnsynchronizedDVFSLock;
      //   286: invokevirtual 207   com/android/server/PowerManagerService$UnsynchronizedDVFSLock:acquire   ()V
      //   289: aload 10
      //   291: monitorexit
      //   292: aload_0
      //   293: iload_3
      //   294: iload 5
      //   296: iconst_0
      //   297: invokespecial 37    com/android/server/PowerManagerService$ScreenBrightnessAnimator:animateInternal (IZI)V
      //   300: aload 6
      //   302: monitorexit
      //   303: return
      //   304: astore 7
      //   306: aload 6
      //   308: monitorexit
      //   309: aload 7
      //   311: athrow
      //   312: iconst_0
      //   313: istore 9
      //   315: goto -126 -> 189
      //   318: iconst_0
      //   319: istore 5
      //   321: goto -125 -> 196
      //   324: astore 11
      //   326: aload 10
      //   328: monitorexit
      //   329: aload 11
      //   331: athrow
      //
      // Exception table:
      //   from to  target  type
      //   27   38  304 finally
      //   45   56  304 finally
      //   56   59  304 finally
      //   60   88  304 finally
      //   88   98  304 finally
      //   105  114 304 finally
      //   114  179 304 finally
      //   189  196 304 finally
      //   206  239 304 finally
      //   244  256 304 finally
      //   292  300 304 finally
      //   300  303 304 finally
      //   306  309 304 finally
      //   329  332 304 finally
      //   256  289 324 finally
      //   289  292 324 finally
      //   326  329 324 finally
    }

    public void cancelAnimation()
    {
      animateTo(this.endValue, this.currentMask, 0);
    }

    public void dump(PrintWriter paramPrintWriter, String paramString)
    {
      paramPrintWriter.println(paramString);
      paramPrintWriter.println("  animating: start:" + this.startValue + ", end:" + this.endValue + ", duration:" + this.duration + ", current:" + this.currentValue);
      paramPrintWriter.println("  startSensorValue:" + this.startSensorValue + " endSensorValue:" + this.endSensorValue);
      paramPrintWriter.println("  startTimeMillis:" + this.startTimeMillis + " now:" + SystemClock.elapsedRealtime());
      paramPrintWriter.println("  currentMask:" + PowerManagerService.dumpPowerState(this.currentMask));
    }

    public int getCurrentBrightness()
    {
      synchronized (PowerManagerService.this.mScreenBrightnessAnimator)
      {
        int i = this.currentValue;
        return i;
      }
    }

    public boolean isAnimating()
    {
      while (true)
      {
        synchronized (PowerManagerService.this.mScreenBrightnessAnimator)
        {
          if (this.currentValue != this.endValue)
          {
            bool = true;
            return bool;
          }
        }
        boolean bool = false;
      }
    }

    protected void onLooperPrepared()
    {
      PowerManagerService.access$6902(PowerManagerService.this, new Handler()
      {
        public void handleMessage(Message paramAnonymousMessage)
        {
          int i = 1;
          while (true)
          {
            long l2;
            synchronized (PowerManagerService.this.mScreenBrightnessAnimator)
            {
              boolean bool1 = PowerManagerService.this.mAutoBrightessEnabled;
              int j = 0;
              if (bool1)
              {
                boolean bool2 = PowerManagerService.this.mInitialAnimation;
                j = 0;
                if (!bool2)
                  j = i;
              }
              if (paramAnonymousMessage.what == 10)
              {
                int m = paramAnonymousMessage.arg1;
                int n = paramAnonymousMessage.arg2;
                long l1 = SystemClock.uptimeMillis();
                if ((m & 0x2) != 0)
                  PowerManagerService.this.mLcdLight.setBrightness(n, j);
                l2 = SystemClock.uptimeMillis() - l1;
                if ((m & 0x4) != 0)
                  PowerManagerService.this.mButtonLight.setBrightness(n);
                if ((m & 0x8) != 0)
                  PowerManagerService.this.mKeyboardLight.setBrightness(n);
                if (l2 > 100L)
                {
                  Slog.e("PowerManagerService", "Excessive delay setting brightness: " + l2 + "ms, mask=" + m);
                  break label269;
                  PowerManagerService.ScreenBrightnessAnimator.this.currentValue = n;
                  PowerManagerService.ScreenBrightnessAnimator.this.animateInternal(m, false, i);
                }
              }
              else
              {
                if (paramAnonymousMessage.what != 11)
                  continue;
                int k = paramAnonymousMessage.arg1;
                PowerManagerService.this.nativeStartSurfaceFlingerAnimation(k);
              }
            }
            label269: if (l2 < 16L)
              i = 16;
          }
        }
      });
      try
      {
        PowerManagerService.access$7802(PowerManagerService.this, true);
        notifyAll();
        return;
      }
      finally
      {
      }
    }
  }

  private class SettingsObserver
    implements Observer
  {
    private SettingsObserver()
    {
    }

    private float getFloat(String paramString, float paramFloat)
    {
      ContentValues localContentValues = PowerManagerService.this.mSettings.getValues(paramString);
      if (localContentValues != null);
      for (Float localFloat = localContentValues.getAsFloat("value"); ; localFloat = null)
      {
        if (localFloat != null)
          paramFloat = localFloat.floatValue();
        return paramFloat;
      }
    }

    private int getInt(String paramString, int paramInt)
    {
      ContentValues localContentValues = PowerManagerService.this.mSettings.getValues(paramString);
      if (localContentValues != null);
      for (Integer localInteger = localContentValues.getAsInteger("value"); ; localInteger = null)
      {
        if (localInteger != null)
          paramInt = localInteger.intValue();
        return paramInt;
      }
    }

    public void update(Observable paramObservable, Object paramObject)
    {
      while (true)
      {
        float f;
        synchronized (PowerManagerService.this.mLocks)
        {
          PowerManagerService.access$2202(PowerManagerService.this, getInt("stay_on_while_plugged_in", 1));
          PowerManagerService.this.updateWakeLockLocked();
          int i = PowerManagerService.this.mScreenOffTimeoutSetting;
          PowerManagerService.access$2302(PowerManagerService.this, getInt("screen_off_timeout", 15000));
          PowerManagerService.access$2402(PowerManagerService.this, getInt("is_secured_lock", 0));
          int j = getInt("button_key_light", 1500);
          int k = PowerManagerService.this.mButtonOffTimeoutSetting;
          int m = 0;
          if (k != j)
          {
            PowerManagerService.access$2502(PowerManagerService.this, j);
            m = 1;
          }
          PowerManagerService.access$2602(PowerManagerService.this, getInt("screen_brightness", 192));
          PowerManagerService.access$2702(PowerManagerService.this, 0.0F);
          PowerManagerService.this.setScreenBrightnessMode(getInt("screen_brightness_mode", 0));
          PowerManagerService.this.setScreenOffTimeoutsLocked();
          if (i != PowerManagerService.this.mScreenOffTimeoutSetting)
            PowerManagerService.this.setTimeoutLocked(SystemClock.uptimeMillis(), PowerManagerService.this.mTimeoutTask.nextState);
          int n = PowerManagerService.this.mAutoPowerOffTimeoutSetting;
          PowerManagerService.access$3202(PowerManagerService.this, Settings.System.getInt(PowerManagerService.this.mContext.getContentResolver(), "auto_power_off", 0));
          if ((PowerManagerService.this.mAutoPowerOffTimeoutSetting > 0) && (n != PowerManagerService.this.mAutoPowerOffTimeoutSetting))
          {
            PowerManagerService.this.mHandler.removeCallbacks(PowerManagerService.this.mUpdateAutoPowerOffTimeTask);
            long l = 1000L + SystemClock.uptimeMillis();
            PowerManagerService.this.mHandler.postAtTime(PowerManagerService.this.mUpdateAutoPowerOffTimeTask, l);
            PowerManagerService.this.mAutoPowerOffPartialLock.acquire();
          }
          if ((m == 1) && (PowerManagerService.this.isScreenOn()))
          {
            Slog.d("PowerManagerService", "SettingsObserver : update : userActivity()");
            PowerManagerService.access$1402(PowerManagerService.this, "SettingsObserver1");
            PowerManagerService.this.userActivity(SystemClock.uptimeMillis(), -1L, false, 3, false, false);
            PowerManagerService.access$1402(PowerManagerService.this, "SettingsObserver2");
            PowerManagerService.this.userActivity(SystemClock.uptimeMillis(), -1L, false, 1, false, false);
          }
          PowerManagerService.access$3802(PowerManagerService.this, getFloat("window_animation_scale", 1.0F));
          f = getFloat("transition_animation_scale", 1.0F);
          PowerManagerService.access$3902(PowerManagerService.this, 0);
          if (PowerManagerService.this.mWindowScaleAnimation > 0.5F)
          {
            PowerManagerService.access$3976(PowerManagerService.this, 16);
            break label453;
            return;
          }
        }
        label453: if (f <= 0.5F);
      }
    }
  }

  private class SmartSleepNotificationTask
    implements Runnable
  {
    private SmartSleepNotificationTask()
    {
    }

    public void run()
    {
      PowerManagerService.access$4702(PowerManagerService.this, false);
      if ((PowerManagerService.this.mUserActivityAllowed) && (PowerManagerService.this.isScreenOn()) && ((0x2 & PowerManagerService.this.mWakeLockState) == 0))
      {
        PowerManagerService.access$4702(PowerManagerService.this, PowerManagerService.this.checkIntelligentSleep());
        if (!PowerManagerService.this.mFaceDetected)
        {
          PowerManagerService.this.mContext.sendBroadcast(PowerManagerService.this.mSmartSleepIntent);
          Slog.d("PowerManagerService", "SmartSleepNotificationTask::SmartSleepNotification : sendBroadcast done.");
        }
      }
    }
  }

  private class SmartSleepTask
    implements Runnable
  {
    private SmartSleepTask()
    {
    }

    public void run()
    {
      PowerManagerService.access$4702(PowerManagerService.this, false);
      if ((PowerManagerService.this.mUserActivityAllowed) && (PowerManagerService.this.isScreenOn()) && ((0x2 & PowerManagerService.this.mWakeLockState) == 0))
      {
        PowerManagerService.access$4702(PowerManagerService.this, PowerManagerService.this.checkIntelligentSleep());
        Slog.d("PowerManagerService", "SmartSleepTask::SmartSleep : mFaceDetected = " + PowerManagerService.this.mFaceDetected);
      }
    }
  }

  private class TimeoutTask
    implements Runnable
  {
    int nextState;
    long remainingTimeoutOverride;

    private TimeoutTask()
    {
    }

    public void run()
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        if (this.nextState == -1)
          return;
        if ((PowerManagerService.this.mFaceDetected) && (PowerManagerService.this.mSmartSleepEnabled) && (PowerManagerService.this.mUserActivityAllowed))
        {
          PowerManagerService.access$4702(PowerManagerService.this, false);
          PowerManagerService.access$1402(PowerManagerService.this, "face detection");
          PowerManagerService.this.userActivity(SystemClock.uptimeMillis(), -1L, false, 0, true, true);
          Slog.v("PowerManagerService", "TimeoutTask::SmartSleep : mFaceDetected is true -> prevent to go DIM/OFF");
          return;
        }
      }
      PowerManagerService.access$5302(PowerManagerService.this, this.nextState);
      Slog.w("PowerManagerService", "Timer 0x" + Integer.toHexString(PowerManagerService.this.mPowerState) + "->0x" + Integer.toHexString(PowerManagerService.this.mUserState) + "|0x" + Integer.toHexString(PowerManagerService.this.mWakeLockState));
      PowerManagerService.this.printCurLock(3);
      if ((PowerManagerService.this.isScreenOn()) && ((0x1 & (this.nextState | PowerManagerService.this.mWakeLockState)) == 0))
        Slog.d("PowerManagerService", "Screen__Off : Timeout");
      PowerManagerService.this.setPowerState(this.nextState | PowerManagerService.this.mWakeLockState);
      long l = SystemClock.uptimeMillis();
      switch (this.nextState)
      {
      case 2:
      default:
      case 3:
      case 1:
      }
      while (true)
      {
        return;
        if (PowerManagerService.this.mDimDelay >= 0)
          PowerManagerService.this.setTimeoutLocked(l, this.remainingTimeoutOverride, 1);
        else
          PowerManagerService.this.setTimeoutLocked(l, this.remainingTimeoutOverride, 0);
      }
    }
  }

  private class UnsynchronizedDVFSLock
  {
    int mFrequency;
    boolean mHeld = false;
    String mTag;
    IBinder mToken;
    int mType;

    UnsynchronizedDVFSLock(int paramInt1, int paramString, String arg4)
    {
      this.mType = paramInt1;
      this.mFrequency = paramString;
      Object localObject;
      this.mTag = localObject;
      this.mToken = new Binder();
    }

    public void acquire()
    {
      long l = Binder.clearCallingIdentity();
      try
      {
        PowerManagerService.this.acquireDVFSLockLocked(this.mType, this.mFrequency, this.mToken, PowerManagerService.this.MY_UID, PowerManagerService.this.MY_PID, this.mTag);
        this.mHeld = true;
        return;
      }
      finally
      {
        Binder.restoreCallingIdentity(l);
      }
    }

    public boolean isHeld()
    {
      return this.mHeld;
    }

    public void release()
    {
      PowerManagerService.this.releaseDVFSLockLocked(this.mToken);
      this.mHeld = false;
    }

    public String toString()
    {
      return "UnsynchronizedDVFSLock(mType=0x" + Integer.toHexString(this.mType) + " mFrequency=" + this.mFrequency + " mHeld=" + this.mHeld + ")";
    }
  }

  private class UnsynchronizedWakeLock
  {
    int mCount = 0;
    int mFlags;
    boolean mHeld;
    boolean mRefCounted;
    String mTag;
    IBinder mToken;

    UnsynchronizedWakeLock(int paramString, String paramBoolean, boolean arg4)
    {
      this.mFlags = paramString;
      this.mTag = paramBoolean;
      this.mToken = new Binder();
      boolean bool;
      this.mRefCounted = bool;
    }

    public void acquire()
    {
      long l;
      if (this.mRefCounted)
      {
        int i = this.mCount;
        this.mCount = (i + 1);
        if (i != 0);
      }
      else
      {
        l = Binder.clearCallingIdentity();
      }
      try
      {
        PowerManagerService.this.acquireWakeLockLocked(this.mFlags, this.mToken, PowerManagerService.this.MY_UID, PowerManagerService.this.MY_PID, this.mTag, null);
        this.mHeld = true;
        return;
      }
      finally
      {
        Binder.restoreCallingIdentity(l);
      }
    }

    public boolean isHeld()
    {
      return this.mHeld;
    }

    public void release()
    {
      if (this.mRefCounted)
      {
        int i = -1 + this.mCount;
        this.mCount = i;
        if (i != 0);
      }
      else
      {
        PowerManagerService.this.releaseWakeLockLocked(this.mToken, 0, false);
        this.mHeld = false;
      }
      if (this.mCount < 0)
        throw new RuntimeException("WakeLock under-locked " + this.mTag);
    }

    public String toString()
    {
      return "UnsynchronizedWakeLock(mFlags=0x" + Integer.toHexString(this.mFlags) + " mCount=" + this.mCount + " mHeld=" + this.mHeld + ")";
    }
  }

  private class WakeLock
    implements IBinder.DeathRecipient
  {
    long acqTime;
    boolean activated = true;
    final IBinder binder;
    final int flags;
    boolean isReleasedInternal = false;
    int minState;
    final int monitorType;
    final int pid;
    final String tag;
    final int uid;
    WorkSource ws;

    WakeLock(int paramIBinder, IBinder paramString, String paramInt1, int paramInt2, int arg6)
    {
      this.flags = paramIBinder;
      this.binder = paramString;
      this.tag = paramInt1;
      int j;
      if (paramInt2 == PowerManagerService.this.MY_UID)
        j = 1000;
      while (true)
      {
        this.uid = j;
        int i;
        this.pid = i;
        int k;
        if ((paramInt2 != PowerManagerService.this.MY_UID) || ((!"KEEP_SCREEN_ON_FLAG".equals(this.tag)) && (!"KeyInputQueue".equals(this.tag))))
          if ((paramIBinder & 0x3F) == 1)
          {
            k = 0;
            label105: this.monitorType = k;
          }
        try
        {
          while (true)
          {
            paramString.linkToDeath(this, 0);
            return;
            j = paramInt2;
            break;
            k = 1;
            break label105;
            this.monitorType = -1;
          }
        }
        catch (RemoteException localRemoteException)
        {
          binderDied();
        }
      }
    }

    public void binderDied()
    {
      synchronized (PowerManagerService.this.mLocks)
      {
        Slog.e("PowerManagerService", "WakeLock : binderDied()");
        PowerManagerService.this.releaseWakeLockLocked(this.binder, 0, true);
        return;
      }
    }
  }
}