auto import from //depot/cupcake/@135843
diff --git a/services/java/com/android/server/HardwareService.java b/services/java/com/android/server/HardwareService.java
new file mode 100755
index 0000000..2131ffdd
--- /dev/null
+++ b/services/java/com/android/server/HardwareService.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.os.Hardware;
+import android.os.IHardwareService;
+import android.os.Power;
+import android.os.PowerManager;
+import android.os.Process;
+import android.os.RemoteException;
+import android.os.IBinder;
+import android.os.Binder;
+import android.os.SystemClock;
+import android.util.Log;
+
+public class HardwareService extends IHardwareService.Stub {
+ private static final String TAG = "HardwareService";
+
+ HardwareService(Context context) {
+ // Reset the hardware to a default state, in case this is a runtime
+ // restart instead of a fresh boot.
+ vibratorOff();
+
+ mContext = context;
+ PowerManager pm = (PowerManager)context.getSystemService(
+ Context.POWER_SERVICE);
+ mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
+ mWakeLock.setReferenceCounted(true);
+
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(Intent.ACTION_SCREEN_OFF);
+ context.registerReceiver(mIntentReceiver, filter);
+ }
+
+ public void vibrate(long milliseconds) {
+ vibratePattern(new long[] { 0, milliseconds }, -1,
+ new Binder());
+ }
+
+ private boolean isAll0(long[] pattern) {
+ int N = pattern.length;
+ for (int i = 0; i < N; i++) {
+ if (pattern[i] != 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public void vibratePattern(long[] pattern, int repeat, IBinder token) {
+ if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.VIBRATE)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires VIBRATE permission");
+ }
+ // so wakelock calls will succeed
+ long identity = Binder.clearCallingIdentity();
+ try {
+ if (false) {
+ String s = "";
+ int N = pattern.length;
+ for (int i=0; i<N; i++) {
+ s += " " + pattern[i];
+ }
+ Log.i(TAG, "vibrating with pattern: " + s);
+ }
+
+ // we're running in the server so we can't fail
+ if (pattern == null || pattern.length == 0
+ || isAll0(pattern)
+ || repeat >= pattern.length || token == null) {
+ return;
+ }
+
+ synchronized (this) {
+ Death death = new Death(token);
+ try {
+ token.linkToDeath(death, 0);
+ } catch (RemoteException e) {
+ return;
+ }
+
+ Thread oldThread = mThread;
+
+ if (oldThread != null) {
+ // stop the old one
+ synchronized (mThread) {
+ mThread.mDone = true;
+ mThread.notify();
+ }
+ }
+
+ if (mDeath != null) {
+ mToken.unlinkToDeath(mDeath, 0);
+ }
+
+ mDeath = death;
+ mToken = token;
+
+ // start the new thread
+ mThread = new VibrateThread(pattern, repeat);
+ mThread.start();
+ }
+ }
+ finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
+ public void cancelVibrate() {
+ mContext.enforceCallingOrSelfPermission(
+ android.Manifest.permission.VIBRATE,
+ "cancelVibrate");
+
+ // so wakelock calls will succeed
+ long identity = Binder.clearCallingIdentity();
+ try {
+ doCancelVibrate();
+ }
+ finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
+ public boolean getFlashlightEnabled() {
+ return Hardware.getFlashlightEnabled();
+ }
+
+ public void setFlashlightEnabled(boolean on) {
+ if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.FLASHLIGHT)
+ != PackageManager.PERMISSION_GRANTED &&
+ mContext.checkCallingOrSelfPermission(android.Manifest.permission.HARDWARE_TEST)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires FLASHLIGHT or HARDWARE_TEST permission");
+ }
+ Hardware.setFlashlightEnabled(on);
+ }
+
+ public void enableCameraFlash(int milliseconds) {
+ if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.CAMERA)
+ != PackageManager.PERMISSION_GRANTED &&
+ mContext.checkCallingOrSelfPermission(android.Manifest.permission.HARDWARE_TEST)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires CAMERA or HARDWARE_TEST permission");
+ }
+ Hardware.enableCameraFlash(milliseconds);
+ }
+
+ public void setScreenBacklight(int brightness) {
+ if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.HARDWARE_TEST)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires HARDWARE_TEST permission");
+ }
+ // Don't let applications turn the screen all the way off
+ brightness = Math.max(brightness, Power.BRIGHTNESS_DIM);
+ Hardware.setScreenBacklight(brightness);
+ }
+
+ public void setKeyboardBacklight(boolean on) {
+ if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.HARDWARE_TEST)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires HARDWARE_TEST permission");
+ }
+ Hardware.setKeyboardBacklight(on);
+ }
+
+ public void setButtonBacklight(boolean on) {
+ if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.HARDWARE_TEST)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires HARDWARE_TEST permission");
+ }
+ Hardware.setButtonBacklight(on);
+ }
+
+ public void setLedState(int colorARGB, int onMS, int offMS) {
+ if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.HARDWARE_TEST)
+ != PackageManager.PERMISSION_GRANTED) {
+ throw new SecurityException("Requires HARDWARE_TEST permission");
+ }
+ Hardware.setLedState(colorARGB, onMS, offMS);
+ }
+
+ private void doCancelVibrate() {
+ synchronized (this) {
+ if (mThread != null) {
+ synchronized (mThread) {
+ mThread.mDone = true;
+ mThread.notify();
+ }
+ mThread = null;
+ vibratorOff();
+ }
+ }
+ }
+
+ private class VibrateThread extends Thread {
+ long[] mPattern;
+ int mRepeat;
+ boolean mDone;
+
+ VibrateThread(long[] pattern, int repeat) {
+ mPattern = pattern;
+ mRepeat = repeat;
+ mWakeLock.acquire();
+ }
+
+ private void delay(long duration) {
+ if (duration > 0) {
+ long bedtime = SystemClock.uptimeMillis();
+ do {
+ try {
+ this.wait(duration);
+ }
+ catch (InterruptedException e) {
+ }
+ if (mDone) {
+ break;
+ }
+ duration = duration
+ - SystemClock.uptimeMillis() - bedtime;
+ } while (duration > 0);
+ }
+ }
+
+ public void run() {
+ Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_DISPLAY);
+ synchronized (this) {
+ int index = 0;
+ long[] pattern = mPattern;
+ int len = pattern.length;
+ long duration = 0;
+
+ while (!mDone) {
+ // add off-time duration to any accumulated on-time duration
+ if (index < len) {
+ duration += pattern[index++];
+ }
+
+ // sleep until it is time to start the vibrator
+ delay(duration);
+ if (mDone) {
+ break;
+ }
+
+ if (index < len) {
+ // read on-time duration and start the vibrator
+ // duration is saved for delay() at top of loop
+ duration = pattern[index++];
+ if (duration > 0) {
+ HardwareService.this.vibratorOn(duration);
+ }
+ } else {
+ if (mRepeat < 0) {
+ break;
+ } else {
+ index = mRepeat;
+ duration = 0;
+ }
+ }
+ }
+ if (mDone) {
+ // make sure vibrator is off if we were cancelled.
+ // otherwise, it will turn off automatically
+ // when the last timeout expires.
+ HardwareService.this.vibratorOff();
+ }
+ mWakeLock.release();
+ }
+ synchronized (HardwareService.this) {
+ if (mThread == this) {
+ mThread = null;
+ }
+ }
+ }
+ };
+
+ private class Death implements IBinder.DeathRecipient {
+ IBinder mMe;
+
+ Death(IBinder me) {
+ mMe = me;
+ }
+
+ public void binderDied() {
+ synchronized (HardwareService.this) {
+ if (mMe == mToken) {
+ doCancelVibrate();
+ }
+ }
+ }
+ }
+
+ BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
+ public void onReceive(Context context, Intent intent) {
+ if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
+ doCancelVibrate();
+ }
+ }
+ };
+
+ private Context mContext;
+ private PowerManager.WakeLock mWakeLock;
+
+ volatile VibrateThread mThread;
+ volatile Death mDeath;
+ volatile IBinder mToken;
+
+ native static void vibratorOn(long milliseconds);
+ native static void vibratorOff();
+}