diff options
Diffstat (limited to 'services/java/com/android')
85 files changed, 55031 insertions, 0 deletions
diff --git a/services/java/com/android/server/AlarmManagerService.java b/services/java/com/android/server/AlarmManagerService.java new file mode 100644 index 0000000..d66c6e5 --- /dev/null +++ b/services/java/com/android/server/AlarmManagerService.java @@ -0,0 +1,808 @@ +/* + * Copyright (C) 2006 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.app.ActivityManagerNative; +import android.app.AlarmManager; +import android.app.IAlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.net.Uri; +import android.os.Binder; +import android.os.Bundle; +import android.os.Handler; +import android.os.Message; +import android.os.PowerManager; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.text.TextUtils; +import android.text.format.Time; +import android.util.EventLog; +import android.util.Log; + +import java.io.FileDescriptor; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.TimeZone; + +class AlarmManagerService extends IAlarmManager.Stub { + // The threshold for how long an alarm can be late before we print a + // warning message. The time duration is in milliseconds. + private static final long LATE_ALARM_THRESHOLD = 10 * 1000; + + private static final int RTC_WAKEUP_MASK = 1 << AlarmManager.RTC_WAKEUP; + private static final int RTC_MASK = 1 << AlarmManager.RTC; + private static final int ELAPSED_REALTIME_WAKEUP_MASK = 1 << AlarmManager.ELAPSED_REALTIME_WAKEUP; + private static final int ELAPSED_REALTIME_MASK = 1 << AlarmManager.ELAPSED_REALTIME; + private static final int TIME_CHANGED_MASK = 1 << 16; + + private static final String TAG = "AlarmManager"; + private static final String ClockReceiver_TAG = "ClockReceiver"; + private static final boolean localLOGV = false; + private static final int ALARM_EVENT = 1; + private static final String TIMEZONE_PROPERTY = "persist.sys.timezone"; + + private static final Intent mBackgroundIntent + = new Intent().addFlags(Intent.FLAG_FROM_BACKGROUND); + + private final Context mContext; + + private Object mLock = new Object(); + + private final ArrayList<Alarm> mRtcWakeupAlarms = new ArrayList<Alarm>(); + private final ArrayList<Alarm> mRtcAlarms = new ArrayList<Alarm>(); + private final ArrayList<Alarm> mElapsedRealtimeWakeupAlarms = new ArrayList<Alarm>(); + private final ArrayList<Alarm> mElapsedRealtimeAlarms = new ArrayList<Alarm>(); + private final IncreasingTimeOrder mIncreasingTimeOrder = new IncreasingTimeOrder(); + + // slots corresponding with the inexact-repeat interval buckets, + // ordered from shortest to longest + private static final long sInexactSlotIntervals[] = { + AlarmManager.INTERVAL_FIFTEEN_MINUTES, + AlarmManager.INTERVAL_HALF_HOUR, + AlarmManager.INTERVAL_HOUR, + AlarmManager.INTERVAL_HALF_DAY, + AlarmManager.INTERVAL_DAY + }; + private long mInexactDeliveryTimes[] = { 0, 0, 0, 0, 0}; + + private int mDescriptor; + private int mBroadcastRefCount = 0; + private PowerManager.WakeLock mWakeLock; + private final AlarmThread mWaitThread = new AlarmThread(); + private final AlarmHandler mHandler = new AlarmHandler(); + private ClockReceiver mClockReceiver; + private UninstallReceiver mUninstallReceiver; + private final ResultReceiver mResultReceiver = new ResultReceiver(); + private final PendingIntent mTimeTickSender; + private final PendingIntent mDateChangeSender; + + private static final class FilterStats { + int count; + } + + private static final class BroadcastStats { + long aggregateTime; + int numWakeup; + long startTime; + int nesting; + HashMap<Intent.FilterComparison, FilterStats> filterStats + = new HashMap<Intent.FilterComparison, FilterStats>(); + } + + private final HashMap<String, BroadcastStats> mBroadcastStats + = new HashMap<String, BroadcastStats>(); + + public AlarmManagerService(Context context) { + mContext = context; + mDescriptor = init(); + PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE); + mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG); + + mTimeTickSender = PendingIntent.getBroadcast(context, 0, + new Intent(Intent.ACTION_TIME_TICK).addFlags( + Intent.FLAG_RECEIVER_REGISTERED_ONLY), 0); + mDateChangeSender = PendingIntent.getBroadcast(context, 0, + new Intent(Intent.ACTION_DATE_CHANGED), 0); + + // now that we have initied the driver schedule the alarm + mClockReceiver= new ClockReceiver(); + mClockReceiver.scheduleTimeTickEvent(); + mClockReceiver.scheduleDateChangedEvent(); + mUninstallReceiver = new UninstallReceiver(); + + if (mDescriptor != -1) { + mWaitThread.start(); + } else { + Log.w(TAG, "Failed to open alarm driver. Falling back to a handler."); + } + } + + protected void finalize() throws Throwable { + try { + close(mDescriptor); + } finally { + super.finalize(); + } + } + + public void set(int type, long triggerAtTime, PendingIntent operation) { + setRepeating(type, triggerAtTime, 0, operation); + } + + public void setRepeating(int type, long triggerAtTime, long interval, + PendingIntent operation) { + if (operation == null) { + Log.w(TAG, "set/setRepeating ignored because there is no intent"); + return; + } + synchronized (mLock) { + Alarm alarm = new Alarm(); + alarm.type = type; + alarm.when = triggerAtTime; + alarm.repeatInterval = interval; + alarm.operation = operation; + + // Remove this alarm if already scheduled. + removeLocked(operation); + + if (localLOGV) Log.v(TAG, "set: " + alarm); + + int index = addAlarmLocked(alarm); + if (index == 0) { + setLocked(alarm); + } + } + } + + public void setInexactRepeating(int type, long triggerAtTime, long interval, + PendingIntent operation) { + if (operation == null) { + Log.w(TAG, "setInexactRepeating ignored because there is no intent"); + return; + } + + // find the slot in the delivery-times array that we will use + int intervalSlot; + for (intervalSlot = 0; intervalSlot < sInexactSlotIntervals.length; intervalSlot++) { + if (sInexactSlotIntervals[intervalSlot] == interval) { + break; + } + } + + // Non-bucket intervals just fall back to the less-efficient + // unbucketed recurring alarm implementation + if (intervalSlot >= sInexactSlotIntervals.length) { + setRepeating(type, triggerAtTime, interval, operation); + return; + } + + // Align bucketed alarm deliveries by trying to match + // the shortest-interval bucket already scheduled + long bucketTime = 0; + for (int slot = 0; slot < mInexactDeliveryTimes.length; slot++) { + if (mInexactDeliveryTimes[slot] > 0) { + bucketTime = mInexactDeliveryTimes[slot]; + break; + } + } + + if (bucketTime == 0) { + // If nothing is scheduled yet, just start at the requested time + bucketTime = triggerAtTime; + } else { + // Align the new alarm with the existing bucketed sequence. To achieve + // alignment, we slide the start time around by min{interval, slot interval} + long adjustment = (interval <= sInexactSlotIntervals[intervalSlot]) + ? interval : sInexactSlotIntervals[intervalSlot]; + + // The bucket may have started in the past; adjust + while (bucketTime < triggerAtTime) { + bucketTime += adjustment; + } + + // Or the bucket may be set to start more than an interval beyond + // our requested trigger time; pull it back to meet our needs + while (bucketTime > triggerAtTime + adjustment) { + bucketTime -= adjustment; + } + } + + // Remember where this bucket started (reducing the amount of later + // fixup required) and set the alarm with the new, bucketed start time. + if (localLOGV) Log.v(TAG, "setInexactRepeating: interval=" + interval + + " bucketTime=" + bucketTime); + mInexactDeliveryTimes[intervalSlot] = bucketTime; + setRepeating(type, bucketTime, interval, operation); + } + + public void setTimeZone(String tz) { + mContext.enforceCallingOrSelfPermission( + "android.permission.SET_TIME_ZONE", + "setTimeZone"); + + if (TextUtils.isEmpty(tz)) return; + TimeZone zone = TimeZone.getTimeZone(tz); + // Prevent reentrant calls from stepping on each other when writing + // the time zone property + boolean timeZoneWasChanged = false; + synchronized (this) { + String current = SystemProperties.get(TIMEZONE_PROPERTY); + if (current == null || !current.equals(zone.getID())) { + if (localLOGV) Log.v(TAG, "timezone changed: " + current + ", new=" + zone.getID()); + timeZoneWasChanged = true; + SystemProperties.set(TIMEZONE_PROPERTY, zone.getID()); + } + + // Update the kernel timezone information + // Kernel tracks time offsets as 'minutes west of GMT' + int gmtOffset = (zone.getRawOffset() + zone.getDSTSavings()) / 60000; + setKernelTimezone(mDescriptor, -(gmtOffset)); + } + + TimeZone.setDefault(null); + + if (timeZoneWasChanged) { + Intent intent = new Intent(Intent.ACTION_TIMEZONE_CHANGED); + intent.putExtra("time-zone", zone.getID()); + mContext.sendBroadcast(intent); + } + } + + public void remove(PendingIntent operation) { + if (operation == null) { + return; + } + synchronized (mLock) { + removeLocked(operation); + } + } + + public void removeLocked(PendingIntent operation) { + removeLocked(mRtcWakeupAlarms, operation); + removeLocked(mRtcAlarms, operation); + removeLocked(mElapsedRealtimeWakeupAlarms, operation); + removeLocked(mElapsedRealtimeAlarms, operation); + } + + private void removeLocked(ArrayList<Alarm> alarmList, + PendingIntent operation) { + if (alarmList.size() <= 0) { + return; + } + + // iterator over the list removing any it where the intent match + Iterator<Alarm> it = alarmList.iterator(); + + while (it.hasNext()) { + Alarm alarm = it.next(); + if (alarm.operation.equals(operation)) { + it.remove(); + } + } + } + + public void removeLocked(String packageName) { + removeLocked(mRtcWakeupAlarms, packageName); + removeLocked(mRtcAlarms, packageName); + removeLocked(mElapsedRealtimeWakeupAlarms, packageName); + removeLocked(mElapsedRealtimeAlarms, packageName); + } + + private void removeLocked(ArrayList<Alarm> alarmList, + String packageName) { + if (alarmList.size() <= 0) { + return; + } + + // iterator over the list removing any it where the intent match + Iterator<Alarm> it = alarmList.iterator(); + + while (it.hasNext()) { + Alarm alarm = it.next(); + if (alarm.operation.getTargetPackage().equals(packageName)) { + it.remove(); + } + } + } + + private ArrayList<Alarm> getAlarmList(int type) { + switch (type) { + case AlarmManager.RTC_WAKEUP: return mRtcWakeupAlarms; + case AlarmManager.RTC: return mRtcAlarms; + case AlarmManager.ELAPSED_REALTIME_WAKEUP: return mElapsedRealtimeWakeupAlarms; + case AlarmManager.ELAPSED_REALTIME: return mElapsedRealtimeAlarms; + } + + return null; + } + + private int addAlarmLocked(Alarm alarm) { + ArrayList<Alarm> alarmList = getAlarmList(alarm.type); + + int index = Collections.binarySearch(alarmList, alarm, mIncreasingTimeOrder); + if (index < 0) { + index = 0 - index - 1; + } + if (localLOGV) Log.v(TAG, "Adding alarm " + alarm + " at " + index); + alarmList.add(index, alarm); + + if (localLOGV) { + // Display the list of alarms for this alarm type + Log.v(TAG, "alarms: " + alarmList.size() + " type: " + alarm.type); + int position = 0; + for (Alarm a : alarmList) { + Time time = new Time(); + time.set(a.when); + String timeStr = time.format("%b %d %I:%M:%S %p"); + Log.v(TAG, position + ": " + timeStr + + " " + a.operation.getTargetPackage()); + position += 1; + } + } + + return index; + } + + public long timeToNextAlarm() { + long nextAlarm = 0xfffffffffffffffl; + synchronized (mLock) { + for (int i=AlarmManager.RTC_WAKEUP; + i<=AlarmManager.ELAPSED_REALTIME; i++) { + ArrayList<Alarm> alarmList = getAlarmList(i); + if (alarmList.size() > 0) { + Alarm a = alarmList.get(0); + if (a.when < nextAlarm) { + nextAlarm = a.when; + } + } + } + } + return nextAlarm; + } + + private void setLocked(Alarm alarm) + { + if (mDescriptor != -1) + { + set(mDescriptor, alarm.type, (alarm.when * 1000 * 1000)); + } + else + { + Message msg = Message.obtain(); + msg.what = ALARM_EVENT; + + mHandler.removeMessages(ALARM_EVENT); + mHandler.sendMessageAtTime(msg, alarm.when); + } + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump AlarmManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + synchronized (mLock) { + pw.println("Current Alarm Manager state:"); + if (mRtcWakeupAlarms.size() > 0) { + pw.println(" "); + pw.println(" Realtime wakeup alarms that are scheduled:"); + dumpAlarmList(pw, mRtcWakeupAlarms, " ", "RTC_WAKEUP"); + } + if (mRtcAlarms.size() > 0) { + pw.println(" "); + pw.println(" Realtime alarms that are scheduled:"); + dumpAlarmList(pw, mRtcAlarms, " ", "RTC"); + } + if (mElapsedRealtimeWakeupAlarms.size() > 0) { + pw.println(" "); + pw.println(" Elapsed realtime wakeup alarms that are scheduled:"); + dumpAlarmList(pw, mElapsedRealtimeWakeupAlarms, " ", "ELAPSED_REALTIME_WAKEUP"); + } + if (mElapsedRealtimeAlarms.size() > 0) { + pw.println(" "); + pw.println(" Elapsed realtime alarms that are scheduled:"); + dumpAlarmList(pw, mElapsedRealtimeAlarms, " ", "ELAPSED_REALTIME"); + } + + pw.println(" "); + pw.println(" Broadcast ref count: " + mBroadcastRefCount); + + pw.println(" "); + pw.println(" Alarm Stats:"); + for (Map.Entry<String, BroadcastStats> be : mBroadcastStats.entrySet()) { + BroadcastStats bs = be.getValue(); + pw.println(" " + be.getKey()); + pw.println(" " + bs.aggregateTime + "ms running, " + + bs.numWakeup + " wakeups"); + for (Map.Entry<Intent.FilterComparison, FilterStats> fe + : bs.filterStats.entrySet()) { + pw.println(" " + fe.getValue().count + " alarms: " + + fe.getKey().getIntent()); + } + } + } + } + + private static final void dumpAlarmList(PrintWriter pw, ArrayList<Alarm> list, String prefix, String label) { + for (int i=list.size()-1; i>=0; i--) { + Alarm a = list.get(i); + pw.println(prefix + label + " #" + i + ":"); + a.dump(pw, prefix + " "); + } + } + + private native int init(); + private native void close(int fd); + private native void set(int fd, int type, long nanoseconds); + private native int waitForAlarm(int fd); + private native int setKernelTimezone(int fd, int minuteswest); + + private void triggerAlarmsLocked(ArrayList<Alarm> alarmList, + ArrayList<Alarm> triggerList, + long now) + { + Iterator<Alarm> it = alarmList.iterator(); + ArrayList<Alarm> repeats = new ArrayList<Alarm>(); + + while (it.hasNext()) + { + Alarm alarm = it.next(); + + if (localLOGV) Log.v(TAG, "Checking active alarm when=" + alarm.when + " " + alarm); + + if (alarm.when > now) { + // don't fire alarms in the future + break; + } + + // If the alarm is late, then print a warning message. + // Note that this can happen if the user creates a new event on + // the Calendar app with a reminder that is in the past. In that + // case, the reminder alarm will fire immediately. + if (localLOGV && now - alarm.when > LATE_ALARM_THRESHOLD) { + Log.v(TAG, "alarm is late! alarm time: " + alarm.when + + " now: " + now + " delay (in seconds): " + + (now - alarm.when) / 1000); + } + + // Recurring alarms may have passed several alarm intervals while the + // phone was asleep or off, so pass a trigger count when sending them. + if (localLOGV) Log.v(TAG, "Alarm triggering: " + alarm); + alarm.count = 1; + if (alarm.repeatInterval > 0) { + // this adjustment will be zero if we're late by + // less than one full repeat interval + alarm.count += (now - alarm.when) / alarm.repeatInterval; + } + triggerList.add(alarm); + + // remove the alarm from the list + it.remove(); + + // if it repeats queue it up to be read-added to the list + if (alarm.repeatInterval > 0) { + repeats.add(alarm); + } + } + + // reset any repeating alarms. + it = repeats.iterator(); + while (it.hasNext()) { + Alarm alarm = it.next(); + alarm.when += alarm.count * alarm.repeatInterval; + addAlarmLocked(alarm); + } + + if (alarmList.size() > 0) { + setLocked(alarmList.get(0)); + } + } + + /** + * This Comparator sorts Alarms into increasing time order. + */ + public static class IncreasingTimeOrder implements Comparator<Alarm> { + public int compare(Alarm a1, Alarm a2) { + long when1 = a1.when; + long when2 = a2.when; + if (when1 - when2 > 0) { + return 1; + } + if (when1 - when2 < 0) { + return -1; + } + return 0; + } + } + + private static class Alarm { + public int type; + public int count; + public long when; + public long repeatInterval; + public PendingIntent operation; + + public Alarm() { + when = 0; + repeatInterval = 0; + operation = null; + } + + @Override + public String toString() + { + return "Alarm{" + + Integer.toHexString(System.identityHashCode(this)) + + " type " + type + " " + operation.getTargetPackage() + "}"; + } + + public void dump(PrintWriter pw, String prefix) + { + pw.println(prefix + this); + pw.println(prefix + "type=" + type + " when=" + when + + " repeatInterval=" + repeatInterval + + " count=" + count); + pw.println(prefix + "operation=" + operation); + } + } + + private class AlarmThread extends Thread + { + public AlarmThread() + { + super("AlarmManager"); + } + + public void run() + { + while (true) + { + int result = waitForAlarm(mDescriptor); + + ArrayList<Alarm> triggerList = new ArrayList<Alarm>(); + + if ((result & TIME_CHANGED_MASK) != 0) { + remove(mTimeTickSender); + mClockReceiver.scheduleTimeTickEvent(); + mContext.sendBroadcast(new Intent(Intent.ACTION_TIME_CHANGED)); + } + + synchronized (mLock) { + final long nowRTC = System.currentTimeMillis(); + final long nowELAPSED = SystemClock.elapsedRealtime(); + if (localLOGV) Log.v( + TAG, "Checking for alarms... rtc=" + nowRTC + + ", elapsed=" + nowELAPSED); + + if ((result & RTC_WAKEUP_MASK) != 0) + triggerAlarmsLocked(mRtcWakeupAlarms, triggerList, nowRTC); + + if ((result & RTC_MASK) != 0) + triggerAlarmsLocked(mRtcAlarms, triggerList, nowRTC); + + if ((result & ELAPSED_REALTIME_WAKEUP_MASK) != 0) + triggerAlarmsLocked(mElapsedRealtimeWakeupAlarms, triggerList, nowELAPSED); + + if ((result & ELAPSED_REALTIME_MASK) != 0) + triggerAlarmsLocked(mElapsedRealtimeAlarms, triggerList, nowELAPSED); + + // now trigger the alarms + Iterator<Alarm> it = triggerList.iterator(); + while (it.hasNext()) { + Alarm alarm = it.next(); + try { + if (localLOGV) Log.v(TAG, "sending alarm " + alarm); + alarm.operation.send(mContext, 0, + mBackgroundIntent.putExtra( + Intent.EXTRA_ALARM_COUNT, alarm.count), + mResultReceiver, mHandler); + + // we have an active broadcast so stay awake. + if (mBroadcastRefCount == 0) { + mWakeLock.acquire(); + } + mBroadcastRefCount++; + + BroadcastStats bs = getStatsLocked(alarm.operation); + if (bs.nesting == 0) { + bs.startTime = nowELAPSED; + } else { + bs.nesting++; + } + if (alarm.type == AlarmManager.ELAPSED_REALTIME_WAKEUP + || alarm.type == AlarmManager.RTC_WAKEUP) { + bs.numWakeup++; + ActivityManagerNative.noteWakeupAlarm( + alarm.operation); + } + } catch (PendingIntent.CanceledException e) { + if (alarm.repeatInterval > 0) { + // This IntentSender is no longer valid, but this + // is a repeating alarm, so toss the hoser. + remove(alarm.operation); + } + } catch (RuntimeException e) { + Log.w(TAG, "Failure sending alarm.", e); + } + } + } + } + } + } + + private class AlarmHandler extends Handler { + public static final int ALARM_EVENT = 1; + public static final int MINUTE_CHANGE_EVENT = 2; + public static final int DATE_CHANGE_EVENT = 3; + + public AlarmHandler() { + } + + public void handleMessage(Message msg) { + if (msg.what == ALARM_EVENT) { + ArrayList<Alarm> triggerList = new ArrayList<Alarm>(); + synchronized (mLock) { + final long nowRTC = System.currentTimeMillis(); + triggerAlarmsLocked(mRtcWakeupAlarms, triggerList, nowRTC); + triggerAlarmsLocked(mRtcAlarms, triggerList, nowRTC); + triggerAlarmsLocked(mElapsedRealtimeWakeupAlarms, triggerList, nowRTC); + triggerAlarmsLocked(mElapsedRealtimeAlarms, triggerList, nowRTC); + } + + // now trigger the alarms without the lock held + Iterator<Alarm> it = triggerList.iterator(); + while (it.hasNext()) + { + Alarm alarm = it.next(); + try { + alarm.operation.send(); + } catch (PendingIntent.CanceledException e) { + if (alarm.repeatInterval > 0) { + // This IntentSender is no longer valid, but this + // is a repeating alarm, so toss the hoser. + remove(alarm.operation); + } + } + } + } + } + } + + class ClockReceiver extends BroadcastReceiver { + public ClockReceiver() { + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_TIME_TICK); + filter.addAction(Intent.ACTION_DATE_CHANGED); + mContext.registerReceiver(this, filter); + } + + @Override + public void onReceive(Context context, Intent intent) { + if (intent.getAction().equals(Intent.ACTION_TIME_TICK)) { + scheduleTimeTickEvent(); + } else if (intent.getAction().equals(Intent.ACTION_DATE_CHANGED)) { + // Since the kernel does not keep track of DST, we need to + // reset the TZ information at the beginning of each day + // based off of the current Zone gmt offset + userspace tracked + // daylight savings information. + TimeZone zone = TimeZone.getTimeZone(SystemProperties.get(TIMEZONE_PROPERTY)); + int gmtOffset = (zone.getRawOffset() + zone.getDSTSavings()) / 60000; + + setKernelTimezone(mDescriptor, -(gmtOffset)); + scheduleDateChangedEvent(); + } + } + + public void scheduleTimeTickEvent() { + Calendar calendar = Calendar.getInstance(); + calendar.setTimeInMillis(System.currentTimeMillis()); + calendar.add(Calendar.MINUTE, 1); + calendar.set(Calendar.SECOND, 0); + calendar.set(Calendar.MILLISECOND, 0); + + set(AlarmManager.RTC, calendar.getTimeInMillis(), mTimeTickSender); + } + + public void scheduleDateChangedEvent() { + Calendar calendar = Calendar.getInstance(); + calendar.setTimeInMillis(System.currentTimeMillis()); + calendar.set(Calendar.HOUR, 0); + calendar.set(Calendar.MINUTE, 0); + calendar.set(Calendar.SECOND, 0); + calendar.set(Calendar.MILLISECOND, 0); + calendar.add(Calendar.DAY_OF_MONTH, 1); + + set(AlarmManager.RTC, calendar.getTimeInMillis(), mDateChangeSender); + } + } + + class UninstallReceiver extends BroadcastReceiver { + public UninstallReceiver() { + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_PACKAGE_REMOVED); + filter.addAction(Intent.ACTION_PACKAGE_RESTARTED); + filter.addDataScheme("package"); + mContext.registerReceiver(this, filter); + } + + @Override + public void onReceive(Context context, Intent intent) { + synchronized (mLock) { + Uri data = intent.getData(); + if (data != null) { + String pkg = data.getSchemeSpecificPart(); + removeLocked(pkg); + mBroadcastStats.remove(pkg); + } + } + } + } + + private final BroadcastStats getStatsLocked(PendingIntent pi) { + String pkg = pi.getTargetPackage(); + BroadcastStats bs = mBroadcastStats.get(pkg); + if (bs == null) { + bs = new BroadcastStats(); + mBroadcastStats.put(pkg, bs); + } + return bs; + } + + class ResultReceiver implements PendingIntent.OnFinished { + public void onSendFinished(PendingIntent pi, Intent intent, int resultCode, + String resultData, Bundle resultExtras) { + synchronized (mLock) { + BroadcastStats bs = getStatsLocked(pi); + if (bs != null) { + bs.nesting--; + if (bs.nesting <= 0) { + bs.nesting = 0; + bs.aggregateTime += SystemClock.elapsedRealtime() + - bs.startTime; + Intent.FilterComparison fc = new Intent.FilterComparison(intent); + FilterStats fs = bs.filterStats.get(fc); + if (fs == null) { + fs = new FilterStats(); + bs.filterStats.put(fc, fs); + } + fs.count++; + } + } + mBroadcastRefCount--; + if (mBroadcastRefCount == 0) { + mWakeLock.release(); + } + } + } + } +} diff --git a/services/java/com/android/server/AttributeCache.java b/services/java/com/android/server/AttributeCache.java new file mode 100644 index 0000000..459ae52 --- /dev/null +++ b/services/java/com/android/server/AttributeCache.java @@ -0,0 +1,129 @@ +/* +** +** Copyright 2007, 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.ComponentName; +import android.content.ContentResolver; +import android.content.Context; +import android.content.SharedPreferences; +import android.content.Intent; +import android.content.BroadcastReceiver; +import android.content.pm.PackageManager; +import android.content.res.Resources; +import android.content.res.TypedArray; +import android.provider.Settings; +import android.util.Config; +import android.util.Log; + +import java.util.WeakHashMap; + +public final class AttributeCache extends BroadcastReceiver { + private static AttributeCache sInstance = null; + + private final Context mContext; + private final WeakHashMap<Key, Entry> mMap = + new WeakHashMap<Key, Entry>(); + private final WeakHashMap<String, Context> mContexts = + new WeakHashMap<String, Context>(); + + final static class Key { + public final String packageName; + public final int resId; + public final int[] styleable; + + public Key(String inPackageName, int inResId, int[] inStyleable) { + packageName = inPackageName; + resId = inResId; + styleable = inStyleable; + } + + @Override public boolean equals(Object obj) { + try { + if (obj != null) { + Key other = (Key)obj; + return packageName.equals(other.packageName) + && resId == other.resId + && styleable == other.styleable; + } + } catch (ClassCastException e) { + } + return false; + } + + @Override public int hashCode() { + return packageName.hashCode() + resId; + } + } + + public final static class Entry { + public final Context context; + public final TypedArray array; + + public Entry(Context c, TypedArray ta) { + context = c; + array = ta; + } + } + + public static void init(Context context) { + if (sInstance == null) { + sInstance = new AttributeCache(context); + } + } + + public static AttributeCache instance() { + return sInstance; + } + + public AttributeCache(Context context) { + mContext = context; + } + + public Entry get(String packageName, int resId, int[] styleable) { + synchronized (this) { + Key key = new Key(packageName, resId, styleable); + Entry ent = mMap.get(key); + if (ent != null) { + return ent; + } + Context context = mContexts.get(packageName); + if (context == null) { + try { + context = mContext.createPackageContext(packageName, 0); + if (context == null) { + return null; + } + mContexts.put(packageName, context); + } catch (PackageManager.NameNotFoundException e) { + return null; + } + } + try { + ent = new Entry(context, + context.obtainStyledAttributes(resId, styleable)); + mMap.put(key, ent); + } catch (Resources.NotFoundException e) { + return null; + } + return ent; + } + } + @Override public void onReceive(Context context, Intent intent) { + } +} + diff --git a/services/java/com/android/server/BatteryService.java b/services/java/com/android/server/BatteryService.java new file mode 100644 index 0000000..3a9a59f --- /dev/null +++ b/services/java/com/android/server/BatteryService.java @@ -0,0 +1,401 @@ +/* + * Copyright (C) 2006 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 com.android.internal.app.IBatteryStats; +import com.android.server.am.BatteryStatsService; + +import android.app.ActivityManagerNative; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.os.BatteryManager; +import android.os.Binder; +import android.os.Debug; +import android.os.IBinder; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.os.UEventObserver; +import android.provider.Checkin; +import android.provider.Settings; +import android.util.EventLog; +import android.util.Log; + +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.PrintWriter; + + + +/** + * <p>BatteryService monitors the charging status, and charge level of the device + * battery. When these values change this service broadcasts the new values + * to all {@link android.content.BroadcastReceiver IntentReceivers} that are + * watching the {@link android.content.Intent#ACTION_BATTERY_CHANGED + * BATTERY_CHANGED} action.</p> + * <p>The new values are stored in the Intent data and can be retrieved by + * calling {@link android.content.Intent#getExtra Intent.getExtra} with the + * following keys:</p> + * <p>"scale" - int, the maximum value for the charge level</p> + * <p>"level" - int, charge level, from 0 through "scale" inclusive</p> + * <p>"status" - String, the current charging status.<br /> + * <p>"health" - String, the current battery health.<br /> + * <p>"present" - boolean, true if the battery is present<br /> + * <p>"icon-small" - int, suggested small icon to use for this state</p> + * <p>"plugged" - int, 0 if the device is not plugged in; 1 if plugged + * into an AC power adapter; 2 if plugged in via USB.</p> + * <p>"voltage" - int, current battery voltage in millivolts</p> + * <p>"temperature" - int, current battery temperature in tenths of + * a degree Centigrade</p> + * <p>"technology" - String, the type of battery installed, e.g. "Li-ion"</p> + */ +class BatteryService extends Binder { + private static final String TAG = BatteryService.class.getSimpleName(); + + private static final boolean LOCAL_LOGV = false; + + static final int LOG_BATTERY_LEVEL = 2722; + static final int LOG_BATTERY_STATUS = 2723; + static final int LOG_BATTERY_DISCHARGE_STATUS = 2730; + + static final int BATTERY_SCALE = 100; // battery capacity is a percentage + + // Used locally for determining when to make a last ditch effort to log + // discharge stats before the device dies. + private static final int CRITICAL_BATTERY_LEVEL = 4; + + private static final int DUMP_MAX_LENGTH = 24 * 1024; + private static final String[] DUMPSYS_ARGS = new String[] { "-c", "-u" }; + private static final String BATTERY_STATS_SERVICE_NAME = "batteryinfo"; + + private static final String DUMPSYS_DATA_PATH = "/data/system/"; + + // This should probably be exposed in the API, though it's not critical + private static final int BATTERY_PLUGGED_NONE = 0; + + private final Context mContext; + private final IBatteryStats mBatteryStats; + + private boolean mAcOnline; + private boolean mUsbOnline; + private int mBatteryStatus; + private int mBatteryHealth; + private boolean mBatteryPresent; + private int mBatteryLevel; + private int mBatteryVoltage; + private int mBatteryTemperature; + private String mBatteryTechnology; + private boolean mBatteryLevelCritical; + + private int mLastBatteryStatus; + private int mLastBatteryHealth; + private boolean mLastBatteryPresent; + private int mLastBatteryLevel; + private int mLastBatteryVoltage; + private int mLastBatteryTemperature; + private boolean mLastBatteryLevelCritical; + + private int mPlugType; + private int mLastPlugType = -1; // Extra state so we can detect first run + + private long mDischargeStartTime; + private int mDischargeStartLevel; + + + public BatteryService(Context context) { + mContext = context; + mBatteryStats = BatteryStatsService.getService(); + + mUEventObserver.startObserving("SUBSYSTEM=power_supply"); + + // set initial status + update(); + } + + final boolean isPowered() { + // assume we are powered if battery state is unknown so the "stay on while plugged in" option will work. + return (mAcOnline || mUsbOnline || mBatteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN); + } + + final boolean isPowered(int plugTypeSet) { + // assume we are powered if battery state is unknown so + // the "stay on while plugged in" option will work. + if (mBatteryStatus == BatteryManager.BATTERY_STATUS_UNKNOWN) { + return true; + } + if (plugTypeSet == 0) { + return false; + } + int plugTypeBit = 0; + if (mAcOnline) { + plugTypeBit |= BatteryManager.BATTERY_PLUGGED_AC; + } + if (mUsbOnline) { + plugTypeBit |= BatteryManager.BATTERY_PLUGGED_USB; + } + return (plugTypeSet & plugTypeBit) != 0; + } + + final int getPlugType() { + return mPlugType; + } + + private UEventObserver mUEventObserver = new UEventObserver() { + @Override + public void onUEvent(UEventObserver.UEvent event) { + update(); + } + }; + + // returns battery level as a percentage + final int getBatteryLevel() { + return mBatteryLevel; + } + + private native void native_update(); + + private synchronized final void update() { + native_update(); + + mBatteryLevelCritical = mBatteryLevel <= CRITICAL_BATTERY_LEVEL; + if (mAcOnline) { + mPlugType = BatteryManager.BATTERY_PLUGGED_AC; + } else if (mUsbOnline) { + mPlugType = BatteryManager.BATTERY_PLUGGED_USB; + } else { + mPlugType = BATTERY_PLUGGED_NONE; + } + if (mBatteryStatus != mLastBatteryStatus || + mBatteryHealth != mLastBatteryHealth || + mBatteryPresent != mLastBatteryPresent || + mBatteryLevel != mLastBatteryLevel || + mPlugType != mLastPlugType || + mBatteryVoltage != mLastBatteryVoltage || + mBatteryTemperature != mLastBatteryTemperature) { + + if (mPlugType != mLastPlugType) { + if (mLastPlugType == BATTERY_PLUGGED_NONE) { + // discharging -> charging + + // There's no value in this data unless we've discharged at least once and the + // battery level has changed; so don't log until it does. + if (mDischargeStartTime != 0 && mDischargeStartLevel != mBatteryLevel) { + long duration = SystemClock.elapsedRealtime() - mDischargeStartTime; + EventLog.writeEvent(LOG_BATTERY_DISCHARGE_STATUS, duration, + mDischargeStartLevel, mBatteryLevel); + // make sure we see a discharge event before logging again + mDischargeStartTime = 0; + + logOutlier(duration); + } + } else if (mPlugType == BATTERY_PLUGGED_NONE) { + // charging -> discharging or we just powered up + mDischargeStartTime = SystemClock.elapsedRealtime(); + mDischargeStartLevel = mBatteryLevel; + } + } + if (mBatteryStatus != mLastBatteryStatus || + mBatteryHealth != mLastBatteryHealth || + mBatteryPresent != mLastBatteryPresent || + mPlugType != mLastPlugType) { + EventLog.writeEvent(LOG_BATTERY_STATUS, + mBatteryStatus, mBatteryHealth, mBatteryPresent ? 1 : 0, + mPlugType, mBatteryTechnology); + } + if (mBatteryLevel != mLastBatteryLevel || + mBatteryVoltage != mLastBatteryVoltage || + mBatteryTemperature != mLastBatteryTemperature) { + EventLog.writeEvent(LOG_BATTERY_LEVEL, + mBatteryLevel, mBatteryVoltage, mBatteryTemperature); + } + if (mBatteryLevelCritical && !mLastBatteryLevelCritical && + mPlugType == BATTERY_PLUGGED_NONE) { + // We want to make sure we log discharge cycle outliers + // if the battery is about to die. + logOutlier(SystemClock.elapsedRealtime() - mDischargeStartTime); + } + + mLastBatteryStatus = mBatteryStatus; + mLastBatteryHealth = mBatteryHealth; + mLastBatteryPresent = mBatteryPresent; + mLastBatteryLevel = mBatteryLevel; + mLastPlugType = mPlugType; + mLastBatteryVoltage = mBatteryVoltage; + mLastBatteryTemperature = mBatteryTemperature; + mLastBatteryLevelCritical = mBatteryLevelCritical; + + sendIntent(); + } + } + + private final void sendIntent() { + // Pack up the values and broadcast them to everyone + Intent intent = new Intent(Intent.ACTION_BATTERY_CHANGED); + intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); + try { + mBatteryStats.setOnBattery(mPlugType == BATTERY_PLUGGED_NONE); + } catch (RemoteException e) { + // Should never happen. + } + + int icon = getIcon(mBatteryLevel); + + intent.putExtra("status", mBatteryStatus); + intent.putExtra("health", mBatteryHealth); + intent.putExtra("present", mBatteryPresent); + intent.putExtra("level", mBatteryLevel); + intent.putExtra("scale", BATTERY_SCALE); + intent.putExtra("icon-small", icon); + intent.putExtra("plugged", mPlugType); + intent.putExtra("voltage", mBatteryVoltage); + intent.putExtra("temperature", mBatteryTemperature); + intent.putExtra("technology", mBatteryTechnology); + + if (false) { + Log.d(TAG, "updateBattery level:" + mBatteryLevel + + " scale:" + BATTERY_SCALE + " status:" + mBatteryStatus + + " health:" + mBatteryHealth + " present:" + mBatteryPresent + + " voltage: " + mBatteryVoltage + + " temperature: " + mBatteryTemperature + + " technology: " + mBatteryTechnology + + " AC powered:" + mAcOnline + " USB powered:" + mUsbOnline + + " icon:" + icon ); + } + + ActivityManagerNative.broadcastStickyIntent(intent, null); + } + + private final void logBatteryStats() { + + IBinder batteryInfoService = ServiceManager.getService(BATTERY_STATS_SERVICE_NAME); + if (batteryInfoService != null) { + byte[] buffer = new byte[DUMP_MAX_LENGTH]; + File dumpFile = null; + FileOutputStream dumpStream = null; + try { + // dump the service to a file + dumpFile = new File(DUMPSYS_DATA_PATH + BATTERY_STATS_SERVICE_NAME + ".dump"); + dumpStream = new FileOutputStream(dumpFile); + batteryInfoService.dump(dumpStream.getFD(), DUMPSYS_ARGS); + dumpStream.getFD().sync(); + + // read dumped file above into buffer truncated to DUMP_MAX_LENGTH + // and insert into events table. + int length = (int) Math.min(dumpFile.length(), DUMP_MAX_LENGTH); + FileInputStream fileInputStream = new FileInputStream(dumpFile); + int nread = fileInputStream.read(buffer, 0, length); + if (nread > 0) { + Checkin.logEvent(mContext.getContentResolver(), + Checkin.Events.Tag.BATTERY_DISCHARGE_INFO, + new String(buffer, 0, nread)); + if (LOCAL_LOGV) Log.v(TAG, "dumped " + nread + "b from " + + batteryInfoService + "to log"); + if (LOCAL_LOGV) Log.v(TAG, "actual dump:" + new String(buffer, 0, nread)); + } + } catch (RemoteException e) { + Log.e(TAG, "failed to dump service '" + BATTERY_STATS_SERVICE_NAME + + "':" + e); + } catch (IOException e) { + Log.e(TAG, "failed to write dumpsys file: " + e); + } finally { + // make sure we clean up + if (dumpStream != null) { + try { + dumpStream.close(); + } catch (IOException e) { + Log.e(TAG, "failed to close dumpsys output stream"); + } + } + if (dumpFile != null && !dumpFile.delete()) { + Log.e(TAG, "failed to delete temporary dumpsys file: " + + dumpFile.getAbsolutePath()); + } + } + } + } + + private final void logOutlier(long duration) { + ContentResolver cr = mContext.getContentResolver(); + String dischargeThresholdString = Settings.Gservices.getString(cr, + Settings.Gservices.BATTERY_DISCHARGE_THRESHOLD); + String durationThresholdString = Settings.Gservices.getString(cr, + Settings.Gservices.BATTERY_DISCHARGE_DURATION_THRESHOLD); + + if (dischargeThresholdString != null && durationThresholdString != null) { + try { + long durationThreshold = Long.parseLong(durationThresholdString); + int dischargeThreshold = Integer.parseInt(dischargeThresholdString); + if (duration <= durationThreshold && + mDischargeStartLevel - mBatteryLevel >= dischargeThreshold) { + // If the discharge cycle is bad enough we want to know about it. + logBatteryStats(); + } + if (LOCAL_LOGV) Log.v(TAG, "duration threshold: " + durationThreshold + + " discharge threshold: " + dischargeThreshold); + if (LOCAL_LOGV) Log.v(TAG, "duration: " + duration + " discharge: " + + (mDischargeStartLevel - mBatteryLevel)); + } catch (NumberFormatException e) { + Log.e(TAG, "Invalid DischargeThresholds GService string: " + + durationThresholdString + " or " + dischargeThresholdString); + return; + } + } + } + + private final int getIcon(int level) { + if (mBatteryStatus == BatteryManager.BATTERY_STATUS_CHARGING) { + return com.android.internal.R.drawable.stat_sys_battery_charge; + } else if (mBatteryStatus == BatteryManager.BATTERY_STATUS_DISCHARGING || + mBatteryStatus == BatteryManager.BATTERY_STATUS_NOT_CHARGING || + mBatteryStatus == BatteryManager.BATTERY_STATUS_FULL) { + return com.android.internal.R.drawable.stat_sys_battery; + } else { + return com.android.internal.R.drawable.stat_sys_battery_unknown; + } + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + + pw.println("Permission Denial: can't dump Battery service from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + synchronized (this) { + pw.println("Current Battery Service state:"); + pw.println(" AC powered: " + mAcOnline); + pw.println(" USB powered: " + mUsbOnline); + pw.println(" status: " + mBatteryStatus); + pw.println(" health: " + mBatteryHealth); + pw.println(" present: " + mBatteryPresent); + pw.println(" level: " + mBatteryLevel); + pw.println(" scale: " + BATTERY_SCALE); + pw.println(" voltage:" + mBatteryVoltage); + pw.println(" temperature: " + mBatteryTemperature); + pw.println(" technology: " + mBatteryTechnology); + } + } +} diff --git a/services/java/com/android/server/BootReceiver.java b/services/java/com/android/server/BootReceiver.java new file mode 100644 index 0000000..590b1e4 --- /dev/null +++ b/services/java/com/android/server/BootReceiver.java @@ -0,0 +1,40 @@ +/* +** +** Copyright 2007, 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.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.BroadcastReceiver; +import android.provider.Settings; + +public class BootReceiver extends BroadcastReceiver +{ + @Override + public void onReceive(Context context, Intent intent) + { + Intent service = new Intent(context, com.android.server.LoadAverageService.class); + ContentResolver res = context.getContentResolver(); + boolean shown = Settings.System.getInt( + res, Settings.System.SHOW_PROCESSES, 0) != 0; + if (shown) { + context.startService(service); + } + } +} + diff --git a/services/java/com/android/server/BrickReceiver.java b/services/java/com/android/server/BrickReceiver.java new file mode 100644 index 0000000..6c4db0d --- /dev/null +++ b/services/java/com/android/server/BrickReceiver.java @@ -0,0 +1,31 @@ +/* + * 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.Context; +import android.content.Intent; +import android.content.BroadcastReceiver; +import android.os.SystemService; +import android.util.Log; + +public class BrickReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + Log.w("BrickReceiver", "!!! BRICKING DEVICE !!!"); + SystemService.start("brick"); + } +} diff --git a/services/java/com/android/server/ClipboardService.java b/services/java/com/android/server/ClipboardService.java new file mode 100644 index 0000000..aa8cded --- /dev/null +++ b/services/java/com/android/server/ClipboardService.java @@ -0,0 +1,57 @@ +/* + * 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.text.IClipboard; +import android.content.Context; + +/** + * Implementation of the clipboard for copy and paste. + */ +public class ClipboardService extends IClipboard.Stub { + private CharSequence mClipboard = ""; + + /** + * Instantiates the clipboard. + */ + public ClipboardService(Context context) { } + + // javadoc from interface + public void setClipboardText(CharSequence text) { + synchronized (this) { + if (text == null) { + text = ""; + } + + mClipboard = text; + } + } + + // javadoc from interface + public CharSequence getClipboardText() { + synchronized (this) { + return mClipboard; + } + } + + // javadoc from interface + public boolean hasClipboardText() { + synchronized (this) { + return mClipboard.length() > 0; + } + } +} diff --git a/services/java/com/android/server/ConnectivityService.java b/services/java/com/android/server/ConnectivityService.java new file mode 100644 index 0000000..760988d --- /dev/null +++ b/services/java/com/android/server/ConnectivityService.java @@ -0,0 +1,741 @@ +/* + * 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.app.Notification; +import android.app.NotificationManager; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.net.ConnectivityManager; +import android.net.IConnectivityManager; +import android.net.MobileDataStateTracker; +import android.net.NetworkInfo; +import android.net.NetworkStateTracker; +import android.net.wifi.WifiStateTracker; +import android.os.Binder; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.os.ServiceManager; +import android.os.SystemProperties; +import android.provider.Settings; +import android.provider.Sync; +import android.util.EventLog; +import android.util.Log; + +import java.io.FileDescriptor; +import java.io.PrintWriter; + +/** + * @hide + */ +public class ConnectivityService extends IConnectivityManager.Stub { + + private static final boolean DBG = false; + private static final String TAG = "ConnectivityService"; + + // Event log tags (must be in sync with event-log-tags) + private static final int EVENTLOG_CONNECTIVITY_STATE_CHANGED = 50020; + + /** + * Sometimes we want to refer to the individual network state + * trackers separately, and sometimes we just want to treat them + * abstractly. + */ + private NetworkStateTracker mNetTrackers[]; + private WifiStateTracker mWifiStateTracker; + private MobileDataStateTracker mMobileDataStateTracker; + private WifiWatchdogService mWifiWatchdogService; + + private Context mContext; + private int mNetworkPreference; + private NetworkStateTracker mActiveNetwork; + + private int mNumDnsEntries; + private static int sDnsChangeCounter; + + private boolean mTestMode; + private static ConnectivityService sServiceInstance; + + private static class ConnectivityThread extends Thread { + private Context mContext; + + private ConnectivityThread(Context context) { + super("ConnectivityThread"); + mContext = context; + } + + @Override + public void run() { + Looper.prepare(); + synchronized (this) { + sServiceInstance = new ConnectivityService(mContext); + notifyAll(); + } + Looper.loop(); + } + + public static ConnectivityService getServiceInstance(Context context) { + ConnectivityThread thread = new ConnectivityThread(context); + thread.start(); + + synchronized (thread) { + while (sServiceInstance == null) { + try { + // Wait until sServiceInstance has been initialized. + thread.wait(); + } catch (InterruptedException ignore) { + Log.e(TAG, + "Unexpected InterruptedException while waiting for ConnectivityService thread"); + } + } + } + + return sServiceInstance; + } + } + + public static ConnectivityService getInstance(Context context) { + return ConnectivityThread.getServiceInstance(context); + } + + private ConnectivityService(Context context) { + if (DBG) Log.v(TAG, "ConnectivityService starting up"); + mContext = context; + mNetTrackers = new NetworkStateTracker[2]; + Handler handler = new MyHandler(); + + mNetworkPreference = getPersistedNetworkPreference(); + + /* + * Create the network state trackers for Wi-Fi and mobile + * data. Maybe this could be done with a factory class, + * but it's not clear that it's worth it, given that + * the number of different network types is not going + * to change very often. + */ + if (DBG) Log.v(TAG, "Starting Wifi Service."); + mWifiStateTracker = new WifiStateTracker(context, handler); + WifiService wifiService = new WifiService(context, mWifiStateTracker); + ServiceManager.addService(Context.WIFI_SERVICE, wifiService); + mNetTrackers[ConnectivityManager.TYPE_WIFI] = mWifiStateTracker; + + mMobileDataStateTracker = new MobileDataStateTracker(context, handler); + mNetTrackers[ConnectivityManager.TYPE_MOBILE] = mMobileDataStateTracker; + + mActiveNetwork = null; + mNumDnsEntries = 0; + + mTestMode = SystemProperties.get("cm.test.mode").equals("true") + && SystemProperties.get("ro.build.type").equals("eng"); + + for (NetworkStateTracker t : mNetTrackers) + t.startMonitoring(); + + // Constructing this starts it too + mWifiWatchdogService = new WifiWatchdogService(context, mWifiStateTracker); + } + + /** + * Sets the preferred network. + * @param preference the new preference + */ + public synchronized void setNetworkPreference(int preference) { + enforceChangePermission(); + if (ConnectivityManager.isNetworkTypeValid(preference)) { + if (mNetworkPreference != preference) { + persistNetworkPreference(preference); + mNetworkPreference = preference; + enforcePreference(); + } + } + } + + public int getNetworkPreference() { + enforceAccessPermission(); + return mNetworkPreference; + } + + private void persistNetworkPreference(int networkPreference) { + final ContentResolver cr = mContext.getContentResolver(); + Settings.Secure.putInt(cr, Settings.Secure.NETWORK_PREFERENCE, networkPreference); + } + + private int getPersistedNetworkPreference() { + final ContentResolver cr = mContext.getContentResolver(); + + final int networkPrefSetting = Settings.Secure + .getInt(cr, Settings.Secure.NETWORK_PREFERENCE, -1); + if (networkPrefSetting != -1) { + return networkPrefSetting; + } + + return ConnectivityManager.DEFAULT_NETWORK_PREFERENCE; + } + + /** + * Make the state of network connectivity conform to the preference settings. + * In this method, we only tear down a non-preferred network. Establishing + * a connection to the preferred network is taken care of when we handle + * the disconnect event from the non-preferred network + * (see {@link #handleDisconnect(NetworkInfo)}). + */ + private void enforcePreference() { + if (mActiveNetwork == null) + return; + + for (NetworkStateTracker t : mNetTrackers) { + if (t == mActiveNetwork) { + int netType = t.getNetworkInfo().getType(); + int otherNetType = ((netType == ConnectivityManager.TYPE_WIFI) ? + ConnectivityManager.TYPE_MOBILE : + ConnectivityManager.TYPE_WIFI); + + if (t.getNetworkInfo().getType() != mNetworkPreference) { + NetworkStateTracker otherTracker = mNetTrackers[otherNetType]; + if (otherTracker.isAvailable()) { + teardown(t); + } + } + } + } + } + + private boolean teardown(NetworkStateTracker netTracker) { + if (netTracker.teardown()) { + netTracker.setTeardownRequested(true); + return true; + } else { + return false; + } + } + + /** + * Return NetworkInfo for the active (i.e., connected) network interface. + * It is assumed that at most one network is active at a time. If more + * than one is active, it is indeterminate which will be returned. + * @return the info for the active network, or {@code null} if none is active + */ + public NetworkInfo getActiveNetworkInfo() { + enforceAccessPermission(); + for (NetworkStateTracker t : mNetTrackers) { + NetworkInfo info = t.getNetworkInfo(); + if (info.isConnected()) { + return info; + } + } + return null; + } + + public NetworkInfo getNetworkInfo(int networkType) { + enforceAccessPermission(); + if (ConnectivityManager.isNetworkTypeValid(networkType)) { + NetworkStateTracker t = mNetTrackers[networkType]; + if (t != null) + return t.getNetworkInfo(); + } + return null; + } + + public NetworkInfo[] getAllNetworkInfo() { + enforceAccessPermission(); + NetworkInfo[] result = new NetworkInfo[mNetTrackers.length]; + int i = 0; + for (NetworkStateTracker t : mNetTrackers) { + result[i++] = t.getNetworkInfo(); + } + return result; + } + + public boolean setRadios(boolean turnOn) { + boolean result = true; + enforceChangePermission(); + for (NetworkStateTracker t : mNetTrackers) { + result = t.setRadio(turnOn) && result; + } + return result; + } + + public boolean setRadio(int netType, boolean turnOn) { + enforceChangePermission(); + if (!ConnectivityManager.isNetworkTypeValid(netType)) { + return false; + } + NetworkStateTracker tracker = mNetTrackers[netType]; + return tracker != null && tracker.setRadio(turnOn); + } + + public int startUsingNetworkFeature(int networkType, String feature) { + enforceChangePermission(); + if (!ConnectivityManager.isNetworkTypeValid(networkType)) { + return -1; + } + NetworkStateTracker tracker = mNetTrackers[networkType]; + if (tracker != null) { + return tracker.startUsingNetworkFeature(feature, getCallingPid(), getCallingUid()); + } + return -1; + } + + public int stopUsingNetworkFeature(int networkType, String feature) { + enforceChangePermission(); + if (!ConnectivityManager.isNetworkTypeValid(networkType)) { + return -1; + } + NetworkStateTracker tracker = mNetTrackers[networkType]; + if (tracker != null) { + return tracker.stopUsingNetworkFeature(feature, getCallingPid(), getCallingUid()); + } + return -1; + } + + /** + * Ensure that a network route exists to deliver traffic to the specified + * host via the specified network interface. + * @param networkType the type of the network over which traffic to the specified + * host is to be routed + * @param hostAddress the IP address of the host to which the route is desired + * @return {@code true} on success, {@code false} on failure + */ + public boolean requestRouteToHost(int networkType, int hostAddress) { + enforceChangePermission(); + if (!ConnectivityManager.isNetworkTypeValid(networkType)) { + return false; + } + NetworkStateTracker tracker = mNetTrackers[networkType]; + /* + * If there's only one connected network, and it's the one requested, + * then we don't have to do anything - the requested route already + * exists. If it's not the requested network, then it's not possible + * to establish the requested route. Finally, if there is more than + * one connected network, then we must insert an entry in the routing + * table. + */ + if (getNumConnectedNetworks() > 1) { + return tracker.requestRouteToHost(hostAddress); + } else { + return tracker.getNetworkInfo().getType() == networkType; + } + } + + /** + * @see ConnectivityManager#getBackgroundDataSetting() + */ + public boolean getBackgroundDataSetting() { + return Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.BACKGROUND_DATA, 1) == 1; + } + + /** + * @see ConnectivityManager#setBackgroundDataSetting(boolean) + */ + public void setBackgroundDataSetting(boolean allowBackgroundDataUsage) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.CHANGE_BACKGROUND_DATA_SETTING, + "ConnectivityService"); + + if (getBackgroundDataSetting() == allowBackgroundDataUsage) return; + + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.BACKGROUND_DATA, allowBackgroundDataUsage ? 1 : 0); + + Intent broadcast = new Intent( + ConnectivityManager.ACTION_BACKGROUND_DATA_SETTING_CHANGED); + mContext.sendBroadcast(broadcast); + } + + private int getNumConnectedNetworks() { + int numConnectedNets = 0; + + for (NetworkStateTracker nt : mNetTrackers) { + if (nt.getNetworkInfo().isConnected() && !nt.isTeardownRequested()) { + ++numConnectedNets; + } + } + return numConnectedNets; + } + + private void enforceAccessPermission() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_NETWORK_STATE, + "ConnectivityService"); + } + + private void enforceChangePermission() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CHANGE_NETWORK_STATE, + "ConnectivityService"); + + } + + /** + * Handle a {@code DISCONNECTED} event. If this pertains to the non-active network, + * we ignore it. If it is for the active network, we send out a broadcast. + * But first, we check whether it might be possible to connect to a different + * network. + * @param info the {@code NetworkInfo} for the network + */ + private void handleDisconnect(NetworkInfo info) { + + if (DBG) Log.v(TAG, "Handle DISCONNECT for " + info.getTypeName()); + + mNetTrackers[info.getType()].setTeardownRequested(false); + /* + * If the disconnected network is not the active one, then don't report + * this as a loss of connectivity. What probably happened is that we're + * getting the disconnect for a network that we explicitly disabled + * in accordance with network preference policies. + */ + if (mActiveNetwork == null || info.getType() != mActiveNetwork.getNetworkInfo().getType()) + return; + + NetworkStateTracker newNet; + if (info.getType() == ConnectivityManager.TYPE_MOBILE) { + newNet = mWifiStateTracker; + } else /* info().getType() == TYPE_WIFI */ { + newNet = mMobileDataStateTracker; + } + + /** + * See if the other network is available to fail over to. + * If is not available, we enable it anyway, so that it + * will be able to connect when it does become available, + * but we report a total loss of connectivity rather than + * report that we are attempting to fail over. + */ + NetworkInfo switchTo = null; + if (newNet.isAvailable()) { + mActiveNetwork = newNet; + switchTo = newNet.getNetworkInfo(); + switchTo.setFailover(true); + if (!switchTo.isConnectedOrConnecting()) { + newNet.reconnect(); + } + } else { + newNet.reconnect(); + } + + boolean otherNetworkConnected = false; + Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION); + intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, info); + if (info.isFailover()) { + intent.putExtra(ConnectivityManager.EXTRA_IS_FAILOVER, true); + info.setFailover(false); + } + if (info.getReason() != null) { + intent.putExtra(ConnectivityManager.EXTRA_REASON, info.getReason()); + } + if (info.getExtraInfo() != null) { + intent.putExtra(ConnectivityManager.EXTRA_EXTRA_INFO, info.getExtraInfo()); + } + if (switchTo != null) { + otherNetworkConnected = switchTo.isConnected(); + if (DBG) { + if (otherNetworkConnected) { + Log.v(TAG, "Switching to already connected " + switchTo.getTypeName()); + } else { + Log.v(TAG, "Attempting to switch to " + switchTo.getTypeName()); + } + } + intent.putExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO, switchTo); + } else { + intent.putExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, true); + } + if (DBG) Log.v(TAG, "Sending DISCONNECT bcast for " + info.getTypeName() + + (switchTo == null ? "" : " other=" + switchTo.getTypeName())); + + mContext.sendStickyBroadcast(intent); + /* + * If the failover network is already connected, then immediately send out + * a followup broadcast indicating successful failover + */ + if (switchTo != null && otherNetworkConnected) + sendConnectedBroadcast(switchTo); + } + + private void sendConnectedBroadcast(NetworkInfo info) { + Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION); + intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, info); + if (info.isFailover()) { + intent.putExtra(ConnectivityManager.EXTRA_IS_FAILOVER, true); + info.setFailover(false); + } + if (info.getReason() != null) { + intent.putExtra(ConnectivityManager.EXTRA_REASON, info.getReason()); + } + if (info.getExtraInfo() != null) { + intent.putExtra(ConnectivityManager.EXTRA_EXTRA_INFO, info.getExtraInfo()); + } + mContext.sendStickyBroadcast(intent); + } + + /** + * Called when an attempt to fail over to another network has failed. + * @param info the {@link NetworkInfo} for the failed network + */ + private void handleConnectionFailure(NetworkInfo info) { + mNetTrackers[info.getType()].setTeardownRequested(false); + if (getActiveNetworkInfo() == null) { + String reason = info.getReason(); + String extraInfo = info.getExtraInfo(); + + if (DBG) { + String reasonText; + if (reason == null) { + reasonText = "."; + } else { + reasonText = " (" + reason + ")."; + } + Log.v(TAG, "Attempt to connect to " + info.getTypeName() + " failed" + reasonText); + } + + Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION); + intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, info); + intent.putExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, true); + if (reason != null) { + intent.putExtra(ConnectivityManager.EXTRA_REASON, reason); + } + if (extraInfo != null) { + intent.putExtra(ConnectivityManager.EXTRA_EXTRA_INFO, extraInfo); + } + if (info.isFailover()) { + intent.putExtra(ConnectivityManager.EXTRA_IS_FAILOVER, true); + info.setFailover(false); + } + mContext.sendStickyBroadcast(intent); + } + } + + private void handleConnect(NetworkInfo info) { + if (DBG) Log.v(TAG, "Handle CONNECT for " + info.getTypeName()); + + // snapshot isFailover, because sendConnectedBroadcast() resets it + boolean isFailover = info.isFailover(); + NetworkStateTracker thisNet = mNetTrackers[info.getType()]; + NetworkStateTracker deadnet = null; + NetworkStateTracker otherNet; + if (info.getType() == ConnectivityManager.TYPE_MOBILE) { + otherNet = mWifiStateTracker; + } else /* info().getType() == TYPE_WIFI */ { + otherNet = mMobileDataStateTracker; + } + /* + * Check policy to see whether we are connected to a non-preferred + * network that now needs to be torn down. + */ + NetworkInfo wifiInfo = mWifiStateTracker.getNetworkInfo(); + NetworkInfo mobileInfo = mMobileDataStateTracker.getNetworkInfo(); + if (wifiInfo.isConnected() && mobileInfo.isConnected()) { + if (mNetworkPreference == ConnectivityManager.TYPE_WIFI) + deadnet = mMobileDataStateTracker; + else + deadnet = mWifiStateTracker; + } + + boolean toredown = false; + thisNet.setTeardownRequested(false); + if (!mTestMode && deadnet != null) { + if (DBG) Log.v(TAG, "Policy requires " + + deadnet.getNetworkInfo().getTypeName() + " teardown"); + toredown = teardown(deadnet); + if (DBG && !toredown) { + Log.d(TAG, "Network declined teardown request"); + } + } + + /* + * Note that if toredown is true, deadnet cannot be null, so there is + * no danger of a null pointer exception here.. + */ + if (!toredown || deadnet.getNetworkInfo().getType() != info.getType()) { + mActiveNetwork = thisNet; + if (DBG) Log.v(TAG, "Sending CONNECT bcast for " + info.getTypeName()); + thisNet.updateNetworkSettings(); + sendConnectedBroadcast(info); + if (isFailover) { + otherNet.releaseWakeLock(); + } + } else { + if (DBG) Log.v(TAG, "Not broadcasting CONNECT_ACTION to torn down network " + + info.getTypeName()); + } + } + + private void handleScanResultsAvailable(NetworkInfo info) { + int networkType = info.getType(); + if (networkType != ConnectivityManager.TYPE_WIFI) { + if (DBG) Log.v(TAG, "Got ScanResultsAvailable for " + info.getTypeName() + " network." + + " Don't know how to handle."); + } + + mNetTrackers[networkType].interpretScanResultsAvailable(); + } + + private void handleNotificationChange(boolean visible, int id, Notification notification) { + NotificationManager notificationManager = (NotificationManager) mContext + .getSystemService(Context.NOTIFICATION_SERVICE); + + if (visible) { + notificationManager.notify(id, notification); + } else { + notificationManager.cancel(id); + } + } + + /** + * After any kind of change in the connectivity state of any network, + * make sure that anything that depends on the connectivity state of + * more than one network is set up correctly. We're mainly concerned + * with making sure that the list of DNS servers is set up according + * to which networks are connected, and ensuring that the right routing + * table entries exist. + */ + private void handleConnectivityChange() { + /* + * If both mobile and wifi are enabled, add the host routes that + * will allow MMS traffic to pass on the mobile network. But + * remove the default route for the mobile network, so that there + * will be only one default route, to ensure that all traffic + * except MMS will travel via Wi-Fi. + */ + int numConnectedNets = handleConfigurationChange(); + if (numConnectedNets > 1) { + mMobileDataStateTracker.addPrivateRoutes(); + mMobileDataStateTracker.removeDefaultRoute(); + } else if (mMobileDataStateTracker.getNetworkInfo().isConnected()) { + mMobileDataStateTracker.removePrivateRoutes(); + mMobileDataStateTracker.restoreDefaultRoute(); + } + } + + private int handleConfigurationChange() { + /* + * Set DNS properties. Always put Wi-Fi entries at the front of + * the list if it is active. + */ + int index = 1; + String lastDns = ""; + int numConnectedNets = 0; + int incrValue = ConnectivityManager.TYPE_MOBILE - ConnectivityManager.TYPE_WIFI; + int stopValue = ConnectivityManager.TYPE_MOBILE + incrValue; + + for (int netType = ConnectivityManager.TYPE_WIFI; netType != stopValue; netType += incrValue) { + NetworkStateTracker nt = mNetTrackers[netType]; + if (nt.getNetworkInfo().isConnected() && !nt.isTeardownRequested()) { + ++numConnectedNets; + String[] dnsList = nt.getNameServers(); + for (int i = 0; i < dnsList.length && dnsList[i] != null; i++) { + // skip duplicate entries + if (!dnsList[i].equals(lastDns)) { + SystemProperties.set("net.dns" + index++, dnsList[i]); + lastDns = dnsList[i]; + } + } + } + } + // Null out any DNS properties that are no longer used + for (int i = index; i <= mNumDnsEntries; i++) { + SystemProperties.set("net.dns" + i, ""); + } + mNumDnsEntries = index - 1; + // Notify the name resolver library of the change + SystemProperties.set("net.dnschange", String.valueOf(sDnsChangeCounter++)); + return numConnectedNets; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ConnectivityService from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + if (mActiveNetwork == null) { + pw.println("No active network"); + } else { + pw.println("Active network: " + mActiveNetwork.getNetworkInfo().getTypeName()); + } + pw.println(); + for (NetworkStateTracker nst : mNetTrackers) { + pw.println(nst.getNetworkInfo()); + pw.println(nst); + pw.println(); + } + } + + private class MyHandler extends Handler { + @Override + public void handleMessage(Message msg) { + NetworkInfo info; + switch (msg.what) { + case NetworkStateTracker.EVENT_STATE_CHANGED: + info = (NetworkInfo) msg.obj; + if (DBG) Log.v(TAG, "ConnectivityChange for " + info.getTypeName() + ": " + + info.getState() + "/" + info.getDetailedState()); + + // Connectivity state changed: + // [31-13] Reserved for future use + // [12-9] Network subtype (for mobile network, as defined by TelephonyManager) + // [8-3] Detailed state ordinal (as defined by NetworkInfo.DetailedState) + // [2-0] Network type (as defined by ConnectivityManager) + int eventLogParam = (info.getType() & 0x7) | + ((info.getDetailedState().ordinal() & 0x3f) << 3) | + (info.getSubtype() << 9); + EventLog.writeEvent(EVENTLOG_CONNECTIVITY_STATE_CHANGED, eventLogParam); + + if (info.getDetailedState() == NetworkInfo.DetailedState.FAILED) { + handleConnectionFailure(info); + } else if (info.getState() == NetworkInfo.State.DISCONNECTED) { + handleDisconnect(info); + } else if (info.getState() == NetworkInfo.State.SUSPENDED) { + // TODO: need to think this over. + // the logic here is, handle SUSPENDED the same as DISCONNECTED. The + // only difference being we are broadcasting an intent with NetworkInfo + // that's suspended. This allows the applications an opportunity to + // handle DISCONNECTED and SUSPENDED differently, or not. + handleDisconnect(info); + } else if (info.getState() == NetworkInfo.State.CONNECTED) { + handleConnect(info); + } + handleConnectivityChange(); + break; + + case NetworkStateTracker.EVENT_SCAN_RESULTS_AVAILABLE: + info = (NetworkInfo) msg.obj; + handleScanResultsAvailable(info); + break; + + case NetworkStateTracker.EVENT_NOTIFICATION_CHANGED: + handleNotificationChange(msg.arg1 == 1, msg.arg2, (Notification) msg.obj); + + case NetworkStateTracker.EVENT_CONFIGURATION_CHANGED: + handleConfigurationChange(); + break; + + case NetworkStateTracker.EVENT_ROAMING_CHANGED: + // fill me in + break; + + case NetworkStateTracker.EVENT_NETWORK_SUBTYPE_CHANGED: + // fill me in + break; + } + } + } +} diff --git a/services/java/com/android/server/DemoDataSet.java b/services/java/com/android/server/DemoDataSet.java new file mode 100644 index 0000000..0de7c1e --- /dev/null +++ b/services/java/com/android/server/DemoDataSet.java @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2007 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.ContentResolver; +import android.content.ContentValues; +import android.content.Context; +import android.content.Intent; +import android.content.res.AssetManager; +import android.net.Uri; +import android.os.Environment; +import android.provider.Contacts; +import android.provider.Settings; +import android.provider.MediaStore.Images; +import android.util.Config; +import android.util.Log; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.InputStream; +import java.io.OutputStream; + +public class DemoDataSet +{ + private final static String LOG_TAG = "DemoDataSet"; + + private ContentResolver mContentResolver; + + public final void add(Context context) + { + mContentResolver = context.getContentResolver(); + + // Remove all the old data + mContentResolver.delete(Contacts.People.CONTENT_URI, null, null); + + // Add the new data + addDefaultData(); + + // Add images from /android/images + addDefaultImages(); + } + + private final void addDefaultImages() + { + File rootDirectory = Environment.getRootDirectory(); + String [] files + = new File(rootDirectory, "images").list(); + int count = files.length; + + if (count == 0) { + Log.i(LOG_TAG, "addDefaultImages: no images found!"); + return; + } + + for (int i = 0; i < count; i++) + { + String name = files[i]; + String path = rootDirectory + "/" + name; + + try { + Images.Media.insertImage(mContentResolver, path, name, null); + } catch (FileNotFoundException e) { + Log.e(LOG_TAG, "Failed to import image " + path, e); + } + } + } + + private final void addDefaultData() + { + Log.i(LOG_TAG, "Adding default data..."); + +// addImage("Violet", "images/violet.png"); +// addImage("Corky", "images/corky.png"); + + // PENDING: should this be done here?!?! + Intent intent = new Intent( + Intent.ACTION_CALL, Uri.fromParts("voicemail", "", null)); + addShortcut("1", intent); + } + + private final Uri addImage(String name, Uri file) + { + ContentValues imagev = new ContentValues(); + imagev.put("name", name); + + Uri url = null; + + AssetManager ass = AssetManager.getSystem(); + InputStream in = null; + OutputStream out = null; + + try + { + in = ass.open(file.toString()); + + url = mContentResolver.insert(Images.Media.INTERNAL_CONTENT_URI, imagev); + out = mContentResolver.openOutputStream(url); + + final int size = 8 * 1024; + byte[] buf = new byte[size]; + + int count = 0; + do + { + count = in.read(buf, 0, size); + if (count > 0) { + out.write(buf, 0, count); + } + } while (count > 0); + } + catch (Exception e) + { + Log.e(LOG_TAG, "Failed to insert image '" + file + "'", e); + url = null; + } + + return url; + } + + private final Uri addShortcut(String shortcut, Intent intent) + { + if (Config.LOGV) Log.v(LOG_TAG, "addShortcut: shortcut=" + shortcut + ", intent=" + intent); + return Settings.Bookmarks.add(mContentResolver, intent, null, null, + shortcut != null ? shortcut.charAt(0) : 0, 0); + } +} diff --git a/services/java/com/android/server/DeviceStorageMonitorService.java b/services/java/com/android/server/DeviceStorageMonitorService.java new file mode 100644 index 0000000..85861bb --- /dev/null +++ b/services/java/com/android/server/DeviceStorageMonitorService.java @@ -0,0 +1,314 @@ +/* + * Copyright (C) 2007-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 com.android.server.am.ActivityManagerService; +import android.app.Notification; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.pm.IPackageDataObserver; +import android.content.pm.IPackageManager; +import android.os.Binder; +import android.os.Handler; +import android.os.Message; +import android.os.Process; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.StatFs; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.provider.Settings.Gservices; +import android.util.Config; +import android.util.EventLog; +import android.util.Log; +import android.provider.Settings; + +/** + * This class implements a service to monitor the amount of disk storage space + * on the device. If the free storage on device is less than a tunable threshold value + * (default is 10%. this value is a gservices parameter) a low memory notification is + * displayed to alert the user. If the user clicks on the low memory notification the + * Application Manager application gets launched to let the user free storage space. + * Event log events: + * A low memory event with the free storage on device in bytes is logged to the event log + * when the device goes low on storage space. + * The amount of free storage on the device is periodically logged to the event log. The log + * interval is a gservices parameter with a default value of 12 hours + * When the free storage differential goes below a threshold(again a gservices parameter with + * a default value of 2MB), the free memory is logged to the event log + */ +class DeviceStorageMonitorService extends Binder { + private static final String TAG = "DeviceStorageMonitorService"; + private static final boolean DEBUG = false; + private static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV; + private static final int DEVICE_MEMORY_WHAT = 1; + private static final int MONITOR_INTERVAL = 1; //in minutes + private static final int LOW_MEMORY_NOTIFICATION_ID = 1; + private static final int DEFAULT_THRESHOLD_PERCENTAGE = 10; + private static final int DEFAULT_FREE_STORAGE_LOG_INTERVAL_IN_MINUTES = 12*60; //in minutes + private static final int EVENT_LOG_STORAGE_BELOW_THRESHOLD = 2744; + private static final int EVENT_LOG_LOW_STORAGE_NOTIFICATION = 2745; + private static final int EVENT_LOG_FREE_STORAGE_LEFT = 2746; + private static final long DEFAULT_DISK_FREE_CHANGE_REPORTING_THRESHOLD = 2 * 1024 * 1024; // 2MB + private static final long DEFAULT_CHECK_INTERVAL = MONITOR_INTERVAL*60*1000; + private long mFreeMem; + private long mLastReportedFreeMem; + private long mLastReportedFreeMemTime; + private boolean mLowMemFlag=false; + private Context mContext; + private ContentResolver mContentResolver; + int mBlkSize; + long mTotalMemory; + StatFs mFileStats; + private static final String DATA_PATH="/data"; + long mThreadStartTime = -1; + boolean mClearSucceeded = false; + boolean mClearingCache; + private Intent mStorageLowIntent; + private Intent mStorageOkIntent; + private CachePackageDataObserver mClearCacheObserver; + private static final int _TRUE = 1; + private static final int _FALSE = 0; + + /** + * This string is used for ServiceManager access to this class. + */ + static final String SERVICE = "devicestoragemonitor"; + + /** + * Handler that checks the amount of disk space on the device and sends a + * notification if the device runs low on disk space + */ + Handler mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + //dont handle an invalid message + if (msg.what != DEVICE_MEMORY_WHAT) { + Log.e(TAG, "Will not process invalid message"); + return; + } + checkMemory(msg.arg1 == _TRUE); + } + }; + + class CachePackageDataObserver extends IPackageDataObserver.Stub { + public void onRemoveCompleted(String packageName, boolean succeeded) { + mClearSucceeded = succeeded; + mClearingCache = false; + if(localLOGV) Log.i(TAG, " Clear succeeded:"+mClearSucceeded + +", mClearingCache:"+mClearingCache+" Forcing memory check"); + postCheckMemoryMsg(false, 0); + } + } + + private final void restatDataDir() { + mFileStats.restat(DATA_PATH); + mFreeMem = mFileStats.getAvailableBlocks()*mBlkSize; + // Allow freemem to be overridden by debug.freemem for testing + String debugFreeMem = SystemProperties.get("debug.freemem"); + if (!"".equals(debugFreeMem)) { + mFreeMem = Long.parseLong(debugFreeMem); + } + // Read the log interval from Gservices + long freeMemLogInterval = Gservices.getLong(mContentResolver, + Gservices.SYS_FREE_STORAGE_LOG_INTERVAL, + DEFAULT_FREE_STORAGE_LOG_INTERVAL_IN_MINUTES)*60*1000; + //log the amount of free memory in event log + long currTime = SystemClock.elapsedRealtime(); + if((mLastReportedFreeMemTime == 0) || + (currTime-mLastReportedFreeMemTime) >= freeMemLogInterval) { + mLastReportedFreeMemTime = currTime; + EventLog.writeEvent(EVENT_LOG_FREE_STORAGE_LEFT, mFreeMem); + } + // Read the reporting threshold from Gservices + long threshold = Gservices.getLong(mContentResolver, + Gservices.DISK_FREE_CHANGE_REPORTING_THRESHOLD, + DEFAULT_DISK_FREE_CHANGE_REPORTING_THRESHOLD); + // If mFree changed significantly log the new value + long delta = mFreeMem - mLastReportedFreeMem; + if (delta > threshold || delta < -threshold) { + mLastReportedFreeMem = mFreeMem; + EventLog.writeEvent(EVENT_LOG_STORAGE_BELOW_THRESHOLD, mFreeMem); + } + } + + private final void clearCache() { + if (mClearCacheObserver == null) { + // Lazy instantiation + mClearCacheObserver = new CachePackageDataObserver(); + } + mClearingCache = true; + try { + if (localLOGV) Log.i(TAG, "Clearing cache"); + IPackageManager.Stub.asInterface(ServiceManager.getService("package")). + freeStorageAndNotify(getMemThreshold(), mClearCacheObserver); + } catch (RemoteException e) { + Log.w(TAG, "Failed to get handle for PackageManger Exception: "+e); + mClearingCache = false; + mClearSucceeded = false; + } + } + + private final void checkMemory(boolean checkCache) { + //if the thread that was started to clear cache is still running do nothing till its + //finished clearing cache. Ideally this flag could be modified by clearCache + // and should be accessed via a lock but even if it does this test will fail now and + //hopefully the next time this flag will be set to the correct value. + if(mClearingCache) { + if(localLOGV) Log.i(TAG, "Thread already running just skip"); + //make sure the thread is not hung for too long + long diffTime = System.currentTimeMillis() - mThreadStartTime; + if(diffTime > (10*60*1000)) { + Log.w(TAG, "Thread that clears cache file seems to run for ever"); + } + } else { + restatDataDir(); + if (localLOGV) Log.v(TAG, "freeMemory="+mFreeMem); + + //post intent to NotificationManager to display icon if necessary + long memThreshold = getMemThreshold(); + if (mFreeMem < memThreshold) { + if (!mLowMemFlag) { + if (checkCache) { + // See if clearing cache helps + // Note that clearing cache is asynchronous and so we do a + // memory check again once the cache has been cleared. + mThreadStartTime = System.currentTimeMillis(); + mClearSucceeded = false; + clearCache(); + } else { + Log.i(TAG, "Running low on memory. Sending notification"); + sendNotification(); + mLowMemFlag = true; + } + } else { + if (localLOGV) Log.v(TAG, "Running low on memory " + + "notification already sent. do nothing"); + } + } else { + if (mLowMemFlag) { + Log.i(TAG, "Memory available. Cancelling notification"); + cancelNotification(); + mLowMemFlag = false; + } + } + } + if(localLOGV) Log.i(TAG, "Posting Message again"); + //keep posting messages to itself periodically + postCheckMemoryMsg(true, DEFAULT_CHECK_INTERVAL); + } + + private void postCheckMemoryMsg(boolean clearCache, long delay) { + // Remove queued messages + mHandler.removeMessages(DEVICE_MEMORY_WHAT); + mHandler.sendMessageDelayed(mHandler.obtainMessage(DEVICE_MEMORY_WHAT, + clearCache ?_TRUE : _FALSE, 0), + delay); + } + + /* + * just query settings to retrieve the memory threshold. + * Preferred this over using a ContentObserver since Settings.Gservices caches the value + * any way + */ + private long getMemThreshold() { + int value = Settings.Gservices.getInt( + mContentResolver, + Settings.Gservices.SYS_STORAGE_THRESHOLD_PERCENTAGE, + DEFAULT_THRESHOLD_PERCENTAGE); + if(localLOGV) Log.v(TAG, "Threshold Percentage="+value); + //evaluate threshold value + return mTotalMemory*value; + } + + /** + * Constructor to run service. initializes the disk space threshold value + * and posts an empty message to kickstart the process. + */ + public DeviceStorageMonitorService(Context context) { + mLastReportedFreeMemTime = 0; + mContext = context; + mContentResolver = mContext.getContentResolver(); + //create StatFs object + mFileStats = new StatFs(DATA_PATH); + //initialize block size + mBlkSize = mFileStats.getBlockSize(); + //initialize total storage on device + mTotalMemory = (mFileStats.getBlockCount()*mBlkSize)/100; + mStorageLowIntent = new Intent(Intent.ACTION_DEVICE_STORAGE_LOW); + mStorageOkIntent = new Intent(Intent.ACTION_DEVICE_STORAGE_OK); + checkMemory(true); + } + + + /** + * This method sends a notification to NotificationManager to display + * an error dialog indicating low disk space and launch the Installer + * application + */ + private final void sendNotification() { + if(localLOGV) Log.i(TAG, "Sending low memory notification"); + //log the event to event log with the amount of free storage(in bytes) left on the device + EventLog.writeEvent(EVENT_LOG_LOW_STORAGE_NOTIFICATION, mFreeMem); + // Pack up the values and broadcast them to everyone + Intent lowMemIntent = new Intent(Intent.ACTION_MANAGE_PACKAGE_STORAGE); + lowMemIntent.putExtra("memory", mFreeMem); + lowMemIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + NotificationManager mNotificationMgr = + (NotificationManager)mContext.getSystemService( + Context.NOTIFICATION_SERVICE); + CharSequence title = mContext.getText( + com.android.internal.R.string.low_internal_storage_view_title); + CharSequence details = mContext.getText( + com.android.internal.R.string.low_internal_storage_view_text); + PendingIntent intent = PendingIntent.getActivity(mContext, 0, lowMemIntent, 0); + Notification notification = new Notification(); + notification.icon = com.android.internal.R.drawable.stat_notify_disk_full; + notification.tickerText = title; + notification.flags |= Notification.FLAG_NO_CLEAR; + notification.setLatestEventInfo(mContext, title, details, intent); + mNotificationMgr.notify(LOW_MEMORY_NOTIFICATION_ID, notification); + mContext.sendStickyBroadcast(mStorageLowIntent); + } + + /** + * Cancels low storage notification and sends OK intent. + */ + private final void cancelNotification() { + if(localLOGV) Log.i(TAG, "Canceling low memory notification"); + NotificationManager mNotificationMgr = + (NotificationManager)mContext.getSystemService( + Context.NOTIFICATION_SERVICE); + //cancel notification since memory has been freed + mNotificationMgr.cancel(LOW_MEMORY_NOTIFICATION_ID); + + mContext.removeStickyBroadcast(mStorageLowIntent); + mContext.sendBroadcast(mStorageOkIntent); + } + + public void updateMemory() { + int callingUid = getCallingUid(); + if(callingUid != Process.SYSTEM_UID) { + return; + } + // force an early check + postCheckMemoryMsg(true, 0); + } +} diff --git a/services/java/com/android/server/FallbackCheckinService.java b/services/java/com/android/server/FallbackCheckinService.java new file mode 100644 index 0000000..cf22446 --- /dev/null +++ b/services/java/com/android/server/FallbackCheckinService.java @@ -0,0 +1,75 @@ +/* + * 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.Context; +import android.content.pm.PackageManager; +import android.os.Binder; +import android.os.ICheckinService; +import android.os.IParentalControlCallback; +import android.util.Log; + +import java.io.IOException; + +import com.android.internal.os.RecoverySystem; +import com.google.android.net.ParentalControlState; + +/** + * @hide + */ +public final class FallbackCheckinService extends ICheckinService.Stub { + static final String TAG = "FallbackCheckinService"; + final Context mContext; + + public FallbackCheckinService(Context context) { + mContext = context; + } + + public boolean checkin() { + return false; // failure, because not implemented + } + + public void reportCrashSync(byte[] crashData) { + } + + public void reportCrashAsync(byte[] crashData) { + } + + public void masterClear() { + if (mContext.checkCallingOrSelfPermission("android.permission.MASTER_CLEAR") != + PackageManager.PERMISSION_GRANTED) { + Log.e(TAG, "Permission Denial: can't invoke masterClear from " + + "pid=" + Binder.getCallingPid() + ", " + + "uid=" + Binder.getCallingUid()); + return; + } + + // Save the android ID so the new system can get it erased. + try { + RecoverySystem.rebootAndWipe(); + } catch (IOException e) { + Log.e(TAG, "Reboot for masterClear() failed", e); + } + } + + public void getParentalControlState(IParentalControlCallback p, String requestingApp) + throws android.os.RemoteException { + ParentalControlState state = new ParentalControlState(); + state.isEnabled = false; + p.onResult(state); + } +} diff --git a/services/java/com/android/server/GadgetService.java b/services/java/com/android/server/GadgetService.java new file mode 100644 index 0000000..0943778 --- /dev/null +++ b/services/java/com/android/server/GadgetService.java @@ -0,0 +1,1148 @@ +/* + * Copyright (C) 2007 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.app.AlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.ActivityInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageInfo; +import android.content.pm.ResolveInfo; +import android.content.pm.PackageItemInfo; +import android.content.res.TypedArray; +import android.content.res.XmlResourceParser; +import android.gadget.GadgetManager; +import android.gadget.GadgetProviderInfo; +import android.net.Uri; +import android.os.Binder; +import android.os.Bundle; +import android.os.RemoteException; +import android.os.SystemClock; +import android.util.AttributeSet; +import android.util.Log; +import android.util.Xml; +import android.widget.RemoteViews; + +import java.io.IOException; +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.List; +import java.util.HashMap; +import java.util.HashSet; + +import com.android.internal.gadget.IGadgetService; +import com.android.internal.gadget.IGadgetHost; +import com.android.internal.util.XmlUtils; +import com.android.internal.util.FastXmlSerializer; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; +import org.xmlpull.v1.XmlSerializer; + +class GadgetService extends IGadgetService.Stub +{ + private static final String TAG = "GadgetService"; + + private static final String SETTINGS_FILENAME = "gadgets.xml"; + private static final String SETTINGS_TMP_FILENAME = SETTINGS_FILENAME + ".tmp"; + + /* + * When identifying a Host or Provider based on the calling process, use the uid field. + * When identifying a Host or Provider based on a package manager broadcast, use the + * package given. + */ + + static class Provider { + int uid; + GadgetProviderInfo info; + ArrayList<GadgetId> instances = new ArrayList(); + PendingIntent broadcast; + boolean zombie; // if we're in safe mode, don't prune this just because nobody references it + + int tag; // for use while saving state (the index) + } + + static class Host { + int uid; + int hostId; + String packageName; + ArrayList<GadgetId> instances = new ArrayList(); + IGadgetHost callbacks; + boolean zombie; // if we're in safe mode, don't prune this just because nobody references it + + int tag; // for use while saving state (the index) + } + + static class GadgetId { + int gadgetId; + Provider provider; + RemoteViews views; + Host host; + } + + Context mContext; + PackageManager mPackageManager; + AlarmManager mAlarmManager; + ArrayList<Provider> mInstalledProviders = new ArrayList(); + int mNextGadgetId = GadgetManager.INVALID_GADGET_ID + 1; + ArrayList<GadgetId> mGadgetIds = new ArrayList(); + ArrayList<Host> mHosts = new ArrayList(); + boolean mSafeMode; + + GadgetService(Context context) { + mContext = context; + mPackageManager = context.getPackageManager(); + mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE); + } + + public void systemReady(boolean safeMode) { + mSafeMode = safeMode; + + loadGadgetList(); + loadStateLocked(); + + // Register for the boot completed broadcast, so we can send the + // ENABLE broacasts. If we try to send them now, they time out, + // because the system isn't ready to handle them yet. + mContext.registerReceiver(mBroadcastReceiver, + new IntentFilter(Intent.ACTION_BOOT_COMPLETED), null, null); + + // Register for broadcasts about package install, etc., so we can + // update the provider list. + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_PACKAGE_ADDED); + filter.addAction(Intent.ACTION_PACKAGE_REMOVED); + filter.addDataScheme("package"); + mContext.registerReceiver(mBroadcastReceiver, filter); + } + + @Override + public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + synchronized (mGadgetIds) { + int N = mInstalledProviders.size(); + pw.println("Providers: (size=" + N + ")"); + for (int i=0; i<N; i++) { + Provider p = mInstalledProviders.get(i); + GadgetProviderInfo info = p.info; + pw.println(" [" + i + "] provder=" + info.provider + + " min=(" + info.minWidth + "x" + info.minHeight + ")" + + " updatePeriodMillis=" + info.updatePeriodMillis + + " initialLayout=" + info.initialLayout + " zombie=" + p.zombie); + } + + N = mGadgetIds.size(); + pw.println("GadgetIds: (size=" + N + ")"); + for (int i=0; i<N; i++) { + GadgetId id = mGadgetIds.get(i); + pw.println(" [" + i + "] gadgetId=" + id.gadgetId + + " host=" + id.host.hostId + "/" + id.host.packageName + " provider=" + + (id.provider == null ? "null" : id.provider.info.provider) + + " host.callbacks=" + (id.host != null ? id.host.callbacks : "(no host)") + + " views=" + id.views); + } + + N = mHosts.size(); + pw.println("Hosts: (size=" + N + ")"); + for (int i=0; i<N; i++) { + Host host = mHosts.get(i); + pw.println(" [" + i + "] packageName=" + host.packageName + " uid=" + host.uid + + " hostId=" + host.hostId + " callbacks=" + host.callbacks + + " instances.size=" + host.instances.size() + " zombie=" + host.zombie); + } + } + } + + public int allocateGadgetId(String packageName, int hostId) { + int callingUid = enforceCallingUid(packageName); + synchronized (mGadgetIds) { + int gadgetId = mNextGadgetId++; + + Host host = lookupOrAddHostLocked(callingUid, packageName, hostId); + + GadgetId id = new GadgetId(); + id.gadgetId = gadgetId; + id.host = host; + + host.instances.add(id); + mGadgetIds.add(id); + + saveStateLocked(); + + return gadgetId; + } + } + + public void deleteGadgetId(int gadgetId) { + synchronized (mGadgetIds) { + GadgetId id = lookupGadgetIdLocked(gadgetId); + if (id != null) { + deleteGadgetLocked(id); + saveStateLocked(); + } + } + } + + public void deleteHost(int hostId) { + synchronized (mGadgetIds) { + int callingUid = getCallingUid(); + Host host = lookupHostLocked(callingUid, hostId); + if (host != null) { + deleteHostLocked(host); + saveStateLocked(); + } + } + } + + public void deleteAllHosts() { + synchronized (mGadgetIds) { + int callingUid = getCallingUid(); + final int N = mHosts.size(); + boolean changed = false; + for (int i=N-1; i>=0; i--) { + Host host = mHosts.get(i); + if (host.uid == callingUid) { + deleteHostLocked(host); + changed = true; + } + } + if (changed) { + saveStateLocked(); + } + } + } + + void deleteHostLocked(Host host) { + final int N = host.instances.size(); + for (int i=N-1; i>=0; i--) { + GadgetId id = host.instances.get(i); + deleteGadgetLocked(id); + } + host.instances.clear(); + mHosts.remove(host); + // it's gone or going away, abruptly drop the callback connection + host.callbacks = null; + } + + void deleteGadgetLocked(GadgetId id) { + Host host = id.host; + host.instances.remove(id); + pruneHostLocked(host); + + mGadgetIds.remove(id); + + Provider p = id.provider; + if (p != null) { + p.instances.remove(id); + if (!p.zombie) { + // send the broacast saying that this gadgetId has been deleted + Intent intent = new Intent(GadgetManager.ACTION_GADGET_DELETED); + intent.setComponent(p.info.provider); + intent.putExtra(GadgetManager.EXTRA_GADGET_ID, id.gadgetId); + mContext.sendBroadcast(intent); + if (p.instances.size() == 0) { + // cancel the future updates + cancelBroadcasts(p); + + // send the broacast saying that the provider is not in use any more + intent = new Intent(GadgetManager.ACTION_GADGET_DISABLED); + intent.setComponent(p.info.provider); + mContext.sendBroadcast(intent); + } + } + } + } + + void cancelBroadcasts(Provider p) { + if (p.broadcast != null) { + mAlarmManager.cancel(p.broadcast); + long token = Binder.clearCallingIdentity(); + try { + p.broadcast.cancel(); + } finally { + Binder.restoreCallingIdentity(token); + } + p.broadcast = null; + } + } + + public void bindGadgetId(int gadgetId, ComponentName provider) { + mContext.enforceCallingPermission(android.Manifest.permission.BIND_GADGET, + "bindGagetId gadgetId=" + gadgetId + " provider=" + provider); + synchronized (mGadgetIds) { + GadgetId id = lookupGadgetIdLocked(gadgetId); + if (id == null) { + throw new IllegalArgumentException("bad gadgetId"); + } + if (id.provider != null) { + throw new IllegalArgumentException("gadgetId " + gadgetId + " already bound to " + + id.provider.info.provider); + } + Provider p = lookupProviderLocked(provider); + if (p == null) { + throw new IllegalArgumentException("not a gadget provider: " + provider); + } + if (p.zombie) { + throw new IllegalArgumentException("can't bind to a 3rd party provider in" + + " safe mode: " + provider); + } + + id.provider = p; + p.instances.add(id); + int instancesSize = p.instances.size(); + if (instancesSize == 1) { + // tell the provider that it's ready + sendEnableIntentLocked(p); + } + + // send an update now -- We need this update now, and just for this gadgetId. + // It's less critical when the next one happens, so when we schdule the next one, + // we add updatePeriodMillis to its start time. That time will have some slop, + // but that's okay. + sendUpdateIntentLocked(p, new int[] { gadgetId }); + + // schedule the future updates + registerForBroadcastsLocked(p, getGadgetIds(p)); + saveStateLocked(); + } + } + + public GadgetProviderInfo getGadgetInfo(int gadgetId) { + synchronized (mGadgetIds) { + GadgetId id = lookupGadgetIdLocked(gadgetId); + if (id != null && id.provider != null && !id.provider.zombie) { + return id.provider.info; + } + return null; + } + } + + public RemoteViews getGadgetViews(int gadgetId) { + synchronized (mGadgetIds) { + GadgetId id = lookupGadgetIdLocked(gadgetId); + if (id != null) { + return id.views; + } + return null; + } + } + + public List<GadgetProviderInfo> getInstalledProviders() { + synchronized (mGadgetIds) { + final int N = mInstalledProviders.size(); + ArrayList<GadgetProviderInfo> result = new ArrayList(N); + for (int i=0; i<N; i++) { + Provider p = mInstalledProviders.get(i); + if (!p.zombie) { + result.add(p.info); + } + } + return result; + } + } + + public void updateGadgetIds(int[] gadgetIds, RemoteViews views) { + if (gadgetIds == null) { + return; + } + if (gadgetIds.length == 0) { + return; + } + final int N = gadgetIds.length; + + synchronized (mGadgetIds) { + for (int i=0; i<N; i++) { + GadgetId id = lookupGadgetIdLocked(gadgetIds[i]); + updateGadgetInstanceLocked(id, views); + } + } + } + + public void updateGadgetProvider(ComponentName provider, RemoteViews views) { + synchronized (mGadgetIds) { + Provider p = lookupProviderLocked(provider); + if (p == null) { + Log.w(TAG, "updateGadget: provider doesn't exist: " + provider); + return; + } + ArrayList<GadgetId> instances = p.instances; + final int N = instances.size(); + for (int i=0; i<N; i++) { + GadgetId id = instances.get(i); + updateGadgetInstanceLocked(id, views); + } + } + } + + void updateGadgetInstanceLocked(GadgetId id, RemoteViews views) { + // allow for stale gadgetIds and other badness + // lookup also checks that the calling process can access the gadget id + // drop unbound gadget ids (shouldn't be possible under normal circumstances) + if (id != null && id.provider != null && !id.provider.zombie && !id.host.zombie) { + id.views = views; + + // is anyone listening? + if (id.host.callbacks != null) { + try { + // the lock is held, but this is a oneway call + id.host.callbacks.updateGadget(id.gadgetId, views); + } catch (RemoteException e) { + // It failed; remove the callback. No need to prune because + // we know that this host is still referenced by this instance. + id.host.callbacks = null; + } + } + } + } + + public int[] startListening(IGadgetHost callbacks, String packageName, int hostId, + List<RemoteViews> updatedViews) { + int callingUid = enforceCallingUid(packageName); + synchronized (mGadgetIds) { + Host host = lookupOrAddHostLocked(callingUid, packageName, hostId); + host.callbacks = callbacks; + + updatedViews.clear(); + + ArrayList<GadgetId> instances = host.instances; + int N = instances.size(); + int[] updatedIds = new int[N]; + for (int i=0; i<N; i++) { + GadgetId id = instances.get(i); + updatedIds[i] = id.gadgetId; + updatedViews.add(id.views); + } + return updatedIds; + } + } + + public void stopListening(int hostId) { + synchronized (mGadgetIds) { + Host host = lookupHostLocked(getCallingUid(), hostId); + host.callbacks = null; + pruneHostLocked(host); + } + } + + boolean canAccessGadgetId(GadgetId id, int callingUid) { + if (id.host.uid == callingUid) { + // Apps hosting the gadget have access to it. + return true; + } + if (id.provider != null && id.provider.uid == callingUid) { + // Apps providing the gadget have access to it (if the gadgetId has been bound) + return true; + } + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.BIND_GADGET) + == PackageManager.PERMISSION_GRANTED) { + // Apps that can bind have access to all gadgetIds. + return true; + } + // Nobody else can access it. + return false; + } + + GadgetId lookupGadgetIdLocked(int gadgetId) { + int callingUid = getCallingUid(); + final int N = mGadgetIds.size(); + for (int i=0; i<N; i++) { + GadgetId id = mGadgetIds.get(i); + if (id.gadgetId == gadgetId && canAccessGadgetId(id, callingUid)) { + return id; + } + } + return null; + } + + Provider lookupProviderLocked(ComponentName provider) { + final int N = mInstalledProviders.size(); + for (int i=0; i<N; i++) { + Provider p = mInstalledProviders.get(i); + if (p.info.provider.equals(provider)) { + return p; + } + } + return null; + } + + Host lookupHostLocked(int uid, int hostId) { + final int N = mHosts.size(); + for (int i=0; i<N; i++) { + Host h = mHosts.get(i); + if (h.uid == uid && h.hostId == hostId) { + return h; + } + } + return null; + } + + Host lookupOrAddHostLocked(int uid, String packageName, int hostId) { + final int N = mHosts.size(); + for (int i=0; i<N; i++) { + Host h = mHosts.get(i); + if (h.hostId == hostId && h.packageName.equals(packageName)) { + return h; + } + } + Host host = new Host(); + host.packageName = packageName; + host.uid = uid; + host.hostId = hostId; + mHosts.add(host); + return host; + } + + void pruneHostLocked(Host host) { + if (host.instances.size() == 0 && host.callbacks == null) { + mHosts.remove(host); + } + } + + void loadGadgetList() { + PackageManager pm = mPackageManager; + + Intent intent = new Intent(GadgetManager.ACTION_GADGET_UPDATE); + List<ResolveInfo> broadcastReceivers = pm.queryBroadcastReceivers(intent, + PackageManager.GET_META_DATA); + + final int N = broadcastReceivers.size(); + for (int i=0; i<N; i++) { + ResolveInfo ri = broadcastReceivers.get(i); + addProviderLocked(ri); + } + } + + boolean addProviderLocked(ResolveInfo ri) { + Provider p = parseProviderInfoXml(new ComponentName(ri.activityInfo.packageName, + ri.activityInfo.name), ri); + if (p != null) { + mInstalledProviders.add(p); + return true; + } else { + return false; + } + } + + void removeProviderLocked(int index, Provider p) { + int N = p.instances.size(); + for (int i=0; i<N; i++) { + GadgetId id = p.instances.get(i); + // Call back with empty RemoteViews + updateGadgetInstanceLocked(id, null); + // Stop telling the host about updates for this from now on + cancelBroadcasts(p); + // clear out references to this gadgetID + id.host.instances.remove(id); + mGadgetIds.remove(id); + id.provider = null; + pruneHostLocked(id.host); + id.host = null; + } + p.instances.clear(); + mInstalledProviders.remove(index); + // no need to send the DISABLE broadcast, since the receiver is gone anyway + cancelBroadcasts(p); + } + + void sendEnableIntentLocked(Provider p) { + Intent intent = new Intent(GadgetManager.ACTION_GADGET_ENABLED); + intent.setComponent(p.info.provider); + mContext.sendBroadcast(intent); + } + + void sendUpdateIntentLocked(Provider p, int[] gadgetIds) { + if (gadgetIds != null && gadgetIds.length > 0) { + Intent intent = new Intent(GadgetManager.ACTION_GADGET_UPDATE); + intent.putExtra(GadgetManager.EXTRA_GADGET_IDS, gadgetIds); + intent.setComponent(p.info.provider); + mContext.sendBroadcast(intent); + } + } + + void registerForBroadcastsLocked(Provider p, int[] gadgetIds) { + if (p.info.updatePeriodMillis > 0) { + // if this is the first instance, set the alarm. otherwise, + // rely on the fact that we've already set it and that + // PendingIntent.getBroadcast will update the extras. + boolean alreadyRegistered = p.broadcast != null; + int instancesSize = p.instances.size(); + Intent intent = new Intent(GadgetManager.ACTION_GADGET_UPDATE); + intent.putExtra(GadgetManager.EXTRA_GADGET_IDS, gadgetIds); + intent.setComponent(p.info.provider); + long token = Binder.clearCallingIdentity(); + try { + p.broadcast = PendingIntent.getBroadcast(mContext, 1, intent, + PendingIntent.FLAG_UPDATE_CURRENT); + } finally { + Binder.restoreCallingIdentity(token); + } + if (!alreadyRegistered) { + mAlarmManager.setInexactRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, + SystemClock.elapsedRealtime() + p.info.updatePeriodMillis, + p.info.updatePeriodMillis, p.broadcast); + } + } + } + + static int[] getGadgetIds(Provider p) { + int instancesSize = p.instances.size(); + int gadgetIds[] = new int[instancesSize]; + for (int i=0; i<instancesSize; i++) { + gadgetIds[i] = p.instances.get(i).gadgetId; + } + return gadgetIds; + } + + public int[] getGadgetIds(ComponentName provider) { + synchronized (mGadgetIds) { + Provider p = lookupProviderLocked(provider); + if (p != null && getCallingUid() == p.uid) { + return getGadgetIds(p); + } else { + return new int[0]; + } + } + } + + private Provider parseProviderInfoXml(ComponentName component, ResolveInfo ri) { + Provider p = null; + + ActivityInfo activityInfo = ri.activityInfo; + XmlResourceParser parser = null; + try { + parser = activityInfo.loadXmlMetaData(mPackageManager, + GadgetManager.META_DATA_GADGET_PROVIDER); + if (parser == null) { + Log.w(TAG, "No " + GadgetManager.META_DATA_GADGET_PROVIDER + " meta-data for " + + "gadget provider '" + component + '\''); + return null; + } + + AttributeSet attrs = Xml.asAttributeSet(parser); + + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && type != XmlPullParser.START_TAG) { + // drain whitespace, comments, etc. + } + + String nodeName = parser.getName(); + if (!"gadget-provider".equals(nodeName)) { + Log.w(TAG, "Meta-data does not start with gadget-provider tag for" + + " gadget provider '" + component + '\''); + return null; + } + + p = new Provider(); + GadgetProviderInfo info = p.info = new GadgetProviderInfo(); + + info.provider = component; + p.uid = activityInfo.applicationInfo.uid; + + TypedArray sa = mContext.getResources().obtainAttributes(attrs, + com.android.internal.R.styleable.GadgetProviderInfo); + info.minWidth = sa.getDimensionPixelSize( + com.android.internal.R.styleable.GadgetProviderInfo_minWidth, 0); + info.minHeight = sa.getDimensionPixelSize( + com.android.internal.R.styleable.GadgetProviderInfo_minHeight, 0); + info.updatePeriodMillis = sa.getInt( + com.android.internal.R.styleable.GadgetProviderInfo_updatePeriodMillis, 0); + info.initialLayout = sa.getResourceId( + com.android.internal.R.styleable.GadgetProviderInfo_initialLayout, 0); + String className = sa.getString( + com.android.internal.R.styleable.GadgetProviderInfo_configure); + if (className != null) { + info.configure = new ComponentName(component.getPackageName(), className); + } + info.label = activityInfo.loadLabel(mPackageManager).toString(); + info.icon = ri.getIconResource(); + sa.recycle(); + } catch (Exception e) { + // Ok to catch Exception here, because anything going wrong because + // of what a client process passes to us should not be fatal for the + // system process. + Log.w(TAG, "XML parsing failed for gadget provider '" + component + '\'', e); + return null; + } finally { + if (parser != null) parser.close(); + } + return p; + } + + int getUidForPackage(String packageName) throws PackageManager.NameNotFoundException { + PackageInfo pkgInfo = mPackageManager.getPackageInfo(packageName, 0); + if (pkgInfo == null || pkgInfo.applicationInfo == null) { + throw new PackageManager.NameNotFoundException(); + } + return pkgInfo.applicationInfo.uid; + } + + int enforceCallingUid(String packageName) throws IllegalArgumentException { + int callingUid = getCallingUid(); + int packageUid; + try { + packageUid = getUidForPackage(packageName); + } catch (PackageManager.NameNotFoundException ex) { + throw new IllegalArgumentException("packageName and uid don't match packageName=" + + packageName); + } + if (callingUid != packageUid) { + throw new IllegalArgumentException("packageName and uid don't match packageName=" + + packageName); + } + return callingUid; + } + + void sendInitialBroadcasts() { + synchronized (mGadgetIds) { + final int N = mInstalledProviders.size(); + for (int i=0; i<N; i++) { + Provider p = mInstalledProviders.get(i); + if (p.instances.size() > 0) { + sendEnableIntentLocked(p); + int[] gadgetIds = getGadgetIds(p); + sendUpdateIntentLocked(p, gadgetIds); + registerForBroadcastsLocked(p, gadgetIds); + } + } + } + } + + // only call from initialization -- it assumes that the data structures are all empty + void loadStateLocked() { + File temp = savedStateTempFile(); + File real = savedStateRealFile(); + + // prefer the real file. If it doesn't exist, use the temp one, and then copy it to the + // real one. if there is both a real file and a temp one, assume that the temp one isn't + // fully written and delete it. + if (real.exists()) { + readStateFromFileLocked(real); + if (temp.exists()) { + temp.delete(); + } + } else if (temp.exists()) { + readStateFromFileLocked(temp); + temp.renameTo(real); + } + } + + void saveStateLocked() { + File temp = savedStateTempFile(); + File real = savedStateRealFile(); + + if (!real.exists()) { + // If the real one doesn't exist, it's either because this is the first time + // or because something went wrong while copying them. In this case, we can't + // trust anything that's in temp. In order to have the loadState code not + // use the temporary one until it's fully written, create an empty file + // for real, which will we'll shortly delete. + try { + real.createNewFile(); + } catch (IOException e) { + } + } + + if (temp.exists()) { + temp.delete(); + } + + writeStateToFileLocked(temp); + + real.delete(); + temp.renameTo(real); + } + + void writeStateToFileLocked(File file) { + FileOutputStream stream = null; + int N; + + try { + stream = new FileOutputStream(file, false); + XmlSerializer out = new FastXmlSerializer(); + out.setOutput(stream, "utf-8"); + out.startDocument(null, true); + + + out.startTag(null, "gs"); + + int providerIndex = 0; + N = mInstalledProviders.size(); + for (int i=0; i<N; i++) { + Provider p = mInstalledProviders.get(i); + if (p.instances.size() > 0) { + out.startTag(null, "p"); + out.attribute(null, "pkg", p.info.provider.getPackageName()); + out.attribute(null, "cl", p.info.provider.getClassName()); + out.endTag(null, "h"); + p.tag = providerIndex; + providerIndex++; + } + } + + N = mHosts.size(); + for (int i=0; i<N; i++) { + Host host = mHosts.get(i); + out.startTag(null, "h"); + out.attribute(null, "pkg", host.packageName); + out.attribute(null, "id", Integer.toHexString(host.hostId)); + out.endTag(null, "h"); + host.tag = i; + } + + N = mGadgetIds.size(); + for (int i=0; i<N; i++) { + GadgetId id = mGadgetIds.get(i); + out.startTag(null, "g"); + out.attribute(null, "id", Integer.toHexString(id.gadgetId)); + out.attribute(null, "h", Integer.toHexString(id.host.tag)); + if (id.provider != null) { + out.attribute(null, "p", Integer.toHexString(id.provider.tag)); + } + out.endTag(null, "g"); + } + + out.endTag(null, "gs"); + + out.endDocument(); + stream.close(); + } catch (IOException e) { + try { + if (stream != null) { + stream.close(); + } + } catch (IOException ex) { + } + if (file.exists()) { + file.delete(); + } + } + } + + void readStateFromFileLocked(File file) { + FileInputStream stream = null; + + boolean success = false; + + try { + stream = new FileInputStream(file); + XmlPullParser parser = Xml.newPullParser(); + parser.setInput(stream, null); + + int type; + int providerIndex = 0; + HashMap<Integer,Provider> loadedProviders = new HashMap(); + do { + type = parser.next(); + if (type == XmlPullParser.START_TAG) { + String tag = parser.getName(); + if ("p".equals(tag)) { + // TODO: do we need to check that this package has the same signature + // as before? + String pkg = parser.getAttributeValue(null, "pkg"); + String cl = parser.getAttributeValue(null, "cl"); + Provider p = lookupProviderLocked(new ComponentName(pkg, cl)); + if (p == null && mSafeMode) { + // if we're in safe mode, make a temporary one + p = new Provider(); + p.info = new GadgetProviderInfo(); + p.info.provider = new ComponentName(pkg, cl); + p.zombie = true; + mInstalledProviders.add(p); + } + if (p != null) { + // if it wasn't uninstalled or something + loadedProviders.put(providerIndex, p); + } + providerIndex++; + } + else if ("h".equals(tag)) { + Host host = new Host(); + + // TODO: do we need to check that this package has the same signature + // as before? + host.packageName = parser.getAttributeValue(null, "pkg"); + try { + host.uid = getUidForPackage(host.packageName); + } catch (PackageManager.NameNotFoundException ex) { + host.zombie = true; + } + if (!host.zombie || mSafeMode) { + // In safe mode, we don't discard the hosts we don't recognize + // so that they're not pruned from our list. Otherwise, we do. + host.hostId = Integer.parseInt( + parser.getAttributeValue(null, "id"), 16); + mHosts.add(host); + } + } + else if ("g".equals(tag)) { + GadgetId id = new GadgetId(); + id.gadgetId = Integer.parseInt(parser.getAttributeValue(null, "id"), 16); + if (id.gadgetId >= mNextGadgetId) { + mNextGadgetId = id.gadgetId + 1; + } + + String providerString = parser.getAttributeValue(null, "p"); + if (providerString != null) { + // there's no provider if it hasn't been bound yet. + // maybe we don't have to save this, but it brings the system + // to the state it was in. + int pIndex = Integer.parseInt(providerString, 16); + id.provider = loadedProviders.get(pIndex); + if (false) { + Log.d(TAG, "bound gadgetId=" + id.gadgetId + " to provider " + + pIndex + " which is " + id.provider); + } + if (id.provider == null) { + // This provider is gone. We just let the host figure out + // that this happened when it fails to load it. + continue; + } + } + + int hIndex = Integer.parseInt(parser.getAttributeValue(null, "h"), 16); + id.host = mHosts.get(hIndex); + if (id.host == null) { + // This host is gone. + continue; + } + + if (id.provider != null) { + id.provider.instances.add(id); + } + id.host.instances.add(id); + mGadgetIds.add(id); + } + } + } while (type != XmlPullParser.END_DOCUMENT); + success = true; + } catch (NullPointerException e) { + Log.w(TAG, "failed parsing " + file, e); + } catch (NumberFormatException e) { + Log.w(TAG, "failed parsing " + file, e); + } catch (XmlPullParserException e) { + Log.w(TAG, "failed parsing " + file, e); + } catch (IOException e) { + Log.w(TAG, "failed parsing " + file, e); + } catch (IndexOutOfBoundsException e) { + Log.w(TAG, "failed parsing " + file, e); + } + try { + if (stream != null) { + stream.close(); + } + } catch (IOException e) { + } + + if (success) { + // delete any hosts that didn't manage to get connected (should happen) + // if it matters, they'll be reconnected. + final int N = mHosts.size(); + for (int i=0; i<N; i++) { + pruneHostLocked(mHosts.get(i)); + } + } else { + // failed reading, clean up + mGadgetIds.clear(); + mHosts.clear(); + final int N = mInstalledProviders.size(); + for (int i=0; i<N; i++) { + mInstalledProviders.get(i).instances.clear(); + } + } + } + + File savedStateTempFile() { + return new File("/data/system/" + SETTINGS_TMP_FILENAME); + //return new File(mContext.getFilesDir(), SETTINGS_FILENAME); + } + + File savedStateRealFile() { + return new File("/data/system/" + SETTINGS_FILENAME); + //return new File(mContext.getFilesDir(), SETTINGS_TMP_FILENAME); + } + + BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + //Log.d(TAG, "received " + action); + if (Intent.ACTION_BOOT_COMPLETED.equals(action)) { + sendInitialBroadcasts(); + } else { + Uri uri = intent.getData(); + if (uri == null) { + return; + } + String pkgName = uri.getSchemeSpecificPart(); + if (pkgName == null) { + return; + } + + if (Intent.ACTION_PACKAGE_ADDED.equals(action)) { + synchronized (mGadgetIds) { + Bundle extras = intent.getExtras(); + if (extras != null && extras.getBoolean(Intent.EXTRA_REPLACING, false)) { + // The package was just upgraded + updateProvidersForPackageLocked(pkgName); + } else { + // The package was just added + addProvidersForPackageLocked(pkgName); + } + saveStateLocked(); + } + } + else if (Intent.ACTION_PACKAGE_REMOVED.equals(action)) { + Bundle extras = intent.getExtras(); + if (extras != null && extras.getBoolean(Intent.EXTRA_REPLACING, false)) { + // The package is being updated. We'll receive a PACKAGE_ADDED shortly. + } else { + synchronized (mGadgetIds) { + removeProvidersForPackageLocked(pkgName); + saveStateLocked(); + } + } + } + } + } + }; + + // TODO: If there's a better way of matching an intent filter against the + // packages for a given package, use that. + void addProvidersForPackageLocked(String pkgName) { + Intent intent = new Intent(GadgetManager.ACTION_GADGET_UPDATE); + List<ResolveInfo> broadcastReceivers = mPackageManager.queryBroadcastReceivers(intent, + PackageManager.GET_META_DATA); + + final int N = broadcastReceivers.size(); + for (int i=0; i<N; i++) { + ResolveInfo ri = broadcastReceivers.get(i); + ActivityInfo ai = ri.activityInfo; + + if (pkgName.equals(ai.packageName)) { + addProviderLocked(ri); + } + } + } + + // TODO: If there's a better way of matching an intent filter against the + // packages for a given package, use that. + void updateProvidersForPackageLocked(String pkgName) { + HashSet<String> keep = new HashSet(); + Intent intent = new Intent(GadgetManager.ACTION_GADGET_UPDATE); + List<ResolveInfo> broadcastReceivers = mPackageManager.queryBroadcastReceivers(intent, + PackageManager.GET_META_DATA); + + // add the missing ones and collect which ones to keep + int N = broadcastReceivers.size(); + for (int i=0; i<N; i++) { + ResolveInfo ri = broadcastReceivers.get(i); + ActivityInfo ai = ri.activityInfo; + if (pkgName.equals(ai.packageName)) { + ComponentName component = new ComponentName(ai.packageName, ai.name); + Provider p = lookupProviderLocked(component); + if (p == null) { + if (addProviderLocked(ri)) { + keep.add(ai.name); + } + } else { + Provider parsed = parseProviderInfoXml(component, ri); + if (parsed != null) { + keep.add(ai.name); + // Use the new GadgetProviderInfo. + GadgetProviderInfo oldInfo = p.info; + p.info = parsed.info; + // If it's enabled + final int M = p.instances.size(); + if (M > 0) { + int[] gadgetIds = getGadgetIds(p); + // Reschedule for the new updatePeriodMillis (don't worry about handling + // it specially if updatePeriodMillis didn't change because we just sent + // an update, and the next one will be updatePeriodMillis from now). + cancelBroadcasts(p); + registerForBroadcastsLocked(p, gadgetIds); + // If it's currently showing, call back with the new GadgetProviderInfo. + for (int j=0; j<M; j++) { + GadgetId id = p.instances.get(j); + if (id.host != null && id.host.callbacks != null) { + try { + id.host.callbacks.providerChanged(id.gadgetId, p.info); + } catch (RemoteException ex) { + // It failed; remove the callback. No need to prune because + // we know that this host is still referenced by this + // instance. + id.host.callbacks = null; + } + } + } + // Now that we've told the host, push out an update. + sendUpdateIntentLocked(p, gadgetIds); + } + } + } + } + } + + // prune the ones we don't want to keep + N = mInstalledProviders.size(); + for (int i=N-1; i>=0; i--) { + Provider p = mInstalledProviders.get(i); + if (pkgName.equals(p.info.provider.getPackageName()) + && !keep.contains(p.info.provider.getClassName())) { + removeProviderLocked(i, p); + } + } + } + + void removeProvidersForPackageLocked(String pkgName) { + int N = mInstalledProviders.size(); + for (int i=N-1; i>=0; i--) { + Provider p = mInstalledProviders.get(i); + if (pkgName.equals(p.info.provider.getPackageName())) { + removeProviderLocked(i, p); + } + } + + // Delete the hosts for this package too + // + // By now, we have removed any gadgets that were in any hosts here, + // so we don't need to worry about sending DISABLE broadcasts to them. + N = mHosts.size(); + for (int i=N-1; i>=0; i--) { + Host host = mHosts.get(i); + if (pkgName.equals(host.packageName)) { + deleteHostLocked(host); + } + } + } +} + diff --git a/services/java/com/android/server/HardwareService.java b/services/java/com/android/server/HardwareService.java new file mode 100755 index 0000000..2131ffd --- /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(); +} diff --git a/services/java/com/android/server/HeadsetObserver.java b/services/java/com/android/server/HeadsetObserver.java new file mode 100644 index 0000000..855734d --- /dev/null +++ b/services/java/com/android/server/HeadsetObserver.java @@ -0,0 +1,144 @@ +/* + * 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.app.ActivityManagerNative; +import android.content.Context; +import android.content.Intent; +import android.os.Handler; +import android.os.Message; +import android.os.UEventObserver; +import android.util.Log; +import android.media.AudioManager; + +import java.io.FileReader; +import java.io.FileNotFoundException; + +/** + * <p>HeadsetObserver monitors for a wired headset. + */ +class HeadsetObserver extends UEventObserver { + private static final String TAG = HeadsetObserver.class.getSimpleName(); + + private static final String HEADSET_UEVENT_MATCH = "DEVPATH=/devices/virtual/switch/h2w"; + private static final String HEADSET_STATE_PATH = "/sys/class/switch/h2w/state"; + private static final String HEADSET_NAME_PATH = "/sys/class/switch/h2w/name"; + + private Context mContext; + + private int mHeadsetState; + private String mHeadsetName; + private boolean mAudioRouteNeedsUpdate; + private AudioManager mAudioManager; + + public HeadsetObserver(Context context) { + mContext = context; + + startObserving(HEADSET_UEVENT_MATCH); + + init(); // set initial status + } + + @Override + public void onUEvent(UEventObserver.UEvent event) { + Log.v(TAG, "Headset UEVENT: " + event.toString()); + + try { + update(event.get("SWITCH_NAME"), Integer.parseInt(event.get("SWITCH_STATE"))); + } catch (NumberFormatException e) { + Log.e(TAG, "Could not parse switch state from event " + event); + } + } + + private synchronized final void init() { + char[] buffer = new char[1024]; + + String newName = mHeadsetName; + int newState = mHeadsetState; + try { + FileReader file = new FileReader(HEADSET_STATE_PATH); + int len = file.read(buffer, 0, 1024); + newState = Integer.valueOf((new String(buffer, 0, len)).trim()); + + file = new FileReader(HEADSET_NAME_PATH); + len = file.read(buffer, 0, 1024); + newName = new String(buffer, 0, len).trim(); + + } catch (FileNotFoundException e) { + Log.w(TAG, "This kernel does not have wired headset support"); + } catch (Exception e) { + Log.e(TAG, "" , e); + } + + mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); + update(newName, newState); + } + + private synchronized final void update(String newName, int newState) { + if (newName != mHeadsetName || newState != mHeadsetState) { + boolean isUnplug = (newState == 0 && mHeadsetState == 1); + mHeadsetName = newName; + mHeadsetState = newState; + mAudioRouteNeedsUpdate = true; + + sendIntent(isUnplug); + + if (isUnplug) { + // It often takes >200ms to flush the audio pipeline after apps + // pause audio playback, but audio route changes are immediate, + // so delay the route change by 400ms. + // This could be improved once the audio sub-system provides an + // interface to clear the audio pipeline. + mHandler.sendEmptyMessageDelayed(0, 400); + } else { + updateAudioRoute(); + } + } + } + + private synchronized final void sendIntent(boolean isUnplug) { + // Pack up the values and broadcast them to everyone + Intent intent = new Intent(Intent.ACTION_HEADSET_PLUG); + intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); + + intent.putExtra("state", mHeadsetState); + intent.putExtra("name", mHeadsetName); + + // TODO: Should we require a permission? + ActivityManagerNative.broadcastStickyIntent(intent, null); + + if (isUnplug) { + intent = new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY); + mContext.sendBroadcast(intent); + } + } + + private synchronized final void updateAudioRoute() { + if (mAudioRouteNeedsUpdate) { + mAudioManager.setWiredHeadsetOn(mHeadsetState == 1); + mAudioRouteNeedsUpdate = false; + } + } + + private final Handler mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + updateAudioRoute(); + } + }; + +} diff --git a/services/java/com/android/server/InputDevice.java b/services/java/com/android/server/InputDevice.java new file mode 100644 index 0000000..7b8a2a4 --- /dev/null +++ b/services/java/com/android/server/InputDevice.java @@ -0,0 +1,213 @@ +/* + * Copyright (C) 2007 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.util.Log; +import android.view.Display; +import android.view.MotionEvent; +import android.view.Surface; +import android.view.WindowManagerPolicy; + +public class InputDevice { + /** Amount that trackball needs to move in order to generate a key event. */ + static final int TRACKBALL_MOVEMENT_THRESHOLD = 6; + + final int id; + final int classes; + final String name; + final AbsoluteInfo absX; + final AbsoluteInfo absY; + final AbsoluteInfo absPressure; + final AbsoluteInfo absSize; + + long mDownTime = 0; + int mMetaKeysState = 0; + + final MotionState mAbs = new MotionState(0, 0); + final MotionState mRel = new MotionState(TRACKBALL_MOVEMENT_THRESHOLD, + TRACKBALL_MOVEMENT_THRESHOLD); + + static class MotionState { + int xPrecision; + int yPrecision; + float xMoveScale; + float yMoveScale; + MotionEvent currentMove = null; + boolean changed = false; + boolean down = false; + boolean lastDown = false; + long downTime = 0; + int x = 0; + int y = 0; + int pressure = 1; + int size = 0; + + MotionState(int mx, int my) { + xPrecision = mx; + yPrecision = my; + xMoveScale = mx != 0 ? (1.0f/mx) : 1.0f; + yMoveScale = my != 0 ? (1.0f/my) : 1.0f; + } + + MotionEvent generateMotion(InputDevice device, long curTime, + boolean isAbs, Display display, int orientation, + int metaState) { + if (!changed) { + return null; + } + + float scaledX = x; + float scaledY = y; + float temp; + float scaledPressure = 1.0f; + float scaledSize = 0; + int edgeFlags = 0; + if (isAbs) { + int w = display.getWidth()-1; + int h = display.getHeight()-1; + if (orientation == Surface.ROTATION_90 + || orientation == Surface.ROTATION_270) { + int tmp = w; + w = h; + h = tmp; + } + if (device.absX != null) { + scaledX = ((scaledX-device.absX.minValue) + / device.absX.range) * w; + } + if (device.absY != null) { + scaledY = ((scaledY-device.absY.minValue) + / device.absY.range) * h; + } + if (device.absPressure != null) { + scaledPressure = + ((pressure-device.absPressure.minValue) + / (float)device.absPressure.range); + } + if (device.absSize != null) { + scaledSize = + ((size-device.absSize.minValue) + / (float)device.absSize.range); + } + switch (orientation) { + case Surface.ROTATION_90: + temp = scaledX; + scaledX = scaledY; + scaledY = w-temp; + break; + case Surface.ROTATION_180: + scaledX = w-scaledX; + scaledY = h-scaledY; + break; + case Surface.ROTATION_270: + temp = scaledX; + scaledX = h-scaledY; + scaledY = temp; + break; + } + + if (scaledX == 0) { + edgeFlags += MotionEvent.EDGE_LEFT; + } else if (scaledX == display.getWidth() - 1.0f) { + edgeFlags += MotionEvent.EDGE_RIGHT; + } + + if (scaledY == 0) { + edgeFlags += MotionEvent.EDGE_TOP; + } else if (scaledY == display.getHeight() - 1.0f) { + edgeFlags += MotionEvent.EDGE_BOTTOM; + } + + } else { + scaledX *= xMoveScale; + scaledY *= yMoveScale; + switch (orientation) { + case Surface.ROTATION_90: + temp = scaledX; + scaledX = scaledY; + scaledY = -temp; + break; + case Surface.ROTATION_180: + scaledX = -scaledX; + scaledY = -scaledY; + break; + case Surface.ROTATION_270: + temp = scaledX; + scaledX = -scaledY; + scaledY = temp; + break; + } + } + + changed = false; + if (down != lastDown) { + int action; + lastDown = down; + if (down) { + action = MotionEvent.ACTION_DOWN; + downTime = curTime; + } else { + action = MotionEvent.ACTION_UP; + } + currentMove = null; + if (!isAbs) { + x = y = 0; + } + return MotionEvent.obtain(downTime, curTime, action, + scaledX, scaledY, scaledPressure, scaledSize, metaState, + xPrecision, yPrecision, device.id, edgeFlags); + } else { + if (currentMove != null) { + if (false) Log.i("InputDevice", "Adding batch x=" + scaledX + + " y=" + scaledY + " to " + currentMove); + currentMove.addBatch(curTime, scaledX, scaledY, + scaledPressure, scaledSize, metaState); + if (WindowManagerPolicy.WATCH_POINTER) { + Log.i("KeyInputQueue", "Updating: " + currentMove); + } + return null; + } + MotionEvent me = MotionEvent.obtain(downTime, curTime, + MotionEvent.ACTION_MOVE, scaledX, scaledY, + scaledPressure, scaledSize, metaState, + xPrecision, yPrecision, device.id, edgeFlags); + currentMove = me; + return me; + } + } + } + + static class AbsoluteInfo { + int minValue; + int maxValue; + int range; + int flat; + int fuzz; + }; + + InputDevice(int _id, int _classes, String _name, + AbsoluteInfo _absX, AbsoluteInfo _absY, + AbsoluteInfo _absPressure, AbsoluteInfo _absSize) { + id = _id; + classes = _classes; + name = _name; + absX = _absX; + absY = _absY; + absPressure = _absPressure; + absSize = _absSize; + } +}; diff --git a/services/java/com/android/server/InputMethodManagerService.java b/services/java/com/android/server/InputMethodManagerService.java new file mode 100644 index 0000000..4b45828 --- /dev/null +++ b/services/java/com/android/server/InputMethodManagerService.java @@ -0,0 +1,1564 @@ +/* + * Copyright (C) 2006-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 com.android.internal.os.HandlerCaller; +import com.android.internal.view.IInputContext; +import com.android.internal.view.IInputMethod; +import com.android.internal.view.IInputMethodCallback; +import com.android.internal.view.IInputMethodClient; +import com.android.internal.view.IInputMethodManager; +import com.android.internal.view.IInputMethodSession; +import com.android.internal.view.InputBindResult; + +import com.android.server.status.IconData; +import com.android.server.status.StatusBarService; + +import org.xmlpull.v1.XmlPullParserException; + +import android.app.ActivityManagerNative; +import android.app.AlertDialog; +import android.content.ComponentName; +import android.content.ContentResolver; +import android.content.Context; +import android.content.DialogInterface; +import android.content.IntentFilter; +import android.content.DialogInterface.OnCancelListener; +import android.content.Intent; +import android.content.ServiceConnection; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.content.res.Resources; +import android.content.res.TypedArray; +import android.database.ContentObserver; +import android.net.Uri; +import android.os.Binder; +import android.os.Handler; +import android.os.IBinder; +import android.os.IInterface; +import android.os.Message; +import android.os.Parcel; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.provider.Settings; +import android.text.TextUtils; +import android.util.EventLog; +import android.util.Log; +import android.util.PrintWriterPrinter; +import android.util.Printer; +import android.view.IWindowManager; +import android.view.WindowManager; +import android.view.inputmethod.InputBinding; +import android.view.inputmethod.InputMethod; +import android.view.inputmethod.InputMethodInfo; +import android.view.inputmethod.InputMethodManager; +import android.view.inputmethod.EditorInfo; + +import java.io.FileDescriptor; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +/** + * This class provides a system service that manages input methods. + */ +public class InputMethodManagerService extends IInputMethodManager.Stub + implements ServiceConnection, Handler.Callback { + static final boolean DEBUG = false; + static final String TAG = "InputManagerService"; + + static final int MSG_SHOW_IM_PICKER = 1; + + static final int MSG_UNBIND_INPUT = 1000; + static final int MSG_BIND_INPUT = 1010; + static final int MSG_SHOW_SOFT_INPUT = 1020; + static final int MSG_HIDE_SOFT_INPUT = 1030; + static final int MSG_ATTACH_TOKEN = 1040; + static final int MSG_CREATE_SESSION = 1050; + + static final int MSG_START_INPUT = 2000; + static final int MSG_RESTART_INPUT = 2010; + + static final int MSG_UNBIND_METHOD = 3000; + static final int MSG_BIND_METHOD = 3010; + + static final long TIME_TO_RECONNECT = 10*1000; + + static final int LOG_IMF_FORCE_RECONNECT_IME = 32000; + + final Context mContext; + final Handler mHandler; + final SettingsObserver mSettingsObserver; + final StatusBarService mStatusBar; + final IBinder mInputMethodIcon; + final IconData mInputMethodData; + final IWindowManager mIWindowManager; + final HandlerCaller mCaller; + + final InputBindResult mNoBinding = new InputBindResult(null, null, -1); + + // All known input methods. mMethodMap also serves as the global + // lock for this class. + final ArrayList<InputMethodInfo> mMethodList + = new ArrayList<InputMethodInfo>(); + final HashMap<String, InputMethodInfo> mMethodMap + = new HashMap<String, InputMethodInfo>(); + + final TextUtils.SimpleStringSplitter mStringColonSplitter + = new TextUtils.SimpleStringSplitter(':'); + + class SessionState { + final ClientState client; + final IInputMethod method; + final IInputMethodSession session; + + @Override + public String toString() { + return "SessionState{uid " + client.uid + " pid " + client.pid + + " method " + Integer.toHexString( + System.identityHashCode(method)) + + " session " + Integer.toHexString( + System.identityHashCode(session)) + + "}"; + } + + SessionState(ClientState _client, IInputMethod _method, + IInputMethodSession _session) { + client = _client; + method = _method; + session = _session; + } + } + + class ClientState { + final IInputMethodClient client; + final IInputContext inputContext; + final int uid; + final int pid; + final InputBinding binding; + + boolean sessionRequested; + SessionState curSession; + + @Override + public String toString() { + return "ClientState{" + Integer.toHexString( + System.identityHashCode(this)) + " uid " + uid + + " pid " + pid + "}"; + } + + ClientState(IInputMethodClient _client, IInputContext _inputContext, + int _uid, int _pid) { + client = _client; + inputContext = _inputContext; + uid = _uid; + pid = _pid; + binding = new InputBinding(null, inputContext.asBinder(), uid, pid); + } + } + + final HashMap<IBinder, ClientState> mClients + = new HashMap<IBinder, ClientState>(); + + /** + * Id of the currently selected input method. + */ + String mCurMethodId; + + /** + * The current binding sequence number, incremented every time there is + * a new bind performed. + */ + int mCurSeq; + + /** + * The client that is currently bound to an input method. + */ + ClientState mCurClient; + + /** + * The input context last provided by the current client. + */ + IInputContext mCurInputContext; + + /** + * The attributes last provided by the current client. + */ + EditorInfo mCurAttribute; + + /** + * The input method ID of the input method service that we are currently + * connected to or in the process of connecting to. + */ + String mCurId; + + /** + * Set to true if our ServiceConnection is currently actively bound to + * a service (whether or not we have gotten its IBinder back yet). + */ + boolean mHaveConnection; + + /** + * Set if the client has asked for the input method to be shown. + */ + boolean mShowRequested; + + /** + * Set if we were explicitly told to show the input method. + */ + boolean mShowExplicitlyRequested; + + /** + * Set if we were forced to be shown. + */ + boolean mShowForced; + + /** + * Set if we last told the input method to show itself. + */ + boolean mInputShown; + + /** + * The Intent used to connect to the current input method. + */ + Intent mCurIntent; + + /** + * The token we have made for the currently active input method, to + * identify it in the future. + */ + IBinder mCurToken; + + /** + * If non-null, this is the input method service we are currently connected + * to. + */ + IInputMethod mCurMethod; + + /** + * Time that we last initiated a bind to the input method, to determine + * if we should try to disconnect and reconnect to it. + */ + long mLastBindTime; + + /** + * Have we called mCurMethod.bindInput()? + */ + boolean mBoundToMethod; + + /** + * Currently enabled session. Only touched by service thread, not + * protected by a lock. + */ + SessionState mEnabledSession; + + /** + * True if the screen is on. The value is true initially. + */ + boolean mScreenOn = true; + + AlertDialog.Builder mDialogBuilder; + AlertDialog mSwitchingDialog; + InputMethodInfo[] mIms; + CharSequence[] mItems; + + class SettingsObserver extends ContentObserver { + SettingsObserver(Handler handler) { + super(handler); + ContentResolver resolver = mContext.getContentResolver(); + resolver.registerContentObserver(Settings.Secure.getUriFor( + Settings.Secure.DEFAULT_INPUT_METHOD), false, this); + } + + @Override public void onChange(boolean selfChange) { + synchronized (mMethodMap) { + updateFromSettingsLocked(); + } + } + } + + class ScreenOnOffReceiver extends android.content.BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) { + mScreenOn = true; + } else if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) { + mScreenOn = false; + } else { + Log.w(TAG, "Unexpected intent " + intent); + } + + // Inform the current client of the change in active status + try { + if (mCurClient != null && mCurClient.client != null) { + mCurClient.client.setActive(mScreenOn); + } + } catch (RemoteException e) { + Log.w(TAG, "Got RemoteException sending 'screen on/off' notification to pid " + + mCurClient.pid + " uid " + mCurClient.uid); + } + } + } + + class PackageReceiver extends android.content.BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + synchronized (mMethodMap) { + buildInputMethodListLocked(mMethodList, mMethodMap); + + InputMethodInfo curIm = null; + String curInputMethodId = Settings.Secure.getString(context + .getContentResolver(), Settings.Secure.DEFAULT_INPUT_METHOD); + final int N = mMethodList.size(); + if (curInputMethodId != null) { + for (int i=0; i<N; i++) { + if (mMethodList.get(i).getId().equals(curInputMethodId)) { + curIm = mMethodList.get(i); + } + } + } + + boolean changed = false; + + Uri uri = intent.getData(); + String pkg = uri != null ? uri.getSchemeSpecificPart() : null; + if (curIm != null && curIm.getPackageName().equals(pkg)) { + ServiceInfo si = null; + try { + si = mContext.getPackageManager().getServiceInfo( + curIm.getComponent(), 0); + } catch (PackageManager.NameNotFoundException ex) { + } + if (si == null) { + // Uh oh, current input method is no longer around! + // Pick another one... + Log.i(TAG, "Current input method removed: " + curInputMethodId); + List<InputMethodInfo> enabled = getEnabledInputMethodListLocked(); + if (enabled != null && enabled.size() > 0) { + changed = true; + curIm = enabled.get(0); + curInputMethodId = curIm.getId(); + Log.i(TAG, "Switching to: " + curInputMethodId); + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD, + curInputMethodId); + } else if (curIm != null) { + changed = true; + curIm = null; + curInputMethodId = ""; + Log.i(TAG, "Unsetting current input method"); + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD, + curInputMethodId); + } + } + + } else if (curIm == null) { + // We currently don't have a default input method... is + // one now available? + List<InputMethodInfo> enabled = getEnabledInputMethodListLocked(); + if (enabled != null && enabled.size() > 0) { + changed = true; + curIm = enabled.get(0); + curInputMethodId = curIm.getId(); + Log.i(TAG, "New default input method: " + curInputMethodId); + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD, + curInputMethodId); + } + } + + if (changed) { + updateFromSettingsLocked(); + } + } + } + } + + class MethodCallback extends IInputMethodCallback.Stub { + final IInputMethod mMethod; + + MethodCallback(IInputMethod method) { + mMethod = method; + } + + public void finishedEvent(int seq, boolean handled) throws RemoteException { + } + + public void sessionCreated(IInputMethodSession session) throws RemoteException { + onSessionCreated(mMethod, session); + } + } + + public InputMethodManagerService(Context context, StatusBarService statusBar) { + mContext = context; + mHandler = new Handler(this); + mIWindowManager = IWindowManager.Stub.asInterface( + ServiceManager.getService(Context.WINDOW_SERVICE)); + mCaller = new HandlerCaller(context, new HandlerCaller.Callback() { + public void executeMessage(Message msg) { + handleMessage(msg); + } + }); + + IntentFilter packageFilt = new IntentFilter(); + packageFilt.addAction(Intent.ACTION_PACKAGE_ADDED); + packageFilt.addAction(Intent.ACTION_PACKAGE_CHANGED); + packageFilt.addAction(Intent.ACTION_PACKAGE_REMOVED); + packageFilt.addAction(Intent.ACTION_PACKAGE_RESTARTED); + packageFilt.addDataScheme("package"); + mContext.registerReceiver(new PackageReceiver(), packageFilt); + + IntentFilter screenOnOffFilt = new IntentFilter(); + screenOnOffFilt.addAction(Intent.ACTION_SCREEN_ON); + screenOnOffFilt.addAction(Intent.ACTION_SCREEN_OFF); + mContext.registerReceiver(new ScreenOnOffReceiver(), screenOnOffFilt); + + buildInputMethodListLocked(mMethodList, mMethodMap); + + final String enabledStr = Settings.Secure.getString( + mContext.getContentResolver(), + Settings.Secure.ENABLED_INPUT_METHODS); + Log.i(TAG, "Enabled input methods: " + enabledStr); + if (enabledStr == null) { + Log.i(TAG, "Enabled input methods has not been set, enabling all"); + InputMethodInfo defIm = null; + StringBuilder sb = new StringBuilder(256); + final int N = mMethodList.size(); + for (int i=0; i<N; i++) { + InputMethodInfo imi = mMethodList.get(i); + Log.i(TAG, "Adding: " + imi.getId()); + if (i > 0) sb.append(':'); + sb.append(imi.getId()); + if (defIm == null && imi.getIsDefaultResourceId() != 0) { + try { + Resources res = mContext.createPackageContext( + imi.getPackageName(), 0).getResources(); + if (res.getBoolean(imi.getIsDefaultResourceId())) { + defIm = imi; + Log.i(TAG, "Selected default: " + imi.getId()); + } + } catch (PackageManager.NameNotFoundException ex) { + } catch (Resources.NotFoundException ex) { + } + } + } + if (defIm == null && N > 0) { + defIm = mMethodList.get(0); + Log.i(TAG, "No default found, using " + defIm.getId()); + } + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ENABLED_INPUT_METHODS, sb.toString()); + if (defIm != null) { + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD, defIm.getId()); + } + } + + mStatusBar = statusBar; + mInputMethodData = IconData.makeIcon("ime", null, 0, 0, 0); + mInputMethodIcon = statusBar.addIcon(mInputMethodData, null); + statusBar.setIconVisibility(mInputMethodIcon, false); + + mSettingsObserver = new SettingsObserver(mHandler); + updateFromSettingsLocked(); + } + + @Override + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) + throws RemoteException { + try { + return super.onTransact(code, data, reply, flags); + } catch (RuntimeException e) { + // The input method manager only throws security exceptions, so let's + // log all others. + if (!(e instanceof SecurityException)) { + Log.e(TAG, "Input Method Manager Crash", e); + } + throw e; + } + } + + public void systemReady() { + } + + public List<InputMethodInfo> getInputMethodList() { + synchronized (mMethodMap) { + return new ArrayList<InputMethodInfo>(mMethodList); + } + } + + public List<InputMethodInfo> getEnabledInputMethodList() { + synchronized (mMethodMap) { + return getEnabledInputMethodListLocked(); + } + } + + List<InputMethodInfo> getEnabledInputMethodListLocked() { + final ArrayList<InputMethodInfo> res = new ArrayList<InputMethodInfo>(); + + final String enabledStr = Settings.Secure.getString( + mContext.getContentResolver(), + Settings.Secure.ENABLED_INPUT_METHODS); + if (enabledStr != null) { + final TextUtils.SimpleStringSplitter splitter = mStringColonSplitter; + splitter.setString(enabledStr); + + while (splitter.hasNext()) { + InputMethodInfo info = mMethodMap.get(splitter.next()); + if (info != null) { + res.add(info); + } + } + } + + return res; + } + + public void addClient(IInputMethodClient client, + IInputContext inputContext, int uid, int pid) { + synchronized (mMethodMap) { + mClients.put(client.asBinder(), new ClientState(client, + inputContext, uid, pid)); + } + } + + public void removeClient(IInputMethodClient client) { + synchronized (mMethodMap) { + mClients.remove(client.asBinder()); + } + } + + void executeOrSendMessage(IInterface target, Message msg) { + if (target.asBinder() instanceof Binder) { + mCaller.sendMessage(msg); + } else { + handleMessage(msg); + msg.recycle(); + } + } + + void unbindCurrentInputLocked() { + if (mCurClient != null) { + if (DEBUG) Log.v(TAG, "unbindCurrentInputLocked: client = " + + mCurClient.client.asBinder()); + if (mBoundToMethod) { + mBoundToMethod = false; + if (mCurMethod != null) { + executeOrSendMessage(mCurMethod, mCaller.obtainMessageO( + MSG_UNBIND_INPUT, mCurMethod)); + } + } + executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO( + MSG_UNBIND_METHOD, mCurSeq, mCurClient.client)); + mCurClient.sessionRequested = false; + + // Call setActive(false) on the old client + try { + mCurClient.client.setActive(false); + } catch (RemoteException e) { + Log.w(TAG, "Got RemoteException sending setActive(false) notification to pid " + + mCurClient.pid + " uid " + mCurClient.uid); + } + mCurClient = null; + } + } + + private int getImeShowFlags() { + int flags = 0; + if (mShowForced) { + flags |= InputMethod.SHOW_FORCED + | InputMethod.SHOW_EXPLICIT; + } else if (mShowExplicitlyRequested) { + flags |= InputMethod.SHOW_EXPLICIT; + } + return flags; + } + + private int getAppShowFlags() { + int flags = 0; + if (mShowForced) { + flags |= InputMethodManager.SHOW_FORCED; + } else if (!mShowExplicitlyRequested) { + flags |= InputMethodManager.SHOW_IMPLICIT; + } + return flags; + } + + InputBindResult attachNewInputLocked(boolean initial, boolean needResult) { + if (!mBoundToMethod) { + executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO( + MSG_BIND_INPUT, mCurMethod, mCurClient.binding)); + mBoundToMethod = true; + } + final SessionState session = mCurClient.curSession; + if (initial) { + executeOrSendMessage(session.method, mCaller.obtainMessageOOO( + MSG_START_INPUT, session, mCurInputContext, mCurAttribute)); + } else { + executeOrSendMessage(session.method, mCaller.obtainMessageOOO( + MSG_RESTART_INPUT, session, mCurInputContext, mCurAttribute)); + } + if (mShowRequested) { + if (DEBUG) Log.v(TAG, "Attach new input asks to show input"); + showCurrentInputLocked(getAppShowFlags()); + } + return needResult + ? new InputBindResult(session.session, mCurId, mCurSeq) + : null; + } + + InputBindResult startInputLocked(IInputMethodClient client, + IInputContext inputContext, EditorInfo attribute, + boolean initial, boolean needResult) { + // If no method is currently selected, do nothing. + if (mCurMethodId == null) { + return mNoBinding; + } + + ClientState cs = mClients.get(client.asBinder()); + if (cs == null) { + throw new IllegalArgumentException("unknown client " + + client.asBinder()); + } + + try { + if (!mIWindowManager.inputMethodClientHasFocus(cs.client)) { + // Check with the window manager to make sure this client actually + // has a window with focus. If not, reject. This is thread safe + // because if the focus changes some time before or after, the + // next client receiving focus that has any interest in input will + // be calling through here after that change happens. + Log.w(TAG, "Starting input on non-focused client " + cs.client + + " (uid=" + cs.uid + " pid=" + cs.pid + ")"); + return null; + } + } catch (RemoteException e) { + } + + if (mCurClient != cs) { + // If the client is changing, we need to switch over to the new + // one. + unbindCurrentInputLocked(); + if (DEBUG) Log.v(TAG, "switching to client: client = " + + cs.client.asBinder()); + + // If the screen is on, inform the new client it is active + if (mScreenOn) { + try { + cs.client.setActive(mScreenOn); + } catch (RemoteException e) { + Log.w(TAG, "Got RemoteException sending setActive notification to pid " + + cs.pid + " uid " + cs.uid); + } + } + } + + // Bump up the sequence for this client and attach it. + mCurSeq++; + if (mCurSeq <= 0) mCurSeq = 1; + mCurClient = cs; + mCurInputContext = inputContext; + mCurAttribute = attribute; + + // Check if the input method is changing. + if (mCurId != null && mCurId.equals(mCurMethodId)) { + if (cs.curSession != null) { + // Fast case: if we are already connected to the input method, + // then just return it. + return attachNewInputLocked(initial, needResult); + } + if (mHaveConnection) { + if (mCurMethod != null) { + if (!cs.sessionRequested) { + cs.sessionRequested = true; + if (DEBUG) Log.v(TAG, "Creating new session for client " + cs); + executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO( + MSG_CREATE_SESSION, mCurMethod, + new MethodCallback(mCurMethod))); + } + // Return to client, and we will get back with it when + // we have had a session made for it. + return new InputBindResult(null, mCurId, mCurSeq); + } else if (SystemClock.uptimeMillis() + < (mLastBindTime+TIME_TO_RECONNECT)) { + // In this case we have connected to the service, but + // don't yet have its interface. If it hasn't been too + // long since we did the connection, we'll return to + // the client and wait to get the service interface so + // we can report back. If it has been too long, we want + // to fall through so we can try a disconnect/reconnect + // to see if we can get back in touch with the service. + return new InputBindResult(null, mCurId, mCurSeq); + } else { + EventLog.writeEvent(LOG_IMF_FORCE_RECONNECT_IME, mCurMethodId, + SystemClock.uptimeMillis()-mLastBindTime, 0); + } + } + } + + InputMethodInfo info = mMethodMap.get(mCurMethodId); + if (info == null) { + throw new IllegalArgumentException("Unknown id: " + mCurMethodId); + } + + if (mHaveConnection) { + mContext.unbindService(this); + mHaveConnection = false; + } + + if (mCurToken != null) { + try { + if (DEBUG) Log.v(TAG, "Removing window token: " + mCurToken); + mIWindowManager.removeWindowToken(mCurToken); + } catch (RemoteException e) { + } + mCurToken = null; + } + + clearCurMethod(); + + mCurIntent = new Intent(InputMethod.SERVICE_INTERFACE); + mCurIntent.setComponent(info.getComponent()); + if (mContext.bindService(mCurIntent, this, Context.BIND_AUTO_CREATE)) { + mLastBindTime = SystemClock.uptimeMillis(); + mHaveConnection = true; + mCurId = info.getId(); + mCurToken = new Binder(); + try { + if (DEBUG) Log.v(TAG, "Adding window token: " + mCurToken); + mIWindowManager.addWindowToken(mCurToken, + WindowManager.LayoutParams.TYPE_INPUT_METHOD); + } catch (RemoteException e) { + } + return new InputBindResult(null, mCurId, mCurSeq); + } else { + mCurIntent = null; + Log.w(TAG, "Failure connecting to input method service: " + + mCurIntent); + } + return null; + } + + public InputBindResult startInput(IInputMethodClient client, + IInputContext inputContext, EditorInfo attribute, + boolean initial, boolean needResult) { + synchronized (mMethodMap) { + final long ident = Binder.clearCallingIdentity(); + try { + return startInputLocked(client, inputContext, attribute, + initial, needResult); + } finally { + Binder.restoreCallingIdentity(ident); + } + } + } + + public void finishInput(IInputMethodClient client) { + } + + public void onServiceConnected(ComponentName name, IBinder service) { + synchronized (mMethodMap) { + if (mCurIntent != null && name.equals(mCurIntent.getComponent())) { + mCurMethod = IInputMethod.Stub.asInterface(service); + if (mCurClient != null) { + if (DEBUG) Log.v(TAG, "Initiating attach with token: " + mCurToken); + executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO( + MSG_ATTACH_TOKEN, mCurMethod, mCurToken)); + if (mCurClient != null) { + if (DEBUG) Log.v(TAG, "Creating first session while with client " + + mCurClient); + executeOrSendMessage(mCurMethod, mCaller.obtainMessageOO( + MSG_CREATE_SESSION, mCurMethod, + new MethodCallback(mCurMethod))); + } + } + } + } + } + + void onSessionCreated(IInputMethod method, IInputMethodSession session) { + synchronized (mMethodMap) { + if (mCurMethod != null && method != null + && mCurMethod.asBinder() == method.asBinder()) { + if (mCurClient != null) { + mCurClient.curSession = new SessionState(mCurClient, + method, session); + mCurClient.sessionRequested = false; + InputBindResult res = attachNewInputLocked(true, true); + if (res.method != null) { + executeOrSendMessage(mCurClient.client, mCaller.obtainMessageOO( + MSG_BIND_METHOD, mCurClient.client, res)); + } + } + } + } + } + + void clearCurMethod() { + if (mCurMethod != null) { + for (ClientState cs : mClients.values()) { + cs.sessionRequested = false; + cs.curSession = null; + } + mCurMethod = null; + } + mStatusBar.setIconVisibility(mInputMethodIcon, false); + } + + public void onServiceDisconnected(ComponentName name) { + synchronized (mMethodMap) { + if (DEBUG) Log.v(TAG, "Service disconnected: " + name + + " mCurIntent=" + mCurIntent); + if (mCurMethod != null && mCurIntent != null + && name.equals(mCurIntent.getComponent())) { + clearCurMethod(); + // We consider this to be a new bind attempt, since the system + // should now try to restart the service for us. + mLastBindTime = SystemClock.uptimeMillis(); + mShowRequested = mInputShown; + mInputShown = false; + if (mCurClient != null) { + executeOrSendMessage(mCurClient.client, mCaller.obtainMessageIO( + MSG_UNBIND_METHOD, mCurSeq, mCurClient.client)); + } + } + } + } + + public void updateStatusIcon(IBinder token, String packageName, int iconId) { + long ident = Binder.clearCallingIdentity(); + try { + if (token == null || mCurToken != token) { + Log.w(TAG, "Ignoring setInputMethod of token: " + token); + return; + } + + synchronized (mMethodMap) { + if (iconId == 0) { + if (DEBUG) Log.d(TAG, "hide the small icon for the input method"); + mStatusBar.setIconVisibility(mInputMethodIcon, false); + } else if (packageName != null) { + if (DEBUG) Log.d(TAG, "show a small icon for the input method"); + mInputMethodData.iconId = iconId; + mInputMethodData.iconPackage = packageName; + mStatusBar.updateIcon(mInputMethodIcon, mInputMethodData, null); + mStatusBar.setIconVisibility(mInputMethodIcon, true); + } + } + } finally { + Binder.restoreCallingIdentity(ident); + } + } + + void updateFromSettingsLocked() { + String id = Settings.Secure.getString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD); + if (id != null) { + try { + setInputMethodLocked(id); + } catch (IllegalArgumentException e) { + Log.w(TAG, "Unknown input method from prefs: " + id, e); + } + } + } + + void setInputMethodLocked(String id) { + InputMethodInfo info = mMethodMap.get(id); + if (info == null) { + throw new IllegalArgumentException("Unknown id: " + mCurMethodId); + } + + if (id.equals(mCurMethodId)) { + return; + } + + final long ident = Binder.clearCallingIdentity(); + try { + mCurMethodId = id; + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD, id); + + if (ActivityManagerNative.isSystemReady()) { + Intent intent = new Intent(Intent.ACTION_INPUT_METHOD_CHANGED); + intent.putExtra("input_method_id", id); + mContext.sendBroadcast(intent); + } + unbindCurrentInputLocked(); + } finally { + Binder.restoreCallingIdentity(ident); + } + } + + public void showSoftInput(IInputMethodClient client, int flags) { + long ident = Binder.clearCallingIdentity(); + try { + synchronized (mMethodMap) { + if (mCurClient == null || client == null + || mCurClient.client.asBinder() != client.asBinder()) { + try { + // We need to check if this is the current client with + // focus in the window manager, to allow this call to + // be made before input is started in it. + if (!mIWindowManager.inputMethodClientHasFocus(client)) { + Log.w(TAG, "Ignoring showSoftInput of: " + client); + return; + } + } catch (RemoteException e) { + } + } + + if (DEBUG) Log.v(TAG, "Client requesting input be shown"); + showCurrentInputLocked(flags); + } + } finally { + Binder.restoreCallingIdentity(ident); + } + } + + void showCurrentInputLocked(int flags) { + mShowRequested = true; + if ((flags&InputMethodManager.SHOW_IMPLICIT) == 0) { + mShowExplicitlyRequested = true; + } + if ((flags&InputMethodManager.SHOW_FORCED) != 0) { + mShowExplicitlyRequested = true; + mShowForced = true; + } + if (mCurMethod != null) { + executeOrSendMessage(mCurMethod, mCaller.obtainMessageIO( + MSG_SHOW_SOFT_INPUT, getImeShowFlags(), mCurMethod)); + mInputShown = true; + } else if (mHaveConnection && SystemClock.uptimeMillis() + < (mLastBindTime+TIME_TO_RECONNECT)) { + // The client has asked to have the input method shown, but + // we have been sitting here too long with a connection to the + // service and no interface received, so let's disconnect/connect + // to try to prod things along. + EventLog.writeEvent(LOG_IMF_FORCE_RECONNECT_IME, mCurMethodId, + SystemClock.uptimeMillis()-mLastBindTime,1); + mContext.unbindService(this); + mContext.bindService(mCurIntent, this, Context.BIND_AUTO_CREATE); + } + } + + public void hideSoftInput(IInputMethodClient client, int flags) { + long ident = Binder.clearCallingIdentity(); + try { + synchronized (mMethodMap) { + if (mCurClient == null || client == null + || mCurClient.client.asBinder() != client.asBinder()) { + try { + // We need to check if this is the current client with + // focus in the window manager, to allow this call to + // be made before input is started in it. + if (!mIWindowManager.inputMethodClientHasFocus(client)) { + Log.w(TAG, "Ignoring hideSoftInput of: " + client); + return; + } + } catch (RemoteException e) { + } + } + + if (DEBUG) Log.v(TAG, "Client requesting input be hidden"); + hideCurrentInputLocked(flags); + } + } finally { + Binder.restoreCallingIdentity(ident); + } + } + + void hideCurrentInputLocked(int flags) { + if ((flags&InputMethodManager.HIDE_IMPLICIT_ONLY) != 0 + && (mShowExplicitlyRequested || mShowForced)) { + if (DEBUG) Log.v(TAG, + "Not hiding: explicit show not cancelled by non-explicit hide"); + return; + } + if (mShowForced && (flags&InputMethodManager.HIDE_NOT_ALWAYS) != 0) { + if (DEBUG) Log.v(TAG, + "Not hiding: forced show not cancelled by not-always hide"); + return; + } + if (mInputShown && mCurMethod != null) { + executeOrSendMessage(mCurMethod, mCaller.obtainMessageO( + MSG_HIDE_SOFT_INPUT, mCurMethod)); + } + mInputShown = false; + mShowRequested = false; + mShowExplicitlyRequested = false; + mShowForced = false; + } + + public void windowGainedFocus(IInputMethodClient client, + boolean viewHasFocus, boolean isTextEditor, int softInputMode, + boolean first, int windowFlags) { + long ident = Binder.clearCallingIdentity(); + try { + synchronized (mMethodMap) { + if (DEBUG) Log.v(TAG, "windowGainedFocus: " + client.asBinder() + + " viewHasFocus=" + viewHasFocus + + " isTextEditor=" + isTextEditor + + " softInputMode=#" + Integer.toHexString(softInputMode) + + " first=" + first + " flags=#" + + Integer.toHexString(windowFlags)); + + if (mCurClient == null || client == null + || mCurClient.client.asBinder() != client.asBinder()) { + try { + // We need to check if this is the current client with + // focus in the window manager, to allow this call to + // be made before input is started in it. + if (!mIWindowManager.inputMethodClientHasFocus(client)) { + Log.w(TAG, "Ignoring focus gain of: " + client); + return; + } + } catch (RemoteException e) { + } + } + + switch (softInputMode&WindowManager.LayoutParams.SOFT_INPUT_MASK_STATE) { + case WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED: + if (!isTextEditor || (softInputMode & + WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) + != WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE) { + if (WindowManager.LayoutParams.mayUseInputMethod(windowFlags)) { + // There is no focus view, and this window will + // be behind any soft input window, so hide the + // soft input window if it is shown. + if (DEBUG) Log.v(TAG, "Unspecified window will hide input"); + hideCurrentInputLocked(InputMethodManager.HIDE_NOT_ALWAYS); + } + } else if (isTextEditor && (softInputMode & + WindowManager.LayoutParams.SOFT_INPUT_MASK_ADJUST) + == WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE + && (softInputMode & + WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) { + // There is a focus view, and we are navigating forward + // into the window, so show the input window for the user. + if (DEBUG) Log.v(TAG, "Unspecified window will show input"); + showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT); + } + break; + case WindowManager.LayoutParams.SOFT_INPUT_STATE_UNCHANGED: + // Do nothing. + break; + case WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN: + if ((softInputMode & + WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) { + if (DEBUG) Log.v(TAG, "Window asks to hide input going forward"); + hideCurrentInputLocked(0); + } + break; + case WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN: + if (DEBUG) Log.v(TAG, "Window asks to hide input"); + hideCurrentInputLocked(0); + break; + case WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE: + if ((softInputMode & + WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION) != 0) { + if (DEBUG) Log.v(TAG, "Window asks to show input going forward"); + showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT); + } + break; + case WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE: + if (DEBUG) Log.v(TAG, "Window asks to always show input"); + showCurrentInputLocked(InputMethodManager.SHOW_IMPLICIT); + break; + } + } + } finally { + Binder.restoreCallingIdentity(ident); + } + } + + public void showInputMethodPickerFromClient(IInputMethodClient client) { + synchronized (mMethodMap) { + if (mCurClient == null || client == null + || mCurClient.client.asBinder() != client.asBinder()) { + Log.w(TAG, "Ignoring showInputMethodDialogFromClient of: " + client); + } + + mHandler.sendEmptyMessage(MSG_SHOW_IM_PICKER); + } + } + + public void setInputMethod(IBinder token, String id) { + synchronized (mMethodMap) { + if (token == null) { + if (mContext.checkCallingOrSelfPermission( + android.Manifest.permission.WRITE_SECURE_SETTINGS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException( + "Using null token requires permission " + + android.Manifest.permission.WRITE_SECURE_SETTINGS); + } + } else if (mCurToken != token) { + Log.w(TAG, "Ignoring setInputMethod of token: " + token); + return; + } + + long ident = Binder.clearCallingIdentity(); + try { + setInputMethodLocked(id); + } finally { + Binder.restoreCallingIdentity(ident); + } + } + } + + public void hideMySoftInput(IBinder token, int flags) { + synchronized (mMethodMap) { + if (token == null || mCurToken != token) { + Log.w(TAG, "Ignoring hideInputMethod of token: " + token); + return; + } + + long ident = Binder.clearCallingIdentity(); + try { + hideCurrentInputLocked(flags); + } finally { + Binder.restoreCallingIdentity(ident); + } + } + } + + void setEnabledSessionInMainThread(SessionState session) { + if (mEnabledSession != session) { + if (mEnabledSession != null) { + try { + if (DEBUG) Log.v(TAG, "Disabling: " + mEnabledSession); + mEnabledSession.method.setSessionEnabled( + mEnabledSession.session, false); + } catch (RemoteException e) { + } + } + mEnabledSession = session; + try { + if (DEBUG) Log.v(TAG, "Enabling: " + mEnabledSession); + session.method.setSessionEnabled( + session.session, true); + } catch (RemoteException e) { + } + } + } + + public boolean handleMessage(Message msg) { + HandlerCaller.SomeArgs args; + switch (msg.what) { + case MSG_SHOW_IM_PICKER: + showInputMethodMenu(); + return true; + + // --------------------------------------------------------- + + case MSG_UNBIND_INPUT: + try { + ((IInputMethod)msg.obj).unbindInput(); + } catch (RemoteException e) { + // There is nothing interesting about the method dying. + } + return true; + case MSG_BIND_INPUT: + args = (HandlerCaller.SomeArgs)msg.obj; + try { + ((IInputMethod)args.arg1).bindInput((InputBinding)args.arg2); + } catch (RemoteException e) { + } + return true; + case MSG_SHOW_SOFT_INPUT: + try { + ((IInputMethod)msg.obj).showSoftInput(msg.arg1); + } catch (RemoteException e) { + } + return true; + case MSG_HIDE_SOFT_INPUT: + try { + ((IInputMethod)msg.obj).hideSoftInput(); + } catch (RemoteException e) { + } + return true; + case MSG_ATTACH_TOKEN: + args = (HandlerCaller.SomeArgs)msg.obj; + try { + if (DEBUG) Log.v(TAG, "Sending attach of token: " + args.arg2); + ((IInputMethod)args.arg1).attachToken((IBinder)args.arg2); + } catch (RemoteException e) { + } + return true; + case MSG_CREATE_SESSION: + args = (HandlerCaller.SomeArgs)msg.obj; + try { + ((IInputMethod)args.arg1).createSession( + (IInputMethodCallback)args.arg2); + } catch (RemoteException e) { + } + return true; + + // --------------------------------------------------------- + + case MSG_START_INPUT: + args = (HandlerCaller.SomeArgs)msg.obj; + try { + SessionState session = (SessionState)args.arg1; + setEnabledSessionInMainThread(session); + session.method.startInput((IInputContext)args.arg2, + (EditorInfo)args.arg3); + } catch (RemoteException e) { + } + return true; + case MSG_RESTART_INPUT: + args = (HandlerCaller.SomeArgs)msg.obj; + try { + SessionState session = (SessionState)args.arg1; + setEnabledSessionInMainThread(session); + session.method.restartInput((IInputContext)args.arg2, + (EditorInfo)args.arg3); + } catch (RemoteException e) { + } + return true; + + // --------------------------------------------------------- + + case MSG_UNBIND_METHOD: + try { + ((IInputMethodClient)msg.obj).onUnbindMethod(msg.arg1); + } catch (RemoteException e) { + // There is nothing interesting about the last client dying. + } + return true; + case MSG_BIND_METHOD: + args = (HandlerCaller.SomeArgs)msg.obj; + try { + ((IInputMethodClient)args.arg1).onBindMethod( + (InputBindResult)args.arg2); + } catch (RemoteException e) { + Log.w(TAG, "Client died receiving input method " + args.arg2); + } + return true; + } + return false; + } + + void buildInputMethodListLocked(ArrayList<InputMethodInfo> list, + HashMap<String, InputMethodInfo> map) { + list.clear(); + map.clear(); + + PackageManager pm = mContext.getPackageManager(); + + List<ResolveInfo> services = pm.queryIntentServices( + new Intent(InputMethod.SERVICE_INTERFACE), + PackageManager.GET_META_DATA); + + for (int i = 0; i < services.size(); ++i) { + ResolveInfo ri = services.get(i); + ServiceInfo si = ri.serviceInfo; + ComponentName compName = new ComponentName(si.packageName, si.name); + if (!android.Manifest.permission.BIND_INPUT_METHOD.equals( + si.permission)) { + Log.w(TAG, "Skipping input method " + compName + + ": it does not require the permission " + + android.Manifest.permission.BIND_INPUT_METHOD); + continue; + } + + if (DEBUG) Log.d(TAG, "Checking " + compName); + + try { + InputMethodInfo p = new InputMethodInfo(mContext, ri); + list.add(p); + map.put(p.getId(), p); + + if (DEBUG) { + Log.d(TAG, "Found a third-party input method " + p); + } + + } catch (XmlPullParserException e) { + Log.w(TAG, "Unable to load input method " + compName, e); + } catch (IOException e) { + Log.w(TAG, "Unable to load input method " + compName, e); + } + } + } + + // ---------------------------------------------------------------------- + + void showInputMethodMenu() { + if (DEBUG) Log.v(TAG, "Show switching menu"); + + hideInputMethodMenu(); + + final Context context = mContext; + + final PackageManager pm = context.getPackageManager(); + + String lastInputMethodId = Settings.Secure.getString(context + .getContentResolver(), Settings.Secure.DEFAULT_INPUT_METHOD); + if (DEBUG) Log.v(TAG, "Current IME: " + lastInputMethodId); + + final List<InputMethodInfo> immis = getEnabledInputMethodList(); + + int N = (immis == null ? 0 : immis.size()); + + mItems = new CharSequence[N]; + mIms = new InputMethodInfo[N]; + + for (int i = 0; i < N; ++i) { + InputMethodInfo property = immis.get(i); + mItems[i] = property.loadLabel(pm); + mIms[i] = property; + } + + int checkedItem = 0; + for (int i = 0; i < N; ++i) { + if (mIms[i].getId().equals(lastInputMethodId)) { + checkedItem = i; + break; + } + } + + AlertDialog.OnClickListener adocl = new AlertDialog.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + hideInputMethodMenu(); + } + }; + + TypedArray a = context.obtainStyledAttributes(null, + com.android.internal.R.styleable.DialogPreference, + com.android.internal.R.attr.alertDialogStyle, 0); + mDialogBuilder = new AlertDialog.Builder(context) + .setTitle(com.android.internal.R.string.select_input_method) + .setOnCancelListener(new OnCancelListener() { + public void onCancel(DialogInterface dialog) { + hideInputMethodMenu(); + } + }) + .setIcon(a.getDrawable( + com.android.internal.R.styleable.DialogPreference_dialogTitle)); + a.recycle(); + + mDialogBuilder.setSingleChoiceItems(mItems, checkedItem, + new AlertDialog.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + synchronized (mMethodMap) { + InputMethodInfo im = mIms[which]; + hideInputMethodMenu(); + setInputMethodLocked(im.getId()); + } + } + }); + + synchronized (mMethodMap) { + mSwitchingDialog = mDialogBuilder.create(); + mSwitchingDialog.getWindow().setType( + WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG); + mSwitchingDialog.show(); + } + } + + void hideInputMethodMenu() { + if (DEBUG) Log.v(TAG, "Hide switching menu"); + + synchronized (mMethodMap) { + if (mSwitchingDialog != null) { + mSwitchingDialog.dismiss(); + mSwitchingDialog = null; + } + + mDialogBuilder = null; + mItems = null; + mIms = null; + } + } + + // ---------------------------------------------------------------------- + + public boolean setInputMethodEnabled(String id, boolean enabled) { + synchronized (mMethodMap) { + if (mContext.checkCallingOrSelfPermission( + android.Manifest.permission.WRITE_SECURE_SETTINGS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException( + "Requires permission " + + android.Manifest.permission.WRITE_SECURE_SETTINGS); + } + + long ident = Binder.clearCallingIdentity(); + try { + // Make sure this is a valid input method. + InputMethodInfo imm = mMethodMap.get(id); + if (imm == null) { + if (imm == null) { + throw new IllegalArgumentException("Unknown id: " + mCurMethodId); + } + } + + StringBuilder builder = new StringBuilder(256); + + boolean removed = false; + String firstId = null; + + // Look through the currently enabled input methods. + String enabledStr = Settings.Secure.getString(mContext.getContentResolver(), + Settings.Secure.ENABLED_INPUT_METHODS); + if (enabledStr != null) { + final TextUtils.SimpleStringSplitter splitter = mStringColonSplitter; + splitter.setString(enabledStr); + while (splitter.hasNext()) { + String curId = splitter.next(); + if (curId.equals(id)) { + if (enabled) { + // We are enabling this input method, but it is + // already enabled. Nothing to do. The previous + // state was enabled. + return true; + } + // We are disabling this input method, and it is + // currently enabled. Skip it to remove from the + // new list. + removed = true; + } else if (!enabled) { + // We are building a new list of input methods that + // doesn't contain the given one. + if (firstId == null) firstId = curId; + if (builder.length() > 0) builder.append(':'); + builder.append(curId); + } + } + } + + if (!enabled) { + if (!removed) { + // We are disabling the input method but it is already + // disabled. Nothing to do. The previous state was + // disabled. + return false; + } + // Update the setting with the new list of input methods. + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ENABLED_INPUT_METHODS, builder.toString()); + // We the disabled input method is currently selected, switch + // to another one. + String selId = Settings.Secure.getString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD); + if (id.equals(selId)) { + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.DEFAULT_INPUT_METHOD, + firstId != null ? firstId : ""); + } + // Previous state was enabled. + return true; + } + + // Add in the newly enabled input method. + if (enabledStr == null || enabledStr.length() == 0) { + enabledStr = id; + } else { + enabledStr = enabledStr + ':' + id; + } + + Settings.Secure.putString(mContext.getContentResolver(), + Settings.Secure.ENABLED_INPUT_METHODS, enabledStr); + + // Previous state was disabled. + return false; + } finally { + Binder.restoreCallingIdentity(ident); + } + } + } + + // ---------------------------------------------------------------------- + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + + pw.println("Permission Denial: can't dump InputMethodManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + IInputMethod method; + ClientState client; + + final Printer p = new PrintWriterPrinter(pw); + + synchronized (mMethodMap) { + p.println("Current Input Method Manager state:"); + int N = mMethodList.size(); + p.println(" Input Methods:"); + for (int i=0; i<N; i++) { + InputMethodInfo info = mMethodList.get(i); + p.println(" InputMethod #" + i + ":"); + info.dump(p, " "); + } + p.println(" Clients:"); + for (ClientState ci : mClients.values()) { + p.println(" Client " + ci + ":"); + p.println(" client=" + ci.client); + p.println(" inputContext=" + ci.inputContext); + p.println(" sessionRequested=" + ci.sessionRequested); + p.println(" curSession=" + ci.curSession); + } + p.println(" mInputMethodIcon=" + mInputMethodIcon); + p.println(" mInputMethodData=" + mInputMethodData); + p.println(" mCurrentMethod=" + mCurMethodId); + client = mCurClient; + p.println(" mCurSeq=" + mCurSeq + " mCurClient=" + client); + p.println(" mCurId=" + mCurId + " mHaveConnect=" + mHaveConnection + + " mBoundToMethod=" + mBoundToMethod); + p.println(" mCurToken=" + mCurToken); + p.println(" mCurIntent=" + mCurIntent); + method = mCurMethod; + p.println(" mCurMethod=" + mCurMethod); + p.println(" mEnabledSession=" + mEnabledSession); + p.println(" mShowRequested=" + mShowRequested + + " mShowExplicitlyRequested=" + mShowExplicitlyRequested + + " mShowForced=" + mShowForced + + " mInputShown=" + mInputShown); + p.println(" mScreenOn=" + mScreenOn); + } + + if (client != null) { + p.println(" "); + pw.flush(); + try { + client.client.asBinder().dump(fd, args); + } catch (RemoteException e) { + p.println("Input method client dead: " + e); + } + } + + if (method != null) { + p.println(" "); + pw.flush(); + try { + method.asBinder().dump(fd, args); + } catch (RemoteException e) { + p.println("Input method service dead: " + e); + } + } + } +} diff --git a/services/java/com/android/server/Installer.java b/services/java/com/android/server/Installer.java new file mode 100644 index 0000000..fe3ad15 --- /dev/null +++ b/services/java/com/android/server/Installer.java @@ -0,0 +1,276 @@ +/* + * 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.pm.PackageStats; +import android.net.LocalSocketAddress; +import android.net.LocalSocket; +import android.util.Config; +import android.util.Log; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.Socket; + + +class Installer { + private static final String TAG = "Installer"; + InputStream mIn; + OutputStream mOut; + LocalSocket mSocket; + + byte buf[] = new byte[1024]; + int buflen = 0; + + private boolean connect() { + if (mSocket != null) { + return true; + } + Log.i(TAG, "connecting..."); + try { + mSocket = new LocalSocket(); + + LocalSocketAddress address = new LocalSocketAddress( + "installd", LocalSocketAddress.Namespace.RESERVED); + + mSocket.connect(address); + + mIn = mSocket.getInputStream(); + mOut = mSocket.getOutputStream(); + } catch (IOException ex) { + disconnect(); + return false; + } + return true; + } + + private void disconnect() { + Log.i(TAG,"disconnecting..."); + try { + if (mSocket != null) mSocket.close(); + } catch (IOException ex) { } + try { + if (mIn != null) mIn.close(); + } catch (IOException ex) { } + try { + if (mOut != null) mOut.close(); + } catch (IOException ex) { } + mSocket = null; + mIn = null; + mOut = null; + } + + private boolean readBytes(byte buffer[], int len) { + int off = 0, count; + if (len < 0) return false; + while (off != len) { + try { + count = mIn.read(buffer, off, len - off); + if (count <= 0) { + Log.e(TAG, "read error " + count); + break; + } + off += count; + } catch (IOException ex) { + Log.e(TAG,"read exception"); + break; + } + } +// Log.i(TAG, "read "+len+" bytes"); + if (off == len) return true; + disconnect(); + return false; + } + + private boolean readReply() { + int len; + buflen = 0; + if (!readBytes(buf, 2)) return false; + len = (((int) buf[0]) & 0xff) | ((((int) buf[1]) & 0xff) << 8); + if ((len < 1) || (len > 1024)) { + Log.e(TAG,"invalid reply length ("+len+")"); + disconnect(); + return false; + } + if (!readBytes(buf, len)) return false; + buflen = len; + return true; + } + + private boolean writeCommand(String _cmd) { + byte[] cmd = _cmd.getBytes(); + int len = cmd.length; + if ((len < 1) || (len > 1024)) return false; + buf[0] = (byte) (len & 0xff); + buf[1] = (byte) ((len >> 8) & 0xff); + try { + mOut.write(buf, 0, 2); + mOut.write(cmd, 0, len); + } catch (IOException ex) { + Log.e(TAG,"write error"); + disconnect(); + return false; + } + return true; + } + + private synchronized String transaction(String cmd) { + if (!connect()) { + Log.e(TAG, "connection failed"); + return "-1"; + } + + if (!writeCommand(cmd)) { + /* If installd died and restarted in the background + * (unlikely but possible) we'll fail on the next + * write (this one). Try to reconnect and write + * the command one more time before giving up. + */ + Log.e(TAG, "write command failed? reconnect!"); + if (!connect() || !writeCommand(cmd)) { + return "-1"; + } + } +// Log.i(TAG,"send: '"+cmd+"'"); + if (readReply()) { + String s = new String(buf, 0, buflen); +// Log.i(TAG,"recv: '"+s+"'"); + return s; + } else { +// Log.i(TAG,"fail"); + return "-1"; + } + } + + private int execute(String cmd) { + String res = transaction(cmd); + try { + return Integer.parseInt(res); + } catch (NumberFormatException ex) { + return -1; + } + } + + public int install(String name, int uid, int gid) { + StringBuilder builder = new StringBuilder("install"); + builder.append(' '); + builder.append(name); + builder.append(' '); + builder.append(uid); + builder.append(' '); + builder.append(gid); + return execute(builder.toString()); + } + + public int dexopt(String apkPath, int uid, boolean isPublic) { + StringBuilder builder = new StringBuilder("dexopt"); + builder.append(' '); + builder.append(apkPath); + builder.append(' '); + builder.append(uid); + builder.append(isPublic ? " 1" : " 0"); + return execute(builder.toString()); + } + + public int movedex(String srcPath, String dstPath) { + StringBuilder builder = new StringBuilder("movedex"); + builder.append(' '); + builder.append(srcPath); + builder.append(' '); + builder.append(dstPath); + return execute(builder.toString()); + } + + public int rmdex(String codePath) { + StringBuilder builder = new StringBuilder("rmdex"); + builder.append(' '); + builder.append(codePath); + return execute(builder.toString()); + } + + public int remove(String name) { + StringBuilder builder = new StringBuilder("remove"); + builder.append(' '); + builder.append(name); + return execute(builder.toString()); + } + + public int deleteCacheFiles(String name) { + StringBuilder builder = new StringBuilder("rmcache"); + builder.append(' '); + builder.append(name); + return execute(builder.toString()); + } + + public int clearUserData(String name) { + StringBuilder builder = new StringBuilder("rmuserdata"); + builder.append(' '); + builder.append(name); + return execute(builder.toString()); + } + + public boolean ping() { + if (execute("ping") < 0) { + return false; + } else { + return true; + } + } + + public int freeCache(long freeStorageSize) { + StringBuilder builder = new StringBuilder("freecache"); + builder.append(' '); + builder.append(String.valueOf(freeStorageSize)); + return execute(builder.toString()); + } + + public int setForwardLockPerm(String packageName, int gid) { + StringBuilder builder = new StringBuilder("protect"); + builder.append(' '); + builder.append(packageName); + builder.append(' '); + builder.append(gid); + return execute(builder.toString()); + } + + public int getSizeInfo(String pkgName, String apkPath, + String fwdLockApkPath, PackageStats pStats) { + StringBuilder builder = new StringBuilder("getsize"); + builder.append(' '); + builder.append(pkgName); + builder.append(' '); + builder.append(apkPath); + builder.append(' '); + builder.append(fwdLockApkPath != null ? fwdLockApkPath : "!"); + + String s = transaction(builder.toString()); + String res[] = s.split(" "); + + if((res == null) || (res.length != 4)) { + return -1; + } + try { + pStats.codeSize = Long.parseLong(res[1]); + pStats.dataSize = Long.parseLong(res[2]); + pStats.cacheSize = Long.parseLong(res[3]); + return Integer.parseInt(res[0]); + } catch (NumberFormatException e) { + return -1; + } + } +} diff --git a/services/java/com/android/server/IntentResolver.java b/services/java/com/android/server/IntentResolver.java new file mode 100644 index 0000000..b534ef1 --- /dev/null +++ b/services/java/com/android/server/IntentResolver.java @@ -0,0 +1,533 @@ +/* + * Copyright (C) 2006 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 java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import android.util.Log; +import android.util.LogPrinter; +import android.util.Printer; + +import android.util.Config; +import android.content.ContentResolver; +import android.content.Intent; +import android.content.IntentFilter; + +/** + * {@hide} + */ +public class IntentResolver<F extends IntentFilter, R extends Object> { + final private static String TAG = "IntentResolver"; + final private static boolean DEBUG = false; + final private static boolean localLOGV = DEBUG || Config.LOGV; + + public void addFilter(F f) { + if (localLOGV) { + Log.v(TAG, "Adding filter: " + f); + f.dump(new LogPrinter(Log.VERBOSE, TAG), " "); + Log.v(TAG, " Building Lookup Maps:"); + } + + mFilters.add(f); + int numS = register_intent_filter(f, f.schemesIterator(), + mSchemeToFilter, " Scheme: "); + int numT = register_mime_types(f, " Type: "); + if (numS == 0 && numT == 0) { + register_intent_filter(f, f.actionsIterator(), + mActionToFilter, " Action: "); + } + if (numT != 0) { + register_intent_filter(f, f.actionsIterator(), + mTypedActionToFilter, " TypedAction: "); + } + } + + public void removeFilter(F f) { + removeFilterInternal(f); + mFilters.remove(f); + } + + void removeFilterInternal(F f) { + if (localLOGV) { + Log.v(TAG, "Removing filter: " + f); + f.dump(new LogPrinter(Log.VERBOSE, TAG), " "); + Log.v(TAG, " Cleaning Lookup Maps:"); + } + + int numS = unregister_intent_filter(f, f.schemesIterator(), + mSchemeToFilter, " Scheme: "); + int numT = unregister_mime_types(f, " Type: "); + if (numS == 0 && numT == 0) { + unregister_intent_filter(f, f.actionsIterator(), + mActionToFilter, " Action: "); + } + if (numT != 0) { + unregister_intent_filter(f, f.actionsIterator(), + mTypedActionToFilter, " TypedAction: "); + } + } + + void dumpMap(Printer out, String prefix, Map<String, ArrayList<F>> map) { + String eprefix = prefix + " "; + String fprefix = prefix + " "; + for (Map.Entry<String, ArrayList<F>> e : map.entrySet()) { + out.println(eprefix + e.getKey() + ":"); + ArrayList<F> a = e.getValue(); + final int N = a.size(); + for (int i=0; i<N; i++) { + dumpFilter(out, fprefix, a.get(i)); + } + } + } + + public void dump(Printer out, String prefix) { + out.println(prefix + "Full MIME Types:"); + dumpMap(out, prefix+" ", mTypeToFilter); + out.println(prefix); + out.println(prefix + "Base MIME Types:"); + dumpMap(out, prefix+" ", mBaseTypeToFilter); + out.println(prefix); + out.println(prefix + "Wild MIME Types:"); + dumpMap(out, prefix+" ", mWildTypeToFilter); + out.println(prefix); + out.println(prefix + "Schemes:"); + dumpMap(out, prefix+" ", mSchemeToFilter); + out.println(prefix); + out.println(prefix + "Non-Data Actions:"); + dumpMap(out, prefix+" ", mActionToFilter); + out.println(prefix); + out.println(prefix + "MIME Typed Actions:"); + dumpMap(out, prefix+" ", mTypedActionToFilter); + } + + private class IteratorWrapper implements Iterator<F> { + private final Iterator<F> mI; + private F mCur; + + IteratorWrapper(Iterator<F> it) { + mI = it; + } + + public boolean hasNext() { + return mI.hasNext(); + } + + public F next() { + return (mCur = mI.next()); + } + + public void remove() { + if (mCur != null) { + removeFilterInternal(mCur); + } + mI.remove(); + } + + } + + /** + * Returns an iterator allowing filters to be removed. + */ + public Iterator<F> filterIterator() { + return new IteratorWrapper(mFilters.iterator()); + } + + /** + * Returns a read-only set of the filters. + */ + public Set<F> filterSet() { + return Collections.unmodifiableSet(mFilters); + } + + public List<R> queryIntent(ContentResolver resolver, Intent intent, + String resolvedType, boolean defaultOnly) { + String scheme = intent.getScheme(); + + ArrayList<R> finalList = new ArrayList<R>(); + + final boolean debug = localLOGV || + ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0); + + if (debug) Log.v( + TAG, "Resolving type " + resolvedType + " scheme " + scheme + + " of intent " + intent); + + ArrayList<F> firstTypeCut = null; + ArrayList<F> secondTypeCut = null; + ArrayList<F> thirdTypeCut = null; + ArrayList<F> schemeCut = null; + + // If the intent includes a MIME type, then we want to collect all of + // the filters that match that MIME type. + if (resolvedType != null) { + int slashpos = resolvedType.indexOf('/'); + if (slashpos > 0) { + final String baseType = resolvedType.substring(0, slashpos); + if (!baseType.equals("*")) { + if (resolvedType.length() != slashpos+2 + || resolvedType.charAt(slashpos+1) != '*') { + // Not a wild card, so we can just look for all filters that + // completely match or wildcards whose base type matches. + firstTypeCut = mTypeToFilter.get(resolvedType); + if (debug) Log.v(TAG, "First type cut: " + firstTypeCut); + secondTypeCut = mWildTypeToFilter.get(baseType); + if (debug) Log.v(TAG, "Second type cut: " + secondTypeCut); + } else { + // We can match anything with our base type. + firstTypeCut = mBaseTypeToFilter.get(baseType); + if (debug) Log.v(TAG, "First type cut: " + firstTypeCut); + secondTypeCut = mWildTypeToFilter.get(baseType); + if (debug) Log.v(TAG, "Second type cut: " + secondTypeCut); + } + // Any */* types always apply, but we only need to do this + // if the intent type was not already */*. + thirdTypeCut = mWildTypeToFilter.get("*"); + if (debug) Log.v(TAG, "Third type cut: " + thirdTypeCut); + } else if (intent.getAction() != null) { + // The intent specified any type ({@literal *}/*). This + // can be a whole heck of a lot of things, so as a first + // cut let's use the action instead. + firstTypeCut = mTypedActionToFilter.get(intent.getAction()); + if (debug) Log.v(TAG, "Typed Action list: " + firstTypeCut); + } + } + } + + // If the intent includes a data URI, then we want to collect all of + // the filters that match its scheme (we will further refine matches + // on the authority and path by directly matching each resulting filter). + if (scheme != null) { + schemeCut = mSchemeToFilter.get(scheme); + if (debug) Log.v(TAG, "Scheme list: " + schemeCut); + } + + // If the intent does not specify any data -- either a MIME type or + // a URI -- then we will only be looking for matches against empty + // data. + if (resolvedType == null && scheme == null && intent.getAction() != null) { + firstTypeCut = mActionToFilter.get(intent.getAction()); + if (debug) Log.v(TAG, "Action list: " + firstTypeCut); + } + + if (firstTypeCut != null) { + buildResolveList(intent, debug, defaultOnly, + resolvedType, scheme, firstTypeCut, finalList); + } + if (secondTypeCut != null) { + buildResolveList(intent, debug, defaultOnly, + resolvedType, scheme, secondTypeCut, finalList); + } + if (thirdTypeCut != null) { + buildResolveList(intent, debug, defaultOnly, + resolvedType, scheme, thirdTypeCut, finalList); + } + if (schemeCut != null) { + buildResolveList(intent, debug, defaultOnly, + resolvedType, scheme, schemeCut, finalList); + } + sortResults(finalList); + + if (debug) { + Log.v(TAG, "Final result list:"); + for (R r : finalList) { + Log.v(TAG, " " + r); + } + } + return finalList; + } + + /** + * Control whether the given filter is allowed to go into the result + * list. Mainly intended to prevent adding multiple filters for the + * same target object. + */ + protected boolean allowFilterResult(F filter, List<R> dest) { + return true; + } + + protected R newResult(F filter, int match) { + return (R)filter; + } + + protected void sortResults(List<R> results) { + Collections.sort(results, mResolvePrioritySorter); + } + + protected void dumpFilter(Printer out, String prefix, F filter) { + out.println(prefix + filter); + } + + private final int register_mime_types(F filter, String prefix) { + final Iterator<String> i = filter.typesIterator(); + if (i == null) { + return 0; + } + + int num = 0; + while (i.hasNext()) { + String name = (String)i.next(); + num++; + if (localLOGV) Log.v(TAG, prefix + name); + String baseName = name; + final int slashpos = name.indexOf('/'); + if (slashpos > 0) { + baseName = name.substring(0, slashpos).intern(); + } else { + name = name + "/*"; + } + + ArrayList<F> array = mTypeToFilter.get(name); + if (array == null) { + //Log.v(TAG, "Creating new array for " + name); + array = new ArrayList<F>(); + mTypeToFilter.put(name, array); + } + array.add(filter); + + if (slashpos > 0) { + array = mBaseTypeToFilter.get(baseName); + if (array == null) { + //Log.v(TAG, "Creating new array for " + name); + array = new ArrayList<F>(); + mBaseTypeToFilter.put(baseName, array); + } + array.add(filter); + } else { + array = mWildTypeToFilter.get(baseName); + if (array == null) { + //Log.v(TAG, "Creating new array for " + name); + array = new ArrayList<F>(); + mWildTypeToFilter.put(baseName, array); + } + array.add(filter); + } + } + + return num; + } + + private final int unregister_mime_types(F filter, String prefix) { + final Iterator<String> i = filter.typesIterator(); + if (i == null) { + return 0; + } + + int num = 0; + while (i.hasNext()) { + String name = (String)i.next(); + num++; + if (localLOGV) Log.v(TAG, prefix + name); + String baseName = name; + final int slashpos = name.indexOf('/'); + if (slashpos > 0) { + baseName = name.substring(0, slashpos).intern(); + } else { + name = name + "/*"; + } + + if (!remove_all_objects(mTypeToFilter.get(name), filter)) { + mTypeToFilter.remove(name); + } + + if (slashpos > 0) { + if (!remove_all_objects(mBaseTypeToFilter.get(baseName), filter)) { + mBaseTypeToFilter.remove(baseName); + } + } else { + if (!remove_all_objects(mWildTypeToFilter.get(baseName), filter)) { + mWildTypeToFilter.remove(baseName); + } + } + } + return num; + } + + private final int register_intent_filter(F filter, Iterator<String> i, + HashMap<String, ArrayList<F>> dest, String prefix) { + if (i == null) { + return 0; + } + + int num = 0; + while (i.hasNext()) { + String name = i.next(); + num++; + if (localLOGV) Log.v(TAG, prefix + name); + ArrayList<F> array = dest.get(name); + if (array == null) { + //Log.v(TAG, "Creating new array for " + name); + array = new ArrayList<F>(); + dest.put(name, array); + } + array.add(filter); + } + return num; + } + + private final int unregister_intent_filter(F filter, Iterator<String> i, + HashMap<String, ArrayList<F>> dest, String prefix) { + if (i == null) { + return 0; + } + + int num = 0; + while (i.hasNext()) { + String name = i.next(); + num++; + if (localLOGV) Log.v(TAG, prefix + name); + if (!remove_all_objects(dest.get(name), filter)) { + dest.remove(name); + } + } + return num; + } + + private final boolean remove_all_objects(List<F> list, Object object) { + if (list != null) { + int N = list.size(); + for (int idx=0; idx<N; idx++) { + if (list.get(idx) == object) { + list.remove(idx); + idx--; + N--; + } + } + return N > 0; + } + return false; + } + + private void buildResolveList(Intent intent, boolean debug, boolean defaultOnly, + String resolvedType, String scheme, List<F> src, List<R> dest) { + Set<String> categories = intent.getCategories(); + + final int N = src != null ? src.size() : 0; + boolean hasNonDefaults = false; + int i; + for (i=0; i<N; i++) { + F filter = src.get(i); + int match; + if (debug) Log.v(TAG, "Matching against filter " + filter); + + // Do we already have this one? + if (!allowFilterResult(filter, dest)) { + if (debug) { + Log.v(TAG, " Filter's target already added"); + } + continue; + } + + match = filter.match( + intent.getAction(), resolvedType, scheme, intent.getData(), categories, TAG); + if (match >= 0) { + if (debug) Log.v(TAG, " Filter matched! match=0x" + + Integer.toHexString(match)); + if (!defaultOnly || filter.hasCategory(Intent.CATEGORY_DEFAULT)) { + final R oneResult = newResult(filter, match); + if (oneResult != null) { + dest.add(oneResult); + } + } else { + hasNonDefaults = true; + } + } else { + if (debug) { + String reason; + switch (match) { + case IntentFilter.NO_MATCH_ACTION: reason = "action"; break; + case IntentFilter.NO_MATCH_CATEGORY: reason = "category"; break; + case IntentFilter.NO_MATCH_DATA: reason = "data"; break; + case IntentFilter.NO_MATCH_TYPE: reason = "type"; break; + default: reason = "unknown reason"; break; + } + Log.v(TAG, " Filter did not match: " + reason); + } + } + } + + if (dest.size() == 0 && hasNonDefaults) { + Log.w(TAG, "resolveIntent failed: found match, but none with Intent.CATEGORY_DEFAULT"); + } + } + + // Sorts a List of IntentFilter objects into descending priority order. + private static final Comparator mResolvePrioritySorter = new Comparator() { + public int compare(Object o1, Object o2) { + float q1 = ((IntentFilter)o1).getPriority(); + float q2 = ((IntentFilter)o2).getPriority(); + return (q1 > q2) ? -1 : ((q1 < q2) ? 1 : 0); + } + }; + + /** + * All filters that have been registered. + */ + private final HashSet<F> mFilters = new HashSet<F>(); + + /** + * All of the MIME types that have been registered, such as "image/jpeg", + * "image/*", or "{@literal *}/*". + */ + private final HashMap<String, ArrayList<F>> mTypeToFilter + = new HashMap<String, ArrayList<F>>(); + + /** + * The base names of all of all fully qualified MIME types that have been + * registered, such as "image" or "*". Wild card MIME types such as + * "image/*" will not be here. + */ + private final HashMap<String, ArrayList<F>> mBaseTypeToFilter + = new HashMap<String, ArrayList<F>>(); + + /** + * The base names of all of the MIME types with a sub-type wildcard that + * have been registered. For example, a filter with "image/*" will be + * included here as "image" but one with "image/jpeg" will not be + * included here. This also includes the "*" for the "{@literal *}/*" + * MIME type. + */ + private final HashMap<String, ArrayList<F>> mWildTypeToFilter + = new HashMap<String, ArrayList<F>>(); + + /** + * All of the URI schemes (such as http) that have been registered. + */ + private final HashMap<String, ArrayList<F>> mSchemeToFilter + = new HashMap<String, ArrayList<F>>(); + + /** + * All of the actions that have been registered, but only those that did + * not specify data. + */ + private final HashMap<String, ArrayList<F>> mActionToFilter + = new HashMap<String, ArrayList<F>>(); + + /** + * All of the actions that have been registered and specified a MIME type. + */ + private final HashMap<String, ArrayList<F>> mTypedActionToFilter + = new HashMap<String, ArrayList<F>>(); +} + diff --git a/services/java/com/android/server/KeyInputQueue.java b/services/java/com/android/server/KeyInputQueue.java new file mode 100644 index 0000000..63b486c --- /dev/null +++ b/services/java/com/android/server/KeyInputQueue.java @@ -0,0 +1,627 @@ +/* + * Copyright (C) 2007 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.Context; +import android.content.res.Configuration; +import android.os.SystemClock; +import android.os.PowerManager; +import android.util.Log; +import android.util.SparseArray; +import android.view.Display; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.RawInputEvent; +import android.view.Surface; +import android.view.WindowManagerPolicy; + +public abstract class KeyInputQueue { + static final String TAG = "KeyInputQueue"; + + SparseArray<InputDevice> mDevices = new SparseArray<InputDevice>(); + + int mGlobalMetaState = 0; + boolean mHaveGlobalMetaState = false; + + final QueuedEvent mFirst; + final QueuedEvent mLast; + QueuedEvent mCache; + int mCacheCount; + + Display mDisplay = null; + + int mOrientation = Surface.ROTATION_0; + int[] mKeyRotationMap = null; + + PowerManager.WakeLock mWakeLock; + + static final int[] KEY_90_MAP = new int[] { + KeyEvent.KEYCODE_DPAD_DOWN, KeyEvent.KEYCODE_DPAD_RIGHT, + KeyEvent.KEYCODE_DPAD_RIGHT, KeyEvent.KEYCODE_DPAD_UP, + KeyEvent.KEYCODE_DPAD_UP, KeyEvent.KEYCODE_DPAD_LEFT, + KeyEvent.KEYCODE_DPAD_LEFT, KeyEvent.KEYCODE_DPAD_DOWN, + }; + + static final int[] KEY_180_MAP = new int[] { + KeyEvent.KEYCODE_DPAD_DOWN, KeyEvent.KEYCODE_DPAD_UP, + KeyEvent.KEYCODE_DPAD_RIGHT, KeyEvent.KEYCODE_DPAD_LEFT, + KeyEvent.KEYCODE_DPAD_UP, KeyEvent.KEYCODE_DPAD_DOWN, + KeyEvent.KEYCODE_DPAD_LEFT, KeyEvent.KEYCODE_DPAD_RIGHT, + }; + + static final int[] KEY_270_MAP = new int[] { + KeyEvent.KEYCODE_DPAD_DOWN, KeyEvent.KEYCODE_DPAD_LEFT, + KeyEvent.KEYCODE_DPAD_LEFT, KeyEvent.KEYCODE_DPAD_UP, + KeyEvent.KEYCODE_DPAD_UP, KeyEvent.KEYCODE_DPAD_RIGHT, + KeyEvent.KEYCODE_DPAD_RIGHT, KeyEvent.KEYCODE_DPAD_DOWN, + }; + + public static final int FILTER_REMOVE = 0; + public static final int FILTER_KEEP = 1; + public static final int FILTER_ABORT = -1; + + public interface FilterCallback { + int filterEvent(QueuedEvent ev); + } + + static class QueuedEvent { + InputDevice inputDevice; + long when; + int flags; // From the raw event + int classType; // One of the class constants in InputEvent + Object event; + boolean inQueue; + + void copyFrom(QueuedEvent that) { + this.inputDevice = that.inputDevice; + this.when = that.when; + this.flags = that.flags; + this.classType = that.classType; + this.event = that.event; + } + + @Override + public String toString() { + return "QueuedEvent{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + event + "}"; + } + + // not copied + QueuedEvent prev; + QueuedEvent next; + } + + KeyInputQueue(Context context) { + PowerManager pm = (PowerManager)context.getSystemService( + Context.POWER_SERVICE); + mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, + "KeyInputQueue"); + mWakeLock.setReferenceCounted(false); + + mFirst = new QueuedEvent(); + mLast = new QueuedEvent(); + mFirst.next = mLast; + mLast.prev = mFirst; + + mThread.start(); + } + + public void setDisplay(Display display) { + mDisplay = display; + } + + public void getInputConfiguration(Configuration config) { + synchronized (mFirst) { + config.touchscreen = Configuration.TOUCHSCREEN_NOTOUCH; + config.keyboard = Configuration.KEYBOARD_NOKEYS; + config.navigation = Configuration.NAVIGATION_NONAV; + + final int N = mDevices.size(); + for (int i=0; i<N; i++) { + InputDevice d = mDevices.valueAt(i); + if (d != null) { + if ((d.classes&RawInputEvent.CLASS_TOUCHSCREEN) != 0) { + config.touchscreen + = Configuration.TOUCHSCREEN_FINGER; + //Log.i("foo", "***** HAVE TOUCHSCREEN!"); + } + if ((d.classes&RawInputEvent.CLASS_ALPHAKEY) != 0) { + config.keyboard + = Configuration.KEYBOARD_QWERTY; + //Log.i("foo", "***** HAVE QWERTY!"); + } + if ((d.classes&RawInputEvent.CLASS_TRACKBALL) != 0) { + config.navigation + = Configuration.NAVIGATION_TRACKBALL; + //Log.i("foo", "***** HAVE TRACKBALL!"); + } + } + } + } + } + + public static native String getDeviceName(int deviceId); + public static native int getDeviceClasses(int deviceId); + public static native boolean getAbsoluteInfo(int deviceId, int axis, + InputDevice.AbsoluteInfo outInfo); + public static native int getSwitchState(int sw); + public static native int getSwitchState(int deviceId, int sw); + public static native int getScancodeState(int sw); + public static native int getScancodeState(int deviceId, int sw); + public static native int getKeycodeState(int sw); + public static native int getKeycodeState(int deviceId, int sw); + public static native boolean hasKeys(int[] keycodes, boolean[] keyExists); + + public static KeyEvent newKeyEvent(InputDevice device, long downTime, + long eventTime, boolean down, int keycode, int repeatCount, + int scancode, int flags) { + return new KeyEvent( + downTime, eventTime, + down ? KeyEvent.ACTION_DOWN : KeyEvent.ACTION_UP, + keycode, repeatCount, + device != null ? device.mMetaKeysState : 0, + device != null ? device.id : -1, scancode, + flags); + } + + Thread mThread = new Thread("InputDeviceReader") { + public void run() { + android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY); + + try { + RawInputEvent ev = new RawInputEvent(); + while (true) { + InputDevice di; + + // block, doesn't release the monitor + readEvent(ev); + + boolean send = false; + boolean configChanged = false; + + if (false) { + Log.i(TAG, "Input event: dev=0x" + + Integer.toHexString(ev.deviceId) + + " type=0x" + Integer.toHexString(ev.type) + + " scancode=" + ev.scancode + + " keycode=" + ev.keycode + + " value=" + ev.value); + } + + if (ev.type == RawInputEvent.EV_DEVICE_ADDED) { + synchronized (mFirst) { + di = newInputDevice(ev.deviceId); + mDevices.put(ev.deviceId, di); + configChanged = true; + } + } else if (ev.type == RawInputEvent.EV_DEVICE_REMOVED) { + synchronized (mFirst) { + Log.i(TAG, "Device removed: id=0x" + + Integer.toHexString(ev.deviceId)); + di = mDevices.get(ev.deviceId); + if (di != null) { + mDevices.delete(ev.deviceId); + configChanged = true; + } else { + Log.w(TAG, "Bad device id: " + ev.deviceId); + } + } + } else { + di = getInputDevice(ev.deviceId); + + // first crack at it + send = preprocessEvent(di, ev); + + if (ev.type == RawInputEvent.EV_KEY) { + di.mMetaKeysState = makeMetaState(ev.keycode, + ev.value != 0, di.mMetaKeysState); + mHaveGlobalMetaState = false; + } + } + + if (di == null) { + continue; + } + + if (configChanged) { + synchronized (mFirst) { + addLocked(di, SystemClock.uptimeMillis(), 0, + RawInputEvent.CLASS_CONFIGURATION_CHANGED, + null); + } + } + + if (!send) { + continue; + } + + synchronized (mFirst) { + // NOTE: The event timebase absolutely must be the same + // timebase as SystemClock.uptimeMillis(). + //curTime = gotOne ? ev.when : SystemClock.uptimeMillis(); + final long curTime = SystemClock.uptimeMillis(); + //Log.i(TAG, "curTime=" + curTime + ", systemClock=" + SystemClock.uptimeMillis()); + + final int classes = di.classes; + final int type = ev.type; + final int scancode = ev.scancode; + send = false; + + // Is it a key event? + if (type == RawInputEvent.EV_KEY && + (classes&RawInputEvent.CLASS_KEYBOARD) != 0 && + (scancode < RawInputEvent.BTN_FIRST || + scancode > RawInputEvent.BTN_LAST)) { + boolean down; + if (ev.value != 0) { + down = true; + di.mDownTime = curTime; + } else { + down = false; + } + int keycode = rotateKeyCodeLocked(ev.keycode); + addLocked(di, curTime, ev.flags, + RawInputEvent.CLASS_KEYBOARD, + newKeyEvent(di, di.mDownTime, curTime, down, + keycode, 0, scancode, + ((ev.flags & WindowManagerPolicy.FLAG_WOKE_HERE) != 0) + ? KeyEvent.FLAG_WOKE_HERE : 0)); + } else if (ev.type == RawInputEvent.EV_KEY) { + if (ev.scancode == RawInputEvent.BTN_TOUCH && + (classes&RawInputEvent.CLASS_TOUCHSCREEN) != 0) { + di.mAbs.changed = true; + di.mAbs.down = ev.value != 0; + } + if (ev.scancode == RawInputEvent.BTN_MOUSE && + (classes&RawInputEvent.CLASS_TRACKBALL) != 0) { + di.mRel.changed = true; + di.mRel.down = ev.value != 0; + send = true; + } + + } else if (ev.type == RawInputEvent.EV_ABS && + (classes&RawInputEvent.CLASS_TOUCHSCREEN) != 0) { + if (ev.scancode == RawInputEvent.ABS_X) { + di.mAbs.changed = true; + di.mAbs.x = ev.value; + } else if (ev.scancode == RawInputEvent.ABS_Y) { + di.mAbs.changed = true; + di.mAbs.y = ev.value; + } else if (ev.scancode == RawInputEvent.ABS_PRESSURE) { + di.mAbs.changed = true; + di.mAbs.pressure = ev.value; + } else if (ev.scancode == RawInputEvent.ABS_TOOL_WIDTH) { + di.mAbs.changed = true; + di.mAbs.size = ev.value; + } + + } else if (ev.type == RawInputEvent.EV_REL && + (classes&RawInputEvent.CLASS_TRACKBALL) != 0) { + // Add this relative movement into our totals. + if (ev.scancode == RawInputEvent.REL_X) { + di.mRel.changed = true; + di.mRel.x += ev.value; + } else if (ev.scancode == RawInputEvent.REL_Y) { + di.mRel.changed = true; + di.mRel.y += ev.value; + } + } + + if (send || ev.type == RawInputEvent.EV_SYN) { + if (mDisplay != null) { + if (!mHaveGlobalMetaState) { + computeGlobalMetaStateLocked(); + } + + MotionEvent me; + me = di.mAbs.generateMotion(di, curTime, true, + mDisplay, mOrientation, mGlobalMetaState); + if (false) Log.v(TAG, "Absolute: x=" + di.mAbs.x + + " y=" + di.mAbs.y + " ev=" + me); + if (me != null) { + if (WindowManagerPolicy.WATCH_POINTER) { + Log.i(TAG, "Enqueueing: " + me); + } + addLocked(di, curTime, ev.flags, + RawInputEvent.CLASS_TOUCHSCREEN, me); + } + me = di.mRel.generateMotion(di, curTime, false, + mDisplay, mOrientation, mGlobalMetaState); + if (false) Log.v(TAG, "Relative: x=" + di.mRel.x + + " y=" + di.mRel.y + " ev=" + me); + if (me != null) { + addLocked(di, curTime, ev.flags, + RawInputEvent.CLASS_TRACKBALL, me); + } + } + } + } + } + } + catch (RuntimeException exc) { + Log.e(TAG, "InputReaderThread uncaught exception", exc); + } + } + }; + + /** + * Returns a new meta state for the given keys and old state. + */ + private static final int makeMetaState(int keycode, boolean down, int old) { + int mask; + switch (keycode) { + case KeyEvent.KEYCODE_ALT_LEFT: + mask = KeyEvent.META_ALT_LEFT_ON; + break; + case KeyEvent.KEYCODE_ALT_RIGHT: + mask = KeyEvent.META_ALT_RIGHT_ON; + break; + case KeyEvent.KEYCODE_SHIFT_LEFT: + mask = KeyEvent.META_SHIFT_LEFT_ON; + break; + case KeyEvent.KEYCODE_SHIFT_RIGHT: + mask = KeyEvent.META_SHIFT_RIGHT_ON; + break; + case KeyEvent.KEYCODE_SYM: + mask = KeyEvent.META_SYM_ON; + break; + default: + return old; + } + int result = ~(KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON) + & (down ? (old | mask) : (old & ~mask)); + if (0 != (result & (KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_ALT_RIGHT_ON))) { + result |= KeyEvent.META_ALT_ON; + } + if (0 != (result & (KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_RIGHT_ON))) { + result |= KeyEvent.META_SHIFT_ON; + } + return result; + } + + private void computeGlobalMetaStateLocked() { + int i = mDevices.size(); + mGlobalMetaState = 0; + while ((--i) >= 0) { + mGlobalMetaState |= mDevices.valueAt(i).mMetaKeysState; + } + mHaveGlobalMetaState = true; + } + + /* + * Return true if you want the event to get passed on to the + * rest of the system, and false if you've handled it and want + * it dropped. + */ + abstract boolean preprocessEvent(InputDevice device, RawInputEvent event); + + InputDevice getInputDevice(int deviceId) { + synchronized (mFirst) { + return getInputDeviceLocked(deviceId); + } + } + + private InputDevice getInputDeviceLocked(int deviceId) { + return mDevices.get(deviceId); + } + + public void setOrientation(int orientation) { + synchronized(mFirst) { + mOrientation = orientation; + switch (orientation) { + case Surface.ROTATION_90: + mKeyRotationMap = KEY_90_MAP; + break; + case Surface.ROTATION_180: + mKeyRotationMap = KEY_180_MAP; + break; + case Surface.ROTATION_270: + mKeyRotationMap = KEY_270_MAP; + break; + default: + mKeyRotationMap = null; + break; + } + } + } + + public int rotateKeyCode(int keyCode) { + synchronized(mFirst) { + return rotateKeyCodeLocked(keyCode); + } + } + + private int rotateKeyCodeLocked(int keyCode) { + int[] map = mKeyRotationMap; + if (map != null) { + final int N = map.length; + for (int i=0; i<N; i+=2) { + if (map[i] == keyCode) { + return map[i+1]; + } + } + } + return keyCode; + } + + boolean hasEvents() { + synchronized (mFirst) { + return mFirst.next != mLast; + } + } + + /* + * returns true if we returned an event, and false if we timed out + */ + QueuedEvent getEvent(long timeoutMS) { + long begin = SystemClock.uptimeMillis(); + final long end = begin+timeoutMS; + long now = begin; + synchronized (mFirst) { + while (mFirst.next == mLast && end > now) { + try { + mWakeLock.release(); + mFirst.wait(end-now); + } + catch (InterruptedException e) { + } + now = SystemClock.uptimeMillis(); + if (begin > now) { + begin = now; + } + } + if (mFirst.next == mLast) { + return null; + } + QueuedEvent p = mFirst.next; + mFirst.next = p.next; + mFirst.next.prev = mFirst; + p.inQueue = false; + return p; + } + } + + void recycleEvent(QueuedEvent ev) { + synchronized (mFirst) { + //Log.i(TAG, "Recycle event: " + ev); + if (ev.event == ev.inputDevice.mAbs.currentMove) { + ev.inputDevice.mAbs.currentMove = null; + } + if (ev.event == ev.inputDevice.mRel.currentMove) { + if (false) Log.i(TAG, "Detach rel " + ev.event); + ev.inputDevice.mRel.currentMove = null; + ev.inputDevice.mRel.x = 0; + ev.inputDevice.mRel.y = 0; + } + recycleLocked(ev); + } + } + + void filterQueue(FilterCallback cb) { + synchronized (mFirst) { + QueuedEvent cur = mLast.prev; + while (cur.prev != null) { + switch (cb.filterEvent(cur)) { + case FILTER_REMOVE: + cur.prev.next = cur.next; + cur.next.prev = cur.prev; + break; + case FILTER_ABORT: + return; + } + cur = cur.prev; + } + } + } + + private QueuedEvent obtainLocked(InputDevice device, long when, + int flags, int classType, Object event) { + QueuedEvent ev; + if (mCacheCount == 0) { + ev = new QueuedEvent(); + } else { + ev = mCache; + ev.inQueue = false; + mCache = ev.next; + mCacheCount--; + } + ev.inputDevice = device; + ev.when = when; + ev.flags = flags; + ev.classType = classType; + ev.event = event; + return ev; + } + + private void recycleLocked(QueuedEvent ev) { + if (ev.inQueue) { + throw new RuntimeException("Event already in queue!"); + } + if (mCacheCount < 10) { + mCacheCount++; + ev.next = mCache; + mCache = ev; + ev.inQueue = true; + } + } + + private void addLocked(InputDevice device, long when, int flags, + int classType, Object event) { + boolean poke = mFirst.next == mLast; + + QueuedEvent ev = obtainLocked(device, when, flags, classType, event); + QueuedEvent p = mLast.prev; + while (p != mFirst && ev.when < p.when) { + p = p.prev; + } + + ev.next = p.next; + ev.prev = p; + p.next = ev; + ev.next.prev = ev; + ev.inQueue = true; + + if (poke) { + mFirst.notify(); + mWakeLock.acquire(); + } + } + + private InputDevice newInputDevice(int deviceId) { + int classes = getDeviceClasses(deviceId); + String name = getDeviceName(deviceId); + Log.i(TAG, "Device added: id=0x" + Integer.toHexString(deviceId) + + ", name=" + name + + ", classes=" + Integer.toHexString(classes)); + InputDevice.AbsoluteInfo absX; + InputDevice.AbsoluteInfo absY; + InputDevice.AbsoluteInfo absPressure; + InputDevice.AbsoluteInfo absSize; + if ((classes&RawInputEvent.CLASS_TOUCHSCREEN) != 0) { + absX = loadAbsoluteInfo(deviceId, RawInputEvent.ABS_X, "X"); + absY = loadAbsoluteInfo(deviceId, RawInputEvent.ABS_Y, "Y"); + absPressure = loadAbsoluteInfo(deviceId, RawInputEvent.ABS_PRESSURE, "Pressure"); + absSize = loadAbsoluteInfo(deviceId, RawInputEvent.ABS_TOOL_WIDTH, "Size"); + } else { + absX = null; + absY = null; + absPressure = null; + absSize = null; + } + + return new InputDevice(deviceId, classes, name, absX, absY, absPressure, absSize); + } + + private InputDevice.AbsoluteInfo loadAbsoluteInfo(int id, int channel, + String name) { + InputDevice.AbsoluteInfo info = new InputDevice.AbsoluteInfo(); + if (getAbsoluteInfo(id, channel, info) + && info.minValue != info.maxValue) { + Log.i(TAG, " " + name + ": min=" + info.minValue + + " max=" + info.maxValue + + " flat=" + info.flat + + " fuzz=" + info.fuzz); + info.range = info.maxValue-info.minValue; + return info; + } + Log.i(TAG, " " + name + ": unknown values"); + return null; + } + private static native boolean readEvent(RawInputEvent outEvent); +} diff --git a/services/java/com/android/server/LoadAverageService.java b/services/java/com/android/server/LoadAverageService.java new file mode 100644 index 0000000..0d86429 --- /dev/null +++ b/services/java/com/android/server/LoadAverageService.java @@ -0,0 +1,297 @@ +/* + * Copyright (C) 2007 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.app.Service; +import android.content.Context; +import android.content.Intent; +import android.graphics.Canvas; +import android.graphics.Paint; +import android.graphics.PixelFormat; +import android.os.Handler; +import android.os.IBinder; +import android.os.Message; +import android.view.Gravity; +import android.view.View; +import android.view.WindowManager; +import android.view.WindowManagerImpl; + +public class LoadAverageService extends Service { + private View mView; + + private static final class Stats extends ProcessStats { + String mLoadText; + int mLoadWidth; + + private final Paint mPaint; + + Stats(Paint paint) { + super(false); + mPaint = paint; + } + + @Override + public void onLoadChanged(float load1, float load5, float load15) { + mLoadText = load1 + " / " + load5 + " / " + load15; + mLoadWidth = (int)mPaint.measureText(mLoadText); + } + + @Override + public int onMeasureProcessName(String name) { + return (int)mPaint.measureText(name); + } + } + + private class LoadView extends View { + private Handler mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + if (msg.what == 1) { + mStats.update(); + updateDisplay(); + Message m = obtainMessage(1); + sendMessageDelayed(m, 2000); + } + } + }; + + private final Stats mStats; + + private Paint mLoadPaint; + private Paint mAddedPaint; + private Paint mRemovedPaint; + private Paint mShadowPaint; + private Paint mShadow2Paint; + private Paint mIrqPaint; + private Paint mSystemPaint; + private Paint mUserPaint; + private float mAscent; + private int mFH; + + private int mNeededWidth; + private int mNeededHeight; + + LoadView(Context c) { + super(c); + + setPadding(4, 4, 4, 4); + //setBackgroundResource(com.android.internal.R.drawable.load_average_background); + + mLoadPaint = new Paint(); + mLoadPaint.setAntiAlias(true); + mLoadPaint.setTextSize(10); + mLoadPaint.setARGB(255, 255, 255, 255); + + mAddedPaint = new Paint(); + mAddedPaint.setAntiAlias(true); + mAddedPaint.setTextSize(10); + mAddedPaint.setARGB(255, 128, 255, 128); + + mRemovedPaint = new Paint(); + mRemovedPaint.setAntiAlias(true); + mRemovedPaint.setStrikeThruText(true); + mRemovedPaint.setTextSize(10); + mRemovedPaint.setARGB(255, 255, 128, 128); + + mShadowPaint = new Paint(); + mShadowPaint.setAntiAlias(true); + mShadowPaint.setTextSize(10); + //mShadowPaint.setFakeBoldText(true); + mShadowPaint.setARGB(192, 0, 0, 0); + mLoadPaint.setShadowLayer(4, 0, 0, 0xff000000); + + mShadow2Paint = new Paint(); + mShadow2Paint.setAntiAlias(true); + mShadow2Paint.setTextSize(10); + //mShadow2Paint.setFakeBoldText(true); + mShadow2Paint.setARGB(192, 0, 0, 0); + mLoadPaint.setShadowLayer(2, 0, 0, 0xff000000); + + mIrqPaint = new Paint(); + mIrqPaint.setARGB(0x80, 0, 0, 0xff); + mIrqPaint.setShadowLayer(2, 0, 0, 0xff000000); + mSystemPaint = new Paint(); + mSystemPaint.setARGB(0x80, 0xff, 0, 0); + mSystemPaint.setShadowLayer(2, 0, 0, 0xff000000); + mUserPaint = new Paint(); + mUserPaint.setARGB(0x80, 0, 0xff, 0); + mSystemPaint.setShadowLayer(2, 0, 0, 0xff000000); + + mAscent = mLoadPaint.ascent(); + float descent = mLoadPaint.descent(); + mFH = (int)(descent - mAscent + .5f); + + mStats = new Stats(mLoadPaint); + mStats.init(); + updateDisplay(); + } + + @Override + protected void onAttachedToWindow() { + super.onAttachedToWindow(); + mHandler.sendEmptyMessage(1); + } + + @Override + protected void onDetachedFromWindow() { + super.onDetachedFromWindow(); + mHandler.removeMessages(1); + } + + @Override + protected void onMeasure(int widthMeasureSpect, int heightMeasureSpec) { + setMeasuredDimension(mNeededWidth, mNeededHeight); + } + + @Override + public void onDraw(Canvas canvas) { + super.onDraw(canvas); + final int W = getWidth(); + + final Stats stats = mStats; + final int userTime = stats.getLastUserTime(); + final int systemTime = stats.getLastSystemTime(); + final int iowaitTime = stats.getLastIoWaitTime(); + final int irqTime = stats.getLastIrqTime(); + final int softIrqTime = stats.getLastSoftIrqTime(); + final int idleTime = stats.getLastIdleTime(); + + final int totalTime = userTime+systemTime+iowaitTime+irqTime+softIrqTime+idleTime; + if (totalTime == 0) { + return; + } + int userW = (userTime*W)/totalTime; + int systemW = (systemTime*W)/totalTime; + int irqW = ((iowaitTime+irqTime+softIrqTime)*W)/totalTime; + + int x = W - mPaddingRight; + int top = mPaddingTop + 2; + int bottom = mPaddingTop + mFH - 2; + + if (irqW > 0) { + canvas.drawRect(x-irqW, top, x, bottom, mIrqPaint); + x -= irqW; + } + if (systemW > 0) { + canvas.drawRect(x-systemW, top, x, bottom, mSystemPaint); + x -= systemW; + } + if (userW > 0) { + canvas.drawRect(x-userW, top, x, bottom, mUserPaint); + x -= userW; + } + + int y = mPaddingTop - (int)mAscent; + canvas.drawText(stats.mLoadText, W-mPaddingRight-stats.mLoadWidth-1, + y-1, mShadowPaint); + canvas.drawText(stats.mLoadText, W-mPaddingRight-stats.mLoadWidth-1, + y+1, mShadowPaint); + canvas.drawText(stats.mLoadText, W-mPaddingRight-stats.mLoadWidth+1, + y-1, mShadow2Paint); + canvas.drawText(stats.mLoadText, W-mPaddingRight-stats.mLoadWidth+1, + y+1, mShadow2Paint); + canvas.drawText(stats.mLoadText, W-mPaddingRight-stats.mLoadWidth, + y, mLoadPaint); + + int N = stats.countWorkingStats(); + for (int i=0; i<N; i++) { + Stats.Stats st = stats.getWorkingStats(i); + y += mFH; + top += mFH; + bottom += mFH; + + userW = (st.rel_utime*W)/totalTime; + systemW = (st.rel_stime*W)/totalTime; + x = W - mPaddingRight; + if (systemW > 0) { + canvas.drawRect(x-systemW, top, x, bottom, mSystemPaint); + x -= systemW; + } + if (userW > 0) { + canvas.drawRect(x-userW, top, x, bottom, mUserPaint); + x -= userW; + } + + canvas.drawText(st.name, W-mPaddingRight-st.nameWidth-1, + y-1, mShadowPaint); + canvas.drawText(st.name, W-mPaddingRight-st.nameWidth-1, + y+1, mShadowPaint); + canvas.drawText(st.name, W-mPaddingRight-st.nameWidth+1, + y-1, mShadow2Paint); + canvas.drawText(st.name, W-mPaddingRight-st.nameWidth+1, + y+1, mShadow2Paint); + Paint p = mLoadPaint; + if (st.added) p = mAddedPaint; + if (st.removed) p = mRemovedPaint; + canvas.drawText(st.name, W-mPaddingRight-st.nameWidth, y, p); + } + } + + void updateDisplay() { + final Stats stats = mStats; + final int NW = stats.countWorkingStats(); + + int maxWidth = stats.mLoadWidth; + for (int i=0; i<NW; i++) { + Stats.Stats st = stats.getWorkingStats(i); + if (st.nameWidth > maxWidth) { + maxWidth = st.nameWidth; + } + } + + int neededWidth = mPaddingLeft + mPaddingRight + maxWidth; + int neededHeight = mPaddingTop + mPaddingBottom + (mFH*(1+NW)); + if (neededWidth != mNeededWidth || neededHeight != mNeededHeight) { + mNeededWidth = neededWidth; + mNeededHeight = neededHeight; + requestLayout(); + } else { + invalidate(); + } + } + } + + @Override + public void onCreate() { + super.onCreate(); + mView = new LoadView(this); + WindowManager.LayoutParams params = new WindowManager.LayoutParams( + WindowManager.LayoutParams.WRAP_CONTENT, + WindowManager.LayoutParams.WRAP_CONTENT, + WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY, + WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE| + WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE, + PixelFormat.TRANSLUCENT); + params.gravity = Gravity.RIGHT | Gravity.TOP; + params.setTitle("Load Average"); + WindowManagerImpl wm = (WindowManagerImpl)getSystemService(WINDOW_SERVICE); + wm.addView(mView, params); + } + + @Override + public void onDestroy() { + super.onDestroy(); + ((WindowManagerImpl)getSystemService(WINDOW_SERVICE)).removeView(mView); + mView = null; + } + + @Override + public IBinder onBind(Intent intent) { + return null; + } + +} diff --git a/services/java/com/android/server/LocationManagerService.java b/services/java/com/android/server/LocationManagerService.java new file mode 100644 index 0000000..9d69114 --- /dev/null +++ b/services/java/com/android/server/LocationManagerService.java @@ -0,0 +1,2753 @@ +/* + * Copyright (C) 2007 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 java.io.BufferedReader; +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.regex.Pattern; + +import android.app.AlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.location.Address; +import android.location.IGpsStatusListener; +import android.location.ILocationListener; +import android.location.ILocationManager; +import android.location.Location; +import android.location.LocationManager; +import android.location.LocationProvider; +import android.location.LocationProviderImpl; +import android.net.ConnectivityManager; +import android.net.Uri; +import android.net.wifi.ScanResult; +import android.net.wifi.WifiManager; +import android.os.Binder; +import android.os.Bundle; +import android.os.Handler; +import android.os.IBinder; +import android.os.Message; +import android.os.PowerManager; +import android.os.RemoteException; +import android.os.SystemClock; +import android.provider.Settings; +import android.telephony.CellLocation; +import android.telephony.PhoneStateListener; +import android.telephony.TelephonyManager; +import android.util.Config; +import android.util.Log; +import android.util.PrintWriterPrinter; +import android.util.SparseIntArray; + +import com.android.internal.app.IBatteryStats; +import com.android.internal.location.CellState; +import com.android.internal.location.GpsLocationProvider; +import com.android.internal.location.ILocationCollector; +import com.android.internal.location.INetworkLocationManager; +import com.android.internal.location.INetworkLocationProvider; +import com.android.internal.location.TrackProvider; +import com.android.server.am.BatteryStatsService; + +/** + * The service class that manages LocationProviders and issues location + * updates and alerts. + * + * {@hide} + */ +public class LocationManagerService extends ILocationManager.Stub + implements INetworkLocationManager { + private static final String TAG = "LocationManagerService"; + + // Minimum time interval between last known location writes, in milliseconds. + private static final long MIN_LAST_KNOWN_LOCATION_TIME = 60L * 1000L; + + // Max time to hold wake lock for, in milliseconds. + private static final long MAX_TIME_FOR_WAKE_LOCK = 60 * 1000L; + + // Time to wait after releasing a wake lock for clients to process location update, + // in milliseconds. + private static final long TIME_AFTER_WAKE_LOCK = 2 * 1000L; + + // The last time a location was written, by provider name. + private HashMap<String,Long> mLastWriteTime = new HashMap<String,Long>(); + + private static final Pattern PATTERN_COMMA = Pattern.compile(","); + + private static final String ACCESS_FINE_LOCATION = + android.Manifest.permission.ACCESS_FINE_LOCATION; + private static final String ACCESS_COARSE_LOCATION = + android.Manifest.permission.ACCESS_COARSE_LOCATION; + private static final String ACCESS_MOCK_LOCATION = + android.Manifest.permission.ACCESS_MOCK_LOCATION; + private static final String ACCESS_LOCATION_EXTRA_COMMANDS = + android.Manifest.permission.ACCESS_LOCATION_EXTRA_COMMANDS; + + // Set of providers that are explicitly enabled + private final Set<String> mEnabledProviders = new HashSet<String>(); + + // Set of providers that are explicitly disabled + private final Set<String> mDisabledProviders = new HashSet<String>(); + + // Locations, status values, and extras for mock providers + HashMap<String,MockProvider> mMockProviders = new HashMap<String,MockProvider>(); + private final HashMap<String,Location> mMockProviderLocation = new HashMap<String,Location>(); + private final HashMap<String,Integer> mMockProviderStatus = new HashMap<String,Integer>(); + private final HashMap<String,Bundle> mMockProviderStatusExtras = new HashMap<String,Bundle>(); + private final HashMap<String,Long> mMockProviderStatusUpdateTime = new HashMap<String,Long>(); + + private static boolean sProvidersLoaded = false; + + private final Context mContext; + private GpsLocationProvider mGpsLocationProvider; + private boolean mGpsNavigating; + private LocationProviderImpl mNetworkLocationProvider; + private INetworkLocationProvider mNetworkLocationInterface; + private LocationWorkerHandler mLocationHandler; + + // Handler messages + private static final int MESSAGE_HEARTBEAT = 1; + private static final int MESSAGE_ACQUIRE_WAKE_LOCK = 2; + private static final int MESSAGE_RELEASE_WAKE_LOCK = 3; + private static final int MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER = 4; + + // Alarm manager and wakelock variables + private final static String ALARM_INTENT = "com.android.location.ALARM_INTENT"; + private final static String WAKELOCK_KEY = "LocationManagerService"; + private final static String WIFILOCK_KEY = "LocationManagerService"; + private AlarmManager mAlarmManager; + private long mAlarmInterval = 0; + private boolean mScreenOn = true; + private PowerManager.WakeLock mWakeLock = null; + private WifiManager.WifiLock mWifiLock = null; + private long mWakeLockAcquireTime = 0; + private boolean mWakeLockGpsReceived = true; + private boolean mWakeLockNetworkReceived = true; + private boolean mWifiWakeLockAcquired = false; + private boolean mCellWakeLockAcquired = false; + + private final IBatteryStats mBatteryStats; + + /** + * Mapping from listener IBinder/PendingIntent to local Listener wrappers. + */ + private final ArrayList<Receiver> mListeners = new ArrayList<Receiver>(); + + /** + * Used for reporting which UIDs are causing the GPS to run. + */ + private final SparseIntArray mReportedGpsUids = new SparseIntArray(); + private int mReportedGpsSeq = 0; + + /** + * Mapping from listener IBinder/PendingIntent to a map from provider name to UpdateRecord. + * This also serves as the lock for our state. + */ + private final HashMap<Receiver,HashMap<String,UpdateRecord>> mLocationListeners = + new HashMap<Receiver,HashMap<String,UpdateRecord>>(); + + /** + * Mapping from listener IBinder/PendingIntent to a map from provider name to last broadcast + * location. + */ + private final HashMap<Receiver,HashMap<String,Location>> mLastFixBroadcast = + new HashMap<Receiver,HashMap<String,Location>>(); + private final HashMap<Receiver,HashMap<String,Long>> mLastStatusBroadcast = + new HashMap<Receiver,HashMap<String,Long>>(); + + /** + * Mapping from provider name to all its UpdateRecords + */ + private final HashMap<String,ArrayList<UpdateRecord>> mRecordsByProvider = + new HashMap<String,ArrayList<UpdateRecord>>(); + + /** + * Mappings from provider name to object to use for current location. Locations + * contained in this list may not always be valid. + */ + private final HashMap<String,Location> mLocationsByProvider = + new HashMap<String,Location>(); + + // Proximity listeners + private Receiver mProximityListener = null; + private HashMap<PendingIntent,ProximityAlert> mProximityAlerts = + new HashMap<PendingIntent,ProximityAlert>(); + private HashSet<ProximityAlert> mProximitiesEntered = + new HashSet<ProximityAlert>(); + + // Last known location for each provider + private HashMap<String,Location> mLastKnownLocation = + new HashMap<String,Location>(); + + // Battery status extras (from com.android.server.BatteryService) + private static final String BATTERY_EXTRA_SCALE = "scale"; + private static final String BATTERY_EXTRA_LEVEL = "level"; + private static final String BATTERY_EXTRA_PLUGGED = "plugged"; + + // Last known cell service state + private TelephonyManager mTelephonyManager; + + // Location collector + private ILocationCollector mCollector; + + // Wifi Manager + private WifiManager mWifiManager; + + /** + * A wrapper class holding either an ILocationListener or a PendingIntent to receive + * location updates. + */ + private final class Receiver implements IBinder.DeathRecipient { + final ILocationListener mListener; + final PendingIntent mPendingIntent; + final int mUid; + final Object mKey; + + Receiver(ILocationListener listener, int uid) { + mListener = listener; + mPendingIntent = null; + mUid = uid; + mKey = listener.asBinder(); + } + + Receiver(PendingIntent intent, int uid) { + mPendingIntent = intent; + mListener = null; + mUid = uid; + mKey = intent; + } + + @Override + public boolean equals(Object otherObj) { + if (otherObj instanceof Receiver) { + return mKey.equals( + ((Receiver)otherObj).mKey); + } + return false; + } + + @Override + public int hashCode() { + return mKey.hashCode(); + } + + + @Override + public String toString() { + if (mListener != null) { + return "Receiver{" + + Integer.toHexString(System.identityHashCode(this)) + + " uid " + mUid + " Listener " + mKey + "}"; + } else { + return "Receiver{" + + Integer.toHexString(System.identityHashCode(this)) + + " uid " + mUid + " Intent " + mKey + "}"; + } + } + + public boolean isListener() { + return mListener != null; + } + + public boolean isPendingIntent() { + return mPendingIntent != null; + } + + public ILocationListener getListener() { + if (mListener != null) { + return mListener; + } + throw new IllegalStateException("Request for non-existent listener"); + } + + public PendingIntent getPendingIntent() { + if (mPendingIntent != null) { + return mPendingIntent; + } + throw new IllegalStateException("Request for non-existent intent"); + } + + public boolean callStatusChangedLocked(String provider, int status, Bundle extras) { + if (mListener != null) { + try { + mListener.onStatusChanged(provider, status, extras); + } catch (RemoteException e) { + return false; + } + } else { + Intent statusChanged = new Intent(); + statusChanged.putExtras(extras); + statusChanged.putExtra(LocationManager.KEY_STATUS_CHANGED, status); + try { + mPendingIntent.send(mContext, 0, statusChanged, null, null); + } catch (PendingIntent.CanceledException e) { + return false; + } + } + return true; + } + + public boolean callLocationChangedLocked(Location location) { + if (mListener != null) { + try { + mListener.onLocationChanged(location); + } catch (RemoteException e) { + return false; + } + } else { + Intent locationChanged = new Intent(); + locationChanged.putExtra(LocationManager.KEY_LOCATION_CHANGED, location); + try { + mPendingIntent.send(mContext, 0, locationChanged, null, null); + } catch (PendingIntent.CanceledException e) { + return false; + } + } + return true; + } + + public void binderDied() { + if (Config.LOGD) { + Log.d(TAG, "Location listener died"); + } + synchronized (mLocationListeners) { + removeUpdatesLocked(this); + } + } + } + + private Location readLastKnownLocationLocked(String provider) { + Location location = null; + String s = null; + try { + File f = new File(LocationManager.SYSTEM_DIR + "/location." + + provider); + if (!f.exists()) { + return null; + } + BufferedReader reader = new BufferedReader(new FileReader(f), 256); + s = reader.readLine(); + } catch (IOException e) { + Log.w(TAG, "Unable to read last known location", e); + } + + if (s == null) { + return null; + } + try { + String[] tokens = PATTERN_COMMA.split(s); + int idx = 0; + long time = Long.parseLong(tokens[idx++]); + double latitude = Double.parseDouble(tokens[idx++]); + double longitude = Double.parseDouble(tokens[idx++]); + double altitude = Double.parseDouble(tokens[idx++]); + float bearing = Float.parseFloat(tokens[idx++]); + float speed = Float.parseFloat(tokens[idx++]); + + location = new Location(provider); + location.setTime(time); + location.setLatitude(latitude); + location.setLongitude(longitude); + location.setAltitude(altitude); + location.setBearing(bearing); + location.setSpeed(speed); + } catch (NumberFormatException nfe) { + Log.e(TAG, "NumberFormatException reading last known location", nfe); + return null; + } + + return location; + } + + private void writeLastKnownLocationLocked(String provider, + Location location) { + long now = SystemClock.elapsedRealtime(); + Long last = mLastWriteTime.get(provider); + if ((last != null) + && (now - last.longValue() < MIN_LAST_KNOWN_LOCATION_TIME)) { + return; + } + mLastWriteTime.put(provider, now); + + StringBuilder sb = new StringBuilder(100); + sb.append(location.getTime()); + sb.append(','); + sb.append(location.getLatitude()); + sb.append(','); + sb.append(location.getLongitude()); + sb.append(','); + sb.append(location.getAltitude()); + sb.append(','); + sb.append(location.getBearing()); + sb.append(','); + sb.append(location.getSpeed()); + + FileWriter writer = null; + try { + File d = new File(LocationManager.SYSTEM_DIR); + if (!d.exists()) { + if (!d.mkdirs()) { + Log.w(TAG, "Unable to create directory to write location"); + return; + } + } + File f = new File(LocationManager.SYSTEM_DIR + "/location." + provider); + writer = new FileWriter(f); + writer.write(sb.toString()); + } catch (IOException e) { + Log.w(TAG, "Unable to write location", e); + } finally { + if (writer != null) { + try { + writer.close(); + } catch (IOException e) { + Log.w(TAG, "Exception closing file", e); + } + } + } + } + + /** + * Load providers from /data/location/<provider_name>/ + * class + * kml + * nmea + * track + * location + * properties + */ + private void loadProviders() { + synchronized (mLocationListeners) { + if (sProvidersLoaded) { + return; + } + + // Load providers + loadProvidersLocked(); + sProvidersLoaded = true; + } + } + + private void loadProvidersLocked() { + try { + _loadProvidersLocked(); + } catch (Exception e) { + Log.e(TAG, "Exception loading providers:", e); + } + } + + private void _loadProvidersLocked() { + // Attempt to load "real" providers first + if (GpsLocationProvider.isSupported()) { + // Create a gps location provider + mGpsLocationProvider = new GpsLocationProvider(mContext); + LocationProviderImpl.addProvider(mGpsLocationProvider); + } + + // Load fake providers if real providers are not available + File f = new File(LocationManager.PROVIDER_DIR); + if (f.isDirectory()) { + File[] subdirs = f.listFiles(); + for (int i = 0; i < subdirs.length; i++) { + if (!subdirs[i].isDirectory()) { + continue; + } + + String name = subdirs[i].getName(); + + if (Config.LOGD) { + Log.d(TAG, "Found dir " + subdirs[i].getAbsolutePath()); + Log.d(TAG, "name = " + name); + } + + // Don't create a fake provider if a real provider exists + if (LocationProviderImpl.getProvider(name) == null) { + LocationProviderImpl provider = null; + try { + File classFile = new File(subdirs[i], "class"); + // Look for a 'class' file + provider = LocationProviderImpl.loadFromClass(classFile); + + // Look for an 'kml', 'nmea', or 'track' file + if (provider == null) { + // Load properties from 'properties' file, if present + File propertiesFile = new File(subdirs[i], "properties"); + + if (propertiesFile.exists()) { + provider = new TrackProvider(name); + ((TrackProvider)provider).readProperties(propertiesFile); + + File kmlFile = new File(subdirs[i], "kml"); + if (kmlFile.exists()) { + ((TrackProvider) provider).readKml(kmlFile); + } else { + File nmeaFile = new File(subdirs[i], "nmea"); + if (nmeaFile.exists()) { + ((TrackProvider) provider).readNmea(name, nmeaFile); + } else { + File trackFile = new File(subdirs[i], "track"); + if (trackFile.exists()) { + ((TrackProvider) provider).readTrack(trackFile); + } + } + } + } + } + if (provider != null) { + LocationProviderImpl.addProvider(provider); + } + // Grab the initial location of a TrackProvider and + // store it as the last known location for that provider + if (provider instanceof TrackProvider) { + TrackProvider tp = (TrackProvider) provider; + mLastKnownLocation.put(tp.getName(), tp.getInitialLocation()); + } + } catch (Exception e) { + Log.e(TAG, "Exception loading provder " + name, e); + } + } + } + } + + updateProvidersLocked(); + } + + /** + * @param context the context that the LocationManagerService runs in + */ + public LocationManagerService(Context context) { + super(); + mContext = context; + mLocationHandler = new LocationWorkerHandler(); + + if (Config.LOGD) { + Log.d(TAG, "Constructed LocationManager Service"); + } + + // Alarm manager, needs to be done before calling loadProviders() below + mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); + + // Create a wake lock, needs to be done before calling loadProviders() below + PowerManager powerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE); + mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_KEY); + + // Battery statistics service to be notified when GPS turns on or off + mBatteryStats = BatteryStatsService.getService(); + + // Load providers + loadProviders(); + + // Listen for Radio changes + mTelephonyManager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); + mTelephonyManager.listen(mPhoneStateListener, + PhoneStateListener.LISTEN_CELL_LOCATION | + PhoneStateListener.LISTEN_SIGNAL_STRENGTH | + PhoneStateListener.LISTEN_DATA_CONNECTION_STATE); + + // Register for Network (Wifi or Mobile) updates + NetworkStateBroadcastReceiver networkReceiver = new NetworkStateBroadcastReceiver(); + IntentFilter networkIntentFilter = new IntentFilter(); + networkIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION); + networkIntentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); + networkIntentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); + networkIntentFilter.addAction(GpsLocationProvider.GPS_ENABLED_CHANGE_ACTION); + context.registerReceiver(networkReceiver, networkIntentFilter); + + // Register for power updates + PowerStateBroadcastReceiver powerStateReceiver = new PowerStateBroadcastReceiver(); + IntentFilter intentFilter = new IntentFilter(); + intentFilter.addAction(ALARM_INTENT); + intentFilter.addAction(Intent.ACTION_SCREEN_OFF); + intentFilter.addAction(Intent.ACTION_SCREEN_ON); + intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED); + intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); + intentFilter.addAction(Intent.ACTION_PACKAGE_RESTARTED); + context.registerReceiver(powerStateReceiver, intentFilter); + + // Get the wifi manager + mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); + + // Create a wifi lock for future use + mWifiLock = getWifiWakelockLocked(); + + // There might be an existing wifi scan available + if (mWifiManager != null) { + List<ScanResult> wifiScanResults = mWifiManager.getScanResults(); + if (wifiScanResults != null && wifiScanResults.size() != 0) { + if (mNetworkLocationInterface != null) { + mNetworkLocationInterface.updateWifiScanResults(wifiScanResults); + } + } + } + } + + public void setInstallCallback(InstallCallback callback) { + synchronized (mLocationListeners) { + mLocationHandler.removeMessages(MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER); + Message m = Message.obtain(mLocationHandler, + MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER, callback); + mLocationHandler.sendMessageAtFrontOfQueue(m); + } + } + + public void setNetworkLocationProvider(INetworkLocationProvider provider) { + synchronized (mLocationListeners) { + mNetworkLocationInterface = provider; + provider.addListener(getPackageNames()); + mNetworkLocationProvider = (LocationProviderImpl)provider; + LocationProviderImpl.addProvider(mNetworkLocationProvider); + updateProvidersLocked(); + } + } + + public void setLocationCollector(ILocationCollector collector) { + synchronized (mLocationListeners) { + mCollector = collector; + if (mGpsLocationProvider != null) { + mGpsLocationProvider.setLocationCollector(mCollector); + } + } + } + + private WifiManager.WifiLock getWifiWakelockLocked() { + if (mWifiLock == null && mWifiManager != null) { + mWifiLock = mWifiManager.createWifiLock(WifiManager.WIFI_MODE_SCAN_ONLY, WIFILOCK_KEY); + mWifiLock.setReferenceCounted(false); + } + return mWifiLock; + } + + private boolean isAllowedBySettingsLocked(String provider) { + if (mEnabledProviders.contains(provider)) { + return true; + } + if (mDisabledProviders.contains(provider)) { + return false; + } + // Use system settings + ContentResolver resolver = mContext.getContentResolver(); + String allowedProviders = Settings.Secure.getString(resolver, + Settings.Secure.LOCATION_PROVIDERS_ALLOWED); + + return ((allowedProviders != null) && (allowedProviders.contains(provider))); + } + + private void checkPermissionsSafe(String provider) { + if (LocationManager.GPS_PROVIDER.equals(provider) + && (mContext.checkCallingPermission(ACCESS_FINE_LOCATION) + != PackageManager.PERMISSION_GRANTED)) { + throw new SecurityException("Requires ACCESS_FINE_LOCATION permission"); + } + if (LocationManager.NETWORK_PROVIDER.equals(provider) + && (mContext.checkCallingPermission(ACCESS_FINE_LOCATION) + != PackageManager.PERMISSION_GRANTED) + && (mContext.checkCallingPermission(ACCESS_COARSE_LOCATION) + != PackageManager.PERMISSION_GRANTED)) { + throw new SecurityException( + "Requires ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION permission"); + } + } + + private boolean isAllowedProviderSafe(String provider) { + if (LocationManager.GPS_PROVIDER.equals(provider) + && (mContext.checkCallingPermission(ACCESS_FINE_LOCATION) + != PackageManager.PERMISSION_GRANTED)) { + return false; + } + if (LocationManager.NETWORK_PROVIDER.equals(provider) + && (mContext.checkCallingPermission(ACCESS_FINE_LOCATION) + != PackageManager.PERMISSION_GRANTED) + && (mContext.checkCallingPermission(ACCESS_COARSE_LOCATION) + != PackageManager.PERMISSION_GRANTED)) { + return false; + } + + return true; + } + + private String[] getPackageNames() { + // Since a single UID may correspond to multiple packages, this can only be used as an + // approximation for tracking + return mContext.getPackageManager().getPackagesForUid(Binder.getCallingUid()); + } + + public List<String> getAllProviders() { + try { + synchronized (mLocationListeners) { + return _getAllProvidersLocked(); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "getAllProviders got exception:", e); + return null; + } + } + + private List<String> _getAllProvidersLocked() { + if (Config.LOGD) { + Log.d(TAG, "getAllProviders"); + } + List<LocationProviderImpl> providers = LocationProviderImpl.getProviders(); + ArrayList<String> out = new ArrayList<String>(providers.size()); + + for (LocationProviderImpl p : providers) { + out.add(p.getName()); + } + return out; + } + + public List<String> getProviders(boolean enabledOnly) { + try { + synchronized (mLocationListeners) { + return _getProvidersLocked(enabledOnly); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "getProviders gotString exception:", e); + return null; + } + } + + private List<String> _getProvidersLocked(boolean enabledOnly) { + if (Config.LOGD) { + Log.d(TAG, "getProviders"); + } + List<LocationProviderImpl> providers = LocationProviderImpl.getProviders(); + ArrayList<String> out = new ArrayList<String>(); + + for (LocationProviderImpl p : providers) { + String name = p.getName(); + if (isAllowedProviderSafe(name)) { + if (enabledOnly && !isAllowedBySettingsLocked(name)) { + continue; + } + out.add(name); + } + } + return out; + } + + public void updateProviders() { + synchronized (mLocationListeners) { + updateProvidersLocked(); + } + } + + private void updateProvidersLocked() { + for (LocationProviderImpl p : LocationProviderImpl.getProviders()) { + boolean isEnabled = p.isEnabled(); + String name = p.getName(); + boolean shouldBeEnabled = isAllowedBySettingsLocked(name); + + // Collection is only allowed when network provider is being used + if (mCollector != null && + p.getName().equals(LocationManager.NETWORK_PROVIDER)) { + mCollector.updateNetworkProviderStatus(shouldBeEnabled); + } + + if (isEnabled && !shouldBeEnabled) { + updateProviderListenersLocked(name, false); + } else if (!isEnabled && shouldBeEnabled) { + updateProviderListenersLocked(name, true); + } + + } + } + + private void updateProviderListenersLocked(String provider, boolean enabled) { + int listeners = 0; + + LocationProviderImpl p = LocationProviderImpl.getProvider(provider); + if (p == null) { + return; + } + + ArrayList<Receiver> deadReceivers = null; + + ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); + if (records != null) { + final int N = records.size(); + for (int i=0; i<N; i++) { + UpdateRecord record = records.get(i); + // Sends a notification message to the receiver + try { + Receiver receiver = record.mReceiver; + if (receiver.isListener()) { + if (enabled) { + receiver.getListener().onProviderEnabled(provider); + } else { + receiver.getListener().onProviderDisabled(provider); + } + } else { + Intent providerIntent = new Intent(); + providerIntent.putExtra(LocationManager.KEY_PROVIDER_ENABLED, enabled); + try { + receiver.getPendingIntent().send(mContext, 0, + providerIntent, null, null); + } catch (PendingIntent.CanceledException e) { + if (deadReceivers == null) { + deadReceivers = new ArrayList<Receiver>(); + deadReceivers.add(receiver); + } + } + } + } catch (RemoteException e) { + // The death link will clean this up. + } + listeners++; + } + } + + if (deadReceivers != null) { + for (int i=deadReceivers.size()-1; i>=0; i--) { + removeUpdatesLocked(deadReceivers.get(i)); + } + } + + if (enabled) { + p.enable(); + if (listeners > 0) { + p.setMinTime(getMinTimeLocked(provider)); + p.enableLocationTracking(true); + updateWakelockStatusLocked(mScreenOn); + } + } else { + p.enableLocationTracking(false); + if (p == mGpsLocationProvider) { + mGpsNavigating = false; + reportStopGpsLocked(); + } + p.disable(); + updateWakelockStatusLocked(mScreenOn); + } + + if (enabled && listeners > 0) { + mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider); + Message m = Message.obtain(mLocationHandler, MESSAGE_HEARTBEAT, provider); + mLocationHandler.sendMessageAtTime(m, SystemClock.uptimeMillis() + 1000); + } else { + mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider); + } + } + + private long getMinTimeLocked(String provider) { + long minTime = Long.MAX_VALUE; + ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); + if (records != null) { + for (int i=records.size()-1; i>=0; i--) { + minTime = Math.min(minTime, records.get(i).mMinTime); + } + } + return minTime; + } + + private class UpdateRecord { + final String mProvider; + final Receiver mReceiver; + final long mMinTime; + final float mMinDistance; + final int mUid; + final String[] mPackages; + + /** + * Note: must be constructed with lock held. + */ + UpdateRecord(String provider, long minTime, float minDistance, + Receiver receiver, int uid, String[] packages) { + mProvider = provider; + mReceiver = receiver; + mMinTime = minTime; + mMinDistance = minDistance; + mUid = uid; + mPackages = packages; + + ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); + if (records == null) { + records = new ArrayList<UpdateRecord>(); + mRecordsByProvider.put(provider, records); + } + if (!records.contains(this)) { + records.add(this); + } + } + + /** + * Method to be called when a record will no longer be used. Calling this multiple times + * must have the same effect as calling it once. + */ + void disposeLocked() { + ArrayList<UpdateRecord> records = mRecordsByProvider.get(this.mProvider); + records.remove(this); + } + + @Override + public String toString() { + return "UpdateRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + mProvider + " " + mReceiver + "}"; + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "mProvider=" + mProvider + " mReceiver=" + mReceiver); + pw.println(prefix + "mMinTime=" + mMinTime + " mMinDistance=" + mMinDistance); + StringBuilder sb = new StringBuilder(); + if (mPackages != null) { + for (int i=0; i<mPackages.length; i++) { + if (i > 0) sb.append(", "); + sb.append(mPackages[i]); + } + } + pw.println(prefix + "mUid=" + mUid + " mPackages=" + sb); + } + + /** + * Calls dispose(). + */ + @Override protected void finalize() { + synchronized (mLocationListeners) { + disposeLocked(); + } + } + } + + public void requestLocationUpdates(String provider, + long minTime, float minDistance, ILocationListener listener) { + + try { + synchronized (mLocationListeners) { + requestLocationUpdatesLocked(provider, minTime, minDistance, + new Receiver(listener, Binder.getCallingUid())); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "requestUpdates got exception:", e); + } + } + + public void requestLocationUpdatesPI(String provider, + long minTime, float minDistance, PendingIntent intent) { + try { + synchronized (mLocationListeners) { + requestLocationUpdatesLocked(provider, minTime, minDistance, + new Receiver(intent, Binder.getCallingUid())); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "requestUpdates got exception:", e); + } + } + + private void requestLocationUpdatesLocked(String provider, + long minTime, float minDistance, Receiver receiver) { + if (Config.LOGD) { + Log.d(TAG, "_requestLocationUpdates: listener = " + receiver); + } + + LocationProviderImpl impl = LocationProviderImpl.getProvider(provider); + if (impl == null) { + throw new IllegalArgumentException("provider=" + provider); + } + + checkPermissionsSafe(provider); + + String[] packages = getPackageNames(); + + // so wakelock calls will succeed + final int callingUid = Binder.getCallingUid(); + long identity = Binder.clearCallingIdentity(); + try { + UpdateRecord r = new UpdateRecord(provider, minTime, minDistance, + receiver, callingUid, packages); + if (!mListeners.contains(receiver)) { + try { + if (receiver.isListener()) { + receiver.getListener().asBinder().linkToDeath(receiver, 0); + } + mListeners.add(receiver); + } catch (RemoteException e) { + return; + } + } + + HashMap<String,UpdateRecord> records = mLocationListeners.get(receiver); + if (records == null) { + records = new HashMap<String,UpdateRecord>(); + mLocationListeners.put(receiver, records); + } + UpdateRecord oldRecord = records.put(provider, r); + if (oldRecord != null) { + oldRecord.disposeLocked(); + } + + boolean isProviderEnabled = isAllowedBySettingsLocked(provider); + if (isProviderEnabled) { + long minTimeForProvider = getMinTimeLocked(provider); + impl.setMinTime(minTimeForProvider); + impl.enableLocationTracking(true); + updateWakelockStatusLocked(mScreenOn); + + if (provider.equals(LocationManager.GPS_PROVIDER)) { + if (mGpsNavigating) { + updateReportedGpsLocked(); + } + } + + // Clear heartbeats if any before starting a new one + mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider); + Message m = Message.obtain(mLocationHandler, MESSAGE_HEARTBEAT, provider); + mLocationHandler.sendMessageAtTime(m, SystemClock.uptimeMillis() + 1000); + } else { + try { + // Notify the listener that updates are currently disabled + if (receiver.isListener()) { + receiver.getListener().onProviderDisabled(provider); + } + } catch(RemoteException e) { + Log.w(TAG, "RemoteException calling onProviderDisabled on " + + receiver.getListener()); + } + } + } finally { + Binder.restoreCallingIdentity(identity); + } + } + + public void removeUpdates(ILocationListener listener) { + try { + synchronized (mLocationListeners) { + removeUpdatesLocked(new Receiver(listener, Binder.getCallingUid())); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "removeUpdates got exception:", e); + } + } + + public void removeUpdatesPI(PendingIntent intent) { + try { + synchronized (mLocationListeners) { + removeUpdatesLocked(new Receiver(intent, Binder.getCallingUid())); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "removeUpdates got exception:", e); + } + } + + private void removeUpdatesLocked(Receiver receiver) { + if (Config.LOGD) { + Log.d(TAG, "_removeUpdates: listener = " + receiver); + } + + // so wakelock calls will succeed + final int callingUid = Binder.getCallingUid(); + long identity = Binder.clearCallingIdentity(); + try { + int idx = mListeners.indexOf(receiver); + if (idx >= 0) { + Receiver myReceiver = mListeners.remove(idx); + if (myReceiver.isListener()) { + myReceiver.getListener().asBinder().unlinkToDeath(myReceiver, 0); + } + } + + // Record which providers were associated with this listener + HashSet<String> providers = new HashSet<String>(); + HashMap<String,UpdateRecord> oldRecords = mLocationListeners.get(receiver); + if (oldRecords != null) { + // Call dispose() on the obsolete update records. + for (UpdateRecord record : oldRecords.values()) { + if (record.mProvider.equals(LocationManager.NETWORK_PROVIDER)) { + if (mNetworkLocationInterface != null) { + mNetworkLocationInterface.removeListener(record.mPackages); + } + } + record.disposeLocked(); + } + // Accumulate providers + providers.addAll(oldRecords.keySet()); + } + + mLocationListeners.remove(receiver); + mLastFixBroadcast.remove(receiver); + mLastStatusBroadcast.remove(receiver); + + // See if the providers associated with this listener have any + // other listeners; if one does, inform it of the new smallest minTime + // value; if one does not, disable location tracking for it + for (String provider : providers) { + // If provider is already disabled, don't need to do anything + if (!isAllowedBySettingsLocked(provider)) { + continue; + } + + boolean hasOtherListener = false; + ArrayList<UpdateRecord> recordsForProvider = mRecordsByProvider.get(provider); + if (recordsForProvider != null && recordsForProvider.size() > 0) { + hasOtherListener = true; + } + + LocationProviderImpl p = LocationProviderImpl.getProvider(provider); + if (p != null) { + if (hasOtherListener) { + p.setMinTime(getMinTimeLocked(provider)); + } else { + mLocationHandler.removeMessages(MESSAGE_HEARTBEAT, provider); + p.enableLocationTracking(false); + } + + if (p == mGpsLocationProvider && mGpsNavigating) { + updateReportedGpsLocked(); + } + } + } + + updateWakelockStatusLocked(mScreenOn); + } finally { + Binder.restoreCallingIdentity(identity); + } + } + + public boolean addGpsStatusListener(IGpsStatusListener listener) { + if (mGpsLocationProvider == null) { + return false; + } + if (mContext.checkCallingPermission(ACCESS_FINE_LOCATION) != + PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires ACCESS_FINE_LOCATION permission"); + } + + try { + mGpsLocationProvider.addGpsStatusListener(listener); + } catch (RemoteException e) { + Log.w(TAG, "RemoteException in addGpsStatusListener"); + return false; + } + return true; + } + + public void removeGpsStatusListener(IGpsStatusListener listener) { + synchronized (mLocationListeners) { + mGpsLocationProvider.removeGpsStatusListener(listener); + } + } + + public boolean sendExtraCommand(String provider, String command, Bundle extras) { + // first check for permission to the provider + checkPermissionsSafe(provider); + // and check for ACCESS_LOCATION_EXTRA_COMMANDS + if ((mContext.checkCallingPermission(ACCESS_LOCATION_EXTRA_COMMANDS) + != PackageManager.PERMISSION_GRANTED)) { + throw new SecurityException("Requires ACCESS_LOCATION_EXTRA_COMMANDS permission"); + } + + synchronized (mLocationListeners) { + LocationProviderImpl impl = LocationProviderImpl.getProvider(provider); + if (provider == null) { + return false; + } + + return impl.sendExtraCommand(command, extras); + } + } + + class ProximityAlert { + final int mUid; + final double mLatitude; + final double mLongitude; + final float mRadius; + final long mExpiration; + final PendingIntent mIntent; + final Location mLocation; + + public ProximityAlert(int uid, double latitude, double longitude, + float radius, long expiration, PendingIntent intent) { + mUid = uid; + mLatitude = latitude; + mLongitude = longitude; + mRadius = radius; + mExpiration = expiration; + mIntent = intent; + + mLocation = new Location(""); + mLocation.setLatitude(latitude); + mLocation.setLongitude(longitude); + } + + long getExpiration() { + return mExpiration; + } + + PendingIntent getIntent() { + return mIntent; + } + + boolean isInProximity(double latitude, double longitude) { + Location loc = new Location(""); + loc.setLatitude(latitude); + loc.setLongitude(longitude); + + double radius = loc.distanceTo(mLocation); + return radius <= mRadius; + } + + @Override + public String toString() { + return "ProximityAlert{" + + Integer.toHexString(System.identityHashCode(this)) + + " uid " + mUid + mIntent + "}"; + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "mLatitude=" + mLatitude + " mLongitude=" + mLongitude); + pw.println(prefix + "mRadius=" + mRadius + " mExpiration=" + mExpiration); + pw.println(prefix + "mIntent=" + mIntent); + pw.println(prefix + "mLocation:"); + mLocation.dump(new PrintWriterPrinter(pw), prefix + " "); + } + } + + // Listener for receiving locations to trigger proximity alerts + class ProximityListener extends ILocationListener.Stub { + + boolean isGpsAvailable = false; + + // Note: this is called with the lock held. + public void onLocationChanged(Location loc) { + + // If Gps is available, then ignore updates from NetworkLocationProvider + if (loc.getProvider().equals(LocationManager.GPS_PROVIDER)) { + isGpsAvailable = true; + } + if (isGpsAvailable && loc.getProvider().equals(LocationManager.NETWORK_PROVIDER)) { + return; + } + + // Process proximity alerts + long now = System.currentTimeMillis(); + double latitude = loc.getLatitude(); + double longitude = loc.getLongitude(); + ArrayList<PendingIntent> intentsToRemove = null; + + for (ProximityAlert alert : mProximityAlerts.values()) { + PendingIntent intent = alert.getIntent(); + long expiration = alert.getExpiration(); + + if ((expiration == -1) || (now <= expiration)) { + boolean entered = mProximitiesEntered.contains(alert); + boolean inProximity = + alert.isInProximity(latitude, longitude); + if (!entered && inProximity) { + if (Config.LOGD) { + Log.i(TAG, "Entered alert"); + } + mProximitiesEntered.add(alert); + Intent enteredIntent = new Intent(); + enteredIntent.putExtra(LocationManager.KEY_PROXIMITY_ENTERING, true); + try { + intent.send(mContext, 0, enteredIntent, null, null); + } catch (PendingIntent.CanceledException e) { + if (Config.LOGD) { + Log.i(TAG, "Canceled proximity alert: " + alert, e); + } + if (intentsToRemove == null) { + intentsToRemove = new ArrayList<PendingIntent>(); + } + intentsToRemove.add(intent); + } + } else if (entered && !inProximity) { + if (Config.LOGD) { + Log.i(TAG, "Exited alert"); + } + mProximitiesEntered.remove(alert); + Intent exitedIntent = new Intent(); + exitedIntent.putExtra(LocationManager.KEY_PROXIMITY_ENTERING, false); + try { + intent.send(mContext, 0, exitedIntent, null, null); + } catch (PendingIntent.CanceledException e) { + if (Config.LOGD) { + Log.i(TAG, "Canceled proximity alert: " + alert, e); + } + if (intentsToRemove == null) { + intentsToRemove = new ArrayList<PendingIntent>(); + } + intentsToRemove.add(intent); + } + } + } else { + // Mark alert for expiration + if (Config.LOGD) { + Log.i(TAG, "Expiring proximity alert: " + alert); + } + if (intentsToRemove == null) { + intentsToRemove = new ArrayList<PendingIntent>(); + } + intentsToRemove.add(alert.getIntent()); + } + } + + // Remove expired alerts + if (intentsToRemove != null) { + for (PendingIntent i : intentsToRemove) { + mProximityAlerts.remove(i); + ProximityAlert alert = mProximityAlerts.get(i); + mProximitiesEntered.remove(alert); + } + } + + } + + // Note: this is called with the lock held. + public void onProviderDisabled(String provider) { + if (provider.equals(LocationManager.GPS_PROVIDER)) { + isGpsAvailable = false; + } + } + + // Note: this is called with the lock held. + public void onProviderEnabled(String provider) { + // ignore + } + + // Note: this is called with the lock held. + public void onStatusChanged(String provider, int status, Bundle extras) { + if ((provider.equals(LocationManager.GPS_PROVIDER)) && + (status != LocationProvider.AVAILABLE)) { + isGpsAvailable = false; + } + } + } + + public void addProximityAlert(double latitude, double longitude, + float radius, long expiration, PendingIntent intent) { + try { + synchronized (mLocationListeners) { + addProximityAlertLocked(latitude, longitude, radius, expiration, intent); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "addProximityAlert got exception:", e); + } + } + + private void addProximityAlertLocked(double latitude, double longitude, + float radius, long expiration, PendingIntent intent) { + if (Config.LOGD) { + Log.d(TAG, "addProximityAlert: latitude = " + latitude + + ", longitude = " + longitude + + ", expiration = " + expiration + + ", intent = " + intent); + } + + // Require ability to access all providers for now + if (!isAllowedProviderSafe(LocationManager.GPS_PROVIDER) || + !isAllowedProviderSafe(LocationManager.NETWORK_PROVIDER)) { + throw new SecurityException("Requires ACCESS_FINE_LOCATION permission"); + } + + if (expiration != -1) { + expiration += System.currentTimeMillis(); + } + ProximityAlert alert = new ProximityAlert(Binder.getCallingUid(), + latitude, longitude, radius, expiration, intent); + mProximityAlerts.put(intent, alert); + + if (mProximityListener == null) { + mProximityListener = new Receiver(new ProximityListener(), -1); + + LocationProvider provider = LocationProviderImpl.getProvider( + LocationManager.GPS_PROVIDER); + if (provider != null) { + requestLocationUpdatesLocked(provider.getName(), 1000L, 1.0f, mProximityListener); + } + + provider = + LocationProviderImpl.getProvider(LocationManager.NETWORK_PROVIDER); + if (provider != null) { + requestLocationUpdatesLocked(provider.getName(), 1000L, 1.0f, mProximityListener); + } + } else if (mGpsNavigating) { + updateReportedGpsLocked(); + } + } + + public void removeProximityAlert(PendingIntent intent) { + try { + synchronized (mLocationListeners) { + removeProximityAlertLocked(intent); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "removeProximityAlert got exception:", e); + } + } + + private void removeProximityAlertLocked(PendingIntent intent) { + if (Config.LOGD) { + Log.d(TAG, "removeProximityAlert: intent = " + intent); + } + + mProximityAlerts.remove(intent); + if (mProximityAlerts.size() == 0) { + removeUpdatesLocked(mProximityListener); + mProximityListener = null; + } else if (mGpsNavigating) { + updateReportedGpsLocked(); + } + } + + /** + * @return null if the provider does not exits + * @throw SecurityException if the provider is not allowed to be + * accessed by the caller + */ + public Bundle getProviderInfo(String provider) { + try { + synchronized (mLocationListeners) { + return _getProviderInfoLocked(provider); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "_getProviderInfo got exception:", e); + return null; + } + } + + private Bundle _getProviderInfoLocked(String provider) { + LocationProviderImpl p = LocationProviderImpl.getProvider(provider); + if (p == null) { + return null; + } + + checkPermissionsSafe(provider); + + Bundle b = new Bundle(); + b.putBoolean("network", p.requiresNetwork()); + b.putBoolean("satellite", p.requiresSatellite()); + b.putBoolean("cell", p.requiresCell()); + b.putBoolean("cost", p.hasMonetaryCost()); + b.putBoolean("altitude", p.supportsAltitude()); + b.putBoolean("speed", p.supportsSpeed()); + b.putBoolean("bearing", p.supportsBearing()); + b.putInt("power", p.getPowerRequirement()); + b.putInt("accuracy", p.getAccuracy()); + + return b; + } + + public boolean isProviderEnabled(String provider) { + try { + synchronized (mLocationListeners) { + return _isProviderEnabledLocked(provider); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "isProviderEnabled got exception:", e); + return false; + } + } + + private boolean _isProviderEnabledLocked(String provider) { + checkPermissionsSafe(provider); + + LocationProviderImpl p = LocationProviderImpl.getProvider(provider); + if (p == null) { + throw new IllegalArgumentException("provider=" + provider); + } + return isAllowedBySettingsLocked(provider); + } + + public Location getLastKnownLocation(String provider) { + try { + synchronized (mLocationListeners) { + return _getLastKnownLocationLocked(provider); + } + } catch (SecurityException se) { + throw se; + } catch (Exception e) { + Log.e(TAG, "getLastKnownLocation got exception:", e); + return null; + } + } + + private Location _getLastKnownLocationLocked(String provider) { + checkPermissionsSafe(provider); + + LocationProviderImpl p = LocationProviderImpl.getProvider(provider); + if (p == null) { + throw new IllegalArgumentException("provider=" + provider); + } + + if (!isAllowedBySettingsLocked(provider)) { + return null; + } + + Location location = mLastKnownLocation.get(provider); + if (location == null) { + // Get the persistent last known location for the provider + location = readLastKnownLocationLocked(provider); + if (location != null) { + mLastKnownLocation.put(provider, location); + } + } + + return location; + } + + private static boolean shouldBroadcastSafe(Location loc, Location lastLoc, UpdateRecord record) { + // Always broadcast the first update + if (lastLoc == null) { + return true; + } + + // Don't broadcast same location again regardless of condition + // TODO - we should probably still rebroadcast if user explicitly sets a minTime > 0 + if (loc.getTime() == lastLoc.getTime()) { + return false; + } + + // Check whether sufficient distance has been traveled + double minDistance = record.mMinDistance; + if (minDistance > 0.0) { + if (loc.distanceTo(lastLoc) <= minDistance) { + return false; + } + } + + return true; + } + + private void handleLocationChangedLocked(String provider) { + ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); + if (records == null || records.size() == 0) { + return; + } + + LocationProviderImpl p = LocationProviderImpl.getProvider(provider); + if (p == null) { + return; + } + + // Get location object + Location loc = mLocationsByProvider.get(provider); + if (loc == null) { + loc = new Location(provider); + mLocationsByProvider.put(provider, loc); + } else { + loc.reset(); + } + + // Use the mock location if available + Location mockLoc = mMockProviderLocation.get(provider); + boolean locationValid; + if (mockLoc != null) { + locationValid = true; + loc.set(mockLoc); + } else { + locationValid = p.getLocation(loc); + } + + // Update last known location for provider + if (locationValid) { + Location location = mLastKnownLocation.get(provider); + if (location == null) { + mLastKnownLocation.put(provider, new Location(loc)); + } else { + location.set(loc); + } + writeLastKnownLocationLocked(provider, loc); + + if (p instanceof INetworkLocationProvider) { + mWakeLockNetworkReceived = true; + } else if (p instanceof GpsLocationProvider) { + // Gps location received signal is in NetworkStateBroadcastReceiver + } + } + + // Fetch latest status update time + long newStatusUpdateTime = p.getStatusUpdateTime(); + + // Override real time with mock time if present + Long mockStatusUpdateTime = mMockProviderStatusUpdateTime.get(provider); + if (mockStatusUpdateTime != null) { + newStatusUpdateTime = mockStatusUpdateTime.longValue(); + } + + // Get latest status + Bundle extras = new Bundle(); + int status = p.getStatus(extras); + + // Override status with mock status if present + Integer mockStatus = mMockProviderStatus.get(provider); + if (mockStatus != null) { + status = mockStatus.intValue(); + } + + // Override extras with mock extras if present + Bundle mockExtras = mMockProviderStatusExtras.get(provider); + if (mockExtras != null) { + extras.clear(); + extras.putAll(mockExtras); + } + + ArrayList<Receiver> deadReceivers = null; + + // Broadcast location or status to all listeners + final int N = records.size(); + for (int i=0; i<N; i++) { + UpdateRecord r = records.get(i); + Receiver receiver = r.mReceiver; + + // Broadcast location only if it is valid + if (locationValid) { + HashMap<String,Location> map = mLastFixBroadcast.get(receiver); + if (map == null) { + map = new HashMap<String,Location>(); + mLastFixBroadcast.put(receiver, map); + } + Location lastLoc = map.get(provider); + if ((lastLoc == null) || shouldBroadcastSafe(loc, lastLoc, r)) { + if (lastLoc == null) { + lastLoc = new Location(loc); + map.put(provider, lastLoc); + } else { + lastLoc.set(loc); + } + if (!receiver.callLocationChangedLocked(loc)) { + Log.w(TAG, "RemoteException calling onLocationChanged on " + receiver); + if (deadReceivers == null) { + deadReceivers = new ArrayList<Receiver>(); + } + deadReceivers.add(receiver); + } + } + } + + // Broadcast status message + HashMap<String,Long> statusMap = mLastStatusBroadcast.get(receiver); + if (statusMap == null) { + statusMap = new HashMap<String,Long>(); + mLastStatusBroadcast.put(receiver, statusMap); + } + long prevStatusUpdateTime = + (statusMap.get(provider) != null) ? statusMap.get(provider) : 0; + + if ((newStatusUpdateTime > prevStatusUpdateTime) && + (prevStatusUpdateTime != 0 || status != LocationProvider.AVAILABLE)) { + + statusMap.put(provider, newStatusUpdateTime); + if (!receiver.callStatusChangedLocked(provider, status, extras)) { + Log.w(TAG, "RemoteException calling onStatusChanged on " + receiver); + if (deadReceivers == null) { + deadReceivers = new ArrayList<Receiver>(); + } + if (!deadReceivers.contains(receiver)) { + deadReceivers.add(receiver); + } + } + } + } + + if (deadReceivers != null) { + for (int i=deadReceivers.size()-1; i>=0; i--) { + removeUpdatesLocked(deadReceivers.get(i)); + } + } + } + + private class LocationWorkerHandler extends Handler { + + @Override + public void handleMessage(Message msg) { + try { + if (msg.what == MESSAGE_HEARTBEAT) { + // log("LocationWorkerHandler: Heartbeat!"); + + synchronized (mLocationListeners) { + String provider = (String) msg.obj; + if (!isAllowedBySettingsLocked(provider)) { + return; + } + + // Process the location fix if the screen is on or we're holding a wakelock + if (mScreenOn || (mWakeLockAcquireTime != 0)) { + handleLocationChangedLocked(provider); + } + + // If it continues to have listeners + ArrayList<UpdateRecord> records = mRecordsByProvider.get(provider); + if (records != null && records.size() > 0) { + Message m = Message.obtain(this, MESSAGE_HEARTBEAT, provider); + sendMessageAtTime(m, SystemClock.uptimeMillis() + 1000); + } + + if ((mWakeLockAcquireTime != 0) && + (SystemClock.elapsedRealtime() - mWakeLockAcquireTime + > MAX_TIME_FOR_WAKE_LOCK)) { + + removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK); + removeMessages(MESSAGE_RELEASE_WAKE_LOCK); + + log("LocationWorkerHandler: Exceeded max time for wake lock"); + Message m = Message.obtain(this, MESSAGE_RELEASE_WAKE_LOCK); + sendMessageAtFrontOfQueue(m); + + } else if (mWakeLockAcquireTime != 0 && + mWakeLockGpsReceived && mWakeLockNetworkReceived) { + + removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK); + removeMessages(MESSAGE_RELEASE_WAKE_LOCK); + + log("LocationWorkerHandler: Locations received."); + mWakeLockAcquireTime = 0; + Message m = Message.obtain(this, MESSAGE_RELEASE_WAKE_LOCK); + sendMessageDelayed(m, TIME_AFTER_WAKE_LOCK); + } + } + + } else if (msg.what == MESSAGE_ACQUIRE_WAKE_LOCK) { + log("LocationWorkerHandler: Acquire"); + synchronized (mLocationListeners) { + acquireWakeLockLocked(); + } + } else if (msg.what == MESSAGE_RELEASE_WAKE_LOCK) { + log("LocationWorkerHandler: Release"); + + // Update wakelock status so the next alarm is set before releasing wakelock + synchronized (mLocationListeners) { + updateWakelockStatusLocked(mScreenOn); + releaseWakeLockLocked(); + } + } else if (msg.what == MESSAGE_INSTALL_NETWORK_LOCATION_PROVIDER) { + synchronized (mLocationListeners) { + Log.d(TAG, "installing network location provider"); + INetworkLocationManager.InstallCallback callback = + (INetworkLocationManager.InstallCallback)msg.obj; + callback.installNetworkLocationProvider(LocationManagerService.this); + } + } + } catch (Exception e) { + // Log, don't crash! + Log.e(TAG, "Exception in LocationWorkerHandler.handleMessage:", e); + } + } + } + + class CellLocationUpdater extends Thread { + CellLocation mNextLocation; + + CellLocationUpdater() { + super("CellLocationUpdater"); + } + + @Override + public void run() { + int curAsu = -1; + CellLocation curLocation = null; + + while (true) { + // See if there is more work to do... + synchronized (mLocationListeners) { + if (curLocation == mNextLocation) { + mCellLocationUpdater = null; + break; + } + + curLocation = mNextLocation; + if (curLocation == null) { + mCellLocationUpdater = null; + break; + } + + curAsu = mLastSignalStrength; + + mNextLocation = null; + } + + try { + // Gets cell state. This can block so must be done without + // locks held. + CellState cs = new CellState(mTelephonyManager, curLocation, curAsu); + + synchronized (mLocationListeners) { + mLastCellState = cs; + + cs.updateSignalStrength(mLastSignalStrength); + cs.updateRadioType(mLastRadioType); + + // Notify collector + if (mCollector != null) { + mCollector.updateCellState(cs); + } + + // Updates providers + List<LocationProviderImpl> providers = LocationProviderImpl.getProviders(); + for (LocationProviderImpl provider : providers) { + if (provider.requiresCell()) { + provider.updateCellState(cs); + } + } + } + } catch (RuntimeException e) { + Log.e(TAG, "Exception in PhoneStateListener.onCellLocationChanged:", e); + } + } + } + } + + CellLocationUpdater mCellLocationUpdater = null; + CellState mLastCellState = null; + int mLastSignalStrength = -1; + int mLastRadioType = -1; + + PhoneStateListener mPhoneStateListener = new PhoneStateListener() { + + @Override + public void onCellLocationChanged(CellLocation cellLocation) { + synchronized (mLocationListeners) { + if (mCellLocationUpdater == null) { + mCellLocationUpdater = new CellLocationUpdater(); + mCellLocationUpdater.start(); + } + mCellLocationUpdater.mNextLocation = cellLocation; + } + } + + @Override + public void onSignalStrengthChanged(int asu) { + synchronized (mLocationListeners) { + mLastSignalStrength = asu; + + if (mLastCellState != null) { + mLastCellState.updateSignalStrength(asu); + } + } + } + + @Override + public void onDataConnectionStateChanged(int state) { + synchronized (mLocationListeners) { + // Get radio type + int radioType = mTelephonyManager.getNetworkType(); + if (radioType == TelephonyManager.NETWORK_TYPE_GPRS || + radioType == TelephonyManager.NETWORK_TYPE_EDGE) { + radioType = CellState.RADIO_TYPE_GPRS; + } else if (radioType == TelephonyManager.NETWORK_TYPE_UMTS) { + radioType = CellState.RADIO_TYPE_WCDMA; + } + mLastRadioType = radioType; + + if (mLastCellState != null) { + mLastCellState.updateRadioType(radioType); + } + } + } + }; + + private class PowerStateBroadcastReceiver extends BroadcastReceiver { + @Override public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + + if (action.equals(ALARM_INTENT)) { + synchronized (mLocationListeners) { + log("PowerStateBroadcastReceiver: Alarm received"); + mLocationHandler.removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK); + // Have to do this immediately, rather than posting a + // message, so we execute our code while the system + // is holding a wake lock until the alarm broadcast + // is finished. + acquireWakeLockLocked(); + } + + } else if (action.equals(Intent.ACTION_SCREEN_OFF)) { + log("PowerStateBroadcastReceiver: Screen off"); + synchronized (mLocationListeners) { + updateWakelockStatusLocked(false); + } + + } else if (action.equals(Intent.ACTION_SCREEN_ON)) { + log("PowerStateBroadcastReceiver: Screen on"); + synchronized (mLocationListeners) { + updateWakelockStatusLocked(true); + } + + } else if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { + log("PowerStateBroadcastReceiver: Battery changed"); + synchronized (mLocationListeners) { + int scale = intent.getIntExtra(BATTERY_EXTRA_SCALE, 100); + int level = intent.getIntExtra(BATTERY_EXTRA_LEVEL, 0); + boolean plugged = intent.getIntExtra(BATTERY_EXTRA_PLUGGED, 0) != 0; + + // Notify collector battery state + if (mCollector != null) { + mCollector.updateBatteryState(scale, level, plugged); + } + } + } else if (action.equals(Intent.ACTION_PACKAGE_REMOVED) + || action.equals(Intent.ACTION_PACKAGE_RESTARTED)) { + synchronized (mLocationListeners) { + int uid = intent.getIntExtra(Intent.EXTRA_UID, -1); + if (uid >= 0) { + ArrayList<Receiver> removedRecs = null; + for (ArrayList<UpdateRecord> i : mRecordsByProvider.values()) { + for (int j=i.size()-1; j>=0; j--) { + UpdateRecord ur = i.get(j); + if (ur.mReceiver.isPendingIntent() && ur.mUid == uid) { + if (removedRecs == null) { + removedRecs = new ArrayList<Receiver>(); + } + if (!removedRecs.contains(ur.mReceiver)) { + removedRecs.add(ur.mReceiver); + } + } + } + } + ArrayList<ProximityAlert> removedAlerts = null; + for (ProximityAlert i : mProximityAlerts.values()) { + if (i.mUid == uid) { + if (removedAlerts == null) { + removedAlerts = new ArrayList<ProximityAlert>(); + } + if (!removedAlerts.contains(i)) { + removedAlerts.add(i); + } + } + } + if (removedRecs != null) { + for (int i=removedRecs.size()-1; i>=0; i--) { + removeUpdatesLocked(removedRecs.get(i)); + } + } + if (removedAlerts != null) { + for (int i=removedAlerts.size()-1; i>=0; i--) { + removeProximityAlertLocked(removedAlerts.get(i).mIntent); + } + } + } + } + } + } + } + + private class NetworkStateBroadcastReceiver extends BroadcastReceiver { + @Override public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + + if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) { + + List<ScanResult> wifiScanResults = mWifiManager.getScanResults(); + + if (wifiScanResults == null) { + return; + } + + // Notify provider and collector of Wifi scan results + synchronized (mLocationListeners) { + if (mCollector != null) { + mCollector.updateWifiScanResults(wifiScanResults); + } + if (mNetworkLocationInterface != null) { + mNetworkLocationInterface.updateWifiScanResults(wifiScanResults); + } + } + + } else if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) { + int networkState = LocationProvider.TEMPORARILY_UNAVAILABLE; + + boolean noConnectivity = + intent.getBooleanExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, false); + if (!noConnectivity) { + networkState = LocationProvider.AVAILABLE; + } + + // Notify location providers of current network state + synchronized (mLocationListeners) { + List<LocationProviderImpl> providers = LocationProviderImpl.getProviders(); + for (LocationProviderImpl provider : providers) { + if (provider.requiresNetwork()) { + provider.updateNetworkState(networkState); + } + } + } + + } else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) { + int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, + WifiManager.WIFI_STATE_UNKNOWN); + + boolean enabled; + if (state == WifiManager.WIFI_STATE_ENABLED) { + enabled = true; + } else if (state == WifiManager.WIFI_STATE_DISABLED) { + enabled = false; + } else { + return; + } + + // Notify network provider of current wifi enabled state + synchronized (mLocationListeners) { + if (mNetworkLocationInterface != null) { + mNetworkLocationInterface.updateWifiEnabledState(enabled); + } + } + + } else if (action.equals(GpsLocationProvider.GPS_ENABLED_CHANGE_ACTION)) { + + final boolean enabled = intent.getBooleanExtra(GpsLocationProvider.EXTRA_ENABLED, + false); + + synchronized (mLocationListeners) { + if (enabled) { + updateReportedGpsLocked(); + mGpsNavigating = true; + } else { + reportStopGpsLocked(); + mGpsNavigating = false; + // When GPS is disabled, we are OK to release wake-lock + mWakeLockGpsReceived = true; + } + } + } + + } + } + + // Wake locks + + private void updateWakelockStatusLocked(boolean screenOn) { + log("updateWakelockStatus(): " + screenOn); + + boolean needsLock = false; + long minTime = Integer.MAX_VALUE; + + if (mNetworkLocationProvider != null && mNetworkLocationProvider.isLocationTracking()) { + needsLock = true; + minTime = Math.min(mNetworkLocationProvider.getMinTime(), minTime); + } + + if (mGpsLocationProvider != null && mGpsLocationProvider.isLocationTracking()) { + needsLock = true; + minTime = Math.min(mGpsLocationProvider.getMinTime(), minTime); + if (screenOn) { + startGpsLocked(); + } else if (mScreenOn && !screenOn) { + // We just turned the screen off so stop navigating + stopGpsLocked(); + } + } + + mScreenOn = screenOn; + + PendingIntent sender = + PendingIntent.getBroadcast(mContext, 0, new Intent(ALARM_INTENT), 0); + + // Cancel existing alarm + log("Cancelling existing alarm"); + mAlarmManager.cancel(sender); + + if (needsLock && !mScreenOn) { + long now = SystemClock.elapsedRealtime(); + mAlarmManager.set( + AlarmManager.ELAPSED_REALTIME_WAKEUP, now + minTime, sender); + mAlarmInterval = minTime; + log("Creating a new wakelock alarm with minTime = " + minTime); + } else { + log("No need for alarm"); + mAlarmInterval = -1; + + // Clear out existing wakelocks + mLocationHandler.removeMessages(MESSAGE_ACQUIRE_WAKE_LOCK); + mLocationHandler.removeMessages(MESSAGE_RELEASE_WAKE_LOCK); + releaseWakeLockLocked(); + } + } + + private void acquireWakeLockLocked() { + try { + acquireWakeLockXLocked(); + } catch (Exception e) { + // This is to catch a runtime exception thrown when we try to release an + // already released lock. + Log.e(TAG, "exception in acquireWakeLock()", e); + } + } + + private void acquireWakeLockXLocked() { + if (mWakeLock.isHeld()) { + log("Must release wakelock before acquiring"); + mWakeLockAcquireTime = 0; + mWakeLock.release(); + } + + boolean networkActive = (mNetworkLocationProvider != null) + && mNetworkLocationProvider.isLocationTracking(); + boolean gpsActive = (mGpsLocationProvider != null) + && mGpsLocationProvider.isLocationTracking(); + + boolean needsLock = networkActive || gpsActive; + if (!needsLock) { + log("No need for Lock!"); + return; + } + + mWakeLockGpsReceived = !gpsActive; + mWakeLockNetworkReceived = !networkActive; + + // Acquire wake lock + mWakeLock.acquire(); + mWakeLockAcquireTime = SystemClock.elapsedRealtime(); + log("Acquired wakelock"); + + // Start the gps provider + startGpsLocked(); + + // Acquire cell lock + if (mCellWakeLockAcquired) { + // Lock is already acquired + } else if (!mWakeLockNetworkReceived) { + mTelephonyManager.enableLocationUpdates(); + mCellWakeLockAcquired = true; + } else { + mCellWakeLockAcquired = false; + } + + // Notify NetworkLocationProvider + if (mNetworkLocationInterface != null) { + mNetworkLocationInterface.updateCellLockStatus(mCellWakeLockAcquired); + } + + // Acquire wifi lock + WifiManager.WifiLock wifiLock = getWifiWakelockLocked(); + if (wifiLock != null) { + if (mWifiWakeLockAcquired) { + // Lock is already acquired + } else if (mWifiManager.isWifiEnabled() && !mWakeLockNetworkReceived) { + wifiLock.acquire(); + mWifiWakeLockAcquired = true; + } else { + mWifiWakeLockAcquired = false; + Log.w(TAG, "acquireWakeLock(): Unable to get WiFi lock"); + } + } + } + + private boolean reportGpsUidLocked(int curSeq, int nextSeq, int uid) { + int seq = mReportedGpsUids.get(uid, -1); + if (seq == curSeq) { + // Already reported; propagate to next sequence. + mReportedGpsUids.put(uid, nextSeq); + return true; + } else if (seq != nextSeq) { + try { + // New UID; report it. + mBatteryStats.noteStartGps(uid); + mReportedGpsUids.put(uid, nextSeq); + return true; + } catch (RemoteException e) { + } + } + return false; + } + + private void updateReportedGpsLocked() { + if (mGpsLocationProvider == null) { + return; + } + + final String name = mGpsLocationProvider.getName(); + final int curSeq = mReportedGpsSeq; + final int nextSeq = (curSeq+1) >= 0 ? (curSeq+1) : 0; + mReportedGpsSeq = nextSeq; + + ArrayList<UpdateRecord> urs = mRecordsByProvider.get(name); + int num = 0; + final int N = urs.size(); + for (int i=0; i<N; i++) { + UpdateRecord ur = urs.get(i); + if (ur.mReceiver == mProximityListener) { + // We don't want the system to take the blame for this one. + continue; + } + if (reportGpsUidLocked(curSeq, nextSeq, ur.mUid)) { + num++; + } + } + + for (ProximityAlert pe : mProximityAlerts.values()) { + if (reportGpsUidLocked(curSeq, nextSeq, pe.mUid)) { + num++; + } + } + + if (num != mReportedGpsUids.size()) { + // The number of uids is processed is different than the + // array; report any that are no longer active. + for (int i=mReportedGpsUids.size()-1; i>=0; i--) { + if (mReportedGpsUids.valueAt(i) != nextSeq) { + try { + mBatteryStats.noteStopGps(mReportedGpsUids.keyAt(i)); + } catch (RemoteException e) { + } + mReportedGpsUids.removeAt(i); + } + } + } + } + + private void reportStopGpsLocked() { + int curSeq = mReportedGpsSeq; + for (int i=mReportedGpsUids.size()-1; i>=0; i--) { + if (mReportedGpsUids.valueAt(i) == curSeq) { + try { + mBatteryStats.noteStopGps(mReportedGpsUids.keyAt(i)); + } catch (RemoteException e) { + } + } + } + curSeq++; + if (curSeq < 0) curSeq = 0; + mReportedGpsSeq = curSeq; + mReportedGpsUids.clear(); + } + + private void startGpsLocked() { + boolean gpsActive = (mGpsLocationProvider != null) + && mGpsLocationProvider.isLocationTracking(); + if (gpsActive) { + mGpsLocationProvider.startNavigating(); + } + } + + private void stopGpsLocked() { + boolean gpsActive = mGpsLocationProvider != null + && mGpsLocationProvider.isLocationTracking(); + if (gpsActive) { + mGpsLocationProvider.stopNavigating(); + } + } + + private void releaseWakeLockLocked() { + try { + releaseWakeLockXLocked(); + } catch (Exception e) { + // This is to catch a runtime exception thrown when we try to release an + // already released lock. + Log.e(TAG, "exception in releaseWakeLock()", e); + } + } + + private void releaseWakeLockXLocked() { + // Release wifi lock + WifiManager.WifiLock wifiLock = getWifiWakelockLocked(); + if (wifiLock != null) { + if (mWifiWakeLockAcquired) { + wifiLock.release(); + mWifiWakeLockAcquired = false; + } + } + + if (!mScreenOn) { + // Stop the gps + stopGpsLocked(); + } + + // Release cell lock + if (mCellWakeLockAcquired) { + mTelephonyManager.disableLocationUpdates(); + mCellWakeLockAcquired = false; + } + + // Notify NetworkLocationProvider + if (mNetworkLocationInterface != null) { + mNetworkLocationInterface.updateCellLockStatus(mCellWakeLockAcquired); + } + + // Release wake lock + mWakeLockAcquireTime = 0; + if (mWakeLock.isHeld()) { + log("Released wakelock"); + mWakeLock.release(); + } else { + log("Can't release wakelock again!"); + } + } + + // Geocoder + + public String getFromLocation(double latitude, double longitude, int maxResults, + String language, String country, String variant, String appName, List<Address> addrs) { + synchronized (mLocationListeners) { + if (mNetworkLocationInterface != null) { + return mNetworkLocationInterface.getFromLocation(latitude, longitude, maxResults, + language, country, variant, appName, addrs); + } else { + return null; + } + } + } + + public String getFromLocationName(String locationName, + double lowerLeftLatitude, double lowerLeftLongitude, + double upperRightLatitude, double upperRightLongitude, int maxResults, + String language, String country, String variant, String appName, List<Address> addrs) { + synchronized (mLocationListeners) { + if (mNetworkLocationInterface != null) { + return mNetworkLocationInterface.getFromLocationName(locationName, lowerLeftLatitude, + lowerLeftLongitude, upperRightLatitude, upperRightLongitude, maxResults, + language, country, variant, appName, addrs); + } else { + return null; + } + } + } + + // Mock Providers + + class MockProvider extends LocationProviderImpl { + boolean mRequiresNetwork; + boolean mRequiresSatellite; + boolean mRequiresCell; + boolean mHasMonetaryCost; + boolean mSupportsAltitude; + boolean mSupportsSpeed; + boolean mSupportsBearing; + int mPowerRequirement; + int mAccuracy; + + public MockProvider(String name, boolean requiresNetwork, boolean requiresSatellite, + boolean requiresCell, boolean hasMonetaryCost, boolean supportsAltitude, + boolean supportsSpeed, boolean supportsBearing, int powerRequirement, int accuracy) { + super(name); + + mRequiresNetwork = requiresNetwork; + mRequiresSatellite = requiresSatellite; + mRequiresCell = requiresCell; + mHasMonetaryCost = hasMonetaryCost; + mSupportsAltitude = supportsAltitude; + mSupportsBearing = supportsBearing; + mSupportsSpeed = supportsSpeed; + mPowerRequirement = powerRequirement; + mAccuracy = accuracy; + } + + @Override + public void disable() { + String name = getName(); + // We shouldn't normally need to lock, since this should only be called + // by the service with the lock held, but let's be paranid. + synchronized (mLocationListeners) { + mEnabledProviders.remove(name); + mDisabledProviders.add(name); + } + } + + @Override + public void enable() { + String name = getName(); + // We shouldn't normally need to lock, since this should only be called + // by the service with the lock held, but let's be paranid. + synchronized (mLocationListeners) { + mEnabledProviders.add(name); + mDisabledProviders.remove(name); + } + } + + @Override + public boolean getLocation(Location l) { + // We shouldn't normally need to lock, since this should only be called + // by the service with the lock held, but let's be paranid. + synchronized (mLocationListeners) { + Location loc = mMockProviderLocation.get(getName()); + if (loc == null) { + return false; + } + l.set(loc); + return true; + } + } + + @Override + public int getStatus(Bundle extras) { + // We shouldn't normally need to lock, since this should only be called + // by the service with the lock held, but let's be paranid. + synchronized (mLocationListeners) { + String name = getName(); + Integer s = mMockProviderStatus.get(name); + int status = (s == null) ? AVAILABLE : s.intValue(); + Bundle newExtras = mMockProviderStatusExtras.get(name); + if (newExtras != null) { + extras.clear(); + extras.putAll(newExtras); + } + return status; + } + } + + @Override + public boolean isEnabled() { + // We shouldn't normally need to lock, since this should only be called + // by the service with the lock held, but let's be paranid. + synchronized (mLocationListeners) { + return mEnabledProviders.contains(getName()); + } + } + + @Override + public int getAccuracy() { + return mAccuracy; + } + + @Override + public int getPowerRequirement() { + return mPowerRequirement; + } + + @Override + public boolean hasMonetaryCost() { + return mHasMonetaryCost; + } + + @Override + public boolean requiresCell() { + return mRequiresCell; + } + + @Override + public boolean requiresNetwork() { + return mRequiresNetwork; + } + + @Override + public boolean requiresSatellite() { + return mRequiresSatellite; + } + + @Override + public boolean supportsAltitude() { + return mSupportsAltitude; + } + + @Override + public boolean supportsBearing() { + return mSupportsBearing; + } + + @Override + public boolean supportsSpeed() { + return mSupportsSpeed; + } + } + + private void checkMockPermissionsSafe() { + boolean allowMocks = Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.ALLOW_MOCK_LOCATION, 0) == 1; + if (!allowMocks) { + throw new SecurityException("Requires ACCESS_MOCK_LOCATION secure setting"); + } + + if (mContext.checkCallingPermission(ACCESS_MOCK_LOCATION) != + PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires ACCESS_MOCK_LOCATION permission"); + } + } + + public void addTestProvider(String name, boolean requiresNetwork, boolean requiresSatellite, + boolean requiresCell, boolean hasMonetaryCost, boolean supportsAltitude, + boolean supportsSpeed, boolean supportsBearing, int powerRequirement, int accuracy) { + checkMockPermissionsSafe(); + + synchronized (mLocationListeners) { + MockProvider provider = new MockProvider(name, requiresNetwork, requiresSatellite, + requiresCell, hasMonetaryCost, supportsAltitude, + supportsSpeed, supportsBearing, powerRequirement, accuracy); + if (LocationProviderImpl.getProvider(name) != null) { + throw new IllegalArgumentException("Provider \"" + name + "\" already exists"); + } + LocationProviderImpl.addProvider(provider); + updateProvidersLocked(); + } + } + + public void removeTestProvider(String provider) { + checkMockPermissionsSafe(); + synchronized (mLocationListeners) { + LocationProviderImpl p = LocationProviderImpl.getProvider(provider); + if (p == null) { + throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); + } + LocationProviderImpl.removeProvider(p); + updateProvidersLocked(); + } + } + + public void setTestProviderLocation(String provider, Location loc) { + checkMockPermissionsSafe(); + synchronized (mLocationListeners) { + if (LocationProviderImpl.getProvider(provider) == null) { + throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); + } + mMockProviderLocation.put(provider, loc); + } + } + + public void clearTestProviderLocation(String provider) { + checkMockPermissionsSafe(); + synchronized (mLocationListeners) { + if (LocationProviderImpl.getProvider(provider) == null) { + throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); + } + mMockProviderLocation.remove(provider); + } + } + + public void setTestProviderEnabled(String provider, boolean enabled) { + checkMockPermissionsSafe(); + synchronized (mLocationListeners) { + if (LocationProviderImpl.getProvider(provider) == null) { + throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); + } + if (enabled) { + mEnabledProviders.add(provider); + mDisabledProviders.remove(provider); + } else { + mEnabledProviders.remove(provider); + mDisabledProviders.add(provider); + } + updateProvidersLocked(); + } + } + + public void clearTestProviderEnabled(String provider) { + checkMockPermissionsSafe(); + synchronized (mLocationListeners) { + if (LocationProviderImpl.getProvider(provider) == null) { + throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); + } + mEnabledProviders.remove(provider); + mDisabledProviders.remove(provider); + updateProvidersLocked(); + } + } + + public void setTestProviderStatus(String provider, int status, Bundle extras, long updateTime) { + checkMockPermissionsSafe(); + synchronized (mLocationListeners) { + if (LocationProviderImpl.getProvider(provider) == null) { + throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); + } + mMockProviderStatus.put(provider, new Integer(status)); + mMockProviderStatusExtras.put(provider, extras); + mMockProviderStatusUpdateTime.put(provider, new Long(updateTime)); + } + } + + public void clearTestProviderStatus(String provider) { + checkMockPermissionsSafe(); + synchronized (mLocationListeners) { + if (LocationProviderImpl.getProvider(provider) == null) { + throw new IllegalArgumentException("Provider \"" + provider + "\" unknown"); + } + mMockProviderStatus.remove(provider); + mMockProviderStatusExtras.remove(provider); + mMockProviderStatusUpdateTime.remove(provider); + } + } + + private void log(String log) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.d(TAG, log); + } + } + + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump AlarmManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + synchronized (mLocationListeners) { + pw.println("Current Location Manager state:"); + pw.println(" sProvidersLoaded=" + sProvidersLoaded); + pw.println(" mGpsLocationProvider=" + mGpsLocationProvider); + pw.println(" mGpsNavigating=" + mGpsNavigating); + pw.println(" mNetworkLocationProvider=" + mNetworkLocationProvider); + pw.println(" mNetworkLocationInterface=" + mNetworkLocationInterface); + pw.println(" mLastSignalStrength=" + mLastSignalStrength + + " mLastRadioType=" + mLastRadioType); + pw.println(" mCellLocationUpdater=" + mCellLocationUpdater); + pw.println(" mLastCellState=" + mLastCellState); + pw.println(" mCollector=" + mCollector); + pw.println(" mAlarmInterval=" + mAlarmInterval + + " mScreenOn=" + mScreenOn + + " mWakeLockAcquireTime=" + mWakeLockAcquireTime); + pw.println(" mWakeLockGpsReceived=" + mWakeLockGpsReceived + + " mWakeLockNetworkReceived=" + mWakeLockNetworkReceived); + pw.println(" mWifiWakeLockAcquired=" + mWifiWakeLockAcquired + + " mCellWakeLockAcquired=" + mCellWakeLockAcquired); + pw.println(" Listeners:"); + int N = mListeners.size(); + for (int i=0; i<N; i++) { + pw.println(" " + mListeners.get(i)); + } + pw.println(" Location Listeners:"); + for (Map.Entry<Receiver, HashMap<String,UpdateRecord>> i + : mLocationListeners.entrySet()) { + pw.println(" " + i.getKey() + ":"); + for (Map.Entry<String,UpdateRecord> j : i.getValue().entrySet()) { + pw.println(" " + j.getKey() + ":"); + j.getValue().dump(pw, " "); + } + } + pw.println(" Last Fix Broadcasts:"); + for (Map.Entry<Receiver, HashMap<String,Location>> i + : mLastFixBroadcast.entrySet()) { + pw.println(" " + i.getKey() + ":"); + for (Map.Entry<String,Location> j : i.getValue().entrySet()) { + pw.println(" " + j.getKey() + ":"); + j.getValue().dump(new PrintWriterPrinter(pw), " "); + } + } + pw.println(" Last Status Broadcasts:"); + for (Map.Entry<Receiver, HashMap<String,Long>> i + : mLastStatusBroadcast.entrySet()) { + pw.println(" " + i.getKey() + ":"); + for (Map.Entry<String,Long> j : i.getValue().entrySet()) { + pw.println(" " + j.getKey() + " -> 0x" + + Long.toHexString(j.getValue())); + } + } + pw.println(" Records by Provider:"); + for (Map.Entry<String, ArrayList<UpdateRecord>> i + : mRecordsByProvider.entrySet()) { + pw.println(" " + i.getKey() + ":"); + for (UpdateRecord j : i.getValue()) { + pw.println(" " + j + ":"); + j.dump(pw, " "); + } + } + pw.println(" Locations by Provider:"); + for (Map.Entry<String, Location> i + : mLocationsByProvider.entrySet()) { + pw.println(" " + i.getKey() + ":"); + i.getValue().dump(new PrintWriterPrinter(pw), " "); + } + pw.println(" Last Known Locations:"); + for (Map.Entry<String, Location> i + : mLastKnownLocation.entrySet()) { + pw.println(" " + i.getKey() + ":"); + i.getValue().dump(new PrintWriterPrinter(pw), " "); + } + if (mProximityAlerts.size() > 0) { + pw.println(" Proximity Alerts:"); + for (Map.Entry<PendingIntent, ProximityAlert> i + : mProximityAlerts.entrySet()) { + pw.println(" " + i.getKey() + ":"); + i.getValue().dump(pw, " "); + } + } + if (mProximitiesEntered.size() > 0) { + pw.println(" Proximities Entered:"); + for (ProximityAlert i : mProximitiesEntered) { + pw.println(" " + i + ":"); + i.dump(pw, " "); + } + } + pw.println(" mProximityListener=" + mProximityListener); + if (mEnabledProviders.size() > 0) { + pw.println(" Enabled Providers:"); + for (String i : mEnabledProviders) { + pw.println(" " + i); + } + + } + if (mDisabledProviders.size() > 0) { + pw.println(" Disabled Providers:"); + for (String i : mDisabledProviders) { + pw.println(" " + i); + } + + } + if (mMockProviders.size() > 0) { + pw.println(" Mock Providers:"); + for (Map.Entry<String, MockProvider> i : mMockProviders.entrySet()) { + pw.println(" " + i.getKey() + " -> " + i.getValue()); + } + } + if (mMockProviderLocation.size() > 0) { + pw.println(" Mock Provider Location:"); + for (Map.Entry<String, Location> i : mMockProviderLocation.entrySet()) { + pw.println(" " + i.getKey() + ":"); + i.getValue().dump(new PrintWriterPrinter(pw), " "); + } + } + if (mMockProviderStatus.size() > 0) { + pw.println(" Mock Provider Status:"); + for (Map.Entry<String, Integer> i : mMockProviderStatus.entrySet()) { + pw.println(" " + i.getKey() + " -> 0x" + + Integer.toHexString(i.getValue())); + } + } + if (mMockProviderStatusExtras.size() > 0) { + pw.println(" Mock Provider Status Extras:"); + for (Map.Entry<String, Bundle> i : mMockProviderStatusExtras.entrySet()) { + pw.println(" " + i.getKey() + " -> " + i.getValue()); + } + } + if (mMockProviderStatusUpdateTime.size() > 0) { + pw.println(" Mock Provider Status Update Time:"); + for (Map.Entry<String, Long> i : mMockProviderStatusUpdateTime.entrySet()) { + pw.println(" " + i.getKey() + " -> " + i.getValue()); + } + } + pw.println(" Reported GPS UIDs @ seq " + mReportedGpsSeq + ":"); + N = mReportedGpsUids.size(); + for (int i=0; i<N; i++) { + pw.println(" UID " + mReportedGpsUids.keyAt(i) + + " seq=" + mReportedGpsUids.valueAt(i)); + } + } + } +} + diff --git a/services/java/com/android/server/MasterClearReceiver.java b/services/java/com/android/server/MasterClearReceiver.java new file mode 100644 index 0000000..5a42e76 --- /dev/null +++ b/services/java/com/android/server/MasterClearReceiver.java @@ -0,0 +1,53 @@ +/* + * 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.Context; +import android.content.Intent; +import android.content.BroadcastReceiver; +import android.os.RemoteException; +import android.os.ICheckinService; +import android.os.ServiceManager; +import android.util.Log; + +public class MasterClearReceiver extends BroadcastReceiver { + + private static final String TAG = "MasterClear"; + + @Override + public void onReceive(Context context, Intent intent) { + if (intent.getAction().equals("android.intent.action.GTALK_DATA_MESSAGE_RECEIVED")) { + if (!intent.getBooleanExtra("from_trusted_server", false)) { + Log.w(TAG, "Ignoring master clear request -- not from trusted server."); + return; + } + } + Log.w(TAG, "!!! FACTORY RESETTING DEVICE !!!"); + ICheckinService service = + ICheckinService.Stub.asInterface( + ServiceManager.getService("checkin")); + if (service != null) { + try { + // This RPC should never return. + service.masterClear(); + } catch (RemoteException e) { + Log.w("MasterClear", + "Unable to invoke ICheckinService.masterClear()"); + } + } + } +} diff --git a/services/java/com/android/server/MountListener.java b/services/java/com/android/server/MountListener.java new file mode 100644 index 0000000..2e430c8 --- /dev/null +++ b/services/java/com/android/server/MountListener.java @@ -0,0 +1,324 @@ +/* + * Copyright (C) 2007 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.net.LocalSocketAddress; +import android.net.LocalSocket; +import android.os.Environment; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.util.Config; +import android.util.Log; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.Socket; + +/** + * Thread for communicating with the vol service daemon via a local socket. + * Events received from the daemon are passed to the MountService instance, + * and the MountService instance calls MountListener to send commands to the daemon. + */ +final class MountListener implements Runnable { + + private static final String TAG = "MountListener"; + + // ** THE FOLLOWING STRING CONSTANTS MUST MATCH VALUES IN system/vold/ + + // socket name for connecting to vold + private static final String VOLD_SOCKET = "vold"; + + // vold commands + private static final String VOLD_CMD_ENABLE_UMS = "enable_ums"; + private static final String VOLD_CMD_DISABLE_UMS = "disable_ums"; + private static final String VOLD_CMD_SEND_UMS_STATUS = "send_ums_status"; + private static final String VOLD_CMD_MOUNT_VOLUME = "mount_volume:"; + private static final String VOLD_CMD_EJECT_MEDIA = "eject_media:"; + private static final String VOLD_CMD_FORMAT_MEDIA = "format_media:"; + + // vold events + private static final String VOLD_EVT_UMS_ENABLED = "ums_enabled"; + private static final String VOLD_EVT_UMS_DISABLED = "ums_disabled"; + private static final String VOLD_EVT_UMS_CONNECTED = "ums_connected"; + private static final String VOLD_EVT_UMS_DISCONNECTED = "ums_disconnected"; + + private static final String VOLD_EVT_NOMEDIA = "volume_nomedia:"; + private static final String VOLD_EVT_UNMOUNTED = "volume_unmounted:"; + private static final String VOLD_EVT_MOUNTED = "volume_mounted:"; + private static final String VOLD_EVT_MOUNTED_RO = "volume_mounted_ro:"; + private static final String VOLD_EVT_UMS = "volume_ums"; + private static final String VOLD_EVT_BAD_REMOVAL = "volume_badremoval:"; + private static final String VOLD_EVT_DAMAGED = "volume_damaged:"; + private static final String VOLD_EVT_CHECKING = "volume_checking:"; + private static final String VOLD_EVT_NOFS = "volume_nofs:"; + private static final String VOLD_EVT_EJECTING = "volume_ejecting:"; + + /** + * MountService that handles events received from the vol service daemon + */ + private MountService mService; + + /** + * Stream for sending commands to the vol service daemon. + */ + private OutputStream mOutputStream; + + /** + * Cached value indicating whether or not USB mass storage is enabled. + */ + private boolean mUmsEnabled; + + /** + * Cached value indicating whether or not USB mass storage is connected. + */ + private boolean mUmsConnected; + + /** + * Constructor for MountListener + * + * @param service The MountListener we are handling communication with USB + * daemon for. + */ + MountListener(MountService service) { + mService = service; + } + + /** + * Process and dispatches events received from the vol service daemon + * + * @param event An event received from the vol service daemon + */ + private void handleEvent(String event) { + if (Config.LOGD) Log.d(TAG, "handleEvent " + event); + + int colonIndex = event.indexOf(':'); + String path = (colonIndex > 0 ? event.substring(colonIndex + 1) : null); + + if (event.equals(VOLD_EVT_UMS_ENABLED)) { + mUmsEnabled = true; + } else if (event.equals(VOLD_EVT_UMS_DISABLED)) { + mUmsEnabled = false; + } else if (event.equals(VOLD_EVT_UMS_CONNECTED)) { + mUmsConnected = true; + mService.notifyUmsConnected(); + } else if (event.equals(VOLD_EVT_UMS_DISCONNECTED)) { + mUmsConnected = false; + mService.notifyUmsDisconnected(); + } else if (event.startsWith(VOLD_EVT_NOMEDIA)) { + mService.notifyMediaRemoved(path); + } else if (event.startsWith(VOLD_EVT_UNMOUNTED)) { + mService.notifyMediaUnmounted(path); + } else if (event.startsWith(VOLD_EVT_CHECKING)) { + mService.notifyMediaChecking(path); + } else if (event.startsWith(VOLD_EVT_NOFS)) { + mService.notifyMediaNoFs(path); + } else if (event.startsWith(VOLD_EVT_MOUNTED)) { + mService.notifyMediaMounted(path, false); + } else if (event.startsWith(VOLD_EVT_MOUNTED_RO)) { + mService.notifyMediaMounted(path, true); + } else if (event.startsWith(VOLD_EVT_UMS)) { + mService.notifyMediaShared(path); + } else if (event.startsWith(VOLD_EVT_BAD_REMOVAL)) { + mService.notifyMediaBadRemoval(path); + // also send media eject intent, to notify apps to close any open + // files on the media. + mService.notifyMediaEject(path); + } else if (event.startsWith(VOLD_EVT_DAMAGED)) { + mService.notifyMediaUnmountable(path); + } else if (event.startsWith(VOLD_EVT_EJECTING)) { + mService.notifyMediaEject(path); + } + } + + /** + * Sends a command to the mount service daemon via a local socket + * + * @param command The command to send to the mount service daemon + */ + private void writeCommand(String command) { + writeCommand2(command, null); + } + + /** + * Sends a command to the mount service daemon via a local socket + * with a single argument + * + * @param command The command to send to the mount service daemon + * @param argument The argument to send with the command (or null) + */ + private void writeCommand2(String command, String argument) { + synchronized (this) { + if (mOutputStream == null) { + Log.e(TAG, "No connection to vold", new IllegalStateException()); + } else { + StringBuilder builder = new StringBuilder(command); + if (argument != null) { + builder.append(argument); + } + builder.append('\0'); + + try { + mOutputStream.write(builder.toString().getBytes()); + } catch (IOException ex) { + Log.e(TAG, "IOException in writeCommand", ex); + } + } + } + } + + /** + * Opens a socket to communicate with the mount service daemon and listens + * for events from the daemon. + * + */ + private void listenToSocket() { + LocalSocket socket = null; + + try { + socket = new LocalSocket(); + LocalSocketAddress address = new LocalSocketAddress(VOLD_SOCKET, + LocalSocketAddress.Namespace.RESERVED); + + socket.connect(address); + + InputStream inputStream = socket.getInputStream(); + mOutputStream = socket.getOutputStream(); + + byte[] buffer = new byte[100]; + + writeCommand(VOLD_CMD_SEND_UMS_STATUS); + + while (true) { + int count = inputStream.read(buffer); + if (count < 0) break; + + int start = 0; + for (int i = 0; i < count; i++) { + if (buffer[i] == 0) { + String event = new String(buffer, start, i - start); + handleEvent(event); + start = i + 1; + } + } + } + } catch (IOException ex) { + // This exception is normal when running in desktop simulator + // where there is no mount daemon to talk to + + // log("IOException in listenToSocket"); + } + + synchronized (this) { + if (mOutputStream != null) { + try { + mOutputStream.close(); + } catch (IOException e) { + Log.w(TAG, "IOException closing output stream"); + } + + mOutputStream = null; + } + } + + try { + if (socket != null) { + socket.close(); + } + } catch (IOException ex) { + Log.w(TAG, "IOException closing socket"); + } + + /* + * Sleep before trying again. + * This should not happen except while debugging. + * Without this sleep, the emulator will spin and + * create tons of throwaway LocalSockets, making + * system_server GC constantly. + */ + Log.e(TAG, "Failed to connect to vold", new IllegalStateException()); + SystemClock.sleep(2000); + } + + /** + * Main loop for MountListener thread. + */ + public void run() { + // ugly hack for the simulator. + if ("simulator".equals(SystemProperties.get("ro.product.device"))) { + SystemProperties.set("EXTERNAL_STORAGE_STATE", Environment.MEDIA_MOUNTED); + // usbd does not run in the simulator, so send a fake device mounted event to trigger the Media Scanner + mService.notifyMediaMounted(Environment.getExternalStorageDirectory().getPath(), false); + + // no usbd in the simulator, so no point in hanging around. + return; + } + + try { + while (true) { + listenToSocket(); + } + } catch (Throwable t) { + // catch all Throwables so we don't bring down the system process + Log.e(TAG, "Fatal error " + t + " in MountListener thread!"); + } + } + + /** + * @return true if USB mass storage is enabled + */ + boolean getMassStorageEnabled() { + return mUmsEnabled; + } + + /** + * Enables or disables USB mass storage support. + * + * @param enable true to enable USB mass storage support + */ + void setMassStorageEnabled(boolean enable) { + writeCommand(enable ? VOLD_CMD_ENABLE_UMS : VOLD_CMD_DISABLE_UMS); + } + + /** + * @return true if USB mass storage is connected + */ + boolean getMassStorageConnected() { + return mUmsConnected; + } + + /** + * Mount media at given mount point. + */ + public void mountMedia(String mountPoint) { + writeCommand2(VOLD_CMD_MOUNT_VOLUME, mountPoint); + } + + /** + * Unmount media at given mount point. + */ + public void ejectMedia(String mountPoint) { + writeCommand2(VOLD_CMD_EJECT_MEDIA, mountPoint); + } + + /** + * Format media at given mount point. + */ + public void formatMedia(String mountPoint) { + writeCommand2(VOLD_CMD_FORMAT_MEDIA, mountPoint); + } +} diff --git a/services/java/com/android/server/MountService.java b/services/java/com/android/server/MountService.java new file mode 100644 index 0000000..8814e48 --- /dev/null +++ b/services/java/com/android/server/MountService.java @@ -0,0 +1,540 @@ +/* + * Copyright (C) 2007 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.app.Notification; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.content.res.Resources; +import android.net.Uri; +import android.os.IMountService; +import android.os.Environment; +import android.os.RemoteException; +import android.os.SystemProperties; +import android.os.UEventObserver; +import android.text.TextUtils; +import android.util.Log; + +import java.io.File; +import java.io.FileReader; + +/** + * MountService implements an to the mount service daemon + * @hide + */ +class MountService extends IMountService.Stub { + + private static final String TAG = "MountService"; + + /** + * Binder context for this service + */ + private Context mContext; + + /** + * listener object for communicating with the mount service daemon + */ + private MountListener mListener; + + /** + * The notification that is shown when a USB mass storage host + * is connected. + * <p> + * This is lazily created, so use {@link #setUsbStorageNotification()}. + */ + private Notification mUsbStorageNotification; + + + /** + * The notification that is shown when the following media events occur: + * - Media is being checked + * - Media is blank (or unknown filesystem) + * - Media is corrupt + * - Media is safe to unmount + * - Media is missing + * <p> + * This is lazily created, so use {@link #setMediaStorageNotification()}. + */ + private Notification mMediaStorageNotification; + + private boolean mShowSafeUnmountNotificationWhenUnmounted; + + private boolean mPlaySounds; + + private boolean mMounted; + + /** + * Constructs a new MountService instance + * + * @param context Binder context for this service + */ + public MountService(Context context) { + mContext = context; + + // Register a BOOT_COMPLETED handler so that we can start + // MountListener. We defer the startup so that we don't + // start processing events before we ought-to + mContext.registerReceiver(mBroadcastReceiver, + new IntentFilter(Intent.ACTION_BOOT_COMPLETED), null, null); + + mListener = new MountListener(this); + mShowSafeUnmountNotificationWhenUnmounted = false; + + mPlaySounds = SystemProperties.get("persist.service.mount.playsnd", "1").equals("1"); + } + + BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { + public void onReceive(Context context, Intent intent) { + if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED)) { + Thread thread = new Thread(mListener, MountListener.class.getName()); + thread.start(); + } + } + }; + + /** + * @return true if USB mass storage support is enabled. + */ + public boolean getMassStorageEnabled() throws RemoteException { + return mListener.getMassStorageEnabled(); + } + + /** + * Enables or disables USB mass storage support. + * + * @param enable true to enable USB mass storage support + */ + public void setMassStorageEnabled(boolean enable) throws RemoteException { + mListener.setMassStorageEnabled(enable); + } + + /** + * @return true if USB mass storage is connected. + */ + public boolean getMassStorageConnected() throws RemoteException { + return mListener.getMassStorageConnected(); + } + + /** + * Attempt to mount external media + */ + public void mountMedia(String mountPath) throws RemoteException { + if (mContext.checkCallingOrSelfPermission( + android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires MOUNT_UNMOUNT_FILESYSTEMS permission"); + } + mListener.mountMedia(mountPath); + } + + /** + * Attempt to unmount external media to prepare for eject + */ + public void unmountMedia(String mountPath) throws RemoteException { + if (mContext.checkCallingOrSelfPermission( + android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires MOUNT_UNMOUNT_FILESYSTEMS permission"); + } + + // Set a flag so that when we get the unmounted event, we know + // to display the notification + mShowSafeUnmountNotificationWhenUnmounted = true; + + // tell mountd to unmount the media + mListener.ejectMedia(mountPath); + } + + /** + * Attempt to format external media + */ + public void formatMedia(String formatPath) throws RemoteException { + if (mContext.checkCallingOrSelfPermission( + android.Manifest.permission.MOUNT_FORMAT_FILESYSTEMS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires MOUNT_FORMAT_FILESYSTEMS permission"); + } + + mListener.formatMedia(formatPath); + } + + /** + * Returns true if we're playing media notification sounds. + */ + public boolean getPlayNotificationSounds() { + return mPlaySounds; + } + + /** + * Set whether or not we're playing media notification sounds. + */ + public void setPlayNotificationSounds(boolean enabled) { + if (mContext.checkCallingOrSelfPermission( + android.Manifest.permission.WRITE_SETTINGS) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires WRITE_SETTINGS permission"); + } + mPlaySounds = enabled; + SystemProperties.set("persist.service.mount.playsnd", (enabled ? "1" : "0")); + } + + /** + * Update the state of the USB mass storage notification + */ + void updateUsbMassStorageNotification(boolean suppressIfConnected, boolean sound) { + + try { + + if (getMassStorageConnected() && !suppressIfConnected) { + Intent intent = new Intent(); + intent.setClass(mContext, com.android.internal.app.UsbStorageActivity.class); + PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); + setUsbStorageNotification( + com.android.internal.R.string.usb_storage_notification_title, + com.android.internal.R.string.usb_storage_notification_message, + com.android.internal.R.drawable.stat_sys_data_usb, + sound, true, pi); + } else { + setUsbStorageNotification(0, 0, 0, false, false, null); + } + } catch (RemoteException e) { + // Nothing to do + } + } + + void handlePossibleExplicitUnmountBroadcast(String path) { + if (mMounted) { + mMounted = false; + Intent intent = new Intent(Intent.ACTION_MEDIA_UNMOUNTED, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + } + + /** + * Broadcasts the USB mass storage connected event to all clients. + */ + void notifyUmsConnected() { + String storageState = Environment.getExternalStorageState(); + if (!storageState.equals(Environment.MEDIA_REMOVED) && + !storageState.equals(Environment.MEDIA_BAD_REMOVAL) && + !storageState.equals(Environment.MEDIA_CHECKING)) { + + updateUsbMassStorageNotification(false, true); + } + + Intent intent = new Intent(Intent.ACTION_UMS_CONNECTED); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the USB mass storage disconnected event to all clients. + */ + void notifyUmsDisconnected() { + updateUsbMassStorageNotification(false, false); + Intent intent = new Intent(Intent.ACTION_UMS_DISCONNECTED); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media removed event to all clients. + */ + void notifyMediaRemoved(String path) { + updateUsbMassStorageNotification(true, false); + + setMediaStorageNotification( + com.android.internal.R.string.ext_media_nomedia_notification_title, + com.android.internal.R.string.ext_media_nomedia_notification_message, + com.android.internal.R.drawable.stat_sys_no_sim, + true, false, null); + handlePossibleExplicitUnmountBroadcast(path); + + Intent intent = new Intent(Intent.ACTION_MEDIA_REMOVED, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media unmounted event to all clients. + */ + void notifyMediaUnmounted(String path) { + if (mShowSafeUnmountNotificationWhenUnmounted) { + setMediaStorageNotification( + com.android.internal.R.string.ext_media_safe_unmount_notification_title, + com.android.internal.R.string.ext_media_safe_unmount_notification_message, + com.android.internal.R.drawable.stat_notify_sim_toolkit, + true, true, null); + mShowSafeUnmountNotificationWhenUnmounted = false; + } else { + setMediaStorageNotification(0, 0, 0, false, false, null); + } + updateUsbMassStorageNotification(false, false); + + Intent intent = new Intent(Intent.ACTION_MEDIA_UNMOUNTED, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media checking event to all clients. + */ + void notifyMediaChecking(String path) { + setMediaStorageNotification( + com.android.internal.R.string.ext_media_checking_notification_title, + com.android.internal.R.string.ext_media_checking_notification_message, + com.android.internal.R.drawable.stat_notify_sim_toolkit, + true, false, null); + + updateUsbMassStorageNotification(true, false); + Intent intent = new Intent(Intent.ACTION_MEDIA_CHECKING, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media nofs event to all clients. + */ + void notifyMediaNoFs(String path) { + + Intent intent = new Intent(); + intent.setClass(mContext, com.android.internal.app.ExternalMediaFormatActivity.class); + PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); + + setMediaStorageNotification(com.android.internal.R.string.ext_media_nofs_notification_title, + com.android.internal.R.string.ext_media_nofs_notification_message, + com.android.internal.R.drawable.stat_sys_no_sim, + true, false, pi); + updateUsbMassStorageNotification(false, false); + intent = new Intent(Intent.ACTION_MEDIA_NOFS, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media mounted event to all clients. + */ + void notifyMediaMounted(String path, boolean readOnly) { + setMediaStorageNotification(0, 0, 0, false, false, null); + updateUsbMassStorageNotification(false, false); + Intent intent = new Intent(Intent.ACTION_MEDIA_MOUNTED, + Uri.parse("file://" + path)); + intent.putExtra("read-only", readOnly); + mMounted = true; + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media shared event to all clients. + */ + void notifyMediaShared(String path) { + Intent intent = new Intent(); + intent.setClass(mContext, com.android.internal.app.UsbStorageStopActivity.class); + PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); + setUsbStorageNotification(com.android.internal.R.string.usb_storage_stop_notification_title, + com.android.internal.R.string.usb_storage_stop_notification_message, + com.android.internal.R.drawable.stat_sys_warning, + false, true, pi); + handlePossibleExplicitUnmountBroadcast(path); + intent = new Intent(Intent.ACTION_MEDIA_SHARED, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media bad removal event to all clients. + */ + void notifyMediaBadRemoval(String path) { + updateUsbMassStorageNotification(true, false); + setMediaStorageNotification(com.android.internal.R.string.ext_media_badremoval_notification_title, + com.android.internal.R.string.ext_media_badremoval_notification_message, + com.android.internal.R.drawable.stat_sys_warning, + true, true, null); + + handlePossibleExplicitUnmountBroadcast(path); + Intent intent = new Intent(Intent.ACTION_MEDIA_BAD_REMOVAL, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + + intent = new Intent(Intent.ACTION_MEDIA_REMOVED, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media unmountable event to all clients. + */ + void notifyMediaUnmountable(String path) { + Intent intent = new Intent(); + intent.setClass(mContext, com.android.internal.app.ExternalMediaFormatActivity.class); + PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); + + setMediaStorageNotification(com.android.internal.R.string.ext_media_unmountable_notification_title, + com.android.internal.R.string.ext_media_unmountable_notification_message, + com.android.internal.R.drawable.stat_sys_no_sim, + true, false, pi); + updateUsbMassStorageNotification(false, false); + + handlePossibleExplicitUnmountBroadcast(path); + + intent = new Intent(Intent.ACTION_MEDIA_UNMOUNTABLE, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Broadcasts the media eject event to all clients. + */ + void notifyMediaEject(String path) { + Intent intent = new Intent(Intent.ACTION_MEDIA_EJECT, + Uri.parse("file://" + path)); + mContext.sendBroadcast(intent); + } + + /** + * Sets the USB storage notification. + */ + private synchronized void setUsbStorageNotification(int titleId, int messageId, int icon, boolean sound, boolean visible, + PendingIntent pi) { + + if (!visible && mUsbStorageNotification == null) { + return; + } + + NotificationManager notificationManager = (NotificationManager) mContext + .getSystemService(Context.NOTIFICATION_SERVICE); + + if (notificationManager == null) { + return; + } + + if (visible) { + Resources r = Resources.getSystem(); + CharSequence title = r.getText(titleId); + CharSequence message = r.getText(messageId); + + if (mUsbStorageNotification == null) { + mUsbStorageNotification = new Notification(); + mUsbStorageNotification.icon = icon; + mUsbStorageNotification.when = 0; + } + + if (sound && mPlaySounds) { + mUsbStorageNotification.defaults |= Notification.DEFAULT_SOUND; + } else { + mUsbStorageNotification.defaults &= ~Notification.DEFAULT_SOUND; + } + + mUsbStorageNotification.flags = Notification.FLAG_ONGOING_EVENT; + + mUsbStorageNotification.tickerText = title; + if (pi == null) { + Intent intent = new Intent(); + pi = PendingIntent.getBroadcast(mContext, 0, intent, 0); + } + + mUsbStorageNotification.setLatestEventInfo(mContext, title, message, pi); + } + + final int notificationId = mUsbStorageNotification.icon; + if (visible) { + notificationManager.notify(notificationId, mUsbStorageNotification); + } else { + notificationManager.cancel(notificationId); + } + } + + private synchronized boolean getMediaStorageNotificationDismissable() { + if ((mMediaStorageNotification != null) && + ((mMediaStorageNotification.flags & Notification.FLAG_AUTO_CANCEL) == + Notification.FLAG_AUTO_CANCEL)) + return true; + + return false; + } + + /** + * Sets the media storage notification. + */ + private synchronized void setMediaStorageNotification(int titleId, int messageId, int icon, boolean visible, + boolean dismissable, PendingIntent pi) { + + if (!visible && mMediaStorageNotification == null) { + return; + } + + NotificationManager notificationManager = (NotificationManager) mContext + .getSystemService(Context.NOTIFICATION_SERVICE); + + if (notificationManager == null) { + return; + } + + if (mMediaStorageNotification != null && visible) { + /* + * Dismiss the previous notification - we're about to + * re-use it. + */ + final int notificationId = mMediaStorageNotification.icon; + notificationManager.cancel(notificationId); + } + + if (visible) { + Resources r = Resources.getSystem(); + CharSequence title = r.getText(titleId); + CharSequence message = r.getText(messageId); + + if (mMediaStorageNotification == null) { + mMediaStorageNotification = new Notification(); + mMediaStorageNotification.when = 0; + } + + if (mPlaySounds) { + mMediaStorageNotification.defaults |= Notification.DEFAULT_SOUND; + } else { + mMediaStorageNotification.defaults &= ~Notification.DEFAULT_SOUND; + } + + if (dismissable) { + mMediaStorageNotification.flags = Notification.FLAG_AUTO_CANCEL; + } else { + mMediaStorageNotification.flags = Notification.FLAG_ONGOING_EVENT; + } + + mMediaStorageNotification.tickerText = title; + if (pi == null) { + Intent intent = new Intent(); + pi = PendingIntent.getBroadcast(mContext, 0, intent, 0); + } + + mMediaStorageNotification.icon = icon; + mMediaStorageNotification.setLatestEventInfo(mContext, title, message, pi); + } + + final int notificationId = mMediaStorageNotification.icon; + if (visible) { + notificationManager.notify(notificationId, mMediaStorageNotification); + } else { + notificationManager.cancel(notificationId); + } + } +} + diff --git a/services/java/com/android/server/NetStatService.java b/services/java/com/android/server/NetStatService.java new file mode 100644 index 0000000..1ea0bac --- /dev/null +++ b/services/java/com/android/server/NetStatService.java @@ -0,0 +1,60 @@ +/* + * 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.Context; +import android.os.INetStatService; +import android.os.NetStat; + +public class NetStatService extends INetStatService.Stub { + + public NetStatService(Context context) { + + } + + public long getMobileTxPackets() { + return NetStat.getMobileTxPkts(); + } + + public long getMobileRxPackets() { + return NetStat.getMobileRxPkts(); + } + + public long getMobileTxBytes() { + return NetStat.getMobileTxBytes(); + } + + public long getMobileRxBytes() { + return NetStat.getMobileRxBytes(); + } + + public long getTotalTxPackets() { + return NetStat.getTotalTxPkts(); + } + + public long getTotalRxPackets() { + return NetStat.getTotalRxPkts(); + } + + public long getTotalTxBytes() { + return NetStat.getTotalTxBytes(); + } + + public long getTotalRxBytes() { + return NetStat.getTotalRxBytes(); + } +} diff --git a/services/java/com/android/server/NotificationManagerService.java b/services/java/com/android/server/NotificationManagerService.java new file mode 100644 index 0000000..bc4b169 --- /dev/null +++ b/services/java/com/android/server/NotificationManagerService.java @@ -0,0 +1,929 @@ +/* + * Copyright (C) 2007 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.app.ActivityManagerNative; +import android.app.IActivityManager; +import android.app.INotificationManager; +import android.app.ITransientNotification; +import android.app.Notification; +import android.app.PendingIntent; +import android.app.StatusBarManager; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; +import android.content.res.Resources; +import android.media.AudioManager; +import android.media.AsyncPlayer; +import android.media.RingtoneManager; +import android.net.Uri; +import android.os.BatteryManager; +import android.os.Binder; +import android.os.RemoteException; +import android.os.Handler; +import android.os.Hardware; +import android.os.IBinder; +import android.os.Message; +import android.os.Power; +import android.os.Vibrator; +import android.provider.Settings; +import android.util.Config; +import android.util.EventLog; +import android.util.Log; +import android.widget.Toast; + +import com.android.server.status.IconData; +import com.android.server.status.NotificationData; +import com.android.server.status.StatusBarService; + +import java.io.FileDescriptor; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Arrays; +import java.io.IOException; + +class NotificationManagerService extends INotificationManager.Stub +{ + private static final String TAG = "NotificationService"; + private static final boolean DBG = false; + + // message codes + private static final int MESSAGE_TIMEOUT = 2; + + private static final int LONG_DELAY = 3500; // 3.5 seconds + private static final int SHORT_DELAY = 2000; // 2 seconds + + private static final long[] DEFAULT_VIBRATE_PATTERN = {0, 250, 250, 250}; + + private static final int DEFAULT_STREAM_TYPE = AudioManager.STREAM_NOTIFICATION; + + final Context mContext; + final IActivityManager mAm; + final IBinder mForegroundToken = new Binder(); + + private WorkerHandler mHandler; + private StatusBarService mStatusBarService; + + private NotificationRecord mSoundNotification; + private AsyncPlayer mSound; + private int mDisabledNotifications; + + private NotificationRecord mVibrateNotification; + private Vibrator mVibrator = new Vibrator(); + + private ArrayList<NotificationRecord> mNotificationList; + + private ArrayList<ToastRecord> mToastQueue; + + private ArrayList<NotificationRecord> mLights = new ArrayList<NotificationRecord>(); + + private boolean mBatteryCharging; + private boolean mBatteryLow; + private boolean mBatteryFull; + private NotificationRecord mLedNotification; + + // Low battery - red, blinking on 0.125s every 3 seconds + private static final int BATTERY_LOW_ARGB = 0xFFFF0000; + private static final int BATTERY_LOW_ON = 125; + private static final int BATTERY_LOW_OFF = 2875; + + // Charging Low - red solid on + private static final int CHARGING_LOW_ARGB = 0xFFFF0000; + private static final int CHARGING_LOW_ON = 0; + private static final int CHARGING_LOW_OFF = 0; + + // Charging - orange solid on + private static final int CHARGING_ARGB = 0xFFFFFF00; + private static final int CHARGING_ON = 0; + private static final int CHARGING_OFF = 0; + + // Charging Full - green solid on + private static final int CHARGING_FULL_ARGB = 0xFF00FF00; + private static final int CHARGING_FULL_ON = 0; + private static final int CHARGING_FULL_OFF = 0; + + // Tag IDs for EventLog. + private static final int EVENT_LOG_ENQUEUE = 2750; + private static final int EVENT_LOG_CANCEL = 2751; + private static final int EVENT_LOG_CANCEL_ALL = 2752; + + private static String idDebugString(Context baseContext, String packageName, int id) { + Context c = null; + + if (packageName != null) { + try { + c = baseContext.createPackageContext(packageName, 0); + } catch (NameNotFoundException e) { + c = baseContext; + } + } else { + c = baseContext; + } + + String pkg; + String type; + String name; + + Resources r = c.getResources(); + try { + return r.getResourceName(id); + } catch (Resources.NotFoundException e) { + return "<name unknown>"; + } + } + + private static final class NotificationRecord + { + String pkg; + int id; + ITransientNotification callback; + int duration; + Notification notification; + IBinder statusBarKey; + + NotificationRecord(String pkg, int id, Notification notification) + { + this.pkg = pkg; + this.id = id; + this.notification = notification; + } + + void dump(PrintWriter pw, String prefix, Context baseContext) { + pw.println(prefix + this); + pw.println(prefix + " icon=0x" + Integer.toHexString(notification.icon) + + " / " + idDebugString(baseContext, this.pkg, notification.icon)); + pw.println(prefix + " contentIntent=" + notification.contentIntent); + pw.println(prefix + " deleteIntent=" + notification.deleteIntent); + pw.println(prefix + " tickerText=" + notification.tickerText); + pw.println(prefix + " contentView=" + notification.contentView); + pw.println(prefix + " defaults=0x" + Integer.toHexString(notification.defaults)); + pw.println(prefix + " flags=0x" + Integer.toHexString(notification.flags)); + pw.println(prefix + " sound=" + notification.sound); + pw.println(prefix + " vibrate=" + Arrays.toString(notification.vibrate)); + pw.println(prefix + " ledARGB=0x" + Integer.toHexString(notification.ledARGB) + + " ledOnMS=" + notification.ledOnMS + + " ledOffMS=" + notification.ledOffMS); + } + + @Override + public final String toString() + { + return "NotificationRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " pkg=" + pkg + + " id=" + Integer.toHexString(id) + "}"; + } + } + + private static final class ToastRecord + { + final int pid; + final String pkg; + final ITransientNotification callback; + int duration; + + ToastRecord(int pid, String pkg, ITransientNotification callback, int duration) + { + this.pid = pid; + this.pkg = pkg; + this.callback = callback; + this.duration = duration; + } + + void update(int duration) { + this.duration = duration; + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + } + + @Override + public final String toString() + { + return "ToastRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " pkg=" + pkg + + " callback=" + callback + + " duration=" + duration; + } + } + + private StatusBarService.NotificationCallbacks mNotificationCallbacks + = new StatusBarService.NotificationCallbacks() { + + public void onSetDisabled(int status) { + synchronized (mNotificationList) { + mDisabledNotifications = status; + if ((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) != 0) { + // cancel whatever's going on + long identity = Binder.clearCallingIdentity(); + try { + mSound.stop(); + } + finally { + Binder.restoreCallingIdentity(identity); + } + + identity = Binder.clearCallingIdentity(); + try { + mVibrator.cancel(); + } + finally { + Binder.restoreCallingIdentity(identity); + } + } + } + } + + public void onClearAll() { + cancelAll(); + } + + public void onNotificationClick(String pkg, int id) { + cancelNotification(pkg, id, Notification.FLAG_AUTO_CANCEL); + } + + public void onPanelRevealed() { + synchronized (mNotificationList) { + // sound + mSoundNotification = null; + long identity = Binder.clearCallingIdentity(); + try { + mSound.stop(); + } + finally { + Binder.restoreCallingIdentity(identity); + } + + // vibrate + mVibrateNotification = null; + identity = Binder.clearCallingIdentity(); + try { + mVibrator.cancel(); + } + finally { + Binder.restoreCallingIdentity(identity); + } + + // light + mLights.clear(); + mLedNotification = null; + updateLightsLocked(); + } + } + }; + + private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + + if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { + boolean batteryCharging = (intent.getIntExtra("plugged", 0) != 0); + int level = intent.getIntExtra("level", -1); + boolean batteryLow = (level >= 0 && level <= Power.LOW_BATTERY_THRESHOLD); + int status = intent.getIntExtra("status", BatteryManager.BATTERY_STATUS_UNKNOWN); + boolean batteryFull = (status == BatteryManager.BATTERY_STATUS_FULL || level >= 90); + + if (batteryCharging != mBatteryCharging || + batteryLow != mBatteryLow || + batteryFull != mBatteryFull) { + mBatteryCharging = batteryCharging; + mBatteryLow = batteryLow; + mBatteryFull = batteryFull; + updateLights(); + } + } else if (action.equals(Intent.ACTION_PACKAGE_REMOVED) + || action.equals(Intent.ACTION_PACKAGE_RESTARTED)) { + Uri uri = intent.getData(); + if (uri == null) { + return; + } + String pkgName = uri.getSchemeSpecificPart(); + if (pkgName == null) { + return; + } + cancelAllNotifications(pkgName); + } + } + }; + + NotificationManagerService(Context context, StatusBarService statusBar) + { + super(); + mContext = context; + mAm = ActivityManagerNative.getDefault(); + mSound = new AsyncPlayer(TAG); + mSound.setUsesWakeLock(context); + mToastQueue = new ArrayList<ToastRecord>(); + mNotificationList = new ArrayList<NotificationRecord>(); + mHandler = new WorkerHandler(); + mStatusBarService = statusBar; + statusBar.setNotificationCallbacks(mNotificationCallbacks); + + // register for battery changed notifications + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_BATTERY_CHANGED); + filter.addAction(Intent.ACTION_PACKAGE_REMOVED); + filter.addAction(Intent.ACTION_PACKAGE_RESTARTED); + mContext.registerReceiver(mIntentReceiver, filter); + } + + // Toasts + // ============================================================================ + public void enqueueToast(String pkg, ITransientNotification callback, int duration) + { + Log.i(TAG, "enqueueToast pkg=" + pkg + " callback=" + callback + " duration=" + duration); + + if (pkg == null || callback == null) { + Log.e(TAG, "Not doing toast. pkg=" + pkg + " callback=" + callback); + return ; + } + + synchronized (mToastQueue) { + int callingPid = Binder.getCallingPid(); + long callingId = Binder.clearCallingIdentity(); + try { + ToastRecord record; + int index = indexOfToastLocked(pkg, callback); + // If it's already in the queue, we update it in place, we don't + // move it to the end of the queue. + if (index >= 0) { + record = mToastQueue.get(index); + record.update(duration); + } else { + record = new ToastRecord(callingPid, pkg, callback, duration); + mToastQueue.add(record); + index = mToastQueue.size() - 1; + keepProcessAliveLocked(callingPid); + } + // If it's at index 0, it's the current toast. It doesn't matter if it's + // new or just been updated. Call back and tell it to show itself. + // If the callback fails, this will remove it from the list, so don't + // assume that it's valid after this. + if (index == 0) { + showNextToastLocked(); + } + } finally { + Binder.restoreCallingIdentity(callingId); + } + } + } + + public void cancelToast(String pkg, ITransientNotification callback) { + Log.i(TAG, "cancelToast pkg=" + pkg + " callback=" + callback); + + if (pkg == null || callback == null) { + Log.e(TAG, "Not cancelling notification. pkg=" + pkg + " callback=" + callback); + return ; + } + + synchronized (mToastQueue) { + long callingId = Binder.clearCallingIdentity(); + try { + int index = indexOfToastLocked(pkg, callback); + if (index >= 0) { + cancelToastLocked(index); + } else { + Log.w(TAG, "Toast already cancelled. pkg=" + pkg + " callback=" + callback); + } + } finally { + Binder.restoreCallingIdentity(callingId); + } + } + } + + private void showNextToastLocked() { + ToastRecord record = mToastQueue.get(0); + while (record != null) { + if (DBG) Log.d(TAG, "Show pkg=" + record.pkg + " callback=" + record.callback); + try { + record.callback.show(); + scheduleTimeoutLocked(record, false); + return; + } catch (RemoteException e) { + Log.w(TAG, "Object died trying to show notification " + record.callback + + " in package " + record.pkg); + // remove it from the list and let the process die + int index = mToastQueue.indexOf(record); + if (index >= 0) { + mToastQueue.remove(index); + } + keepProcessAliveLocked(record.pid); + if (mToastQueue.size() > 0) { + record = mToastQueue.get(0); + } else { + record = null; + } + } + } + } + + private void cancelToastLocked(int index) { + ToastRecord record = mToastQueue.get(index); + try { + record.callback.hide(); + } catch (RemoteException e) { + Log.w(TAG, "Object died trying to hide notification " + record.callback + + " in package " + record.pkg); + // don't worry about this, we're about to remove it from + // the list anyway + } + mToastQueue.remove(index); + keepProcessAliveLocked(record.pid); + if (mToastQueue.size() > 0) { + // Show the next one. If the callback fails, this will remove + // it from the list, so don't assume that the list hasn't changed + // after this point. + showNextToastLocked(); + } + } + + private void scheduleTimeoutLocked(ToastRecord r, boolean immediate) + { + Message m = Message.obtain(mHandler, MESSAGE_TIMEOUT, r); + long delay = immediate ? 0 : (r.duration == Toast.LENGTH_LONG ? LONG_DELAY : SHORT_DELAY); + mHandler.removeCallbacksAndMessages(r); + mHandler.sendMessageDelayed(m, delay); + } + + private void handleTimeout(ToastRecord record) + { + if (DBG) Log.d(TAG, "Timeout pkg=" + record.pkg + " callback=" + record.callback); + synchronized (mToastQueue) { + int index = indexOfToastLocked(record.pkg, record.callback); + if (index >= 0) { + cancelToastLocked(index); + } + } + } + + // lock on mToastQueue + private int indexOfToastLocked(String pkg, ITransientNotification callback) + { + IBinder cbak = callback.asBinder(); + ArrayList<ToastRecord> list = mToastQueue; + int len = list.size(); + for (int i=0; i<len; i++) { + ToastRecord r = list.get(i); + if (r.pkg.equals(pkg) && r.callback.asBinder() == cbak) { + return i; + } + } + return -1; + } + + // lock on mToastQueue + private void keepProcessAliveLocked(int pid) + { + int toastCount = 0; // toasts from this pid + ArrayList<ToastRecord> list = mToastQueue; + int N = list.size(); + for (int i=0; i<N; i++) { + ToastRecord r = list.get(i); + if (r.pid == pid) { + toastCount++; + } + } + try { + mAm.setProcessForeground(mForegroundToken, pid, toastCount > 0); + } catch (RemoteException e) { + // Shouldn't happen. + } + } + + private final class WorkerHandler extends Handler + { + @Override + public void handleMessage(Message msg) + { + switch (msg.what) + { + case MESSAGE_TIMEOUT: + handleTimeout((ToastRecord)msg.obj); + break; + } + } + } + + + // Notifications + // ============================================================================ + public void enqueueNotification(String pkg, int id, Notification notification, int[] idOut) + { + // This conditional is a dirty hack to limit the logging done on + // behalf of the download manager without affecting other apps. + if (!pkg.equals("com.android.providers.downloads") + || Log.isLoggable("DownloadManager", Log.VERBOSE)) { + EventLog.writeEvent(EVENT_LOG_ENQUEUE, pkg, id, notification.toString()); + } + + if (pkg == null || notification == null) { + throw new IllegalArgumentException("null not allowed: pkg=" + pkg + + " id=" + id + " notification=" + notification); + } + if (notification.icon != 0) { + if (notification.contentView == null) { + throw new IllegalArgumentException("contentView required: pkg=" + pkg + + " id=" + id + " notification=" + notification); + } + if (notification.contentIntent == null) { + throw new IllegalArgumentException("contentIntent required: pkg=" + pkg + + " id=" + id + " notification=" + notification); + } + } + + synchronized (mNotificationList) { + NotificationRecord r = new NotificationRecord(pkg, id, notification); + NotificationRecord old = null; + + int index = indexOfNotificationLocked(pkg, id); + if (index < 0) { + mNotificationList.add(r); + } else { + old = mNotificationList.remove(index); + mNotificationList.add(index, r); + } + if (notification.icon != 0) { + IconData icon = IconData.makeIcon(null, pkg, notification.icon, + notification.iconLevel, + notification.number); + CharSequence truncatedTicker = notification.tickerText; + + // TODO: make this restriction do something smarter like never fill + // more than two screens. "Why would anyone need more than 80 characters." :-/ + final int maxTickerLen = 80; + if (truncatedTicker != null && truncatedTicker.length() > maxTickerLen) { + truncatedTicker = truncatedTicker.subSequence(0, maxTickerLen); + } + + NotificationData n = new NotificationData(); + n.id = id; + n.pkg = pkg; + n.when = notification.when; + n.tickerText = truncatedTicker; + n.ongoingEvent = (notification.flags & Notification.FLAG_ONGOING_EVENT) != 0; + if (!n.ongoingEvent && (notification.flags & Notification.FLAG_NO_CLEAR) == 0) { + n.clearable = true; + } + n.contentView = notification.contentView; + n.contentIntent = notification.contentIntent; + n.deleteIntent = notification.deleteIntent; + if (old != null && old.statusBarKey != null) { + r.statusBarKey = old.statusBarKey; + long identity = Binder.clearCallingIdentity(); + try { + mStatusBarService.updateIcon(r.statusBarKey, icon, n); + } + finally { + Binder.restoreCallingIdentity(identity); + } + } else { + long identity = Binder.clearCallingIdentity(); + try { + r.statusBarKey = mStatusBarService.addIcon(icon, n); + } + finally { + Binder.restoreCallingIdentity(identity); + } + } + } else { + if (old != null && old.statusBarKey != null) { + long identity = Binder.clearCallingIdentity(); + try { + mStatusBarService.removeIcon(old.statusBarKey); + } + finally { + Binder.restoreCallingIdentity(identity); + } + } + } + + // If we're not supposed to beep, vibrate, etc. then don't. + if (((mDisabledNotifications & StatusBarManager.DISABLE_NOTIFICATION_ALERTS) == 0) + && (!(old != null + && (notification.flags & Notification.FLAG_ONLY_ALERT_ONCE) != 0 ))) { + // sound + final boolean useDefaultSound = + (notification.defaults & Notification.DEFAULT_SOUND) != 0; + if (useDefaultSound || notification.sound != null) { + Uri uri; + if (useDefaultSound) { + uri = Settings.System.DEFAULT_NOTIFICATION_URI; + } else { + uri = notification.sound; + } + boolean looping = (notification.flags & Notification.FLAG_INSISTENT) != 0; + int audioStreamType; + if (notification.audioStreamType >= 0) { + audioStreamType = notification.audioStreamType; + } else { + audioStreamType = DEFAULT_STREAM_TYPE; + } + mSoundNotification = r; + long identity = Binder.clearCallingIdentity(); + try { + mSound.play(mContext, uri, looping, audioStreamType); + } + finally { + Binder.restoreCallingIdentity(identity); + } + } + + // vibrate + final AudioManager audioManager = (AudioManager) mContext + .getSystemService(Context.AUDIO_SERVICE); + final boolean useDefaultVibrate = + (notification.defaults & Notification.DEFAULT_VIBRATE) != 0; + if ((useDefaultVibrate || notification.vibrate != null) + && audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_NOTIFICATION)) { + mVibrateNotification = r; + + mVibrator.vibrate(useDefaultVibrate ? DEFAULT_VIBRATE_PATTERN + : notification.vibrate, + ((notification.flags & Notification.FLAG_INSISTENT) != 0) ? 0: -1); + } + } + + // this option doesn't shut off the lights + + // light + // the most recent thing gets the light + mLights.remove(old); + if (mLedNotification == old) { + mLedNotification = null; + } + //Log.i(TAG, "notification.lights=" + // + ((old.notification.lights.flags & Notification.FLAG_SHOW_LIGHTS) != 0)); + if ((notification.flags & Notification.FLAG_SHOW_LIGHTS) != 0) { + mLights.add(r); + updateLightsLocked(); + } else { + if (old != null + && ((old.notification.flags & Notification.FLAG_SHOW_LIGHTS) != 0)) { + updateLightsLocked(); + } + } + } + + idOut[0] = id; + } + + private void cancelNotificationLocked(NotificationRecord r) { + // status bar + if (r.notification.icon != 0) { + long identity = Binder.clearCallingIdentity(); + try { + mStatusBarService.removeIcon(r.statusBarKey); + } + finally { + Binder.restoreCallingIdentity(identity); + } + r.statusBarKey = null; + } + + // sound + if (mSoundNotification == r) { + mSoundNotification = null; + long identity = Binder.clearCallingIdentity(); + try { + mSound.stop(); + } + finally { + Binder.restoreCallingIdentity(identity); + } + } + + // vibrate + if (mVibrateNotification == r) { + mVibrateNotification = null; + long identity = Binder.clearCallingIdentity(); + try { + mVibrator.cancel(); + } + finally { + Binder.restoreCallingIdentity(identity); + } + } + + // light + mLights.remove(r); + if (mLedNotification == r) { + mLedNotification = null; + } + } + + /** + * Cancels a notification ONLY if it has all of the {@code mustHaveFlags}. + */ + private void cancelNotification(String pkg, int id, int mustHaveFlags) { + EventLog.writeEvent(EVENT_LOG_CANCEL, pkg, id, mustHaveFlags); + + synchronized (mNotificationList) { + NotificationRecord r = null; + + int index = indexOfNotificationLocked(pkg, id); + if (index >= 0) { + r = mNotificationList.get(index); + + if ((r.notification.flags & mustHaveFlags) != mustHaveFlags) { + return; + } + + mNotificationList.remove(index); + + cancelNotificationLocked(r); + updateLightsLocked(); + } + } + } + + /** + * Cancels all notifications from a given package that have all of the + * {@code mustHaveFlags}. + */ + private void cancelAllNotificationsInt(String pkg, int mustHaveFlags) { + EventLog.writeEvent(EVENT_LOG_CANCEL_ALL, pkg, mustHaveFlags); + + synchronized (mNotificationList) { + final int N = mNotificationList.size(); + boolean canceledSomething = false; + for (int i = N-1; i >= 0; --i) { + NotificationRecord r = mNotificationList.get(i); + if ((r.notification.flags & mustHaveFlags) != mustHaveFlags) { + continue; + } + if (!r.pkg.equals(pkg)) { + continue; + } + mNotificationList.remove(i); + cancelNotificationLocked(r); + canceledSomething = true; + } + if (canceledSomething) { + updateLightsLocked(); + } + } + } + + + public void cancelNotification(String pkg, int id) + { + cancelNotification(pkg, id, 0); + } + + public void cancelAllNotifications(String pkg) + { + cancelAllNotificationsInt(pkg, 0); + } + + public void cancelAll() { + synchronized (mNotificationList) { + final int N = mNotificationList.size(); + for (int i=N-1; i>=0; i--) { + NotificationRecord r = mNotificationList.get(i); + + if ((r.notification.flags & (Notification.FLAG_ONGOING_EVENT + | Notification.FLAG_NO_CLEAR)) == 0) { + if (r.notification.deleteIntent != null) { + try { + r.notification.deleteIntent.send(); + } catch (PendingIntent.CanceledException ex) { + // do nothing - there's no relevant way to recover, and + // no reason to let this propagate + Log.w(TAG, "canceled PendingIntent for " + r.pkg, ex); + } + } + mNotificationList.remove(i); + cancelNotificationLocked(r); + } + } + + updateLightsLocked(); + } + } + + private void updateLights() { + synchronized (mNotificationList) { + updateLightsLocked(); + } + } + + // lock on mNotificationList + private void updateLightsLocked() + { + // battery low has highest priority, then charging + if (mBatteryLow && !mBatteryCharging) { + Hardware.setLedState(BATTERY_LOW_ARGB, BATTERY_LOW_ON, BATTERY_LOW_OFF); + } else if (mBatteryCharging) { + if (mBatteryLow) { + Hardware.setLedState(CHARGING_LOW_ARGB, CHARGING_LOW_ON, CHARGING_LOW_OFF); + } else if (mBatteryFull) { + Hardware.setLedState(CHARGING_FULL_ARGB, CHARGING_FULL_ON, CHARGING_FULL_OFF); + } else { + Hardware.setLedState(CHARGING_ARGB, CHARGING_ON, CHARGING_OFF); + } + } else { + // handle notification lights + if (mLedNotification == null) { + // get next notification, if any + int n = mLights.size(); + if (n > 0) { + mLedNotification = mLights.get(n-1); + } + } + + if (mLedNotification == null) { + Hardware.setLedState(0, 0, 0); + } else { + Hardware.setLedState(mLedNotification.notification.ledARGB, + mLedNotification.notification.ledOnMS, + mLedNotification.notification.ledOffMS); + } + } + } + + // lock on mNotificationList + private int indexOfNotificationLocked(String pkg, int id) + { + ArrayList<NotificationRecord> list = mNotificationList; + final int len = list.size(); + for (int i=0; i<len; i++) { + NotificationRecord r = list.get(i); + if (r.id == id && r.pkg.equals(pkg)) { + return i; + } + } + return -1; + } + + // ====================================================================== + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump NotificationManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + pw.println("Current Notification Manager state:"); + + int N; + + synchronized (mToastQueue) { + N = mToastQueue.size(); + if (N > 0) { + pw.println(" Toast Queue:"); + for (int i=0; i<N; i++) { + mToastQueue.get(i).dump(pw, " "); + } + pw.println(" "); + } + + } + + synchronized (mNotificationList) { + N = mNotificationList.size(); + if (N > 0) { + pw.println(" Notification List:"); + for (int i=0; i<N; i++) { + mNotificationList.get(i).dump(pw, " ", mContext); + } + pw.println(" "); + } + + N = mLights.size(); + if (N > 0) { + pw.println(" Lights List:"); + for (int i=0; i<N; i++) { + mLights.get(i).dump(pw, " ", mContext); + } + pw.println(" "); + } + + pw.println(" mSoundNotification=" + mSoundNotification); + pw.println(" mSound=" + mSound); + pw.println(" mVibrateNotification=" + mVibrateNotification); + } + } +} diff --git a/services/java/com/android/server/PackageManagerService.java b/services/java/com/android/server/PackageManagerService.java new file mode 100644 index 0000000..fec3608 --- /dev/null +++ b/services/java/com/android/server/PackageManagerService.java @@ -0,0 +1,6569 @@ +/* + * Copyright (C) 2006 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 com.android.internal.app.ResolverActivity; +import com.android.internal.util.FastXmlSerializer; +import com.android.internal.util.XmlUtils; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; +import org.xmlpull.v1.XmlSerializer; + +import android.app.ActivityManagerNative; +import android.app.IActivityManager; +import android.app.PendingIntent; +import android.app.PendingIntent.CanceledException; +import android.content.ComponentName; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.pm.ComponentInfo; +import android.content.pm.IPackageDataObserver; +import android.content.pm.IPackageDeleteObserver; +import android.content.pm.IPackageInstallObserver; +import android.content.pm.IPackageManager; +import android.content.pm.IPackageStatsObserver; +import android.content.pm.InstrumentationInfo; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.PackageStats; +import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT; +import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED; +import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED; +import static android.content.pm.PackageManager.PKG_INSTALL_COMPLETE; +import static android.content.pm.PackageManager.PKG_INSTALL_INCOMPLETE; +import android.content.pm.PackageParser; +import android.content.pm.PermissionInfo; +import android.content.pm.PermissionGroupInfo; +import android.content.pm.ProviderInfo; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.content.pm.Signature; +import android.content.pm.PackageParser.Package; +import android.net.Uri; +import android.os.Binder; +import android.os.Bundle; +import android.os.HandlerThread; +import android.os.Parcel; +import android.os.RemoteException; +import android.os.Environment; +import android.os.FileObserver; +import android.os.FileUtils; +import android.os.Handler; +import android.os.ParcelFileDescriptor; +import android.os.Process; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.util.*; +import android.view.Display; +import android.view.WindowManager; + +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FilenameFilter; +import java.io.IOException; +import java.io.InputStream; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; +import java.util.zip.ZipOutputStream; + +class PackageManagerService extends IPackageManager.Stub { + private static final String TAG = "PackageManager"; + private static final boolean DEBUG_SETTINGS = false; + private static final boolean DEBUG_PREFERRED = false; + + private static final boolean MULTIPLE_APPLICATION_UIDS = true; + private static final int RADIO_UID = Process.PHONE_UID; + private static final int FIRST_APPLICATION_UID = + Process.FIRST_APPLICATION_UID; + private static final int MAX_APPLICATION_UIDS = 1000; + + private static final boolean SHOW_INFO = false; + + private static final boolean GET_CERTIFICATES = true; + + private static final int REMOVE_EVENTS = + FileObserver.CLOSE_WRITE | FileObserver.DELETE | FileObserver.MOVED_FROM; + private static final int ADD_EVENTS = + FileObserver.CLOSE_WRITE /*| FileObserver.CREATE*/ | FileObserver.MOVED_TO; + + private static final int OBSERVER_EVENTS = REMOVE_EVENTS | ADD_EVENTS; + + static final int SCAN_MONITOR = 1<<0; + static final int SCAN_NO_DEX = 1<<1; + static final int SCAN_FORCE_DEX = 1<<2; + static final int SCAN_UPDATE_SIGNATURE = 1<<3; + static final int SCAN_FORWARD_LOCKED = 1<<4; + + static final int LOG_BOOT_PROGRESS_PMS_START = 3060; + static final int LOG_BOOT_PROGRESS_PMS_SYSTEM_SCAN_START = 3070; + static final int LOG_BOOT_PROGRESS_PMS_DATA_SCAN_START = 3080; + static final int LOG_BOOT_PROGRESS_PMS_SCAN_END = 3090; + static final int LOG_BOOT_PROGRESS_PMS_READY = 3100; + + final HandlerThread mHandlerThread = new HandlerThread("PackageManager", + Process.THREAD_PRIORITY_BACKGROUND); + final Handler mHandler; + + final int mSdkVersion = SystemProperties.getInt( + "ro.build.version.sdk", 0); + + final Context mContext; + final boolean mFactoryTest; + final DisplayMetrics mMetrics; + final int mDefParseFlags; + final String[] mSeparateProcesses; + + // This is where all application persistent data goes. + final File mAppDataDir; + + // This is the object monitoring the framework dir. + final FileObserver mFrameworkInstallObserver; + + // This is the object monitoring the system app dir. + final FileObserver mSystemInstallObserver; + + // This is the object monitoring mAppInstallDir. + final FileObserver mAppInstallObserver; + + // This is the object monitoring mDrmAppPrivateInstallDir. + final FileObserver mDrmAppInstallObserver; + + // Used for priviledge escalation. MUST NOT BE CALLED WITH mPackages + // LOCK HELD. Can be called with mInstallLock held. + final Installer mInstaller; + + final File mFrameworkDir; + final File mSystemAppDir; + final File mAppInstallDir; + + // Directory containing the private parts (e.g. code and non-resource assets) of forward-locked + // apps. + final File mDrmAppPrivateInstallDir; + + // ---------------------------------------------------------------- + + // Lock for state used when installing and doing other long running + // operations. Methods that must be called with this lock held have + // the prefix "LI". + final Object mInstallLock = new Object(); + + // These are the directories in the 3rd party applications installed dir + // that we have currently loaded packages from. Keys are the application's + // installed zip file (absolute codePath), and values are Package. + final HashMap<String, PackageParser.Package> mAppDirs = + new HashMap<String, PackageParser.Package>(); + + // Information for the parser to write more useful error messages. + File mScanningPath; + int mLastScanError; + + final int[] mOutPermissions = new int[3]; + + // ---------------------------------------------------------------- + + // Keys are String (package name), values are Package. This also serves + // as the lock for the global state. Methods that must be called with + // this lock held have the prefix "LP". + final HashMap<String, PackageParser.Package> mPackages = + new HashMap<String, PackageParser.Package>(); + + final Settings mSettings; + boolean mRestoredSettings; + boolean mReportedUidError; + + // Group-ids that are given to all packages as read from etc/permissions/*.xml. + int[] mGlobalGids; + + // These are the built-in uid -> permission mappings that were read from the + // etc/permissions.xml file. + final SparseArray<HashSet<String>> mSystemPermissions = + new SparseArray<HashSet<String>>(); + + // These are the built-in shared libraries that were read from the + // etc/permissions.xml file. + final HashMap<String, String> mSharedLibraries = new HashMap<String, String>(); + + // All available activities, for your resolving pleasure. + final ActivityIntentResolver mActivities = + new ActivityIntentResolver(); + + // All available receivers, for your resolving pleasure. + final ActivityIntentResolver mReceivers = + new ActivityIntentResolver(); + + // All available services, for your resolving pleasure. + final ServiceIntentResolver mServices = new ServiceIntentResolver(); + + // Keys are String (provider class name), values are Provider. + final HashMap<ComponentName, PackageParser.Provider> mProvidersByComponent = + new HashMap<ComponentName, PackageParser.Provider>(); + + // Mapping from provider base names (first directory in content URI codePath) + // to the provider information. + final HashMap<String, PackageParser.Provider> mProviders = + new HashMap<String, PackageParser.Provider>(); + + // Mapping from instrumentation class names to info about them. + final HashMap<ComponentName, PackageParser.Instrumentation> mInstrumentation = + new HashMap<ComponentName, PackageParser.Instrumentation>(); + + // Mapping from permission names to info about them. + final HashMap<String, PackageParser.PermissionGroup> mPermissionGroups = + new HashMap<String, PackageParser.PermissionGroup>(); + + boolean mSystemReady; + boolean mSafeMode; + boolean mHasSystemUidErrors; + + ApplicationInfo mAndroidApplication; + final ActivityInfo mResolveActivity = new ActivityInfo(); + final ResolveInfo mResolveInfo = new ResolveInfo(); + ComponentName mResolveComponentName; + PackageParser.Package mPlatformPackage; + + public static final IPackageManager main(Context context, boolean factoryTest) { + PackageManagerService m = new PackageManagerService(context, factoryTest); + ServiceManager.addService("package", m); + return m; + } + + static String[] splitString(String str, char sep) { + int count = 1; + int i = 0; + while ((i=str.indexOf(sep, i)) >= 0) { + count++; + i++; + } + + String[] res = new String[count]; + i=0; + count = 0; + int lastI=0; + while ((i=str.indexOf(sep, i)) >= 0) { + res[count] = str.substring(lastI, i); + count++; + i++; + lastI = i; + } + res[count] = str.substring(lastI, str.length()); + return res; + } + + public PackageManagerService(Context context, boolean factoryTest) { + EventLog.writeEvent(LOG_BOOT_PROGRESS_PMS_START, + SystemClock.uptimeMillis()); + + if (mSdkVersion <= 0) { + Log.w(TAG, "**** ro.build.version.sdk not set!"); + } + + mContext = context; + mFactoryTest = factoryTest; + mMetrics = new DisplayMetrics(); + mSettings = new Settings(); + mSettings.addSharedUserLP("android.uid.system", + Process.SYSTEM_UID, ApplicationInfo.FLAG_SYSTEM); + mSettings.addSharedUserLP("android.uid.phone", + MULTIPLE_APPLICATION_UIDS + ? RADIO_UID : FIRST_APPLICATION_UID, + ApplicationInfo.FLAG_SYSTEM); + + String separateProcesses = SystemProperties.get("debug.separate_processes"); + if (separateProcesses != null && separateProcesses.length() > 0) { + if ("*".equals(separateProcesses)) { + mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES; + mSeparateProcesses = null; + Log.w(TAG, "Running with debug.separate_processes: * (ALL)"); + } else { + mDefParseFlags = 0; + mSeparateProcesses = separateProcesses.split(","); + Log.w(TAG, "Running with debug.separate_processes: " + + separateProcesses); + } + } else { + mDefParseFlags = 0; + mSeparateProcesses = null; + } + + Installer installer = new Installer(); + // Little hacky thing to check if installd is here, to determine + // whether we are running on the simulator and thus need to take + // care of building the /data file structure ourself. + // (apparently the sim now has a working installer) + if (installer.ping() && Process.supportsProcesses()) { + mInstaller = installer; + } else { + mInstaller = null; + } + + WindowManager wm = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE); + Display d = wm.getDefaultDisplay(); + d.getMetrics(mMetrics); + + synchronized (mInstallLock) { + synchronized (mPackages) { + mHandlerThread.start(); + mHandler = new Handler(mHandlerThread.getLooper()); + + File dataDir = Environment.getDataDirectory(); + mAppDataDir = new File(dataDir, "data"); + mDrmAppPrivateInstallDir = new File(dataDir, "app-private"); + + if (mInstaller == null) { + // Make sure these dirs exist, when we are running in + // the simulator. + // Make a wide-open directory for random misc stuff. + File miscDir = new File(dataDir, "misc"); + miscDir.mkdirs(); + mAppDataDir.mkdirs(); + mDrmAppPrivateInstallDir.mkdirs(); + } + + readPermissions(); + + mRestoredSettings = mSettings.readLP(); + long startTime = SystemClock.uptimeMillis(); + + EventLog.writeEvent(LOG_BOOT_PROGRESS_PMS_SYSTEM_SCAN_START, + startTime); + + int scanMode = SCAN_MONITOR; + + final HashSet<String> libFiles = new HashSet<String>(); + + mFrameworkDir = new File(Environment.getRootDirectory(), "framework"); + + if (mInstaller != null) { + /** + * Out of paranoia, ensure that everything in the boot class + * path has been dexed. + */ + String bootClassPath = System.getProperty("java.boot.class.path"); + if (bootClassPath != null) { + String[] paths = splitString(bootClassPath, ':'); + for (int i=0; i<paths.length; i++) { + try { + if (dalvik.system.DexFile.isDexOptNeeded(paths[i])) { + libFiles.add(paths[i]); + mInstaller.dexopt(paths[i], Process.SYSTEM_UID, true); + } + } catch (FileNotFoundException e) { + Log.w(TAG, "Boot class path not found: " + paths[i]); + } catch (IOException e) { + Log.w(TAG, "Exception reading boot class path: " + paths[i], e); + } + } + } else { + Log.w(TAG, "No BOOTCLASSPATH found!"); + } + + /** + * Also ensure all external libraries have had dexopt run on them. + */ + if (mSharedLibraries.size() > 0) { + Iterator<String> libs = mSharedLibraries.values().iterator(); + while (libs.hasNext()) { + String lib = libs.next(); + try { + if (dalvik.system.DexFile.isDexOptNeeded(lib)) { + libFiles.add(lib); + mInstaller.dexopt(lib, Process.SYSTEM_UID, true); + } + } catch (FileNotFoundException e) { + Log.w(TAG, "Library not found: " + lib); + } catch (IOException e) { + Log.w(TAG, "Exception reading library: " + lib, e); + } + } + } + + // Gross hack for now: we know this file doesn't contain any + // code, so don't dexopt it to avoid the resulting log spew. + libFiles.add(mFrameworkDir.getPath() + "/framework-res.apk"); + + /** + * And there are a number of commands implemented in Java, which + * we currently need to do the dexopt on so that they can be + * run from a non-root shell. + */ + String[] frameworkFiles = mFrameworkDir.list(); + if (frameworkFiles != null && mInstaller != null) { + for (int i=0; i<frameworkFiles.length; i++) { + File libPath = new File(mFrameworkDir, frameworkFiles[i]); + String path = libPath.getPath(); + // Skip the file if we alrady did it. + if (libFiles.contains(path)) { + continue; + } + // Skip the file if it is not a type we want to dexopt. + if (!path.endsWith(".apk") && !path.endsWith(".jar")) { + continue; + } + try { + if (dalvik.system.DexFile.isDexOptNeeded(path)) { + mInstaller.dexopt(path, Process.SYSTEM_UID, true); + } + } catch (FileNotFoundException e) { + Log.w(TAG, "Jar not found: " + path); + } catch (IOException e) { + Log.w(TAG, "Exception reading jar: " + path, e); + } + } + } + } + + mFrameworkInstallObserver = new AppDirObserver( + mFrameworkDir.getPath(), OBSERVER_EVENTS, true); + mFrameworkInstallObserver.startWatching(); + scanDirLI(mFrameworkDir, PackageParser.PARSE_IS_SYSTEM, + scanMode | SCAN_NO_DEX); + mSystemAppDir = new File(Environment.getRootDirectory(), "app"); + mSystemInstallObserver = new AppDirObserver( + mSystemAppDir.getPath(), OBSERVER_EVENTS, true); + mSystemInstallObserver.startWatching(); + scanDirLI(mSystemAppDir, PackageParser.PARSE_IS_SYSTEM, scanMode); + mAppInstallDir = new File(dataDir, "app"); + if (mInstaller == null) { + // Make sure these dirs exist, when we are running in + // the simulator. + mAppInstallDir.mkdirs(); // scanDirLI() assumes this dir exists + } + //look for any incomplete package installations + ArrayList<String> deletePkgsList = mSettings.getListOfIncompleteInstallPackages(); + //clean up list + for(int i = 0; i < deletePkgsList.size(); i++) { + //clean up here + cleanupInstallFailedPackage(deletePkgsList.get(i)); + } + //delete tmp files + deleteTempPackageFiles(); + + EventLog.writeEvent(LOG_BOOT_PROGRESS_PMS_DATA_SCAN_START, + SystemClock.uptimeMillis()); + mAppInstallObserver = new AppDirObserver( + mAppInstallDir.getPath(), OBSERVER_EVENTS, false); + mAppInstallObserver.startWatching(); + scanDirLI(mAppInstallDir, 0, scanMode); + + mDrmAppInstallObserver = new AppDirObserver( + mDrmAppPrivateInstallDir.getPath(), OBSERVER_EVENTS, false); + mDrmAppInstallObserver.startWatching(); + scanDirLI(mDrmAppPrivateInstallDir, 0, scanMode); + + EventLog.writeEvent(LOG_BOOT_PROGRESS_PMS_SCAN_END, + SystemClock.uptimeMillis()); + Log.i(TAG, "Time to scan packages: " + + ((SystemClock.uptimeMillis()-startTime)/1000f) + + " seconds"); + + updatePermissionsLP(); + + mSettings.writeLP(); + + EventLog.writeEvent(LOG_BOOT_PROGRESS_PMS_READY, + SystemClock.uptimeMillis()); + + // Now after opening every single application zip, make sure they + // are all flushed. Not really needed, but keeps things nice and + // tidy. + Runtime.getRuntime().gc(); + } // synchronized (mPackages) + } // synchronized (mInstallLock) + } + + @Override + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) + throws RemoteException { + try { + return super.onTransact(code, data, reply, flags); + } catch (RuntimeException e) { + if (!(e instanceof SecurityException) && !(e instanceof IllegalArgumentException)) { + Log.e(TAG, "Package Manager Crash", e); + } + throw e; + } + } + + void cleanupInstallFailedPackage(String packageName) { + if (mInstaller != null) { + int retCode = mInstaller.remove(packageName); + if (retCode < 0) { + Log.w(TAG, "Couldn't remove app data directory for package: " + + packageName + ", retcode=" + retCode); + } + } else { + //for emulator + PackageParser.Package pkg = mPackages.get(packageName); + File dataDir = new File(pkg.applicationInfo.dataDir); + dataDir.delete(); + } + mSettings.removePackageLP(packageName); + } + + void readPermissions() { + // Read permissions from .../etc/permission directory. + File libraryDir = new File(Environment.getRootDirectory(), "etc/permissions"); + if (!libraryDir.exists() || !libraryDir.isDirectory()) { + Log.w(TAG, "No directory " + libraryDir + ", skipping"); + return; + } + if (!libraryDir.canRead()) { + Log.w(TAG, "Directory " + libraryDir + " cannot be read"); + return; + } + + // Iterate over the files in the directory and scan .xml files + for (File f : libraryDir.listFiles()) { + // We'll read platform.xml last + if (f.getPath().endsWith("etc/permissions/platform.xml")) { + continue; + } + + if (!f.getPath().endsWith(".xml")) { + Log.i(TAG, "Non-xml file " + f + " in " + libraryDir + " directory, ignoring"); + continue; + } + if (!f.canRead()) { + Log.w(TAG, "Permissions library file " + f + " cannot be read"); + continue; + } + + readPermissionsFromXml(f); + } + + // Read permissions from .../etc/permissions/platform.xml last so it will take precedence + final File permFile = new File(Environment.getRootDirectory(), + "etc/permissions/platform.xml"); + readPermissionsFromXml(permFile); + } + + private void readPermissionsFromXml(File permFile) { + FileReader permReader = null; + try { + permReader = new FileReader(permFile); + } catch (FileNotFoundException e) { + Log.w(TAG, "Couldn't find or open permissions file " + permFile); + return; + } + + try { + XmlPullParser parser = Xml.newPullParser(); + parser.setInput(permReader); + + XmlUtils.beginDocument(parser, "permissions"); + + while (true) { + XmlUtils.nextElement(parser); + if (parser.getEventType() == XmlPullParser.END_DOCUMENT) { + break; + } + + String name = parser.getName(); + if ("group".equals(name)) { + String gidStr = parser.getAttributeValue(null, "gid"); + if (gidStr != null) { + int gid = Integer.parseInt(gidStr); + mGlobalGids = appendInt(mGlobalGids, gid); + } else { + Log.w(TAG, "<group> without gid at " + + parser.getPositionDescription()); + } + + XmlUtils.skipCurrentTag(parser); + continue; + } else if ("permission".equals(name)) { + String perm = parser.getAttributeValue(null, "name"); + if (perm == null) { + Log.w(TAG, "<permission> without name at " + + parser.getPositionDescription()); + XmlUtils.skipCurrentTag(parser); + continue; + } + perm = perm.intern(); + readPermission(parser, perm); + + } else if ("assign-permission".equals(name)) { + String perm = parser.getAttributeValue(null, "name"); + if (perm == null) { + Log.w(TAG, "<assign-permission> without name at " + + parser.getPositionDescription()); + XmlUtils.skipCurrentTag(parser); + continue; + } + String uidStr = parser.getAttributeValue(null, "uid"); + if (uidStr == null) { + Log.w(TAG, "<assign-permission> without uid at " + + parser.getPositionDescription()); + XmlUtils.skipCurrentTag(parser); + continue; + } + int uid = Process.getUidForName(uidStr); + if (uid < 0) { + Log.w(TAG, "<assign-permission> with unknown uid \"" + + uidStr + "\" at " + + parser.getPositionDescription()); + XmlUtils.skipCurrentTag(parser); + continue; + } + perm = perm.intern(); + HashSet<String> perms = mSystemPermissions.get(uid); + if (perms == null) { + perms = new HashSet<String>(); + mSystemPermissions.put(uid, perms); + } + perms.add(perm); + XmlUtils.skipCurrentTag(parser); + + } else if ("library".equals(name)) { + String lname = parser.getAttributeValue(null, "name"); + String lfile = parser.getAttributeValue(null, "file"); + if (lname == null) { + Log.w(TAG, "<library> without name at " + + parser.getPositionDescription()); + } else if (lfile == null) { + Log.w(TAG, "<library> without file at " + + parser.getPositionDescription()); + } else { + Log.i(TAG, "Got library " + lname + " in " + lfile); + this.mSharedLibraries.put(lname, lfile); + } + XmlUtils.skipCurrentTag(parser); + continue; + + } else { + XmlUtils.skipCurrentTag(parser); + continue; + } + + } + } catch (XmlPullParserException e) { + Log.w(TAG, "Got execption parsing permissions.", e); + } catch (IOException e) { + Log.w(TAG, "Got execption parsing permissions.", e); + } + } + + void readPermission(XmlPullParser parser, String name) + throws IOException, XmlPullParserException { + + name = name.intern(); + + BasePermission bp = mSettings.mPermissions.get(name); + if (bp == null) { + bp = new BasePermission(name, null, BasePermission.TYPE_BUILTIN); + mSettings.mPermissions.put(name, bp); + } + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if ("group".equals(tagName)) { + String gidStr = parser.getAttributeValue(null, "gid"); + if (gidStr != null) { + int gid = Process.getGidForName(gidStr); + bp.gids = appendInt(bp.gids, gid); + } else { + Log.w(TAG, "<group> without gid at " + + parser.getPositionDescription()); + } + } + XmlUtils.skipCurrentTag(parser); + } + } + + static int[] appendInt(int[] cur, int val) { + if (cur == null) { + return new int[] { val }; + } + final int N = cur.length; + for (int i=0; i<N; i++) { + if (cur[i] == val) { + return cur; + } + } + int[] ret = new int[N+1]; + System.arraycopy(cur, 0, ret, 0, N); + ret[N] = val; + return ret; + } + + static int[] appendInts(int[] cur, int[] add) { + if (add == null) return cur; + if (cur == null) return add; + final int N = add.length; + for (int i=0; i<N; i++) { + cur = appendInt(cur, add[i]); + } + return cur; + } + + PackageInfo generatePackageInfo(PackageParser.Package p, int flags) { + final PackageSetting ps = (PackageSetting)p.mExtras; + if (ps == null) { + return null; + } + final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps; + return PackageParser.generatePackageInfo(p, gp.gids, flags); + } + + public PackageInfo getPackageInfo(String packageName, int flags) { + synchronized (mPackages) { + PackageParser.Package p = mPackages.get(packageName); + if (Config.LOGV) Log.v( + TAG, "getApplicationInfo " + packageName + + ": " + p); + if (p != null) { + return generatePackageInfo(p, flags); + } + if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) { + return generatePackageInfoFromSettingsLP(packageName, flags); + } + } + return null; + } + + public int getPackageUid(String packageName) { + synchronized (mPackages) { + PackageParser.Package p = mPackages.get(packageName); + if(p != null) { + return p.applicationInfo.uid; + } + PackageSetting ps = mSettings.mPackages.get(packageName); + if((ps == null) || (ps.pkg == null) || (ps.pkg.applicationInfo == null)) { + return -1; + } + p = ps.pkg; + return p != null ? p.applicationInfo.uid : -1; + } + } + + public int[] getPackageGids(String packageName) { + synchronized (mPackages) { + PackageParser.Package p = mPackages.get(packageName); + if (Config.LOGV) Log.v( + TAG, "getApplicationInfo " + packageName + + ": " + p); + if (p != null) { + final PackageSetting ps = (PackageSetting)p.mExtras; + final SharedUserSetting suid = ps.sharedUser; + return suid != null ? suid.gids : ps.gids; + } + } + // stupid thing to indicate an error. + return new int[0]; + } + + public PermissionInfo getPermissionInfo(String name, int flags) { + synchronized (mPackages) { + final BasePermission p = mSettings.mPermissions.get(name); + if (p != null && p.perm != null) { + return PackageParser.generatePermissionInfo(p.perm, flags); + } + return null; + } + } + + public List<PermissionInfo> queryPermissionsByGroup(String group, int flags) { + synchronized (mPackages) { + ArrayList<PermissionInfo> out = new ArrayList<PermissionInfo>(10); + for (BasePermission p : mSettings.mPermissions.values()) { + if (group == null) { + if (p.perm.info.group == null) { + out.add(PackageParser.generatePermissionInfo(p.perm, flags)); + } + } else { + if (group.equals(p.perm.info.group)) { + out.add(PackageParser.generatePermissionInfo(p.perm, flags)); + } + } + } + + if (out.size() > 0) { + return out; + } + return mPermissionGroups.containsKey(group) ? out : null; + } + } + + public PermissionGroupInfo getPermissionGroupInfo(String name, int flags) { + synchronized (mPackages) { + return PackageParser.generatePermissionGroupInfo( + mPermissionGroups.get(name), flags); + } + } + + public List<PermissionGroupInfo> getAllPermissionGroups(int flags) { + synchronized (mPackages) { + final int N = mPermissionGroups.size(); + ArrayList<PermissionGroupInfo> out + = new ArrayList<PermissionGroupInfo>(N); + for (PackageParser.PermissionGroup pg : mPermissionGroups.values()) { + out.add(PackageParser.generatePermissionGroupInfo(pg, flags)); + } + return out; + } + } + + private ApplicationInfo generateApplicationInfoFromSettingsLP(String packageName, int flags) { + PackageSetting ps = mSettings.mPackages.get(packageName); + if(ps != null) { + if(ps.pkg == null) { + PackageInfo pInfo = generatePackageInfoFromSettingsLP(packageName, flags); + if(pInfo != null) { + return pInfo.applicationInfo; + } + return null; + } + return PackageParser.generateApplicationInfo(ps.pkg, flags); + } + return null; + } + + private PackageInfo generatePackageInfoFromSettingsLP(String packageName, int flags) { + PackageSetting ps = mSettings.mPackages.get(packageName); + if(ps != null) { + if(ps.pkg == null) { + ps.pkg = new PackageParser.Package(packageName); + ps.pkg.applicationInfo.packageName = packageName; + } + return generatePackageInfo(ps.pkg, flags); + } + return null; + } + + public ApplicationInfo getApplicationInfo(String packageName, int flags) { + synchronized (mPackages) { + PackageParser.Package p = mPackages.get(packageName); + if (Config.LOGV) Log.v( + TAG, "getApplicationInfo " + packageName + + ": " + p); + if (p != null) { + // Note: isEnabledLP() does not apply here - always return info + return PackageParser.generateApplicationInfo(p, flags); + } + if ("android".equals(packageName)||"system".equals(packageName)) { + return mAndroidApplication; + } + if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) { + return generateApplicationInfoFromSettingsLP(packageName, flags); + } + } + return null; + } + + + public void freeStorageAndNotify(final long freeStorageSize, final IPackageDataObserver observer) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.CLEAR_APP_CACHE, null); + // Queue up an async operation since clearing cache may take a little while. + mHandler.post(new Runnable() { + public void run() { + mHandler.removeCallbacks(this); + int retCode = -1; + if (mInstaller != null) { + retCode = mInstaller.freeCache(freeStorageSize); + if (retCode < 0) { + Log.w(TAG, "Couldn't clear application caches"); + } + } //end if mInstaller + if (observer != null) { + try { + observer.onRemoveCompleted(null, (retCode >= 0)); + } catch (RemoteException e) { + Log.w(TAG, "RemoveException when invoking call back"); + } + } + } + }); + } + + public void freeStorage(final long freeStorageSize, final PendingIntent opFinishedIntent) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.CLEAR_APP_CACHE, null); + // Queue up an async operation since clearing cache may take a little while. + mHandler.post(new Runnable() { + public void run() { + mHandler.removeCallbacks(this); + int retCode = -1; + if (mInstaller != null) { + retCode = mInstaller.freeCache(freeStorageSize); + if (retCode < 0) { + Log.w(TAG, "Couldn't clear application caches"); + } + } + if(opFinishedIntent != null) { + try { + // Callback via pending intent + opFinishedIntent.send((retCode >= 0) ? 1 : 0); + } catch (CanceledException e1) { + Log.i(TAG, "Failed to send pending intent"); + } + } + } + }); + } + + public ActivityInfo getActivityInfo(ComponentName component, int flags) { + synchronized (mPackages) { + PackageParser.Activity a = mActivities.mActivities.get(component); + if (Config.LOGV) Log.v( + TAG, "getActivityInfo " + component + ": " + a); + if (a != null && mSettings.isEnabledLP(a.info, flags)) { + return PackageParser.generateActivityInfo(a, flags); + } + if (mResolveComponentName.equals(component)) { + return mResolveActivity; + } + } + return null; + } + + public ActivityInfo getReceiverInfo(ComponentName component, int flags) { + synchronized (mPackages) { + PackageParser.Activity a = mReceivers.mActivities.get(component); + if (Config.LOGV) Log.v( + TAG, "getReceiverInfo " + component + ": " + a); + if (a != null && mSettings.isEnabledLP(a.info, flags)) { + return PackageParser.generateActivityInfo(a, flags); + } + } + return null; + } + + public ServiceInfo getServiceInfo(ComponentName component, int flags) { + synchronized (mPackages) { + PackageParser.Service s = mServices.mServices.get(component); + if (Config.LOGV) Log.v( + TAG, "getServiceInfo " + component + ": " + s); + if (s != null && mSettings.isEnabledLP(s.info, flags)) { + return PackageParser.generateServiceInfo(s, flags); + } + } + return null; + } + + public String[] getSystemSharedLibraryNames() { + Set<String> libSet; + synchronized (mPackages) { + libSet = mSharedLibraries.keySet(); + } + int size = libSet.size(); + if (size > 0) { + String[] libs = new String[size]; + libSet.toArray(libs); + return libs; + } + return null; + } + + public int checkPermission(String permName, String pkgName) { + synchronized (mPackages) { + PackageParser.Package p = mPackages.get(pkgName); + if (p != null && p.mExtras != null) { + PackageSetting ps = (PackageSetting)p.mExtras; + if (ps.sharedUser != null) { + if (ps.sharedUser.grantedPermissions.contains(permName)) { + return PackageManager.PERMISSION_GRANTED; + } + } else if (ps.grantedPermissions.contains(permName)) { + return PackageManager.PERMISSION_GRANTED; + } + } + } + return PackageManager.PERMISSION_DENIED; + } + + public int checkUidPermission(String permName, int uid) { + synchronized (mPackages) { + Object obj = mSettings.getUserIdLP(uid); + if (obj != null) { + if (obj instanceof SharedUserSetting) { + SharedUserSetting sus = (SharedUserSetting)obj; + if (sus.grantedPermissions.contains(permName)) { + return PackageManager.PERMISSION_GRANTED; + } + } else if (obj instanceof PackageSetting) { + PackageSetting ps = (PackageSetting)obj; + if (ps.grantedPermissions.contains(permName)) { + return PackageManager.PERMISSION_GRANTED; + } + } + } else { + HashSet<String> perms = mSystemPermissions.get(uid); + if (perms != null && perms.contains(permName)) { + return PackageManager.PERMISSION_GRANTED; + } + } + } + return PackageManager.PERMISSION_DENIED; + } + + private BasePermission findPermissionTreeLP(String permName) { + for(BasePermission bp : mSettings.mPermissionTrees.values()) { + if (permName.startsWith(bp.name) && + permName.length() > bp.name.length() && + permName.charAt(bp.name.length()) == '.') { + return bp; + } + } + return null; + } + + private BasePermission checkPermissionTreeLP(String permName) { + if (permName != null) { + BasePermission bp = findPermissionTreeLP(permName); + if (bp != null) { + if (bp.uid == Binder.getCallingUid()) { + return bp; + } + throw new SecurityException("Calling uid " + + Binder.getCallingUid() + + " is not allowed to add to permission tree " + + bp.name + " owned by uid " + bp.uid); + } + } + throw new SecurityException("No permission tree found for " + permName); + } + + public boolean addPermission(PermissionInfo info) { + synchronized (mPackages) { + if (info.labelRes == 0 && info.nonLocalizedLabel == null) { + throw new SecurityException("Label must be specified in permission"); + } + BasePermission tree = checkPermissionTreeLP(info.name); + BasePermission bp = mSettings.mPermissions.get(info.name); + boolean added = bp == null; + if (added) { + bp = new BasePermission(info.name, tree.sourcePackage, + BasePermission.TYPE_DYNAMIC); + } else if (bp.type != BasePermission.TYPE_DYNAMIC) { + throw new SecurityException( + "Not allowed to modify non-dynamic permission " + + info.name); + } + bp.perm = new PackageParser.Permission(tree.perm.owner, + new PermissionInfo(info)); + bp.perm.info.packageName = tree.perm.info.packageName; + bp.uid = tree.uid; + if (added) { + mSettings.mPermissions.put(info.name, bp); + } + mSettings.writeLP(); + return added; + } + } + + public void removePermission(String name) { + synchronized (mPackages) { + checkPermissionTreeLP(name); + BasePermission bp = mSettings.mPermissions.get(name); + if (bp != null) { + if (bp.type != BasePermission.TYPE_DYNAMIC) { + throw new SecurityException( + "Not allowed to modify non-dynamic permission " + + name); + } + mSettings.mPermissions.remove(name); + mSettings.writeLP(); + } + } + } + + public int checkSignatures(String pkg1, String pkg2) { + synchronized (mPackages) { + PackageParser.Package p1 = mPackages.get(pkg1); + PackageParser.Package p2 = mPackages.get(pkg2); + if (p1 == null || p1.mExtras == null + || p2 == null || p2.mExtras == null) { + return PackageManager.SIGNATURE_UNKNOWN_PACKAGE; + } + return checkSignaturesLP(p1, p2); + } + } + + int checkSignaturesLP(PackageParser.Package p1, PackageParser.Package p2) { + if (p1.mSignatures == null) { + return p2.mSignatures == null + ? PackageManager.SIGNATURE_NEITHER_SIGNED + : PackageManager.SIGNATURE_FIRST_NOT_SIGNED; + } + if (p2.mSignatures == null) { + return PackageManager.SIGNATURE_SECOND_NOT_SIGNED; + } + final int N1 = p1.mSignatures.length; + final int N2 = p2.mSignatures.length; + for (int i=0; i<N1; i++) { + boolean match = false; + for (int j=0; j<N2; j++) { + if (p1.mSignatures[i].equals(p2.mSignatures[j])) { + match = true; + break; + } + } + if (!match) { + return PackageManager.SIGNATURE_NO_MATCH; + } + } + return PackageManager.SIGNATURE_MATCH; + } + + public String[] getPackagesForUid(int uid) { + synchronized (mPackages) { + Object obj = mSettings.getUserIdLP(uid); + if (obj instanceof SharedUserSetting) { + SharedUserSetting sus = (SharedUserSetting)obj; + final int N = sus.packages.size(); + String[] res = new String[N]; + Iterator<PackageSetting> it = sus.packages.iterator(); + int i=0; + while (it.hasNext()) { + res[i++] = it.next().name; + } + return res; + } else if (obj instanceof PackageSetting) { + PackageSetting ps = (PackageSetting)obj; + return new String[] { ps.name }; + } + } + return null; + } + + public String getNameForUid(int uid) { + synchronized (mPackages) { + Object obj = mSettings.getUserIdLP(uid); + if (obj instanceof SharedUserSetting) { + SharedUserSetting sus = (SharedUserSetting)obj; + return sus.name + ":" + sus.userId; + } else if (obj instanceof PackageSetting) { + PackageSetting ps = (PackageSetting)obj; + return ps.name; + } + } + return null; + } + + public int getUidForSharedUser(String sharedUserName) { + if(sharedUserName == null) { + return -1; + } + synchronized (mPackages) { + SharedUserSetting suid = mSettings.getSharedUserLP(sharedUserName, 0, false); + if(suid == null) { + return -1; + } + return suid.userId; + } + } + + public ResolveInfo resolveIntent(Intent intent, String resolvedType, + int flags) { + List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags); + if (query != null) { + final int N = query.size(); + if (N == 1) { + return query.get(0); + } else if (N > 1) { + // If there is more than one activity with the same priority, + // then let the user decide between them. + ResolveInfo r0 = query.get(0); + ResolveInfo r1 = query.get(1); + if (false) { + System.out.println(r0.activityInfo.name + + "=" + r0.priority + " vs " + + r1.activityInfo.name + + "=" + r1.priority); + } + // If the first activity has a higher priority, or a different + // default, then it is always desireable to pick it. + if (r0.priority != r1.priority + || r0.preferredOrder != r1.preferredOrder + || r0.isDefault != r1.isDefault) { + return query.get(0); + } + // If we have saved a preference for a preferred activity for + // this Intent, use that. + ResolveInfo ri = findPreferredActivity(intent, resolvedType, + flags, query, r0.priority); + if (ri != null) { + return ri; + } + return mResolveInfo; + } + } + return null; + } + + ResolveInfo findPreferredActivity(Intent intent, String resolvedType, + int flags, List<ResolveInfo> query, int priority) { + synchronized (mPackages) { + if (DEBUG_PREFERRED) intent.addFlags(Intent.FLAG_DEBUG_LOG_RESOLUTION); + List<PreferredActivity> prefs = + mSettings.mPreferredActivities.queryIntent(null, + intent, resolvedType, + (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0); + if (prefs != null && prefs.size() > 0) { + // First figure out how good the original match set is. + // We will only allow preferred activities that came + // from the same match quality. + int match = 0; + final int N = query.size(); + if (DEBUG_PREFERRED) Log.v(TAG, "Figuring out best match..."); + for (int j=0; j<N; j++) { + ResolveInfo ri = query.get(j); + if (DEBUG_PREFERRED) Log.v(TAG, "Match for " + ri.activityInfo + + ": 0x" + Integer.toHexString(match)); + if (ri.match > match) match = ri.match; + } + if (DEBUG_PREFERRED) Log.v(TAG, "Best match: 0x" + + Integer.toHexString(match)); + match &= IntentFilter.MATCH_CATEGORY_MASK; + final int M = prefs.size(); + for (int i=0; i<M; i++) { + PreferredActivity pa = prefs.get(i); + if (pa.mMatch != match) { + continue; + } + ActivityInfo ai = getActivityInfo(pa.mActivity, flags); + if (DEBUG_PREFERRED) { + Log.v(TAG, "Got preferred activity:"); + ai.dump(new LogPrinter(Log.INFO, TAG), " "); + } + if (ai != null) { + for (int j=0; j<N; j++) { + ResolveInfo ri = query.get(j); + if (!ri.activityInfo.applicationInfo.packageName + .equals(ai.applicationInfo.packageName)) { + continue; + } + if (!ri.activityInfo.name.equals(ai.name)) { + continue; + } + + // Okay we found a previously set preferred app. + // If the result set is different from when this + // was created, we need to clear it and re-ask the + // user their preference. + if (!pa.sameSet(query, priority)) { + Log.i(TAG, "Result set changed, dropping preferred activity for " + + intent + " type " + resolvedType); + mSettings.mPreferredActivities.removeFilter(pa); + return null; + } + + // Yay! + return ri; + } + } + } + } + } + return null; + } + + public List<ResolveInfo> queryIntentActivities(Intent intent, + String resolvedType, int flags) { + ComponentName comp = intent.getComponent(); + if (comp != null) { + List<ResolveInfo> list = new ArrayList<ResolveInfo>(1); + ActivityInfo ai = getActivityInfo(comp, flags); + if (ai != null) { + ResolveInfo ri = new ResolveInfo(); + ri.activityInfo = ai; + list.add(ri); + } + return list; + } + + synchronized (mPackages) { + return (List<ResolveInfo>)mActivities. + queryIntent(null, intent, resolvedType, flags); + } + } + + public List<ResolveInfo> queryIntentActivityOptions(ComponentName caller, + Intent[] specifics, String[] specificTypes, Intent intent, + String resolvedType, int flags) { + final String resultsAction = intent.getAction(); + + List<ResolveInfo> results = queryIntentActivities( + intent, resolvedType, flags|PackageManager.GET_RESOLVED_FILTER); + if (Config.LOGV) Log.v(TAG, "Query " + intent + ": " + results); + + int specificsPos = 0; + int N; + + // todo: note that the algorithm used here is O(N^2). This + // isn't a problem in our current environment, but if we start running + // into situations where we have more than 5 or 10 matches then this + // should probably be changed to something smarter... + + // First we go through and resolve each of the specific items + // that were supplied, taking care of removing any corresponding + // duplicate items in the generic resolve list. + if (specifics != null) { + for (int i=0; i<specifics.length; i++) { + final Intent sintent = specifics[i]; + if (sintent == null) { + continue; + } + + if (Config.LOGV) Log.v(TAG, "Specific #" + i + ": " + sintent); + String action = sintent.getAction(); + if (resultsAction != null && resultsAction.equals(action)) { + // If this action was explicitly requested, then don't + // remove things that have it. + action = null; + } + ComponentName comp = sintent.getComponent(); + ResolveInfo ri = null; + ActivityInfo ai = null; + if (comp == null) { + ri = resolveIntent( + sintent, + specificTypes != null ? specificTypes[i] : null, + flags); + if (ri == null) { + continue; + } + if (ri == mResolveInfo) { + // ACK! Must do something better with this. + } + ai = ri.activityInfo; + comp = new ComponentName(ai.applicationInfo.packageName, + ai.name); + } else { + ai = getActivityInfo(comp, flags); + if (ai == null) { + continue; + } + } + + // Look for any generic query activities that are duplicates + // of this specific one, and remove them from the results. + if (Config.LOGV) Log.v(TAG, "Specific #" + i + ": " + ai); + N = results.size(); + int j; + for (j=specificsPos; j<N; j++) { + ResolveInfo sri = results.get(j); + if ((sri.activityInfo.name.equals(comp.getClassName()) + && sri.activityInfo.applicationInfo.packageName.equals( + comp.getPackageName())) + || (action != null && sri.filter.matchAction(action))) { + results.remove(j); + if (Config.LOGV) Log.v( + TAG, "Removing duplicate item from " + j + + " due to specific " + specificsPos); + if (ri == null) { + ri = sri; + } + j--; + N--; + } + } + + // Add this specific item to its proper place. + if (ri == null) { + ri = new ResolveInfo(); + ri.activityInfo = ai; + } + results.add(specificsPos, ri); + ri.specificIndex = i; + specificsPos++; + } + } + + // Now we go through the remaining generic results and remove any + // duplicate actions that are found here. + N = results.size(); + for (int i=specificsPos; i<N-1; i++) { + final ResolveInfo rii = results.get(i); + if (rii.filter == null) { + continue; + } + + // Iterate over all of the actions of this result's intent + // filter... typically this should be just one. + final Iterator<String> it = rii.filter.actionsIterator(); + if (it == null) { + continue; + } + while (it.hasNext()) { + final String action = it.next(); + if (resultsAction != null && resultsAction.equals(action)) { + // If this action was explicitly requested, then don't + // remove things that have it. + continue; + } + for (int j=i+1; j<N; j++) { + final ResolveInfo rij = results.get(j); + if (rij.filter != null && rij.filter.hasAction(action)) { + results.remove(j); + if (Config.LOGV) Log.v( + TAG, "Removing duplicate item from " + j + + " due to action " + action + " at " + i); + j--; + N--; + } + } + } + + // If the caller didn't request filter information, drop it now + // so we don't have to marshall/unmarshall it. + if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) { + rii.filter = null; + } + } + + // Filter out the caller activity if so requested. + if (caller != null) { + N = results.size(); + for (int i=0; i<N; i++) { + ActivityInfo ainfo = results.get(i).activityInfo; + if (caller.getPackageName().equals(ainfo.applicationInfo.packageName) + && caller.getClassName().equals(ainfo.name)) { + results.remove(i); + break; + } + } + } + + // If the caller didn't request filter information, + // drop them now so we don't have to + // marshall/unmarshall it. + if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) { + N = results.size(); + for (int i=0; i<N; i++) { + results.get(i).filter = null; + } + } + + if (Config.LOGV) Log.v(TAG, "Result: " + results); + return results; + } + + public List<ResolveInfo> queryIntentReceivers(Intent intent, + String resolvedType, int flags) { + synchronized (mPackages) { + return (List<ResolveInfo>)mReceivers. + queryIntent(null, intent, resolvedType, flags); + } + } + + public ResolveInfo resolveService(Intent intent, String resolvedType, + int flags) { + List<ResolveInfo> query = queryIntentServices(intent, resolvedType, + flags); + if (query != null) { + if (query.size() >= 1) { + // If there is more than one service with the same priority, + // just arbitrarily pick the first one. + return query.get(0); + } + } + return null; + } + + public List<ResolveInfo> queryIntentServices(Intent intent, + String resolvedType, int flags) { + ComponentName comp = intent.getComponent(); + if (comp != null) { + List<ResolveInfo> list = new ArrayList<ResolveInfo>(1); + ServiceInfo si = getServiceInfo(comp, flags); + if (si != null) { + ResolveInfo ri = new ResolveInfo(); + ri.serviceInfo = si; + list.add(ri); + } + return list; + } + + synchronized (mPackages) { + return (List<ResolveInfo>)mServices. + queryIntent(null, intent, resolvedType, flags); + } + } + + public List<PackageInfo> getInstalledPackages(int flags) { + ArrayList<PackageInfo> finalList = new ArrayList<PackageInfo>(); + + synchronized (mPackages) { + if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) { + Iterator<PackageSetting> i = mSettings.mPackages.values().iterator(); + while (i.hasNext()) { + final PackageSetting ps = i.next(); + PackageInfo psPkg = generatePackageInfoFromSettingsLP(ps.name, flags); + if(psPkg != null) { + finalList.add(psPkg); + } + } + } + else { + Iterator<PackageParser.Package> i = mPackages.values().iterator(); + while (i.hasNext()) { + final PackageParser.Package p = i.next(); + if (p.applicationInfo != null) { + PackageInfo pi = generatePackageInfo(p, flags); + if(pi != null) { + finalList.add(pi); + } + } + } + } + } + return finalList; + } + + public List<ApplicationInfo> getInstalledApplications(int flags) { + ArrayList<ApplicationInfo> finalList = new ArrayList<ApplicationInfo>(); + synchronized(mPackages) { + if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) { + Iterator<PackageSetting> i = mSettings.mPackages.values().iterator(); + while (i.hasNext()) { + final PackageSetting ps = i.next(); + ApplicationInfo ai = generateApplicationInfoFromSettingsLP(ps.name, flags); + if(ai != null) { + finalList.add(ai); + } + } + } + else { + Iterator<PackageParser.Package> i = mPackages.values().iterator(); + while (i.hasNext()) { + final PackageParser.Package p = i.next(); + if (p.applicationInfo != null) { + ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags); + if(ai != null) { + finalList.add(ai); + } + } + } + } + } + return finalList; + } + + public List<ApplicationInfo> getPersistentApplications(int flags) { + ArrayList<ApplicationInfo> finalList = new ArrayList<ApplicationInfo>(); + + synchronized (mPackages) { + Iterator<PackageParser.Package> i = mPackages.values().iterator(); + while (i.hasNext()) { + PackageParser.Package p = i.next(); + if (p.applicationInfo != null + && (p.applicationInfo.flags&ApplicationInfo.FLAG_PERSISTENT) != 0 + && (!mSafeMode || (p.applicationInfo.flags + &ApplicationInfo.FLAG_SYSTEM) != 0)) { + finalList.add(p.applicationInfo); + } + } + } + + return finalList; + } + + public ProviderInfo resolveContentProvider(String name, int flags) { + synchronized (mPackages) { + final PackageParser.Provider provider = mProviders.get(name); + return provider != null + && mSettings.isEnabledLP(provider.info, flags) + && (!mSafeMode || (provider.info.applicationInfo.flags + &ApplicationInfo.FLAG_SYSTEM) != 0) + ? PackageParser.generateProviderInfo(provider, flags) + : null; + } + } + + public void querySyncProviders(List outNames, List outInfo) { + synchronized (mPackages) { + Iterator<Map.Entry<String, PackageParser.Provider>> i + = mProviders.entrySet().iterator(); + + while (i.hasNext()) { + Map.Entry<String, PackageParser.Provider> entry = i.next(); + PackageParser.Provider p = entry.getValue(); + + if (p.syncable + && (!mSafeMode || (p.info.applicationInfo.flags + &ApplicationInfo.FLAG_SYSTEM) != 0)) { + outNames.add(entry.getKey()); + outInfo.add(PackageParser.generateProviderInfo(p, 0)); + } + } + } + } + + public List<ProviderInfo> queryContentProviders(String processName, + int uid, int flags) { + ArrayList<ProviderInfo> finalList = null; + + synchronized (mPackages) { + Iterator<PackageParser.Provider> i = mProvidersByComponent.values().iterator(); + while (i.hasNext()) { + PackageParser.Provider p = i.next(); + if (p.info.authority != null + && (processName == null || + (p.info.processName.equals(processName) + && p.info.applicationInfo.uid == uid)) + && mSettings.isEnabledLP(p.info, flags) + && (!mSafeMode || (p.info.applicationInfo.flags + &ApplicationInfo.FLAG_SYSTEM) != 0)) { + if (finalList == null) { + finalList = new ArrayList<ProviderInfo>(3); + } + finalList.add(PackageParser.generateProviderInfo(p, + flags)); + } + } + } + + if (finalList != null) { + Collections.sort(finalList, mProviderInitOrderSorter); + } + + return finalList; + } + + public InstrumentationInfo getInstrumentationInfo(ComponentName name, + int flags) { + synchronized (mPackages) { + final PackageParser.Instrumentation i = mInstrumentation.get(name); + return PackageParser.generateInstrumentationInfo(i, flags); + } + } + + public List<InstrumentationInfo> queryInstrumentation(String targetPackage, + int flags) { + ArrayList<InstrumentationInfo> finalList = + new ArrayList<InstrumentationInfo>(); + + synchronized (mPackages) { + Iterator<PackageParser.Instrumentation> i = mInstrumentation.values().iterator(); + while (i.hasNext()) { + PackageParser.Instrumentation p = i.next(); + if (targetPackage == null + || targetPackage.equals(p.info.targetPackage)) { + finalList.add(PackageParser.generateInstrumentationInfo(p, + flags)); + } + } + } + + return finalList; + } + + private void scanDirLI(File dir, int flags, int scanMode) { + Log.d(TAG, "Scanning app dir " + dir); + + String[] files = dir.list(); + + int i; + for (i=0; i<files.length; i++) { + File file = new File(dir, files[i]); + PackageParser.Package pkg = scanPackageLI(file, file, file, + flags|PackageParser.PARSE_MUST_BE_APK, scanMode); + } + } + + private static void reportSettingsProblem(int priority, String msg) { + try { + File dataDir = Environment.getDataDirectory(); + File systemDir = new File(dataDir, "system"); + File fname = new File(systemDir, "uiderrors.txt"); + FileOutputStream out = new FileOutputStream(fname, true); + PrintWriter pw = new PrintWriter(out); + pw.println(msg); + pw.close(); + FileUtils.setPermissions( + fname.toString(), + FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IROTH, + -1, -1); + } catch (java.io.IOException e) { + } + Log.println(priority, TAG, msg); + } + + private boolean collectCertificatesLI(PackageParser pp, PackageSetting ps, + PackageParser.Package pkg, File srcFile, int parseFlags) { + if (GET_CERTIFICATES) { + if (ps == null || !ps.codePath.equals(srcFile) + || ps.getTimeStamp() != srcFile.lastModified()) { + Log.i(TAG, srcFile.toString() + " changed; collecting certs"); + if (!pp.collectCertificates(pkg, parseFlags)) { + mLastScanError = pp.getParseError(); + return false; + } + } + } + return true; + } + + /* + * Scan a package and return the newly parsed package. + * Returns null in case of errors and the error code is stored in mLastScanError + */ + private PackageParser.Package scanPackageLI(File scanFile, + File destCodeFile, File destResourceFile, int parseFlags, + int scanMode) { + mLastScanError = PackageManager.INSTALL_SUCCEEDED; + parseFlags |= mDefParseFlags; + PackageParser pp = new PackageParser(scanFile.getPath()); + pp.setSeparateProcesses(mSeparateProcesses); + pp.setSdkVersion(mSdkVersion); + final PackageParser.Package pkg = pp.parsePackage(scanFile, + destCodeFile.getAbsolutePath(), mMetrics, parseFlags); + if (pkg == null) { + mLastScanError = pp.getParseError(); + return null; + } + PackageSetting ps; + PackageSetting updatedPkg; + synchronized (mPackages) { + ps = mSettings.peekPackageLP(pkg.packageName, + scanFile.toString()); + updatedPkg = mSettings.mDisabledSysPackages.get(pkg.packageName); + } + if (updatedPkg != null) { + // An updated system app will not have the PARSE_IS_SYSTEM flag set initially + parseFlags |= PackageParser.PARSE_IS_SYSTEM; + } + if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) { + // Check for updated system applications here + if ((updatedPkg != null) && (ps == null)) { + // The system package has been updated and the code path does not match + // Ignore entry. Just return + Log.w(TAG, "Package:" + pkg.packageName + + " has been updated. Ignoring the one from path:"+scanFile); + mLastScanError = PackageManager.INSTALL_FAILED_DUPLICATE_PACKAGE; + return null; + } + } + if (!collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags)) { + Log.i(TAG, "Failed verifying certificates for package:" + pkg.packageName); + return null; + } + // The apk is forward locked (not public) if its code and resources + // are kept in different files. + if (ps != null && !ps.codePath.equals(ps.resourcePath)) { + scanMode |= SCAN_FORWARD_LOCKED; + } + // Note that we invoke the following method only if we are about to unpack an application + return scanPackageLI(scanFile, destCodeFile, destResourceFile, + pkg, parseFlags, scanMode | SCAN_UPDATE_SIGNATURE); + } + + private static String fixProcessName(String defProcessName, + String processName, int uid) { + if (processName == null) { + return defProcessName; + } + return processName; + } + + private boolean verifySignaturesLP(PackageSetting pkgSetting, + PackageParser.Package pkg, int parseFlags, boolean updateSignature) { + if (pkg.mSignatures != null) { + if (!pkgSetting.signatures.updateSignatures(pkg.mSignatures, + updateSignature)) { + Log.e(TAG, "Package " + pkg.packageName + + " signatures do not match the previously installed version; ignoring!"); + mLastScanError = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE; + return false; + } + + if (pkgSetting.sharedUser != null) { + if (!pkgSetting.sharedUser.signatures.mergeSignatures( + pkg.mSignatures, updateSignature)) { + Log.e(TAG, "Package " + pkg.packageName + + " has no signatures that match those in shared user " + + pkgSetting.sharedUser.name + "; ignoring!"); + mLastScanError = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE; + return false; + } + } + } else { + pkg.mSignatures = pkgSetting.signatures.mSignatures; + } + return true; + } + + private PackageParser.Package scanPackageLI( + File scanFile, File destCodeFile, File destResourceFile, + PackageParser.Package pkg, int parseFlags, int scanMode) { + + mScanningPath = scanFile; + if (pkg == null) { + mLastScanError = PackageManager.INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME; + return null; + } + + final String pkgName = pkg.applicationInfo.packageName; + if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) { + pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM; + } + + if (pkgName.equals("android")) { + synchronized (mPackages) { + if (mAndroidApplication != null) { + Log.w(TAG, "*************************************************"); + Log.w(TAG, "Core android package being redefined. Skipping."); + Log.w(TAG, " file=" + mScanningPath); + Log.w(TAG, "*************************************************"); + mLastScanError = PackageManager.INSTALL_FAILED_DUPLICATE_PACKAGE; + return null; + } + + // Set up information for our fall-back user intent resolution + // activity. + mPlatformPackage = pkg; + pkg.mVersionCode = mSdkVersion; + mAndroidApplication = pkg.applicationInfo; + mResolveActivity.applicationInfo = mAndroidApplication; + mResolveActivity.name = ResolverActivity.class.getName(); + mResolveActivity.packageName = mAndroidApplication.packageName; + mResolveActivity.processName = mAndroidApplication.processName; + mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE; + mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS; + mResolveActivity.theme = com.android.internal.R.style.Theme_Dialog_Alert; + mResolveActivity.exported = true; + mResolveActivity.enabled = true; + mResolveInfo.activityInfo = mResolveActivity; + mResolveInfo.priority = 0; + mResolveInfo.preferredOrder = 0; + mResolveInfo.match = 0; + mResolveComponentName = new ComponentName( + mAndroidApplication.packageName, mResolveActivity.name); + } + } + + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0 && Config.LOGD) Log.d( + TAG, "Scanning package " + pkgName); + if (mPackages.containsKey(pkgName) || mSharedLibraries.containsKey(pkgName)) { + Log.w(TAG, "*************************************************"); + Log.w(TAG, "Application package " + pkgName + + " already installed. Skipping duplicate."); + Log.w(TAG, "*************************************************"); + mLastScanError = PackageManager.INSTALL_FAILED_DUPLICATE_PACKAGE; + return null; + } + + SharedUserSetting suid = null; + PackageSetting pkgSetting = null; + + boolean removeExisting = false; + + synchronized (mPackages) { + // Check all shared libraries and map to their actual file path. + if (pkg.usesLibraryFiles != null) { + for (int i=0; i<pkg.usesLibraryFiles.length; i++) { + String file = mSharedLibraries.get(pkg.usesLibraryFiles[i]); + if (file == null) { + Log.e(TAG, "Package " + pkg.packageName + + " requires unavailable shared library " + + pkg.usesLibraryFiles[i] + "; ignoring!"); + mLastScanError = PackageManager.INSTALL_FAILED_MISSING_SHARED_LIBRARY; + return null; + } + pkg.usesLibraryFiles[i] = file; + } + } + + if (pkg.mSharedUserId != null) { + suid = mSettings.getSharedUserLP(pkg.mSharedUserId, + pkg.applicationInfo.flags, true); + if (suid == null) { + Log.w(TAG, "Creating application package " + pkgName + + " for shared user failed"); + mLastScanError = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + return null; + } + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0 && Config.LOGD) { + Log.d(TAG, "Shared UserID " + pkg.mSharedUserId + " (uid=" + + suid.userId + "): packages=" + suid.packages); + } + } + + // Just create the setting, don't add it yet + pkgSetting = mSettings.getPackageLP(pkg, suid, destCodeFile, + destResourceFile, pkg.applicationInfo.flags, true, false); + if (pkgSetting == null) { + Log.w(TAG, "Creating application package " + pkgName + " failed"); + mLastScanError = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + return null; + } + if(mSettings.mDisabledSysPackages.get(pkg.packageName) != null) { + pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP; + } + + pkg.applicationInfo.uid = pkgSetting.userId; + pkg.mExtras = pkgSetting; + + if (!verifySignaturesLP(pkgSetting, pkg, parseFlags, + (scanMode&SCAN_UPDATE_SIGNATURE) != 0)) { + if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) == 0) { + mLastScanError = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE; + return null; + } + // The signature has changed, but this package is in the system + // image... let's recover! + pkg.mSignatures = pkgSetting.signatures.mSignatures; + // However... if this package is part of a shared user, but it + // doesn't match the signature of the shared user, let's fail. + // What this means is that you can't change the signatures + // associated with an overall shared user, which doesn't seem all + // that unreasonable. + if (pkgSetting.sharedUser != null) { + if (!pkgSetting.sharedUser.signatures.mergeSignatures( + pkg.mSignatures, false)) { + mLastScanError = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; + return null; + } + } + removeExisting = true; + } + } + + if (removeExisting) { + if (mInstaller != null) { + int ret = mInstaller.remove(pkgName); + if (ret != 0) { + String msg = "System package " + pkg.packageName + + " could not have data directory erased after signature change."; + reportSettingsProblem(Log.WARN, msg); + mLastScanError = PackageManager.INSTALL_FAILED_REPLACE_COULDNT_DELETE; + return null; + } + } + Log.w(TAG, "System package " + pkg.packageName + + " signature changed: existing data removed."); + mLastScanError = PackageManager.INSTALL_SUCCEEDED; + } + + long scanFileTime = scanFile.lastModified(); + final boolean forceDex = (scanMode&SCAN_FORCE_DEX) != 0; + final boolean scanFileNewer = forceDex || scanFileTime != pkgSetting.getTimeStamp(); + pkg.applicationInfo.processName = fixProcessName( + pkg.applicationInfo.packageName, + pkg.applicationInfo.processName, + pkg.applicationInfo.uid); + pkg.applicationInfo.publicSourceDir = pkgSetting.resourcePathString; + + File dataPath; + if (mPlatformPackage == pkg) { + // The system package is special. + dataPath = new File (Environment.getDataDirectory(), "system"); + pkg.applicationInfo.dataDir = dataPath.getPath(); + } else { + // This is a normal package, need to make its data directory. + dataPath = new File(mAppDataDir, pkgName); + if (dataPath.exists()) { + mOutPermissions[1] = 0; + FileUtils.getPermissions(dataPath.getPath(), mOutPermissions); + if (mOutPermissions[1] == pkg.applicationInfo.uid + || !Process.supportsProcesses()) { + pkg.applicationInfo.dataDir = dataPath.getPath(); + } else { + boolean recovered = false; + if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) { + // If this is a system app, we can at least delete its + // current data so the application will still work. + if (mInstaller != null) { + int ret = mInstaller.remove(pkgName); + if(ret >= 0) { + // Old data gone! + String msg = "System package " + pkg.packageName + + " has changed from uid: " + + mOutPermissions[1] + " to " + + pkg.applicationInfo.uid + "; old data erased"; + reportSettingsProblem(Log.WARN, msg); + recovered = true; + + // And now re-install the app. + ret = mInstaller.install(pkgName, pkg.applicationInfo.uid, + pkg.applicationInfo.uid); + if (ret == -1) { + // Ack should not happen! + msg = "System package " + pkg.packageName + + " could not have data directory re-created after delete."; + reportSettingsProblem(Log.WARN, msg); + mLastScanError = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + return null; + } + } + } + if (!recovered) { + mHasSystemUidErrors = true; + } + } + if (!recovered) { + pkg.applicationInfo.dataDir = "/mismatched_uid/settings_" + + pkg.applicationInfo.uid + "/fs_" + + mOutPermissions[1]; + String msg = "Package " + pkg.packageName + + " has mismatched uid: " + + mOutPermissions[1] + " on disk, " + + pkg.applicationInfo.uid + " in settings"; + synchronized (mPackages) { + if (!mReportedUidError) { + mReportedUidError = true; + msg = msg + "; read messages:\n" + + mSettings.getReadMessagesLP(); + } + reportSettingsProblem(Log.ERROR, msg); + } + } + } + pkg.applicationInfo.dataDir = dataPath.getPath(); + } else { + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0 && Config.LOGV) + Log.v(TAG, "Want this data dir: " + dataPath); + //invoke installer to do the actual installation + if (mInstaller != null) { + int ret = mInstaller.install(pkgName, pkg.applicationInfo.uid, + pkg.applicationInfo.uid); + if(ret < 0) { + // Error from installer + mLastScanError = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + return null; + } + } else { + dataPath.mkdirs(); + if (dataPath.exists()) { + FileUtils.setPermissions( + dataPath.toString(), + FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, + pkg.applicationInfo.uid, pkg.applicationInfo.uid); + } + } + if (dataPath.exists()) { + pkg.applicationInfo.dataDir = dataPath.getPath(); + } else { + Log.w(TAG, "Unable to create data directory: " + dataPath); + pkg.applicationInfo.dataDir = null; + } + } + } + + // Perform shared library installation and dex validation and + // optimization, if this is not a system app. + if (mInstaller != null) { + String path = scanFile.getPath(); + if (scanFileNewer) { + Log.i(TAG, path + " changed; unpacking"); + try { + cachePackageSharedLibsLI(pkg, dataPath, scanFile); + } catch (IOException e) { + Log.e(TAG, "Failure extracting shared libs", e); + if(mInstaller != null) { + mInstaller.remove(pkgName); + } else { + dataPath.delete(); + } + mLastScanError = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + return null; + } + } + + if ((scanMode&SCAN_NO_DEX) == 0 + && (pkg.applicationInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0) { + int ret = 0; + try { + if (forceDex || dalvik.system.DexFile.isDexOptNeeded(path)) { + ret = mInstaller.dexopt(path, pkg.applicationInfo.uid, + (scanMode&SCAN_FORWARD_LOCKED) == 0); + } + } catch (FileNotFoundException e) { + Log.w(TAG, "Apk not found for dexopt: " + path); + ret = -1; + } catch (IOException e) { + Log.w(TAG, "Exception reading apk: " + path, e); + ret = -1; + } + if (ret < 0) { + //error from installer + mLastScanError = PackageManager.INSTALL_FAILED_DEXOPT; + return null; + } + } + } + + if (mFactoryTest && pkg.requestedPermissions.contains( + android.Manifest.permission.FACTORY_TEST)) { + pkg.applicationInfo.flags |= ApplicationInfo.FLAG_FACTORY_TEST; + } + + if ((scanMode&SCAN_MONITOR) != 0) { + pkg.mPath = destCodeFile.getAbsolutePath(); + mAppDirs.put(pkg.mPath, pkg); + } + + synchronized (mPackages) { + // We don't expect installation to fail beyond this point + // Add the new setting to mSettings + mSettings.insertPackageSettingLP(pkgSetting, pkg.packageName, suid); + // Add the new setting to mPackages + mPackages.put(pkg.applicationInfo.packageName, pkg); + int N = pkg.providers.size(); + StringBuilder r = null; + int i; + for (i=0; i<N; i++) { + PackageParser.Provider p = pkg.providers.get(i); + p.info.processName = fixProcessName(pkg.applicationInfo.processName, + p.info.processName, pkg.applicationInfo.uid); + mProvidersByComponent.put(new ComponentName(p.info.packageName, + p.info.name), p); + p.syncable = p.info.isSyncable; + String names[] = p.info.authority.split(";"); + p.info.authority = null; + for (int j = 0; j < names.length; j++) { + if (j == 1 && p.syncable) { + // We only want the first authority for a provider to possibly be + // syncable, so if we already added this provider using a different + // authority clear the syncable flag. We copy the provider before + // changing it because the mProviders object contains a reference + // to a provider that we don't want to change. + // Only do this for the second authority since the resulting provider + // object can be the same for all future authorities for this provider. + p = new PackageParser.Provider(p); + p.syncable = false; + } + if (!mProviders.containsKey(names[j])) { + mProviders.put(names[j], p); + if (p.info.authority == null) { + p.info.authority = names[j]; + } else { + p.info.authority = p.info.authority + ";" + names[j]; + } + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0 && Config.LOGD) + Log.d(TAG, "Registered content provider: " + names[j] + + ", className = " + p.info.name + + ", isSyncable = " + p.info.isSyncable); + } else { + Log.w(TAG, "Skipping provider name " + names[j] + + " (in package " + pkg.applicationInfo.packageName + + "): name already used"); + } + } + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(p.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Providers: " + r); + } + + N = pkg.services.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Service s = pkg.services.get(i); + s.info.processName = fixProcessName(pkg.applicationInfo.processName, + s.info.processName, pkg.applicationInfo.uid); + mServices.addService(s); + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(s.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Services: " + r); + } + + N = pkg.receivers.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Activity a = pkg.receivers.get(i); + a.info.processName = fixProcessName(pkg.applicationInfo.processName, + a.info.processName, pkg.applicationInfo.uid); + mReceivers.addActivity(a, "receiver"); + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(a.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Receivers: " + r); + } + + N = pkg.activities.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Activity a = pkg.activities.get(i); + a.info.processName = fixProcessName(pkg.applicationInfo.processName, + a.info.processName, pkg.applicationInfo.uid); + mActivities.addActivity(a, "activity"); + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(a.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Activities: " + r); + } + + N = pkg.permissionGroups.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.PermissionGroup pg = pkg.permissionGroups.get(i); + PackageParser.PermissionGroup cur = mPermissionGroups.get(pg.info.name); + if (cur == null) { + mPermissionGroups.put(pg.info.name, pg); + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(pg.info.name); + } + } else { + Log.w(TAG, "Permission group " + pg.info.name + " from package " + + pg.info.packageName + " ignored: original from " + + cur.info.packageName); + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append("DUP:"); + r.append(pg.info.name); + } + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Permission Groups: " + r); + } + + N = pkg.permissions.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Permission p = pkg.permissions.get(i); + HashMap<String, BasePermission> permissionMap = + p.tree ? mSettings.mPermissionTrees + : mSettings.mPermissions; + p.group = mPermissionGroups.get(p.info.group); + if (p.info.group == null || p.group != null) { + BasePermission bp = permissionMap.get(p.info.name); + if (bp == null) { + bp = new BasePermission(p.info.name, p.info.packageName, + BasePermission.TYPE_NORMAL); + permissionMap.put(p.info.name, bp); + } + if (bp.perm == null) { + if (bp.sourcePackage == null + || bp.sourcePackage.equals(p.info.packageName)) { + BasePermission tree = findPermissionTreeLP(p.info.name); + if (tree == null + || tree.sourcePackage.equals(p.info.packageName)) { + bp.perm = p; + bp.uid = pkg.applicationInfo.uid; + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(p.info.name); + } + } else { + Log.w(TAG, "Permission " + p.info.name + " from package " + + p.info.packageName + " ignored: base tree " + + tree.name + " is from package " + + tree.sourcePackage); + } + } else { + Log.w(TAG, "Permission " + p.info.name + " from package " + + p.info.packageName + " ignored: original from " + + bp.sourcePackage); + } + } else if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append("DUP:"); + r.append(p.info.name); + } + } else { + Log.w(TAG, "Permission " + p.info.name + " from package " + + p.info.packageName + " ignored: no group " + + p.group); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Permissions: " + r); + } + + N = pkg.instrumentation.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Instrumentation a = pkg.instrumentation.get(i); + a.info.packageName = pkg.applicationInfo.packageName; + a.info.sourceDir = pkg.applicationInfo.sourceDir; + a.info.publicSourceDir = pkg.applicationInfo.publicSourceDir; + a.info.dataDir = pkg.applicationInfo.dataDir; + mInstrumentation.put(a.component, a); + if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(a.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Instrumentation: " + r); + } + + pkgSetting.setTimeStamp(scanFileTime); + } + + return pkg; + } + + private void cachePackageSharedLibsLI(PackageParser.Package pkg, + File dataPath, File scanFile) throws IOException { + File sharedLibraryDir = new File(dataPath.getPath() + "/lib"); + final String sharedLibraryABI = "armeabi"; + final String apkLibraryDirectory = "lib/" + sharedLibraryABI + "/"; + final String apkSharedLibraryPrefix = apkLibraryDirectory + "lib"; + final String sharedLibrarySuffix = ".so"; + boolean createdSharedLib = false; + try { + ZipFile zipFile = new ZipFile(scanFile); + Enumeration<ZipEntry> entries = + (Enumeration<ZipEntry>) zipFile.entries(); + + while (entries.hasMoreElements()) { + ZipEntry entry = entries.nextElement(); + if (entry.isDirectory()) { + continue; + } + String entryName = entry.getName(); + if (! (entryName.startsWith(apkSharedLibraryPrefix) + && entryName.endsWith(sharedLibrarySuffix))) { + continue; + } + String libFileName = entryName.substring( + apkLibraryDirectory.length()); + if (libFileName.contains("/") + || (!FileUtils.isFilenameSafe(new File(libFileName)))) { + continue; + } + String sharedLibraryFilePath = sharedLibraryDir.getPath() + + File.separator + libFileName; + File sharedLibraryFile = new File(sharedLibraryFilePath); + if (! sharedLibraryFile.exists() || + sharedLibraryFile.length() != entry.getSize() || + sharedLibraryFile.lastModified() != entry.getTime()) { + if (Config.LOGD) { + Log.d(TAG, "Caching shared lib " + entry.getName()); + } + if (mInstaller == null) { + sharedLibraryDir.mkdir(); + createdSharedLib = true; + } + cacheSharedLibLI(pkg, zipFile, entry, sharedLibraryDir, + sharedLibraryFile); + } + } + } catch (IOException e) { + Log.e(TAG, "Failed to cache package shared libs", e); + if(createdSharedLib) { + sharedLibraryDir.delete(); + } + throw e; + } + } + + private void cacheSharedLibLI(PackageParser.Package pkg, + ZipFile zipFile, ZipEntry entry, + File sharedLibraryDir, + File sharedLibraryFile) throws IOException { + InputStream inputStream = zipFile.getInputStream(entry); + try { + File tempFile = File.createTempFile("tmp", "tmp", sharedLibraryDir); + String tempFilePath = tempFile.getPath(); + // XXX package manager can't change owner, so the lib files for + // now need to be left as world readable and owned by the system. + if (! FileUtils.copyToFile(inputStream, tempFile) || + ! tempFile.setLastModified(entry.getTime()) || + FileUtils.setPermissions(tempFilePath, + FileUtils.S_IRUSR|FileUtils.S_IWUSR|FileUtils.S_IRGRP + |FileUtils.S_IROTH, -1, -1) != 0 || + ! tempFile.renameTo(sharedLibraryFile)) { + // Failed to properly write file. + tempFile.delete(); + throw new IOException("Couldn't create cached shared lib " + + sharedLibraryFile + " in " + sharedLibraryDir); + } + } finally { + inputStream.close(); + } + } + + void removePackageLI(PackageParser.Package pkg, boolean chatty) { + if (chatty && Config.LOGD) Log.d( + TAG, "Removing package " + pkg.applicationInfo.packageName ); + + synchronized (mPackages) { + if (pkg.mPreferredOrder > 0) { + mSettings.mPreferredPackages.remove(pkg); + pkg.mPreferredOrder = 0; + updatePreferredIndicesLP(); + } + + clearPackagePreferredActivitiesLP(pkg.packageName); + + mPackages.remove(pkg.applicationInfo.packageName); + if (pkg.mPath != null) { + mAppDirs.remove(pkg.mPath); + } + + PackageSetting ps = (PackageSetting)pkg.mExtras; + if (ps != null && ps.sharedUser != null) { + // XXX don't do this until the data is removed. + if (false) { + ps.sharedUser.packages.remove(ps); + if (ps.sharedUser.packages.size() == 0) { + // Remove. + } + } + } + + int N = pkg.providers.size(); + StringBuilder r = null; + int i; + for (i=0; i<N; i++) { + PackageParser.Provider p = pkg.providers.get(i); + mProvidersByComponent.remove(new ComponentName(p.info.packageName, + p.info.name)); + if (p.info.authority == null) { + + /* The is another ContentProvider with this authority when + * this app was installed so this authority is null, + * Ignore it as we don't have to unregister the provider. + */ + continue; + } + String names[] = p.info.authority.split(";"); + for (int j = 0; j < names.length; j++) { + if (mProviders.get(names[j]) == p) { + mProviders.remove(names[j]); + if (chatty && Config.LOGD) Log.d( + TAG, "Unregistered content provider: " + names[j] + + ", className = " + p.info.name + + ", isSyncable = " + p.info.isSyncable); + } + } + if (chatty) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(p.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Providers: " + r); + } + + N = pkg.services.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Service s = pkg.services.get(i); + mServices.removeService(s); + if (chatty) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(s.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Services: " + r); + } + + N = pkg.receivers.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Activity a = pkg.receivers.get(i); + mReceivers.removeActivity(a, "receiver"); + if (chatty) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(a.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Receivers: " + r); + } + + N = pkg.activities.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Activity a = pkg.activities.get(i); + mActivities.removeActivity(a, "activity"); + if (chatty) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(a.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Activities: " + r); + } + + N = pkg.permissions.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Permission p = pkg.permissions.get(i); + boolean tree = false; + BasePermission bp = mSettings.mPermissions.get(p.info.name); + if (bp == null) { + tree = true; + bp = mSettings.mPermissionTrees.get(p.info.name); + } + if (bp != null && bp.perm == p) { + if (bp.type != BasePermission.TYPE_BUILTIN) { + if (tree) { + mSettings.mPermissionTrees.remove(p.info.name); + } else { + mSettings.mPermissions.remove(p.info.name); + } + } else { + bp.perm = null; + } + if (chatty) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(p.info.name); + } + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Permissions: " + r); + } + + N = pkg.instrumentation.size(); + r = null; + for (i=0; i<N; i++) { + PackageParser.Instrumentation a = pkg.instrumentation.get(i); + mInstrumentation.remove(a.component); + if (chatty) { + if (r == null) { + r = new StringBuilder(256); + } else { + r.append(' '); + } + r.append(a.info.name); + } + } + if (r != null) { + if (Config.LOGD) Log.d(TAG, " Instrumentation: " + r); + } + } + } + + private static final boolean isPackageFilename(String name) { + return name != null && name.endsWith(".apk"); + } + + private void updatePermissionsLP() { + // Make sure there are no dangling permission trees. + Iterator<BasePermission> it = mSettings.mPermissionTrees + .values().iterator(); + while (it.hasNext()) { + BasePermission bp = it.next(); + if (bp.perm == null) { + Log.w(TAG, "Removing dangling permission tree: " + bp.name + + " from package " + bp.sourcePackage); + it.remove(); + } + } + + // Make sure all dynamic permissions have been assigned to a package, + // and make sure there are no dangling permissions. + it = mSettings.mPermissions.values().iterator(); + while (it.hasNext()) { + BasePermission bp = it.next(); + if (bp.type == BasePermission.TYPE_DYNAMIC) { + if (DEBUG_SETTINGS) Log.v(TAG, "Dynamic permission: name=" + + bp.name + " pkg=" + bp.sourcePackage + + " info=" + bp.pendingInfo); + if (bp.perm == null && bp.pendingInfo != null) { + BasePermission tree = findPermissionTreeLP(bp.name); + if (tree != null) { + bp.perm = new PackageParser.Permission(tree.perm.owner, + new PermissionInfo(bp.pendingInfo)); + bp.perm.info.packageName = tree.perm.info.packageName; + bp.perm.info.name = bp.name; + bp.uid = tree.uid; + } + } + } + if (bp.perm == null) { + Log.w(TAG, "Removing dangling permission: " + bp.name + + " from package " + bp.sourcePackage); + it.remove(); + } + } + + // Now update the permissions for all packages, in particular + // replace the granted permissions of the system packages. + for (PackageParser.Package pkg : mPackages.values()) { + grantPermissionsLP(pkg, false); + } + } + + private void grantPermissionsLP(PackageParser.Package pkg, boolean replace) { + final PackageSetting ps = (PackageSetting)pkg.mExtras; + if (ps == null) { + return; + } + final GrantedPermissions gp = ps.sharedUser != null ? ps.sharedUser : ps; + boolean addedPermission = false; + + if (replace) { + ps.permissionsFixed = false; + if (gp == ps) { + gp.grantedPermissions.clear(); + gp.gids = mGlobalGids; + } + } + + if (gp.gids == null) { + gp.gids = mGlobalGids; + } + + final int N = pkg.requestedPermissions.size(); + for (int i=0; i<N; i++) { + String name = pkg.requestedPermissions.get(i); + BasePermission bp = mSettings.mPermissions.get(name); + PackageParser.Permission p = bp != null ? bp.perm : null; + if (false) { + if (gp != ps) { + Log.i(TAG, "Package " + pkg.packageName + " checking " + name + + ": " + p); + } + } + if (p != null) { + final String perm = p.info.name; + boolean allowed; + if (p.info.protectionLevel == PermissionInfo.PROTECTION_NORMAL + || p.info.protectionLevel == PermissionInfo.PROTECTION_DANGEROUS) { + allowed = true; + } else if (p.info.protectionLevel == PermissionInfo.PROTECTION_SIGNATURE + || p.info.protectionLevel == PermissionInfo.PROTECTION_SIGNATURE_OR_SYSTEM) { + allowed = (checkSignaturesLP(p.owner, pkg) + == PackageManager.SIGNATURE_MATCH) + || (checkSignaturesLP(mPlatformPackage, pkg) + == PackageManager.SIGNATURE_MATCH); + if (p.info.protectionLevel == PermissionInfo.PROTECTION_SIGNATURE_OR_SYSTEM) { + if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) { + // For updated system applications, the signatureOrSystem permission + // is granted only if it had been defined by the original application. + if ((pkg.applicationInfo.flags + & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) { + PackageSetting sysPs = mSettings.getDisabledSystemPkg(pkg.packageName); + if(sysPs.grantedPermissions.contains(perm)) { + allowed = true; + } else { + allowed = false; + } + } else { + allowed = true; + } + } + } + } else { + allowed = false; + } + if (false) { + if (gp != ps) { + Log.i(TAG, "Package " + pkg.packageName + " granting " + perm); + } + } + if (allowed) { + if ((ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0 + && ps.permissionsFixed) { + // If this is an existing, non-system package, then + // we can't add any new permissions to it. + if (!gp.loadedPermissions.contains(perm)) { + allowed = false; + } + } + if (allowed) { + if (!gp.grantedPermissions.contains(perm)) { + addedPermission = true; + gp.grantedPermissions.add(perm); + gp.gids = appendInts(gp.gids, bp.gids); + } + } else { + Log.w(TAG, "Not granting permission " + perm + + " to package " + pkg.packageName + + " because it was previously installed without"); + } + } else { + Log.w(TAG, "Not granting permission " + perm + + " to package " + pkg.packageName + + " (protectionLevel=" + p.info.protectionLevel + + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags) + + ")"); + } + } else { + Log.w(TAG, "Unknown permission " + name + + " in package " + pkg.packageName); + } + } + + if ((addedPermission || replace) && !ps.permissionsFixed && + (ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) { + // This is the first that we have heard about this package, so the + // permissions we have now selected are fixed until explicitly + // changed. + ps.permissionsFixed = true; + gp.loadedPermissions = new HashSet<String>(gp.grantedPermissions); + } + } + + private final class ActivityIntentResolver + extends IntentResolver<PackageParser.ActivityIntentInfo, ResolveInfo> { + public List queryIntent(ContentResolver resolver, Intent intent, + String resolvedType, boolean defaultOnly) { + mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0; + return super.queryIntent(resolver, intent, resolvedType, defaultOnly); + } + + public List queryIntent(ContentResolver resolver, Intent intent, + String resolvedType, int flags) { + mFlags = flags; + return super.queryIntent( + resolver, intent, resolvedType, + (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0); + } + + public final void addActivity(PackageParser.Activity a, String type) { + mActivities.put(a.component, a); + if (SHOW_INFO || Config.LOGV) Log.v( + TAG, " " + type + " " + + (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel : a.info.name) + ":"); + if (SHOW_INFO || Config.LOGV) Log.v(TAG, " Class=" + a.info.name); + int NI = a.intents.size(); + int j; + for (j=0; j<NI; j++) { + PackageParser.ActivityIntentInfo intent = a.intents.get(j); + if (SHOW_INFO || Config.LOGV) { + Log.v(TAG, " IntentFilter:"); + intent.dump(new LogPrinter(Log.VERBOSE, TAG), " "); + } + if (!intent.debugCheck()) { + Log.w(TAG, "==> For Activity " + a.info.name); + } + addFilter(intent); + } + } + + public final void removeActivity(PackageParser.Activity a, String type) { + mActivities.remove(a.component); + if (SHOW_INFO || Config.LOGV) Log.v( + TAG, " " + type + " " + + (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel : a.info.name) + ":"); + if (SHOW_INFO || Config.LOGV) Log.v(TAG, " Class=" + a.info.name); + int NI = a.intents.size(); + int j; + for (j=0; j<NI; j++) { + PackageParser.ActivityIntentInfo intent = a.intents.get(j); + if (SHOW_INFO || Config.LOGV) { + Log.v(TAG, " IntentFilter:"); + intent.dump(new LogPrinter(Log.VERBOSE, TAG), " "); + } + removeFilter(intent); + } + } + + @Override + protected boolean allowFilterResult( + PackageParser.ActivityIntentInfo filter, List<ResolveInfo> dest) { + ActivityInfo filterAi = filter.activity.info; + for (int i=dest.size()-1; i>=0; i--) { + ActivityInfo destAi = dest.get(i).activityInfo; + if (destAi.name == filterAi.name + && destAi.packageName == filterAi.packageName) { + return false; + } + } + return true; + } + + @Override + protected ResolveInfo newResult(PackageParser.ActivityIntentInfo info, + int match) { + if (!mSettings.isEnabledLP(info.activity.info, mFlags)) { + return null; + } + final PackageParser.Activity activity = info.activity; + if (mSafeMode && (activity.info.applicationInfo.flags + &ApplicationInfo.FLAG_SYSTEM) == 0) { + return null; + } + final ResolveInfo res = new ResolveInfo(); + res.activityInfo = PackageParser.generateActivityInfo(activity, + mFlags); + if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) { + res.filter = info; + } + res.priority = info.getPriority(); + res.preferredOrder = activity.owner.mPreferredOrder; + //System.out.println("Result: " + res.activityInfo.className + + // " = " + res.priority); + res.match = match; + res.isDefault = info.hasDefault; + res.labelRes = info.labelRes; + res.nonLocalizedLabel = info.nonLocalizedLabel; + res.icon = info.icon; + return res; + } + + @Override + protected void sortResults(List<ResolveInfo> results) { + Collections.sort(results, mResolvePrioritySorter); + } + + @Override + protected void dumpFilter(Printer out, String prefix, + PackageParser.ActivityIntentInfo filter) { + out.println(prefix + + Integer.toHexString(System.identityHashCode(filter.activity)) + + " " + filter.activity.component.flattenToShortString()); + } + +// List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) { +// final Iterator<ResolveInfo> i = resolveInfoList.iterator(); +// final List<ResolveInfo> retList = Lists.newArrayList(); +// while (i.hasNext()) { +// final ResolveInfo resolveInfo = i.next(); +// if (isEnabledLP(resolveInfo.activityInfo)) { +// retList.add(resolveInfo); +// } +// } +// return retList; +// } + + // Keys are String (activity class name), values are Activity. + private final HashMap<ComponentName, PackageParser.Activity> mActivities + = new HashMap<ComponentName, PackageParser.Activity>(); + private int mFlags; + } + + private final class ServiceIntentResolver + extends IntentResolver<PackageParser.ServiceIntentInfo, ResolveInfo> { + public List queryIntent(ContentResolver resolver, Intent intent, + String resolvedType, boolean defaultOnly) { + mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0; + return super.queryIntent(resolver, intent, resolvedType, defaultOnly); + } + + public List queryIntent(ContentResolver resolver, Intent intent, + String resolvedType, int flags) { + mFlags = flags; + return super.queryIntent( + resolver, intent, resolvedType, + (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0); + } + + public final void addService(PackageParser.Service s) { + mServices.put(s.component, s); + if (SHOW_INFO || Config.LOGV) Log.v( + TAG, " " + (s.info.nonLocalizedLabel != null + ? s.info.nonLocalizedLabel : s.info.name) + ":"); + if (SHOW_INFO || Config.LOGV) Log.v( + TAG, " Class=" + s.info.name); + int NI = s.intents.size(); + int j; + for (j=0; j<NI; j++) { + PackageParser.ServiceIntentInfo intent = s.intents.get(j); + if (SHOW_INFO || Config.LOGV) { + Log.v(TAG, " IntentFilter:"); + intent.dump(new LogPrinter(Log.VERBOSE, TAG), " "); + } + if (!intent.debugCheck()) { + Log.w(TAG, "==> For Service " + s.info.name); + } + addFilter(intent); + } + } + + public final void removeService(PackageParser.Service s) { + mServices.remove(s.component); + if (SHOW_INFO || Config.LOGV) Log.v( + TAG, " " + (s.info.nonLocalizedLabel != null + ? s.info.nonLocalizedLabel : s.info.name) + ":"); + if (SHOW_INFO || Config.LOGV) Log.v( + TAG, " Class=" + s.info.name); + int NI = s.intents.size(); + int j; + for (j=0; j<NI; j++) { + PackageParser.ServiceIntentInfo intent = s.intents.get(j); + if (SHOW_INFO || Config.LOGV) { + Log.v(TAG, " IntentFilter:"); + intent.dump(new LogPrinter(Log.VERBOSE, TAG), " "); + } + removeFilter(intent); + } + } + + @Override + protected boolean allowFilterResult( + PackageParser.ServiceIntentInfo filter, List<ResolveInfo> dest) { + ServiceInfo filterSi = filter.service.info; + for (int i=dest.size()-1; i>=0; i--) { + ServiceInfo destAi = dest.get(i).serviceInfo; + if (destAi.name == filterSi.name + && destAi.packageName == filterSi.packageName) { + return false; + } + } + return true; + } + + @Override + protected ResolveInfo newResult(PackageParser.ServiceIntentInfo filter, + int match) { + final PackageParser.ServiceIntentInfo info = (PackageParser.ServiceIntentInfo)filter; + if (!mSettings.isEnabledLP(info.service.info, mFlags)) { + return null; + } + final PackageParser.Service service = info.service; + if (mSafeMode && (service.info.applicationInfo.flags + &ApplicationInfo.FLAG_SYSTEM) == 0) { + return null; + } + final ResolveInfo res = new ResolveInfo(); + res.serviceInfo = PackageParser.generateServiceInfo(service, + mFlags); + if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) { + res.filter = filter; + } + res.priority = info.getPriority(); + res.preferredOrder = service.owner.mPreferredOrder; + //System.out.println("Result: " + res.activityInfo.className + + // " = " + res.priority); + res.match = match; + res.isDefault = info.hasDefault; + res.labelRes = info.labelRes; + res.nonLocalizedLabel = info.nonLocalizedLabel; + res.icon = info.icon; + return res; + } + + @Override + protected void sortResults(List<ResolveInfo> results) { + Collections.sort(results, mResolvePrioritySorter); + } + + @Override + protected void dumpFilter(Printer out, String prefix, + PackageParser.ServiceIntentInfo filter) { + out.println(prefix + + Integer.toHexString(System.identityHashCode(filter.service)) + + " " + filter.service.component.flattenToShortString()); + } + +// List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) { +// final Iterator<ResolveInfo> i = resolveInfoList.iterator(); +// final List<ResolveInfo> retList = Lists.newArrayList(); +// while (i.hasNext()) { +// final ResolveInfo resolveInfo = (ResolveInfo) i; +// if (isEnabledLP(resolveInfo.serviceInfo)) { +// retList.add(resolveInfo); +// } +// } +// return retList; +// } + + // Keys are String (activity class name), values are Activity. + private final HashMap<ComponentName, PackageParser.Service> mServices + = new HashMap<ComponentName, PackageParser.Service>(); + private int mFlags; + }; + + private static final Comparator<ResolveInfo> mResolvePrioritySorter = + new Comparator<ResolveInfo>() { + public int compare(ResolveInfo r1, ResolveInfo r2) { + int v1 = r1.priority; + int v2 = r2.priority; + //System.out.println("Comparing: q1=" + q1 + " q2=" + q2); + if (v1 != v2) { + return (v1 > v2) ? -1 : 1; + } + v1 = r1.preferredOrder; + v2 = r2.preferredOrder; + if (v1 != v2) { + return (v1 > v2) ? -1 : 1; + } + if (r1.isDefault != r2.isDefault) { + return r1.isDefault ? -1 : 1; + } + v1 = r1.match; + v2 = r2.match; + //System.out.println("Comparing: m1=" + m1 + " m2=" + m2); + return (v1 > v2) ? -1 : ((v1 < v2) ? 1 : 0); + } + }; + + private static final Comparator<ProviderInfo> mProviderInitOrderSorter = + new Comparator<ProviderInfo>() { + public int compare(ProviderInfo p1, ProviderInfo p2) { + final int v1 = p1.initOrder; + final int v2 = p2.initOrder; + return (v1 > v2) ? -1 : ((v1 < v2) ? 1 : 0); + } + }; + + private static final void sendPackageBroadcast(String action, String pkg, Bundle extras) { + IActivityManager am = ActivityManagerNative.getDefault(); + if (am != null) { + try { + final Intent intent = new Intent(action, + pkg != null ? Uri.fromParts("package", pkg, null) : null); + if (extras != null) { + intent.putExtras(extras); + } + am.broadcastIntent( + null, intent, + null, null, 0, null, null, null, false, false); + } catch (RemoteException ex) { + } + } + } + + private final class AppDirObserver extends FileObserver { + public AppDirObserver(String path, int mask, boolean isrom) { + super(path, mask); + mRootDir = path; + mIsRom = isrom; + } + + public void onEvent(int event, String path) { + String removedPackage = null; + int removedUid = -1; + String addedPackage = null; + int addedUid = -1; + + synchronized (mInstallLock) { + String fullPathStr = null; + File fullPath = null; + if (path != null) { + fullPath = new File(mRootDir, path); + fullPathStr = fullPath.getPath(); + } + + if (Config.LOGV) Log.v( + TAG, "File " + fullPathStr + " changed: " + + Integer.toHexString(event)); + + if (!isPackageFilename(path)) { + if (Config.LOGV) Log.v( + TAG, "Ignoring change of non-package file: " + fullPathStr); + return; + } + + if ((event&REMOVE_EVENTS) != 0) { + synchronized (mInstallLock) { + PackageParser.Package p = mAppDirs.get(fullPathStr); + if (p != null) { + removePackageLI(p, true); + removedPackage = p.applicationInfo.packageName; + removedUid = p.applicationInfo.uid; + } + } + } + + if ((event&ADD_EVENTS) != 0) { + PackageParser.Package p = mAppDirs.get(fullPathStr); + if (p == null) { + p = scanPackageLI(fullPath, fullPath, fullPath, + (mIsRom ? PackageParser.PARSE_IS_SYSTEM : 0) | + PackageParser.PARSE_CHATTY | + PackageParser.PARSE_MUST_BE_APK, + SCAN_MONITOR); + if (p != null) { + synchronized (mPackages) { + grantPermissionsLP(p, false); + } + addedPackage = p.applicationInfo.packageName; + addedUid = p.applicationInfo.uid; + } + } + } + + synchronized (mPackages) { + mSettings.writeLP(); + } + } + + if (removedPackage != null) { + Bundle extras = new Bundle(1); + extras.putInt(Intent.EXTRA_UID, removedUid); + extras.putBoolean(Intent.EXTRA_DATA_REMOVED, false); + sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage, extras); + } + if (addedPackage != null) { + Bundle extras = new Bundle(1); + extras.putInt(Intent.EXTRA_UID, addedUid); + sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, addedPackage, extras); + } + } + + private final String mRootDir; + private final boolean mIsRom; + } + + /* Called when a downloaded package installation has been confirmed by the user */ + public void installPackage( + final Uri packageURI, final IPackageInstallObserver observer, final int flags) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.INSTALL_PACKAGES, null); + + // Queue up an async operation since the package installation may take a little while. + mHandler.post(new Runnable() { + public void run() { + mHandler.removeCallbacks(this); + PackageInstalledInfo res; + synchronized (mInstallLock) { + res = installPackageLI(packageURI, flags); + } + if (observer != null) { + try { + observer.packageInstalled(res.name, res.returnCode); + } catch (RemoteException e) { + Log.i(TAG, "Observer no longer exists."); + } + } + // There appears to be a subtle deadlock condition if the sendPackageBroadcast + // call appears in the synchronized block above. + if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) { + res.removedInfo.sendBroadcast(false, true); + Bundle extras = new Bundle(1); + extras.putInt(Intent.EXTRA_UID, res.uid); + if (res.removedInfo.removedPackage != null) { + extras.putBoolean(Intent.EXTRA_REPLACING, true); + } + sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, + res.pkg.applicationInfo.packageName, + extras); + } + Runtime.getRuntime().gc(); + } + }); + } + + class PackageInstalledInfo { + String name; + int uid; + PackageParser.Package pkg; + int returnCode; + PackageRemovedInfo removedInfo; + } + + /* + * Install a non-existing package. + */ + private void installNewPackageLI(String pkgName, + File tmpPackageFile, + String destFilePath, File destPackageFile, File destResourceFile, + PackageParser.Package pkg, boolean forwardLocked, + PackageInstalledInfo res) { + // Remember this for later, in case we need to rollback this install + boolean dataDirExists = (new File(mAppDataDir, pkgName)).exists(); + res.name = pkgName; + synchronized(mPackages) { + if (mPackages.containsKey(pkgName) || mAppDirs.containsKey(destFilePath)) { + // Don't allow installation over an existing package with the same name. + Log.w(TAG, "Attempt to re-install " + pkgName + + " without first uninstalling."); + res.returnCode = PackageManager.INSTALL_FAILED_ALREADY_EXISTS; + return; + } + } + if (destPackageFile.exists()) { + // It's safe to do this because we know (from the above check) that the file + // isn't currently used for an installed package. + destPackageFile.delete(); + } + mLastScanError = PackageManager.INSTALL_SUCCEEDED; + PackageParser.Package newPackage = scanPackageLI(tmpPackageFile, destPackageFile, + destResourceFile, pkg, 0, + SCAN_MONITOR | SCAN_FORCE_DEX + | SCAN_UPDATE_SIGNATURE + | (forwardLocked ? SCAN_FORWARD_LOCKED : 0)); + if (newPackage == null) { + Log.w(TAG, "Package couldn't be installed in " + destPackageFile); + if ((res.returnCode=mLastScanError) == PackageManager.INSTALL_SUCCEEDED) { + res.returnCode = PackageManager.INSTALL_FAILED_INVALID_APK; + } + } else { + updateSettingsLI(pkgName, tmpPackageFile, + destFilePath, destPackageFile, + destResourceFile, pkg, + newPackage, + true, + forwardLocked, + res); + // delete the partially installed application. the data directory will have to be + // restored if it was already existing + if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) { + // remove package from internal structures. Note that we want deletePackageX to + // delete the package data and cache directories that it created in + // scanPackageLocked, unless those directories existed before we even tried to + // install. + deletePackageLI( + pkgName, true, + dataDirExists ? PackageManager.DONT_DELETE_DATA : 0, + res.removedInfo); + } + } + } + + private void replacePackageLI(String pkgName, + File tmpPackageFile, + String destFilePath, File destPackageFile, File destResourceFile, + PackageParser.Package pkg, boolean forwardLocked, + PackageInstalledInfo res) { + PackageParser.Package deletedPackage; + // First find the old package info and check signatures + synchronized(mPackages) { + deletedPackage = mPackages.get(pkgName); + if(checkSignaturesLP(pkg, deletedPackage) != PackageManager.SIGNATURE_MATCH) { + res.returnCode = PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES; + return; + } + } + boolean sysPkg = ((deletedPackage.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0); + if(sysPkg) { + replaceSystemPackageLI(deletedPackage, + tmpPackageFile, destFilePath, + destPackageFile, destResourceFile, pkg, forwardLocked, res); + } else { + replaceNonSystemPackageLI(deletedPackage, tmpPackageFile, destFilePath, + destPackageFile, destResourceFile, pkg, forwardLocked, res); + } + } + + private void replaceNonSystemPackageLI(PackageParser.Package deletedPackage, + File tmpPackageFile, + String destFilePath, File destPackageFile, File destResourceFile, + PackageParser.Package pkg, boolean forwardLocked, + PackageInstalledInfo res) { + PackageParser.Package newPackage = null; + String pkgName = deletedPackage.packageName; + boolean deletedPkg = true; + boolean updatedSettings = false; + int parseFlags = PackageManager.REPLACE_EXISTING_PACKAGE; + // First delete the existing package while retaining the data directory + if (!deletePackageLI(pkgName, false, PackageManager.DONT_DELETE_DATA, + res.removedInfo)) { + // If the existing package was'nt successfully deleted + res.returnCode = PackageManager.INSTALL_FAILED_REPLACE_COULDNT_DELETE; + deletedPkg = false; + } else { + // Successfully deleted the old package. Now proceed with re-installation + mLastScanError = PackageManager.INSTALL_SUCCEEDED; + newPackage = scanPackageLI(tmpPackageFile, destPackageFile, + destResourceFile, pkg, parseFlags, + SCAN_MONITOR | SCAN_FORCE_DEX + | SCAN_UPDATE_SIGNATURE + | (forwardLocked ? SCAN_FORWARD_LOCKED : 0)); + if (newPackage == null) { + Log.w(TAG, "Package couldn't be installed in " + destPackageFile); + if ((res.returnCode=mLastScanError) == PackageManager.INSTALL_SUCCEEDED) { + res.returnCode = PackageManager.INSTALL_FAILED_INVALID_APK; + } + } else { + updateSettingsLI(pkgName, tmpPackageFile, + destFilePath, destPackageFile, + destResourceFile, pkg, + newPackage, + true, + forwardLocked, + res); + updatedSettings = true; + } + } + + if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) { + // If we deleted an exisiting package, the old source and resource files that we + // were keeping around in case we needed them (see below) can now be deleted + final ApplicationInfo deletedPackageAppInfo = deletedPackage.applicationInfo; + final ApplicationInfo installedPackageAppInfo = + newPackage.applicationInfo; + if (!deletedPackageAppInfo.sourceDir + .equals(installedPackageAppInfo.sourceDir)) { + new File(deletedPackageAppInfo.sourceDir).delete(); + } + if (!deletedPackageAppInfo.publicSourceDir + .equals(installedPackageAppInfo.publicSourceDir)) { + new File(deletedPackageAppInfo.publicSourceDir).delete(); + } + //update signature on the new package setting + //this should always succeed, since we checked the + //signature earlier. + synchronized(mPackages) { + verifySignaturesLP(mSettings.mPackages.get(pkgName), pkg, + parseFlags, true); + } + } else { + // remove package from internal structures. Note that we want deletePackageX to + // delete the package data and cache directories that it created in + // scanPackageLocked, unless those directories existed before we even tried to + // install. + if(updatedSettings) { + deletePackageLI( + pkgName, true, + PackageManager.DONT_DELETE_DATA, + res.removedInfo); + } + // Since we failed to install the new package we need to restore the old + // package that we deleted. + if(deletedPkg) { + installPackageLI( + Uri.fromFile(new File(deletedPackage.mPath)), + isForwardLocked(deletedPackage) + ? PackageManager.FORWARD_LOCK_PACKAGE + : 0); + } + } + } + + private void replaceSystemPackageLI(PackageParser.Package deletedPackage, + File tmpPackageFile, + String destFilePath, File destPackageFile, File destResourceFile, + PackageParser.Package pkg, boolean forwardLocked, + PackageInstalledInfo res) { + PackageParser.Package newPackage = null; + boolean updatedSettings = false; + int parseFlags = PackageManager.REPLACE_EXISTING_PACKAGE | + PackageParser.PARSE_IS_SYSTEM; + String packageName = deletedPackage.packageName; + res.returnCode = PackageManager.INSTALL_FAILED_REPLACE_COULDNT_DELETE; + if (packageName == null) { + Log.w(TAG, "Attempt to delete null packageName."); + return; + } + PackageParser.Package oldPkg; + PackageSetting oldPkgSetting; + synchronized (mPackages) { + oldPkg = mPackages.get(packageName); + oldPkgSetting = mSettings.mPackages.get(packageName); + if((oldPkg == null) || (oldPkg.applicationInfo == null) || + (oldPkgSetting == null)) { + Log.w(TAG, "Could'nt find package:"+packageName+" information"); + return; + } + } + res.removedInfo.uid = oldPkg.applicationInfo.uid; + res.removedInfo.removedPackage = packageName; + // Remove existing system package + removePackageLI(oldPkg, true); + synchronized (mPackages) { + res.removedInfo.removedUid = mSettings.disableSystemPackageLP(packageName); + } + + // Successfully disabled the old package. Now proceed with re-installation + mLastScanError = PackageManager.INSTALL_SUCCEEDED; + pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP; + newPackage = scanPackageLI(tmpPackageFile, destPackageFile, + destResourceFile, pkg, parseFlags, + SCAN_MONITOR | SCAN_FORCE_DEX + | SCAN_UPDATE_SIGNATURE + | (forwardLocked ? SCAN_FORWARD_LOCKED : 0)); + if (newPackage == null) { + Log.w(TAG, "Package couldn't be installed in " + destPackageFile); + if ((res.returnCode=mLastScanError) == PackageManager.INSTALL_SUCCEEDED) { + res.returnCode = PackageManager.INSTALL_FAILED_INVALID_APK; + } + } else { + updateSettingsLI(packageName, tmpPackageFile, + destFilePath, destPackageFile, + destResourceFile, pkg, + newPackage, + true, + forwardLocked, + res); + updatedSettings = true; + } + + if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) { + //update signature on the new package setting + //this should always succeed, since we checked the + //signature earlier. + synchronized(mPackages) { + verifySignaturesLP(mSettings.mPackages.get(packageName), pkg, + parseFlags, true); + } + } else { + // Re installation failed. Restore old information + // Remove new pkg information + removePackageLI(newPackage, true); + // Add back the old system package + scanPackageLI(oldPkgSetting.codePath, oldPkgSetting.codePath, + oldPkgSetting.resourcePath, + oldPkg, parseFlags, + SCAN_MONITOR + | SCAN_UPDATE_SIGNATURE + | (forwardLocked ? SCAN_FORWARD_LOCKED : 0)); + // Restore the old system information in Settings + synchronized(mPackages) { + if(updatedSettings) { + mSettings.enableSystemPackageLP(packageName); + } + mSettings.writeLP(); + } + } + } + + private void updateSettingsLI(String pkgName, File tmpPackageFile, + String destFilePath, File destPackageFile, + File destResourceFile, + PackageParser.Package pkg, + PackageParser.Package newPackage, + boolean replacingExistingPackage, + boolean forwardLocked, + PackageInstalledInfo res) { + synchronized (mPackages) { + //write settings. the installStatus will be incomplete at this stage. + //note that the new package setting would have already been + //added to mPackages. It hasn't been persisted yet. + mSettings.setInstallStatus(pkgName, PKG_INSTALL_INCOMPLETE); + mSettings.writeLP(); + } + + int retCode = 0; + if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_HAS_CODE) != 0) { + retCode = mInstaller.movedex(tmpPackageFile.toString(), + destPackageFile.toString()); + if (retCode != 0) { + Log.e(TAG, "Couldn't rename dex file: " + destPackageFile); + res.returnCode = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + return; + } + } + // XXX There are probably some big issues here: upon doing + // the rename, we have reached the point of no return (the + // original .apk is gone!), so we can't fail. Yet... we can. + if (!tmpPackageFile.renameTo(destPackageFile)) { + Log.e(TAG, "Couldn't move package file to: " + destPackageFile); + res.returnCode = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + } else { + res.returnCode = setPermissionsLI(pkgName, newPackage, destFilePath, + destResourceFile, + forwardLocked); + if(res.returnCode != PackageManager.INSTALL_SUCCEEDED) { + return; + } else { + Log.d(TAG, "New package installed in " + destPackageFile); + } + } + if(res.returnCode != PackageManager.INSTALL_SUCCEEDED) { + if (mInstaller != null) { + mInstaller.rmdex(tmpPackageFile.getPath()); + } + } + + synchronized (mPackages) { + grantPermissionsLP(newPackage, true); + res.name = pkgName; + res.uid = newPackage.applicationInfo.uid; + res.pkg = newPackage; + mSettings.setInstallStatus(pkgName, PKG_INSTALL_COMPLETE); + res.returnCode = PackageManager.INSTALL_SUCCEEDED; + //to update install status + mSettings.writeLP(); + } + } + + private PackageInstalledInfo installPackageLI(Uri pPackageURI, int pFlags) { + File tmpPackageFile = null; + String pkgName = null; + boolean forwardLocked = false; + boolean replacingExistingPackage = false; + // Result object to be returned + PackageInstalledInfo res = new PackageInstalledInfo(); + res.returnCode = PackageManager.INSTALL_SUCCEEDED; + res.uid = -1; + res.pkg = null; + res.removedInfo = new PackageRemovedInfo(); + + main_flow: try { + tmpPackageFile = createTempPackageFile(); + if (tmpPackageFile == null) { + res.returnCode = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + break main_flow; + } + tmpPackageFile.deleteOnExit(); // paranoia + if (pPackageURI.getScheme().equals("file")) { + final File srcPackageFile = new File(pPackageURI.getPath()); + // We copy the source package file to a temp file and then rename it to the + // destination file in order to eliminate a window where the package directory + // scanner notices the new package file but it's not completely copied yet. + if (!FileUtils.copyFile(srcPackageFile, tmpPackageFile)) { + Log.e(TAG, "Couldn't copy package file to temp file."); + res.returnCode = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + break main_flow; + } + } else if (pPackageURI.getScheme().equals("content")) { + ParcelFileDescriptor fd; + try { + fd = mContext.getContentResolver().openFileDescriptor(pPackageURI, "r"); + } catch (FileNotFoundException e) { + Log.e(TAG, "Couldn't open file descriptor from download service."); + res.returnCode = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + break main_flow; + } + if (fd == null) { + Log.e(TAG, "Couldn't open file descriptor from download service (null)."); + res.returnCode = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + break main_flow; + } + if (Config.LOGV) { + Log.v(TAG, "Opened file descriptor from download service."); + } + ParcelFileDescriptor.AutoCloseInputStream + dlStream = new ParcelFileDescriptor.AutoCloseInputStream(fd); + // We copy the source package file to a temp file and then rename it to the + // destination file in order to eliminate a window where the package directory + // scanner notices the new package file but it's not completely copied yet. + if (!FileUtils.copyToFile(dlStream, tmpPackageFile)) { + Log.e(TAG, "Couldn't copy package stream to temp file."); + res.returnCode = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + break main_flow; + } + } else { + Log.e(TAG, "Package URI is not 'file:' or 'content:' - " + pPackageURI); + res.returnCode = PackageManager.INSTALL_FAILED_INVALID_URI; + break main_flow; + } + pkgName = PackageParser.parsePackageName( + tmpPackageFile.getAbsolutePath(), 0); + if (pkgName == null) { + Log.e(TAG, "Couldn't find a package name in : " + tmpPackageFile); + res.returnCode = PackageManager.INSTALL_FAILED_INVALID_APK; + break main_flow; + } + res.name = pkgName; + //initialize some variables before installing pkg + final String pkgFileName = pkgName + ".apk"; + final File destDir = ((pFlags&PackageManager.FORWARD_LOCK_PACKAGE) != 0) + ? mDrmAppPrivateInstallDir + : mAppInstallDir; + final File destPackageFile = new File(destDir, pkgFileName); + final String destFilePath = destPackageFile.getAbsolutePath(); + File destResourceFile; + if ((pFlags&PackageManager.FORWARD_LOCK_PACKAGE) != 0) { + final String publicZipFileName = pkgName + ".zip"; + destResourceFile = new File(mAppInstallDir, publicZipFileName); + forwardLocked = true; + } else { + destResourceFile = destPackageFile; + } + // Retrieve PackageSettings and parse package + int parseFlags = PackageParser.PARSE_CHATTY; + parseFlags |= mDefParseFlags; + PackageParser pp = new PackageParser(tmpPackageFile.getPath()); + pp.setSeparateProcesses(mSeparateProcesses); + pp.setSdkVersion(mSdkVersion); + final PackageParser.Package pkg = pp.parsePackage(tmpPackageFile, + destPackageFile.getAbsolutePath(), mMetrics, parseFlags); + if (pkg == null) { + res.returnCode = pp.getParseError(); + break main_flow; + } + if (GET_CERTIFICATES && !pp.collectCertificates(pkg, parseFlags)) { + res.returnCode = pp.getParseError(); + break main_flow; + } + + synchronized (mPackages) { + //check if installing already existing package + if ((pFlags&PackageManager.REPLACE_EXISTING_PACKAGE) != 0 + && mPackages.containsKey(pkgName)) { + replacingExistingPackage = true; + } + } + + if(replacingExistingPackage) { + replacePackageLI(pkgName, + tmpPackageFile, + destFilePath, destPackageFile, destResourceFile, + pkg, forwardLocked, + res); + } else { + installNewPackageLI(pkgName, + tmpPackageFile, + destFilePath, destPackageFile, destResourceFile, + pkg, forwardLocked, + res); + } + } finally { + if (tmpPackageFile != null && tmpPackageFile.exists()) { + tmpPackageFile.delete(); + } + return res; + } + } + + private int setPermissionsLI(String pkgName, + PackageParser.Package newPackage, + String destFilePath, + File destResourceFile, + boolean forwardLocked) { + int retCode; + if (forwardLocked) { + try { + extractPublicFiles(newPackage, destResourceFile); + } catch (IOException e) { + Log.e(TAG, "Couldn't create a new zip file for the public parts of a" + + " forward-locked app."); + return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE; + } finally { + //TODO clean up the extracted public files + } + if (mInstaller != null) { + retCode = mInstaller.setForwardLockPerm(pkgName, + newPackage.applicationInfo.uid); + } else { + final int filePermissions = + FileUtils.S_IRUSR|FileUtils.S_IWUSR|FileUtils.S_IRGRP; + retCode = FileUtils.setPermissions(destFilePath, filePermissions, -1, + newPackage.applicationInfo.uid); + } + } else { + final int filePermissions = + FileUtils.S_IRUSR|FileUtils.S_IWUSR|FileUtils.S_IRGRP + |FileUtils.S_IROTH; + retCode = FileUtils.setPermissions(destFilePath, filePermissions, -1, -1); + } + if (retCode != 0) { + Log.e(TAG, "Couldn't set new package file permissions for " + destFilePath + + ". The return code was: " + retCode); + } + return PackageManager.INSTALL_SUCCEEDED; + } + + private boolean isForwardLocked(PackageParser.Package deletedPackage) { + final ApplicationInfo applicationInfo = deletedPackage.applicationInfo; + return applicationInfo.sourceDir.startsWith(mDrmAppPrivateInstallDir.getAbsolutePath()); + } + + private void extractPublicFiles(PackageParser.Package newPackage, + File publicZipFile) throws IOException { + final ZipOutputStream publicZipOutStream = + new ZipOutputStream(new FileOutputStream(publicZipFile)); + final ZipFile privateZip = new ZipFile(newPackage.mPath); + + // Copy manifest, resources.arsc and res directory to public zip + + final Enumeration<? extends ZipEntry> privateZipEntries = privateZip.entries(); + while (privateZipEntries.hasMoreElements()) { + final ZipEntry zipEntry = privateZipEntries.nextElement(); + final String zipEntryName = zipEntry.getName(); + if ("AndroidManifest.xml".equals(zipEntryName) + || "resources.arsc".equals(zipEntryName) + || zipEntryName.startsWith("res/")) { + try { + copyZipEntry(zipEntry, privateZip, publicZipOutStream); + } catch (IOException e) { + try { + publicZipOutStream.close(); + throw e; + } finally { + publicZipFile.delete(); + } + } + } + } + + publicZipOutStream.close(); + FileUtils.setPermissions( + publicZipFile.getAbsolutePath(), + FileUtils.S_IRUSR|FileUtils.S_IWUSR|FileUtils.S_IRGRP|FileUtils.S_IROTH, + -1, -1); + } + + private static void copyZipEntry(ZipEntry zipEntry, + ZipFile inZipFile, + ZipOutputStream outZipStream) throws IOException { + byte[] buffer = new byte[4096]; + int num; + + ZipEntry newEntry; + if (zipEntry.getMethod() == ZipEntry.STORED) { + // Preserve the STORED method of the input entry. + newEntry = new ZipEntry(zipEntry); + } else { + // Create a new entry so that the compressed len is recomputed. + newEntry = new ZipEntry(zipEntry.getName()); + } + outZipStream.putNextEntry(newEntry); + + InputStream data = inZipFile.getInputStream(zipEntry); + while ((num = data.read(buffer)) > 0) { + outZipStream.write(buffer, 0, num); + } + outZipStream.flush(); + } + + private void deleteTempPackageFiles() { + FilenameFilter filter = new FilenameFilter() { + public boolean accept(File dir, String name) { + return name.startsWith("vmdl") && name.endsWith(".tmp"); + } + }; + String tmpFilesList[] = mAppInstallDir.list(filter); + if(tmpFilesList == null) { + return; + } + for(int i = 0; i < tmpFilesList.length; i++) { + File tmpFile = new File(mAppInstallDir, tmpFilesList[i]); + tmpFile.delete(); + } + } + + private File createTempPackageFile() { + File tmpPackageFile; + try { + tmpPackageFile = File.createTempFile("vmdl", ".tmp", mAppInstallDir); + } catch (IOException e) { + Log.e(TAG, "Couldn't create temp file for downloaded package file."); + return null; + } + try { + FileUtils.setPermissions( + tmpPackageFile.getCanonicalPath(), FileUtils.S_IRUSR|FileUtils.S_IWUSR, + -1, -1); + } catch (IOException e) { + Log.e(TAG, "Trouble getting the canoncical path for a temp file."); + return null; + } + return tmpPackageFile; + } + + public void deletePackage(final String packageName, + final IPackageDeleteObserver observer, + final int flags) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.DELETE_PACKAGES, null); + // Queue up an async operation since the package deletion may take a little while. + mHandler.post(new Runnable() { + public void run() { + mHandler.removeCallbacks(this); + final boolean succeded = deletePackageX(packageName, true, true, flags); + if (observer != null) { + try { + observer.packageDeleted(succeded); + } catch (RemoteException e) { + Log.i(TAG, "Observer no longer exists."); + } //end catch + } //end if + } //end run + }); + } + + /** + * This method is an internal method that could be get invoked either + * to delete an installed package or to clean up a failed installation. + * After deleting an installed package, a broadcast is sent to notify any + * listeners that the package has been installed. For cleaning up a failed + * installation, the broadcast is not necessary since the package's + * installation wouldn't have sent the initial broadcast either + * The key steps in deleting a package are + * deleting the package information in internal structures like mPackages, + * deleting the packages base directories through installd + * updating mSettings to reflect current status + * persisting settings for later use + * sending a broadcast if necessary + */ + + private boolean deletePackageX(String packageName, boolean sendBroadCast, + boolean deleteCodeAndResources, int flags) { + PackageRemovedInfo info = new PackageRemovedInfo(); + boolean res = false; + + synchronized (mInstallLock) { + res = deletePackageLI(packageName, deleteCodeAndResources, flags, info); + } + + if(res && sendBroadCast) { + info.sendBroadcast(deleteCodeAndResources, false); + } + return res; + } + + static class PackageRemovedInfo { + String removedPackage; + int uid = -1; + int removedUid = -1; + + void sendBroadcast(boolean fullRemove, boolean replacing) { + Bundle extras = new Bundle(1); + extras.putInt(Intent.EXTRA_UID, removedUid >= 0 ? removedUid : uid); + extras.putBoolean(Intent.EXTRA_DATA_REMOVED, fullRemove); + if (replacing) { + extras.putBoolean(Intent.EXTRA_REPLACING, true); + } + if (removedPackage != null) { + sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage, extras); + } + if (removedUid >= 0) { + sendPackageBroadcast(Intent.ACTION_UID_REMOVED, null, extras); + } + } + } + + /* + * This method deletes the package from internal data structures. If the DONT_DELETE_DATA + * flag is not set, the data directory is removed as well. + * make sure this flag is set for partially installed apps. If not its meaningless to + * delete a partially installed application. + */ + private void removePackageDataLI(PackageParser.Package p, PackageRemovedInfo outInfo, + int flags) { + String packageName = p.packageName; + outInfo.removedPackage = packageName; + removePackageLI(p, true); + // Retrieve object to delete permissions for shared user later on + PackageSetting deletedPs; + synchronized (mPackages) { + deletedPs = mSettings.mPackages.get(packageName); + } + if ((flags&PackageManager.DONT_DELETE_DATA) == 0) { + if (mInstaller != null) { + int retCode = mInstaller.remove(packageName); + if (retCode < 0) { + Log.w(TAG, "Couldn't remove app data or cache directory for package: " + + packageName + ", retcode=" + retCode); + // we don't consider this to be a failure of the core package deletion + } + } else { + //for emulator + PackageParser.Package pkg = mPackages.get(packageName); + File dataDir = new File(pkg.applicationInfo.dataDir); + dataDir.delete(); + } + synchronized (mPackages) { + outInfo.removedUid = mSettings.removePackageLP(packageName); + } + } + synchronized (mPackages) { + if ( (deletedPs != null) && (deletedPs.sharedUser != null)) { + // remove permissions associated with package + mSettings.updateSharedUserPerms (deletedPs); + } + // Save settings now + mSettings.writeLP (); + } + } + + /* + * Tries to delete system package. + */ + private boolean deleteSystemPackageLI(PackageParser.Package p, + boolean deleteCodeAndResources, int flags, PackageRemovedInfo outInfo) { + ApplicationInfo applicationInfo = p.applicationInfo; + //applicable for non-partially installed applications only + if (applicationInfo == null) { + Log.w(TAG, "Package " + p.packageName + " has no applicationInfo."); + return false; + } + PackageSetting ps = null; + // Confirm if the system package has been updated + // An updated system app can be deleted. This will also have to restore + // the system pkg from system partition + synchronized (mPackages) { + ps = mSettings.getDisabledSystemPkg(p.packageName); + } + if (ps == null) { + Log.w(TAG, "Attempt to delete system package "+ p.packageName); + return false; + } else { + Log.i(TAG, "Deleting system pkg from data partition"); + } + // Delete the updated package + boolean ret = deleteInstalledPackageLI(p, deleteCodeAndResources, flags, outInfo); + if (!ret) { + return false; + } + synchronized (mPackages) { + // Reinstate the old system package + mSettings.enableSystemPackageLP(p.packageName); + } + // Install the system package + PackageParser.Package newPkg = scanPackageLI(ps.codePath, ps.codePath, ps.resourcePath, + PackageParser.PARSE_MUST_BE_APK | PackageParser.PARSE_IS_SYSTEM, + SCAN_MONITOR); + + if (newPkg == null) { + Log.w(TAG, "Failed to restore system package:"+p.packageName+" with error:" + mLastScanError); + return false; + } + synchronized (mPackages) { + mSettings.writeLP(); + } + return true; + } + + private boolean deleteInstalledPackageLI(PackageParser.Package p, + boolean deleteCodeAndResources, int flags, PackageRemovedInfo outInfo) { + ApplicationInfo applicationInfo = p.applicationInfo; + if (applicationInfo == null) { + Log.w(TAG, "Package " + p.packageName + " has no applicationInfo."); + return false; + } + // Delete application's source directory + File sourceFile = new File(applicationInfo.sourceDir); + if (!sourceFile.exists()) { + Log.w(TAG, "Package source " + applicationInfo.sourceDir + " does not exist."); + } + outInfo.uid = applicationInfo.uid; + + // Delete package data from internal structures and also remove data if flag is set + removePackageDataLI(p, outInfo, flags); + + // Delete application code and resources + if (deleteCodeAndResources) { + sourceFile.delete(); + final File publicSourceFile = new File(applicationInfo.publicSourceDir); + if (publicSourceFile.exists()) { + publicSourceFile.delete(); + } + if (mInstaller != null) { + int retCode = mInstaller.rmdex(sourceFile.toString()); + if (retCode < 0) { + Log.w(TAG, "Couldn't remove dex file for package: " + + p.packageName + " at location " + sourceFile.toString() + ", retcode=" + retCode); + // we don't consider this to be a failure of the core package deletion + } + } + } + return true; + } + + /* + * This method handles package deletion in general + */ + private boolean deletePackageLI(String packageName, + boolean deleteCodeAndResources, int flags, PackageRemovedInfo outInfo) { + if (packageName == null) { + Log.w(TAG, "Attempt to delete null packageName."); + return false; + } + PackageParser.Package p; + boolean dataOnly = false; + synchronized (mPackages) { + p = mPackages.get(packageName); + if (p == null) { + //this retrieves partially installed apps + dataOnly = true; + PackageSetting ps = mSettings.mPackages.get(packageName); + if (ps == null) { + Log.w(TAG, "Package named '" + packageName +"' doesn't exist."); + return false; + } + p = ps.pkg; + } + } + if (p == null) { + Log.w(TAG, "Package named '" + packageName +"' doesn't exist."); + return false; + } + + if (dataOnly) { + // Delete application data first + removePackageDataLI(p, outInfo, flags); + return true; + } + // At this point the package should have ApplicationInfo associated with it + if (p.applicationInfo == null) { + Log.w(TAG, "Package " + p.packageName + " has no applicationInfo."); + return false; + } + if ( (p.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) { + Log.i(TAG, "Removing system package:"+p.packageName); + // When an updated system application is deleted we delete the existing resources as well and + // fall back to existing code in system partition + return deleteSystemPackageLI(p, true, flags, outInfo); + } + Log.i(TAG, "Removing non-system package:"+p.packageName); + return deleteInstalledPackageLI (p, deleteCodeAndResources, flags, outInfo); + } + + public void clearApplicationUserData(final String packageName, + final IPackageDataObserver observer) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.CLEAR_APP_USER_DATA, null); + // Queue up an async operation since the package deletion may take a little while. + mHandler.post(new Runnable() { + public void run() { + mHandler.removeCallbacks(this); + final boolean succeeded; + synchronized (mInstallLock) { + succeeded = clearApplicationUserDataLI(packageName); + } + if (succeeded) { + // invoke DeviceStorageMonitor's update method to clear any notifications + DeviceStorageMonitorService dsm = (DeviceStorageMonitorService) + ServiceManager.getService(DeviceStorageMonitorService.SERVICE); + if (dsm != null) { + dsm.updateMemory(); + } + } + if(observer != null) { + try { + observer.onRemoveCompleted(packageName, succeeded); + } catch (RemoteException e) { + Log.i(TAG, "Observer no longer exists."); + } + } //end if observer + } //end run + }); + } + + private boolean clearApplicationUserDataLI(String packageName) { + if (packageName == null) { + Log.w(TAG, "Attempt to delete null packageName."); + return false; + } + PackageParser.Package p; + boolean dataOnly = false; + synchronized (mPackages) { + p = mPackages.get(packageName); + if(p == null) { + dataOnly = true; + PackageSetting ps = mSettings.mPackages.get(packageName); + if((ps == null) || (ps.pkg == null)) { + Log.w(TAG, "Package named '" + packageName +"' doesn't exist."); + return false; + } + p = ps.pkg; + } + } + if(!dataOnly) { + //need to check this only for fully installed applications + if (p == null) { + Log.w(TAG, "Package named '" + packageName +"' doesn't exist."); + return false; + } + final ApplicationInfo applicationInfo = p.applicationInfo; + if (applicationInfo == null) { + Log.w(TAG, "Package " + packageName + " has no applicationInfo."); + return false; + } + } + if (mInstaller != null) { + int retCode = mInstaller.clearUserData(packageName); + if (retCode < 0) { + Log.w(TAG, "Couldn't remove cache files for package: " + + packageName); + return false; + } + } + return true; + } + + public void deleteApplicationCacheFiles(final String packageName, + final IPackageDataObserver observer) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.DELETE_CACHE_FILES, null); + // Queue up an async operation since the package deletion may take a little while. + mHandler.post(new Runnable() { + public void run() { + mHandler.removeCallbacks(this); + final boolean succeded; + synchronized (mInstallLock) { + succeded = deleteApplicationCacheFilesLI(packageName); + } + if(observer != null) { + try { + observer.onRemoveCompleted(packageName, succeded); + } catch (RemoteException e) { + Log.i(TAG, "Observer no longer exists."); + } + } //end if observer + } //end run + }); + } + + private boolean deleteApplicationCacheFilesLI(String packageName) { + if (packageName == null) { + Log.w(TAG, "Attempt to delete null packageName."); + return false; + } + PackageParser.Package p; + synchronized (mPackages) { + p = mPackages.get(packageName); + } + if (p == null) { + Log.w(TAG, "Package named '" + packageName +"' doesn't exist."); + return false; + } + final ApplicationInfo applicationInfo = p.applicationInfo; + if (applicationInfo == null) { + Log.w(TAG, "Package " + packageName + " has no applicationInfo."); + return false; + } + if (mInstaller != null) { + int retCode = mInstaller.deleteCacheFiles(packageName); + if (retCode < 0) { + Log.w(TAG, "Couldn't remove cache files for package: " + + packageName); + return false; + } + } + return true; + } + + public void getPackageSizeInfo(final String packageName, + final IPackageStatsObserver observer) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.GET_PACKAGE_SIZE, null); + // Queue up an async operation since the package deletion may take a little while. + mHandler.post(new Runnable() { + public void run() { + mHandler.removeCallbacks(this); + PackageStats lStats = new PackageStats(packageName); + final boolean succeded; + synchronized (mInstallLock) { + succeded = getPackageSizeInfoLI(packageName, lStats); + } + if(observer != null) { + try { + observer.onGetStatsCompleted(lStats, succeded); + } catch (RemoteException e) { + Log.i(TAG, "Observer no longer exists."); + } + } //end if observer + } //end run + }); + } + + private boolean getPackageSizeInfoLI(String packageName, PackageStats pStats) { + if (packageName == null) { + Log.w(TAG, "Attempt to get size of null packageName."); + return false; + } + PackageParser.Package p; + boolean dataOnly = false; + synchronized (mPackages) { + p = mPackages.get(packageName); + if(p == null) { + dataOnly = true; + PackageSetting ps = mSettings.mPackages.get(packageName); + if((ps == null) || (ps.pkg == null)) { + Log.w(TAG, "Package named '" + packageName +"' doesn't exist."); + return false; + } + p = ps.pkg; + } + } + String publicSrcDir = null; + if(!dataOnly) { + final ApplicationInfo applicationInfo = p.applicationInfo; + if (applicationInfo == null) { + Log.w(TAG, "Package " + packageName + " has no applicationInfo."); + return false; + } + publicSrcDir = isForwardLocked(p) ? applicationInfo.publicSourceDir : null; + } + if (mInstaller != null) { + int res = mInstaller.getSizeInfo(packageName, p.mPath, + publicSrcDir, pStats); + if (res < 0) { + return false; + } else { + return true; + } + } + return true; + } + + + public void addPackageToPreferred(String packageName) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null); + + synchronized (mPackages) { + PackageParser.Package p = mPackages.get(packageName); + if (p == null) { + return; + } + PackageSetting ps = (PackageSetting)p.mExtras; + if (ps != null) { + mSettings.mPreferredPackages.remove(ps); + mSettings.mPreferredPackages.add(0, ps); + updatePreferredIndicesLP(); + mSettings.writeLP(); + } + } + } + + public void removePackageFromPreferred(String packageName) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null); + + synchronized (mPackages) { + PackageParser.Package p = mPackages.get(packageName); + if (p == null) { + return; + } + if (p.mPreferredOrder > 0) { + PackageSetting ps = (PackageSetting)p.mExtras; + if (ps != null) { + mSettings.mPreferredPackages.remove(ps); + p.mPreferredOrder = 0; + updatePreferredIndicesLP(); + mSettings.writeLP(); + } + } + } + } + + private void updatePreferredIndicesLP() { + final ArrayList<PackageSetting> pkgs + = mSettings.mPreferredPackages; + final int N = pkgs.size(); + for (int i=0; i<N; i++) { + pkgs.get(i).pkg.mPreferredOrder = N - i; + } + } + + public List<PackageInfo> getPreferredPackages(int flags) { + synchronized (mPackages) { + final ArrayList<PackageInfo> res = new ArrayList<PackageInfo>(); + final ArrayList<PackageSetting> pref = mSettings.mPreferredPackages; + final int N = pref.size(); + for (int i=0; i<N; i++) { + res.add(generatePackageInfo(pref.get(i).pkg, flags)); + } + return res; + } + } + + public void addPreferredActivity(IntentFilter filter, int match, + ComponentName[] set, ComponentName activity) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null); + + synchronized (mPackages) { + Log.i(TAG, "Adding preferred activity " + activity + ":"); + filter.dump(new LogPrinter(Log.INFO, TAG), " "); + mSettings.mPreferredActivities.addFilter( + new PreferredActivity(filter, match, set, activity)); + mSettings.writeLP(); + } + } + + public void clearPackagePreferredActivities(String packageName) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null); + + synchronized (mPackages) { + if (clearPackagePreferredActivitiesLP(packageName)) { + mSettings.writeLP(); + } + } + } + + boolean clearPackagePreferredActivitiesLP(String packageName) { + boolean changed = false; + Iterator<PreferredActivity> it = mSettings.mPreferredActivities.filterIterator(); + while (it.hasNext()) { + PreferredActivity pa = it.next(); + if (pa.mActivity.getPackageName().equals(packageName)) { + it.remove(); + changed = true; + } + } + return changed; + } + + public int getPreferredActivities(List<IntentFilter> outFilters, + List<ComponentName> outActivities, String packageName) { + + int num = 0; + synchronized (mPackages) { + Iterator<PreferredActivity> it = mSettings.mPreferredActivities.filterIterator(); + while (it.hasNext()) { + PreferredActivity pa = it.next(); + if (packageName == null + || pa.mActivity.getPackageName().equals(packageName)) { + if (outFilters != null) { + outFilters.add(new IntentFilter(pa)); + } + if (outActivities != null) { + outActivities.add(pa.mActivity); + } + } + } + } + + return num; + } + + public void setApplicationEnabledSetting(String appPackageName, + int newState, int flags) { + setEnabledSetting(appPackageName, null, newState, flags); + } + + public void setComponentEnabledSetting(ComponentName componentName, + int newState, int flags) { + setEnabledSetting(componentName.getPackageName(), + componentName.getClassName(), newState, flags); + } + + private void setEnabledSetting( + final String packageNameStr, String classNameStr, int newState, final int flags) { + if (!(newState == COMPONENT_ENABLED_STATE_DEFAULT + || newState == COMPONENT_ENABLED_STATE_ENABLED + || newState == COMPONENT_ENABLED_STATE_DISABLED)) { + throw new IllegalArgumentException("Invalid new component state: " + + newState); + } + PackageSetting pkgSetting; + final int uid = Binder.getCallingUid(); + final int permission = mContext.checkCallingPermission( + android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE); + final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED); + int packageUid = -1; + synchronized (mPackages) { + pkgSetting = mSettings.mPackages.get(packageNameStr); + if (pkgSetting == null) { + if (classNameStr == null) { + throw new IllegalArgumentException( + "Unknown package: " + packageNameStr); + } + throw new IllegalArgumentException( + "Unknown component: " + packageNameStr + + "/" + classNameStr); + } + if (!allowedByPermission && (uid != pkgSetting.userId)) { + throw new SecurityException( + "Permission Denial: attempt to change component state from pid=" + + Binder.getCallingPid() + + ", uid=" + uid + ", package uid=" + pkgSetting.userId); + } + packageUid = pkgSetting.userId; + if (classNameStr == null) { + // We're dealing with an application/package level state change + pkgSetting.enabled = newState; + } else { + // We're dealing with a component level state change + switch (newState) { + case COMPONENT_ENABLED_STATE_ENABLED: + pkgSetting.enableComponentLP(classNameStr); + break; + case COMPONENT_ENABLED_STATE_DISABLED: + pkgSetting.disableComponentLP(classNameStr); + break; + case COMPONENT_ENABLED_STATE_DEFAULT: + pkgSetting.restoreComponentLP(classNameStr); + break; + default: + Log.e(TAG, "Invalid new component state: " + newState); + } + } + mSettings.writeLP(); + } + + long callingId = Binder.clearCallingIdentity(); + try { + Bundle extras = new Bundle(2); + extras.putBoolean(Intent.EXTRA_DONT_KILL_APP, + (flags&PackageManager.DONT_KILL_APP) != 0); + extras.putInt(Intent.EXTRA_UID, packageUid); + sendPackageBroadcast(Intent.ACTION_PACKAGE_CHANGED, packageNameStr, extras); + } finally { + Binder.restoreCallingIdentity(callingId); + } + } + + public int getApplicationEnabledSetting(String appPackageName) { + synchronized (mPackages) { + PackageSetting pkg = mSettings.mPackages.get(appPackageName); + if (pkg == null) { + throw new IllegalArgumentException("Unknown package: " + appPackageName); + } + return pkg.enabled; + } + } + + public int getComponentEnabledSetting(ComponentName componentName) { + synchronized (mPackages) { + final String packageNameStr = componentName.getPackageName(); + PackageSetting pkg = mSettings.mPackages.get(packageNameStr); + if (pkg == null) { + throw new IllegalArgumentException("Unknown component: " + componentName); + } + final String classNameStr = componentName.getClassName(); + return pkg.currentEnabledStateLP(classNameStr); + } + } + + public void enterSafeMode() { + if (!mSystemReady) { + mSafeMode = true; + } + } + + public void systemReady() { + mSystemReady = true; + } + + public boolean isSafeMode() { + return mSafeMode; + } + + public boolean hasSystemUidErrors() { + return mHasSystemUidErrors; + } + + static String arrayToString(int[] array) { + StringBuffer buf = new StringBuffer(128); + buf.append('['); + if (array != null) { + for (int i=0; i<array.length; i++) { + if (i > 0) buf.append(", "); + buf.append(array[i]); + } + } + buf.append(']'); + return buf.toString(); + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + + Printer printer = new PrintWriterPrinter(pw); + synchronized (mPackages) { + pw.println("Activity Resolver Table:"); + mActivities.dump(printer, " "); + pw.println(" "); + pw.println("Receiver Resolver Table:"); + mReceivers.dump(printer, " "); + pw.println(" "); + pw.println("Service Resolver Table:"); + mServices.dump(printer, " "); + pw.println(" "); + pw.println("Preferred Activities:"); + mSettings.mPreferredActivities.dump(printer, " "); + pw.println(" "); + pw.println("Preferred Packages:"); + { + for (PackageSetting ps : mSettings.mPreferredPackages) { + pw.println(" " + ps.name); + } + } + pw.println(" "); + pw.println("Permissions:"); + { + for (BasePermission p : mSettings.mPermissions.values()) { + pw.println(" Permission [" + p.name + "] (" + + Integer.toHexString(System.identityHashCode(p)) + + "):"); + pw.println(" sourcePackage=" + p.sourcePackage); + pw.println(" uid=" + p.uid + + " gids=" + arrayToString(p.gids) + + " type=" + p.type); + } + } + pw.println(" "); + pw.println("Packages:"); + { + for (PackageSetting ps : mSettings.mPackages.values()) { + pw.println(" Package [" + ps.name + "] (" + + Integer.toHexString(System.identityHashCode(ps)) + + "):"); + pw.println(" userId=" + ps.userId + + " gids=" + arrayToString(ps.gids)); + pw.println(" sharedUser=" + ps.sharedUser); + pw.println(" pkg=" + ps.pkg); + pw.println(" codePath=" + ps.codePathString); + pw.println(" resourcePath=" + ps.resourcePathString); + if (ps.pkg != null) { + pw.println(" dataDir=" + ps.pkg.applicationInfo.dataDir); + } + pw.println(" timeStamp=" + ps.getTimeStampStr()); + pw.println(" signatures=" + ps.signatures); + pw.println(" permissionsFixed=" + ps.permissionsFixed + + " pkgFlags=0x" + Integer.toHexString(ps.pkgFlags) + + " installStatus=" + ps.installStatus + + " enabled=" + ps.enabled); + if (ps.disabledComponents.size() > 0) { + pw.println(" disabledComponents:"); + for (String s : ps.disabledComponents) { + pw.println(" " + s); + } + } + if (ps.enabledComponents.size() > 0) { + pw.println(" enabledComponents:"); + for (String s : ps.enabledComponents) { + pw.println(" " + s); + } + } + pw.println(" grantedPermissions:"); + for (String s : ps.grantedPermissions) { + pw.println(" " + s); + } + pw.println(" loadedPermissions:"); + for (String s : ps.loadedPermissions) { + pw.println(" " + s); + } + } + } + pw.println(" "); + pw.println("Shared Users:"); + { + for (SharedUserSetting su : mSettings.mSharedUsers.values()) { + pw.println(" SharedUser [" + su.name + "] (" + + Integer.toHexString(System.identityHashCode(su)) + + "):"); + pw.println(" userId=" + su.userId + + " gids=" + arrayToString(su.gids)); + pw.println(" grantedPermissions:"); + for (String s : su.grantedPermissions) { + pw.println(" " + s); + } + pw.println(" loadedPermissions:"); + for (String s : su.loadedPermissions) { + pw.println(" " + s); + } + } + } + pw.println(" "); + pw.println("Settings parse messages:"); + pw.println(mSettings.mReadMessages.toString()); + } + } + + static final class BasePermission { + final static int TYPE_NORMAL = 0; + final static int TYPE_BUILTIN = 1; + final static int TYPE_DYNAMIC = 2; + + final String name; + final String sourcePackage; + final int type; + PackageParser.Permission perm; + PermissionInfo pendingInfo; + int uid; + int[] gids; + + BasePermission(String _name, String _sourcePackage, int _type) { + name = _name; + sourcePackage = _sourcePackage; + type = _type; + } + } + + static class PackageSignatures { + private Signature[] mSignatures; + + PackageSignatures(Signature[] sigs) { + assignSignatures(sigs); + } + + PackageSignatures() { + } + + void writeXml(XmlSerializer serializer, String tagName, + ArrayList<Signature> pastSignatures) throws IOException { + if (mSignatures == null) { + return; + } + serializer.startTag(null, tagName); + serializer.attribute(null, "count", + Integer.toString(mSignatures.length)); + for (int i=0; i<mSignatures.length; i++) { + serializer.startTag(null, "cert"); + final Signature sig = mSignatures[i]; + final int sigHash = sig.hashCode(); + final int numPast = pastSignatures.size(); + int j; + for (j=0; j<numPast; j++) { + Signature pastSig = pastSignatures.get(j); + if (pastSig.hashCode() == sigHash && pastSig.equals(sig)) { + serializer.attribute(null, "index", Integer.toString(j)); + break; + } + } + if (j >= numPast) { + pastSignatures.add(sig); + serializer.attribute(null, "index", Integer.toString(numPast)); + serializer.attribute(null, "key", sig.toCharsString()); + } + serializer.endTag(null, "cert"); + } + serializer.endTag(null, tagName); + } + + void readXml(XmlPullParser parser, ArrayList<Signature> pastSignatures) + throws IOException, XmlPullParserException { + String countStr = parser.getAttributeValue(null, "count"); + if (countStr == null) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <signatures> has" + + " no count at " + parser.getPositionDescription()); + XmlUtils.skipCurrentTag(parser); + } + final int count = Integer.parseInt(countStr); + mSignatures = new Signature[count]; + int pos = 0; + + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("cert")) { + if (pos < count) { + String index = parser.getAttributeValue(null, "index"); + if (index != null) { + try { + int idx = Integer.parseInt(index); + String key = parser.getAttributeValue(null, "key"); + if (key == null) { + if (idx >= 0 && idx < pastSignatures.size()) { + Signature sig = pastSignatures.get(idx); + if (sig != null) { + mSignatures[pos] = pastSignatures.get(idx); + pos++; + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <cert> " + + "index " + index + " is not defined at " + + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <cert> " + + "index " + index + " is out of bounds at " + + parser.getPositionDescription()); + } + } else { + while (pastSignatures.size() <= idx) { + pastSignatures.add(null); + } + Signature sig = new Signature(key); + pastSignatures.set(idx, sig); + mSignatures[pos] = sig; + pos++; + } + } catch (NumberFormatException e) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <cert> " + + "index " + index + " is not a number at " + + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <cert> has" + + " no index at " + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: too " + + "many <cert> tags, expected " + count + + " at " + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <cert>: " + + parser.getName()); + } + XmlUtils.skipCurrentTag(parser); + } + + if (pos < count) { + // Should never happen -- there is an error in the written + // settings -- but if it does we don't want to generate + // a bad array. + Signature[] newSigs = new Signature[pos]; + System.arraycopy(mSignatures, 0, newSigs, 0, pos); + mSignatures = newSigs; + } + } + + /** + * If any of the given 'sigs' is contained in the existing signatures, + * then completely replace the current signatures with the ones in + * 'sigs'. This is used for updating an existing package to a newly + * installed version. + */ + boolean updateSignatures(Signature[] sigs, boolean update) { + if (mSignatures == null) { + if (update) { + assignSignatures(sigs); + } + return true; + } + if (sigs == null) { + return false; + } + + for (int i=0; i<sigs.length; i++) { + Signature sig = sigs[i]; + for (int j=0; j<mSignatures.length; j++) { + if (mSignatures[j].equals(sig)) { + if (update) { + assignSignatures(sigs); + } + return true; + } + } + } + return false; + } + + /** + * If any of the given 'sigs' is contained in the existing signatures, + * then add in any new signatures found in 'sigs'. This is used for + * including a new package into an existing shared user id. + */ + boolean mergeSignatures(Signature[] sigs, boolean update) { + if (mSignatures == null) { + if (update) { + assignSignatures(sigs); + } + return true; + } + if (sigs == null) { + return false; + } + + Signature[] added = null; + int addedCount = 0; + boolean haveMatch = false; + for (int i=0; i<sigs.length; i++) { + Signature sig = sigs[i]; + boolean found = false; + for (int j=0; j<mSignatures.length; j++) { + if (mSignatures[j].equals(sig)) { + found = true; + haveMatch = true; + break; + } + } + + if (!found) { + if (added == null) { + added = new Signature[sigs.length]; + } + added[i] = sig; + addedCount++; + } + } + + if (!haveMatch) { + // Nothing matched -- reject the new signatures. + return false; + } + if (added == null) { + // Completely matched -- nothing else to do. + return true; + } + + // Add additional signatures in. + if (update) { + Signature[] total = new Signature[addedCount+mSignatures.length]; + System.arraycopy(mSignatures, 0, total, 0, mSignatures.length); + int j = mSignatures.length; + for (int i=0; i<added.length; i++) { + if (added[i] != null) { + total[j] = added[i]; + j++; + } + } + mSignatures = total; + } + return true; + } + + private void assignSignatures(Signature[] sigs) { + if (sigs == null) { + mSignatures = null; + return; + } + mSignatures = new Signature[sigs.length]; + for (int i=0; i<sigs.length; i++) { + mSignatures[i] = sigs[i]; + } + } + + @Override + public String toString() { + StringBuffer buf = new StringBuffer(128); + buf.append("PackageSignatures{"); + buf.append(Integer.toHexString(System.identityHashCode(this))); + buf.append(" ["); + if (mSignatures != null) { + for (int i=0; i<mSignatures.length; i++) { + if (i > 0) buf.append(", "); + buf.append(Integer.toHexString( + System.identityHashCode(mSignatures[i]))); + } + } + buf.append("]}"); + return buf.toString(); + } + } + + static class PreferredActivity extends IntentFilter { + final int mMatch; + final String[] mSetPackages; + final String[] mSetClasses; + final String[] mSetComponents; + final ComponentName mActivity; + final String mShortActivity; + String mParseError; + + PreferredActivity(IntentFilter filter, int match, ComponentName[] set, + ComponentName activity) { + super(filter); + mMatch = match&IntentFilter.MATCH_CATEGORY_MASK; + mActivity = activity; + mShortActivity = activity.flattenToShortString(); + mParseError = null; + if (set != null) { + final int N = set.length; + String[] myPackages = new String[N]; + String[] myClasses = new String[N]; + String[] myComponents = new String[N]; + for (int i=0; i<N; i++) { + ComponentName cn = set[i]; + if (cn == null) { + mSetPackages = null; + mSetClasses = null; + mSetComponents = null; + return; + } + myPackages[i] = cn.getPackageName().intern(); + myClasses[i] = cn.getClassName().intern(); + myComponents[i] = cn.flattenToShortString().intern(); + } + mSetPackages = myPackages; + mSetClasses = myClasses; + mSetComponents = myComponents; + } else { + mSetPackages = null; + mSetClasses = null; + mSetComponents = null; + } + } + + PreferredActivity(XmlPullParser parser) throws XmlPullParserException, + IOException { + mShortActivity = parser.getAttributeValue(null, "name"); + mActivity = ComponentName.unflattenFromString(mShortActivity); + if (mActivity == null) { + mParseError = "Bad activity name " + mShortActivity; + } + String matchStr = parser.getAttributeValue(null, "match"); + mMatch = matchStr != null ? Integer.parseInt(matchStr, 16) : 0; + String setCountStr = parser.getAttributeValue(null, "set"); + int setCount = setCountStr != null ? Integer.parseInt(setCountStr) : 0; + + String[] myPackages = setCount > 0 ? new String[setCount] : null; + String[] myClasses = setCount > 0 ? new String[setCount] : null; + String[] myComponents = setCount > 0 ? new String[setCount] : null; + + int setPos = 0; + + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + //Log.i(TAG, "Parse outerDepth=" + outerDepth + " depth=" + // + parser.getDepth() + " tag=" + tagName); + if (tagName.equals("set")) { + String name = parser.getAttributeValue(null, "name"); + if (name == null) { + if (mParseError == null) { + mParseError = "No name in set tag in preferred activity " + + mShortActivity; + } + } else if (setPos >= setCount) { + if (mParseError == null) { + mParseError = "Too many set tags in preferred activity " + + mShortActivity; + } + } else { + ComponentName cn = ComponentName.unflattenFromString(name); + if (cn == null) { + if (mParseError == null) { + mParseError = "Bad set name " + name + " in preferred activity " + + mShortActivity; + } + } else { + myPackages[setPos] = cn.getPackageName(); + myClasses[setPos] = cn.getClassName(); + myComponents[setPos] = name; + setPos++; + } + } + XmlUtils.skipCurrentTag(parser); + } else if (tagName.equals("filter")) { + //Log.i(TAG, "Starting to parse filter..."); + readFromXml(parser); + //Log.i(TAG, "Finished filter: outerDepth=" + outerDepth + " depth=" + // + parser.getDepth() + " tag=" + parser.getName()); + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <preferred-activities>: " + + parser.getName()); + XmlUtils.skipCurrentTag(parser); + } + } + + if (setPos != setCount) { + if (mParseError == null) { + mParseError = "Not enough set tags (expected " + setCount + + " but found " + setPos + ") in " + mShortActivity; + } + } + + mSetPackages = myPackages; + mSetClasses = myClasses; + mSetComponents = myComponents; + } + + public void writeToXml(XmlSerializer serializer) throws IOException { + final int NS = mSetClasses != null ? mSetClasses.length : 0; + serializer.attribute(null, "name", mShortActivity); + serializer.attribute(null, "match", Integer.toHexString(mMatch)); + serializer.attribute(null, "set", Integer.toString(NS)); + for (int s=0; s<NS; s++) { + serializer.startTag(null, "set"); + serializer.attribute(null, "name", mSetComponents[s]); + serializer.endTag(null, "set"); + } + serializer.startTag(null, "filter"); + super.writeToXml(serializer); + serializer.endTag(null, "filter"); + } + + boolean sameSet(List<ResolveInfo> query, int priority) { + if (mSetPackages == null) return false; + final int NQ = query.size(); + final int NS = mSetPackages.length; + int numMatch = 0; + for (int i=0; i<NQ; i++) { + ResolveInfo ri = query.get(i); + if (ri.priority != priority) continue; + ActivityInfo ai = ri.activityInfo; + boolean good = false; + for (int j=0; j<NS; j++) { + if (mSetPackages[j].equals(ai.packageName) + && mSetClasses[j].equals(ai.name)) { + numMatch++; + good = true; + break; + } + } + if (!good) return false; + } + return numMatch == NS; + } + } + + static class GrantedPermissions { + final int pkgFlags; + + HashSet<String> grantedPermissions = new HashSet<String>(); + int[] gids; + + HashSet<String> loadedPermissions = new HashSet<String>(); + + GrantedPermissions(int pkgFlags) { + this.pkgFlags = pkgFlags & ApplicationInfo.FLAG_SYSTEM; + } + } + + /** + * Settings base class for pending and resolved classes. + */ + static class PackageSettingBase extends GrantedPermissions { + final String name; + final File codePath; + final String codePathString; + final File resourcePath; + final String resourcePathString; + private long timeStamp; + private String timeStampString = "0"; + + PackageSignatures signatures = new PackageSignatures(); + + boolean permissionsFixed; + + /* Explicitly disabled components */ + HashSet<String> disabledComponents = new HashSet<String>(0); + /* Explicitly enabled components */ + HashSet<String> enabledComponents = new HashSet<String>(0); + int enabled = COMPONENT_ENABLED_STATE_DEFAULT; + int installStatus = PKG_INSTALL_COMPLETE; + + PackageSettingBase(String name, File codePath, File resourcePath, + int pkgFlags) { + super(pkgFlags); + this.name = name; + this.codePath = codePath; + this.codePathString = codePath.toString(); + this.resourcePath = resourcePath; + this.resourcePathString = resourcePath.toString(); + } + + public void setInstallStatus(int newStatus) { + installStatus = newStatus; + } + + public int getInstallStatus() { + return installStatus; + } + + public void setTimeStamp(long newStamp) { + if (newStamp != timeStamp) { + timeStamp = newStamp; + timeStampString = Long.toString(newStamp); + } + } + + public void setTimeStamp(long newStamp, String newStampStr) { + timeStamp = newStamp; + timeStampString = newStampStr; + } + + public long getTimeStamp() { + return timeStamp; + } + + public String getTimeStampStr() { + return timeStampString; + } + + public void copyFrom(PackageSettingBase base) { + grantedPermissions = base.grantedPermissions; + gids = base.gids; + loadedPermissions = base.loadedPermissions; + + timeStamp = base.timeStamp; + timeStampString = base.timeStampString; + signatures = base.signatures; + permissionsFixed = base.permissionsFixed; + disabledComponents = base.disabledComponents; + enabledComponents = base.enabledComponents; + enabled = base.enabled; + installStatus = base.installStatus; + } + + void enableComponentLP(String componentClassName) { + disabledComponents.remove(componentClassName); + enabledComponents.add(componentClassName); + } + + void disableComponentLP(String componentClassName) { + enabledComponents.remove(componentClassName); + disabledComponents.add(componentClassName); + } + + void restoreComponentLP(String componentClassName) { + enabledComponents.remove(componentClassName); + disabledComponents.remove(componentClassName); + } + + int currentEnabledStateLP(String componentName) { + if (enabledComponents.contains(componentName)) { + return COMPONENT_ENABLED_STATE_ENABLED; + } else if (disabledComponents.contains(componentName)) { + return COMPONENT_ENABLED_STATE_DISABLED; + } else { + return COMPONENT_ENABLED_STATE_DEFAULT; + } + } + } + + /** + * Settings data for a particular package we know about. + */ + static final class PackageSetting extends PackageSettingBase { + int userId; + PackageParser.Package pkg; + SharedUserSetting sharedUser; + + PackageSetting(String name, File codePath, File resourcePath, + int pkgFlags) { + super(name, codePath, resourcePath, pkgFlags); + } + + @Override + public String toString() { + return "PackageSetting{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + name + "/" + userId + "}"; + } + } + + /** + * Settings data for a particular shared user ID we know about. + */ + static final class SharedUserSetting extends GrantedPermissions { + final String name; + int userId; + final HashSet<PackageSetting> packages = new HashSet<PackageSetting>(); + final PackageSignatures signatures = new PackageSignatures(); + + SharedUserSetting(String _name, int _pkgFlags) { + super(_pkgFlags); + name = _name; + } + + @Override + public String toString() { + return "SharedUserSetting{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + name + "/" + userId + "}"; + } + } + + /** + * Holds information about dynamic settings. + */ + private static final class Settings { + private final File mSettingsFilename; + private final File mBackupSettingsFilename; + private final HashMap<String, PackageSetting> mPackages = + new HashMap<String, PackageSetting>(); + // The user's preferred packages/applications, in order of preference. + // First is the most preferred. + private final ArrayList<PackageSetting> mPreferredPackages = + new ArrayList<PackageSetting>(); + // List of replaced system applications + final HashMap<String, PackageSetting> mDisabledSysPackages = + new HashMap<String, PackageSetting>(); + + // The user's preferred activities associated with particular intent + // filters. + private final IntentResolver<PreferredActivity, PreferredActivity> mPreferredActivities = + new IntentResolver<PreferredActivity, PreferredActivity>() { + @Override + protected void dumpFilter(Printer out, String prefix, + PreferredActivity filter) { + out.println(prefix + + Integer.toHexString(System.identityHashCode(filter)) + + " " + filter.mActivity.flattenToShortString() + + " match=0x" + Integer.toHexString(filter.mMatch)); + if (filter.mSetComponents != null) { + out.println(prefix + " Selected from:"); + for (int i=0; i<filter.mSetComponents.length; i++) { + out.println(prefix + " " + filter.mSetComponents[i]); + } + } + } + }; + private final HashMap<String, SharedUserSetting> mSharedUsers = + new HashMap<String, SharedUserSetting>(); + private final ArrayList<Object> mUserIds = new ArrayList<Object>(); + private final SparseArray<Object> mOtherUserIds = + new SparseArray<Object>(); + + // For reading/writing settings file. + private final ArrayList<Signature> mPastSignatures = + new ArrayList<Signature>(); + + // Mapping from permission names to info about them. + final HashMap<String, BasePermission> mPermissions = + new HashMap<String, BasePermission>(); + + // Mapping from permission tree names to info about them. + final HashMap<String, BasePermission> mPermissionTrees = + new HashMap<String, BasePermission>(); + + private final ArrayList<String> mPendingPreferredPackages + = new ArrayList<String>(); + + private final StringBuilder mReadMessages = new StringBuilder(); + + private static final class PendingPackage extends PackageSettingBase { + final int sharedId; + + PendingPackage(String name, File codePath, File resourcePath, + int sharedId, int pkgFlags) { + super(name, codePath, resourcePath, pkgFlags); + this.sharedId = sharedId; + } + } + private final ArrayList<PendingPackage> mPendingPackages + = new ArrayList<PendingPackage>(); + + Settings() { + File dataDir = Environment.getDataDirectory(); + File systemDir = new File(dataDir, "system"); + systemDir.mkdirs(); + FileUtils.setPermissions(systemDir.toString(), + FileUtils.S_IRWXU|FileUtils.S_IRWXG + |FileUtils.S_IROTH|FileUtils.S_IXOTH, + -1, -1); + mSettingsFilename = new File(systemDir, "packages.xml"); + mBackupSettingsFilename = new File(systemDir, "packages-backup.xml"); + } + + PackageSetting getPackageLP(PackageParser.Package pkg, + SharedUserSetting sharedUser, File codePath, File resourcePath, + int pkgFlags, boolean create, boolean add) { + final String name = pkg.packageName; + PackageSetting p = getPackageLP(name, sharedUser, codePath, + resourcePath, pkgFlags, create, add); + + if (p != null) { + p.pkg = pkg; + } + return p; + } + + PackageSetting peekPackageLP(String name, String codePath) { + PackageSetting p = mPackages.get(name); + if (p != null && p.codePath.getPath().equals(codePath)) { + return p; + } + return null; + } + + void setInstallStatus(String pkgName, int status) { + PackageSetting p = mPackages.get(pkgName); + if(p != null) { + if(p.getInstallStatus() != status) { + p.setInstallStatus(status); + } + } + } + + int getInstallStatus(String pkgName) { + PackageSetting p = mPackages.get(pkgName); + if(p != null) { + return p.getInstallStatus(); + } + return -1; + } + + SharedUserSetting getSharedUserLP(String name, + int pkgFlags, boolean create) { + SharedUserSetting s = mSharedUsers.get(name); + if (s == null) { + if (!create) { + return null; + } + s = new SharedUserSetting(name, pkgFlags); + if (MULTIPLE_APPLICATION_UIDS) { + s.userId = newUserIdLP(s); + } else { + s.userId = FIRST_APPLICATION_UID; + } + Log.i(TAG, "New shared user " + name + ": id=" + s.userId); + // < 0 means we couldn't assign a userid; fall out and return + // s, which is currently null + if (s.userId >= 0) { + mSharedUsers.put(name, s); + } + } + + return s; + } + + int disableSystemPackageLP(String name) { + PackageSetting p = mPackages.get(name); + if(p == null) { + Log.w(TAG, "Package:"+name+" is not an installed package"); + return -1; + } + PackageSetting dp = mDisabledSysPackages.get(name); + // always make sure the system package code and resource paths dont change + if(dp == null) { + if((p.pkg != null) && (p.pkg.applicationInfo != null)) { + p.pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP; + } + mDisabledSysPackages.put(name, p); + } + return removePackageLP(name); + } + + PackageSetting enableSystemPackageLP(String name) { + PackageSetting p = mDisabledSysPackages.get(name); + if(p == null) { + Log.w(TAG, "Package:"+name+" is not disabled"); + return null; + } + // Reset flag in ApplicationInfo object + if((p.pkg != null) && (p.pkg.applicationInfo != null)) { + p.pkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_UPDATED_SYSTEM_APP; + } + PackageSetting ret = addPackageLP(name, p.codePath, + p.resourcePath, p.userId, p.pkgFlags); + mDisabledSysPackages.remove(name); + return ret; + } + + PackageSetting addPackageLP(String name, File codePath, + File resourcePath, int uid, int pkgFlags) { + PackageSetting p = mPackages.get(name); + if (p != null) { + if (p.userId == uid) { + return p; + } + reportSettingsProblem(Log.ERROR, + "Adding duplicate package, keeping first: " + name); + return null; + } + p = new PackageSetting(name, codePath, resourcePath, pkgFlags); + p.userId = uid; + if (addUserIdLP(uid, p, name)) { + mPackages.put(name, p); + return p; + } + return null; + } + + SharedUserSetting addSharedUserLP(String name, int uid, int pkgFlags) { + SharedUserSetting s = mSharedUsers.get(name); + if (s != null) { + if (s.userId == uid) { + return s; + } + reportSettingsProblem(Log.ERROR, + "Adding duplicate shared user, keeping first: " + name); + return null; + } + s = new SharedUserSetting(name, pkgFlags); + s.userId = uid; + if (addUserIdLP(uid, s, name)) { + mSharedUsers.put(name, s); + return s; + } + return null; + } + + private PackageSetting getPackageLP(String name, + SharedUserSetting sharedUser, File codePath, File resourcePath, + int pkgFlags, boolean create, boolean add) { + PackageSetting p = mPackages.get(name); + if (p != null) { + if (!p.codePath.equals(codePath)) { + // Check to see if its a disabled system app + PackageSetting ps = mDisabledSysPackages.get(name); + if((ps != null) && ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0)) { + // Could be a replaced system package + // Note that if the user replaced a system app, the user has to physically + // delete the new one in order to revert to the system app. So even + // if the user updated the system app via an update, the user still + // has to delete the one installed in the data partition in order to pick up the + // new system package. + return p; + } else { + reportSettingsProblem(Log.WARN, + "Package " + name + " codePath changed from " + p.codePath + + " to " + codePath + "; replacing with new"); + p = null; + } + } else if (p.sharedUser != sharedUser) { + reportSettingsProblem(Log.WARN, + "Package " + name + " shared user changed from " + + (p.sharedUser != null ? p.sharedUser.name : "<nothing>") + + " to " + + (sharedUser != null ? sharedUser.name : "<nothing>") + + "; replacing with new"); + p = null; + } + } + if (p == null) { + // Create a new PackageSettings entry. this can end up here because + // of code path mismatch or user id mismatch of an updated system partition + if (!create) { + return null; + } + p = new PackageSetting(name, codePath, resourcePath, pkgFlags); + p.setTimeStamp(codePath.lastModified()); + if (sharedUser != null) { + p.userId = sharedUser.userId; + } else if (MULTIPLE_APPLICATION_UIDS) { + p.userId = newUserIdLP(p); + } else { + p.userId = FIRST_APPLICATION_UID; + } + if (p.userId < 0) { + reportSettingsProblem(Log.WARN, + "Package " + name + " could not be assigned a valid uid"); + return null; + } + if (add) { + // Finish adding new package by adding it and updating shared + // user preferences + insertPackageSettingLP(p, name, sharedUser); + } + } + return p; + } + + // Utility method that adds a PackageSetting to mPackages and + // completes updating the shared user attributes + private void insertPackageSettingLP(PackageSetting p, String name, + SharedUserSetting sharedUser) { + mPackages.put(name, p); + if (sharedUser != null) { + if (p.sharedUser != null && p.sharedUser != sharedUser) { + reportSettingsProblem(Log.ERROR, + "Package " + p.name + " was user " + + p.sharedUser + " but is now " + sharedUser + + "; I am not changing its files so it will probably fail!"); + p.sharedUser.packages.remove(p); + } else if (p.userId != sharedUser.userId) { + reportSettingsProblem(Log.ERROR, + "Package " + p.name + " was user id " + p.userId + + " but is now user " + sharedUser + + " with id " + sharedUser.userId + + "; I am not changing its files so it will probably fail!"); + } + + sharedUser.packages.add(p); + p.sharedUser = sharedUser; + p.userId = sharedUser.userId; + } + } + + private void updateSharedUserPerms (PackageSetting deletedPs) { + if ( (deletedPs == null) || (deletedPs.pkg == null)) { + Log.i(TAG, "Trying to update info for null package. Just ignoring"); + return; + } + // No sharedUserId + if (deletedPs.sharedUser == null) { + return; + } + SharedUserSetting sus = deletedPs.sharedUser; + // Update permissions + for (String eachPerm: deletedPs.pkg.requestedPermissions) { + boolean used = false; + if (!sus.grantedPermissions.contains (eachPerm)) { + continue; + } + for (PackageSetting pkg:sus.packages) { + if (pkg.grantedPermissions.contains (eachPerm)) { + used = true; + break; + } + } + if (!used) { + // can safely delete this permission from list + sus.grantedPermissions.remove(eachPerm); + sus.loadedPermissions.remove(eachPerm); + } + } + // Update gids + int newGids[] = null; + for (PackageSetting pkg:sus.packages) { + newGids = appendInts(newGids, pkg.gids); + } + sus.gids = newGids; + } + + private int removePackageLP(String name) { + PackageSetting p = mPackages.get(name); + if (p != null) { + mPackages.remove(name); + if (p.sharedUser != null) { + p.sharedUser.packages.remove(p); + if (p.sharedUser.packages.size() == 0) { + mSharedUsers.remove(p.sharedUser.name); + removeUserIdLP(p.sharedUser.userId); + return p.sharedUser.userId; + } + } else { + removeUserIdLP(p.userId); + return p.userId; + } + } + return -1; + } + + private boolean addUserIdLP(int uid, Object obj, Object name) { + if (uid >= FIRST_APPLICATION_UID + MAX_APPLICATION_UIDS) { + return false; + } + + if (uid >= FIRST_APPLICATION_UID) { + int N = mUserIds.size(); + final int index = uid - FIRST_APPLICATION_UID; + while (index >= N) { + mUserIds.add(null); + N++; + } + if (mUserIds.get(index) != null) { + reportSettingsProblem(Log.ERROR, + "Adding duplicate shared id: " + uid + + " name=" + name); + return false; + } + mUserIds.set(index, obj); + } else { + if (mOtherUserIds.get(uid) != null) { + reportSettingsProblem(Log.ERROR, + "Adding duplicate shared id: " + uid + + " name=" + name); + return false; + } + mOtherUserIds.put(uid, obj); + } + return true; + } + + public Object getUserIdLP(int uid) { + if (uid >= FIRST_APPLICATION_UID) { + int N = mUserIds.size(); + final int index = uid - FIRST_APPLICATION_UID; + return index < N ? mUserIds.get(index) : null; + } else { + return mOtherUserIds.get(uid); + } + } + + private void removeUserIdLP(int uid) { + if (uid >= FIRST_APPLICATION_UID) { + int N = mUserIds.size(); + final int index = uid - FIRST_APPLICATION_UID; + if (index < N) mUserIds.set(index, null); + } else { + mOtherUserIds.remove(uid); + } + } + + void writeLP() { + //Debug.startMethodTracing("/data/system/packageprof", 8 * 1024 * 1024); + + // Keep the old settings around until we know the new ones have + // been successfully written. + if (mSettingsFilename.exists()) { + if (mBackupSettingsFilename.exists()) { + mBackupSettingsFilename.delete(); + } + mSettingsFilename.renameTo(mBackupSettingsFilename); + } + + mPastSignatures.clear(); + + try { + FileOutputStream str = new FileOutputStream(mSettingsFilename); + + //XmlSerializer serializer = XmlUtils.serializerInstance(); + XmlSerializer serializer = new FastXmlSerializer(); + serializer.setOutput(str, "utf-8"); + serializer.startDocument(null, true); + serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); + + serializer.startTag(null, "packages"); + + serializer.startTag(null, "permission-trees"); + for (BasePermission bp : mPermissionTrees.values()) { + writePermission(serializer, bp); + } + serializer.endTag(null, "permission-trees"); + + serializer.startTag(null, "permissions"); + for (BasePermission bp : mPermissions.values()) { + writePermission(serializer, bp); + } + serializer.endTag(null, "permissions"); + + for (PackageSetting pkg : mPackages.values()) { + writePackage(serializer, pkg); + } + + for (PackageSetting pkg : mDisabledSysPackages.values()) { + writeDisabledSysPackage(serializer, pkg); + } + + serializer.startTag(null, "preferred-packages"); + int N = mPreferredPackages.size(); + for (int i=0; i<N; i++) { + PackageSetting pkg = mPreferredPackages.get(i); + serializer.startTag(null, "item"); + serializer.attribute(null, "name", pkg.name); + serializer.endTag(null, "item"); + } + serializer.endTag(null, "preferred-packages"); + + serializer.startTag(null, "preferred-activities"); + for (PreferredActivity pa : mPreferredActivities.filterSet()) { + serializer.startTag(null, "item"); + pa.writeToXml(serializer); + serializer.endTag(null, "item"); + } + serializer.endTag(null, "preferred-activities"); + + for (SharedUserSetting usr : mSharedUsers.values()) { + serializer.startTag(null, "shared-user"); + serializer.attribute(null, "name", usr.name); + serializer.attribute(null, "userId", + Integer.toString(usr.userId)); + usr.signatures.writeXml(serializer, "sigs", mPastSignatures); + serializer.startTag(null, "perms"); + for (String name : usr.grantedPermissions) { + serializer.startTag(null, "item"); + serializer.attribute(null, "name", name); + serializer.endTag(null, "item"); + } + serializer.endTag(null, "perms"); + serializer.endTag(null, "shared-user"); + } + + serializer.endTag(null, "packages"); + + serializer.endDocument(); + + str.flush(); + str.close(); + + // New settings successfully written, old ones are no longer + // needed. + mBackupSettingsFilename.delete(); + FileUtils.setPermissions(mSettingsFilename.toString(), + FileUtils.S_IRUSR|FileUtils.S_IWUSR + |FileUtils.S_IRGRP|FileUtils.S_IWGRP + |FileUtils.S_IROTH, + -1, -1); + + } catch(XmlPullParserException e) { + Log.w(TAG, "Unable to write package manager settings, current changes will be lost at reboot", e); + + } catch(java.io.IOException e) { + Log.w(TAG, "Unable to write package manager settings, current changes will be lost at reboot", e); + + } + + //Debug.stopMethodTracing(); + } + + void writeDisabledSysPackage(XmlSerializer serializer, final PackageSetting pkg) + throws java.io.IOException { + serializer.startTag(null, "updated-package"); + serializer.attribute(null, "name", pkg.name); + serializer.attribute(null, "codePath", pkg.codePathString); + serializer.attribute(null, "ts", pkg.getTimeStampStr()); + if (!pkg.resourcePathString.equals(pkg.codePathString)) { + serializer.attribute(null, "resourcePath", pkg.resourcePathString); + } + if (pkg.sharedUser == null) { + serializer.attribute(null, "userId", + Integer.toString(pkg.userId)); + } else { + serializer.attribute(null, "sharedUserId", + Integer.toString(pkg.userId)); + } + serializer.startTag(null, "perms"); + if (pkg.sharedUser == null) { + // If this is a shared user, the permissions will + // be written there. We still need to write an + // empty permissions list so permissionsFixed will + // be set. + for (final String name : pkg.grantedPermissions) { + BasePermission bp = mPermissions.get(name); + if ((bp != null) && (bp.perm != null) && (bp.perm.info != null)) { + // We only need to write signature or system permissions but this wont + // match the semantics of grantedPermissions. So write all permissions. + serializer.startTag(null, "item"); + serializer.attribute(null, "name", name); + serializer.endTag(null, "item"); + } + } + } + serializer.endTag(null, "perms"); + serializer.endTag(null, "updated-package"); + } + + void writePackage(XmlSerializer serializer, final PackageSetting pkg) + throws java.io.IOException { + serializer.startTag(null, "package"); + serializer.attribute(null, "name", pkg.name); + serializer.attribute(null, "codePath", pkg.codePathString); + if (!pkg.resourcePathString.equals(pkg.codePathString)) { + serializer.attribute(null, "resourcePath", pkg.resourcePathString); + } + serializer.attribute(null, "system", + (pkg.pkgFlags&ApplicationInfo.FLAG_SYSTEM) != 0 + ? "true" : "false"); + serializer.attribute(null, "ts", pkg.getTimeStampStr()); + if (pkg.sharedUser == null) { + serializer.attribute(null, "userId", + Integer.toString(pkg.userId)); + } else { + serializer.attribute(null, "sharedUserId", + Integer.toString(pkg.userId)); + } + if (pkg.enabled != COMPONENT_ENABLED_STATE_DEFAULT) { + serializer.attribute(null, "enabled", + pkg.enabled == COMPONENT_ENABLED_STATE_ENABLED + ? "true" : "false"); + } + if(pkg.installStatus == PKG_INSTALL_INCOMPLETE) { + serializer.attribute(null, "installStatus", "false"); + } + pkg.signatures.writeXml(serializer, "sigs", mPastSignatures); + if ((pkg.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) { + serializer.startTag(null, "perms"); + if (pkg.sharedUser == null) { + // If this is a shared user, the permissions will + // be written there. We still need to write an + // empty permissions list so permissionsFixed will + // be set. + for (final String name : pkg.grantedPermissions) { + serializer.startTag(null, "item"); + serializer.attribute(null, "name", name); + serializer.endTag(null, "item"); + } + } + serializer.endTag(null, "perms"); + } + if (pkg.disabledComponents.size() > 0) { + serializer.startTag(null, "disabled-components"); + for (final String name : pkg.disabledComponents) { + serializer.startTag(null, "item"); + serializer.attribute(null, "name", name); + serializer.endTag(null, "item"); + } + serializer.endTag(null, "disabled-components"); + } + if (pkg.enabledComponents.size() > 0) { + serializer.startTag(null, "enabled-components"); + for (final String name : pkg.enabledComponents) { + serializer.startTag(null, "item"); + serializer.attribute(null, "name", name); + serializer.endTag(null, "item"); + } + serializer.endTag(null, "enabled-components"); + } + serializer.endTag(null, "package"); + } + + void writePermission(XmlSerializer serializer, BasePermission bp) + throws XmlPullParserException, java.io.IOException { + if (bp.type != BasePermission.TYPE_BUILTIN + && bp.sourcePackage != null) { + serializer.startTag(null, "item"); + serializer.attribute(null, "name", bp.name); + serializer.attribute(null, "package", bp.sourcePackage); + if (DEBUG_SETTINGS) Log.v(TAG, + "Writing perm: name=" + bp.name + " type=" + bp.type); + if (bp.type == BasePermission.TYPE_DYNAMIC) { + PermissionInfo pi = bp.perm != null ? bp.perm.info + : bp.pendingInfo; + if (pi != null) { + serializer.attribute(null, "type", "dynamic"); + if (pi.icon != 0) { + serializer.attribute(null, "icon", + Integer.toString(pi.icon)); + } + if (pi.nonLocalizedLabel != null) { + serializer.attribute(null, "label", + pi.nonLocalizedLabel.toString()); + } + if (pi.protectionLevel != + PermissionInfo.PROTECTION_NORMAL) { + serializer.attribute(null, "protection", + Integer.toString(pi.protectionLevel)); + } + } + } + serializer.endTag(null, "item"); + } + } + + String getReadMessagesLP() { + return mReadMessages.toString(); + } + + ArrayList<String> getListOfIncompleteInstallPackages() { + HashSet<String> kList = new HashSet<String>(mPackages.keySet()); + Iterator<String> its = kList.iterator(); + ArrayList<String> ret = new ArrayList<String>(); + while(its.hasNext()) { + String key = its.next(); + PackageSetting ps = mPackages.get(key); + if(ps.getInstallStatus() == PKG_INSTALL_INCOMPLETE) { + ret.add(key); + } + } + return ret; + } + + boolean readLP() { + FileInputStream str = null; + if (mBackupSettingsFilename.exists()) { + try { + str = new FileInputStream(mBackupSettingsFilename); + mReadMessages.append("Reading from backup settings file\n"); + Log.i(TAG, "Reading from backup settings file!"); + } catch (java.io.IOException e) { + // We'll try for the normal settings file. + } + } + + mPastSignatures.clear(); + + try { + if (str == null) { + if (!mSettingsFilename.exists()) { + mReadMessages.append("No settings file found\n"); + Log.i(TAG, "No current settings file!"); + return false; + } + str = new FileInputStream(mSettingsFilename); + } + XmlPullParser parser = Xml.newPullParser(); + parser.setInput(str, null); + + int type; + while ((type=parser.next()) != XmlPullParser.START_TAG + && type != XmlPullParser.END_DOCUMENT) { + ; + } + + if (type != XmlPullParser.START_TAG) { + mReadMessages.append("No start tag found in settings file\n"); + Log.e(TAG, "No start tag found in package manager settings"); + return false; + } + + int outerDepth = parser.getDepth(); + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("package")) { + readPackageLP(parser); + } else if (tagName.equals("permissions")) { + readPermissionsLP(mPermissions, parser); + } else if (tagName.equals("permission-trees")) { + readPermissionsLP(mPermissionTrees, parser); + } else if (tagName.equals("shared-user")) { + readSharedUserLP(parser); + } else if (tagName.equals("preferred-packages")) { + readPreferredPackagesLP(parser); + } else if (tagName.equals("preferred-activities")) { + readPreferredActivitiesLP(parser); + } else if(tagName.equals("updated-package")) { + readDisabledSysPackageLP(parser); + } else { + Log.w(TAG, "Unknown element under <packages>: " + + parser.getName()); + XmlUtils.skipCurrentTag(parser); + } + } + + str.close(); + + } catch(XmlPullParserException e) { + mReadMessages.append("Error reading: " + e.toString()); + Log.e(TAG, "Error reading package manager settings", e); + + } catch(java.io.IOException e) { + mReadMessages.append("Error reading: " + e.toString()); + Log.e(TAG, "Error reading package manager settings", e); + + } + + int N = mPendingPackages.size(); + for (int i=0; i<N; i++) { + final PendingPackage pp = mPendingPackages.get(i); + Object idObj = getUserIdLP(pp.sharedId); + if (idObj != null && idObj instanceof SharedUserSetting) { + PackageSetting p = getPackageLP(pp.name, + (SharedUserSetting)idObj, pp.codePath, pp.resourcePath, + pp.pkgFlags, true, true); + if (p == null) { + Log.w(TAG, "Unable to create application package for " + + pp.name); + continue; + } + p.copyFrom(pp); + } else if (idObj != null) { + String msg = "Bad package setting: package " + pp.name + + " has shared uid " + pp.sharedId + + " that is not a shared uid\n"; + mReadMessages.append(msg); + Log.e(TAG, msg); + } else { + String msg = "Bad package setting: package " + pp.name + + " has shared uid " + pp.sharedId + + " that is not defined\n"; + mReadMessages.append(msg); + Log.e(TAG, msg); + } + } + mPendingPackages.clear(); + + N = mPendingPreferredPackages.size(); + mPreferredPackages.clear(); + for (int i=0; i<N; i++) { + final String name = mPendingPreferredPackages.get(i); + final PackageSetting p = mPackages.get(name); + if (p != null) { + mPreferredPackages.add(p); + } else { + Log.w(TAG, "Unknown preferred package: " + name); + } + } + mPendingPreferredPackages.clear(); + + mReadMessages.append("Read completed successfully: " + + mPackages.size() + " packages, " + + mSharedUsers.size() + " shared uids\n"); + + return true; + } + + private int readInt(XmlPullParser parser, String ns, String name, + int defValue) { + String v = parser.getAttributeValue(ns, name); + try { + if (v == null) { + return defValue; + } + return Integer.parseInt(v); + } catch (NumberFormatException e) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: attribute " + + name + " has bad integer value " + v + " at " + + parser.getPositionDescription()); + } + return defValue; + } + + private void readPermissionsLP(HashMap<String, BasePermission> out, + XmlPullParser parser) + throws IOException, XmlPullParserException { + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("item")) { + String name = parser.getAttributeValue(null, "name"); + String sourcePackage = parser.getAttributeValue(null, "package"); + String ptype = parser.getAttributeValue(null, "type"); + if (name != null && sourcePackage != null) { + boolean dynamic = "dynamic".equals(ptype); + BasePermission bp = new BasePermission(name, sourcePackage, + dynamic + ? BasePermission.TYPE_DYNAMIC + : BasePermission.TYPE_NORMAL); + if (dynamic) { + PermissionInfo pi = new PermissionInfo(); + pi.packageName = sourcePackage.intern(); + pi.name = name.intern(); + pi.icon = readInt(parser, null, "icon", 0); + pi.nonLocalizedLabel = parser.getAttributeValue( + null, "label"); + pi.protectionLevel = readInt(parser, null, "protection", + PermissionInfo.PROTECTION_NORMAL); + bp.pendingInfo = pi; + } + out.put(bp.name, bp); + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: permissions has" + + " no name at " + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Unknown element reading permissions: " + + parser.getName() + " at " + + parser.getPositionDescription()); + } + XmlUtils.skipCurrentTag(parser); + } + } + + private void readDisabledSysPackageLP(XmlPullParser parser) + throws XmlPullParserException, IOException { + String name = parser.getAttributeValue(null, "name"); + String codePathStr = parser.getAttributeValue(null, "codePath"); + String resourcePathStr = parser.getAttributeValue(null, "resourcePath"); + if(resourcePathStr == null) { + resourcePathStr = codePathStr; + } + + int pkgFlags = 0; + pkgFlags |= ApplicationInfo.FLAG_SYSTEM; + PackageSetting ps = new PackageSetting(name, + new File(codePathStr), + new File(resourcePathStr), pkgFlags); + String timeStampStr = parser.getAttributeValue(null, "ts"); + if (timeStampStr != null) { + try { + long timeStamp = Long.parseLong(timeStampStr); + ps.setTimeStamp(timeStamp, timeStampStr); + } catch (NumberFormatException e) { + } + } + String idStr = parser.getAttributeValue(null, "userId"); + ps.userId = idStr != null ? Integer.parseInt(idStr) : 0; + if(ps.userId <= 0) { + String sharedIdStr = parser.getAttributeValue(null, "sharedUserId"); + ps.userId = sharedIdStr != null ? Integer.parseInt(sharedIdStr) : 0; + } + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("perms")) { + readGrantedPermissionsLP(parser, + ps.grantedPermissions); + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <updated-package>: " + + parser.getName()); + XmlUtils.skipCurrentTag(parser); + } + } + mDisabledSysPackages.put(name, ps); + } + + private void readPackageLP(XmlPullParser parser) + throws XmlPullParserException, IOException { + String name = null; + String idStr = null; + String sharedIdStr = null; + String codePathStr = null; + String resourcePathStr = null; + String systemStr = null; + int pkgFlags = 0; + String timeStampStr; + long timeStamp = 0; + PackageSettingBase packageSetting = null; + try { + name = parser.getAttributeValue(null, "name"); + idStr = parser.getAttributeValue(null, "userId"); + sharedIdStr = parser.getAttributeValue(null, "sharedUserId"); + codePathStr = parser.getAttributeValue(null, "codePath"); + resourcePathStr = parser.getAttributeValue(null, "resourcePath"); + systemStr = parser.getAttributeValue(null, "system"); + if (systemStr != null) { + if ("true".equals(systemStr)) { + pkgFlags |= ApplicationInfo.FLAG_SYSTEM; + } + } else { + // Old settings that don't specify system... just treat + // them as system, good enough. + pkgFlags |= ApplicationInfo.FLAG_SYSTEM; + } + timeStampStr = parser.getAttributeValue(null, "ts"); + if (timeStampStr != null) { + try { + timeStamp = Long.parseLong(timeStampStr); + } catch (NumberFormatException e) { + } + } + if (DEBUG_SETTINGS) Log.v(TAG, "Reading package: " + name + + " userId=" + idStr + " sharedUserId=" + sharedIdStr); + int userId = idStr != null ? Integer.parseInt(idStr) : 0; + if (resourcePathStr == null) { + resourcePathStr = codePathStr; + } + if (name == null) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <package> has no name at " + + parser.getPositionDescription()); + } else if (codePathStr == null) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <package> has no codePath at " + + parser.getPositionDescription()); + } else if (userId > 0) { + packageSetting = addPackageLP(name.intern(), new File(codePathStr), + new File(resourcePathStr), userId, pkgFlags); + if (DEBUG_SETTINGS) Log.i(TAG, "Reading package " + name + + ": userId=" + userId + " pkg=" + packageSetting); + if (packageSetting == null) { + reportSettingsProblem(Log.ERROR, + "Failure adding uid " + userId + + " while parsing settings at " + + parser.getPositionDescription()); + } else { + packageSetting.setTimeStamp(timeStamp, timeStampStr); + } + } else if (sharedIdStr != null) { + userId = sharedIdStr != null + ? Integer.parseInt(sharedIdStr) : 0; + if (userId > 0) { + packageSetting = new PendingPackage(name.intern(), new File(codePathStr), + new File(resourcePathStr), userId, pkgFlags); + packageSetting.setTimeStamp(timeStamp, timeStampStr); + mPendingPackages.add((PendingPackage) packageSetting); + if (DEBUG_SETTINGS) Log.i(TAG, "Reading package " + name + + ": sharedUserId=" + userId + " pkg=" + + packageSetting); + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: package " + + name + " has bad sharedId " + sharedIdStr + + " at " + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: package " + + name + " has bad userId " + idStr + " at " + + parser.getPositionDescription()); + } + } catch (NumberFormatException e) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: package " + + name + " has bad userId " + idStr + " at " + + parser.getPositionDescription()); + } + if (packageSetting != null) { + final String enabledStr = parser.getAttributeValue(null, "enabled"); + if (enabledStr != null) { + if (enabledStr.equalsIgnoreCase("true")) { + packageSetting.enabled = COMPONENT_ENABLED_STATE_ENABLED; + } else if (enabledStr.equalsIgnoreCase("false")) { + packageSetting.enabled = COMPONENT_ENABLED_STATE_DISABLED; + } else if (enabledStr.equalsIgnoreCase("default")) { + packageSetting.enabled = COMPONENT_ENABLED_STATE_DEFAULT; + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: package " + + name + " has bad enabled value: " + idStr + + " at " + parser.getPositionDescription()); + } + } else { + packageSetting.enabled = COMPONENT_ENABLED_STATE_DEFAULT; + } + final String installStatusStr = parser.getAttributeValue(null, "installStatus"); + if (installStatusStr != null) { + if (installStatusStr.equalsIgnoreCase("false")) { + packageSetting.installStatus = PKG_INSTALL_INCOMPLETE; + } else { + packageSetting.installStatus = PKG_INSTALL_COMPLETE; + } + } + + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("disabled-components")) { + readDisabledComponentsLP(packageSetting, parser); + } else if (tagName.equals("enabled-components")) { + readEnabledComponentsLP(packageSetting, parser); + } else if (tagName.equals("sigs")) { + packageSetting.signatures.readXml(parser, mPastSignatures); + } else if (tagName.equals("perms")) { + readGrantedPermissionsLP(parser, + packageSetting.loadedPermissions); + packageSetting.permissionsFixed = true; + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <package>: " + + parser.getName()); + XmlUtils.skipCurrentTag(parser); + } + } + } else { + XmlUtils.skipCurrentTag(parser); + } + } + + private void readDisabledComponentsLP(PackageSettingBase packageSetting, + XmlPullParser parser) + throws IOException, XmlPullParserException { + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("item")) { + String name = parser.getAttributeValue(null, "name"); + if (name != null) { + packageSetting.disabledComponents.add(name.intern()); + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <disabled-components> has" + + " no name at " + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <disabled-components>: " + + parser.getName()); + } + XmlUtils.skipCurrentTag(parser); + } + } + + private void readEnabledComponentsLP(PackageSettingBase packageSetting, + XmlPullParser parser) + throws IOException, XmlPullParserException { + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("item")) { + String name = parser.getAttributeValue(null, "name"); + if (name != null) { + packageSetting.enabledComponents.add(name.intern()); + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <enabled-components> has" + + " no name at " + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <enabled-components>: " + + parser.getName()); + } + XmlUtils.skipCurrentTag(parser); + } + } + + private void readSharedUserLP(XmlPullParser parser) + throws XmlPullParserException, IOException { + String name = null; + String idStr = null; + int pkgFlags = 0; + SharedUserSetting su = null; + try { + name = parser.getAttributeValue(null, "name"); + idStr = parser.getAttributeValue(null, "userId"); + int userId = idStr != null ? Integer.parseInt(idStr) : 0; + if ("true".equals(parser.getAttributeValue(null, "system"))) { + pkgFlags |= ApplicationInfo.FLAG_SYSTEM; + } + if (name == null) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <shared-user> has no name at " + + parser.getPositionDescription()); + } else if (userId == 0) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: shared-user " + + name + " has bad userId " + idStr + " at " + + parser.getPositionDescription()); + } else { + if ((su=addSharedUserLP(name.intern(), userId, pkgFlags)) == null) { + reportSettingsProblem(Log.ERROR, + "Occurred while parsing settings at " + + parser.getPositionDescription()); + } + } + } catch (NumberFormatException e) { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: package " + + name + " has bad userId " + idStr + " at " + + parser.getPositionDescription()); + }; + + if (su != null) { + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("sigs")) { + su.signatures.readXml(parser, mPastSignatures); + } else if (tagName.equals("perms")) { + readGrantedPermissionsLP(parser, su.loadedPermissions); + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <shared-user>: " + + parser.getName()); + XmlUtils.skipCurrentTag(parser); + } + } + + } else { + XmlUtils.skipCurrentTag(parser); + } + } + + private void readGrantedPermissionsLP(XmlPullParser parser, + HashSet<String> outPerms) throws IOException, XmlPullParserException { + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("item")) { + String name = parser.getAttributeValue(null, "name"); + if (name != null) { + outPerms.add(name.intern()); + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <perms> has" + + " no name at " + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <perms>: " + + parser.getName()); + } + XmlUtils.skipCurrentTag(parser); + } + } + + private void readPreferredPackagesLP(XmlPullParser parser) + throws XmlPullParserException, IOException { + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("item")) { + String name = parser.getAttributeValue(null, "name"); + if (name != null) { + mPendingPreferredPackages.add(name); + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <preferred-package> has no name at " + + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <preferred-packages>: " + + parser.getName()); + } + XmlUtils.skipCurrentTag(parser); + } + } + + private void readPreferredActivitiesLP(XmlPullParser parser) + throws XmlPullParserException, IOException { + int outerDepth = parser.getDepth(); + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && (type != XmlPullParser.END_TAG + || parser.getDepth() > outerDepth)) { + if (type == XmlPullParser.END_TAG + || type == XmlPullParser.TEXT) { + continue; + } + + String tagName = parser.getName(); + if (tagName.equals("item")) { + PreferredActivity pa = new PreferredActivity(parser); + if (pa.mParseError == null) { + mPreferredActivities.addFilter(pa); + } else { + reportSettingsProblem(Log.WARN, + "Error in package manager settings: <preferred-activity> " + + pa.mParseError + " at " + + parser.getPositionDescription()); + } + } else { + reportSettingsProblem(Log.WARN, + "Unknown element under <preferred-activities>: " + + parser.getName()); + XmlUtils.skipCurrentTag(parser); + } + } + } + + // Returns -1 if we could not find an available UserId to assign + private int newUserIdLP(Object obj) { + // Let's be stupidly inefficient for now... + final int N = mUserIds.size(); + for (int i=0; i<N; i++) { + if (mUserIds.get(i) == null) { + mUserIds.set(i, obj); + return FIRST_APPLICATION_UID + i; + } + } + + // None left? + if (N >= MAX_APPLICATION_UIDS) { + return -1; + } + + mUserIds.add(obj); + return FIRST_APPLICATION_UID + N; + } + + public PackageSetting getDisabledSystemPkg(String name) { + synchronized(mPackages) { + PackageSetting ps = mDisabledSysPackages.get(name); + return ps; + } + } + + boolean isEnabledLP(ComponentInfo componentInfo, int flags) { + final PackageSetting packageSettings = mPackages.get(componentInfo.packageName); + if (Config.LOGV) { + Log.v(TAG, "isEnabledLock - packageName = " + componentInfo.packageName + + " componentName = " + componentInfo.name); + Log.v(TAG, "enabledComponents: " + + Arrays.toString(packageSettings.enabledComponents.toArray())); + Log.v(TAG, "disabledComponents: " + + Arrays.toString(packageSettings.disabledComponents.toArray())); + } + return ((flags&PackageManager.GET_DISABLED_COMPONENTS) != 0) + || ((componentInfo.enabled + && ((packageSettings.enabled == COMPONENT_ENABLED_STATE_ENABLED) + || (componentInfo.applicationInfo.enabled + && packageSettings.enabled != COMPONENT_ENABLED_STATE_DISABLED)) + && !packageSettings.disabledComponents.contains(componentInfo.name)) + || packageSettings.enabledComponents.contains(componentInfo.name)); + } + } +} diff --git a/services/java/com/android/server/PowerManagerService.java b/services/java/com/android/server/PowerManagerService.java new file mode 100644 index 0000000..ad30ffc --- /dev/null +++ b/services/java/com/android/server/PowerManagerService.java @@ -0,0 +1,1862 @@ +/* + * Copyright (C) 2007 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 com.android.internal.app.IBatteryStats; +import com.android.server.am.BatteryStatsService; + +import android.app.ActivityManagerNative; +import android.app.IActivityManager; +import android.content.BroadcastReceiver; +import android.content.ContentQueryMap; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.database.Cursor; +import android.os.BatteryStats; +import android.os.Binder; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.IBinder; +import android.os.IPowerManager; +import android.os.LocalPowerManager; +import android.os.Power; +import android.os.PowerManager; +import android.os.Process; +import android.os.RemoteException; +import android.os.SystemClock; +import android.provider.Settings.SettingNotFoundException; +import android.provider.Settings; +import android.util.EventLog; +import android.util.Log; +import android.view.WindowManagerPolicy; +import static android.provider.Settings.System.DIM_SCREEN; +import static android.provider.Settings.System.SCREEN_BRIGHTNESS; +import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT; +import static android.provider.Settings.System.STAY_ON_WHILE_PLUGGED_IN; + +import java.io.FileDescriptor; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Observable; +import java.util.Observer; + +class PowerManagerService extends IPowerManager.Stub implements LocalPowerManager, Watchdog.Monitor { + + private static final String TAG = "PowerManagerService"; + static final String PARTIAL_NAME = "PowerManagerService"; + + private static final boolean LOG_PARTIAL_WL = false; + + // Indicates whether touch-down cycles should be logged as part of the + // LOG_POWER_SCREEN_STATE log events + private static final boolean LOG_TOUCH_DOWNS = true; + + private static final int LOCK_MASK = PowerManager.PARTIAL_WAKE_LOCK + | PowerManager.SCREEN_DIM_WAKE_LOCK + | PowerManager.SCREEN_BRIGHT_WAKE_LOCK + | PowerManager.FULL_WAKE_LOCK; + + // time since last state: time since last event: + // The short keylight delay comes from Gservices; this is the default. + private static final int SHORT_KEYLIGHT_DELAY_DEFAULT = 6000; // t+6 sec + private static final int MEDIUM_KEYLIGHT_DELAY = 15000; // t+15 sec + private static final int LONG_KEYLIGHT_DELAY = 6000; // t+6 sec + private static final int LONG_DIM_TIME = 7000; // t+N-5 sec + + // Cached Gservices settings; see updateGservicesValues() + private int mShortKeylightDelay = SHORT_KEYLIGHT_DELAY_DEFAULT; + + // flags for setPowerState + private static final int SCREEN_ON_BIT = 0x00000001; + private static final int SCREEN_BRIGHT_BIT = 0x00000002; + private static final int BUTTON_BRIGHT_BIT = 0x00000004; + private static final int KEYBOARD_BRIGHT_BIT = 0x00000008; + private static final int BATTERY_LOW_BIT = 0x00000010; + + // values for setPowerState + + // SCREEN_OFF == everything off + private static final int SCREEN_OFF = 0x00000000; + + // SCREEN_DIM == screen on, screen backlight dim + private static final int SCREEN_DIM = SCREEN_ON_BIT; + + // SCREEN_BRIGHT == screen on, screen backlight bright + private static final int SCREEN_BRIGHT = SCREEN_ON_BIT | SCREEN_BRIGHT_BIT; + + // SCREEN_BUTTON_BRIGHT == screen on, screen and button backlights bright + private static final int SCREEN_BUTTON_BRIGHT = SCREEN_BRIGHT | BUTTON_BRIGHT_BIT; + + // SCREEN_BUTTON_BRIGHT == screen on, screen, button and keyboard backlights bright + private static final int ALL_BRIGHT = SCREEN_BUTTON_BRIGHT | KEYBOARD_BRIGHT_BIT; + + // used for noChangeLights in setPowerState() + private static final int LIGHTS_MASK = SCREEN_BRIGHT_BIT | BUTTON_BRIGHT_BIT | KEYBOARD_BRIGHT_BIT; + + static final boolean ANIMATE_SCREEN_LIGHTS = true; + static final boolean ANIMATE_BUTTON_LIGHTS = false; + static final boolean ANIMATE_KEYBOARD_LIGHTS = false; + + static final int ANIM_STEPS = 60/4; + + // These magic numbers are the initial state of the LEDs at boot. Ideally + // we should read them from the driver, but our current hardware returns 0 + // for the initial value. Oops! + static final int INITIAL_SCREEN_BRIGHTNESS = 255; + static final int INITIAL_BUTTON_BRIGHTNESS = Power.BRIGHTNESS_OFF; + static final int INITIAL_KEYBOARD_BRIGHTNESS = Power.BRIGHTNESS_OFF; + + static final int LOG_POWER_SLEEP_REQUESTED = 2724; + static final int LOG_POWER_SCREEN_BROADCAST_SEND = 2725; + static final int LOG_POWER_SCREEN_BROADCAST_DONE = 2726; + static final int LOG_POWER_SCREEN_BROADCAST_STOP = 2727; + static final int LOG_POWER_SCREEN_STATE = 2728; + static final int LOG_POWER_PARTIAL_WAKE_STATE = 2729; + + private final int MY_UID; + + private boolean mDoneBooting = false; + private int mStayOnConditions = 0; + private int mNotificationQueue = -1; + private int mNotificationWhy; + private int mPartialCount = 0; + private int mPowerState; + private boolean mOffBecauseOfUser; + private int mUserState; + private boolean mKeyboardVisible = false; + private boolean mUserActivityAllowed = true; + private int mTotalDelaySetting; + private int mKeylightDelay; + private int mDimDelay; + private int mScreenOffDelay; + private int mWakeLockState; + private long mLastEventTime = 0; + private long mScreenOffTime; + private volatile WindowManagerPolicy mPolicy; + private final LockList mLocks = new LockList(); + private Intent mScreenOffIntent; + private Intent mScreenOnIntent; + private Context mContext; + private UnsynchronizedWakeLock mBroadcastWakeLock; + private UnsynchronizedWakeLock mStayOnWhilePluggedInScreenDimLock; + private UnsynchronizedWakeLock mStayOnWhilePluggedInPartialLock; + private UnsynchronizedWakeLock mPreventScreenOnPartialLock; + private HandlerThread mHandlerThread; + private Handler mHandler; + private TimeoutTask mTimeoutTask = new TimeoutTask(); + private LightAnimator mLightAnimator = new LightAnimator(); + private final BrightnessState mScreenBrightness + = new BrightnessState(Power.SCREEN_LIGHT); + private final BrightnessState mKeyboardBrightness + = new BrightnessState(Power.KEYBOARD_LIGHT); + private final BrightnessState mButtonBrightness + = new BrightnessState(Power.BUTTON_LIGHT); + private boolean mIsPowered = false; + private IActivityManager mActivityService; + private IBatteryStats mBatteryStats; + private BatteryService mBatteryService; + private boolean mDimScreen = true; + private long mNextTimeout; + private volatile int mPokey = 0; + private volatile boolean mPokeAwakeOnSet = false; + private volatile boolean mInitComplete = false; + private HashMap<IBinder,PokeLock> mPokeLocks = new HashMap<IBinder,PokeLock>(); + private long mScreenOnTime; + private long mScreenOnStartTime; + private boolean mPreventScreenOn; + private int mScreenBrightnessOverride = -1; + + // Used when logging number and duration of touch-down cycles + private long mTotalTouchDownTime; + private long mLastTouchDown; + private int mTouchCycles; + + // could be either static or controllable at runtime + private static final boolean mSpew = false; + + /* + static PrintStream mLog; + static { + try { + mLog = new PrintStream("/data/power.log"); + } + catch (FileNotFoundException e) { + android.util.Log.e(TAG, "Life is hard", e); + } + } + static class Log { + static void d(String tag, String s) { + mLog.println(s); + android.util.Log.d(tag, s); + } + static void i(String tag, String s) { + mLog.println(s); + android.util.Log.i(tag, s); + } + static void w(String tag, String s) { + mLog.println(s); + android.util.Log.w(tag, s); + } + static void e(String tag, String s) { + mLog.println(s); + android.util.Log.e(tag, s); + } + } + */ + + /** + * This class works around a deadlock between the lock in PowerManager.WakeLock + * and our synchronizing on mLocks. PowerManager.WakeLock synchronizes on its + * mToken object so it can be accessed from any thread, but it calls into here + * with its lock held. This class is essentially a reimplementation of + * PowerManager.WakeLock, but without that extra synchronized block, because we'll + * only call it with our own locks held. + */ + private class UnsynchronizedWakeLock { + int mFlags; + String mTag; + IBinder mToken; + int mCount = 0; + boolean mRefCounted; + + UnsynchronizedWakeLock(int flags, String tag, boolean refCounted) { + mFlags = flags; + mTag = tag; + mToken = new Binder(); + mRefCounted = refCounted; + } + + public void acquire() { + if (!mRefCounted || mCount++ == 0) { + long ident = Binder.clearCallingIdentity(); + try { + PowerManagerService.this.acquireWakeLockLocked(mFlags, mToken, + MY_UID, mTag); + } finally { + Binder.restoreCallingIdentity(ident); + } + } + } + + public void release() { + if (!mRefCounted || --mCount == 0) { + PowerManagerService.this.releaseWakeLockLocked(mToken, false); + } + if (mCount < 0) { + throw new RuntimeException("WakeLock under-locked " + mTag); + } + } + + public String toString() { + return "UnsynchronizedWakeLock(mFlags=0x" + Integer.toHexString(mFlags) + + " mCount=" + mCount + ")"; + } + } + + private final class BatteryReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + synchronized (mLocks) { + boolean wasPowered = mIsPowered; + mIsPowered = mBatteryService.isPowered(); + + if (mIsPowered != wasPowered) { + // update mStayOnWhilePluggedIn wake lock + updateWakeLockLocked(); + + // treat plugging and unplugging the devices as a user activity. + // users find it disconcerting when they unplug the device + // and it shuts off right away. + // temporarily set mUserActivityAllowed to true so this will work + // even when the keyguard is on. + synchronized (mLocks) { + boolean savedActivityAllowed = mUserActivityAllowed; + mUserActivityAllowed = true; + userActivity(SystemClock.uptimeMillis(), false); + mUserActivityAllowed = savedActivityAllowed; + } + } + } + } + } + + /** + * Set the setting that determines whether the device stays on when plugged in. + * The argument is a bit string, with each bit specifying a power source that, + * when the device is connected to that source, causes the device to stay on. + * See {@link android.os.BatteryManager} for the list of power sources that + * can be specified. Current values include {@link android.os.BatteryManager#BATTERY_PLUGGED_AC} + * and {@link android.os.BatteryManager#BATTERY_PLUGGED_USB} + * @param val an {@code int} containing the bits that specify which power sources + * should cause the device to stay on. + */ + public void setStayOnSetting(int val) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WRITE_SETTINGS, null); + Settings.System.putInt(mContext.getContentResolver(), + Settings.System.STAY_ON_WHILE_PLUGGED_IN, val); + } + + private class SettingsObserver implements Observer { + private int getInt(String name) { + return mSettings.getValues(name).getAsInteger(Settings.System.VALUE); + } + + public void update(Observable o, Object arg) { + synchronized (mLocks) { + // STAY_ON_WHILE_PLUGGED_IN + mStayOnConditions = getInt(STAY_ON_WHILE_PLUGGED_IN); + updateWakeLockLocked(); + + // SCREEN_OFF_TIMEOUT + mTotalDelaySetting = getInt(SCREEN_OFF_TIMEOUT); + + // DIM_SCREEN + //mDimScreen = getInt(DIM_SCREEN) != 0; + + // recalculate everything + setScreenOffTimeoutsLocked(); + } + } + } + + PowerManagerService() + { + // Hack to get our uid... should have a func for this. + long token = Binder.clearCallingIdentity(); + MY_UID = Binder.getCallingUid(); + Binder.restoreCallingIdentity(token); + + // XXX remove this when the kernel doesn't timeout wake locks + Power.setLastUserActivityTimeout(7*24*3600*1000); // one week + + // assume nothing is on yet + mUserState = mPowerState = 0; + + // Add ourself to the Watchdog monitors. + Watchdog.getInstance().addMonitor(this); + mScreenOnStartTime = SystemClock.elapsedRealtime(); + } + + private ContentQueryMap mSettings; + + void init(Context context, IActivityManager activity, BatteryService battery) { + mContext = context; + mActivityService = activity; + mBatteryStats = BatteryStatsService.getService(); + mBatteryService = battery; + + mHandlerThread = new HandlerThread("PowerManagerService") { + @Override + protected void onLooperPrepared() { + super.onLooperPrepared(); + initInThread(); + } + }; + mHandlerThread.start(); + + synchronized (mHandlerThread) { + while (!mInitComplete) { + try { + mHandlerThread.wait(); + } catch (InterruptedException e) { + // Ignore + } + } + } + } + + void initInThread() { + mHandler = new Handler(); + + mBroadcastWakeLock = new UnsynchronizedWakeLock( + PowerManager.PARTIAL_WAKE_LOCK, "sleep_notification", true); + mStayOnWhilePluggedInScreenDimLock = new UnsynchronizedWakeLock( + PowerManager.SCREEN_DIM_WAKE_LOCK, "StayOnWhilePluggedIn Screen Dim", false); + mStayOnWhilePluggedInPartialLock = new UnsynchronizedWakeLock( + PowerManager.PARTIAL_WAKE_LOCK, "StayOnWhilePluggedIn Partial", false); + mPreventScreenOnPartialLock = new UnsynchronizedWakeLock( + PowerManager.PARTIAL_WAKE_LOCK, "PreventScreenOn Partial", false); + + mScreenOnIntent = new Intent(Intent.ACTION_SCREEN_ON); + mScreenOnIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); + mScreenOffIntent = new Intent(Intent.ACTION_SCREEN_OFF); + mScreenOffIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); + + ContentResolver resolver = mContext.getContentResolver(); + Cursor settingsCursor = resolver.query(Settings.System.CONTENT_URI, null, + "(" + Settings.System.NAME + "=?) or (" + + Settings.System.NAME + "=?) or (" + + Settings.System.NAME + "=?)", + new String[]{STAY_ON_WHILE_PLUGGED_IN, SCREEN_OFF_TIMEOUT, DIM_SCREEN}, + null); + mSettings = new ContentQueryMap(settingsCursor, Settings.System.NAME, true, mHandler); + SettingsObserver settingsObserver = new SettingsObserver(); + mSettings.addObserver(settingsObserver); + + // pretend that the settings changed so we will get their initial state + settingsObserver.update(mSettings, null); + + // register for the battery changed notifications + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_BATTERY_CHANGED); + mContext.registerReceiver(new BatteryReceiver(), filter); + + // Listen for Gservices changes + IntentFilter gservicesChangedFilter = + new IntentFilter(Settings.Gservices.CHANGED_ACTION); + mContext.registerReceiver(new GservicesChangedReceiver(), gservicesChangedFilter); + // And explicitly do the initial update of our cached settings + updateGservicesValues(); + + // turn everything on + setPowerState(ALL_BRIGHT); + + synchronized (mHandlerThread) { + mInitComplete = true; + mHandlerThread.notifyAll(); + } + } + + private class WakeLock implements IBinder.DeathRecipient + { + WakeLock(int f, IBinder b, String t, int u) { + super(); + flags = f; + binder = b; + tag = t; + uid = u == MY_UID ? Process.SYSTEM_UID : u; + if (u != MY_UID || ( + !"KEEP_SCREEN_ON_FLAG".equals(tag) + && !"KeyInputQueue".equals(tag))) { + monitorType = (f & LOCK_MASK) == PowerManager.PARTIAL_WAKE_LOCK + ? BatteryStats.WAKE_TYPE_PARTIAL + : BatteryStats.WAKE_TYPE_FULL; + } else { + monitorType = -1; + } + try { + b.linkToDeath(this, 0); + } catch (RemoteException e) { + binderDied(); + } + } + public void binderDied() { + synchronized (mLocks) { + releaseWakeLockLocked(this.binder, true); + } + } + final int flags; + final IBinder binder; + final String tag; + final int uid; + final int monitorType; + boolean activated = true; + int minState; + } + + private void updateWakeLockLocked() { + if (mStayOnConditions != 0 && mBatteryService.isPowered(mStayOnConditions)) { + // keep the device on if we're plugged in and mStayOnWhilePluggedIn is set. + mStayOnWhilePluggedInScreenDimLock.acquire(); + mStayOnWhilePluggedInPartialLock.acquire(); + } else { + mStayOnWhilePluggedInScreenDimLock.release(); + mStayOnWhilePluggedInPartialLock.release(); + } + } + + private boolean isScreenLock(int flags) + { + int n = flags & LOCK_MASK; + return n == PowerManager.FULL_WAKE_LOCK + || n == PowerManager.SCREEN_BRIGHT_WAKE_LOCK + || n == PowerManager.SCREEN_DIM_WAKE_LOCK; + } + + public void acquireWakeLock(int flags, IBinder lock, String tag) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); + int uid = Binder.getCallingUid(); + long ident = Binder.clearCallingIdentity(); + try { + synchronized (mLocks) { + acquireWakeLockLocked(flags, lock, uid, tag); + } + } finally { + Binder.restoreCallingIdentity(ident); + } + } + + public void acquireWakeLockLocked(int flags, IBinder lock, int uid, String tag) { + int acquireUid = -1; + String acquireName = null; + int acquireType = -1; + + if (mSpew) { + Log.d(TAG, "acquireWakeLock flags=0x" + Integer.toHexString(flags) + " tag=" + tag); + } + + int index = mLocks.getIndex(lock); + WakeLock wl; + boolean newlock; + if (index < 0) { + wl = new WakeLock(flags, lock, tag, uid); + switch (wl.flags & LOCK_MASK) + { + case PowerManager.FULL_WAKE_LOCK: + wl.minState = (mKeyboardVisible ? ALL_BRIGHT : SCREEN_BUTTON_BRIGHT); + break; + case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: + wl.minState = SCREEN_BRIGHT; + break; + case PowerManager.SCREEN_DIM_WAKE_LOCK: + wl.minState = SCREEN_DIM; + break; + case PowerManager.PARTIAL_WAKE_LOCK: + break; + default: + // just log and bail. we're in the server, so don't + // throw an exception. + Log.e(TAG, "bad wakelock type for lock '" + tag + "' " + + " flags=" + flags); + return; + } + mLocks.addLock(wl); + newlock = true; + } else { + wl = mLocks.get(index); + newlock = false; + } + if (isScreenLock(flags)) { + // if this causes a wakeup, we reactivate all of the locks and + // set it to whatever they want. otherwise, we modulate that + // by the current state so we never turn it more on than + // it already is. + if ((wl.flags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0) { + reactivateWakeLocksLocked(); + if (mSpew) { + Log.d(TAG, "wakeup here mUserState=0x" + Integer.toHexString(mUserState) + + " mLocks.gatherState()=0x" + + Integer.toHexString(mLocks.gatherState()) + + " mWakeLockState=0x" + Integer.toHexString(mWakeLockState)); + } + mWakeLockState = mLocks.gatherState(); + } else { + if (mSpew) { + Log.d(TAG, "here mUserState=0x" + Integer.toHexString(mUserState) + + " mLocks.gatherState()=0x" + + Integer.toHexString(mLocks.gatherState()) + + " mWakeLockState=0x" + Integer.toHexString(mWakeLockState)); + } + mWakeLockState = (mUserState | mWakeLockState) & mLocks.gatherState(); + } + setPowerState(mWakeLockState | mUserState); + } + else if ((flags & LOCK_MASK) == PowerManager.PARTIAL_WAKE_LOCK) { + if (newlock) { + mPartialCount++; + if (mPartialCount == 1) { + if (LOG_PARTIAL_WL) EventLog.writeEvent(LOG_POWER_PARTIAL_WAKE_STATE, 1, tag); + } + } + Power.acquireWakeLock(Power.PARTIAL_WAKE_LOCK,PARTIAL_NAME); + } + if (newlock) { + acquireUid = wl.uid; + acquireName = wl.tag; + acquireType = wl.monitorType; + } + + if (acquireType >= 0) { + try { + mBatteryStats.noteStartWakelock(acquireUid, acquireName, acquireType); + } catch (RemoteException e) { + // Ignore + } + } + } + + public void releaseWakeLock(IBinder lock) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); + + synchronized (mLocks) { + releaseWakeLockLocked(lock, false); + } + } + + private void releaseWakeLockLocked(IBinder lock, boolean death) { + int releaseUid; + String releaseName; + int releaseType; + + WakeLock wl = mLocks.removeLock(lock); + if (wl == null) { + return; + } + + if (mSpew) { + Log.d(TAG, "releaseWakeLock flags=0x" + + Integer.toHexString(wl.flags) + " tag=" + wl.tag); + } + + if (isScreenLock(wl.flags)) { + mWakeLockState = mLocks.gatherState(); + // goes in the middle to reduce flicker + if ((wl.flags & PowerManager.ON_AFTER_RELEASE) != 0) { + userActivity(SystemClock.uptimeMillis(), false); + } + setPowerState(mWakeLockState | mUserState); + } + else if ((wl.flags & LOCK_MASK) == PowerManager.PARTIAL_WAKE_LOCK) { + mPartialCount--; + if (mPartialCount == 0) { + if (LOG_PARTIAL_WL) EventLog.writeEvent(LOG_POWER_PARTIAL_WAKE_STATE, 0, wl.tag); + Power.releaseWakeLock(PARTIAL_NAME); + } + } + // Unlink the lock from the binder. + wl.binder.unlinkToDeath(wl, 0); + releaseUid = wl.uid; + releaseName = wl.tag; + releaseType = wl.monitorType; + + if (releaseType >= 0) { + long origId = Binder.clearCallingIdentity(); + try { + mBatteryStats.noteStopWakelock(releaseUid, releaseName, releaseType); + } catch (RemoteException e) { + // Ignore + } finally { + Binder.restoreCallingIdentity(origId); + } + } + } + + private void reactivateWakeLocksLocked() + { + int N = mLocks.size(); + for (int i=0; i<N; i++) { + WakeLock wl = mLocks.get(i); + if (isScreenLock(wl.flags)) { + mLocks.get(i).activated = true; + } + } + } + + private class PokeLock implements IBinder.DeathRecipient + { + PokeLock(int p, IBinder b, String t) { + super(); + this.pokey = p; + this.binder = b; + this.tag = t; + try { + b.linkToDeath(this, 0); + } catch (RemoteException e) { + binderDied(); + } + } + public void binderDied() { + setPokeLock(0, this.binder, this.tag); + } + int pokey; + IBinder binder; + String tag; + boolean awakeOnSet; + } + + public void setPokeLock(int pokey, IBinder token, String tag) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); + if (token == null) { + Log.e(TAG, "setPokeLock got null token for tag='" + tag + "'"); + return; + } + + if ((pokey & POKE_LOCK_TIMEOUT_MASK) == POKE_LOCK_TIMEOUT_MASK) { + throw new IllegalArgumentException("setPokeLock can't have both POKE_LOCK_SHORT_TIMEOUT" + + " and POKE_LOCK_MEDIUM_TIMEOUT"); + } + + synchronized (mLocks) { + if (pokey != 0) { + PokeLock p = mPokeLocks.get(token); + int oldPokey = 0; + if (p != null) { + oldPokey = p.pokey; + p.pokey = pokey; + } else { + p = new PokeLock(pokey, token, tag); + mPokeLocks.put(token, p); + } + int oldTimeout = oldPokey & POKE_LOCK_TIMEOUT_MASK; + int newTimeout = pokey & POKE_LOCK_TIMEOUT_MASK; + if (((mPowerState & SCREEN_ON_BIT) == 0) && (oldTimeout != newTimeout)) { + p.awakeOnSet = true; + } + } else { + mPokeLocks.remove(token); + } + + int oldPokey = mPokey; + int cumulative = 0; + boolean oldAwakeOnSet = mPokeAwakeOnSet; + boolean awakeOnSet = false; + for (PokeLock p: mPokeLocks.values()) { + cumulative |= p.pokey; + if (p.awakeOnSet) { + awakeOnSet = true; + } + } + mPokey = cumulative; + mPokeAwakeOnSet = awakeOnSet; + + int oldCumulativeTimeout = oldPokey & POKE_LOCK_TIMEOUT_MASK; + int newCumulativeTimeout = pokey & POKE_LOCK_TIMEOUT_MASK; + + if (oldCumulativeTimeout != newCumulativeTimeout) { + setScreenOffTimeoutsLocked(); + // reset the countdown timer, but use the existing nextState so it doesn't + // change anything + setTimeoutLocked(SystemClock.uptimeMillis(), mTimeoutTask.nextState); + } + } + } + + private static String lockType(int type) + { + switch (type) + { + case PowerManager.FULL_WAKE_LOCK: + return "FULL_WAKE_LOCK "; + case PowerManager.SCREEN_BRIGHT_WAKE_LOCK: + return "SCREEN_BRIGHT_WAKE_LOCK"; + case PowerManager.SCREEN_DIM_WAKE_LOCK: + return "SCREEN_DIM_WAKE_LOCK "; + case PowerManager.PARTIAL_WAKE_LOCK: + return "PARTIAL_WAKE_LOCK "; + default: + return "??? "; + } + } + + private static String dumpPowerState(int state) { + return (((state & KEYBOARD_BRIGHT_BIT) != 0) + ? "KEYBOARD_BRIGHT_BIT " : "") + + (((state & SCREEN_BRIGHT_BIT) != 0) + ? "SCREEN_BRIGHT_BIT " : "") + + (((state & SCREEN_ON_BIT) != 0) + ? "SCREEN_ON_BIT " : "") + + (((state & BATTERY_LOW_BIT) != 0) + ? "BATTERY_LOW_BIT " : ""); + } + + @Override + public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump PowerManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + long now = SystemClock.uptimeMillis(); + + pw.println("Power Manager State:"); + pw.println(" mIsPowered=" + mIsPowered + + " mPowerState=" + mPowerState + + " mScreenOffTime=" + (SystemClock.elapsedRealtime()-mScreenOffTime) + + " ms"); + pw.println(" mPartialCount=" + mPartialCount); + pw.println(" mWakeLockState=" + dumpPowerState(mWakeLockState)); + pw.println(" mUserState=" + dumpPowerState(mUserState)); + pw.println(" mPowerState=" + dumpPowerState(mPowerState)); + pw.println(" mLocks.gather=" + dumpPowerState(mLocks.gatherState())); + pw.println(" mNextTimeout=" + mNextTimeout + " now=" + now + + " " + ((mNextTimeout-now)/1000) + "s from now"); + pw.println(" mDimScreen=" + mDimScreen + + " mStayOnConditions=" + mStayOnConditions); + pw.println(" mOffBecauseOfUser=" + mOffBecauseOfUser + + " mUserState=" + mUserState); + pw.println(" mNotificationQueue=" + mNotificationQueue + + " mNotificationWhy=" + mNotificationWhy); + pw.println(" mPokey=" + mPokey + " mPokeAwakeonSet=" + mPokeAwakeOnSet); + pw.println(" mKeyboardVisible=" + mKeyboardVisible + + " mUserActivityAllowed=" + mUserActivityAllowed); + pw.println(" mKeylightDelay=" + mKeylightDelay + " mDimDelay=" + mDimDelay + + " mScreenOffDelay=" + mScreenOffDelay); + pw.println(" mPreventScreenOn=" + mPreventScreenOn + + " mScreenBrightnessOverride=" + mScreenBrightnessOverride); + pw.println(" mTotalDelaySetting=" + mTotalDelaySetting); + pw.println(" mBroadcastWakeLock=" + mBroadcastWakeLock); + pw.println(" mStayOnWhilePluggedInScreenDimLock=" + mStayOnWhilePluggedInScreenDimLock); + pw.println(" mStayOnWhilePluggedInPartialLock=" + mStayOnWhilePluggedInPartialLock); + pw.println(" mPreventScreenOnPartialLock=" + mPreventScreenOnPartialLock); + mScreenBrightness.dump(pw, " mScreenBrightness: "); + mKeyboardBrightness.dump(pw, " mKeyboardBrightness: "); + mButtonBrightness.dump(pw, " mButtonBrightness: "); + + int N = mLocks.size(); + pw.println(); + pw.println("mLocks.size=" + N + ":"); + for (int i=0; i<N; i++) { + WakeLock wl = mLocks.get(i); + String type = lockType(wl.flags & LOCK_MASK); + String acquireCausesWakeup = ""; + if ((wl.flags & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0) { + acquireCausesWakeup = "ACQUIRE_CAUSES_WAKEUP "; + } + String activated = ""; + if (wl.activated) { + activated = " activated"; + } + pw.println(" " + type + " '" + wl.tag + "'" + acquireCausesWakeup + + activated + " (minState=" + wl.minState + ")"); + } + + pw.println(); + pw.println("mPokeLocks.size=" + mPokeLocks.size() + ":"); + for (PokeLock p: mPokeLocks.values()) { + pw.println(" poke lock '" + p.tag + "':" + + ((p.pokey & POKE_LOCK_IGNORE_CHEEK_EVENTS) != 0 + ? " POKE_LOCK_IGNORE_CHEEK_EVENTS" : "") + + ((p.pokey & POKE_LOCK_SHORT_TIMEOUT) != 0 + ? " POKE_LOCK_SHORT_TIMEOUT" : "") + + ((p.pokey & POKE_LOCK_MEDIUM_TIMEOUT) != 0 + ? " POKE_LOCK_MEDIUM_TIMEOUT" : "")); + } + + pw.println(); + } + + private void setTimeoutLocked(long now, int nextState) + { + if (mDoneBooting) { + mHandler.removeCallbacks(mTimeoutTask); + mTimeoutTask.nextState = nextState; + long when = now; + switch (nextState) + { + case SCREEN_BRIGHT: + when += mKeylightDelay; + break; + case SCREEN_DIM: + if (mDimDelay >= 0) { + when += mDimDelay; + break; + } else { + Log.w(TAG, "mDimDelay=" + mDimDelay + " while trying to dim"); + } + case SCREEN_OFF: + synchronized (mLocks) { + when += mScreenOffDelay; + } + break; + } + if (mSpew) { + Log.d(TAG, "setTimeoutLocked now=" + now + " nextState=" + nextState + + " when=" + when); + } + mHandler.postAtTime(mTimeoutTask, when); + mNextTimeout = when; // for debugging + } + } + + private void cancelTimerLocked() + { + mHandler.removeCallbacks(mTimeoutTask); + mTimeoutTask.nextState = -1; + } + + private class TimeoutTask implements Runnable + { + int nextState; // access should be synchronized on mLocks + public void run() + { + synchronized (mLocks) { + if (mSpew) { + Log.d(TAG, "user activity timeout timed out nextState=" + this.nextState); + } + + if (nextState == -1) { + return; + } + + mUserState = this.nextState; + setPowerState(this.nextState | mWakeLockState); + + long now = SystemClock.uptimeMillis(); + + switch (this.nextState) + { + case SCREEN_BRIGHT: + if (mDimDelay >= 0) { + setTimeoutLocked(now, SCREEN_DIM); + break; + } + case SCREEN_DIM: + setTimeoutLocked(now, SCREEN_OFF); + break; + } + } + } + } + + private void sendNotificationLocked(boolean on, int why) + { + + if (!on) { + mNotificationWhy = why; + } + + int value = on ? 1 : 0; + if (mNotificationQueue == -1) { + // empty + // Acquire the broadcast wake lock before changing the power + // state. It will be release after the broadcast is sent. + mBroadcastWakeLock.acquire(); + EventLog.writeEvent(LOG_POWER_SCREEN_BROADCAST_SEND, mBroadcastWakeLock.mCount); + mNotificationQueue = value; + mHandler.post(mNotificationTask); + } else if (mNotificationQueue != value) { + // it's a pair, so cancel it + mNotificationQueue = -1; + mHandler.removeCallbacks(mNotificationTask); + EventLog.writeEvent(LOG_POWER_SCREEN_BROADCAST_STOP, 1, mBroadcastWakeLock.mCount); + mBroadcastWakeLock.release(); + } else { + // else, same so do nothing -- maybe we should warn? + Log.w(TAG, "Duplicate notification: on=" + on + " why=" + why); + } + } + + private Runnable mNotificationTask = new Runnable() + { + public void run() + { + int value; + int why; + WindowManagerPolicy policy; + synchronized (mLocks) { + policy = getPolicyLocked(); + value = mNotificationQueue; + why = mNotificationWhy; + mNotificationQueue = -1; + } + if (value == 1) { + mScreenOnStart = SystemClock.uptimeMillis(); + + policy.screenTurnedOn(); + try { + ActivityManagerNative.getDefault().wakingUp(); + } catch (RemoteException e) { + // ignore it + } + + if (mSpew) { + Log.d(TAG, "mBroadcastWakeLock=" + mBroadcastWakeLock); + } + if (mContext != null && ActivityManagerNative.isSystemReady()) { + mContext.sendOrderedBroadcast(mScreenOnIntent, null, + mScreenOnBroadcastDone, mHandler, 0, null, null); + } else { + synchronized (mLocks) { + EventLog.writeEvent(LOG_POWER_SCREEN_BROADCAST_STOP, 2, + mBroadcastWakeLock.mCount); + mBroadcastWakeLock.release(); + } + } + } + else if (value == 0) { + mScreenOffStart = SystemClock.uptimeMillis(); + + policy.screenTurnedOff(why); + try { + ActivityManagerNative.getDefault().goingToSleep(); + } catch (RemoteException e) { + // ignore it. + } + + if (mContext != null && ActivityManagerNative.isSystemReady()) { + mContext.sendOrderedBroadcast(mScreenOffIntent, null, + mScreenOffBroadcastDone, mHandler, 0, null, null); + } else { + synchronized (mLocks) { + EventLog.writeEvent(LOG_POWER_SCREEN_BROADCAST_STOP, 3, + mBroadcastWakeLock.mCount); + mBroadcastWakeLock.release(); + } + } + } + else { + // If we're in this case, then this handler is running for a previous + // paired transaction. mBroadcastWakeLock will already have been released + // in sendNotificationLocked. + } + } + }; + + long mScreenOnStart; + private BroadcastReceiver mScreenOnBroadcastDone = new BroadcastReceiver() { + public void onReceive(Context context, Intent intent) { + synchronized (mLocks) { + EventLog.writeEvent(LOG_POWER_SCREEN_BROADCAST_DONE, 1, + SystemClock.uptimeMillis() - mScreenOnStart, mBroadcastWakeLock.mCount); + mBroadcastWakeLock.release(); + } + } + }; + + long mScreenOffStart; + private BroadcastReceiver mScreenOffBroadcastDone = new BroadcastReceiver() { + public void onReceive(Context context, Intent intent) { + synchronized (mLocks) { + EventLog.writeEvent(LOG_POWER_SCREEN_BROADCAST_DONE, 0, + SystemClock.uptimeMillis() - mScreenOffStart, mBroadcastWakeLock.mCount); + mBroadcastWakeLock.release(); + } + } + }; + + void logPointerUpEvent() { + if (LOG_TOUCH_DOWNS) { + mTotalTouchDownTime += SystemClock.elapsedRealtime() - mLastTouchDown; + mLastTouchDown = 0; + } + } + + void logPointerDownEvent() { + if (LOG_TOUCH_DOWNS) { + // If we are not already timing a down/up sequence + if (mLastTouchDown == 0) { + mLastTouchDown = SystemClock.elapsedRealtime(); + mTouchCycles++; + } + } + } + + /** + * Prevents the screen from turning on even if it *should* turn on due + * to a subsequent full wake lock being acquired. + * <p> + * This is a temporary hack that allows an activity to "cover up" any + * display glitches that happen during the activity's startup + * sequence. (Specifically, this API was added to work around a + * cosmetic bug in the "incoming call" sequence, where the lock screen + * would flicker briefly before the incoming call UI became visible.) + * TODO: There ought to be a more elegant way of doing this, + * probably by having the PowerManager and ActivityManager + * work together to let apps specify that the screen on/off + * state should be synchronized with the Activity lifecycle. + * <p> + * Note that calling preventScreenOn(true) will NOT turn the screen + * off if it's currently on. (This API only affects *future* + * acquisitions of full wake locks.) + * But calling preventScreenOn(false) WILL turn the screen on if + * it's currently off because of a prior preventScreenOn(true) call. + * <p> + * Any call to preventScreenOn(true) MUST be followed promptly by a call + * to preventScreenOn(false). In fact, if the preventScreenOn(false) + * call doesn't occur within 5 seconds, we'll turn the screen back on + * ourselves (and log a warning about it); this prevents a buggy app + * from disabling the screen forever.) + * <p> + * TODO: this feature should really be controlled by a new type of poke + * lock (rather than an IPowerManager call). + */ + public void preventScreenOn(boolean prevent) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); + + synchronized (mLocks) { + if (prevent) { + // First of all, grab a partial wake lock to + // make sure the CPU stays on during the entire + // preventScreenOn(true) -> preventScreenOn(false) sequence. + mPreventScreenOnPartialLock.acquire(); + + // Post a forceReenableScreen() call (for 5 seconds in the + // future) to make sure the matching preventScreenOn(false) call + // has happened by then. + mHandler.removeCallbacks(mForceReenableScreenTask); + mHandler.postDelayed(mForceReenableScreenTask, 5000); + + // Finally, set the flag that prevents the screen from turning on. + // (Below, in setPowerState(), we'll check mPreventScreenOn and + // we *won't* call Power.setScreenState(true) if it's set.) + mPreventScreenOn = true; + } else { + // (Re)enable the screen. + mPreventScreenOn = false; + + // We're "undoing" a the prior preventScreenOn(true) call, so we + // no longer need the 5-second safeguard. + mHandler.removeCallbacks(mForceReenableScreenTask); + + // Forcibly turn on the screen if it's supposed to be on. (This + // handles the case where the screen is currently off because of + // a prior preventScreenOn(true) call.) + if ((mPowerState & SCREEN_ON_BIT) != 0) { + if (mSpew) { + Log.d(TAG, + "preventScreenOn: turning on after a prior preventScreenOn(true)!"); + } + int err = Power.setScreenState(true); + if (err != 0) { + Log.w(TAG, "preventScreenOn: error from Power.setScreenState(): " + err); + } + } + + // Release the partial wake lock that we held during the + // preventScreenOn(true) -> preventScreenOn(false) sequence. + mPreventScreenOnPartialLock.release(); + } + } + } + + public void setScreenBrightnessOverride(int brightness) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); + + synchronized (mLocks) { + if (mScreenBrightnessOverride != brightness) { + mScreenBrightnessOverride = brightness; + updateLightsLocked(mPowerState, SCREEN_ON_BIT); + } + } + } + + /** + * Sanity-check that gets called 5 seconds after any call to + * preventScreenOn(true). This ensures that the original call + * is followed promptly by a call to preventScreenOn(false). + */ + private void forceReenableScreen() { + // We shouldn't get here at all if mPreventScreenOn is false, since + // we should have already removed any existing + // mForceReenableScreenTask messages... + if (!mPreventScreenOn) { + Log.w(TAG, "forceReenableScreen: mPreventScreenOn is false, nothing to do"); + return; + } + + // Uh oh. It's been 5 seconds since a call to + // preventScreenOn(true) and we haven't re-enabled the screen yet. + // This means the app that called preventScreenOn(true) is either + // slow (i.e. it took more than 5 seconds to call preventScreenOn(false)), + // or buggy (i.e. it forgot to call preventScreenOn(false), or + // crashed before doing so.) + + // Log a warning, and forcibly turn the screen back on. + Log.w(TAG, "App called preventScreenOn(true) but didn't promptly reenable the screen! " + + "Forcing the screen back on..."); + preventScreenOn(false); + } + + private Runnable mForceReenableScreenTask = new Runnable() { + public void run() { + forceReenableScreen(); + } + }; + + private void setPowerState(int state) + { + setPowerState(state, false, false); + } + + private void setPowerState(int newState, boolean noChangeLights, boolean becauseOfUser) + { + synchronized (mLocks) { + int err; + + if (mSpew) { + Log.d(TAG, "setPowerState: mPowerState=0x" + Integer.toHexString(mPowerState) + + " newState=0x" + Integer.toHexString(newState) + + " noChangeLights=" + noChangeLights); + } + + if (noChangeLights) { + newState = (newState & ~LIGHTS_MASK) | (mPowerState & LIGHTS_MASK); + } + + if (batteryIsLow()) { + newState |= BATTERY_LOW_BIT; + } else { + newState &= ~BATTERY_LOW_BIT; + } + if (newState == mPowerState) { + return; + } + + if (!mDoneBooting) { + newState |= ALL_BRIGHT; + } + + boolean oldScreenOn = (mPowerState & SCREEN_ON_BIT) != 0; + boolean newScreenOn = (newState & SCREEN_ON_BIT) != 0; + + if (mSpew) { + Log.d(TAG, "setPowerState: mPowerState=" + mPowerState + + " newState=" + newState + " noChangeLights=" + noChangeLights); + Log.d(TAG, " oldKeyboardBright=" + ((mPowerState & KEYBOARD_BRIGHT_BIT) != 0) + + " newKeyboardBright=" + ((newState & KEYBOARD_BRIGHT_BIT) != 0)); + Log.d(TAG, " oldScreenBright=" + ((mPowerState & SCREEN_BRIGHT_BIT) != 0) + + " newScreenBright=" + ((newState & SCREEN_BRIGHT_BIT) != 0)); + Log.d(TAG, " oldButtonBright=" + ((mPowerState & BUTTON_BRIGHT_BIT) != 0) + + " newButtonBright=" + ((newState & BUTTON_BRIGHT_BIT) != 0)); + Log.d(TAG, " oldScreenOn=" + oldScreenOn + + " newScreenOn=" + newScreenOn); + Log.d(TAG, " oldBatteryLow=" + ((mPowerState & BATTERY_LOW_BIT) != 0) + + " newBatteryLow=" + ((newState & BATTERY_LOW_BIT) != 0)); + } + + if (mPowerState != newState) { + err = updateLightsLocked(newState, 0); + if (err != 0) { + return; + } + mPowerState = (mPowerState & ~LIGHTS_MASK) | (newState & LIGHTS_MASK); + } + + if (oldScreenOn != newScreenOn) { + if (newScreenOn) { + // Turn on the screen UNLESS there was a prior + // preventScreenOn(true) request. (Note that the lifetime + // of a single preventScreenOn() request is limited to 5 + // seconds to prevent a buggy app from disabling the + // screen forever; see forceReenableScreen().) + boolean reallyTurnScreenOn = true; + if (mSpew) { + Log.d(TAG, "- turning screen on... mPreventScreenOn = " + + mPreventScreenOn); + } + + if (mPreventScreenOn) { + if (mSpew) { + Log.d(TAG, "- PREVENTING screen from really turning on!"); + } + reallyTurnScreenOn = false; + } + if (reallyTurnScreenOn) { + err = Power.setScreenState(true); + long identity = Binder.clearCallingIdentity(); + try { + mBatteryStats.noteScreenOn(); + } catch (RemoteException e) { + Log.w(TAG, "RemoteException calling noteScreenOn on BatteryStatsService", e); + } finally { + Binder.restoreCallingIdentity(identity); + } + } else { + Power.setScreenState(false); + // But continue as if we really did turn the screen on... + err = 0; + } + + mScreenOnStartTime = SystemClock.elapsedRealtime(); + mLastTouchDown = 0; + mTotalTouchDownTime = 0; + mTouchCycles = 0; + EventLog.writeEvent(LOG_POWER_SCREEN_STATE, 1, becauseOfUser ? 1 : 0, + mTotalTouchDownTime, mTouchCycles); + if (err == 0) { + mPowerState |= SCREEN_ON_BIT; + sendNotificationLocked(true, -1); + } + } else { + mScreenOffTime = SystemClock.elapsedRealtime(); + long identity = Binder.clearCallingIdentity(); + try { + mBatteryStats.noteScreenOff(); + } catch (RemoteException e) { + Log.w(TAG, "RemoteException calling noteScreenOff on BatteryStatsService", e); + } finally { + Binder.restoreCallingIdentity(identity); + } + mPowerState &= ~SCREEN_ON_BIT; + if (!mScreenBrightness.animating) { + err = screenOffFinishedAnimating(becauseOfUser); + } else { + mOffBecauseOfUser = becauseOfUser; + err = 0; + mLastTouchDown = 0; + } + } + } + } + } + + private int screenOffFinishedAnimating(boolean becauseOfUser) { + // I don't think we need to check the current state here because all of these + // Power.setScreenState and sendNotificationLocked can both handle being + // called multiple times in the same state. -joeo + EventLog.writeEvent(LOG_POWER_SCREEN_STATE, 0, becauseOfUser ? 1 : 0, + mTotalTouchDownTime, mTouchCycles); + mLastTouchDown = 0; + int err = Power.setScreenState(false); + if (mScreenOnStartTime != 0) { + mScreenOnTime += SystemClock.elapsedRealtime() - mScreenOnStartTime; + mScreenOnStartTime = 0; + } + if (err == 0) { + int why = becauseOfUser + ? WindowManagerPolicy.OFF_BECAUSE_OF_USER + : WindowManagerPolicy.OFF_BECAUSE_OF_TIMEOUT; + sendNotificationLocked(false, why); + } + return err; + } + + private boolean batteryIsLow() { + return (!mIsPowered && + mBatteryService.getBatteryLevel() <= Power.LOW_BATTERY_THRESHOLD); + } + + private int updateLightsLocked(int newState, int forceState) { + int oldState = mPowerState; + int difference = (newState ^ oldState) | forceState; + if (difference == 0) { + return 0; + } + + int offMask = 0; + int dimMask = 0; + int onMask = 0; + + int preferredBrightness = getPreferredBrightness(); + boolean startAnimation = false; + + if ((difference & KEYBOARD_BRIGHT_BIT) != 0) { + if (ANIMATE_KEYBOARD_LIGHTS) { + if ((newState & KEYBOARD_BRIGHT_BIT) == 0) { + mKeyboardBrightness.setTargetLocked(Power.BRIGHTNESS_OFF, + ANIM_STEPS, INITIAL_KEYBOARD_BRIGHTNESS); + } else { + mKeyboardBrightness.setTargetLocked(preferredBrightness, + ANIM_STEPS, INITIAL_KEYBOARD_BRIGHTNESS); + } + startAnimation = true; + } else { + if ((newState & KEYBOARD_BRIGHT_BIT) == 0) { + offMask |= Power.KEYBOARD_LIGHT; + } else { + onMask |= Power.KEYBOARD_LIGHT; + } + } + } + + if ((difference & BUTTON_BRIGHT_BIT) != 0) { + if (ANIMATE_BUTTON_LIGHTS) { + if ((newState & BUTTON_BRIGHT_BIT) == 0) { + mButtonBrightness.setTargetLocked(Power.BRIGHTNESS_OFF, + ANIM_STEPS, INITIAL_BUTTON_BRIGHTNESS); + } else { + mButtonBrightness.setTargetLocked(preferredBrightness, + ANIM_STEPS, INITIAL_BUTTON_BRIGHTNESS); + } + startAnimation = true; + } else { + if ((newState & BUTTON_BRIGHT_BIT) == 0) { + offMask |= Power.BUTTON_LIGHT; + } else { + onMask |= Power.BUTTON_LIGHT; + } + } + } + + if ((difference & (SCREEN_ON_BIT | SCREEN_BRIGHT_BIT)) != 0) { + if (ANIMATE_SCREEN_LIGHTS) { + if ((newState & SCREEN_BRIGHT_BIT) == 0) { + // dim or turn off backlight, depending on if the screen is on + // the scale is because the brightness ramp isn't linear and this biases + // it so the later parts take longer. + final float scale = 1.5f; + float ratio = (((float)Power.BRIGHTNESS_DIM)/preferredBrightness); + if (ratio > 1.0f) ratio = 1.0f; + if ((newState & SCREEN_ON_BIT) == 0) { + int steps; + if ((oldState & SCREEN_BRIGHT_BIT) != 0) { + // was bright + steps = ANIM_STEPS; + } else { + // was dim + steps = (int)(ANIM_STEPS*ratio*scale); + } + mScreenBrightness.setTargetLocked(Power.BRIGHTNESS_OFF, + steps, INITIAL_SCREEN_BRIGHTNESS); + } else { + int steps; + if ((oldState & SCREEN_ON_BIT) != 0) { + // was bright + steps = (int)(ANIM_STEPS*(1.0f-ratio)*scale); + } else { + // was dim + steps = (int)(ANIM_STEPS*ratio); + } + if (mStayOnConditions != 0 && mBatteryService.isPowered(mStayOnConditions)) { + // If the "stay on while plugged in" option is + // turned on, then the screen will often not + // automatically turn off while plugged in. To + // still have a sense of when it is inactive, we + // will then count going dim as turning off. + mScreenOffTime = SystemClock.elapsedRealtime(); + } + mScreenBrightness.setTargetLocked(Power.BRIGHTNESS_DIM, + steps, INITIAL_SCREEN_BRIGHTNESS); + } + } else { + mScreenBrightness.setTargetLocked(preferredBrightness, + ANIM_STEPS, INITIAL_SCREEN_BRIGHTNESS); + } + startAnimation = true; + } else { + if ((newState & SCREEN_BRIGHT_BIT) == 0) { + // dim or turn off backlight, depending on if the screen is on + if ((newState & SCREEN_ON_BIT) == 0) { + offMask |= Power.SCREEN_LIGHT; + } else { + dimMask |= Power.SCREEN_LIGHT; + } + } else { + onMask |= Power.SCREEN_LIGHT; + } + } + } + + if (startAnimation) { + if (mSpew) { + Log.i(TAG, "Scheduling light animator!"); + } + mHandler.removeCallbacks(mLightAnimator); + mHandler.post(mLightAnimator); + } + + int err = 0; + if (offMask != 0) { + //Log.i(TAG, "Setting brightess off: " + offMask); + err |= Power.setLightBrightness(offMask, Power.BRIGHTNESS_OFF); + } + if (dimMask != 0) { + int brightness = Power.BRIGHTNESS_DIM; + if ((newState & BATTERY_LOW_BIT) != 0 && + brightness > Power.BRIGHTNESS_LOW_BATTERY) { + brightness = Power.BRIGHTNESS_LOW_BATTERY; + } + //Log.i(TAG, "Setting brightess dim " + brightness + ": " + offMask); + err |= Power.setLightBrightness(dimMask, brightness); + } + if (onMask != 0) { + int brightness = getPreferredBrightness(); + if ((newState & BATTERY_LOW_BIT) != 0 && + brightness > Power.BRIGHTNESS_LOW_BATTERY) { + brightness = Power.BRIGHTNESS_LOW_BATTERY; + } + //Log.i(TAG, "Setting brightess on " + brightness + ": " + onMask); + err |= Power.setLightBrightness(onMask, brightness); + } + + return err; + } + + class BrightnessState { + final int mask; + + boolean initialized; + int targetValue; + float curValue; + float delta; + boolean animating; + + BrightnessState(int m) { + mask = m; + } + + public void dump(PrintWriter pw, String prefix) { + pw.println(prefix + "animating=" + animating + + " targetValue=" + targetValue + + " curValue=" + curValue + + " delta=" + delta); + } + + void setTargetLocked(int target, int stepsToTarget, int initialValue) { + if (!initialized) { + initialized = true; + curValue = (float)initialValue; + } + targetValue = target; + delta = (targetValue-curValue) / stepsToTarget; + if (mSpew) { + Log.i(TAG, "Setting target " + mask + ": cur=" + curValue + + " target=" + targetValue + " delta=" + delta); + } + animating = true; + } + + boolean stepLocked() { + if (!animating) return false; + if (false && mSpew) { + Log.i(TAG, "Step target " + mask + ": cur=" + curValue + + " target=" + targetValue + " delta=" + delta); + } + curValue += delta; + int curIntValue = (int)curValue; + boolean more = true; + if (delta == 0) { + more = false; + } else if (delta > 0) { + if (curIntValue >= targetValue) { + curValue = curIntValue = targetValue; + more = false; + } + } else { + if (curIntValue <= targetValue) { + curValue = curIntValue = targetValue; + more = false; + } + } + //Log.i(TAG, "Animating brightess " + curIntValue + ": " + mask); + Power.setLightBrightness(mask, curIntValue); + animating = more; + if (!more) { + if (mask == Power.SCREEN_LIGHT && curIntValue == Power.BRIGHTNESS_OFF) { + screenOffFinishedAnimating(mOffBecauseOfUser); + } + } + return more; + } + } + + private class LightAnimator implements Runnable { + public void run() { + synchronized (mLocks) { + long now = SystemClock.uptimeMillis(); + boolean more = mScreenBrightness.stepLocked(); + if (mKeyboardBrightness.stepLocked()) { + more = true; + } + if (mButtonBrightness.stepLocked()) { + more = true; + } + if (more) { + mHandler.postAtTime(mLightAnimator, now+(1000/60)); + } + } + } + } + + private int getPreferredBrightness() { + try { + if (mScreenBrightnessOverride >= 0) { + return mScreenBrightnessOverride; + } + final int brightness = Settings.System.getInt(mContext.getContentResolver(), + SCREEN_BRIGHTNESS); + // Don't let applications turn the screen all the way off + return Math.max(brightness, Power.BRIGHTNESS_DIM); + } catch (SettingNotFoundException snfe) { + return Power.BRIGHTNESS_ON; + } + } + + boolean screenIsOn() { + synchronized (mLocks) { + return (mPowerState & SCREEN_ON_BIT) != 0; + } + } + + boolean screenIsBright() { + synchronized (mLocks) { + return (mPowerState & SCREEN_BRIGHT) == SCREEN_BRIGHT; + } + } + + public void userActivityWithForce(long time, boolean noChangeLights, boolean force) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); + userActivity(time, noChangeLights, OTHER_EVENT, force); + } + + public void userActivity(long time, boolean noChangeLights) { + userActivity(time, noChangeLights, OTHER_EVENT, false); + } + + public void userActivity(long time, boolean noChangeLights, int eventType) { + userActivity(time, noChangeLights, eventType, false); + } + + public void userActivity(long time, boolean noChangeLights, int eventType, boolean force) { + //mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); + + if (((mPokey & POKE_LOCK_IGNORE_CHEEK_EVENTS) != 0) + && !((eventType == OTHER_EVENT) || (eventType == BUTTON_EVENT))) { + if (false) { + Log.d(TAG, "dropping mPokey=0x" + Integer.toHexString(mPokey)); + } + return; + } + + if (false) { + if (((mPokey & POKE_LOCK_IGNORE_CHEEK_EVENTS) != 0)) { + Log.d(TAG, "userActivity !!!");//, new RuntimeException()); + } else { + Log.d(TAG, "mPokey=0x" + Integer.toHexString(mPokey)); + } + } + + synchronized (mLocks) { + if (mSpew) { + Log.d(TAG, "userActivity mLastEventTime=" + mLastEventTime + " time=" + time + + " mUserActivityAllowed=" + mUserActivityAllowed + + " mUserState=0x" + Integer.toHexString(mUserState) + + " mWakeLockState=0x" + Integer.toHexString(mWakeLockState)); + } + if (mLastEventTime <= time || force) { + mLastEventTime = time; + if (mUserActivityAllowed || force) { + // Only turn on button backlights if a button was pressed. + if (eventType == BUTTON_EVENT) { + mUserState = (mKeyboardVisible ? ALL_BRIGHT : SCREEN_BUTTON_BRIGHT); + } else { + // don't clear button/keyboard backlights when the screen is touched. + mUserState |= SCREEN_BRIGHT; + } + + reactivateWakeLocksLocked(); + mWakeLockState = mLocks.gatherState(); + setPowerState(mUserState | mWakeLockState, noChangeLights, true); + setTimeoutLocked(time, SCREEN_BRIGHT); + } + } + } + } + + /** + * The user requested that we go to sleep (probably with the power button). + * This overrides all wake locks that are held. + */ + public void goToSleep(long time) + { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.DEVICE_POWER, null); + synchronized (mLocks) { + goToSleepLocked(time); + } + } + + /** + * Returns the time the screen has been on since boot, in millis. + * @return screen on time + */ + public long getScreenOnTime() { + synchronized (mLocks) { + if (mScreenOnStartTime == 0) { + return mScreenOnTime; + } else { + return SystemClock.elapsedRealtime() - mScreenOnStartTime + mScreenOnTime; + } + } + } + + private void goToSleepLocked(long time) { + + if (mLastEventTime <= time) { + mLastEventTime = time; + // cancel all of the wake locks + mWakeLockState = SCREEN_OFF; + int N = mLocks.size(); + int numCleared = 0; + for (int i=0; i<N; i++) { + WakeLock wl = mLocks.get(i); + if (isScreenLock(wl.flags)) { + mLocks.get(i).activated = false; + numCleared++; + } + } + EventLog.writeEvent(LOG_POWER_SLEEP_REQUESTED, numCleared); + mUserState = SCREEN_OFF; + setPowerState(SCREEN_OFF, false, true); + cancelTimerLocked(); + } + } + + public long timeSinceScreenOn() { + synchronized (mLocks) { + if ((mPowerState & SCREEN_ON_BIT) != 0) { + return 0; + } + return SystemClock.elapsedRealtime() - mScreenOffTime; + } + } + + public void setKeyboardVisibility(boolean visible) { + mKeyboardVisible = visible; + } + + /** + * When the keyguard is up, it manages the power state, and userActivity doesn't do anything. + */ + public void enableUserActivity(boolean enabled) { + synchronized (mLocks) { + mUserActivityAllowed = enabled; + mLastEventTime = SystemClock.uptimeMillis(); // we might need to pass this in + } + } + + /** Sets the screen off timeouts: + * mKeylightDelay + * mDimDelay + * mScreenOffDelay + * */ + private void setScreenOffTimeoutsLocked() { + if ((mPokey & POKE_LOCK_SHORT_TIMEOUT) != 0) { + mKeylightDelay = mShortKeylightDelay; // Configurable via Gservices + mDimDelay = -1; + mScreenOffDelay = 0; + } else if ((mPokey & POKE_LOCK_MEDIUM_TIMEOUT) != 0) { + mKeylightDelay = MEDIUM_KEYLIGHT_DELAY; + mDimDelay = -1; + mScreenOffDelay = 0; + } else { + int totalDelay = mTotalDelaySetting; + mKeylightDelay = LONG_KEYLIGHT_DELAY; + if (totalDelay < 0) { + mScreenOffDelay = Integer.MAX_VALUE; + } else if (mKeylightDelay < totalDelay) { + // subtract the time that the keylight delay. This will give us the + // remainder of the time that we need to sleep to get the accurate + // screen off timeout. + mScreenOffDelay = totalDelay - mKeylightDelay; + } else { + mScreenOffDelay = 0; + } + if (mDimScreen && totalDelay >= (LONG_KEYLIGHT_DELAY + LONG_DIM_TIME)) { + mDimDelay = mScreenOffDelay - LONG_DIM_TIME; + mScreenOffDelay = LONG_DIM_TIME; + } else { + mDimDelay = -1; + } + } + if (mSpew) { + Log.d(TAG, "setScreenOffTimeouts mKeylightDelay=" + mKeylightDelay + + " mDimDelay=" + mDimDelay + " mScreenOffDelay=" + mScreenOffDelay + + " mDimScreen=" + mDimScreen); + } + } + + /** + * Refreshes cached Gservices settings. Called once on startup, and + * on subsequent Settings.Gservices.CHANGED_ACTION broadcasts (see + * GservicesChangedReceiver). + */ + private void updateGservicesValues() { + mShortKeylightDelay = Settings.Gservices.getInt( + mContext.getContentResolver(), + Settings.Gservices.SHORT_KEYLIGHT_DELAY_MS, + SHORT_KEYLIGHT_DELAY_DEFAULT); + // Log.i(TAG, "updateGservicesValues(): mShortKeylightDelay now " + mShortKeylightDelay); + } + + /** + * Receiver for the Gservices.CHANGED_ACTION broadcast intent, + * which tells us we need to refresh our cached Gservices settings. + */ + private class GservicesChangedReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + // Log.i(TAG, "GservicesChangedReceiver.onReceive(): " + intent); + updateGservicesValues(); + } + } + + private class LockList extends ArrayList<WakeLock> + { + void addLock(WakeLock wl) + { + int index = getIndex(wl.binder); + if (index < 0) { + this.add(wl); + } + } + + WakeLock removeLock(IBinder binder) + { + int index = getIndex(binder); + if (index >= 0) { + return this.remove(index); + } else { + return null; + } + } + + int getIndex(IBinder binder) + { + int N = this.size(); + for (int i=0; i<N; i++) { + if (this.get(i).binder == binder) { + return i; + } + } + return -1; + } + + int gatherState() + { + int result = 0; + int N = this.size(); + for (int i=0; i<N; i++) { + WakeLock wl = this.get(i); + if (wl.activated) { + if (isScreenLock(wl.flags)) { + result |= wl.minState; + } + } + } + return result; + } + } + + void setPolicy(WindowManagerPolicy p) { + synchronized (mLocks) { + mPolicy = p; + mLocks.notifyAll(); + } + } + + WindowManagerPolicy getPolicyLocked() { + while (mPolicy == null || !mDoneBooting) { + try { + mLocks.wait(); + } catch (InterruptedException e) { + // Ignore + } + } + return mPolicy; + } + + void systemReady() { + synchronized (mLocks) { + Log.d(TAG, "system ready!"); + mDoneBooting = true; + userActivity(SystemClock.uptimeMillis(), false, BUTTON_EVENT, true); + updateWakeLockLocked(); + mLocks.notifyAll(); + } + } + + public void monitor() { + synchronized (mLocks) { } + } +} diff --git a/services/java/com/android/server/ProcessMap.java b/services/java/com/android/server/ProcessMap.java new file mode 100644 index 0000000..6b26403 --- /dev/null +++ b/services/java/com/android/server/ProcessMap.java @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2006 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.util.SparseArray; + +import java.util.HashMap; + +public class ProcessMap<E> { + final HashMap<String, SparseArray<E>> mMap + = new HashMap<String, SparseArray<E>>(); + + public E get(String name, int uid) { + SparseArray<E> uids = mMap.get(name); + if (uids == null) return null; + return uids.get(uid); + } + + public E put(String name, int uid, E value) { + SparseArray<E> uids = mMap.get(name); + if (uids == null) { + uids = new SparseArray<E>(2); + mMap.put(name, uids); + } + uids.put(uid, value); + return value; + } + + public void remove(String name, int uid) { + SparseArray<E> uids = mMap.get(name); + if (uids != null) { + uids.remove(uid); + if (uids.size() == 0) { + mMap.remove(name); + } + } + } + + public HashMap<String, SparseArray<E>> getMap() { + return mMap; + } +} diff --git a/services/java/com/android/server/ProcessStats.java b/services/java/com/android/server/ProcessStats.java new file mode 100644 index 0000000..55adabb --- /dev/null +++ b/services/java/com/android/server/ProcessStats.java @@ -0,0 +1,580 @@ +/* + * Copyright (C) 2007 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 static android.os.Process.*; + +import android.os.Process; +import android.os.SystemClock; +import android.util.Config; +import android.util.Log; + +import java.io.File; +import java.io.FileInputStream; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; + +public class ProcessStats { + private static final String TAG = "ProcessStats"; + private static final boolean DEBUG = false; + private static final boolean localLOGV = DEBUG || Config.LOGV; + + private static final int[] PROCESS_STATS_FORMAT = new int[] { + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM|PROC_OUT_LONG, // 13: utime + PROC_SPACE_TERM|PROC_OUT_LONG // 14: stime + }; + + private final long[] mProcessStatsData = new long[2]; + + private static final int[] PROCESS_FULL_STATS_FORMAT = new int[] { + PROC_SPACE_TERM, + PROC_SPACE_TERM|PROC_PARENS|PROC_OUT_STRING, // 1: name + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM, + PROC_SPACE_TERM|PROC_OUT_LONG, // 13: utime + PROC_SPACE_TERM|PROC_OUT_LONG // 14: stime + }; + + private final String[] mProcessFullStatsStringData = new String[3]; + private final long[] mProcessFullStatsData = new long[3]; + + private static final int[] SYSTEM_CPU_FORMAT = new int[] { + PROC_SPACE_TERM|PROC_COMBINE, + PROC_SPACE_TERM|PROC_OUT_LONG, // 1: user time + PROC_SPACE_TERM|PROC_OUT_LONG, // 2: nice time + PROC_SPACE_TERM|PROC_OUT_LONG, // 3: sys time + PROC_SPACE_TERM|PROC_OUT_LONG, // 4: idle time + PROC_SPACE_TERM|PROC_OUT_LONG, // 5: iowait time + PROC_SPACE_TERM|PROC_OUT_LONG, // 6: irq time + PROC_SPACE_TERM|PROC_OUT_LONG // 7: softirq time + }; + + private final long[] mSystemCpuData = new long[7]; + + private static final int[] LOAD_AVERAGE_FORMAT = new int[] { + PROC_SPACE_TERM|PROC_OUT_FLOAT, // 0: 1 min + PROC_SPACE_TERM|PROC_OUT_FLOAT, // 1: 5 mins + PROC_SPACE_TERM|PROC_OUT_FLOAT // 2: 15 mins + }; + + private final float[] mLoadAverageData = new float[3]; + + private final boolean mIncludeThreads; + + private float mLoad1 = 0; + private float mLoad5 = 0; + private float mLoad15 = 0; + + private long mCurrentSampleTime; + private long mLastSampleTime; + + private long mBaseUserTime; + private long mBaseSystemTime; + private long mBaseIoWaitTime; + private long mBaseIrqTime; + private long mBaseSoftIrqTime; + private long mBaseIdleTime; + private int mRelUserTime; + private int mRelSystemTime; + private int mRelIoWaitTime; + private int mRelIrqTime; + private int mRelSoftIrqTime; + private int mRelIdleTime; + + private int[] mCurPids; + private int[] mCurThreadPids; + + private final ArrayList<Stats> mProcStats = new ArrayList<Stats>(); + private final ArrayList<Stats> mWorkingProcs = new ArrayList<Stats>(); + private boolean mWorkingProcsSorted; + + private boolean mFirst = true; + + private byte[] mBuffer = new byte[256]; + + public static class Stats { + public final int pid; + final String statFile; + final String cmdlineFile; + final String threadsDir; + final ArrayList<Stats> threadStats; + final ArrayList<Stats> workingThreads; + + public String baseName; + public String name; + int nameWidth; + + public long base_utime; + public long base_stime; + public int rel_utime; + public int rel_stime; + + public boolean active; + public boolean added; + public boolean removed; + + Stats(int _pid, int parentPid, boolean includeThreads) { + pid = _pid; + if (parentPid < 0) { + final File procDir = new File("/proc", Integer.toString(pid)); + statFile = new File(procDir, "stat").toString(); + cmdlineFile = new File(procDir, "cmdline").toString(); + threadsDir = (new File(procDir, "task")).toString(); + if (includeThreads) { + threadStats = new ArrayList<Stats>(); + workingThreads = new ArrayList<Stats>(); + } else { + threadStats = null; + workingThreads = null; + } + } else { + final File procDir = new File("/proc", Integer.toString( + parentPid)); + final File taskDir = new File( + new File(procDir, "task"), Integer.toString(pid)); + statFile = new File(taskDir, "stat").toString(); + cmdlineFile = null; + threadsDir = null; + threadStats = null; + workingThreads = null; + } + } + } + + private final static Comparator<Stats> sLoadComparator = new Comparator<Stats>() { + public final int + compare(Stats sta, Stats stb) + { + int ta = sta.rel_utime + sta.rel_stime; + int tb = stb.rel_utime + stb.rel_stime; + if (ta != tb) { + return ta > tb ? -1 : 1; + } + if (sta.added != stb.added) { + return sta.added ? -1 : 1; + } + if (sta.removed != stb.removed) { + return sta.added ? -1 : 1; + } + return 0; + } + }; + + + public ProcessStats(boolean includeThreads) { + mIncludeThreads = includeThreads; + } + + public void onLoadChanged(float load1, float load5, float load15) { + } + + public int onMeasureProcessName(String name) { + return 0; + } + + public void init() { + mFirst = true; + update(); + } + + public void update() { + mLastSampleTime = mCurrentSampleTime; + mCurrentSampleTime = SystemClock.uptimeMillis(); + + final float[] loadAverages = mLoadAverageData; + if (Process.readProcFile("/proc/loadavg", LOAD_AVERAGE_FORMAT, + null, null, loadAverages)) { + float load1 = loadAverages[0]; + float load5 = loadAverages[1]; + float load15 = loadAverages[2]; + if (load1 != mLoad1 || load5 != mLoad5 || load15 != mLoad15) { + mLoad1 = load1; + mLoad5 = load5; + mLoad15 = load15; + onLoadChanged(load1, load5, load15); + } + } + + mCurPids = collectStats("/proc", -1, mFirst, mCurPids, + mProcStats, mWorkingProcs); + mFirst = false; + + final long[] sysCpu = mSystemCpuData; + if (Process.readProcFile("/proc/stat", SYSTEM_CPU_FORMAT, + null, sysCpu, null)) { + // Total user time is user + nice time. + final long usertime = sysCpu[0]+sysCpu[1]; + // Total system time is simply system time. + final long systemtime = sysCpu[2]; + // Total idle time is simply idle time. + final long idletime = sysCpu[3]; + // Total irq time is iowait + irq + softirq time. + final long iowaittime = sysCpu[4]; + final long irqtime = sysCpu[5]; + final long softirqtime = sysCpu[6]; + + mRelUserTime = (int)(usertime - mBaseUserTime); + mRelSystemTime = (int)(systemtime - mBaseSystemTime); + mRelIoWaitTime = (int)(iowaittime - mBaseIoWaitTime); + mRelIrqTime = (int)(irqtime - mBaseIrqTime); + mRelSoftIrqTime = (int)(softirqtime - mBaseSoftIrqTime); + mRelIdleTime = (int)(idletime - mBaseIdleTime); + + if (false) { + Log.i("Load", "Total U:" + sysCpu[0] + " N:" + sysCpu[1] + + " S:" + sysCpu[2] + " I:" + sysCpu[3] + + " W:" + sysCpu[4] + " Q:" + sysCpu[5] + + " O:" + sysCpu[6]); + Log.i("Load", "Rel U:" + mRelUserTime + " S:" + mRelSystemTime + + " I:" + mRelIdleTime + " Q:" + mRelIrqTime); + } + + mBaseUserTime = usertime; + mBaseSystemTime = systemtime; + mBaseIoWaitTime = iowaittime; + mBaseIrqTime = irqtime; + mBaseSoftIrqTime = softirqtime; + mBaseIdleTime = idletime; + } + + mWorkingProcsSorted = false; + mFirst = false; + } + + private int[] collectStats(String statsFile, int parentPid, boolean first, + int[] curPids, ArrayList<Stats> allProcs, + ArrayList<Stats> workingProcs) { + + workingProcs.clear(); + + int[] pids = Process.getPids(statsFile, curPids); + int NP = (pids == null) ? 0 : pids.length; + int NS = allProcs.size(); + int curStatsIndex = 0; + for (int i=0; i<NP; i++) { + int pid = pids[i]; + if (pid < 0) { + NP = pid; + break; + } + Stats st = curStatsIndex < NS ? allProcs.get(curStatsIndex) : null; + + if (st != null && st.pid == pid) { + // Update an existing process... + st.added = false; + curStatsIndex++; + if (localLOGV) Log.v(TAG, "Existing pid " + pid + ": " + st); + + final long[] procStats = mProcessStatsData; + if (!Process.readProcFile(st.statFile.toString(), + PROCESS_STATS_FORMAT, null, procStats, null)) { + continue; + } + + final long utime = procStats[0]; + final long stime = procStats[1]; + + if (utime == st.base_utime && stime == st.base_stime) { + st.rel_utime = 0; + st.rel_stime = 0; + if (st.active) { + st.active = false; + } + continue; + } + + if (!st.active) { + st.active = true; + } + + if (parentPid < 0) { + getName(st, st.cmdlineFile); + if (st.threadStats != null) { + mCurThreadPids = collectStats(st.threadsDir, pid, false, + mCurThreadPids, st.threadStats, + st.workingThreads); + } + } + + st.rel_utime = (int)(utime - st.base_utime); + st.rel_stime = (int)(stime - st.base_stime); + st.base_utime = utime; + st.base_stime = stime; + //Log.i("Load", "Stats changed " + name + " pid=" + st.pid + // + " name=" + st.name + " utime=" + utime + // + " stime=" + stime); + workingProcs.add(st); + continue; + } + + if (st == null || st.pid > pid) { + // We have a new process! + st = new Stats(pid, parentPid, mIncludeThreads); + allProcs.add(curStatsIndex, st); + curStatsIndex++; + NS++; + if (localLOGV) Log.v(TAG, "New pid " + pid + ": " + st); + + final String[] procStatsString = mProcessFullStatsStringData; + final long[] procStats = mProcessFullStatsData; + if (Process.readProcFile(st.statFile.toString(), + PROCESS_FULL_STATS_FORMAT, procStatsString, + procStats, null)) { + st.baseName = parentPid < 0 + ? procStatsString[0] : Integer.toString(pid); + st.base_utime = procStats[1]; + st.base_stime = procStats[2]; + } else { + st.baseName = "<unknown>"; + st.base_utime = st.base_stime = 0; + } + + if (parentPid < 0) { + getName(st, st.cmdlineFile); + } else { + st.name = st.baseName; + st.nameWidth = onMeasureProcessName(st.name); + if (st.threadStats != null) { + mCurThreadPids = collectStats(st.threadsDir, pid, true, + mCurThreadPids, st.threadStats, + st.workingThreads); + } + } + + //Log.i("Load", "New process: " + st.pid + " " + st.name); + st.rel_utime = 0; + st.rel_stime = 0; + st.added = true; + if (!first) { + workingProcs.add(st); + } + continue; + } + + // This process has gone away! + st.rel_utime = 0; + st.rel_stime = 0; + st.removed = true; + workingProcs.add(st); + allProcs.remove(curStatsIndex); + NS--; + if (localLOGV) Log.v(TAG, "Removed pid " + st.pid + ": " + st); + // Decrement the loop counter so that we process the current pid + // again the next time through the loop. + i--; + continue; + } + + while (curStatsIndex < NS) { + // This process has gone away! + final Stats st = allProcs.get(curStatsIndex); + st.rel_utime = 0; + st.rel_stime = 0; + st.removed = true; + workingProcs.add(st); + allProcs.remove(curStatsIndex); + NS--; + if (localLOGV) Log.v(TAG, "Removed pid " + st.pid + ": " + st); + } + + return pids; + } + + final public int getLastUserTime() { + return mRelUserTime; + } + + final public int getLastSystemTime() { + return mRelSystemTime; + } + + final public int getLastIoWaitTime() { + return mRelIoWaitTime; + } + + final public int getLastIrqTime() { + return mRelIrqTime; + } + + final public int getLastSoftIrqTime() { + return mRelSoftIrqTime; + } + + final public int getLastIdleTime() { + return mRelIdleTime; + } + + final public float getTotalCpuPercent() { + return ((float)(mRelUserTime+mRelSystemTime+mRelIrqTime)*100) + / (mRelUserTime+mRelSystemTime+mRelIrqTime+mRelIdleTime); + } + + final public int countWorkingStats() { + if (!mWorkingProcsSorted) { + Collections.sort(mWorkingProcs, sLoadComparator); + mWorkingProcsSorted = true; + } + return mWorkingProcs.size(); + } + + final public Stats getWorkingStats(int index) { + return mWorkingProcs.get(index); + } + + final public String printCurrentState() { + if (!mWorkingProcsSorted) { + Collections.sort(mWorkingProcs, sLoadComparator); + mWorkingProcsSorted = true; + } + + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + pw.print("Load: "); + pw.print(mLoad1); + pw.print(" / "); + pw.print(mLoad5); + pw.print(" / "); + pw.println(mLoad15); + + long now = SystemClock.uptimeMillis(); + + pw.print("CPU usage from "); + pw.print(now-mLastSampleTime); + pw.print("ms to "); + pw.print(now-mCurrentSampleTime); + pw.println("ms ago:"); + + final int totalTime = mRelUserTime + mRelSystemTime + mRelIoWaitTime + mRelIrqTime + + mRelSoftIrqTime + mRelIdleTime; + + int N = mWorkingProcs.size(); + for (int i=0; i<N; i++) { + Stats st = mWorkingProcs.get(i); + printProcessCPU(pw, st.added ? " +" : (st.removed ? " -": " "), + st.name, totalTime, st.rel_utime, st.rel_stime, 0, 0, 0); + if (!st.removed && st.workingThreads != null) { + int M = st.workingThreads.size(); + for (int j=0; j<M; j++) { + Stats tst = st.workingThreads.get(j); + printProcessCPU(pw, + tst.added ? " +" : (tst.removed ? " -": " "), + tst.name, totalTime, tst.rel_utime, tst.rel_stime, 0, 0, 0); + } + } + } + + printProcessCPU(pw, "", "TOTAL", totalTime, mRelUserTime, mRelSystemTime, mRelIoWaitTime, + mRelIrqTime, mRelSoftIrqTime); + + return sw.toString(); + } + + private void printProcessCPU(PrintWriter pw, String prefix, String label, int totalTime, + int user, int system, int iowait, int irq, int softIrq) { + pw.print(prefix); + pw.print(label); + pw.print(": "); + if (totalTime == 0) totalTime = 1; + pw.print(((user+system+iowait+irq+softIrq)*100)/totalTime); + pw.print("% = "); + pw.print((user*100)/totalTime); + pw.print("% user + "); + pw.print((system*100)/totalTime); + pw.print("% kernel"); + if (iowait > 0) { + pw.print(" + "); + pw.print((iowait*100)/totalTime); + pw.print("% iowait"); + } + if (irq > 0) { + pw.print(" + "); + pw.print((irq*100)/totalTime); + pw.print("% irq"); + } + if (softIrq > 0) { + pw.print(" + "); + pw.print((softIrq*100)/totalTime); + pw.print("% softirq"); + } + pw.println(); + } + + private String readFile(String file, char endChar) { + try { + FileInputStream is = new FileInputStream(file); + int len = is.read(mBuffer); + is.close(); + + if (len > 0) { + int i; + for (i=0; i<len; i++) { + if (mBuffer[i] == endChar) { + break; + } + } + return new String(mBuffer, 0, 0, i); + } + } catch (java.io.FileNotFoundException e) { + } catch (java.io.IOException e) { + } + return null; + } + + private void getName(Stats st, String cmdlineFile) { + String newName = st.baseName; + if (st.baseName == null || st.baseName.equals("app_process")) { + String cmdName = readFile(cmdlineFile, '\0'); + if (cmdName != null && cmdName.length() > 1) { + newName = cmdName; + int i = newName.lastIndexOf("/"); + if (i > 0 && i < newName.length()-1) { + newName = newName.substring(i+1); + } + } + } + if (st.name == null || !newName.equals(st.name)) { + st.name = newName; + st.nameWidth = onMeasureProcessName(st.name); + } + } +} + diff --git a/services/java/com/android/server/SensorService.java b/services/java/com/android/server/SensorService.java new file mode 100644 index 0000000..29b45ab --- /dev/null +++ b/services/java/com/android/server/SensorService.java @@ -0,0 +1,190 @@ +/* + * 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.Context; +import android.hardware.ISensorService; +import android.os.Binder; +import android.os.ParcelFileDescriptor; +import android.os.RemoteException; +import android.os.IBinder; +import android.util.Config; +import android.util.Log; + +import java.util.ArrayList; + +import com.android.internal.app.IBatteryStats; +import com.android.server.am.BatteryStatsService; + + +/** + * Class that manages the device's sensors. It register clients and activate + * the needed sensors. The sensor events themselves are not broadcasted from + * this service, instead, a file descriptor is provided to each client they + * can read events from. + */ + +class SensorService extends ISensorService.Stub { + static final String TAG = SensorService.class.getSimpleName(); + private static final boolean DEBUG = false; + private static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV; + private static final int SENSOR_DISABLE = -1; + + /** + * Battery statistics to be updated when sensors are enabled and diabled. + */ + final IBatteryStats mBatteryStats = BatteryStatsService.getService(); + + private final class Listener implements IBinder.DeathRecipient { + final IBinder mToken; + + int mSensors = 0; + int mDelay = 0x7FFFFFFF; + + Listener(IBinder token) { + mToken = token; + } + + void addSensor(int sensor, int delay) { + mSensors |= (1<<sensor); + if (mDelay > delay) + mDelay = delay; + } + + void removeSensor(int sensor) { + mSensors &= ~(1<<sensor); + } + + boolean hasSensor(int sensor) { + return ((mSensors & (1<<sensor)) != 0); + } + + public void binderDied() { + if (localLOGV) Log.d(TAG, "sensor listener died"); + synchronized(mListeners) { + mListeners.remove(this); + mToken.unlinkToDeath(this, 0); + // go through the lists of sensors used by the listener that + // died and deactivate them. + for (int sensor=0 ; sensor<32 && mSensors!=0 ; sensor++) { + if (hasSensor(sensor)) { + removeSensor(sensor); + try { + deactivateIfUnused(sensor); + } catch (RemoteException e) { + Log.w(TAG, "RemoteException in binderDied"); + } + } + } + mListeners.notify(); + } + } + } + + @SuppressWarnings("unused") + public SensorService(Context context) { + if (localLOGV) Log.d(TAG, "SensorService startup"); + _sensors_control_init(); + } + + public ParcelFileDescriptor getDataChanel() throws RemoteException { + return _sensors_control_open(); + } + + public boolean enableSensor(IBinder binder, String name, int sensor, int enable) + throws RemoteException { + if (localLOGV) Log.d(TAG, "enableSensor " + name + "(#" + sensor + ") " + enable); + + // Inform battery statistics service of status change + int uid = Binder.getCallingUid(); + long identity = Binder.clearCallingIdentity(); + if (enable == SENSOR_DISABLE) { + mBatteryStats.noteStopSensor(uid, sensor); + } else { + mBatteryStats.noteStartSensor(uid, sensor); + } + Binder.restoreCallingIdentity(identity); + + if (binder == null) throw new NullPointerException("listener is null in enableSensor"); + + synchronized(mListeners) { + if (enable!=SENSOR_DISABLE && !_sensors_control_activate(sensor, true)) { + Log.w(TAG, "could not enable sensor " + sensor); + return false; + } + + Listener l = null; + int minDelay = enable; + for (Listener listener : mListeners) { + if (binder == listener.mToken) { + l = listener; + } + if (minDelay > listener.mDelay) + minDelay = listener.mDelay; + } + + if (l == null && enable!=SENSOR_DISABLE) { + l = new Listener(binder); + binder.linkToDeath(l, 0); + mListeners.add(l); + mListeners.notify(); + } + + if (l == null) { + throw new NullPointerException("no Listener object in enableSensor"); + } + + if (minDelay >= 0) { + _sensors_control_set_delay(minDelay); + } + + if (enable != SENSOR_DISABLE) { + l.addSensor(sensor, enable); + } else { + l.removeSensor(sensor); + deactivateIfUnused(sensor); + if (l.mSensors == 0) { + mListeners.remove(l); + binder.unlinkToDeath(l, 0); + mListeners.notify(); + } + } + + if (mListeners.size() == 0) { + _sensors_control_wake(); + } + } + return true; + } + + void deactivateIfUnused(int sensor) throws RemoteException { + int size = mListeners.size(); + for (int i=0 ; i<size ; i++) { + if (mListeners.get(i).hasSensor(sensor)) + return; + } + _sensors_control_activate(sensor, false); + } + + ArrayList<Listener> mListeners = new ArrayList<Listener>(); + + private static native int _sensors_control_init(); + private static native ParcelFileDescriptor _sensors_control_open(); + private static native boolean _sensors_control_activate(int sensor, boolean activate); + private static native int _sensors_control_set_delay(int ms); + private static native int _sensors_control_wake(); +} diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java new file mode 100644 index 0000000..77383bd --- /dev/null +++ b/services/java/com/android/server/SystemServer.java @@ -0,0 +1,423 @@ +/* + * Copyright (C) 2006 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 com.android.server.am.ActivityManagerService; +import com.android.server.status.StatusBarService; + +import dalvik.system.PathClassLoader; +import dalvik.system.VMRuntime; + +import android.app.ActivityManagerNative; +import android.content.ComponentName; +import android.content.ContentResolver; +import android.content.ContentService; +import android.content.Context; +import android.content.Intent; +import android.content.pm.IPackageManager; +import android.database.ContentObserver; +import android.database.Cursor; +import android.media.AudioService; +import android.os.IBinder; +import android.os.Looper; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.provider.Contacts.People; +import android.provider.Settings; +import android.server.BluetoothA2dpService; +import android.server.BluetoothDeviceService; +import android.server.search.SearchManagerService; +import android.util.EventLog; +import android.util.Log; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; + +class ServerThread extends Thread { + private static final String TAG = "SystemServer"; + private final static boolean INCLUDE_DEMO = false; + + private static final int LOG_BOOT_PROGRESS_SYSTEM_RUN = 3010; + + private ContentResolver mContentResolver; + + private class AdbSettingsObserver extends ContentObserver { + public AdbSettingsObserver() { + super(null); + } + @Override + public void onChange(boolean selfChange) { + boolean enableAdb = (Settings.Secure.getInt(mContentResolver, + Settings.Secure.ADB_ENABLED, 0) > 0); + // setting this secure property will start or stop adbd + SystemProperties.set("persist.service.adb.enable", enableAdb ? "1" : "0"); + } + } + + @Override + public void run() { + EventLog.writeEvent(LOG_BOOT_PROGRESS_SYSTEM_RUN, + SystemClock.uptimeMillis()); + + ActivityManagerService.prepareTraceFile(false); // create dir + + Looper.prepare(); + + android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_FOREGROUND); + + String factoryTestStr = SystemProperties.get("ro.factorytest"); + int factoryTest = "".equals(factoryTestStr) ? SystemServer.FACTORY_TEST_OFF + : Integer.parseInt(factoryTestStr); + + PowerManagerService power = null; + IPackageManager pm = null; + Context context = null; + WindowManagerService wm = null; + BluetoothDeviceService bluetooth = null; + BluetoothA2dpService bluetoothA2dp = null; + HeadsetObserver headset = null; + + // Critical services... + try { + Log.i(TAG, "Starting Power Manager."); + power = new PowerManagerService(); + ServiceManager.addService(Context.POWER_SERVICE, power); + + Log.i(TAG, "Starting Activity Manager."); + context = ActivityManagerService.main(factoryTest); + + Log.i(TAG, "Starting telephony registry"); + ServiceManager.addService("telephony.registry", new TelephonyRegistry(context)); + + AttributeCache.init(context); + + Log.i(TAG, "Starting Package Manager."); + pm = PackageManagerService.main(context, + factoryTest != SystemServer.FACTORY_TEST_OFF); + + ActivityManagerService.setSystemProcess(); + + mContentResolver = context.getContentResolver(); + + Log.i(TAG, "Starting Content Manager."); + ContentService.main(context, + factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL); + + Log.i(TAG, "Starting System Content Providers."); + ActivityManagerService.installSystemProviders(); + + Log.i(TAG, "Starting Battery Service."); + BatteryService battery = new BatteryService(context); + ServiceManager.addService("battery", battery); + + // only initialize the power service after we have started the + // content providers and the batter service. + power.init(context, ActivityManagerService.getDefault(), battery); + + Log.i(TAG, "Starting Alarm Manager."); + AlarmManagerService alarm = new AlarmManagerService(context); + ServiceManager.addService(Context.ALARM_SERVICE, alarm); + + Watchdog.getInstance().init(context, battery, power, alarm, + ActivityManagerService.self()); + + // Sensor Service is needed by Window Manager, so this goes first + Log.i(TAG, "Starting Sensor Service."); + ServiceManager.addService(Context.SENSOR_SERVICE, new SensorService(context)); + + Log.i(TAG, "Starting Window Manager."); + wm = WindowManagerService.main(context, power, + factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL); + ServiceManager.addService(Context.WINDOW_SERVICE, wm); + + ((ActivityManagerService)ServiceManager.getService("activity")) + .setWindowManager(wm); + + // Skip Bluetooth if we have an emulator kernel + // TODO: Use a more reliable check to see if this product should + // support Bluetooth - see bug 988521 + if (SystemProperties.get("ro.kernel.qemu").equals("1")) { + Log.i(TAG, "Registering null Bluetooth Service (emulator)"); + ServiceManager.addService(Context.BLUETOOTH_SERVICE, null); + } else if (factoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) { + Log.i(TAG, "Registering null Bluetooth Service (factory test)"); + ServiceManager.addService(Context.BLUETOOTH_SERVICE, null); + } else { + Log.i(TAG, "Starting Bluetooth Service."); + bluetooth = new BluetoothDeviceService(context); + bluetooth.init(); + ServiceManager.addService(Context.BLUETOOTH_SERVICE, bluetooth); + bluetoothA2dp = new BluetoothA2dpService(context); + ServiceManager.addService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE, + bluetoothA2dp); + + int bluetoothOn = Settings.Secure.getInt(mContentResolver, + Settings.Secure.BLUETOOTH_ON, 0); + if (bluetoothOn > 0) { + bluetooth.enable(null); + } + } + + } catch (RuntimeException e) { + Log.e("System", "Failure starting core service", e); + } + + StatusBarService statusBar = null; + InputMethodManagerService imm = null; + GadgetService gadget = null; + + if (factoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { + try { + Log.i(TAG, "Starting Status Bar Service."); + statusBar = new StatusBarService(context); + ServiceManager.addService("statusbar", statusBar); + } catch (Throwable e) { + Log.e(TAG, "Failure starting StatusBarService", e); + } + + try { + Log.i(TAG, "Starting Clipboard Service."); + ServiceManager.addService("clipboard", new ClipboardService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Clipboard Service", e); + } + + try { + Log.i(TAG, "Starting Input Method Service."); + imm = new InputMethodManagerService(context, statusBar); + ServiceManager.addService(Context.INPUT_METHOD_SERVICE, imm); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Input Manager Service", e); + } + + try { + Log.i(TAG, "Starting Hardware Service."); + ServiceManager.addService("hardware", new HardwareService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Hardware Service", e); + } + + try { + Log.i(TAG, "Starting NetStat Service."); + ServiceManager.addService("netstat", new NetStatService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting NetStat Service", e); + } + + try { + Log.i(TAG, "Starting Connectivity Service."); + ServiceManager.addService(Context.CONNECTIVITY_SERVICE, + ConnectivityService.getInstance(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Connectivity Service", e); + } + + try { + Log.i(TAG, "Starting Notification Manager."); + ServiceManager.addService(Context.NOTIFICATION_SERVICE, + new NotificationManagerService(context, statusBar)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Notification Manager", e); + } + + try { + // MountService must start after NotificationManagerService + Log.i(TAG, "Starting Mount Service."); + ServiceManager.addService("mount", new MountService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Mount Service", e); + } + + try { + Log.i(TAG, "Starting DeviceStorageMonitor service"); + ServiceManager.addService(DeviceStorageMonitorService.SERVICE, + new DeviceStorageMonitorService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting DeviceStorageMonitor service", e); + } + + try { + Log.i(TAG, "Starting Location Manager."); + ServiceManager.addService(Context.LOCATION_SERVICE, new LocationManagerService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Location Manager", e); + } + + try { + Log.i(TAG, "Starting Search Service."); + ServiceManager.addService( Context.SEARCH_SERVICE, new SearchManagerService(context) ); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Search Service", e); + } + + if (INCLUDE_DEMO) { + Log.i(TAG, "Installing demo data..."); + (new DemoThread(context)).start(); + } + + try { + Log.i(TAG, "Starting Checkin Service."); + Intent intent = new Intent().setComponent(new ComponentName( + "com.google.android.server.checkin", + "com.google.android.server.checkin.CheckinService")); + if (context.startService(intent) == null) { + Log.w(TAG, "Using fallback Checkin Service."); + ServiceManager.addService("checkin", new FallbackCheckinService(context)); + } + } catch (Throwable e) { + Log.e(TAG, "Failure starting Checkin Service", e); + } + + try { + Log.i(TAG, "Starting Wallpaper Service"); + ServiceManager.addService(Context.WALLPAPER_SERVICE, new WallpaperService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Wallpaper Service", e); + } + + try { + Log.i(TAG, "Starting Audio Service"); + ServiceManager.addService(Context.AUDIO_SERVICE, new AudioService(context)); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Audio Service", e); + } + + try { + Log.i(TAG, "Starting HeadsetObserver"); + // Listen for wired headset changes + headset = new HeadsetObserver(context); + } catch (Throwable e) { + Log.e(TAG, "Failure starting HeadsetObserver", e); + } + + try { + Log.i(TAG, "Starting Gadget Service"); + gadget = new GadgetService(context); + ServiceManager.addService(Context.GADGET_SERVICE, gadget); + } catch (Throwable e) { + Log.e(TAG, "Failure starting Gadget Service", e); + } + + try { + com.android.server.status.StatusBarPolicy.installIcons(context, statusBar); + } catch (Throwable e) { + Log.e(TAG, "Failure installing status bar icons", e); + } + } + + // make sure the ADB_ENABLED setting value matches the secure property value + Settings.Secure.putInt(mContentResolver, Settings.Secure.ADB_ENABLED, + "1".equals(SystemProperties.get("persist.service.adb.enable")) ? 1 : 0); + + // register observer to listen for settings changes + mContentResolver.registerContentObserver(Settings.Secure.getUriFor(Settings.Secure.ADB_ENABLED), + false, new AdbSettingsObserver()); + + // It is now time to start up the app processes... + boolean safeMode = wm.detectSafeMode(); + if (statusBar != null) { + statusBar.systemReady(); + } + if (imm != null) { + imm.systemReady(); + } + wm.systemReady(); + power.systemReady(); + try { + pm.systemReady(); + } catch (RemoteException e) { + } + if (gadget != null) { + gadget.systemReady(safeMode); + } + + // After making the following code, third party code may be running... + try { + ActivityManagerNative.getDefault().systemReady(); + } catch (RemoteException e) { + } + + Watchdog.getInstance().start(); + + Looper.loop(); + Log.d(TAG, "System ServerThread is exiting!"); + } +} + +class DemoThread extends Thread +{ + DemoThread(Context context) + { + mContext = context; + } + + @Override + public void run() + { + try { + Cursor c = mContext.getContentResolver().query(People.CONTENT_URI, null, null, null, null); + boolean hasData = c != null && c.moveToFirst(); + if (c != null) { + c.deactivate(); + } + if (!hasData) { + DemoDataSet dataset = new DemoDataSet(); + dataset.add(mContext); + } + } catch (Throwable e) { + Log.e("SystemServer", "Failure installing demo data", e); + } + + } + + Context mContext; +} + +public class SystemServer +{ + private static final String TAG = "SystemServer"; + + public static final int FACTORY_TEST_OFF = 0; + public static final int FACTORY_TEST_LOW_LEVEL = 1; + public static final int FACTORY_TEST_HIGH_LEVEL = 2; + + /** + * This method is called from Zygote to initialize the system. This will cause the native + * services (SurfaceFlinger, AudioFlinger, etc..) to be started. After that it will call back + * up into init2() to start the Android services. + */ + native public static void init1(String[] args); + + public static void main(String[] args) { + // The system server has to run all of the time, so it needs to be + // as efficient as possible with its memory usage. + VMRuntime.getRuntime().setTargetHeapUtilization(0.8f); + + System.loadLibrary("android_servers"); + init1(args); + } + + public static final void init2() { + Log.i(TAG, "Entered the Android system server!"); + Thread thr = new ServerThread(); + thr.setName("android.server.ServerThread"); + thr.start(); + } +} diff --git a/services/java/com/android/server/TelephonyRegistry.java b/services/java/com/android/server/TelephonyRegistry.java new file mode 100644 index 0000000..5e5fb93 --- /dev/null +++ b/services/java/com/android/server/TelephonyRegistry.java @@ -0,0 +1,462 @@ +/* + * Copyright (C) 2007 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.Context; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.os.Binder; +import android.os.Bundle; +import android.os.IBinder; +import android.os.RemoteException; +import android.telephony.CellLocation; +import android.telephony.PhoneStateListener; +import android.telephony.ServiceState; +import android.telephony.TelephonyManager; +import android.text.TextUtils; + +import java.util.ArrayList; +import java.io.FileDescriptor; +import java.io.PrintWriter; + +import com.android.internal.app.IBatteryStats; +import com.android.internal.telephony.ITelephonyRegistry; +import com.android.internal.telephony.IPhoneStateListener; +import com.android.internal.telephony.DefaultPhoneNotifier; +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneStateIntentReceiver; +import com.android.internal.telephony.TelephonyIntents; +import com.android.server.am.BatteryStatsService; + + +/** + * Since phone process can be restarted, this class provides a centralized + * place that applications can register and be called back from. + */ +class TelephonyRegistry extends ITelephonyRegistry.Stub { + private static final String TAG = "TelephonyRegistry"; + + private static class Record { + String pkgForDebug; + IBinder binder; + IPhoneStateListener callback; + int events; + } + + private final Context mContext; + private final ArrayList<Record> mRecords = new ArrayList(); + private final IBatteryStats mBatteryStats; + + private int mCallState = TelephonyManager.CALL_STATE_IDLE; + private String mCallIncomingNumber = ""; + private ServiceState mServiceState = new ServiceState(); + private int mSignalStrength = -1; + private boolean mMessageWaiting = false; + private boolean mCallForwarding = false; + private int mDataActivity = TelephonyManager.DATA_ACTIVITY_NONE; + private int mDataConnectionState = TelephonyManager.DATA_CONNECTED; + private boolean mDataConnectionPossible = false; + private String mDataConnectionReason = ""; + private String mDataConnectionApn = ""; + private String mDataConnectionInterfaceName = ""; + private Bundle mCellLocation = new Bundle(); + + // we keep a copy of all of the sate so we can send it out when folks register for it + // + // In these calls we call with the lock held. This is safe becasuse remote + // calls go through a oneway interface and local calls going through a handler before + // they get to app code. + + TelephonyRegistry(Context context) { + CellLocation.getEmpty().fillInNotifierBundle(mCellLocation); + mContext = context; + mBatteryStats = BatteryStatsService.getService(); + } + + public void listen(String pkgForDebug, IPhoneStateListener callback, int events, + boolean notifyNow) { + //Log.d(TAG, "listen pkg=" + pkgForDebug + " events=0x" + Integer.toHexString(events)); + if (events != 0) { + // check permissions + if ((events & PhoneStateListener.LISTEN_CELL_LOCATION) != 0) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.ACCESS_COARSE_LOCATION, null); + + } + + synchronized (mRecords) { + // register + Record r = null; + find_and_add: { + IBinder b = callback.asBinder(); + final int N = mRecords.size(); + for (int i=0; i<N; i++) { + r = mRecords.get(i); + if (b == r.binder) { + break find_and_add; + } + } + r = new Record(); + r.binder = b; + r.callback = callback; + r.pkgForDebug = pkgForDebug; + mRecords.add(r); + } + int send = events & (events ^ r.events); + r.events = events; + if (notifyNow) { + if ((events & PhoneStateListener.LISTEN_SERVICE_STATE) != 0) { + sendServiceState(r, mServiceState); + } + if ((events & PhoneStateListener.LISTEN_SIGNAL_STRENGTH) != 0) { + try { + r.callback.onSignalStrengthChanged(mSignalStrength); + } catch (RemoteException ex) { + remove(r.binder); + } + } + if ((events & PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR) != 0) { + try { + r.callback.onMessageWaitingIndicatorChanged(mMessageWaiting); + } catch (RemoteException ex) { + remove(r.binder); + } + } + if ((events & PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR) != 0) { + try { + r.callback.onCallForwardingIndicatorChanged(mCallForwarding); + } catch (RemoteException ex) { + remove(r.binder); + } + } + if ((events & PhoneStateListener.LISTEN_CELL_LOCATION) != 0) { + sendCellLocation(r, mCellLocation); + } + if ((events & PhoneStateListener.LISTEN_CALL_STATE) != 0) { + try { + r.callback.onCallStateChanged(mCallState, mCallIncomingNumber); + } catch (RemoteException ex) { + remove(r.binder); + } + } + if ((events & PhoneStateListener.LISTEN_DATA_CONNECTION_STATE) != 0) { + try { + r.callback.onDataConnectionStateChanged(mDataConnectionState); + } catch (RemoteException ex) { + remove(r.binder); + } + } + if ((events & PhoneStateListener.LISTEN_DATA_ACTIVITY) != 0) { + try { + r.callback.onDataActivity(mDataActivity); + } catch (RemoteException ex) { + remove(r.binder); + } + } + } + } + } else { + remove(callback.asBinder()); + } + } + + private void remove(IBinder binder) { + synchronized (mRecords) { + final int N = mRecords.size(); + for (int i=0; i<N; i++) { + if (mRecords.get(i).binder == binder) { + mRecords.remove(i); + return; + } + } + } + } + + public void notifyCallState(int state, String incomingNumber) { + synchronized (mRecords) { + mCallState = state; + mCallIncomingNumber = incomingNumber; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_CALL_STATE) != 0) { + try { + r.callback.onCallStateChanged(state, incomingNumber); + } catch (RemoteException ex) { + remove(r.binder); + } + } + } + } + broadcastCallStateChanged(state, incomingNumber); + } + + public void notifyServiceState(ServiceState state) { + synchronized (mRecords) { + mServiceState = state; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_SERVICE_STATE) != 0) { + sendServiceState(r, state); + } + } + } + broadcastServiceStateChanged(state); + } + + public void notifySignalStrength(int signalStrengthASU) { + synchronized (mRecords) { + mSignalStrength = signalStrengthASU; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_SIGNAL_STRENGTH) != 0) { + try { + r.callback.onSignalStrengthChanged(signalStrengthASU); + } catch (RemoteException ex) { + remove(r.binder); + } + } + } + } + broadcastSignalStrengthChanged(signalStrengthASU); + } + + public void notifyMessageWaitingChanged(boolean mwi) { + synchronized (mRecords) { + mMessageWaiting = mwi; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR) != 0) { + try { + r.callback.onMessageWaitingIndicatorChanged(mwi); + } catch (RemoteException ex) { + remove(r.binder); + } + } + } + } + } + + public void notifyCallForwardingChanged(boolean cfi) { + synchronized (mRecords) { + mCallForwarding = cfi; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR) != 0) { + try { + r.callback.onCallForwardingIndicatorChanged(cfi); + } catch (RemoteException ex) { + remove(r.binder); + } + } + } + } + } + + public void notifyDataActivity(int state) { + synchronized (mRecords) { + mDataActivity = state; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_DATA_ACTIVITY) != 0) { + try { + r.callback.onDataActivity(state); + } catch (RemoteException ex) { + remove(r.binder); + } + } + } + } + } + + public void notifyDataConnection(int state, boolean isDataConnectivityPissible, + String reason, String apn, String interfaceName) { + synchronized (mRecords) { + mDataConnectionState = state; + mDataConnectionPossible = isDataConnectivityPissible; + mDataConnectionReason = reason; + mDataConnectionApn = apn; + mDataConnectionInterfaceName = interfaceName; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_DATA_CONNECTION_STATE) != 0) { + try { + r.callback.onDataConnectionStateChanged(state); + } catch (RemoteException ex) { + remove(r.binder); + } + } + } + } + broadcastDataConnectionStateChanged(state, isDataConnectivityPissible, + reason, apn, interfaceName); + } + + public void notifyDataConnectionFailed(String reason) { + /* + * This is commented out because there is on onDataConnectionFailed callback + * on PhoneStateListener. There should be. + synchronized (mRecords) { + mDataConnectionFailedReason = reason; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_DATA_CONNECTION_FAILED) != 0) { + // XXX + } + } + } + */ + broadcastDataConnectionFailed(reason); + } + + public void notifyCellLocation(Bundle cellLocation) { + synchronized (mRecords) { + mCellLocation = cellLocation; + final int N = mRecords.size(); + for (int i=N-1; i>=0; i--) { + Record r = mRecords.get(i); + if ((r.events & PhoneStateListener.LISTEN_CELL_LOCATION) != 0) { + sendCellLocation(r, cellLocation); + } + } + } + } + + // + // the new callback broadcasting + // + // copy the service state object so they can't mess it up in the local calls + // + public void sendServiceState(Record r, ServiceState state) { + try { + r.callback.onServiceStateChanged(new ServiceState(state)); + } catch (RemoteException ex) { + remove(r.binder); + } + } + + public void sendCellLocation(Record r, Bundle cellLocation) { + try { + r.callback.onCellLocationChanged(new Bundle(cellLocation)); + } catch (RemoteException ex) { + remove(r.binder); + } + } + + + @Override + public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump telephony.registry from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + synchronized (mRecords) { + final int N = mRecords.size(); + pw.println("last known state:"); + pw.println(" mCallState=" + mCallState); + pw.println(" mCallIncomingNumber=" + mCallIncomingNumber); + pw.println(" mServiceState=" + mServiceState); + pw.println(" mSignalStrength=" + mSignalStrength); + pw.println(" mMessageWaiting=" + mMessageWaiting); + pw.println(" mCallForwarding=" + mCallForwarding); + pw.println(" mDataActivity=" + mDataActivity); + pw.println(" mDataConnectionState=" + mDataConnectionState); + pw.println(" mDataConnectionPossible=" + mDataConnectionPossible); + pw.println(" mDataConnectionReason=" + mDataConnectionReason); + pw.println(" mDataConnectionApn=" + mDataConnectionApn); + pw.println(" mDataConnectionInterfaceName=" + mDataConnectionInterfaceName); + pw.println(" mCellLocation=" + mCellLocation); + pw.println("registrations: count=" + N); + for (int i=0; i<N; i++) { + Record r = mRecords.get(i); + pw.println(" " + r.pkgForDebug + " 0x" + Integer.toHexString(r.events)); + } + } + } + + + // + // the legacy intent broadcasting + // + + private void broadcastServiceStateChanged(ServiceState state) { + Intent intent = new Intent(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED); + Bundle data = new Bundle(); + state.fillInNotifierBundle(data); + intent.putExtras(data); + mContext.sendStickyBroadcast(intent); + } + + private void broadcastSignalStrengthChanged(int asu) { + Intent intent = new Intent(TelephonyIntents.ACTION_SIGNAL_STRENGTH_CHANGED); + intent.putExtra(PhoneStateIntentReceiver.INTENT_KEY_ASU, asu); + mContext.sendStickyBroadcast(intent); + } + + private void broadcastCallStateChanged(int state, String incomingNumber) { + long ident = Binder.clearCallingIdentity(); + try { + if (state == TelephonyManager.CALL_STATE_IDLE) { + mBatteryStats.notePhoneOff(); + } else { + mBatteryStats.notePhoneOn(); + } + } catch (RemoteException e) { + } finally { + Binder.restoreCallingIdentity(ident); + } + + Intent intent = new Intent(TelephonyManager.ACTION_PHONE_STATE_CHANGED); + intent.putExtra(Phone.STATE_KEY, + DefaultPhoneNotifier.convertCallState(state).toString()); + if (!TextUtils.isEmpty(incomingNumber)) { + intent.putExtra(TelephonyManager.EXTRA_INCOMING_NUMBER, incomingNumber); + } + mContext.sendBroadcast(intent, android.Manifest.permission.READ_PHONE_STATE); + } + + private void broadcastDataConnectionStateChanged(int state, boolean isDataConnectivityPossible, + String reason, String apn, String interfaceName) { + Intent intent = new Intent(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED); + intent.putExtra(Phone.STATE_KEY, DefaultPhoneNotifier.convertDataState(state).toString()); + if (!isDataConnectivityPossible) { + intent.putExtra(Phone.NETWORK_UNAVAILABLE_KEY, true); + } + if (reason != null) { + intent.putExtra(Phone.STATE_CHANGE_REASON_KEY, reason); + } + intent.putExtra(Phone.DATA_APN_KEY, apn); + intent.putExtra(Phone.DATA_IFACE_NAME_KEY, interfaceName); + mContext.sendStickyBroadcast(intent); + } + + private void broadcastDataConnectionFailed(String reason) { + Intent intent = new Intent(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED); + intent.putExtra(Phone.FAILURE_REASON_KEY, reason); + mContext.sendStickyBroadcast(intent); + } +} diff --git a/services/java/com/android/server/ViewServer.java b/services/java/com/android/server/ViewServer.java new file mode 100644 index 0000000..4201b39 --- /dev/null +++ b/services/java/com/android/server/ViewServer.java @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2007 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.util.Log; + +import java.net.ServerSocket; +import java.net.Socket; +import java.net.InetAddress; +import java.io.IOException; +import java.io.BufferedReader; +import java.io.InputStreamReader; + +/** + * The ViewServer is local socket server that can be used to communicate with the + * views of the opened windows. Communication with the views is ensured by the + * {@link com.android.server.WindowManagerService} and is a cross-process operation. + * + * {@hide} + */ +class ViewServer implements Runnable { + /** + * The default port used to start view servers. + */ + public static final int VIEW_SERVER_DEFAULT_PORT = 4939; + + // Debug facility + private static final String LOG_TAG = "ViewServer"; + + // Protocol commands + // Lists all of the available windows in the system + private static final String COMMAND_WINDOW_MANAGER_LIST = "LIST"; + + private ServerSocket mServer; + private Thread mThread; + + private final WindowManagerService mWindowManager; + private final int mPort; + + /** + * Creates a new ViewServer associated with the specified window manager. + * The server uses the default port {@link #VIEW_SERVER_DEFAULT_PORT}. The server + * is not started by default. + * + * @param windowManager The window manager used to communicate with the views. + * + * @see #start() + */ + ViewServer(WindowManagerService windowManager) { + this(windowManager, VIEW_SERVER_DEFAULT_PORT); + } + + /** + * Creates a new ViewServer associated with the specified window manager on the + * specified local port. The server is not started by default. + * + * @param windowManager The window manager used to communicate with the views. + * @param port The port for the server to listen to. + * + * @see #start() + */ + ViewServer(WindowManagerService windowManager, int port) { + mWindowManager = windowManager; + mPort = port; + } + + /** + * Starts the server. + * + * @return True if the server was successfully created, or false if it already exists. + * @throws IOException If the server cannot be created. + * + * @see #stop() + * @see #isRunning() + * @see WindowManagerService#startViewServer(int) + */ + boolean start() throws IOException { + if (mThread != null) { + return false; + } + + mServer = new ServerSocket(mPort, 1, InetAddress.getLocalHost()); + mThread = new Thread(this, "Remote View Server [port=" + mPort + "]"); + mThread.start(); + + return true; + } + + /** + * Stops the server. + * + * @return True if the server was stopped, false if an error occured or if the + * server wasn't started. + * + * @see #start() + * @see #isRunning() + * @see WindowManagerService#stopViewServer() + */ + boolean stop() { + if (mThread != null) { + mThread.interrupt(); + mThread = null; + try { + mServer.close(); + mServer = null; + return true; + } catch (IOException e) { + Log.w(LOG_TAG, "Could not close the view server"); + } + } + return false; + } + + /** + * Indicates whether the server is currently running. + * + * @return True if the server is running, false otherwise. + * + * @see #start() + * @see #stop() + * @see WindowManagerService#isViewServerRunning() + */ + boolean isRunning() { + return mThread != null && mThread.isAlive(); + } + + /** + * Main server loop. + */ + public void run() { + final ServerSocket server = mServer; + + while (Thread.currentThread() == mThread) { + Socket client = null; + // Any uncaught exception will crash the system process + try { + client = server.accept(); + + BufferedReader in = null; + try { + in = new BufferedReader(new InputStreamReader(client.getInputStream()), 1024); + + final String request = in.readLine(); + + String command; + String parameters; + + int index = request.indexOf(' '); + if (index == -1) { + command = request; + parameters = ""; + } else { + command = request.substring(0, index); + parameters = request.substring(index + 1); + } + + boolean result; + if (COMMAND_WINDOW_MANAGER_LIST.equalsIgnoreCase(command)) { + result = mWindowManager.viewServerListWindows(client); + } else { + result = mWindowManager.viewServerWindowCommand(client, + command, parameters); + } + + if (!result) { + Log.w(LOG_TAG, "An error occured with the command: " + command); + } + } finally { + if (in != null) { + in.close(); + } + } + } catch (Exception e) { + Log.w(LOG_TAG, "Connection error: ", e); + } finally { + if (client != null) { + try { + client.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } + } + } +} diff --git a/services/java/com/android/server/WallpaperService.java b/services/java/com/android/server/WallpaperService.java new file mode 100644 index 0000000..5532894 --- /dev/null +++ b/services/java/com/android/server/WallpaperService.java @@ -0,0 +1,192 @@ +/* + * 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 static android.os.FileObserver.*; +import static android.os.ParcelFileDescriptor.*; +import android.app.IWallpaperService; +import android.app.IWallpaperServiceCallback; +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; +import android.content.pm.PackageManager; +import android.os.Binder; +import android.os.RemoteException; +import android.os.FileObserver; +import android.os.ParcelFileDescriptor; +import android.os.RemoteCallbackList; +import android.util.Config; +import android.util.Log; + +import java.io.File; +import java.io.FileNotFoundException; + +class WallpaperService extends IWallpaperService.Stub { + private static final String TAG = WallpaperService.class.getSimpleName(); + + private static final File WALLPAPER_DIR = new File( + "/data/data/com.android.settings/files"); + private static final String WALLPAPER = "wallpaper"; + private static final File WALLPAPER_FILE = new File(WALLPAPER_DIR, WALLPAPER); + + private static final String PREFERENCES = "wallpaper-hints"; + + private static final String HINT_WIDTH = "hintWidth"; + private static final String HINT_HEIGHT = "hintHeight"; + + /** + * List of callbacks registered they should each be notified + * when the wallpaper is changed. + */ + private final RemoteCallbackList<IWallpaperServiceCallback> mCallbacks + = new RemoteCallbackList<IWallpaperServiceCallback>(); + + /** + * Observes the wallpaper for changes and notifies all IWallpaperServiceCallbacks + * that the wallpaper has changed. The CREATE is triggered when there is no + * wallpaper set and is created for the first time. The CLOSE_WRITE is triggered + * everytime the wallpaper is changed. + */ + private final FileObserver mWallpaperObserver = new FileObserver( + WALLPAPER_DIR.getAbsolutePath(), CREATE | CLOSE_WRITE) { + @Override + public void onEvent(int event, String path) { + if (path == null) { + return; + } + + File changedFile = new File(WALLPAPER_DIR, path); + if (WALLPAPER_FILE.equals(changedFile)) { + notifyCallbacks(); + } + } + }; + + private final Context mContext; + + private int mWidth = -1; + private int mHeight = -1; + + public WallpaperService(Context context) { + if (Config.LOGD) Log.d(TAG, "WallpaperService startup"); + mContext = context; + createFilesDir(); + mWallpaperObserver.startWatching(); + + SharedPreferences preferences = mContext.getSharedPreferences(PREFERENCES, + Context.MODE_PRIVATE); + mWidth = preferences.getInt(HINT_WIDTH, -1); + mHeight = preferences.getInt(HINT_HEIGHT, -1); + } + + @Override + protected void finalize() throws Throwable { + super.finalize(); + mWallpaperObserver.stopWatching(); + } + + public void clearWallpaper() { + File f = WALLPAPER_FILE; + if (f.exists()) { + f.delete(); + } + } + + public void setDimensionHints(int width, int height) throws RemoteException { + checkPermission(android.Manifest.permission.SET_WALLPAPER_HINTS); + + if (width <= 0 || height <= 0) { + throw new IllegalArgumentException("width and height must be > 0"); + } + + if (width != mWidth || height != mHeight) { + mWidth = width; + mHeight = height; + + SharedPreferences preferences = mContext.getSharedPreferences(PREFERENCES, + Context.MODE_PRIVATE); + + final SharedPreferences.Editor editor = preferences.edit(); + editor.putInt(HINT_WIDTH, width); + editor.putInt(HINT_HEIGHT, height); + editor.commit(); + } + } + + public int getWidthHint() throws RemoteException { + return mWidth; + } + + public int getHeightHint() throws RemoteException { + return mHeight; + } + + public ParcelFileDescriptor getWallpaper(IWallpaperServiceCallback cb) { + try { + mCallbacks.register(cb); + File f = WALLPAPER_FILE; + if (!f.exists()) { + return null; + } + return ParcelFileDescriptor.open(f, MODE_READ_ONLY); + } catch (FileNotFoundException e) { + + /* Shouldn't happen as we check to see if the file exists */ + if (Config.LOGD) Log.d(TAG, "Error getting wallpaper", e); + } + return null; + } + + public ParcelFileDescriptor setWallpaper() { + checkPermission(android.Manifest.permission.SET_WALLPAPER); + try { + return ParcelFileDescriptor.open(WALLPAPER_FILE, MODE_CREATE|MODE_READ_WRITE); + } catch (FileNotFoundException e) { + if (Config.LOGD) Log.d(TAG, "Error setting wallpaper", e); + } + return null; + } + + private void createFilesDir() { + if (!WALLPAPER_DIR.exists()) { + WALLPAPER_DIR.mkdirs(); + } + } + + private void notifyCallbacks() { + final int n = mCallbacks.beginBroadcast(); + for (int i = 0; i < n; i++) { + try { + mCallbacks.getBroadcastItem(i).onWallpaperChanged(); + } catch (RemoteException e) { + + // The RemoteCallbackList will take care of removing + // the dead object for us. + } + } + mCallbacks.finishBroadcast(); + final Intent intent = new Intent(Intent.ACTION_WALLPAPER_CHANGED); + mContext.sendBroadcast(intent); + } + + private void checkPermission(String permission) { + if (PackageManager.PERMISSION_GRANTED != mContext.checkCallingOrSelfPermission(permission)) { + throw new SecurityException("Access denied to process: " + Binder.getCallingPid() + + ", must have permission " + permission); + } + } +} diff --git a/services/java/com/android/server/Watchdog.java b/services/java/com/android/server/Watchdog.java new file mode 100644 index 0000000..fef3598 --- /dev/null +++ b/services/java/com/android/server/Watchdog.java @@ -0,0 +1,855 @@ +/* + * 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 com.android.server.am.ActivityManagerService; + +import android.app.AlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.os.Debug; +import android.os.Handler; +import android.os.Message; +import android.os.Process; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.provider.Settings; +import android.util.Config; +import android.util.EventLog; +import android.util.Log; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Calendar; + +/** This class calls its monitor every minute. Killing this process if they don't return **/ +public class Watchdog extends Thread { + static final String TAG = "Watchdog"; + static final boolean localLOGV = false || Config.LOGV; + + // Set this to true to use debug default values. + static final boolean DB = false; + + static final int MONITOR = 2718; + static final int GLOBAL_PSS = 2719; + + static final int TIME_TO_WAIT = DB ? 15*1000 : 60*1000; + static final int EVENT_LOG_TAG = 2802; + static final int EVENT_LOG_PROC_PSS_TAG = 2803; + static final int EVENT_LOG_SOFT_RESET_TAG = 2804; + static final int EVENT_LOG_HARD_RESET_TAG = 2805; + static final int EVENT_LOG_PSS_STATS_TAG = 2806; + static final int EVENT_LOG_PROC_STATS_TAG = 2807; + static final int EVENT_LOG_SCHEDULED_REBOOT_TAG = 2808; + static final int EVENT_LOG_MEMINFO_TAG = 2809; + static final int EVENT_LOG_VMSTAT_TAG = 2810; + static final int EVENT_LOG_REQUESTED_REBOOT_TAG = 2811; + + static final int MEMCHECK_DEFAULT_INTERVAL = DB ? 30 : 30*60; // 30 minutes + static final int MEMCHECK_DEFAULT_LOG_REALTIME_INTERVAL = DB ? 60 : 2*60*60; // 2 hours + static final int MEMCHECK_DEFAULT_SYSTEM_SOFT_THRESHOLD = (DB ? 10:16)*1024*1024; // 16MB + static final int MEMCHECK_DEFAULT_SYSTEM_HARD_THRESHOLD = (DB ? 14:20)*1024*1024; // 20MB + static final int MEMCHECK_DEFAULT_PHONE_SOFT_THRESHOLD = (DB ? 4:8)*1024*1024; // 8MB + static final int MEMCHECK_DEFAULT_PHONE_HARD_THRESHOLD = (DB ? 8:12)*1024*1024; // 12MB + + static final int MEMCHECK_DEFAULT_EXEC_START_TIME = 1*60*60; // 1:00am + static final int MEMCHECK_DEFAULT_EXEC_END_TIME = 5*60*60; // 5:00am + static final int MEMCHECK_DEFAULT_MIN_SCREEN_OFF = DB ? 1*60 : 5*60; // 5 minutes + static final int MEMCHECK_DEFAULT_MIN_ALARM = DB ? 1*60 : 3*60; // 3 minutes + static final int MEMCHECK_DEFAULT_RECHECK_INTERVAL = DB ? 1*60 : 5*60; // 5 minutes + + static final int REBOOT_DEFAULT_INTERVAL = DB ? 1 : 0; // never force reboot + static final int REBOOT_DEFAULT_START_TIME = 3*60*60; // 3:00am + static final int REBOOT_DEFAULT_WINDOW = 60*60; // within 1 hour + + static final String CHECKUP_ACTION = "com.android.service.Watchdog.CHECKUP"; + static final String REBOOT_ACTION = "com.android.service.Watchdog.REBOOT"; + + static Watchdog sWatchdog; + + /* This handler will be used to post message back onto the main thread */ + final Handler mHandler; + final Runnable mGlobalPssCollected; + final ArrayList<Monitor> mMonitors = new ArrayList<Monitor>(); + ContentResolver mResolver; + BatteryService mBattery; + PowerManagerService mPower; + AlarmManagerService mAlarm; + ActivityManagerService mActivity; + boolean mCompleted; + boolean mForceKillSystem; + Monitor mCurrentMonitor; + + PssRequestor mPhoneReq; + int mPhonePid; + int mPhonePss; + + long mLastMemCheckTime = -(MEMCHECK_DEFAULT_INTERVAL*1000); + boolean mHavePss; + long mLastMemCheckRealtime = -(MEMCHECK_DEFAULT_LOG_REALTIME_INTERVAL*1000); + boolean mHaveGlobalPss; + final MemMonitor mSystemMemMonitor = new MemMonitor("system", + Settings.Gservices.MEMCHECK_SYSTEM_ENABLED, + Settings.Gservices.MEMCHECK_SYSTEM_SOFT_THRESHOLD, + MEMCHECK_DEFAULT_SYSTEM_SOFT_THRESHOLD, + Settings.Gservices.MEMCHECK_SYSTEM_HARD_THRESHOLD, + MEMCHECK_DEFAULT_SYSTEM_HARD_THRESHOLD); + final MemMonitor mPhoneMemMonitor = new MemMonitor("com.android.phone", + Settings.Gservices.MEMCHECK_PHONE_ENABLED, + Settings.Gservices.MEMCHECK_PHONE_SOFT_THRESHOLD, + MEMCHECK_DEFAULT_PHONE_SOFT_THRESHOLD, + Settings.Gservices.MEMCHECK_PHONE_HARD_THRESHOLD, + MEMCHECK_DEFAULT_PHONE_HARD_THRESHOLD); + + final Calendar mCalendar = Calendar.getInstance(); + long mMemcheckLastTime; + long mMemcheckExecStartTime; + long mMemcheckExecEndTime; + int mMinScreenOff = MEMCHECK_DEFAULT_MIN_SCREEN_OFF; + int mMinAlarm = MEMCHECK_DEFAULT_MIN_ALARM; + boolean mNeedScheduledCheck; + PendingIntent mCheckupIntent; + PendingIntent mRebootIntent; + + long mBootTime; + int mRebootInterval; + + boolean mReqRebootNoWait; // should wait for one interval before reboot? + int mReqRebootInterval = -1; // >= 0 if a reboot has been requested + int mReqRebootStartTime = -1; // >= 0 if a specific start time has been requested + int mReqRebootWindow = -1; // >= 0 if a specific window has been requested + int mReqMinScreenOff = -1; // >= 0 if a specific screen off time has been requested + int mReqMinNextAlarm = -1; // >= 0 if specific time to next alarm has been requested + int mReqRecheckInterval= -1; // >= 0 if a specific recheck interval has been requested + + /** + * This class monitors the memory in a particular process. + */ + final class MemMonitor { + final String mProcessName; + final String mEnabledSetting; + final String mSoftSetting; + final String mHardSetting; + + int mSoftThreshold; + int mHardThreshold; + boolean mEnabled; + long mLastPss; + + static final int STATE_OK = 0; + static final int STATE_SOFT = 1; + static final int STATE_HARD = 2; + int mState; + + MemMonitor(String processName, String enabledSetting, + String softSetting, int defSoftThreshold, + String hardSetting, int defHardThreshold) { + mProcessName = processName; + mEnabledSetting = enabledSetting; + mSoftSetting = softSetting; + mHardSetting = hardSetting; + mSoftThreshold = defSoftThreshold; + mHardThreshold = defHardThreshold; + } + + void retrieveSettings(ContentResolver resolver) { + mSoftThreshold = Settings.Gservices.getInt( + resolver, mSoftSetting, mSoftThreshold); + mHardThreshold = Settings.Gservices.getInt( + resolver, mHardSetting, mHardThreshold); + mEnabled = Settings.Gservices.getInt( + resolver, mEnabledSetting, 0) != 0; + } + + boolean checkLocked(long curTime, int pid, int pss) { + mLastPss = pss; + if (mLastPss < mSoftThreshold) { + mState = STATE_OK; + } else if (mLastPss < mHardThreshold) { + mState = STATE_SOFT; + } else { + mState = STATE_HARD; + } + EventLog.writeEvent(EVENT_LOG_PROC_PSS_TAG, mProcessName, pid, mLastPss); + + if (mState == STATE_OK) { + // Memory is good, don't recover. + return false; + } + + if (mState == STATE_HARD) { + // Memory is really bad, kill right now. + EventLog.writeEvent(EVENT_LOG_HARD_RESET_TAG, mProcessName, pid, + mHardThreshold, mLastPss); + return mEnabled; + } + + // It is time to schedule a reset... + // Check if we are currently within the time to kill processes due + // to memory use. + computeMemcheckTimesLocked(curTime); + String skipReason = null; + if (curTime < mMemcheckExecStartTime || curTime > mMemcheckExecEndTime) { + skipReason = "time"; + } else { + skipReason = shouldWeBeBrutalLocked(curTime); + } + EventLog.writeEvent(EVENT_LOG_SOFT_RESET_TAG, mProcessName, pid, + mSoftThreshold, mLastPss, skipReason != null ? skipReason : ""); + if (skipReason != null) { + mNeedScheduledCheck = true; + return false; + } + return mEnabled; + } + + void clear() { + mLastPss = 0; + mState = STATE_OK; + } + } + + /** + * Used for scheduling monitor callbacks and checking memory usage. + */ + final class HeartbeatHandler extends Handler { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case GLOBAL_PSS: { + if (mHaveGlobalPss) { + // During the last pass we collected pss information, so + // now it is time to report it. + mHaveGlobalPss = false; + if (localLOGV) Log.v(TAG, "Received global pss, logging."); + logGlobalMemory(); + } + } break; + + case MONITOR: { + if (mHavePss) { + // During the last pass we collected pss information, so + // now it is time to report it. + mHavePss = false; + if (localLOGV) Log.v(TAG, "Have pss, checking memory."); + checkMemory(); + } + + if (mHaveGlobalPss) { + // During the last pass we collected pss information, so + // now it is time to report it. + mHaveGlobalPss = false; + if (localLOGV) Log.v(TAG, "Have global pss, logging."); + logGlobalMemory(); + } + + long now = SystemClock.uptimeMillis(); + + // See if we should force a reboot. + int rebootInterval = mReqRebootInterval >= 0 + ? mReqRebootInterval : Settings.Gservices.getInt( + mResolver, Settings.Gservices.REBOOT_INTERVAL, + REBOOT_DEFAULT_INTERVAL); + if (mRebootInterval != rebootInterval) { + mRebootInterval = rebootInterval; + // We have been running long enough that a reboot can + // be considered... + checkReboot(false); + } + + // See if we should check memory conditions. + long memCheckInterval = Settings.Gservices.getLong( + mResolver, Settings.Gservices.MEMCHECK_INTERVAL, + MEMCHECK_DEFAULT_INTERVAL) * 1000; + if ((mLastMemCheckTime+memCheckInterval) < now) { + // It is now time to collect pss information. This + // is async so we won't report it now. And to keep + // things simple, we will assume that everyone has + // reported back by the next MONITOR message. + mLastMemCheckTime = now; + if (localLOGV) Log.v(TAG, "Collecting memory usage."); + collectMemory(); + mHavePss = true; + + long memCheckRealtimeInterval = Settings.Gservices.getLong( + mResolver, Settings.Gservices.MEMCHECK_LOG_REALTIME_INTERVAL, + MEMCHECK_DEFAULT_LOG_REALTIME_INTERVAL) * 1000; + long realtimeNow = SystemClock.elapsedRealtime(); + if ((mLastMemCheckRealtime+memCheckRealtimeInterval) < realtimeNow) { + mLastMemCheckRealtime = realtimeNow; + if (localLOGV) Log.v(TAG, "Collecting global memory usage."); + collectGlobalMemory(); + mHaveGlobalPss = true; + } + } + + final int size = mMonitors.size(); + for (int i = 0 ; i < size ; i++) { + mCurrentMonitor = mMonitors.get(i); + mCurrentMonitor.monitor(); + } + + synchronized (Watchdog.this) { + mCompleted = true; + mCurrentMonitor = null; + } + } break; + } + } + } + + final class GlobalPssCollected implements Runnable { + public void run() { + mHandler.sendEmptyMessage(GLOBAL_PSS); + } + } + + final class CheckupReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context c, Intent intent) { + if (localLOGV) Log.v(TAG, "Alarm went off, checking memory."); + checkMemory(); + } + } + + final class RebootReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context c, Intent intent) { + if (localLOGV) Log.v(TAG, "Alarm went off, checking reboot."); + checkReboot(true); + } + } + + final class RebootRequestReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context c, Intent intent) { + mReqRebootNoWait = intent.getIntExtra("nowait", 0) != 0; + mReqRebootInterval = intent.getIntExtra("interval", -1); + mReqRebootStartTime = intent.getIntExtra("startTime", -1); + mReqRebootWindow = intent.getIntExtra("window", -1); + mReqMinScreenOff = intent.getIntExtra("minScreenOff", -1); + mReqMinNextAlarm = intent.getIntExtra("minNextAlarm", -1); + mReqRecheckInterval = intent.getIntExtra("recheckInterval", -1); + EventLog.writeEvent(EVENT_LOG_REQUESTED_REBOOT_TAG, + mReqRebootNoWait ? 1 : 0, mReqRebootInterval, + mReqRecheckInterval, mReqRebootStartTime, + mReqRebootWindow, mReqMinScreenOff, mReqMinNextAlarm); + checkReboot(true); + } + } + + public interface Monitor { + void monitor(); + } + + public interface PssRequestor { + void requestPss(); + } + + public class PssStats { + public int mEmptyPss; + public int mEmptyCount; + public int mBackgroundPss; + public int mBackgroundCount; + public int mServicePss; + public int mServiceCount; + public int mVisiblePss; + public int mVisibleCount; + public int mForegroundPss; + public int mForegroundCount; + + public int mNoPssCount; + + public int mProcDeaths[] = new int[10]; + } + + public static Watchdog getInstance() { + if (sWatchdog == null) { + sWatchdog = new Watchdog(); + } + + return sWatchdog; + } + + private Watchdog() { + super("watchdog"); + mHandler = new HeartbeatHandler(); + mGlobalPssCollected = new GlobalPssCollected(); + } + + public void init(Context context, BatteryService battery, + PowerManagerService power, AlarmManagerService alarm, + ActivityManagerService activity) { + mResolver = context.getContentResolver(); + mBattery = battery; + mPower = power; + mAlarm = alarm; + mActivity = activity; + + context.registerReceiver(new CheckupReceiver(), + new IntentFilter(CHECKUP_ACTION)); + mCheckupIntent = PendingIntent.getBroadcast(context, + 0, new Intent(CHECKUP_ACTION), 0); + + context.registerReceiver(new RebootReceiver(), + new IntentFilter(REBOOT_ACTION)); + mRebootIntent = PendingIntent.getBroadcast(context, + 0, new Intent(REBOOT_ACTION), 0); + + context.registerReceiver(new RebootRequestReceiver(), + new IntentFilter(Intent.ACTION_REBOOT), + android.Manifest.permission.REBOOT, null); + + mBootTime = System.currentTimeMillis(); + } + + public void processStarted(PssRequestor req, String name, int pid) { + synchronized (this) { + if ("com.android.phone".equals(name)) { + mPhoneReq = req; + mPhonePid = pid; + mPhonePss = 0; + } + } + } + + public void reportPss(PssRequestor req, String name, int pss) { + synchronized (this) { + if (mPhoneReq == req) { + mPhonePss = pss; + } + } + } + + public void addMonitor(Monitor monitor) { + synchronized (this) { + if (isAlive()) { + throw new RuntimeException("Monitors can't be added while the Watchdog is running"); + } + mMonitors.add(monitor); + } + } + + /** + * Retrieve memory usage information from specific processes being + * monitored. This is an async operation, so must be done before doing + * memory checks. + */ + void collectMemory() { + synchronized (this) { + if (mPhoneReq != null) { + mPhoneReq.requestPss(); + } + } + } + + /** + * Retrieve memory usage over all application processes. This is an + * async operation, so must be done before doing memory checks. + */ + void collectGlobalMemory() { + mActivity.requestPss(mGlobalPssCollected); + } + + /** + * Check memory usage in the system, scheduling kills/reboots as needed. + * This always runs on the mHandler thread. + */ + void checkMemory() { + boolean needScheduledCheck; + long curTime; + long nextTime = 0; + + long recheckInterval = Settings.Gservices.getLong( + mResolver, Settings.Gservices.MEMCHECK_RECHECK_INTERVAL, + MEMCHECK_DEFAULT_RECHECK_INTERVAL) * 1000; + + mSystemMemMonitor.retrieveSettings(mResolver); + mPhoneMemMonitor.retrieveSettings(mResolver); + retrieveBrutalityAmount(); + + synchronized (this) { + curTime = System.currentTimeMillis(); + mNeedScheduledCheck = false; + + // How is the system doing? + if (mSystemMemMonitor.checkLocked(curTime, Process.myPid(), + (int)Process.getPss(Process.myPid()))) { + // Not good! Time to suicide. + mForceKillSystem = true; + notifyAll(); + return; + } + + // How is the phone process doing? + if (mPhoneReq != null) { + if (mPhoneMemMonitor.checkLocked(curTime, mPhonePid, + mPhonePss)) { + // Just kill the phone process and let it restart. + Process.killProcess(mPhonePid); + } + } else { + mPhoneMemMonitor.clear(); + } + + needScheduledCheck = mNeedScheduledCheck; + if (needScheduledCheck) { + // Something is going bad, but now is not a good time to + // tear things down... schedule an alarm to check again soon. + nextTime = curTime + recheckInterval; + if (nextTime < mMemcheckExecStartTime) { + nextTime = mMemcheckExecStartTime; + } else if (nextTime >= mMemcheckExecEndTime){ + // Need to check during next exec time... so that needs + // to be computed. + if (localLOGV) Log.v(TAG, "Computing next time range"); + computeMemcheckTimesLocked(nextTime); + nextTime = mMemcheckExecStartTime; + } + + if (localLOGV) { + mCalendar.setTimeInMillis(nextTime); + Log.v(TAG, "Next Alarm Time: " + mCalendar); + } + } + } + + if (needScheduledCheck) { + if (localLOGV) Log.v(TAG, "Scheduling next memcheck alarm for " + + ((nextTime-curTime)/1000/60) + "m from now"); + mAlarm.remove(mCheckupIntent); + mAlarm.set(AlarmManager.RTC_WAKEUP, nextTime, mCheckupIntent); + } else { + if (localLOGV) Log.v(TAG, "No need to schedule a memcheck alarm!"); + mAlarm.remove(mCheckupIntent); + } + } + + final PssStats mPssStats = new PssStats(); + final String[] mMemInfoFields = new String[] { + "MemFree:", "Buffers:", "Cached:", + "Active:", "Inactive:", + "AnonPages:", "Mapped:", "Slab:", + "SReclaimable:", "SUnreclaim:", "PageTables:" }; + final long[] mMemInfoSizes = new long[mMemInfoFields.length]; + final String[] mVMStatFields = new String[] { + "pgfree ", "pgactivate ", "pgdeactivate ", + "pgfault ", "pgmajfault " }; + final long[] mVMStatSizes = new long[mVMStatFields.length]; + final long[] mPrevVMStatSizes = new long[mVMStatFields.length]; + long mLastLogGlobalMemoryTime; + + void logGlobalMemory() { + PssStats stats = mPssStats; + mActivity.collectPss(stats); + EventLog.writeEvent(EVENT_LOG_PSS_STATS_TAG, + stats.mEmptyPss, stats.mEmptyCount, + stats.mBackgroundPss, stats.mBackgroundCount, + stats.mServicePss, stats.mServiceCount, + stats.mVisiblePss, stats.mVisibleCount, + stats.mForegroundPss, stats.mForegroundCount, + stats.mNoPssCount); + EventLog.writeEvent(EVENT_LOG_PROC_STATS_TAG, + stats.mProcDeaths[0], stats.mProcDeaths[1], stats.mProcDeaths[2], + stats.mProcDeaths[3], stats.mProcDeaths[4]); + Process.readProcLines("/proc/meminfo", mMemInfoFields, mMemInfoSizes); + for (int i=0; i<mMemInfoSizes.length; i++) { + mMemInfoSizes[i] *= 1024; + } + EventLog.writeEvent(EVENT_LOG_MEMINFO_TAG, + (int)mMemInfoSizes[0], (int)mMemInfoSizes[1], (int)mMemInfoSizes[2], + (int)mMemInfoSizes[3], (int)mMemInfoSizes[4], + (int)mMemInfoSizes[5], (int)mMemInfoSizes[6], (int)mMemInfoSizes[7], + (int)mMemInfoSizes[8], (int)mMemInfoSizes[9], (int)mMemInfoSizes[10]); + long now = SystemClock.uptimeMillis(); + long dur = now - mLastLogGlobalMemoryTime; + mLastLogGlobalMemoryTime = now; + Process.readProcLines("/proc/vmstat", mVMStatFields, mVMStatSizes); + for (int i=0; i<mVMStatSizes.length; i++) { + long v = mVMStatSizes[i]; + mVMStatSizes[i] -= mPrevVMStatSizes[i]; + mPrevVMStatSizes[i] = v; + } + EventLog.writeEvent(EVENT_LOG_VMSTAT_TAG, dur, + (int)mVMStatSizes[0], (int)mVMStatSizes[1], (int)mVMStatSizes[2], + (int)mVMStatSizes[3], (int)mVMStatSizes[4]); + } + + void checkReboot(boolean fromAlarm) { + int rebootInterval = mReqRebootInterval >= 0 ? mReqRebootInterval + : Settings.Gservices.getInt( + mResolver, Settings.Gservices.REBOOT_INTERVAL, + REBOOT_DEFAULT_INTERVAL); + mRebootInterval = rebootInterval; + if (rebootInterval <= 0) { + // No reboot interval requested. + if (localLOGV) Log.v(TAG, "No need to schedule a reboot alarm!"); + mAlarm.remove(mRebootIntent); + return; + } + + long rebootStartTime = mReqRebootStartTime >= 0 ? mReqRebootStartTime + : Settings.Gservices.getLong( + mResolver, Settings.Gservices.REBOOT_START_TIME, + REBOOT_DEFAULT_START_TIME); + long rebootWindowMillis = (mReqRebootWindow >= 0 ? mReqRebootWindow + : Settings.Gservices.getLong( + mResolver, Settings.Gservices.REBOOT_WINDOW, + REBOOT_DEFAULT_WINDOW)) * 1000; + long recheckInterval = (mReqRecheckInterval >= 0 ? mReqRecheckInterval + : Settings.Gservices.getLong( + mResolver, Settings.Gservices.MEMCHECK_RECHECK_INTERVAL, + MEMCHECK_DEFAULT_RECHECK_INTERVAL)) * 1000; + + retrieveBrutalityAmount(); + + long realStartTime; + long now; + + synchronized (this) { + now = System.currentTimeMillis(); + realStartTime = computeCalendarTime(mCalendar, now, + rebootStartTime); + + long rebootIntervalMillis = rebootInterval*24*60*60*1000; + if (DB || mReqRebootNoWait || + (now-mBootTime) >= (rebootIntervalMillis-rebootWindowMillis)) { + if (fromAlarm && rebootWindowMillis <= 0) { + // No reboot window -- just immediately reboot. + EventLog.writeEvent(EVENT_LOG_SCHEDULED_REBOOT_TAG, now, + (int)rebootIntervalMillis, (int)rebootStartTime*1000, + (int)rebootWindowMillis, ""); + rebootSystem("Checkin scheduled forced"); + return; + } + + // Are we within the reboot window? + if (now < realStartTime) { + // Schedule alarm for next check interval. + realStartTime = computeCalendarTime(mCalendar, + now, rebootStartTime); + } else if (now < (realStartTime+rebootWindowMillis)) { + String doit = shouldWeBeBrutalLocked(now); + EventLog.writeEvent(EVENT_LOG_SCHEDULED_REBOOT_TAG, now, + (int)rebootInterval, (int)rebootStartTime*1000, + (int)rebootWindowMillis, doit != null ? doit : ""); + if (doit == null) { + rebootSystem("Checked scheduled range"); + return; + } + + // Schedule next alarm either within the window or in the + // next interval. + if ((now+recheckInterval) >= (realStartTime+rebootWindowMillis)) { + realStartTime = computeCalendarTime(mCalendar, + now + rebootIntervalMillis, rebootStartTime); + } else { + realStartTime = now + recheckInterval; + } + } else { + // Schedule alarm for next check interval. + realStartTime = computeCalendarTime(mCalendar, + now + rebootIntervalMillis, rebootStartTime); + } + } + } + + if (localLOGV) Log.v(TAG, "Scheduling next reboot alarm for " + + ((realStartTime-now)/1000/60) + "m from now"); + mAlarm.remove(mRebootIntent); + mAlarm.set(AlarmManager.RTC_WAKEUP, realStartTime, mRebootIntent); + } + + /** + * Perform a full reboot of the system. + */ + void rebootSystem(String reason) { + Log.i(TAG, "Rebooting system because: " + reason); + try { + android.os.Power.reboot(reason); + } catch (IOException e) { + Log.e(TAG, "Reboot failed!", e); + } + } + + /** + * Load the current Gservices settings for when + * {@link #shouldWeBeBrutalLocked} will allow the brutality to happen. + * Must not be called with the lock held. + */ + void retrieveBrutalityAmount() { + mMinScreenOff = (mReqMinScreenOff >= 0 ? mReqMinScreenOff + : Settings.Gservices.getInt( + mResolver, Settings.Gservices.MEMCHECK_MIN_SCREEN_OFF, + MEMCHECK_DEFAULT_MIN_SCREEN_OFF)) * 1000; + mMinAlarm = (mReqMinNextAlarm >= 0 ? mReqMinNextAlarm + : Settings.Gservices.getInt( + mResolver, Settings.Gservices.MEMCHECK_MIN_ALARM, + MEMCHECK_DEFAULT_MIN_ALARM)) * 1000; + } + + /** + * Determine whether it is a good time to kill, crash, or otherwise + * plunder the current situation for the overall long-term benefit of + * the world. + * + * @param curTime The current system time. + * @return Returns null if this is a good time, else a String with the + * text of why it is not a good time. + */ + String shouldWeBeBrutalLocked(long curTime) { + if (mBattery == null || !mBattery.isPowered()) { + return "battery"; + } + + if (mMinScreenOff >= 0 && (mPower == null || + mPower.timeSinceScreenOn() < mMinScreenOff)) { + return "screen"; + } + + if (mMinAlarm >= 0 && (mAlarm == null || + mAlarm.timeToNextAlarm() < mMinAlarm)) { + return "alarm"; + } + + return null; + } + + /** + * Compute the times during which we next would like to perform process + * restarts. + * + * @param curTime The current system time. + */ + void computeMemcheckTimesLocked(long curTime) { + if (mMemcheckLastTime == curTime) { + return; + } + + mMemcheckLastTime = curTime; + + long memcheckExecStartTime = Settings.Gservices.getLong( + mResolver, Settings.Gservices.MEMCHECK_EXEC_START_TIME, + MEMCHECK_DEFAULT_EXEC_START_TIME); + long memcheckExecEndTime = Settings.Gservices.getLong( + mResolver, Settings.Gservices.MEMCHECK_EXEC_END_TIME, + MEMCHECK_DEFAULT_EXEC_END_TIME); + + mMemcheckExecEndTime = computeCalendarTime(mCalendar, curTime, + memcheckExecEndTime); + if (mMemcheckExecEndTime < curTime) { + memcheckExecStartTime += 24*60*60; + memcheckExecEndTime += 24*60*60; + mMemcheckExecEndTime = computeCalendarTime(mCalendar, curTime, + memcheckExecEndTime); + } + mMemcheckExecStartTime = computeCalendarTime(mCalendar, curTime, + memcheckExecStartTime); + + if (localLOGV) { + mCalendar.setTimeInMillis(curTime); + Log.v(TAG, "Current Time: " + mCalendar); + mCalendar.setTimeInMillis(mMemcheckExecStartTime); + Log.v(TAG, "Start Check Time: " + mCalendar); + mCalendar.setTimeInMillis(mMemcheckExecEndTime); + Log.v(TAG, "End Check Time: " + mCalendar); + } + } + + static long computeCalendarTime(Calendar c, long curTime, + long secondsSinceMidnight) { + + // start with now + c.setTimeInMillis(curTime); + + int val = (int)secondsSinceMidnight / (60*60); + c.set(Calendar.HOUR_OF_DAY, val); + secondsSinceMidnight -= val * (60*60); + val = (int)secondsSinceMidnight / 60; + c.set(Calendar.MINUTE, val); + c.set(Calendar.SECOND, (int)secondsSinceMidnight - (val*60)); + c.set(Calendar.MILLISECOND, 0); + + long newTime = c.getTimeInMillis(); + if (newTime < curTime) { + // The given time (in seconds since midnight) has already passed for today, so advance + // by one day (due to daylight savings, etc., the delta may differ from 24 hours). + c.add(Calendar.DAY_OF_MONTH, 1); + newTime = c.getTimeInMillis(); + } + + return newTime; + } + + @Override + public void run() { + while (true) { + mCompleted = false; + mHandler.sendEmptyMessage(MONITOR); + + synchronized (this) { + long timeout = TIME_TO_WAIT; + + // NOTE: We use uptimeMillis() here because we do not want to increment the time we + // wait while asleep. If the device is asleep then the thing that we are waiting + // to timeout on is asleep as well and won't have a chance to run. Causing a false + // positive on when to kill things. + long start = SystemClock.uptimeMillis(); + do { + try { + wait(timeout); + } catch (InterruptedException e) { + if (SystemProperties.getBoolean("ro.secure", false)) { + // If this is a secure build, just log the error. + Log.e("WatchDog", "Woof! Woof! Interrupter!"); + } else { + throw new AssertionError("Someone interrupted the watchdog"); + } + } + timeout = TIME_TO_WAIT - (SystemClock.uptimeMillis() - start); + } while (timeout > 0 && !mForceKillSystem); + + if (mCompleted && !mForceKillSystem) { + // The monitors have returned. + continue; + } + } + + // If we got here, that means that the system is most likely hung. + // First send a SIGQUIT so that we can see where it was hung. Then + // kill this process so that the system will restart. + String name = (mCurrentMonitor != null) ? mCurrentMonitor.getClass().getName() : "null"; + EventLog.writeEvent(EVENT_LOG_TAG, name); + Process.sendSignal(Process.myPid(), Process.SIGNAL_QUIT); + + // Wait a bit longer before killing so we can make sure that the stacks are captured. + try { + Thread.sleep(10*1000); + } catch (InterruptedException e) { + } + + // Only kill the process if the debugger is not attached. + if (!Debug.isDebuggerConnected()) { + Process.killProcess(Process.myPid()); + } + } + } +} diff --git a/services/java/com/android/server/WifiService.java b/services/java/com/android/server/WifiService.java new file mode 100644 index 0000000..eece581 --- /dev/null +++ b/services/java/com/android/server/WifiService.java @@ -0,0 +1,1844 @@ +/* + * 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 static android.net.wifi.WifiManager.WIFI_STATE_DISABLED; +import static android.net.wifi.WifiManager.WIFI_STATE_DISABLING; +import static android.net.wifi.WifiManager.WIFI_STATE_ENABLED; +import static android.net.wifi.WifiManager.WIFI_STATE_ENABLING; +import static android.net.wifi.WifiManager.WIFI_STATE_UNKNOWN; + +import android.app.ActivityManagerNative; +import android.app.AlarmManager; +import android.app.PendingIntent; +import android.content.BroadcastReceiver; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.net.wifi.IWifiManager; +import android.net.wifi.WifiInfo; +import android.net.wifi.WifiManager; +import android.net.wifi.WifiNative; +import android.net.wifi.WifiStateTracker; +import android.net.wifi.ScanResult; +import android.net.wifi.WifiConfiguration; +import android.net.NetworkStateTracker; +import android.net.DhcpInfo; +import android.os.Binder; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.IBinder; +import android.os.Looper; +import android.os.Message; +import android.os.PowerManager; +import android.os.RemoteException; +import android.provider.Settings; +import android.util.Log; +import android.text.TextUtils; + +import java.util.ArrayList; +import java.util.BitSet; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Pattern; +import java.io.FileDescriptor; +import java.io.PrintWriter; + +/** + * WifiService handles remote WiFi operation requests by implementing + * the IWifiManager interface. It also creates a WifiMonitor to listen + * for Wifi-related events. + * + * @hide + */ +public class WifiService extends IWifiManager.Stub { + private static final String TAG = "WifiService"; + private static final boolean DBG = false; + private static final Pattern scanResultPattern = Pattern.compile("\t+"); + private final WifiStateTracker mWifiStateTracker; + + private Context mContext; + private int mWifiState; + + private AlarmManager mAlarmManager; + private PendingIntent mIdleIntent; + private static final int IDLE_REQUEST = 0; + private boolean mScreenOff; + private boolean mDeviceIdle; + private int mPluggedType; + + private final LockList mLocks = new LockList(); + /** + * See {@link Settings.Gservices#WIFI_IDLE_MS}. This is the default value if a + * Settings.Gservices value is not present. This timeout value is chosen as + * the approximate point at which the battery drain caused by Wi-Fi + * being enabled but not active exceeds the battery drain caused by + * re-establishing a connection to the mobile data network. + */ + private static final long DEFAULT_IDLE_MILLIS = 15 * 60 * 1000; /* 15 minutes */ + + private static final String WAKELOCK_TAG = "WifiService"; + + /** + * The maximum amount of time to hold the wake lock after a disconnect + * caused by stopping the driver. Establishing an EDGE connection has been + * observed to take about 5 seconds under normal circumstances. This + * provides a bit of extra margin. + * <p> + * See {@link android.provider.Settings.Secure#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS}. + * This is the default value if a Settings.Secure value is not present. + */ + private static final int DEFAULT_WAKELOCK_TIMEOUT = 8000; + + // Wake lock used by driver-stop operation + private static PowerManager.WakeLock sDriverStopWakeLock; + // Wake lock used by other operations + private static PowerManager.WakeLock sWakeLock; + + private static final int MESSAGE_ENABLE_WIFI = 0; + private static final int MESSAGE_DISABLE_WIFI = 1; + private static final int MESSAGE_STOP_WIFI = 2; + private static final int MESSAGE_START_WIFI = 3; + private static final int MESSAGE_RELEASE_WAKELOCK = 4; + + private final WifiHandler mWifiHandler; + + /* + * Map used to keep track of hidden networks presence, which + * is needed to switch between active and passive scan modes. + * If there is at least one hidden network that is currently + * present (enabled), we want to do active scans instead of + * passive. + */ + private final Map<Integer, Boolean> mIsHiddenNetworkPresent; + /* + * The number of currently present hidden networks. When this + * counter goes from 0 to 1 or from 1 to 0, we change the + * scan mode to active or passive respectively. Initially, we + * set the counter to 0 and we increment it every time we add + * a new present (enabled) hidden network. + */ + private int mNumHiddenNetworkPresent; + /* + * Whether we change the scan mode is due to a hidden network + * (in this class, this is always the case) + */ + private final static boolean SET_DUE_TO_A_HIDDEN_NETWORK = true; + + /* + * Cache of scan results objects (size is somewhat arbitrary) + */ + private static final int SCAN_RESULT_CACHE_SIZE = 80; + private final LinkedHashMap<String, ScanResult> mScanResultCache; + + /* + * Character buffer used to parse scan results (optimization) + */ + private static final int SCAN_RESULT_BUFFER_SIZE = 512; + private char[] mScanResultBuffer; + private boolean mNeedReconfig; + + /** + * Number of allowed radio frequency channels in various regulatory domains. + * This list is sufficient for 802.11b/g networks (2.4GHz range). + */ + private static int[] sValidRegulatoryChannelCounts = new int[] {11, 13, 14}; + + private static final String ACTION_DEVICE_IDLE = + "com.android.server.WifiManager.action.DEVICE_IDLE"; + + WifiService(Context context, WifiStateTracker tracker) { + mContext = context; + mWifiStateTracker = tracker; + + /* + * Initialize the hidden-networks state + */ + mIsHiddenNetworkPresent = new HashMap<Integer, Boolean>(); + mNumHiddenNetworkPresent = 0; + + mScanResultCache = new LinkedHashMap<String, ScanResult>( + SCAN_RESULT_CACHE_SIZE, 0.75f, true) { + /* + * Limit the cache size by SCAN_RESULT_CACHE_SIZE + * elements + */ + public boolean removeEldestEntry(Map.Entry eldest) { + return SCAN_RESULT_CACHE_SIZE < this.size(); + } + }; + + mScanResultBuffer = new char [SCAN_RESULT_BUFFER_SIZE]; + + HandlerThread wifiThread = new HandlerThread("WifiService"); + wifiThread.start(); + mWifiHandler = new WifiHandler(wifiThread.getLooper()); + + mWifiState = WIFI_STATE_DISABLED; + boolean wifiEnabled = getPersistedWifiEnabled(); + + mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE); + Intent idleIntent = new Intent(ACTION_DEVICE_IDLE, null); + mIdleIntent = PendingIntent.getBroadcast(mContext, IDLE_REQUEST, idleIntent, 0); + + PowerManager powerManager = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE); + sWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_TAG); + sDriverStopWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_TAG); + mWifiStateTracker.setReleaseWakeLockCallback( + new Runnable() { + public void run() { + mWifiHandler.removeMessages(MESSAGE_RELEASE_WAKELOCK); + synchronized (sDriverStopWakeLock) { + if (sDriverStopWakeLock.isHeld()) { + sDriverStopWakeLock.release(); + } + } + } + } + ); + + Log.i(TAG, "WifiService starting up with Wi-Fi " + + (wifiEnabled ? "enabled" : "disabled")); + + mContext.registerReceiver( + new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + updateWifiState(); + } + }, + new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED)); + + setWifiEnabledBlocking(wifiEnabled, false); + } + + /** + * Initializes the hidden networks state. Must be called when we + * enable Wi-Fi. + */ + private synchronized void initializeHiddenNetworksState() { + // First, reset the state + resetHiddenNetworksState(); + + // ... then add networks that are marked as hidden + List<WifiConfiguration> networks = getConfiguredNetworks(); + if (!networks.isEmpty()) { + for (WifiConfiguration config : networks) { + if (config != null && config.hiddenSSID) { + addOrUpdateHiddenNetwork( + config.networkId, + config.status != WifiConfiguration.Status.DISABLED); + } + } + + } + } + + /** + * Resets the hidden networks state. + */ + private synchronized void resetHiddenNetworksState() { + mNumHiddenNetworkPresent = 0; + mIsHiddenNetworkPresent.clear(); + } + + /** + * Marks all but netId network as not present. + */ + private synchronized void markAllHiddenNetworksButOneAsNotPresent(int netId) { + for (Map.Entry<Integer, Boolean> entry : mIsHiddenNetworkPresent.entrySet()) { + if (entry != null) { + Integer networkId = entry.getKey(); + if (networkId != netId) { + updateNetworkIfHidden( + networkId, false); + } + } + } + } + + /** + * Updates the netId network presence status if netId is an existing + * hidden network. + */ + private synchronized void updateNetworkIfHidden(int netId, boolean present) { + if (isHiddenNetwork(netId)) { + addOrUpdateHiddenNetwork(netId, present); + } + } + + /** + * Updates the netId network presence status if netId is an existing + * hidden network. If the network does not exist, adds the network. + */ + private synchronized void addOrUpdateHiddenNetwork(int netId, boolean present) { + if (0 <= netId) { + + // If we are adding a new entry or modifying an existing one + Boolean isPresent = mIsHiddenNetworkPresent.get(netId); + if (isPresent == null || isPresent != present) { + if (present) { + incrementHiddentNetworkPresentCounter(); + } else { + // If we add a new hidden network, no need to change + // the counter (it must be 0) + if (isPresent != null) { + decrementHiddentNetworkPresentCounter(); + } + } + mIsHiddenNetworkPresent.put(netId, present); + } + } else { + Log.e(TAG, "addOrUpdateHiddenNetwork(): Invalid (negative) network id!"); + } + } + + /** + * Removes the netId network if it is hidden (being kept track of). + */ + private synchronized void removeNetworkIfHidden(int netId) { + if (isHiddenNetwork(netId)) { + removeHiddenNetwork(netId); + } + } + + /** + * Removes the netId network. For the call to be successful, the network + * must be hidden. + */ + private synchronized void removeHiddenNetwork(int netId) { + if (0 <= netId) { + Boolean isPresent = + mIsHiddenNetworkPresent.remove(netId); + if (isPresent != null) { + // If we remove an existing hidden network that is not + // present, no need to change the counter + if (isPresent) { + decrementHiddentNetworkPresentCounter(); + } + } else { + if (DBG) { + Log.d(TAG, "removeHiddenNetwork(): Removing a non-existent network!"); + } + } + } else { + Log.e(TAG, "removeHiddenNetwork(): Invalid (negative) network id!"); + } + } + + /** + * Returns true if netId is an existing hidden network. + */ + private synchronized boolean isHiddenNetwork(int netId) { + return mIsHiddenNetworkPresent.containsKey(netId); + } + + /** + * Increments the present (enabled) hidden networks counter. If the + * counter value goes from 0 to 1, changes the scan mode to active. + */ + private void incrementHiddentNetworkPresentCounter() { + ++mNumHiddenNetworkPresent; + if (1 == mNumHiddenNetworkPresent) { + // Switch the scan mode to "active" + mWifiStateTracker.setScanMode(true, SET_DUE_TO_A_HIDDEN_NETWORK); + } + } + + /** + * Decrements the present (enabled) hidden networks counter. If the + * counter goes from 1 to 0, changes the scan mode back to passive. + */ + private void decrementHiddentNetworkPresentCounter() { + if (0 < mNumHiddenNetworkPresent) { + --mNumHiddenNetworkPresent; + if (0 == mNumHiddenNetworkPresent) { + // Switch the scan mode to "passive" + mWifiStateTracker.setScanMode(false, SET_DUE_TO_A_HIDDEN_NETWORK); + } + } else { + Log.e(TAG, "Hidden-network counter invariant violation!"); + } + } + + private boolean getPersistedWifiEnabled() { + final ContentResolver cr = mContext.getContentResolver(); + try { + return Settings.Secure.getInt(cr, Settings.Secure.WIFI_ON) == 1; + } catch (Settings.SettingNotFoundException e) { + Settings.Secure.putInt(cr, Settings.Secure.WIFI_ON, 0); + return false; + } + } + + private void persistWifiEnabled(boolean enabled) { + final ContentResolver cr = mContext.getContentResolver(); + Settings.Secure.putInt(cr, Settings.Secure.WIFI_ON, enabled ? 1 : 0); + } + + NetworkStateTracker getNetworkStateTracker() { + return mWifiStateTracker; + } + + /** + * see {@link android.net.wifi.WifiManager#pingSupplicant()} + * @return {@code true} if the operation succeeds + */ + public boolean pingSupplicant() { + enforceChangePermission(); + synchronized (mWifiStateTracker) { + return WifiNative.pingCommand(); + } + } + + /** + * see {@link android.net.wifi.WifiManager#startScan()} + * @return {@code true} if the operation succeeds + */ + public boolean startScan() { + enforceChangePermission(); + synchronized (mWifiStateTracker) { + switch (mWifiStateTracker.getSupplicantState()) { + case DISCONNECTED: + case INACTIVE: + case SCANNING: + case DORMANT: + break; + default: + WifiNative.setScanResultHandlingCommand( + WifiStateTracker.SUPPL_SCAN_HANDLING_LIST_ONLY); + break; + } + return WifiNative.scanCommand(); + } + } + + /** + * see {@link android.net.wifi.WifiManager#setWifiEnabled(boolean)} + * @param enable {@code true} to enable, {@code false} to disable. + * @return {@code true} if the enable/disable operation was + * started or is already in the queue. + */ + public boolean setWifiEnabled(boolean enable) { + enforceChangePermission(); + if (mWifiHandler == null) return false; + + synchronized (mWifiHandler) { + sWakeLock.acquire(); + sendEnableMessage(enable, true); + } + + return true; + } + + /** + * Enables/disables Wi-Fi synchronously. + * @param enable {@code true} to turn Wi-Fi on, {@code false} to turn it off. + * @param persist {@code true} if the setting should be persisted. + * @return {@code true} if the operation succeeds (or if the existing state + * is the same as the requested state) + */ + private boolean setWifiEnabledBlocking(boolean enable, boolean persist) { + final int eventualWifiState = enable ? WIFI_STATE_ENABLED : WIFI_STATE_DISABLED; + + if (mWifiState == eventualWifiState) { + return true; + } + if (enable && isAirplaneModeOn()) { + return false; + } + + setWifiEnabledState(enable ? WIFI_STATE_ENABLING : WIFI_STATE_DISABLING); + + if (enable) { + if (!WifiNative.loadDriver()) { + Log.e(TAG, "Failed to load Wi-Fi driver."); + setWifiEnabledState(WIFI_STATE_UNKNOWN); + return false; + } + if (!WifiNative.startSupplicant()) { + WifiNative.unloadDriver(); + Log.e(TAG, "Failed to start supplicant daemon."); + setWifiEnabledState(WIFI_STATE_UNKNOWN); + return false; + } + registerForBroadcasts(); + mWifiStateTracker.startEventLoop(); + } else { + + mContext.unregisterReceiver(mReceiver); + // Remove notification (it will no-op if it isn't visible) + mWifiStateTracker.setNotificationVisible(false, 0, false, 0); + + boolean failedToStopSupplicantOrUnloadDriver = false; + if (!WifiNative.stopSupplicant()) { + Log.e(TAG, "Failed to stop supplicant daemon."); + setWifiEnabledState(WIFI_STATE_UNKNOWN); + failedToStopSupplicantOrUnloadDriver = true; + } + + // We must reset the interface before we unload the driver + mWifiStateTracker.resetInterface(); + + if (!WifiNative.unloadDriver()) { + Log.e(TAG, "Failed to unload Wi-Fi driver."); + if (!failedToStopSupplicantOrUnloadDriver) { + setWifiEnabledState(WIFI_STATE_UNKNOWN); + failedToStopSupplicantOrUnloadDriver = true; + } + } + if (failedToStopSupplicantOrUnloadDriver) { + return false; + } + } + + // Success! + + if (persist) { + persistWifiEnabled(enable); + } + setWifiEnabledState(eventualWifiState); + + /* + * Initialize the hidden networks state and the number of allowed + * radio channels if Wi-Fi is being turned on. + */ + if (enable) { + mWifiStateTracker.setNumAllowedChannels(); + initializeHiddenNetworksState(); + } + + return true; + } + + private void setWifiEnabledState(int wifiState) { + final int previousWifiState = mWifiState; + + // Update state + mWifiState = wifiState; + + // Broadcast + final Intent intent = new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION); + intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); + intent.putExtra(WifiManager.EXTRA_WIFI_STATE, wifiState); + intent.putExtra(WifiManager.EXTRA_PREVIOUS_WIFI_STATE, previousWifiState); + mContext.sendStickyBroadcast(intent); + } + + private void enforceAccessPermission() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.ACCESS_WIFI_STATE, + "WifiService"); + } + + private void enforceChangePermission() { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CHANGE_WIFI_STATE, + "WifiService"); + + } + + /** + * see {@link WifiManager#getWifiState()} + * @return One of {@link WifiManager#WIFI_STATE_DISABLED}, + * {@link WifiManager#WIFI_STATE_DISABLING}, + * {@link WifiManager#WIFI_STATE_ENABLED}, + * {@link WifiManager#WIFI_STATE_ENABLING}, + * {@link WifiManager#WIFI_STATE_UNKNOWN} + */ + public int getWifiEnabledState() { + enforceAccessPermission(); + return mWifiState; + } + + /** + * see {@link android.net.wifi.WifiManager#disconnect()} + * @return {@code true} if the operation succeeds + */ + public boolean disconnect() { + enforceChangePermission(); + synchronized (mWifiStateTracker) { + return WifiNative.disconnectCommand(); + } + } + + /** + * see {@link android.net.wifi.WifiManager#reconnect()} + * @return {@code true} if the operation succeeds + */ + public boolean reconnect() { + enforceChangePermission(); + synchronized (mWifiStateTracker) { + return WifiNative.reconnectCommand(); + } + } + + /** + * see {@link android.net.wifi.WifiManager#reassociate()} + * @return {@code true} if the operation succeeds + */ + public boolean reassociate() { + enforceChangePermission(); + synchronized (mWifiStateTracker) { + return WifiNative.reassociateCommand(); + } + } + + /** + * see {@link android.net.wifi.WifiManager#getConfiguredNetworks()} + * @return the list of configured networks + */ + public List<WifiConfiguration> getConfiguredNetworks() { + enforceAccessPermission(); + String listStr; + /* + * We don't cache the list, because we want to allow + * for the possibility that the configuration file + * has been modified through some external means, + * such as the wpa_cli command line program. + */ + synchronized (mWifiStateTracker) { + listStr = WifiNative.listNetworksCommand(); + } + List<WifiConfiguration> networks = + new ArrayList<WifiConfiguration>(); + if (listStr == null) + return networks; + + String[] lines = listStr.split("\n"); + // Skip the first line, which is a header + for (int i = 1; i < lines.length; i++) { + String[] result = lines[i].split("\t"); + // network-id | ssid | bssid | flags + WifiConfiguration config = new WifiConfiguration(); + try { + config.networkId = Integer.parseInt(result[0]); + } catch(NumberFormatException e) { + continue; + } + if (result.length > 3) { + if (result[3].indexOf("[CURRENT]") != -1) + config.status = WifiConfiguration.Status.CURRENT; + else if (result[3].indexOf("[DISABLED]") != -1) + config.status = WifiConfiguration.Status.DISABLED; + else + config.status = WifiConfiguration.Status.ENABLED; + } else + config.status = WifiConfiguration.Status.ENABLED; + synchronized (mWifiStateTracker) { + readNetworkVariables(config); + } + networks.add(config); + } + + return networks; + } + + /** + * Read the variables from the supplicant daemon that are needed to + * fill in the WifiConfiguration object. + * <p/> + * The caller must hold the synchronization monitor. + * @param config the {@link WifiConfiguration} object to be filled in. + */ + private static void readNetworkVariables(WifiConfiguration config) { + + int netId = config.networkId; + if (netId < 0) + return; + + /* + * TODO: maybe should have a native method that takes an array of + * variable names and returns an array of values. But we'd still + * be doing a round trip to the supplicant daemon for each variable. + */ + String value; + + value = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.ssidVarName); + if (!TextUtils.isEmpty(value)) { + config.SSID = value; + } else { + config.SSID = null; + } + + value = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.bssidVarName); + if (!TextUtils.isEmpty(value)) { + config.BSSID = value; + } else { + config.BSSID = null; + } + + value = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.priorityVarName); + config.priority = -1; + if (!TextUtils.isEmpty(value)) { + try { + config.priority = Integer.parseInt(value); + } catch (NumberFormatException ignore) { + } + } + + value = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.hiddenSSIDVarName); + config.hiddenSSID = false; + if (!TextUtils.isEmpty(value)) { + try { + config.hiddenSSID = Integer.parseInt(value) != 0; + } catch (NumberFormatException ignore) { + } + } + + value = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.wepTxKeyIdxVarName); + config.wepTxKeyIndex = -1; + if (!TextUtils.isEmpty(value)) { + try { + config.wepTxKeyIndex = Integer.parseInt(value); + } catch (NumberFormatException ignore) { + } + } + + /* + * Get up to 4 WEP keys. Note that the actual keys are not passed back, + * just a "*" if the key is set, or the null string otherwise. + */ + for (int i = 0; i < 4; i++) { + value = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.wepKeyVarNames[i]); + if (!TextUtils.isEmpty(value)) { + config.wepKeys[i] = value; + } else { + config.wepKeys[i] = null; + } + } + + /* + * Get the private shared key. Note that the actual keys are not passed back, + * just a "*" if the key is set, or the null string otherwise. + */ + value = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.pskVarName); + if (!TextUtils.isEmpty(value)) { + config.preSharedKey = value; + } else { + config.preSharedKey = null; + } + + value = WifiNative.getNetworkVariableCommand(config.networkId, + WifiConfiguration.Protocol.varName); + if (!TextUtils.isEmpty(value)) { + String vals[] = value.split(" "); + for (String val : vals) { + int index = + lookupString(val, WifiConfiguration.Protocol.strings); + if (0 <= index) { + config.allowedProtocols.set(index); + } + } + } + + value = WifiNative.getNetworkVariableCommand(config.networkId, + WifiConfiguration.KeyMgmt.varName); + if (!TextUtils.isEmpty(value)) { + String vals[] = value.split(" "); + for (String val : vals) { + int index = + lookupString(val, WifiConfiguration.KeyMgmt.strings); + if (0 <= index) { + config.allowedKeyManagement.set(index); + } + } + } + + value = WifiNative.getNetworkVariableCommand(config.networkId, + WifiConfiguration.AuthAlgorithm.varName); + if (!TextUtils.isEmpty(value)) { + String vals[] = value.split(" "); + for (String val : vals) { + int index = + lookupString(val, WifiConfiguration.AuthAlgorithm.strings); + if (0 <= index) { + config.allowedAuthAlgorithms.set(index); + } + } + } + + value = WifiNative.getNetworkVariableCommand(config.networkId, + WifiConfiguration.PairwiseCipher.varName); + if (!TextUtils.isEmpty(value)) { + String vals[] = value.split(" "); + for (String val : vals) { + int index = + lookupString(val, WifiConfiguration.PairwiseCipher.strings); + if (0 <= index) { + config.allowedPairwiseCiphers.set(index); + } + } + } + + value = WifiNative.getNetworkVariableCommand(config.networkId, + WifiConfiguration.GroupCipher.varName); + if (!TextUtils.isEmpty(value)) { + String vals[] = value.split(" "); + for (String val : vals) { + int index = + lookupString(val, WifiConfiguration.GroupCipher.strings); + if (0 <= index) { + config.allowedGroupCiphers.set(index); + } + } + } + } + + /** + * see {@link android.net.wifi.WifiManager#addOrUpdateNetwork(WifiConfiguration)} + * @return the supplicant-assigned identifier for the new or updated + * network if the operation succeeds, or {@code -1} if it fails + */ + public synchronized int addOrUpdateNetwork(WifiConfiguration config) { + enforceChangePermission(); + /* + * If the supplied networkId is -1, we create a new empty + * network configuration. Otherwise, the networkId should + * refer to an existing configuration. + */ + int netId = config.networkId; + boolean newNetwork = netId == -1; + boolean doReconfig; + int currentPriority; + // networkId of -1 means we want to create a new network + if (newNetwork) { + netId = WifiNative.addNetworkCommand(); + if (netId < 0) { + if (DBG) { + Log.d(TAG, "Failed to add a network!"); + } + return -1; + } + doReconfig = true; + } else { + String priorityVal = WifiNative.getNetworkVariableCommand(netId, WifiConfiguration.priorityVarName); + currentPriority = -1; + if (!TextUtils.isEmpty(priorityVal)) { + try { + currentPriority = Integer.parseInt(priorityVal); + } catch (NumberFormatException ignore) { + } + } + doReconfig = currentPriority != config.priority; + } + mNeedReconfig = mNeedReconfig || doReconfig; + + /* + * If we have hidden networks, we may have to change the scan mode + */ + if (config.hiddenSSID) { + // Mark the network as present unless it is disabled + addOrUpdateHiddenNetwork( + netId, config.status != WifiConfiguration.Status.DISABLED); + } + + setVariables: { + /* + * Note that if a networkId for a non-existent network + * was supplied, then the first setNetworkVariableCommand() + * will fail, so we don't bother to make a separate check + * for the validity of the ID up front. + */ + + if (config.SSID != null && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.ssidVarName, + config.SSID)) { + if (DBG) { + Log.d(TAG, "failed to set SSID: "+config.SSID); + } + break setVariables; + } + + if (config.BSSID != null && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.bssidVarName, + config.BSSID)) { + if (DBG) { + Log.d(TAG, "failed to set BSSID: "+config.BSSID); + } + break setVariables; + } + + String allowedKeyManagementString = + makeString(config.allowedKeyManagement, WifiConfiguration.KeyMgmt.strings); + if (config.allowedKeyManagement.cardinality() != 0 && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.KeyMgmt.varName, + allowedKeyManagementString)) { + if (DBG) { + Log.d(TAG, "failed to set key_mgmt: "+ + allowedKeyManagementString); + } + break setVariables; + } + + String allowedProtocolsString = + makeString(config.allowedProtocols, WifiConfiguration.Protocol.strings); + if (config.allowedProtocols.cardinality() != 0 && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.Protocol.varName, + allowedProtocolsString)) { + if (DBG) { + Log.d(TAG, "failed to set proto: "+ + allowedProtocolsString); + } + break setVariables; + } + + String allowedAuthAlgorithmsString = + makeString(config.allowedAuthAlgorithms, WifiConfiguration.AuthAlgorithm.strings); + if (config.allowedAuthAlgorithms.cardinality() != 0 && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.AuthAlgorithm.varName, + allowedAuthAlgorithmsString)) { + if (DBG) { + Log.d(TAG, "failed to set auth_alg: "+ + allowedAuthAlgorithmsString); + } + break setVariables; + } + + String allowedPairwiseCiphersString = + makeString(config.allowedPairwiseCiphers, WifiConfiguration.PairwiseCipher.strings); + if (config.allowedPairwiseCiphers.cardinality() != 0 && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.PairwiseCipher.varName, + allowedPairwiseCiphersString)) { + if (DBG) { + Log.d(TAG, "failed to set pairwise: "+ + allowedPairwiseCiphersString); + } + break setVariables; + } + + String allowedGroupCiphersString = + makeString(config.allowedGroupCiphers, WifiConfiguration.GroupCipher.strings); + if (config.allowedGroupCiphers.cardinality() != 0 && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.GroupCipher.varName, + allowedGroupCiphersString)) { + if (DBG) { + Log.d(TAG, "failed to set group: "+ + allowedGroupCiphersString); + } + break setVariables; + } + + // Prevent client screw-up by passing in a WifiConfiguration we gave it + // by preventing "*" as a key. + if (config.preSharedKey != null && !config.preSharedKey.equals("*") && + !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.pskVarName, + config.preSharedKey)) { + if (DBG) { + Log.d(TAG, "failed to set psk: "+config.preSharedKey); + } + break setVariables; + } + + boolean hasSetKey = false; + if (config.wepKeys != null) { + for (int i = 0; i < config.wepKeys.length; i++) { + // Prevent client screw-up by passing in a WifiConfiguration we gave it + // by preventing "*" as a key. + if (config.wepKeys[i] != null && !config.wepKeys[i].equals("*")) { + if (!WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.wepKeyVarNames[i], + config.wepKeys[i])) { + if (DBG) { + Log.d(TAG, + "failed to set wep_key"+i+": " + + config.wepKeys[i]); + } + break setVariables; + } + hasSetKey = true; + } + } + } + + if (hasSetKey) { + if (!WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.wepTxKeyIdxVarName, + Integer.toString(config.wepTxKeyIndex))) { + if (DBG) { + Log.d(TAG, + "failed to set wep_tx_keyidx: "+ + config.wepTxKeyIndex); + } + break setVariables; + } + } + + if (!WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.priorityVarName, + Integer.toString(config.priority))) { + if (DBG) { + Log.d(TAG, config.SSID + ": failed to set priority: " + +config.priority); + } + break setVariables; + } + + if (config.hiddenSSID && !WifiNative.setNetworkVariableCommand( + netId, + WifiConfiguration.hiddenSSIDVarName, + Integer.toString(config.hiddenSSID ? 1 : 0))) { + if (DBG) { + Log.d(TAG, config.SSID + ": failed to set hiddenSSID: "+ + config.hiddenSSID); + } + break setVariables; + } + + return netId; + } + + /* + * For an update, if one of the setNetworkVariable operations fails, + * we might want to roll back all the changes already made. But the + * chances are that if anything is going to go wrong, it'll happen + * the first time we try to set one of the variables. + */ + if (newNetwork) { + removeNetwork(netId); + if (DBG) { + Log.d(TAG, + "Failed to set a network variable, removed network: " + + netId); + } + } + return -1; + } + + private static String makeString(BitSet set, String[] strings) { + StringBuffer buf = new StringBuffer(); + int nextSetBit = -1; + + /* Make sure all set bits are in [0, strings.length) to avoid + * going out of bounds on strings. (Shouldn't happen, but...) */ + set = set.get(0, strings.length); + + while ((nextSetBit = set.nextSetBit(nextSetBit + 1)) != -1) { + buf.append(strings[nextSetBit].replace('_', '-')).append(' '); + } + + // remove trailing space + if (set.cardinality() > 0) { + buf.setLength(buf.length() - 1); + } + + return buf.toString(); + } + + private static int lookupString(String string, String[] strings) { + int size = strings.length; + + string = string.replace('-', '_'); + + for (int i = 0; i < size; i++) + if (string.equals(strings[i])) + return i; + + if (DBG) { + // if we ever get here, we should probably add the + // value to WifiConfiguration to reflect that it's + // supported by the WPA supplicant + Log.w(TAG, "Failed to look-up a string: " + string); + } + + return -1; + } + + /** + * See {@link android.net.wifi.WifiManager#removeNetwork(int)} + * @param netId the integer that identifies the network configuration + * to the supplicant + * @return {@code true} if the operation succeeded + */ + public boolean removeNetwork(int netId) { + enforceChangePermission(); + + /* + * If we have hidden networks, we may have to change the scan mode + */ + removeNetworkIfHidden(netId); + + return mWifiStateTracker.removeNetwork(netId); + } + + /** + * See {@link android.net.wifi.WifiManager#enableNetwork(int, boolean)} + * @param netId the integer that identifies the network configuration + * to the supplicant + * @param disableOthers if true, disable all other networks. + * @return {@code true} if the operation succeeded + */ + public boolean enableNetwork(int netId, boolean disableOthers) { + enforceChangePermission(); + + /* + * If we have hidden networks, we may have to change the scan mode + */ + synchronized(this) { + if (disableOthers) { + markAllHiddenNetworksButOneAsNotPresent(netId); + } + updateNetworkIfHidden(netId, true); + } + + synchronized (mWifiStateTracker) { + return WifiNative.enableNetworkCommand(netId, disableOthers); + } + } + + /** + * See {@link android.net.wifi.WifiManager#disableNetwork(int)} + * @param netId the integer that identifies the network configuration + * to the supplicant + * @return {@code true} if the operation succeeded + */ + public boolean disableNetwork(int netId) { + enforceChangePermission(); + + /* + * If we have hidden networks, we may have to change the scan mode + */ + updateNetworkIfHidden(netId, false); + + synchronized (mWifiStateTracker) { + return WifiNative.disableNetworkCommand(netId); + } + } + + /** + * See {@link android.net.wifi.WifiManager#getConnectionInfo()} + * @return the Wi-Fi information, contained in {@link WifiInfo}. + */ + public WifiInfo getConnectionInfo() { + enforceAccessPermission(); + /* + * Make sure we have the latest information, by sending + * a status request to the supplicant. + */ + return mWifiStateTracker.requestConnectionInfo(); + } + + /** + * Return the results of the most recent access point scan, in the form of + * a list of {@link ScanResult} objects. + * @return the list of results + */ + public List<ScanResult> getScanResults() { + enforceAccessPermission(); + String reply; + synchronized (mWifiStateTracker) { + reply = WifiNative.scanResultsCommand(); + } + if (reply == null) { + return null; + } + + List<ScanResult> scanList = new ArrayList<ScanResult>(); + + int lineCount = 0; + + int replyLen = reply.length(); + // Parse the result string, keeping in mind that the last line does + // not end with a newline. + for (int lineBeg = 0, lineEnd = 0; lineEnd <= replyLen; ++lineEnd) { + if (lineEnd == replyLen || reply.charAt(lineEnd) == '\n') { + ++lineCount; + /* + * Skip the first line, which is a header + */ + if (lineCount == 1) { + lineBeg = lineEnd + 1; + continue; + } + int lineLen = lineEnd - lineBeg; + if (0 < lineLen && lineLen <= SCAN_RESULT_BUFFER_SIZE) { + int scanResultLevel = 0; + /* + * At most one thread should have access to the buffer at a time! + */ + synchronized(mScanResultBuffer) { + boolean parsingScanResultLevel = false; + for (int i = lineBeg; i < lineEnd; ++i) { + char ch = reply.charAt(i); + /* + * Assume that the signal level starts with a '-' + */ + if (ch == '-') { + /* + * Skip whatever instances of '-' we may have + * after we parse the signal level + */ + parsingScanResultLevel = (scanResultLevel == 0); + } else if (parsingScanResultLevel) { + int digit = Character.digit(ch, 10); + if (0 <= digit) { + scanResultLevel = + 10 * scanResultLevel + digit; + /* + * Replace the signal level number in + * the string with 0's for caching + */ + ch = '0'; + } else { + /* + * Reset the flag if we meet a non-digit + * character + */ + parsingScanResultLevel = false; + } + } + mScanResultBuffer[i - lineBeg] = ch; + } + if (scanResultLevel != 0) { + ScanResult scanResult = parseScanResult( + new String(mScanResultBuffer, 0, lineLen)); + if (scanResult != null) { + scanResult.level = -scanResultLevel; + scanList.add(scanResult); + } + } else if (DBG) { + Log.w(TAG, + "ScanResult.level=0: misformatted scan result?"); + } + } + } else if (0 < lineLen) { + if (DBG) { + Log.w(TAG, "Scan result line is too long: " + + (lineEnd - lineBeg) + ", skipping the line!"); + } + } + lineBeg = lineEnd + 1; + } + } + mWifiStateTracker.setScanResultsList(scanList); + return scanList; + } + + /** + * Parse the scan result line passed to us by wpa_supplicant (helper). + * @param line the line to parse + * @return the {@link ScanResult} object + */ + private ScanResult parseScanResult(String line) { + ScanResult scanResult = null; + if (line != null) { + /* + * Cache implementation (LinkedHashMap) is not synchronized, thus, + * must synchronized here! + */ + synchronized (mScanResultCache) { + scanResult = mScanResultCache.get(line); + if (scanResult == null) { + String[] result = scanResultPattern.split(line); + if (3 <= result.length && result.length <= 5) { + // bssid | frequency | level | flags | ssid + int frequency; + int level; + try { + frequency = Integer.parseInt(result[1]); + level = Integer.parseInt(result[2]); + } catch (NumberFormatException e) { + frequency = 0; + level = 0; + } + + /* + * The formatting of the results returned by + * wpa_supplicant is intended to make the fields + * line up nicely when printed, + * not to make them easy to parse. So we have to + * apply some heuristics to figure out which field + * is the SSID and which field is the flags. + */ + String ssid; + String flags; + if (result.length == 4) { + if (result[3].charAt(0) == '[') { + flags = result[3]; + ssid = ""; + } else { + flags = ""; + ssid = result[3]; + } + } else if (result.length == 5) { + flags = result[3]; + ssid = result[4]; + } else { + // Here, we must have 3 fields: no flags and ssid + // set + flags = ""; + ssid = ""; + } + + // Do not add scan results that have no SSID set + if (0 < ssid.trim().length()) { + scanResult = + new ScanResult( + ssid, result[0], flags, level, frequency); + mScanResultCache.put(line, scanResult); + } + } else { + Log.w(TAG, "Misformatted scan result text with " + + result.length + " fields: " + line); + } + } + } + } + + return scanResult; + } + + /** + * Parse the "flags" field passed back in a scan result by wpa_supplicant, + * and construct a {@code WifiConfiguration} that describes the encryption, + * key management, and authenticaion capabilities of the access point. + * @param flags the string returned by wpa_supplicant + * @return the {@link WifiConfiguration} object, filled in + */ + WifiConfiguration parseScanFlags(String flags) { + WifiConfiguration config = new WifiConfiguration(); + + if (flags.length() == 0) { + config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE); + } + // ... to be implemented + return config; + } + + /** + * Tell the supplicant to persist the current list of configured networks. + * @return {@code true} if the operation succeeded + */ + public boolean saveConfiguration() { + boolean result; + enforceChangePermission(); + synchronized (mWifiStateTracker) { + result = WifiNative.saveConfigCommand(); + if (result && mNeedReconfig) { + mNeedReconfig = false; + result = WifiNative.reloadConfigCommand(); + + if (result) { + Intent intent = new Intent(WifiManager.NETWORK_IDS_CHANGED_ACTION); + mContext.sendBroadcast(intent); + } + } + } + return result; + } + + /** + * Set the number of radio frequency channels that are allowed to be used + * in the current regulatory domain. This method should be used only + * if the correct number of channels cannot be determined automatically + * for some reason. If the operation is successful, the new value is + * persisted as a Secure setting. + * @param numChannels the number of allowed channels. Must be greater than 0 + * and less than or equal to 16. + * @return {@code true} if the operation succeeds, {@code false} otherwise, e.g., + * {@code numChannels} is outside the valid range. + */ + public boolean setNumAllowedChannels(int numChannels) { + enforceChangePermission(); + /* + * Validate the argument. We'd like to let the Wi-Fi driver do this, + * but if Wi-Fi isn't currently enabled, that's not possible, and + * we want to persist the setting anyway,so that it will take + * effect when Wi-Fi does become enabled. + */ + boolean found = false; + for (int validChan : sValidRegulatoryChannelCounts) { + if (validChan == numChannels) { + found = true; + break; + } + } + if (!found) { + return false; + } + + Settings.Secure.putInt(mContext.getContentResolver(), + Settings.Secure.WIFI_NUM_ALLOWED_CHANNELS, + numChannels); + mWifiStateTracker.setNumAllowedChannels(numChannels); + return true; + } + + /** + * Return the number of frequency channels that are allowed + * to be used in the current regulatory domain. + * @return the number of allowed channels, or {@code -1} if an error occurs + */ + public int getNumAllowedChannels() { + int numChannels; + + enforceAccessPermission(); + synchronized (mWifiStateTracker) { + /* + * If we can't get the value from the driver (e.g., because + * Wi-Fi is not currently enabled), get the value from + * Settings. + */ + numChannels = WifiNative.getNumAllowedChannelsCommand(); + if (numChannels < 0) { + numChannels = Settings.Secure.getInt(mContext.getContentResolver(), + Settings.Secure.WIFI_NUM_ALLOWED_CHANNELS, + -1); + } + } + return numChannels; + } + + /** + * Return the list of valid values for the number of allowed radio channels + * for various regulatory domains. + * @return the list of channel counts + */ + public int[] getValidChannelCounts() { + enforceAccessPermission(); + return sValidRegulatoryChannelCounts; + } + + /** + * Return the DHCP-assigned addresses from the last successful DHCP request, + * if any. + * @return the DHCP information + */ + public DhcpInfo getDhcpInfo() { + enforceAccessPermission(); + return mWifiStateTracker.getDhcpInfo(); + } + + private final BroadcastReceiver mReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + + long idleMillis = Settings.Gservices.getLong(mContext.getContentResolver(), + Settings.Gservices.WIFI_IDLE_MS, DEFAULT_IDLE_MILLIS); + int stayAwakeConditions = + Settings.System.getInt(mContext.getContentResolver(), + Settings.System.STAY_ON_WHILE_PLUGGED_IN, 0); + if (action.equals(Intent.ACTION_SCREEN_ON)) { + mAlarmManager.cancel(mIdleIntent); + mDeviceIdle = false; + mScreenOff = false; + } else if (action.equals(Intent.ACTION_SCREEN_OFF)) { + mScreenOff = true; + /* + * Set a timer to put Wi-Fi to sleep, but only if the screen is off + * AND the "stay on while plugged in" setting doesn't match the + * current power conditions (i.e, not plugged in, plugged in to USB, + * or plugged in to AC). + */ + if (!shouldWifiStayAwake(stayAwakeConditions, mPluggedType)) { + long triggerTime = System.currentTimeMillis() + idleMillis; + mAlarmManager.set(AlarmManager.RTC_WAKEUP, triggerTime, mIdleIntent); + } + /* we can return now -- there's nothing to do until we get the idle intent back */ + return; + } else if (action.equals(ACTION_DEVICE_IDLE)) { + mDeviceIdle = true; + } else if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { + /* + * Set a timer to put Wi-Fi to sleep, but only if the screen is off + * AND we are transitioning from a state in which the device was supposed + * to stay awake to a state in which it is not supposed to stay awake. + * If "stay awake" state is not changing, we do nothing, to avoid resetting + * the already-set timer. + */ + int pluggedType = intent.getIntExtra("plugged", 0); + if (mScreenOff && shouldWifiStayAwake(stayAwakeConditions, mPluggedType) && + !shouldWifiStayAwake(stayAwakeConditions, pluggedType)) { + long triggerTime = System.currentTimeMillis() + idleMillis; + mAlarmManager.set(AlarmManager.RTC_WAKEUP, triggerTime, mIdleIntent); + mPluggedType = pluggedType; + return; + } + mPluggedType = pluggedType; + } else { + return; + } + + updateWifiState(); + } + + /** + * Determines whether the Wi-Fi chipset should stay awake or be put to + * sleep. Looks at the setting for the sleep policy and the current + * conditions. + * + * @see #shouldDeviceStayAwake(int, int) + */ + private boolean shouldWifiStayAwake(int stayAwakeConditions, int pluggedType) { + int wifiSleepPolicy = Settings.System.getInt(mContext.getContentResolver(), + Settings.System.WIFI_SLEEP_POLICY, Settings.System.WIFI_SLEEP_POLICY_DEFAULT); + + if (wifiSleepPolicy == Settings.System.WIFI_SLEEP_POLICY_NEVER) { + // Never sleep + return true; + } else if ((wifiSleepPolicy == Settings.System.WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED) && + (pluggedType != 0)) { + // Never sleep while plugged, and we're plugged + return true; + } else { + // Default + return shouldDeviceStayAwake(stayAwakeConditions, pluggedType); + } + } + + /** + * Determine whether the bit value corresponding to {@code pluggedType} is set in + * the bit string {@code stayAwakeConditions}. Because a {@code pluggedType} value + * of {@code 0} isn't really a plugged type, but rather an indication that the + * device isn't plugged in at all, there is no bit value corresponding to a + * {@code pluggedType} value of {@code 0}. That is why we shift by + * {@code pluggedType — 1} instead of by {@code pluggedType}. + * @param stayAwakeConditions a bit string specifying which "plugged types" should + * keep the device (and hence Wi-Fi) awake. + * @param pluggedType the type of plug (USB, AC, or none) for which the check is + * being made + * @return {@code true} if {@code pluggedType} indicates that the device is + * supposed to stay awake, {@code false} otherwise. + */ + private boolean shouldDeviceStayAwake(int stayAwakeConditions, int pluggedType) { + return (stayAwakeConditions & pluggedType) != 0; + } + }; + + private void sendEnableMessage(boolean enable, boolean persist) { + Message msg = Message.obtain(mWifiHandler, + (enable ? MESSAGE_ENABLE_WIFI : MESSAGE_DISABLE_WIFI), + (persist ? 1 : 0), 0); + msg.sendToTarget(); + } + + private void sendStartMessage(boolean scanOnlyMode) { + Message.obtain(mWifiHandler, MESSAGE_START_WIFI, scanOnlyMode ? 1 : 0, 0).sendToTarget(); + } + + private void updateWifiState() { + boolean wifiEnabled = getPersistedWifiEnabled(); + boolean airplaneMode = isAirplaneModeOn(); + boolean lockHeld = mLocks.hasLocks(); + int strongestLockMode; + boolean wifiShouldBeEnabled = wifiEnabled && !airplaneMode; + boolean wifiShouldBeStarted = !mDeviceIdle || lockHeld; + if (mDeviceIdle && lockHeld) { + strongestLockMode = mLocks.getStrongestLockMode(); + } else { + strongestLockMode = WifiManager.WIFI_MODE_FULL; + } + + synchronized (mWifiHandler) { + if (mWifiState == WIFI_STATE_ENABLING && !airplaneMode) { + return; + } + if (wifiShouldBeEnabled) { + if (wifiShouldBeStarted) { + sWakeLock.acquire(); + sendEnableMessage(true, false); + sWakeLock.acquire(); + sendStartMessage(strongestLockMode == WifiManager.WIFI_MODE_SCAN_ONLY); + } else { + int wakeLockTimeout = + Settings.Secure.getInt( + mContext.getContentResolver(), + Settings.Secure.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS, + DEFAULT_WAKELOCK_TIMEOUT); + /* + * The following wakelock is held in order to ensure + * that the connectivity manager has time to fail over + * to the mobile data network. The connectivity manager + * releases it once mobile data connectivity has been + * established. If connectivity cannot be established, + * the wakelock is released after wakeLockTimeout + * milliseconds have elapsed. + */ + sDriverStopWakeLock.acquire(); + mWifiHandler.sendEmptyMessage(MESSAGE_STOP_WIFI); + mWifiHandler.sendEmptyMessageDelayed(MESSAGE_RELEASE_WAKELOCK, wakeLockTimeout); + } + } else { + sWakeLock.acquire(); + sendEnableMessage(false, false); + } + } + } + + private void registerForBroadcasts() { + IntentFilter intentFilter = new IntentFilter(); + if (isAirplaneSensitive()) { + intentFilter.addAction(Intent.ACTION_AIRPLANE_MODE_CHANGED); + } + intentFilter.addAction(Intent.ACTION_SCREEN_ON); + intentFilter.addAction(Intent.ACTION_SCREEN_OFF); + intentFilter.addAction(Intent.ACTION_BATTERY_CHANGED); + intentFilter.addAction(ACTION_DEVICE_IDLE); + mContext.registerReceiver(mReceiver, intentFilter); + } + + private boolean isAirplaneSensitive() { + String airplaneModeRadios = Settings.System.getString(mContext.getContentResolver(), + Settings.System.AIRPLANE_MODE_RADIOS); + return airplaneModeRadios == null + || airplaneModeRadios.contains(Settings.System.RADIO_WIFI); + } + + /** + * Returns true if Wi-Fi is sensitive to airplane mode, and airplane mode is + * currently on. + * @return {@code true} if airplane mode is on. + */ + private boolean isAirplaneModeOn() { + return isAirplaneSensitive() && Settings.System.getInt(mContext.getContentResolver(), + Settings.System.AIRPLANE_MODE_ON, 0) == 1; + } + + /** + * Handler that allows posting to the WifiThread. + */ + private class WifiHandler extends Handler { + public WifiHandler(Looper looper) { + super(looper); + } + + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + + case MESSAGE_ENABLE_WIFI: + setWifiEnabledBlocking(true, msg.arg1 == 1); + sWakeLock.release(); + break; + + case MESSAGE_START_WIFI: + mWifiStateTracker.setScanOnlyMode(msg.arg1 != 0); + mWifiStateTracker.restart(); + sWakeLock.release(); + break; + + case MESSAGE_DISABLE_WIFI: + // a non-zero msg.arg1 value means the "enabled" setting + // should be persisted + setWifiEnabledBlocking(false, msg.arg1 == 1); + sWakeLock.release(); + break; + + case MESSAGE_STOP_WIFI: + mWifiStateTracker.disconnectAndStop(); + // don't release wakelock + break; + + case MESSAGE_RELEASE_WAKELOCK: + synchronized (sDriverStopWakeLock) { + if (sDriverStopWakeLock.isHeld()) { + sDriverStopWakeLock.release(); + } + } + break; + } + } + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump WifiService from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + pw.println("Wi-Fi is " + stateName(mWifiState)); + pw.println("Stay-awake conditions: " + + Settings.System.getInt(mContext.getContentResolver(), + Settings.System.STAY_ON_WHILE_PLUGGED_IN, 0)); + pw.println(); + + pw.println("Internal state:"); + pw.println(mWifiStateTracker); + pw.println(); + pw.println("Latest scan results:"); + List<ScanResult> scanResults = mWifiStateTracker.getScanResultsList(); + if (scanResults != null && scanResults.size() != 0) { + pw.println(" BSSID Frequency RSSI Flags SSID"); + for (ScanResult r : scanResults) { + pw.printf(" %17s %9d %5d %-16s %s%n", + r.BSSID, + r.frequency, + r.level, + r.capabilities, + r.SSID == null ? "" : r.SSID); + } + } + pw.println(); + pw.println("Locks held:"); + mLocks.dump(pw); + } + + private static String stateName(int wifiState) { + switch (wifiState) { + case WIFI_STATE_DISABLING: + return "disabling"; + case WIFI_STATE_DISABLED: + return "disabled"; + case WIFI_STATE_ENABLING: + return "enabling"; + case WIFI_STATE_ENABLED: + return "enabled"; + case WIFI_STATE_UNKNOWN: + return "unknown state"; + default: + return "[invalid state]"; + } + } + + private class WifiLock implements IBinder.DeathRecipient { + String mTag; + int mLockMode; + IBinder mBinder; + + WifiLock(int lockMode, String tag, IBinder binder) { + super(); + mTag = tag; + mLockMode = lockMode; + mBinder = binder; + try { + mBinder.linkToDeath(this, 0); + } catch (RemoteException e) { + binderDied(); + } + } + + public void binderDied() { + synchronized (mLocks) { + releaseWifiLockLocked(mBinder); + } + } + + public String toString() { + return "WifiLock{" + mTag + " type=" + mLockMode + " binder=" + mBinder + "}"; + } + } + + private class LockList { + private List<WifiLock> mList; + + private LockList() { + mList = new ArrayList<WifiLock>(); + } + + private synchronized boolean hasLocks() { + return !mList.isEmpty(); + } + + private synchronized int getStrongestLockMode() { + if (mList.isEmpty()) { + return WifiManager.WIFI_MODE_FULL; + } + for (WifiLock l : mList) { + if (l.mLockMode == WifiManager.WIFI_MODE_FULL) { + return WifiManager.WIFI_MODE_FULL; + } + } + return WifiManager.WIFI_MODE_SCAN_ONLY; + } + + private void addLock(WifiLock lock) { + if (findLockByBinder(lock.mBinder) < 0) { + mList.add(lock); + } + } + + private WifiLock removeLock(IBinder binder) { + int index = findLockByBinder(binder); + if (index >= 0) { + return mList.remove(index); + } else { + return null; + } + } + + private int findLockByBinder(IBinder binder) { + int size = mList.size(); + for (int i = size - 1; i >= 0; i--) + if (mList.get(i).mBinder == binder) + return i; + return -1; + } + + private void dump(PrintWriter pw) { + for (WifiLock l : mList) { + pw.print(" "); + pw.println(l); + } + } + } + + public boolean acquireWifiLock(IBinder binder, int lockMode, String tag) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); + if (lockMode != WifiManager.WIFI_MODE_FULL && lockMode != WifiManager.WIFI_MODE_SCAN_ONLY) { + return false; + } + WifiLock wifiLock = new WifiLock(lockMode, tag, binder); + synchronized (mLocks) { + return acquireWifiLockLocked(wifiLock); + } + } + + private boolean acquireWifiLockLocked(WifiLock wifiLock) { + mLocks.addLock(wifiLock); + updateWifiState(); + return true; + } + + public boolean releaseWifiLock(IBinder lock) { + mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WAKE_LOCK, null); + synchronized (mLocks) { + return releaseWifiLockLocked(lock); + } + } + + private boolean releaseWifiLockLocked(IBinder lock) { + boolean result; + result = (mLocks.removeLock(lock) != null); + updateWifiState(); + return result; + } +} diff --git a/services/java/com/android/server/WifiWatchdogService.java b/services/java/com/android/server/WifiWatchdogService.java new file mode 100644 index 0000000..fe97b93 --- /dev/null +++ b/services/java/com/android/server/WifiWatchdogService.java @@ -0,0 +1,1332 @@ +/* + * 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.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.database.ContentObserver; +import android.net.NetworkInfo; +import android.net.DhcpInfo; +import android.net.wifi.ScanResult; +import android.net.wifi.WifiInfo; +import android.net.wifi.WifiManager; +import android.net.wifi.WifiStateTracker; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.provider.Settings; +import android.text.TextUtils; +import android.util.Config; +import android.util.Log; + +import java.io.IOException; +import java.net.DatagramPacket; +import java.net.DatagramSocket; +import java.net.InetAddress; +import java.net.SocketException; +import java.net.SocketTimeoutException; +import java.net.UnknownHostException; +import java.util.List; +import java.util.Random; + +/** + * {@link WifiWatchdogService} monitors the initial connection to a Wi-Fi + * network with multiple access points. After the framework successfully + * connects to an access point, the watchdog verifies whether the DNS server is + * reachable. If not, the watchdog blacklists the current access point, leading + * to a connection on another access point within the same network. + * <p> + * The watchdog has a few safeguards: + * <ul> + * <li>Only monitor networks with multiple access points + * <li>Only check at most {@link #getMaxApChecks()} different access points + * within the network before giving up + * <p> + * The watchdog checks for connectivity on an access point by ICMP pinging the + * DNS. There are settings that allow disabling the watchdog, or tweaking the + * acceptable packet loss (and other various parameters). + * <p> + * The core logic of the watchdog is done on the main watchdog thread. Wi-Fi + * callbacks can come in on other threads, so we must queue messages to the main + * watchdog thread's handler. Most (if not all) state is only written to from + * the main thread. + * + * {@hide} + */ +public class WifiWatchdogService { + private static final String TAG = "WifiWatchdogService"; + private static final boolean V = false || Config.LOGV; + private static final boolean D = true || Config.LOGD; + + /* + * When this was "net.dns1", sometimes the mobile data's DNS was seen + * instead due to a race condition. All we really care about is the + * DHCP-replied DNS server anyway. + */ + /** The system property whose value provides the current DNS address. */ + private static final String SYSTEMPROPERTY_KEY_DNS = "dhcp.tiwlan0.dns1"; + + private Context mContext; + private ContentResolver mContentResolver; + private WifiStateTracker mWifiStateTracker; + private WifiManager mWifiManager; + + /** + * The main watchdog thread. + */ + private WifiWatchdogThread mThread; + /** + * The handler for the main watchdog thread. + */ + private WifiWatchdogHandler mHandler; + + /** + * The current watchdog state. Only written from the main thread! + */ + private WatchdogState mState = WatchdogState.IDLE; + /** + * The SSID of the network that the watchdog is currently monitoring. Only + * touched in the main thread! + */ + private String mSsid; + /** + * The number of access points in the current network ({@link #mSsid}) that + * have been checked. Only touched in the main thread! + */ + private int mNumApsChecked; + /** Whether the current AP check should be canceled. */ + private boolean mShouldCancel; + + WifiWatchdogService(Context context, WifiStateTracker wifiStateTracker) { + mContext = context; + mContentResolver = context.getContentResolver(); + mWifiStateTracker = wifiStateTracker; + mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); + + createThread(); + + // The content observer to listen needs a handler, which createThread creates + registerForSettingsChanges(); + if (isWatchdogEnabled()) { + registerForWifiBroadcasts(); + } + + if (V) { + myLogV("WifiWatchdogService: Created"); + } + } + + /** + * Observes the watchdog on/off setting, and takes action when changed. + */ + private void registerForSettingsChanges() { + ContentResolver contentResolver = mContext.getContentResolver(); + contentResolver.registerContentObserver( + Settings.Secure.getUriFor(Settings.Secure.WIFI_WATCHDOG_ON), false, + new ContentObserver(mHandler) { + @Override + public void onChange(boolean selfChange) { + if (isWatchdogEnabled()) { + registerForWifiBroadcasts(); + } else { + unregisterForWifiBroadcasts(); + if (mHandler != null) { + mHandler.disableWatchdog(); + } + } + } + }); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_ON + */ + private boolean isWatchdogEnabled() { + return Settings.Secure.getInt(mContentResolver, Settings.Secure.WIFI_WATCHDOG_ON, 1) == 1; + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_AP_COUNT + */ + private int getApCount() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_AP_COUNT, 2); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT + */ + private int getInitialIgnoredPingCount() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT , 2); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_PING_COUNT + */ + private int getPingCount() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_PING_COUNT, 4); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_PING_TIMEOUT_MS + */ + private int getPingTimeoutMs() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS, 500); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_PING_DELAY_MS + */ + private int getPingDelayMs() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_PING_DELAY_MS, 250); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE + */ + private int getAcceptablePacketLossPercentage() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE, 25); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_MAX_AP_CHECKS + */ + private int getMaxApChecks() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_MAX_AP_CHECKS, 7); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED + */ + private boolean isBackgroundCheckEnabled() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED, 1) == 1; + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS + */ + private int getBackgroundCheckDelayMs() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS, 60000); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS + */ + private int getBackgroundCheckTimeoutMs() { + return Settings.Secure.getInt(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS, 1000); + } + + /** + * @see android.provider.Settings.Secure#WIFI_WATCHDOG_WATCH_LIST + * @return the comma-separated list of SSIDs + */ + private String getWatchList() { + return Settings.Secure.getString(mContentResolver, + Settings.Secure.WIFI_WATCHDOG_WATCH_LIST); + } + + /** + * Registers to receive the necessary Wi-Fi broadcasts. + */ + private void registerForWifiBroadcasts() { + IntentFilter intentFilter = new IntentFilter(); + intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); + intentFilter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION); + intentFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); + mContext.registerReceiver(mReceiver, intentFilter); + } + + /** + * Unregisters from receiving the Wi-Fi broadcasts. + */ + private void unregisterForWifiBroadcasts() { + mContext.unregisterReceiver(mReceiver); + } + + /** + * Creates the main watchdog thread, including waiting for the handler to be + * created. + */ + private void createThread() { + mThread = new WifiWatchdogThread(); + mThread.start(); + waitForHandlerCreation(); + } + + /** + * Waits for the main watchdog thread to create the handler. + */ + private void waitForHandlerCreation() { + synchronized(this) { + while (mHandler == null) { + try { + // Wait for the handler to be set by the other thread + wait(); + } catch (InterruptedException e) { + Log.e(TAG, "Interrupted while waiting on handler."); + } + } + } + } + + // Utility methods + + /** + * Logs with the current thread. + */ + private static void myLogV(String message) { + Log.v(TAG, "(" + Thread.currentThread().getName() + ") " + message); + } + + private static void myLogD(String message) { + Log.d(TAG, "(" + Thread.currentThread().getName() + ") " + message); + } + + /** + * Gets the DNS of the current AP. + * + * @return The DNS of the current AP. + */ + private int getDns() { + DhcpInfo addressInfo = mWifiManager.getDhcpInfo(); + if (addressInfo != null) { + return addressInfo.dns1; + } else { + return -1; + } + } + + /** + * Checks whether the DNS can be reached using multiple attempts according + * to the current setting values. + * + * @return Whether the DNS is reachable + */ + private boolean checkDnsConnectivity() { + int dns = getDns(); + if (dns == -1) { + if (V) { + myLogV("checkDnsConnectivity: Invalid DNS, returning false"); + } + return false; + } + + if (V) { + myLogV("checkDnsConnectivity: Checking 0x" + + Integer.toHexString(Integer.reverseBytes(dns)) + " for connectivity"); + } + + int numInitialIgnoredPings = getInitialIgnoredPingCount(); + int numPings = getPingCount(); + int pingDelay = getPingDelayMs(); + int acceptableLoss = getAcceptablePacketLossPercentage(); + + /** See {@link Secure#WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT} */ + int ignoredPingCounter = 0; + int pingCounter = 0; + int successCounter = 0; + + // No connectivity check needed + if (numPings == 0) { + return true; + } + + // Do the initial pings that we ignore + for (; ignoredPingCounter < numInitialIgnoredPings; ignoredPingCounter++) { + if (shouldCancel()) return false; + + boolean dnsAlive = DnsPinger.isDnsReachable(dns, getPingTimeoutMs()); + if (dnsAlive) { + /* + * Successful "ignored" pings are *not* ignored (they count in the total number + * of pings), but failures are really ignored. + */ + pingCounter++; + successCounter++; + } + + if (V) { + Log.v(TAG, (dnsAlive ? " +" : " Ignored: -")); + } + + if (shouldCancel()) return false; + + try { + Thread.sleep(pingDelay); + } catch (InterruptedException e) { + Log.w(TAG, "Interrupted while pausing between pings", e); + } + } + + // Do the pings that we use to measure packet loss + for (; pingCounter < numPings; pingCounter++) { + if (shouldCancel()) return false; + + if (DnsPinger.isDnsReachable(dns, getPingTimeoutMs())) { + successCounter++; + if (V) { + Log.v(TAG, " +"); + } + } else { + if (V) { + Log.v(TAG, " -"); + } + } + + if (shouldCancel()) return false; + + try { + Thread.sleep(pingDelay); + } catch (InterruptedException e) { + Log.w(TAG, "Interrupted while pausing between pings", e); + } + } + + int packetLossPercentage = 100 * (numPings - successCounter) / numPings; + if (D) { + Log.d(TAG, packetLossPercentage + + "% packet loss (acceptable is " + acceptableLoss + "%)"); + } + + return !shouldCancel() && (packetLossPercentage <= acceptableLoss); + } + + private boolean backgroundCheckDnsConnectivity() { + int dns = getDns(); + if (false && V) { + myLogV("backgroundCheckDnsConnectivity: Background checking " + dns + + " for connectivity"); + } + + if (dns == -1) { + if (V) { + myLogV("backgroundCheckDnsConnectivity: DNS is empty, returning false"); + } + return false; + } + + return DnsPinger.isDnsReachable(dns, getBackgroundCheckTimeoutMs()); + } + + /** + * Signals the current action to cancel. + */ + private void cancelCurrentAction() { + mShouldCancel = true; + } + + /** + * Helper to check whether to cancel. + * + * @return Whether to cancel processing the action. + */ + private boolean shouldCancel() { + if (V && mShouldCancel) { + myLogV("shouldCancel: Cancelling"); + } + + return mShouldCancel; + } + + // Wi-Fi initiated callbacks (could be executed in another thread) + + /** + * Called when connected to an AP (this can be the next AP in line, or + * it can be a completely different network). + * + * @param ssid The SSID of the access point. + * @param bssid The BSSID of the access point. + */ + private void onConnected(String ssid, String bssid) { + if (V) { + myLogV("onConnected: SSID: " + ssid + ", BSSID: " + bssid); + } + + /* + * The current action being processed by the main watchdog thread is now + * stale, so cancel it. + */ + cancelCurrentAction(); + + if ((mSsid == null) || !mSsid.equals(ssid)) { + /* + * This is a different network than what the main watchdog thread is + * processing, dispatch the network change message on the main thread. + */ + mHandler.dispatchNetworkChanged(ssid); + } + + if (requiresWatchdog(ssid, bssid)) { + if (D) { + myLogD(ssid + " (" + bssid + ") requires the watchdog"); + } + + // This access point requires a watchdog, so queue the check on the main thread + mHandler.checkAp(new AccessPoint(ssid, bssid)); + + } else { + if (D) { + myLogD(ssid + " (" + bssid + ") does not require the watchdog"); + } + + // This access point does not require a watchdog, so queue idle on the main thread + mHandler.idle(); + } + } + + /** + * Called when Wi-Fi is enabled. + */ + private void onEnabled() { + cancelCurrentAction(); + // Queue a hard-reset of the state on the main thread + mHandler.reset(); + } + + /** + * Called when disconnected (or some other event similar to being disconnected). + */ + private void onDisconnected() { + if (V) { + myLogV("onDisconnected"); + } + + /* + * Disconnected from an access point, the action being processed by the + * watchdog thread is now stale, so cancel it. + */ + cancelCurrentAction(); + // Dispatch the disconnected to the main watchdog thread + mHandler.dispatchDisconnected(); + // Queue the action to go idle + mHandler.idle(); + } + + /** + * Checks whether an access point requires watchdog monitoring. + * + * @param ssid The SSID of the access point. + * @param bssid The BSSID of the access point. + * @return Whether the access point/network should be monitored by the + * watchdog. + */ + private boolean requiresWatchdog(String ssid, String bssid) { + if (V) { + myLogV("requiresWatchdog: SSID: " + ssid + ", BSSID: " + bssid); + } + + WifiInfo info = null; + if (ssid == null) { + /* + * This is called from a Wi-Fi callback, so assume the WifiInfo does + * not have stale data. + */ + info = mWifiManager.getConnectionInfo(); + ssid = info.getSSID(); + if (ssid == null) { + // It's still null, give up + if (V) { + Log.v(TAG, " Invalid SSID, returning false"); + } + return false; + } + } + + if (TextUtils.isEmpty(bssid)) { + // Similar as above + if (info == null) { + info = mWifiManager.getConnectionInfo(); + } + bssid = info.getBSSID(); + if (TextUtils.isEmpty(bssid)) { + // It's still null, give up + if (V) { + Log.v(TAG, " Invalid BSSID, returning false"); + } + return false; + } + } + + if (!isOnWatchList(ssid)) { + if (V) { + Log.v(TAG, " SSID not on watch list, returning false"); + } + return false; + } + + // The watchdog only monitors networks with multiple APs + if (!hasRequiredNumberOfAps(ssid)) { + return false; + } + + return true; + } + + private boolean isOnWatchList(String ssid) { + String watchList; + + if (ssid == null || (watchList = getWatchList()) == null) { + return false; + } + + String[] list = watchList.split(" *, *"); + + for (String name : list) { + if (ssid.equals(name)) { + return true; + } + } + + return false; + } + + /** + * Checks if the current scan results have multiple access points with an SSID. + * + * @param ssid The SSID to check. + * @return Whether the SSID has multiple access points. + */ + private boolean hasRequiredNumberOfAps(String ssid) { + List<ScanResult> results = mWifiManager.getScanResults(); + if (results == null) { + if (V) { + myLogV("hasRequiredNumberOfAps: Got null scan results, returning false"); + } + return false; + } + + int numApsRequired = getApCount(); + int numApsFound = 0; + int resultsSize = results.size(); + for (int i = 0; i < resultsSize; i++) { + ScanResult result = results.get(i); + if (result == null) continue; + if (result.SSID == null) continue; + + if (result.SSID.equals(ssid)) { + numApsFound++; + + if (numApsFound >= numApsRequired) { + if (V) { + myLogV("hasRequiredNumberOfAps: SSID: " + ssid + ", returning true"); + } + return true; + } + } + } + + if (V) { + myLogV("hasRequiredNumberOfAps: SSID: " + ssid + ", returning false"); + } + return false; + } + + // Watchdog logic (assume all of these methods will be in our main thread) + + /** + * Handles a Wi-Fi network change (for example, from networkA to networkB). + */ + private void handleNetworkChanged(String ssid) { + // Set the SSID being monitored to the new SSID + mSsid = ssid; + // Set various state to that when being idle + setIdleState(true); + } + + /** + * Handles checking whether an AP is a "good" AP. If not, it will be blacklisted. + * + * @param ap The access point to check. + */ + private void handleCheckAp(AccessPoint ap) { + // Reset the cancel state since this is the entry point of this action + mShouldCancel = false; + + if (V) { + myLogV("handleCheckAp: AccessPoint: " + ap); + } + + // Make sure we are not sleeping + if (mState == WatchdogState.SLEEP) { + if (V) { + Log.v(TAG, " Sleeping (in " + mSsid + "), so returning"); + } + return; + } + + mState = WatchdogState.CHECKING_AP; + + /* + * Checks to make sure we haven't exceeded the max number of checks + * we're allowed per network + */ + mNumApsChecked++; + if (mNumApsChecked > getMaxApChecks()) { + if (V) { + Log.v(TAG, " Passed the max attempts (" + getMaxApChecks() + + "), going to sleep for " + mSsid); + } + mHandler.sleep(mSsid); + return; + } + + // Do the check + boolean isApAlive = checkDnsConnectivity(); + + if (V) { + Log.v(TAG, " Is it alive: " + isApAlive); + } + + // Take action based on results + if (isApAlive) { + handleApAlive(ap); + } else { + handleApUnresponsive(ap); + } + } + + /** + * Handles the case when an access point is alive. + * + * @param ap The access point. + */ + private void handleApAlive(AccessPoint ap) { + // Check whether we are stale and should cancel + if (shouldCancel()) return; + // We're satisfied with this AP, so go idle + setIdleState(false); + + if (D) { + myLogD("AP is alive: " + ap.toString()); + } + + // Queue the next action to be a background check + mHandler.backgroundCheckAp(ap); + } + + /** + * Handles an unresponsive AP by blacklisting it. + * + * @param ap The access point. + */ + private void handleApUnresponsive(AccessPoint ap) { + // Check whether we are stale and should cancel + if (shouldCancel()) return; + // This AP is "bad", switch to another + mState = WatchdogState.SWITCHING_AP; + + if (D) { + myLogD("AP is dead: " + ap.toString()); + } + + // Black list this "bad" AP, this will cause an attempt to connect to another + blacklistAp(ap.bssid); + } + + private void blacklistAp(String bssid) { + if (TextUtils.isEmpty(bssid)) { + return; + } + + // Before taking action, make sure we should not cancel our processing + if (shouldCancel()) return; + + if (!mWifiStateTracker.addToBlacklist(bssid)) { + // There's a known bug where this method returns failure on success + //Log.e(TAG, "Blacklisting " + bssid + " failed"); + } + + if (D) { + myLogD("Blacklisting " + bssid); + } + } + + /** + * Handles a single background check. If it fails, it should trigger a + * normal check. If it succeeds, it should queue another background check. + * + * @param ap The access point to do a background check for. If this is no + * longer the current AP, it is okay to return without any + * processing. + */ + private void handleBackgroundCheckAp(AccessPoint ap) { + // Reset the cancel state since this is the entry point of this action + mShouldCancel = false; + + if (false && V) { + myLogV("handleBackgroundCheckAp: AccessPoint: " + ap); + } + + // Make sure we are not sleeping + if (mState == WatchdogState.SLEEP) { + if (V) { + Log.v(TAG, " handleBackgroundCheckAp: Sleeping (in " + mSsid + "), so returning"); + } + return; + } + + // Make sure the AP we're supposed to be background checking is still the active one + WifiInfo info = mWifiManager.getConnectionInfo(); + if (info.getSSID() == null || !info.getSSID().equals(ap.ssid)) { + if (V) { + myLogV("handleBackgroundCheckAp: We are no longer connected to " + + ap + ", and instead are on " + info); + } + return; + } + + if (info.getBSSID() == null || !info.getBSSID().equals(ap.bssid)) { + if (V) { + myLogV("handleBackgroundCheckAp: We are no longer connected to " + + ap + ", and instead are on " + info); + } + return; + } + + // Do the check + boolean isApAlive = backgroundCheckDnsConnectivity(); + + if (V && !isApAlive) { + Log.v(TAG, " handleBackgroundCheckAp: Is it alive: " + isApAlive); + } + + if (shouldCancel()) { + return; + } + + // Take action based on results + if (isApAlive) { + // Queue another background check + mHandler.backgroundCheckAp(ap); + + } else { + if (D) { + myLogD("Background check failed for " + ap.toString()); + } + + // Queue a normal check, so it can take proper action + mHandler.checkAp(ap); + } + } + + /** + * Handles going to sleep for this network. Going to sleep means we will not + * monitor this network anymore. + * + * @param ssid The network that will not be monitored anymore. + */ + private void handleSleep(String ssid) { + // Make sure the network we're trying to sleep in is still the current network + if (ssid != null && ssid.equals(mSsid)) { + mState = WatchdogState.SLEEP; + + if (D) { + myLogD("Going to sleep for " + ssid); + } + + /* + * Before deciding to go to sleep, we may have checked a few APs + * (and blacklisted them). Clear the blacklist so the AP with best + * signal is chosen. + */ + if (!mWifiStateTracker.clearBlacklist()) { + // There's a known bug where this method returns failure on success + //Log.e(TAG, "Clearing blacklist failed"); + } + + if (V) { + myLogV("handleSleep: Set state to SLEEP and cleared blacklist"); + } + } + } + + /** + * Handles an access point disconnection. + */ + private void handleDisconnected() { + /* + * We purposefully do not change mSsid to null. This is to handle + * disconnected followed by connected better (even if there is some + * duration in between). For example, if the watchdog went to sleep in a + * network, and then the phone goes to sleep, when the phone wakes up we + * still want to be in the sleeping state. When the phone went to sleep, + * we would have gotten a disconnected event which would then set mSsid + * = null. This is bad, since the following connect would cause us to do + * the "network is good?" check all over again. */ + + /* + * Set the state as if we were idle (don't come out of sleep, only + * hard reset and network changed should do that. + */ + setIdleState(false); + } + + /** + * Handles going idle. Idle means we are satisfied with the current state of + * things, but if a new connection occurs we'll re-evaluate. + */ + private void handleIdle() { + // Reset the cancel state since this is the entry point for this action + mShouldCancel = false; + + if (V) { + myLogV("handleSwitchToIdle"); + } + + // If we're sleeping, don't do anything + if (mState == WatchdogState.SLEEP) { + Log.v(TAG, " Sleeping (in " + mSsid + "), so returning"); + return; + } + + // Set the idle state + setIdleState(false); + + if (V) { + Log.v(TAG, " Set state to IDLE"); + } + } + + /** + * Sets the state as if we are going idle. + */ + private void setIdleState(boolean forceIdleState) { + // Setting idle state does not kick us out of sleep unless the forceIdleState is set + if (forceIdleState || (mState != WatchdogState.SLEEP)) { + mState = WatchdogState.IDLE; + } + mNumApsChecked = 0; + } + + /** + * Handles a hard reset. A hard reset is rarely used, but when used it + * should revert anything done by the watchdog monitoring. + */ + private void handleReset() { + mWifiStateTracker.clearBlacklist(); + setIdleState(true); + } + + // Inner classes + + /** + * Possible states for the watchdog to be in. + */ + private static enum WatchdogState { + /** The watchdog is currently idle, but it is still responsive to future AP checks in this network. */ + IDLE, + /** The watchdog is sleeping, so it will not try any AP checks for the network. */ + SLEEP, + /** The watchdog is currently checking an AP for connectivity. */ + CHECKING_AP, + /** The watchdog is switching to another AP in the network. */ + SWITCHING_AP + } + + /** + * The main thread for the watchdog monitoring. This will be turned into a + * {@link Looper} thread. + */ + private class WifiWatchdogThread extends Thread { + WifiWatchdogThread() { + super("WifiWatchdogThread"); + } + + @Override + public void run() { + // Set this thread up so the handler will work on it + Looper.prepare(); + + synchronized(WifiWatchdogService.this) { + mHandler = new WifiWatchdogHandler(); + + // Notify that the handler has been created + WifiWatchdogService.this.notify(); + } + + // Listen for messages to the handler + Looper.loop(); + } + } + + /** + * The main thread's handler. There are 'actions', and just general + * 'messages'. There should only ever be one 'action' in the queue (aside + * from the one being processed, if any). There may be multiple messages in + * the queue. So, actions are replaced by more recent actions, where as + * messages will be executed for sure. Messages end up being used to just + * change some state, and not really take any action. + * <p> + * There is little logic inside this class, instead methods of the form + * "handle___" are called in the main {@link WifiWatchdogService}. + */ + private class WifiWatchdogHandler extends Handler { + /** Check whether the AP is "good". The object will be an {@link AccessPoint}. */ + static final int ACTION_CHECK_AP = 1; + /** Go into the idle state. */ + static final int ACTION_IDLE = 2; + /** + * Performs a periodic background check whether the AP is still "good". + * The object will be an {@link AccessPoint}. + */ + static final int ACTION_BACKGROUND_CHECK_AP = 3; + + /** + * Go to sleep for the current network. We are conservative with making + * this a message rather than action. We want to make sure our main + * thread sees this message, but if it were an action it could be + * removed from the queue and replaced by another action. The main + * thread will ensure when it sees the message that the state is still + * valid for going to sleep. + * <p> + * For an explanation of sleep, see {@link android.provider.Settings.Secure#WIFI_WATCHDOG_MAX_AP_CHECKS}. + */ + static final int MESSAGE_SLEEP = 101; + /** Disables the watchdog. */ + static final int MESSAGE_DISABLE_WATCHDOG = 102; + /** The network has changed. */ + static final int MESSAGE_NETWORK_CHANGED = 103; + /** The current access point has disconnected. */ + static final int MESSAGE_DISCONNECTED = 104; + /** Performs a hard-reset on the watchdog state. */ + static final int MESSAGE_RESET = 105; + + void checkAp(AccessPoint ap) { + removeAllActions(); + sendMessage(obtainMessage(ACTION_CHECK_AP, ap)); + } + + void backgroundCheckAp(AccessPoint ap) { + if (!isBackgroundCheckEnabled()) return; + + removeAllActions(); + sendMessageDelayed(obtainMessage(ACTION_BACKGROUND_CHECK_AP, ap), + getBackgroundCheckDelayMs()); + } + + void idle() { + removeAllActions(); + sendMessage(obtainMessage(ACTION_IDLE)); + } + + void sleep(String ssid) { + removeAllActions(); + sendMessage(obtainMessage(MESSAGE_SLEEP, ssid)); + } + + void disableWatchdog() { + removeAllActions(); + sendMessage(obtainMessage(MESSAGE_DISABLE_WATCHDOG)); + } + + void dispatchNetworkChanged(String ssid) { + removeAllActions(); + sendMessage(obtainMessage(MESSAGE_NETWORK_CHANGED, ssid)); + } + + void dispatchDisconnected() { + removeAllActions(); + sendMessage(obtainMessage(MESSAGE_DISCONNECTED)); + } + + void reset() { + removeAllActions(); + sendMessage(obtainMessage(MESSAGE_RESET)); + } + + private void removeAllActions() { + removeMessages(ACTION_CHECK_AP); + removeMessages(ACTION_IDLE); + removeMessages(ACTION_BACKGROUND_CHECK_AP); + } + + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case MESSAGE_NETWORK_CHANGED: + handleNetworkChanged((String) msg.obj); + break; + case ACTION_CHECK_AP: + handleCheckAp((AccessPoint) msg.obj); + break; + case ACTION_BACKGROUND_CHECK_AP: + handleBackgroundCheckAp((AccessPoint) msg.obj); + break; + case MESSAGE_SLEEP: + handleSleep((String) msg.obj); + break; + case ACTION_IDLE: + handleIdle(); + break; + case MESSAGE_DISABLE_WATCHDOG: + handleIdle(); + break; + case MESSAGE_DISCONNECTED: + handleDisconnected(); + break; + case MESSAGE_RESET: + handleReset(); + break; + } + } + } + + /** + * Receives Wi-Fi broadcasts. + * <p> + * There is little logic in this class, instead methods of the form "on___" + * are called in the {@link WifiWatchdogService}. + */ + private BroadcastReceiver mReceiver = new BroadcastReceiver() { + + @Override + public void onReceive(Context context, Intent intent) { + final String action = intent.getAction(); + if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) { + handleNetworkStateChanged( + (NetworkInfo) intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO)); + } else if (action.equals(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION)) { + handleSupplicantConnectionChanged( + intent.getBooleanExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, false)); + } else if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) { + handleWifiStateChanged(intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, + WifiManager.WIFI_STATE_UNKNOWN)); + } + } + + private void handleNetworkStateChanged(NetworkInfo info) { + if (V) { + myLogV("Receiver.handleNetworkStateChanged: NetworkInfo: " + + info); + } + + switch (info.getState()) { + case CONNECTED: + WifiInfo wifiInfo = mWifiManager.getConnectionInfo(); + if (wifiInfo.getSSID() == null || wifiInfo.getBSSID() == null) { + if (V) { + myLogV("handleNetworkStateChanged: Got connected event but SSID or BSSID are null. SSID: " + + wifiInfo.getSSID() + + ", BSSID: " + + wifiInfo.getBSSID() + ", ignoring event"); + } + return; + } + onConnected(wifiInfo.getSSID(), wifiInfo.getBSSID()); + break; + + case DISCONNECTED: + onDisconnected(); + break; + } + } + + private void handleSupplicantConnectionChanged(boolean connected) { + if (!connected) { + onDisconnected(); + } + } + + private void handleWifiStateChanged(int wifiState) { + if (wifiState == WifiManager.WIFI_STATE_DISABLED) { + onDisconnected(); + } else if (wifiState == WifiManager.WIFI_STATE_ENABLED) { + onEnabled(); + } + } + }; + + /** + * Describes an access point by its SSID and BSSID. + */ + private static class AccessPoint { + String ssid; + String bssid; + + AccessPoint(String ssid, String bssid) { + this.ssid = ssid; + this.bssid = bssid; + } + + private boolean hasNull() { + return ssid == null || bssid == null; + } + + @Override + public boolean equals(Object o) { + if (!(o instanceof AccessPoint)) return false; + AccessPoint otherAp = (AccessPoint) o; + boolean iHaveNull = hasNull(); + // Either we both have a null, or our SSIDs and BSSIDs are equal + return (iHaveNull && otherAp.hasNull()) || + (otherAp.bssid != null && ssid.equals(otherAp.ssid) + && bssid.equals(otherAp.bssid)); + } + + @Override + public int hashCode() { + if (ssid == null || bssid == null) return 0; + return ssid.hashCode() + bssid.hashCode(); + } + + @Override + public String toString() { + return ssid + " (" + bssid + ")"; + } + } + + /** + * Performs a simple DNS "ping" by sending a "server status" query packet to + * the DNS server. As long as the server replies, we consider it a success. + * <p> + * We do not use a simple hostname lookup because that could be cached and + * the API may not differentiate between a time out and a failure lookup + * (which we really care about). + */ + private static class DnsPinger { + + /** Number of bytes for the query */ + private static final int DNS_QUERY_BASE_SIZE = 33; + + /** The DNS port */ + private static final int DNS_PORT = 53; + + /** Used to generate IDs */ + private static Random sRandom = new Random(); + + static boolean isDnsReachable(int dns, int timeout) { + try { + DatagramSocket socket = new DatagramSocket(); + + // Set some socket properties + socket.setSoTimeout(timeout); + + byte[] buf = new byte[DNS_QUERY_BASE_SIZE]; + fillQuery(buf); + + // Send the DNS query + byte parts[] = new byte[4]; + parts[0] = (byte)(dns & 0xff); + parts[1] = (byte)((dns >> 8) & 0xff); + parts[2] = (byte)((dns >> 16) & 0xff); + parts[3] = (byte)((dns >> 24) & 0xff); + + InetAddress dnsAddress = InetAddress.getByAddress(parts); + DatagramPacket packet = new DatagramPacket(buf, + buf.length, dnsAddress, DNS_PORT); + socket.send(packet); + + // Wait for reply (blocks for the above timeout) + DatagramPacket replyPacket = new DatagramPacket(buf, buf.length); + socket.receive(replyPacket); + + // If a timeout occurred, an exception would have been thrown. We got a reply! + return true; + + } catch (SocketException e) { + if (V) { + Log.v(TAG, "DnsPinger.isReachable received SocketException", e); + } + return false; + + } catch (UnknownHostException e) { + if (V) { + Log.v(TAG, "DnsPinger.isReachable is unable to resolve the DNS host", e); + } + return false; + + } catch (SocketTimeoutException e) { + return false; + + } catch (IOException e) { + if (V) { + Log.v(TAG, "DnsPinger.isReachable got an IOException", e); + } + return false; + + } catch (Exception e) { + if (V || Config.LOGD) { + Log.d(TAG, "DnsPinger.isReachable got an unknown exception", e); + } + return false; + } + } + + private static void fillQuery(byte[] buf) { + + /* + * See RFC2929 (though the bit tables in there are misleading for + * us. For example, the recursion desired bit is the 0th bit for us, + * but looking there it would appear as the 7th bit of the byte + */ + + // Make sure it's all zeroed out + for (int i = 0; i < buf.length; i++) buf[i] = 0; + + // Form a query for www.android.com + + // [0-1] bytes are an ID, generate random ID for this query + buf[0] = (byte) sRandom.nextInt(256); + buf[1] = (byte) sRandom.nextInt(256); + + // [2-3] bytes are for flags. + buf[2] = 1; // Recursion desired + + // [4-5] bytes are for the query count + buf[5] = 1; // One query + + // [6-7] [8-9] [10-11] are all counts of other fields we don't use + + // [12-15] for www + writeString(buf, 12, "www"); + + // [16-23] for android + writeString(buf, 16, "android"); + + // [24-27] for com + writeString(buf, 24, "com"); + + // [29-30] bytes are for QTYPE, set to 1 + buf[30] = 1; + + // [31-32] bytes are for QCLASS, set to 1 + buf[32] = 1; + } + + private static void writeString(byte[] buf, int startPos, String string) { + int pos = startPos; + + // Write the length first + buf[pos++] = (byte) string.length(); + for (int i = 0; i < string.length(); i++) { + buf[pos++] = (byte) string.charAt(i); + } + } + } +} diff --git a/services/java/com/android/server/WindowManagerService.java b/services/java/com/android/server/WindowManagerService.java new file mode 100644 index 0000000..48570d2 --- /dev/null +++ b/services/java/com/android/server/WindowManagerService.java @@ -0,0 +1,8731 @@ +/* + * Copyright (C) 2007 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 static android.os.LocalPowerManager.CHEEK_EVENT; +import static android.os.LocalPowerManager.OTHER_EVENT; +import static android.os.LocalPowerManager.TOUCH_EVENT; +import static android.view.WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW; +import static android.view.WindowManager.LayoutParams.FIRST_SUB_WINDOW; +import static android.view.WindowManager.LayoutParams.FLAG_BLUR_BEHIND; +import static android.view.WindowManager.LayoutParams.FLAG_DIM_BEHIND; +import static android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON; +import static android.view.WindowManager.LayoutParams.FLAG_SYSTEM_ERROR; +import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE; +import static android.view.WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM; +import static android.view.WindowManager.LayoutParams.LAST_APPLICATION_WINDOW; +import static android.view.WindowManager.LayoutParams.LAST_SUB_WINDOW; +import static android.view.WindowManager.LayoutParams.MEMORY_TYPE_GPU; +import static android.view.WindowManager.LayoutParams.MEMORY_TYPE_HARDWARE; +import static android.view.WindowManager.LayoutParams.MEMORY_TYPE_PUSH_BUFFERS; +import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING; +import static android.view.WindowManager.LayoutParams.TYPE_BASE_APPLICATION; +import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD; +import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG; + +import com.android.internal.app.IBatteryStats; +import com.android.internal.policy.PolicyManager; +import com.android.internal.view.IInputContext; +import com.android.internal.view.IInputMethodClient; +import com.android.internal.view.IInputMethodManager; +import com.android.server.KeyInputQueue.QueuedEvent; +import com.android.server.am.BatteryStatsService; + +import android.Manifest; +import android.app.ActivityManagerNative; +import android.app.IActivityManager; +import android.content.Context; +import android.content.pm.ActivityInfo; +import android.content.pm.PackageManager; +import android.content.res.Configuration; +import android.graphics.Matrix; +import android.graphics.PixelFormat; +import android.graphics.Rect; +import android.graphics.Region; +import android.os.BatteryStats; +import android.os.Binder; +import android.os.Debug; +import android.os.Handler; +import android.os.IBinder; +import android.os.LocalPowerManager; +import android.os.Looper; +import android.os.Message; +import android.os.Parcel; +import android.os.ParcelFileDescriptor; +import android.os.Power; +import android.os.PowerManager; +import android.os.Process; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.os.TokenWatcher; +import android.provider.Settings; +import android.util.Config; +import android.util.EventLog; +import android.util.Log; +import android.util.SparseIntArray; +import android.view.Display; +import android.view.Gravity; +import android.view.IApplicationToken; +import android.view.IOnKeyguardExitResult; +import android.view.IRotationWatcher; +import android.view.IWindow; +import android.view.IWindowManager; +import android.view.IWindowSession; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.RawInputEvent; +import android.view.Surface; +import android.view.SurfaceSession; +import android.view.View; +import android.view.ViewTreeObserver; +import android.view.WindowManager; +import android.view.WindowManagerImpl; +import android.view.WindowManagerPolicy; +import android.view.WindowManager.LayoutParams; +import android.view.animation.Animation; +import android.view.animation.AnimationUtils; +import android.view.animation.Transformation; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileDescriptor; +import java.io.IOException; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.net.Socket; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; + +/** {@hide} */ +public class WindowManagerService extends IWindowManager.Stub implements Watchdog.Monitor { + static final String TAG = "WindowManager"; + static final boolean DEBUG = false; + static final boolean DEBUG_FOCUS = false; + static final boolean DEBUG_ANIM = false; + static final boolean DEBUG_LAYERS = false; + static final boolean DEBUG_INPUT = false; + static final boolean DEBUG_INPUT_METHOD = false; + static final boolean DEBUG_VISIBILITY = false; + static final boolean DEBUG_ORIENTATION = false; + static final boolean DEBUG_APP_TRANSITIONS = false; + static final boolean DEBUG_STARTING_WINDOW = false; + static final boolean DEBUG_REORDER = false; + static final boolean SHOW_TRANSACTIONS = false; + + static final boolean PROFILE_ORIENTATION = false; + static final boolean BLUR = true; + static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV; + + static final int LOG_WM_NO_SURFACE_MEMORY = 31000; + + /** How long to wait for first key repeat, in milliseconds */ + static final int KEY_REPEAT_FIRST_DELAY = 750; + + /** How long to wait for subsequent key repeats, in milliseconds */ + static final int KEY_REPEAT_DELAY = 50; + + /** How much to multiply the policy's type layer, to reserve room + * for multiple windows of the same type and Z-ordering adjustment + * with TYPE_LAYER_OFFSET. */ + static final int TYPE_LAYER_MULTIPLIER = 10000; + + /** Offset from TYPE_LAYER_MULTIPLIER for moving a group of windows above + * or below others in the same layer. */ + static final int TYPE_LAYER_OFFSET = 1000; + + /** How much to increment the layer for each window, to reserve room + * for effect surfaces between them. + */ + static final int WINDOW_LAYER_MULTIPLIER = 5; + + /** The maximum length we will accept for a loaded animation duration: + * this is 10 seconds. + */ + static final int MAX_ANIMATION_DURATION = 10*1000; + + /** Amount of time (in milliseconds) to animate the dim surface from one + * value to another, when no window animation is driving it. + */ + static final int DEFAULT_DIM_DURATION = 200; + + /** Adjustment to time to perform a dim, to make it more dramatic. + */ + static final int DIM_DURATION_MULTIPLIER = 6; + + static final int UPDATE_FOCUS_NORMAL = 0; + static final int UPDATE_FOCUS_WILL_ASSIGN_LAYERS = 1; + static final int UPDATE_FOCUS_PLACING_SURFACES = 2; + static final int UPDATE_FOCUS_WILL_PLACE_SURFACES = 3; + + private static final String SYSTEM_SECURE = "ro.secure"; + + /** + * Condition waited on by {@link #reenableKeyguard} to know the call to + * the window policy has finished. + */ + private boolean mWaitingUntilKeyguardReenabled = false; + + + final TokenWatcher mKeyguardDisabled = new TokenWatcher( + new Handler(), "WindowManagerService.mKeyguardDisabled") { + public void acquired() { + mPolicy.enableKeyguard(false); + } + public void released() { + synchronized (mKeyguardDisabled) { + mPolicy.enableKeyguard(true); + mWaitingUntilKeyguardReenabled = false; + mKeyguardDisabled.notifyAll(); + } + } + }; + + final Context mContext; + + final boolean mHaveInputMethods; + + final boolean mLimitedAlphaCompositing; + + final WindowManagerPolicy mPolicy = PolicyManager.makeNewWindowManager(); + + final IActivityManager mActivityManager; + + final IBatteryStats mBatteryStats; + + /** + * All currently active sessions with clients. + */ + final HashSet<Session> mSessions = new HashSet<Session>(); + + /** + * Mapping from an IWindow IBinder to the server's Window object. + * This is also used as the lock for all of our state. + */ + final HashMap<IBinder, WindowState> mWindowMap = new HashMap<IBinder, WindowState>(); + + /** + * Mapping from a token IBinder to a WindowToken object. + */ + final HashMap<IBinder, WindowToken> mTokenMap = + new HashMap<IBinder, WindowToken>(); + + /** + * The same tokens as mTokenMap, stored in a list for efficient iteration + * over them. + */ + final ArrayList<WindowToken> mTokenList = new ArrayList<WindowToken>(); + + /** + * Window tokens that are in the process of exiting, but still + * on screen for animations. + */ + final ArrayList<WindowToken> mExitingTokens = new ArrayList<WindowToken>(); + + /** + * Z-ordered (bottom-most first) list of all application tokens, for + * controlling the ordering of windows in different applications. This + * contains WindowToken objects. + */ + final ArrayList<AppWindowToken> mAppTokens = new ArrayList<AppWindowToken>(); + + /** + * Application tokens that are in the process of exiting, but still + * on screen for animations. + */ + final ArrayList<AppWindowToken> mExitingAppTokens = new ArrayList<AppWindowToken>(); + + /** + * List of window tokens that have finished starting their application, + * and now need to have the policy remove their windows. + */ + final ArrayList<AppWindowToken> mFinishedStarting = new ArrayList<AppWindowToken>(); + + /** + * Z-ordered (bottom-most first) list of all Window objects. + */ + final ArrayList mWindows = new ArrayList(); + + /** + * Windows that are being resized. Used so we can tell the client about + * the resize after closing the transaction in which we resized the + * underlying surface. + */ + final ArrayList<WindowState> mResizingWindows = new ArrayList<WindowState>(); + + /** + * Windows whose animations have ended and now must be removed. + */ + final ArrayList<WindowState> mPendingRemove = new ArrayList<WindowState>(); + + /** + * Windows whose surface should be destroyed. + */ + final ArrayList<WindowState> mDestroySurface = new ArrayList<WindowState>(); + + /** + * Windows that have lost input focus and are waiting for the new + * focus window to be displayed before they are told about this. + */ + ArrayList<WindowState> mLosingFocus = new ArrayList<WindowState>(); + + /** + * This is set when we have run out of memory, and will either be an empty + * list or contain windows that need to be force removed. + */ + ArrayList<WindowState> mForceRemoves; + + IInputMethodManager mInputMethodManager; + + SurfaceSession mFxSession; + Surface mDimSurface; + boolean mDimShown; + float mDimCurrentAlpha; + float mDimTargetAlpha; + float mDimDeltaPerMs; + long mLastDimAnimTime; + Surface mBlurSurface; + boolean mBlurShown; + + int mTransactionSequence = 0; + + final float[] mTmpFloats = new float[9]; + + boolean mSafeMode; + boolean mDisplayEnabled = false; + boolean mSystemBooted = false; + int mRotation = 0; + int mRequestedRotation = 0; + int mForcedAppOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + ArrayList<IRotationWatcher> mRotationWatchers + = new ArrayList<IRotationWatcher>(); + + boolean mLayoutNeeded = true; + boolean mAnimationPending = false; + boolean mDisplayFrozen = false; + boolean mWindowsFreezingScreen = false; + long mFreezeGcPending = 0; + int mAppsFreezingScreen = 0; + + // This is held as long as we have the screen frozen, to give us time to + // perform a rotation animation when turning off shows the lock screen which + // changes the orientation. + PowerManager.WakeLock mScreenFrozenLock; + + // State management of app transitions. When we are preparing for a + // transition, mNextAppTransition will be the kind of transition to + // perform or TRANSIT_NONE if we are not waiting. If we are waiting, + // mOpeningApps and mClosingApps are the lists of tokens that will be + // made visible or hidden at the next transition. + int mNextAppTransition = WindowManagerPolicy.TRANSIT_NONE; + boolean mAppTransitionReady = false; + boolean mAppTransitionTimeout = false; + boolean mStartingIconInTransition = false; + boolean mSkipAppTransitionAnimation = false; + final ArrayList<AppWindowToken> mOpeningApps = new ArrayList<AppWindowToken>(); + final ArrayList<AppWindowToken> mClosingApps = new ArrayList<AppWindowToken>(); + + //flag to detect fat touch events + boolean mFatTouch = false; + Display mDisplay; + + H mH = new H(); + + WindowState mCurrentFocus = null; + WindowState mLastFocus = null; + + // This just indicates the window the input method is on top of, not + // necessarily the window its input is going to. + WindowState mInputMethodTarget = null; + WindowState mUpcomingInputMethodTarget = null; + boolean mInputMethodTargetWaitingAnim; + int mInputMethodAnimLayerAdjustment; + + WindowState mInputMethodWindow = null; + final ArrayList<WindowState> mInputMethodDialogs = new ArrayList<WindowState>(); + + AppWindowToken mFocusedApp = null; + + PowerManagerService mPowerManager; + + float mWindowAnimationScale = 1.0f; + float mTransitionAnimationScale = 1.0f; + + final KeyWaiter mKeyWaiter = new KeyWaiter(); + final KeyQ mQueue; + final InputDispatcherThread mInputThread; + + // Who is holding the screen on. + Session mHoldingScreenOn; + + /** + * Whether the UI is currently running in touch mode (not showing + * navigational focus because the user is directly pressing the screen). + */ + boolean mInTouchMode = false; + + private ViewServer mViewServer; + + final Rect mTempRect = new Rect(); + + public static WindowManagerService main(Context context, + PowerManagerService pm, boolean haveInputMethods) { + WMThread thr = new WMThread(context, pm, haveInputMethods); + thr.start(); + + synchronized (thr) { + while (thr.mService == null) { + try { + thr.wait(); + } catch (InterruptedException e) { + } + } + } + + return thr.mService; + } + + static class WMThread extends Thread { + WindowManagerService mService; + + private final Context mContext; + private final PowerManagerService mPM; + private final boolean mHaveInputMethods; + + public WMThread(Context context, PowerManagerService pm, + boolean haveInputMethods) { + super("WindowManager"); + mContext = context; + mPM = pm; + mHaveInputMethods = haveInputMethods; + } + + public void run() { + Looper.prepare(); + WindowManagerService s = new WindowManagerService(mContext, mPM, + mHaveInputMethods); + android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_DISPLAY); + + synchronized (this) { + mService = s; + notifyAll(); + } + + Looper.loop(); + } + } + + static class PolicyThread extends Thread { + private final WindowManagerPolicy mPolicy; + private final WindowManagerService mService; + private final Context mContext; + private final PowerManagerService mPM; + boolean mRunning = false; + + public PolicyThread(WindowManagerPolicy policy, + WindowManagerService service, Context context, + PowerManagerService pm) { + super("WindowManagerPolicy"); + mPolicy = policy; + mService = service; + mContext = context; + mPM = pm; + } + + public void run() { + Looper.prepare(); + //Looper.myLooper().setMessageLogging(new LogPrinter( + // Log.VERBOSE, "WindowManagerPolicy")); + android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_FOREGROUND); + mPolicy.init(mContext, mService, mPM); + + synchronized (this) { + mRunning = true; + notifyAll(); + } + + Looper.loop(); + } + } + + private WindowManagerService(Context context, PowerManagerService pm, + boolean haveInputMethods) { + mContext = context; + mHaveInputMethods = haveInputMethods; + mLimitedAlphaCompositing = context.getResources().getBoolean( + com.android.internal.R.bool.config_sf_limitedAlpha); + + mPowerManager = pm; + mPowerManager.setPolicy(mPolicy); + PowerManager pmc = (PowerManager)context.getSystemService(Context.POWER_SERVICE); + mScreenFrozenLock = pmc.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, + "SCREEN_FROZEN"); + mScreenFrozenLock.setReferenceCounted(false); + + mActivityManager = ActivityManagerNative.getDefault(); + mBatteryStats = BatteryStatsService.getService(); + + // Get persisted window scale setting + mWindowAnimationScale = Settings.System.getFloat(context.getContentResolver(), + Settings.System.WINDOW_ANIMATION_SCALE, mWindowAnimationScale); + mTransitionAnimationScale = Settings.System.getFloat(context.getContentResolver(), + Settings.System.TRANSITION_ANIMATION_SCALE, mTransitionAnimationScale); + + mQueue = new KeyQ(); + + mInputThread = new InputDispatcherThread(); + + PolicyThread thr = new PolicyThread(mPolicy, this, context, pm); + thr.start(); + + synchronized (thr) { + while (!thr.mRunning) { + try { + thr.wait(); + } catch (InterruptedException e) { + } + } + } + + mInputThread.start(); + + // Add ourself to the Watchdog monitors. + Watchdog.getInstance().addMonitor(this); + } + + @Override + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) + throws RemoteException { + try { + return super.onTransact(code, data, reply, flags); + } catch (RuntimeException e) { + // The window manager only throws security exceptions, so let's + // log all others. + if (!(e instanceof SecurityException)) { + Log.e(TAG, "Window Manager Crash", e); + } + throw e; + } + } + + private void placeWindowAfter(Object pos, WindowState window) { + final int i = mWindows.indexOf(pos); + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Adding window " + window + " at " + + (i+1) + " of " + mWindows.size() + " (after " + pos + ")"); + mWindows.add(i+1, window); + } + + private void placeWindowBefore(Object pos, WindowState window) { + final int i = mWindows.indexOf(pos); + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Adding window " + window + " at " + + i + " of " + mWindows.size() + " (before " + pos + ")"); + mWindows.add(i, window); + } + + //This method finds out the index of a window that has the same app token as + //win. used for z ordering the windows in mWindows + private int findIdxBasedOnAppTokens(WindowState win) { + //use a local variable to cache mWindows + ArrayList localmWindows = mWindows; + int jmax = localmWindows.size(); + if(jmax == 0) { + return -1; + } + for(int j = (jmax-1); j >= 0; j--) { + WindowState wentry = (WindowState)localmWindows.get(j); + if(wentry.mAppToken == win.mAppToken) { + return j; + } + } + return -1; + } + + private void addWindowToListInOrderLocked(WindowState win, boolean addToToken) { + final IWindow client = win.mClient; + final WindowToken token = win.mToken; + final ArrayList localmWindows = mWindows; + + final int N = localmWindows.size(); + final WindowState attached = win.mAttachedWindow; + int i; + if (attached == null) { + int tokenWindowsPos = token.windows.size(); + if (token.appWindowToken != null) { + int index = tokenWindowsPos-1; + if (index >= 0) { + // If this application has existing windows, we + // simply place the new window on top of them... but + // keep the starting window on top. + if (win.mAttrs.type == TYPE_BASE_APPLICATION) { + // Base windows go behind everything else. + placeWindowBefore(token.windows.get(0), win); + tokenWindowsPos = 0; + } else { + AppWindowToken atoken = win.mAppToken; + if (atoken != null && + token.windows.get(index) == atoken.startingWindow) { + placeWindowBefore(token.windows.get(index), win); + tokenWindowsPos--; + } else { + int newIdx = findIdxBasedOnAppTokens(win); + if(newIdx != -1) { + //there is a window above this one associated with the same + //apptoken note that the window could be a floating window + //that was created later or a window at the top of the list of + //windows associated with this token. + localmWindows.add(newIdx+1, win); + } + } + } + } else { + if (localLOGV) Log.v( + TAG, "Figuring out where to add app window " + + client.asBinder() + " (token=" + token + ")"); + // Figure out where the window should go, based on the + // order of applications. + final int NA = mAppTokens.size(); + Object pos = null; + for (i=NA-1; i>=0; i--) { + AppWindowToken t = mAppTokens.get(i); + if (t == token) { + i--; + break; + } + if (t.windows.size() > 0) { + pos = t.windows.get(0); + } + } + // We now know the index into the apps. If we found + // an app window above, that gives us the position; else + // we need to look some more. + if (pos != null) { + // Move behind any windows attached to this one. + WindowToken atoken = + mTokenMap.get(((WindowState)pos).mClient.asBinder()); + if (atoken != null) { + final int NC = atoken.windows.size(); + if (NC > 0) { + WindowState bottom = atoken.windows.get(0); + if (bottom.mSubLayer < 0) { + pos = bottom; + } + } + } + placeWindowBefore(pos, win); + } else { + while (i >= 0) { + AppWindowToken t = mAppTokens.get(i); + final int NW = t.windows.size(); + if (NW > 0) { + pos = t.windows.get(NW-1); + break; + } + i--; + } + if (pos != null) { + // Move in front of any windows attached to this + // one. + WindowToken atoken = + mTokenMap.get(((WindowState)pos).mClient.asBinder()); + if (atoken != null) { + final int NC = atoken.windows.size(); + if (NC > 0) { + WindowState top = atoken.windows.get(NC-1); + if (top.mSubLayer >= 0) { + pos = top; + } + } + } + placeWindowAfter(pos, win); + } else { + // Just search for the start of this layer. + final int myLayer = win.mBaseLayer; + for (i=0; i<N; i++) { + WindowState w = (WindowState)localmWindows.get(i); + if (w.mBaseLayer > myLayer) { + break; + } + } + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Adding window " + win + " at " + + i + " of " + N); + localmWindows.add(i, win); + } + } + } + } else { + // Figure out where window should go, based on layer. + final int myLayer = win.mBaseLayer; + for (i=N-1; i>=0; i--) { + if (((WindowState)localmWindows.get(i)).mBaseLayer <= myLayer) { + i++; + break; + } + } + if (i < 0) i = 0; + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Adding window " + win + " at " + + i + " of " + N); + localmWindows.add(i, win); + } + if (addToToken) { + token.windows.add(tokenWindowsPos, win); + } + + } else { + // Figure out this window's ordering relative to the window + // it is attached to. + final int NA = token.windows.size(); + final int sublayer = win.mSubLayer; + int largestSublayer = Integer.MIN_VALUE; + WindowState windowWithLargestSublayer = null; + for (i=0; i<NA; i++) { + WindowState w = token.windows.get(i); + final int wSublayer = w.mSubLayer; + if (wSublayer >= largestSublayer) { + largestSublayer = wSublayer; + windowWithLargestSublayer = w; + } + if (sublayer < 0) { + // For negative sublayers, we go below all windows + // in the same sublayer. + if (wSublayer >= sublayer) { + if (addToToken) { + token.windows.add(i, win); + } + placeWindowBefore( + wSublayer >= 0 ? attached : w, win); + break; + } + } else { + // For positive sublayers, we go above all windows + // in the same sublayer. + if (wSublayer > sublayer) { + if (addToToken) { + token.windows.add(i, win); + } + placeWindowBefore(w, win); + break; + } + } + } + if (i >= NA) { + if (addToToken) { + token.windows.add(win); + } + if (sublayer < 0) { + placeWindowBefore(attached, win); + } else { + placeWindowAfter(largestSublayer >= 0 + ? windowWithLargestSublayer + : attached, + win); + } + } + } + + if (win.mAppToken != null && addToToken) { + win.mAppToken.allAppWindows.add(win); + } + } + + static boolean canBeImeTarget(WindowState w) { + final int fl = w.mAttrs.flags + & (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM); + if (fl == 0 || fl == (FLAG_NOT_FOCUSABLE|FLAG_ALT_FOCUSABLE_IM)) { + return w.isVisibleOrAdding(); + } + return false; + } + + int findDesiredInputMethodWindowIndexLocked(boolean willMove) { + final ArrayList localmWindows = mWindows; + final int N = localmWindows.size(); + WindowState w = null; + int i = N; + while (i > 0) { + i--; + w = (WindowState)localmWindows.get(i); + + //Log.i(TAG, "Checking window @" + i + " " + w + " fl=0x" + // + Integer.toHexString(w.mAttrs.flags)); + if (canBeImeTarget(w)) { + //Log.i(TAG, "Putting input method here!"); + + // Yet more tricksyness! If this window is a "starting" + // window, we do actually want to be on top of it, but + // it is not -really- where input will go. So if the caller + // is not actually looking to move the IME, look down below + // for a real window to target... + if (!willMove + && w.mAttrs.type == WindowManager.LayoutParams.TYPE_APPLICATION_STARTING + && i > 0) { + WindowState wb = (WindowState)localmWindows.get(i-1); + if (wb.mAppToken == w.mAppToken && canBeImeTarget(wb)) { + i--; + w = wb; + } + } + break; + } + } + + mUpcomingInputMethodTarget = w; + + if (DEBUG_INPUT_METHOD) Log.v(TAG, "Desired input method target=" + + w + " willMove=" + willMove); + + if (willMove && w != null) { + final WindowState curTarget = mInputMethodTarget; + if (curTarget != null && curTarget.mAppToken != null) { + + // Now some fun for dealing with window animations that + // modify the Z order. We need to look at all windows below + // the current target that are in this app, finding the highest + // visible one in layering. + AppWindowToken token = curTarget.mAppToken; + WindowState highestTarget = null; + int highestPos = 0; + if (token.animating || token.animation != null) { + int pos = 0; + pos = localmWindows.indexOf(curTarget); + while (pos >= 0) { + WindowState win = (WindowState)localmWindows.get(pos); + if (win.mAppToken != token) { + break; + } + if (!win.mRemoved) { + if (highestTarget == null || win.mAnimLayer > + highestTarget.mAnimLayer) { + highestTarget = win; + highestPos = pos; + } + } + pos--; + } + } + + if (highestTarget != null) { + if (DEBUG_INPUT_METHOD) Log.v(TAG, "mNextAppTransition=" + + mNextAppTransition + " " + highestTarget + + " animating=" + highestTarget.isAnimating() + + " layer=" + highestTarget.mAnimLayer + + " new layer=" + w.mAnimLayer); + + if (mNextAppTransition != WindowManagerPolicy.TRANSIT_NONE) { + // If we are currently setting up for an animation, + // hold everything until we can find out what will happen. + mInputMethodTargetWaitingAnim = true; + mInputMethodTarget = highestTarget; + return highestPos + 1; + } else if (highestTarget.isAnimating() && + highestTarget.mAnimLayer > w.mAnimLayer) { + // If the window we are currently targeting is involved + // with an animation, and it is on top of the next target + // we will be over, then hold off on moving until + // that is done. + mInputMethodTarget = highestTarget; + return highestPos + 1; + } + } + } + } + + //Log.i(TAG, "Placing input method @" + (i+1)); + if (w != null) { + if (willMove) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + if (DEBUG_INPUT_METHOD) Log.w(TAG, "Moving IM target from " + + mInputMethodTarget + " to " + w, e); + mInputMethodTarget = w; + if (w.mAppToken != null) { + setInputMethodAnimLayerAdjustment(w.mAppToken.animLayerAdjustment); + } else { + setInputMethodAnimLayerAdjustment(0); + } + } + return i+1; + } + if (willMove) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + if (DEBUG_INPUT_METHOD) Log.w(TAG, "Moving IM target from " + + mInputMethodTarget + " to null", e); + mInputMethodTarget = null; + setInputMethodAnimLayerAdjustment(0); + } + return -1; + } + + void addInputMethodWindowToListLocked(WindowState win) { + int pos = findDesiredInputMethodWindowIndexLocked(true); + if (pos >= 0) { + win.mTargetAppToken = mInputMethodTarget.mAppToken; + mWindows.add(pos, win); + moveInputMethodDialogsLocked(pos+1); + return; + } + win.mTargetAppToken = null; + addWindowToListInOrderLocked(win, true); + moveInputMethodDialogsLocked(pos); + } + + void setInputMethodAnimLayerAdjustment(int adj) { + if (DEBUG_LAYERS) Log.v(TAG, "Setting im layer adj to " + adj); + mInputMethodAnimLayerAdjustment = adj; + WindowState imw = mInputMethodWindow; + if (imw != null) { + imw.mAnimLayer = imw.mLayer + adj; + if (DEBUG_LAYERS) Log.v(TAG, "IM win " + imw + + " anim layer: " + imw.mAnimLayer); + int wi = imw.mChildWindows.size(); + while (wi > 0) { + wi--; + WindowState cw = (WindowState)imw.mChildWindows.get(wi); + cw.mAnimLayer = cw.mLayer + adj; + if (DEBUG_LAYERS) Log.v(TAG, "IM win " + cw + + " anim layer: " + cw.mAnimLayer); + } + } + int di = mInputMethodDialogs.size(); + while (di > 0) { + di --; + imw = mInputMethodDialogs.get(di); + imw.mAnimLayer = imw.mLayer + adj; + if (DEBUG_LAYERS) Log.v(TAG, "IM win " + imw + + " anim layer: " + imw.mAnimLayer); + } + } + + private int tmpRemoveWindowLocked(int interestingPos, WindowState win) { + int wpos = mWindows.indexOf(win); + if (wpos >= 0) { + if (wpos < interestingPos) interestingPos--; + mWindows.remove(wpos); + int NC = win.mChildWindows.size(); + while (NC > 0) { + NC--; + WindowState cw = (WindowState)win.mChildWindows.get(NC); + int cpos = mWindows.indexOf(cw); + if (cpos >= 0) { + if (cpos < interestingPos) interestingPos--; + mWindows.remove(cpos); + } + } + } + return interestingPos; + } + + private void reAddWindowToListInOrderLocked(WindowState win) { + addWindowToListInOrderLocked(win, false); + // This is a hack to get all of the child windows added as well + // at the right position. Child windows should be rare and + // this case should be rare, so it shouldn't be that big a deal. + int wpos = mWindows.indexOf(win); + if (wpos >= 0) { + mWindows.remove(wpos); + reAddWindowLocked(wpos, win); + } + } + + void logWindowList(String prefix) { + int N = mWindows.size(); + while (N > 0) { + N--; + Log.v(TAG, prefix + "#" + N + ": " + mWindows.get(N)); + } + } + + void moveInputMethodDialogsLocked(int pos) { + ArrayList<WindowState> dialogs = mInputMethodDialogs; + + final int N = dialogs.size(); + if (DEBUG_INPUT_METHOD) Log.v(TAG, "Removing " + N + " dialogs w/pos=" + pos); + for (int i=0; i<N; i++) { + pos = tmpRemoveWindowLocked(pos, dialogs.get(i)); + } + if (DEBUG_INPUT_METHOD) { + Log.v(TAG, "Window list w/pos=" + pos); + logWindowList(" "); + } + + if (pos >= 0) { + final AppWindowToken targetAppToken = mInputMethodTarget.mAppToken; + if (pos < mWindows.size()) { + WindowState wp = (WindowState)mWindows.get(pos); + if (wp == mInputMethodWindow) { + pos++; + } + } + if (DEBUG_INPUT_METHOD) Log.v(TAG, "Adding " + N + " dialogs at pos=" + pos); + for (int i=0; i<N; i++) { + WindowState win = dialogs.get(i); + win.mTargetAppToken = targetAppToken; + pos = reAddWindowLocked(pos, win); + } + if (DEBUG_INPUT_METHOD) { + Log.v(TAG, "Final window list:"); + logWindowList(" "); + } + return; + } + for (int i=0; i<N; i++) { + WindowState win = dialogs.get(i); + win.mTargetAppToken = null; + reAddWindowToListInOrderLocked(win); + if (DEBUG_INPUT_METHOD) { + Log.v(TAG, "No IM target, final list:"); + logWindowList(" "); + } + } + } + + boolean moveInputMethodWindowsIfNeededLocked(boolean needAssignLayers) { + final WindowState imWin = mInputMethodWindow; + final int DN = mInputMethodDialogs.size(); + if (imWin == null && DN == 0) { + return false; + } + + int imPos = findDesiredInputMethodWindowIndexLocked(true); + if (imPos >= 0) { + // In this case, the input method windows are to be placed + // immediately above the window they are targeting. + + // First check to see if the input method windows are already + // located here, and contiguous. + final int N = mWindows.size(); + WindowState firstImWin = imPos < N + ? (WindowState)mWindows.get(imPos) : null; + + // Figure out the actual input method window that should be + // at the bottom of their stack. + WindowState baseImWin = imWin != null + ? imWin : mInputMethodDialogs.get(0); + if (baseImWin.mChildWindows.size() > 0) { + WindowState cw = (WindowState)baseImWin.mChildWindows.get(0); + if (cw.mSubLayer < 0) baseImWin = cw; + } + + if (firstImWin == baseImWin) { + // The windows haven't moved... but are they still contiguous? + // First find the top IM window. + int pos = imPos+1; + while (pos < N) { + if (!((WindowState)mWindows.get(pos)).mIsImWindow) { + break; + } + pos++; + } + pos++; + // Now there should be no more input method windows above. + while (pos < N) { + if (((WindowState)mWindows.get(pos)).mIsImWindow) { + break; + } + pos++; + } + if (pos >= N) { + // All is good! + return false; + } + } + + if (imWin != null) { + if (DEBUG_INPUT_METHOD) { + Log.v(TAG, "Moving IM from " + imPos); + logWindowList(" "); + } + imPos = tmpRemoveWindowLocked(imPos, imWin); + if (DEBUG_INPUT_METHOD) { + Log.v(TAG, "List after moving with new pos " + imPos + ":"); + logWindowList(" "); + } + imWin.mTargetAppToken = mInputMethodTarget.mAppToken; + reAddWindowLocked(imPos, imWin); + if (DEBUG_INPUT_METHOD) { + Log.v(TAG, "List after moving IM to " + imPos + ":"); + logWindowList(" "); + } + if (DN > 0) moveInputMethodDialogsLocked(imPos+1); + } else { + moveInputMethodDialogsLocked(imPos); + } + + } else { + // In this case, the input method windows go in a fixed layer, + // because they aren't currently associated with a focus window. + + if (imWin != null) { + if (DEBUG_INPUT_METHOD) Log.v(TAG, "Moving IM from " + imPos); + tmpRemoveWindowLocked(0, imWin); + imWin.mTargetAppToken = null; + reAddWindowToListInOrderLocked(imWin); + if (DEBUG_INPUT_METHOD) { + Log.v(TAG, "List with no IM target:"); + logWindowList(" "); + } + if (DN > 0) moveInputMethodDialogsLocked(-1);; + } else { + moveInputMethodDialogsLocked(-1);; + } + + } + + if (needAssignLayers) { + assignLayersLocked(); + } + + return true; + } + + void adjustInputMethodDialogsLocked() { + moveInputMethodDialogsLocked(findDesiredInputMethodWindowIndexLocked(true)); + } + + public int addWindow(Session session, IWindow client, + WindowManager.LayoutParams attrs, int viewVisibility, + Rect outContentInsets) { + int res = mPolicy.checkAddPermission(attrs); + if (res != WindowManagerImpl.ADD_OKAY) { + return res; + } + + boolean reportNewConfig = false; + WindowState attachedWindow = null; + WindowState win = null; + + synchronized(mWindowMap) { + // Instantiating a Display requires talking with the simulator, + // so don't do it until we know the system is mostly up and + // running. + if (mDisplay == null) { + WindowManager wm = (WindowManager)mContext.getSystemService(Context.WINDOW_SERVICE); + mDisplay = wm.getDefaultDisplay(); + mQueue.setDisplay(mDisplay); + reportNewConfig = true; + } + + if (mWindowMap.containsKey(client.asBinder())) { + Log.w(TAG, "Window " + client + " is already added"); + return WindowManagerImpl.ADD_DUPLICATE_ADD; + } + + if (attrs.type >= FIRST_SUB_WINDOW && attrs.type <= LAST_SUB_WINDOW) { + attachedWindow = windowForClientLocked(null, attrs.token); + if (attachedWindow == null) { + Log.w(TAG, "Attempted to add window with token that is not a window: " + + attrs.token + ". Aborting."); + return WindowManagerImpl.ADD_BAD_SUBWINDOW_TOKEN; + } + if (attachedWindow.mAttrs.type >= FIRST_SUB_WINDOW + && attachedWindow.mAttrs.type <= LAST_SUB_WINDOW) { + Log.w(TAG, "Attempted to add window with token that is a sub-window: " + + attrs.token + ". Aborting."); + return WindowManagerImpl.ADD_BAD_SUBWINDOW_TOKEN; + } + } + + boolean addToken = false; + WindowToken token = mTokenMap.get(attrs.token); + if (token == null) { + if (attrs.type >= FIRST_APPLICATION_WINDOW + && attrs.type <= LAST_APPLICATION_WINDOW) { + Log.w(TAG, "Attempted to add application window with unknown token " + + attrs.token + ". Aborting."); + return WindowManagerImpl.ADD_BAD_APP_TOKEN; + } + if (attrs.type == TYPE_INPUT_METHOD) { + Log.w(TAG, "Attempted to add input method window with unknown token " + + attrs.token + ". Aborting."); + return WindowManagerImpl.ADD_BAD_APP_TOKEN; + } + token = new WindowToken(attrs.token, -1, false); + addToken = true; + } else if (attrs.type >= FIRST_APPLICATION_WINDOW + && attrs.type <= LAST_APPLICATION_WINDOW) { + AppWindowToken atoken = token.appWindowToken; + if (atoken == null) { + Log.w(TAG, "Attempted to add window with non-application token " + + token + ". Aborting."); + return WindowManagerImpl.ADD_NOT_APP_TOKEN; + } else if (atoken.removed) { + Log.w(TAG, "Attempted to add window with exiting application token " + + token + ". Aborting."); + return WindowManagerImpl.ADD_APP_EXITING; + } + if (attrs.type == TYPE_APPLICATION_STARTING && atoken.firstWindowDrawn) { + // No need for this guy! + if (localLOGV) Log.v( + TAG, "**** NO NEED TO START: " + attrs.getTitle()); + return WindowManagerImpl.ADD_STARTING_NOT_NEEDED; + } + } else if (attrs.type == TYPE_INPUT_METHOD) { + if (token.windowType != TYPE_INPUT_METHOD) { + Log.w(TAG, "Attempted to add input method window with bad token " + + attrs.token + ". Aborting."); + return WindowManagerImpl.ADD_BAD_APP_TOKEN; + } + } + + win = new WindowState(session, client, token, + attachedWindow, attrs, viewVisibility); + if (win.mDeathRecipient == null) { + // Client has apparently died, so there is no reason to + // continue. + Log.w(TAG, "Adding window client " + client.asBinder() + + " that is dead, aborting."); + return WindowManagerImpl.ADD_APP_EXITING; + } + + mPolicy.adjustWindowParamsLw(win.mAttrs); + + res = mPolicy.prepareAddWindowLw(win, attrs); + if (res != WindowManagerImpl.ADD_OKAY) { + return res; + } + + // From now on, no exceptions or errors allowed! + + res = WindowManagerImpl.ADD_OKAY; + + final long origId = Binder.clearCallingIdentity(); + + if (addToken) { + mTokenMap.put(attrs.token, token); + mTokenList.add(token); + } + win.attach(); + mWindowMap.put(client.asBinder(), win); + + if (attrs.type == TYPE_APPLICATION_STARTING && + token.appWindowToken != null) { + token.appWindowToken.startingWindow = win; + } + + boolean imMayMove = true; + + if (attrs.type == TYPE_INPUT_METHOD) { + mInputMethodWindow = win; + addInputMethodWindowToListLocked(win); + imMayMove = false; + } else if (attrs.type == TYPE_INPUT_METHOD_DIALOG) { + mInputMethodDialogs.add(win); + addWindowToListInOrderLocked(win, true); + adjustInputMethodDialogsLocked(); + imMayMove = false; + } else { + addWindowToListInOrderLocked(win, true); + } + + win.mEnterAnimationPending = true; + + mPolicy.getContentInsetHintLw(attrs, outContentInsets); + + if (mInTouchMode) { + res |= WindowManagerImpl.ADD_FLAG_IN_TOUCH_MODE; + } + if (win == null || win.mAppToken == null || !win.mAppToken.clientHidden) { + res |= WindowManagerImpl.ADD_FLAG_APP_VISIBLE; + } + + if (win.canReceiveKeys()) { + if (updateFocusedWindowLocked(UPDATE_FOCUS_WILL_ASSIGN_LAYERS)) { + imMayMove = false; + } + } + + if (imMayMove) { + moveInputMethodWindowsIfNeededLocked(false); + } + + assignLayersLocked(); + // Don't do layout here, the window must call + // relayout to be displayed, so we'll do it there. + + //dump(); + + if (localLOGV) Log.v( + TAG, "New client " + client.asBinder() + + ": window=" + win); + } + + // sendNewConfiguration() checks caller permissions so we must call it with + // privilege. updateOrientationFromAppTokens() clears and resets the caller + // identity anyway, so it's safe to just clear & restore around this whole + // block. + final long origId = Binder.clearCallingIdentity(); + if (reportNewConfig) { + sendNewConfiguration(); + } else { + // Update Orientation after adding a window, only if the window needs to be + // displayed right away + if (win.isVisibleOrAdding()) { + if (updateOrientationFromAppTokens(null) != null) { + sendNewConfiguration(); + } + } + } + Binder.restoreCallingIdentity(origId); + + return res; + } + + public void removeWindow(Session session, IWindow client) { + synchronized(mWindowMap) { + WindowState win = windowForClientLocked(session, client); + if (win == null) { + return; + } + removeWindowLocked(session, win); + } + } + + public void removeWindowLocked(Session session, WindowState win) { + + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Remove " + win + " client=" + + Integer.toHexString(System.identityHashCode( + win.mClient.asBinder())) + + ", surface=" + win.mSurface); + + final long origId = Binder.clearCallingIdentity(); + + if (DEBUG_APP_TRANSITIONS) Log.v( + TAG, "Remove " + win + ": mSurface=" + win.mSurface + + " mExiting=" + win.mExiting + + " isAnimating=" + win.isAnimating() + + " app-animation=" + + (win.mAppToken != null ? win.mAppToken.animation : null) + + " inPendingTransaction=" + + (win.mAppToken != null ? win.mAppToken.inPendingTransaction : false) + + " mDisplayFrozen=" + mDisplayFrozen); + // Visibility of the removed window. Will be used later to update orientation later on. + boolean wasVisible = false; + // First, see if we need to run an animation. If we do, we have + // to hold off on removing the window until the animation is done. + // If the display is frozen, just remove immediately, since the + // animation wouldn't be seen. + if (win.mSurface != null && !mDisplayFrozen) { + // If we are not currently running the exit animation, we + // need to see about starting one. + if (wasVisible=win.isWinVisibleLw()) { + + int transit = WindowManagerPolicy.TRANSIT_EXIT; + if (win.getAttrs().type == TYPE_APPLICATION_STARTING) { + transit = WindowManagerPolicy.TRANSIT_PREVIEW_DONE; + } + // Try starting an animation. + if (applyAnimationLocked(win, transit, false)) { + win.mExiting = true; + } + } + if (win.mExiting || win.isAnimating()) { + // The exit animation is running... wait for it! + //Log.i(TAG, "*** Running exit animation..."); + win.mExiting = true; + win.mRemoveOnExit = true; + mLayoutNeeded = true; + updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES); + performLayoutAndPlaceSurfacesLocked(); + if (win.mAppToken != null) { + win.mAppToken.updateReportedVisibilityLocked(); + } + //dump(); + Binder.restoreCallingIdentity(origId); + return; + } + } + + removeWindowInnerLocked(session, win); + // Removing a visible window will effect the computed orientation + // So just update orientation if needed. + if (wasVisible) { + if (updateOrientationFromAppTokens(null) != null) { + sendNewConfiguration(); + } + } + updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL); + Binder.restoreCallingIdentity(origId); + } + + private void removeWindowInnerLocked(Session session, WindowState win) { + mKeyWaiter.releasePendingPointerLocked(win.mSession); + mKeyWaiter.releasePendingTrackballLocked(win.mSession); + + win.mRemoved = true; + + if (mInputMethodTarget == win) { + moveInputMethodWindowsIfNeededLocked(false); + } + + mPolicy.removeWindowLw(win); + win.removeLocked(); + + mWindowMap.remove(win.mClient.asBinder()); + mWindows.remove(win); + + if (mInputMethodWindow == win) { + mInputMethodWindow = null; + } else if (win.mAttrs.type == TYPE_INPUT_METHOD_DIALOG) { + mInputMethodDialogs.remove(win); + } + + final WindowToken token = win.mToken; + final AppWindowToken atoken = win.mAppToken; + token.windows.remove(win); + if (atoken != null) { + atoken.allAppWindows.remove(win); + } + if (localLOGV) Log.v( + TAG, "**** Removing window " + win + ": count=" + + token.windows.size()); + if (token.windows.size() == 0) { + if (!token.explicit) { + mTokenMap.remove(token.token); + mTokenList.remove(token); + } else if (atoken != null) { + atoken.firstWindowDrawn = false; + } + } + + if (atoken != null) { + if (atoken.startingWindow == win) { + atoken.startingWindow = null; + } else if (atoken.allAppWindows.size() == 0 && atoken.startingData != null) { + // If this is the last window and we had requested a starting + // transition window, well there is no point now. + atoken.startingData = null; + } else if (atoken.allAppWindows.size() == 1 && atoken.startingView != null) { + // If this is the last window except for a starting transition + // window, we need to get rid of the starting transition. + if (DEBUG_STARTING_WINDOW) { + Log.v(TAG, "Schedule remove starting " + token + + ": no more real windows"); + } + Message m = mH.obtainMessage(H.REMOVE_STARTING, atoken); + mH.sendMessage(m); + } + } + + if (!mInLayout) { + assignLayersLocked(); + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + if (win.mAppToken != null) { + win.mAppToken.updateReportedVisibilityLocked(); + } + } + } + + private void setTransparentRegionWindow(Session session, IWindow client, Region region) { + long origId = Binder.clearCallingIdentity(); + try { + synchronized (mWindowMap) { + WindowState w = windowForClientLocked(session, client); + if ((w != null) && (w.mSurface != null)) { + Surface.openTransaction(); + try { + w.mSurface.setTransparentRegionHint(region); + } finally { + Surface.closeTransaction(); + } + } + } + } finally { + Binder.restoreCallingIdentity(origId); + } + } + + void setInsetsWindow(Session session, IWindow client, + int touchableInsets, Rect contentInsets, + Rect visibleInsets) { + long origId = Binder.clearCallingIdentity(); + try { + synchronized (mWindowMap) { + WindowState w = windowForClientLocked(session, client); + if (w != null) { + w.mGivenInsetsPending = false; + w.mGivenContentInsets.set(contentInsets); + w.mGivenVisibleInsets.set(visibleInsets); + w.mTouchableInsets = touchableInsets; + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + } + } + } finally { + Binder.restoreCallingIdentity(origId); + } + } + + public void getWindowDisplayFrame(Session session, IWindow client, + Rect outDisplayFrame) { + synchronized(mWindowMap) { + WindowState win = windowForClientLocked(session, client); + if (win == null) { + outDisplayFrame.setEmpty(); + return; + } + outDisplayFrame.set(win.mDisplayFrame); + } + } + + public int relayoutWindow(Session session, IWindow client, + WindowManager.LayoutParams attrs, int requestedWidth, + int requestedHeight, int viewVisibility, boolean insetsPending, + Rect outFrame, Rect outContentInsets, Rect outVisibleInsets, + Surface outSurface) { + boolean displayed = false; + boolean inTouchMode; + Configuration newConfig = null; + long origId = Binder.clearCallingIdentity(); + + synchronized(mWindowMap) { + WindowState win = windowForClientLocked(session, client); + if (win == null) { + return 0; + } + win.mRequestedWidth = requestedWidth; + win.mRequestedHeight = requestedHeight; + + if (attrs != null) { + mPolicy.adjustWindowParamsLw(attrs); + } + + int attrChanges = 0; + int flagChanges = 0; + if (attrs != null) { + flagChanges = win.mAttrs.flags ^= attrs.flags; + attrChanges = win.mAttrs.copyFrom(attrs); + } + + if (localLOGV) Log.v( + TAG, "Relayout given client " + client.asBinder() + + " (" + win.mAttrs.getTitle() + ")"); + + + if ((attrChanges & WindowManager.LayoutParams.ALPHA_CHANGED) != 0) { + win.mAlpha = attrs.alpha; + } + + final boolean scaledWindow = + ((win.mAttrs.flags & WindowManager.LayoutParams.FLAG_SCALED) != 0); + + if (scaledWindow) { + // requested{Width|Height} Surface's physical size + // attrs.{width|height} Size on screen + win.mHScale = (attrs.width != requestedWidth) ? + (attrs.width / (float)requestedWidth) : 1.0f; + win.mVScale = (attrs.height != requestedHeight) ? + (attrs.height / (float)requestedHeight) : 1.0f; + } + + boolean imMayMove = (flagChanges&( + WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM | + WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE)) != 0; + + boolean focusMayChange = win.mViewVisibility != viewVisibility + || ((flagChanges&WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE) != 0) + || (!win.mRelayoutCalled); + + win.mRelayoutCalled = true; + final int oldVisibility = win.mViewVisibility; + win.mViewVisibility = viewVisibility; + if (viewVisibility == View.VISIBLE && + (win.mAppToken == null || !win.mAppToken.clientHidden)) { + displayed = !win.isVisibleLw(); + if (win.mExiting) { + win.mExiting = false; + win.mAnimation = null; + } + if (win.mDestroying) { + win.mDestroying = false; + mDestroySurface.remove(win); + } + if (oldVisibility == View.GONE) { + win.mEnterAnimationPending = true; + } + if (displayed && win.mSurface != null && !win.mDrawPending + && !win.mCommitDrawPending && !mDisplayFrozen) { + applyEnterAnimationLocked(win); + } + if ((attrChanges&WindowManager.LayoutParams.FORMAT_CHANGED) != 0) { + // To change the format, we need to re-build the surface. + win.destroySurfaceLocked(); + displayed = true; + } + try { + Surface surface = win.createSurfaceLocked(); + if (surface != null) { + outSurface.copyFrom(surface); + } else { + outSurface.clear(); + } + } catch (Exception e) { + Log.w(TAG, "Exception thrown when creating surface for client " + + client + " (" + win.mAttrs.getTitle() + ")", + e); + Binder.restoreCallingIdentity(origId); + return 0; + } + if (displayed) { + focusMayChange = true; + } + if (win.mAttrs.type == TYPE_INPUT_METHOD + && mInputMethodWindow == null) { + mInputMethodWindow = win; + imMayMove = true; + } + } else { + win.mEnterAnimationPending = false; + if (win.mSurface != null) { + // If we are not currently running the exit animation, we + // need to see about starting one. + if (!win.mExiting) { + // Try starting an animation; if there isn't one, we + // can destroy the surface right away. + int transit = WindowManagerPolicy.TRANSIT_EXIT; + if (win.getAttrs().type == TYPE_APPLICATION_STARTING) { + transit = WindowManagerPolicy.TRANSIT_PREVIEW_DONE; + } + if (win.isWinVisibleLw() && + applyAnimationLocked(win, transit, false)) { + win.mExiting = true; + mKeyWaiter.finishedKey(session, client, true, + KeyWaiter.RETURN_NOTHING); + } else if (win.isAnimating()) { + // Currently in a hide animation... turn this into + // an exit. + win.mExiting = true; + } else { + if (mInputMethodWindow == win) { + mInputMethodWindow = null; + } + win.destroySurfaceLocked(); + } + } + } + outSurface.clear(); + } + + boolean assignLayers = false; + + if (focusMayChange) { + //System.out.println("Focus may change: " + win.mAttrs.getTitle()); + if (updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES)) { + assignLayers = true; + imMayMove = false; + } + //System.out.println("Relayout " + win + ": focus=" + mCurrentFocus); + } + + if (imMayMove) { + if (moveInputMethodWindowsIfNeededLocked(false)) { + assignLayers = true; + } + } + + mLayoutNeeded = true; + win.mGivenInsetsPending = insetsPending; + if (assignLayers) { + assignLayersLocked(); + } + newConfig = updateOrientationFromAppTokensLocked(null); + performLayoutAndPlaceSurfacesLocked(); + if (win.mAppToken != null) { + win.mAppToken.updateReportedVisibilityLocked(); + } + outFrame.set(win.mFrame); + outContentInsets.set(win.mContentInsets); + outVisibleInsets.set(win.mVisibleInsets); + if (localLOGV) Log.v( + TAG, "Relayout given client " + client.asBinder() + + ", requestedWidth=" + requestedWidth + + ", requestedHeight=" + requestedHeight + + ", viewVisibility=" + viewVisibility + + "\nRelayout returning frame=" + outFrame + + ", surface=" + outSurface); + + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Relayout of " + win + ": focusMayChange=" + focusMayChange); + + inTouchMode = mInTouchMode; + } + + if (newConfig != null) { + sendNewConfiguration(); + } + + Binder.restoreCallingIdentity(origId); + + return (inTouchMode ? WindowManagerImpl.RELAYOUT_IN_TOUCH_MODE : 0) + | (displayed ? WindowManagerImpl.RELAYOUT_FIRST_TIME : 0); + } + + public void finishDrawingWindow(Session session, IWindow client) { + final long origId = Binder.clearCallingIdentity(); + synchronized(mWindowMap) { + WindowState win = windowForClientLocked(session, client); + if (win != null && win.finishDrawingLocked()) { + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + } + } + Binder.restoreCallingIdentity(origId); + } + + private AttributeCache.Entry getCachedAnimations(WindowManager.LayoutParams lp) { + if (DEBUG_ANIM) Log.v(TAG, "Loading animations: params package=" + + (lp != null ? lp.packageName : null) + + " resId=0x" + (lp != null ? Integer.toHexString(lp.windowAnimations) : null)); + if (lp != null && lp.windowAnimations != 0) { + // If this is a system resource, don't try to load it from the + // application resources. It is nice to avoid loading application + // resources if we can. + String packageName = lp.packageName != null ? lp.packageName : "android"; + int resId = lp.windowAnimations; + if ((resId&0xFF000000) == 0x01000000) { + packageName = "android"; + } + if (DEBUG_ANIM) Log.v(TAG, "Loading animations: picked package=" + + packageName); + return AttributeCache.instance().get(packageName, resId, + com.android.internal.R.styleable.WindowAnimation); + } + return null; + } + + private void applyEnterAnimationLocked(WindowState win) { + int transit = WindowManagerPolicy.TRANSIT_SHOW; + if (win.mEnterAnimationPending) { + win.mEnterAnimationPending = false; + transit = WindowManagerPolicy.TRANSIT_ENTER; + } + + applyAnimationLocked(win, transit, true); + } + + private boolean applyAnimationLocked(WindowState win, + int transit, boolean isEntrance) { + if (win.mLocalAnimating && win.mAnimationIsEntrance == isEntrance) { + // If we are trying to apply an animation, but already running + // an animation of the same type, then just leave that one alone. + return true; + } + + // Only apply an animation if the display isn't frozen. If it is + // frozen, there is no reason to animate and it can cause strange + // artifacts when we unfreeze the display if some different animation + // is running. + if (!mDisplayFrozen) { + int anim = mPolicy.selectAnimationLw(win, transit); + int attr = -1; + Animation a = null; + if (anim != 0) { + a = AnimationUtils.loadAnimation(mContext, anim); + } else { + switch (transit) { + case WindowManagerPolicy.TRANSIT_ENTER: + attr = com.android.internal.R.styleable.WindowAnimation_windowEnterAnimation; + break; + case WindowManagerPolicy.TRANSIT_EXIT: + attr = com.android.internal.R.styleable.WindowAnimation_windowExitAnimation; + break; + case WindowManagerPolicy.TRANSIT_SHOW: + attr = com.android.internal.R.styleable.WindowAnimation_windowShowAnimation; + break; + case WindowManagerPolicy.TRANSIT_HIDE: + attr = com.android.internal.R.styleable.WindowAnimation_windowHideAnimation; + break; + } + if (attr >= 0) { + a = loadAnimation(win.mAttrs, attr); + } + } + if (DEBUG_ANIM) Log.v(TAG, "applyAnimation: win=" + win + + " anim=" + anim + " attr=0x" + Integer.toHexString(attr) + + " mAnimation=" + win.mAnimation + + " isEntrance=" + isEntrance); + if (a != null) { + if (DEBUG_ANIM) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.v(TAG, "Loaded animation " + a + " for " + win, e); + } + win.setAnimation(a); + win.mAnimationIsEntrance = isEntrance; + } + } else { + win.clearAnimation(); + } + + return win.mAnimation != null; + } + + private Animation loadAnimation(WindowManager.LayoutParams lp, int animAttr) { + int anim = 0; + Context context = mContext; + if (animAttr >= 0) { + AttributeCache.Entry ent = getCachedAnimations(lp); + if (ent != null) { + context = ent.context; + anim = ent.array.getResourceId(animAttr, 0); + } + } + if (anim != 0) { + return AnimationUtils.loadAnimation(context, anim); + } + return null; + } + + private boolean applyAnimationLocked(AppWindowToken wtoken, + WindowManager.LayoutParams lp, int transit, boolean enter) { + // Only apply an animation if the display isn't frozen. If it is + // frozen, there is no reason to animate and it can cause strange + // artifacts when we unfreeze the display if some different animation + // is running. + if (!mDisplayFrozen) { + int animAttr = 0; + switch (transit) { + case WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN: + animAttr = enter + ? com.android.internal.R.styleable.WindowAnimation_activityOpenEnterAnimation + : com.android.internal.R.styleable.WindowAnimation_activityOpenExitAnimation; + break; + case WindowManagerPolicy.TRANSIT_ACTIVITY_CLOSE: + animAttr = enter + ? com.android.internal.R.styleable.WindowAnimation_activityCloseEnterAnimation + : com.android.internal.R.styleable.WindowAnimation_activityCloseExitAnimation; + break; + case WindowManagerPolicy.TRANSIT_TASK_OPEN: + animAttr = enter + ? com.android.internal.R.styleable.WindowAnimation_taskOpenEnterAnimation + : com.android.internal.R.styleable.WindowAnimation_taskOpenExitAnimation; + break; + case WindowManagerPolicy.TRANSIT_TASK_CLOSE: + animAttr = enter + ? com.android.internal.R.styleable.WindowAnimation_taskCloseEnterAnimation + : com.android.internal.R.styleable.WindowAnimation_taskCloseExitAnimation; + break; + case WindowManagerPolicy.TRANSIT_TASK_TO_FRONT: + animAttr = enter + ? com.android.internal.R.styleable.WindowAnimation_taskToFrontEnterAnimation + : com.android.internal.R.styleable.WindowAnimation_taskToFrontExitAnimation; + break; + case WindowManagerPolicy.TRANSIT_TASK_TO_BACK: + animAttr = enter + ? com.android.internal.R.styleable.WindowAnimation_taskToBackEnterAnimation + : com.android.internal.R.styleable.WindowAnimation_taskToBackExitAnimation; + break; + } + Animation a = loadAnimation(lp, animAttr); + if (DEBUG_ANIM) Log.v(TAG, "applyAnimation: wtoken=" + wtoken + + " anim=" + a + + " animAttr=0x" + Integer.toHexString(animAttr) + + " transit=" + transit); + if (a != null) { + if (DEBUG_ANIM) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.v(TAG, "Loaded animation " + a + " for " + wtoken, e); + } + wtoken.setAnimation(a); + } + } else { + wtoken.clearAnimation(); + } + + return wtoken.animation != null; + } + + // ------------------------------------------------------------- + // Application Window Tokens + // ------------------------------------------------------------- + + public void validateAppTokens(List tokens) { + int v = tokens.size()-1; + int m = mAppTokens.size()-1; + while (v >= 0 && m >= 0) { + AppWindowToken wtoken = mAppTokens.get(m); + if (wtoken.removed) { + m--; + continue; + } + if (tokens.get(v) != wtoken.token) { + Log.w(TAG, "Tokens out of sync: external is " + tokens.get(v) + + " @ " + v + ", internal is " + wtoken.token + " @ " + m); + } + v--; + m--; + } + while (v >= 0) { + Log.w(TAG, "External token not found: " + tokens.get(v) + " @ " + v); + v--; + } + while (m >= 0) { + AppWindowToken wtoken = mAppTokens.get(m); + if (!wtoken.removed) { + Log.w(TAG, "Invalid internal token: " + wtoken.token + " @ " + m); + } + m--; + } + } + + boolean checkCallingPermission(String permission, String func) { + // Quick check: if the calling permission is me, it's all okay. + if (Binder.getCallingPid() == Process.myPid()) { + return true; + } + + if (mContext.checkCallingPermission(permission) + == PackageManager.PERMISSION_GRANTED) { + return true; + } + String msg = "Permission Denial: " + func + " from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + permission; + Log.w(TAG, msg); + return false; + } + + AppWindowToken findAppWindowToken(IBinder token) { + WindowToken wtoken = mTokenMap.get(token); + if (wtoken == null) { + return null; + } + return wtoken.appWindowToken; + } + + public void addWindowToken(IBinder token, int type) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "addWindowToken()")) { + return; + } + + synchronized(mWindowMap) { + WindowToken wtoken = mTokenMap.get(token); + if (wtoken != null) { + Log.w(TAG, "Attempted to add existing input method token: " + token); + return; + } + wtoken = new WindowToken(token, type, true); + mTokenMap.put(token, wtoken); + mTokenList.add(wtoken); + } + } + + public void removeWindowToken(IBinder token) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "removeWindowToken()")) { + return; + } + + final long origId = Binder.clearCallingIdentity(); + synchronized(mWindowMap) { + WindowToken wtoken = mTokenMap.remove(token); + mTokenList.remove(wtoken); + if (wtoken != null) { + boolean delayed = false; + if (!wtoken.hidden) { + wtoken.hidden = true; + + final int N = wtoken.windows.size(); + boolean changed = false; + + for (int i=0; i<N; i++) { + WindowState win = wtoken.windows.get(i); + + if (win.isAnimating()) { + delayed = true; + } + + if (win.isVisibleNow()) { + applyAnimationLocked(win, + WindowManagerPolicy.TRANSIT_EXIT, false); + mKeyWaiter.finishedKey(win.mSession, win.mClient, true, + KeyWaiter.RETURN_NOTHING); + changed = true; + } + } + + if (changed) { + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL); + } + + if (delayed) { + mExitingTokens.add(wtoken); + } + } + + } else { + Log.w(TAG, "Attempted to remove non-existing token: " + token); + } + } + Binder.restoreCallingIdentity(origId); + } + + public void addAppToken(int addPos, IApplicationToken token, + int groupId, int requestedOrientation, boolean fullscreen) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "addAppToken()")) { + return; + } + + synchronized(mWindowMap) { + AppWindowToken wtoken = findAppWindowToken(token.asBinder()); + if (wtoken != null) { + Log.w(TAG, "Attempted to add existing app token: " + token); + return; + } + wtoken = new AppWindowToken(token); + wtoken.groupId = groupId; + wtoken.appFullscreen = fullscreen; + wtoken.requestedOrientation = requestedOrientation; + mAppTokens.add(addPos, wtoken); + if (Config.LOGV) Log.v(TAG, "Adding new app token: " + wtoken); + mTokenMap.put(token.asBinder(), wtoken); + mTokenList.add(wtoken); + + // Application tokens start out hidden. + wtoken.hidden = true; + wtoken.hiddenRequested = true; + + //dump(); + } + } + + public void setAppGroupId(IBinder token, int groupId) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setAppStartingIcon()")) { + return; + } + + synchronized(mWindowMap) { + AppWindowToken wtoken = findAppWindowToken(token); + if (wtoken == null) { + Log.w(TAG, "Attempted to set group id of non-existing app token: " + token); + return; + } + wtoken.groupId = groupId; + } + } + + public int getOrientationFromWindowsLocked() { + int pos = mWindows.size() - 1; + while (pos >= 0) { + WindowState wtoken = (WindowState) mWindows.get(pos); + pos--; + if (wtoken.mAppToken != null) { + // We hit an application window. so the orientation will be determined by the + // app window. No point in continuing further. + return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + } + if (!wtoken.isVisibleLw()) { + continue; + } + int req = wtoken.mAttrs.screenOrientation; + if((req == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) || + (req == ActivityInfo.SCREEN_ORIENTATION_BEHIND)){ + continue; + } else { + return req; + } + } + return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + } + + public int getOrientationFromAppTokensLocked() { + int pos = mAppTokens.size() - 1; + int curGroup = 0; + int lastOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + boolean haveGroup = false; + while (pos >= 0) { + AppWindowToken wtoken = mAppTokens.get(pos); + pos--; + if (!haveGroup) { + // We ignore any hidden applications on the top. + if (wtoken.hiddenRequested || wtoken.willBeHidden) { + continue; + } + haveGroup = true; + curGroup = wtoken.groupId; + lastOrientation = wtoken.requestedOrientation; + } else if (curGroup != wtoken.groupId) { + // If we have hit a new application group, and the bottom + // of the previous group didn't explicitly say to use + // the orientation behind it, then we'll stick with the + // user's orientation. + if (lastOrientation != ActivityInfo.SCREEN_ORIENTATION_BEHIND) { + return lastOrientation; + } + } + int or = wtoken.requestedOrientation; + // If this application is fullscreen, then just take whatever + // orientation it has and ignores whatever is under it. + if (wtoken.appFullscreen) { + return or; + } + // If this application has requested an explicit orientation, + // then use it. + if (or == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE || + or == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT || + or == ActivityInfo.SCREEN_ORIENTATION_SENSOR || + or == ActivityInfo.SCREEN_ORIENTATION_NOSENSOR || + or == ActivityInfo.SCREEN_ORIENTATION_USER) { + return or; + } + } + return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + } + + public Configuration updateOrientationFromAppTokens( + IBinder freezeThisOneIfNeeded) { + Configuration config; + long ident = Binder.clearCallingIdentity(); + synchronized(mWindowMap) { + config = updateOrientationFromAppTokensLocked(freezeThisOneIfNeeded); + } + if (config != null) { + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + } + Binder.restoreCallingIdentity(ident); + return config; + } + + /* + * The orientation is computed from non-application windows first. If none of + * the non-application windows specify orientation, the orientation is computed from + * application tokens. + * @see android.view.IWindowManager#updateOrientationFromAppTokens( + * android.os.IBinder) + */ + public Configuration updateOrientationFromAppTokensLocked( + IBinder freezeThisOneIfNeeded) { + boolean changed = false; + Configuration config = null; + long ident = Binder.clearCallingIdentity(); + try { + int req = getOrientationFromWindowsLocked(); + if (req == ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED) { + req = getOrientationFromAppTokensLocked(); + } + + if (req != mForcedAppOrientation) { + changed = true; + mForcedAppOrientation = req; + //send a message to Policy indicating orientation change to take + //action like disabling/enabling sensors etc., + mPolicy.setCurrentOrientation(req); + } + + if (changed) { + changed = setRotationUncheckedLocked( + WindowManagerPolicy.USE_LAST_ROTATION); + if (changed) { + if (freezeThisOneIfNeeded != null) { + AppWindowToken wtoken = findAppWindowToken( + freezeThisOneIfNeeded); + if (wtoken != null) { + startAppFreezingScreenLocked(wtoken, + ActivityInfo.CONFIG_ORIENTATION); + } + } + return computeNewConfiguration(); + } + } + } finally { + Binder.restoreCallingIdentity(ident); + } + + return null; + } + + public void setAppOrientation(IApplicationToken token, int requestedOrientation) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setAppOrientation()")) { + return; + } + + synchronized(mWindowMap) { + AppWindowToken wtoken = findAppWindowToken(token.asBinder()); + if (wtoken == null) { + Log.w(TAG, "Attempted to set orientation of non-existing app token: " + token); + return; + } + + wtoken.requestedOrientation = requestedOrientation; + } + } + + public int getAppOrientation(IApplicationToken token) { + synchronized(mWindowMap) { + AppWindowToken wtoken = findAppWindowToken(token.asBinder()); + if (wtoken == null) { + return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + } + + return wtoken.requestedOrientation; + } + } + + public void setFocusedApp(IBinder token, boolean moveFocusNow) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setFocusedApp()")) { + return; + } + + synchronized(mWindowMap) { + boolean changed = false; + if (token == null) { + if (DEBUG_FOCUS) Log.v(TAG, "Clearing focused app, was " + mFocusedApp); + changed = mFocusedApp != null; + mFocusedApp = null; + mKeyWaiter.tickle(); + } else { + AppWindowToken newFocus = findAppWindowToken(token); + if (newFocus == null) { + Log.w(TAG, "Attempted to set focus to non-existing app token: " + token); + return; + } + changed = mFocusedApp != newFocus; + mFocusedApp = newFocus; + if (DEBUG_FOCUS) Log.v(TAG, "Set focused app to: " + mFocusedApp); + mKeyWaiter.tickle(); + } + + if (moveFocusNow && changed) { + final long origId = Binder.clearCallingIdentity(); + updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL); + Binder.restoreCallingIdentity(origId); + } + } + } + + public void prepareAppTransition(int transit) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "prepareAppTransition()")) { + return; + } + + synchronized(mWindowMap) { + if (DEBUG_APP_TRANSITIONS) Log.v( + TAG, "Prepare app transition: transit=" + transit + + " mNextAppTransition=" + mNextAppTransition); + if (!mDisplayFrozen) { + if (mNextAppTransition == WindowManagerPolicy.TRANSIT_NONE) { + mNextAppTransition = transit; + } + mAppTransitionReady = false; + mAppTransitionTimeout = false; + mStartingIconInTransition = false; + mSkipAppTransitionAnimation = false; + mH.removeMessages(H.APP_TRANSITION_TIMEOUT); + mH.sendMessageDelayed(mH.obtainMessage(H.APP_TRANSITION_TIMEOUT), + 5000); + } + } + } + + public int getPendingAppTransition() { + return mNextAppTransition; + } + + public void executeAppTransition() { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "executeAppTransition()")) { + return; + } + + synchronized(mWindowMap) { + if (DEBUG_APP_TRANSITIONS) Log.v( + TAG, "Execute app transition: mNextAppTransition=" + mNextAppTransition); + if (mNextAppTransition != WindowManagerPolicy.TRANSIT_NONE) { + mAppTransitionReady = true; + final long origId = Binder.clearCallingIdentity(); + performLayoutAndPlaceSurfacesLocked(); + Binder.restoreCallingIdentity(origId); + } + } + } + + public void setAppStartingWindow(IBinder token, String pkg, + int theme, CharSequence nonLocalizedLabel, int labelRes, int icon, + IBinder transferFrom, boolean createIfNeeded) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setAppStartingIcon()")) { + return; + } + + synchronized(mWindowMap) { + if (DEBUG_STARTING_WINDOW) Log.v( + TAG, "setAppStartingIcon: token=" + token + " pkg=" + pkg + + " transferFrom=" + transferFrom); + + AppWindowToken wtoken = findAppWindowToken(token); + if (wtoken == null) { + Log.w(TAG, "Attempted to set icon of non-existing app token: " + token); + return; + } + + // If the display is frozen, we won't do anything until the + // actual window is displayed so there is no reason to put in + // the starting window. + if (mDisplayFrozen) { + return; + } + + if (wtoken.startingData != null) { + return; + } + + if (transferFrom != null) { + AppWindowToken ttoken = findAppWindowToken(transferFrom); + if (ttoken != null) { + WindowState startingWindow = ttoken.startingWindow; + if (startingWindow != null) { + if (mStartingIconInTransition) { + // In this case, the starting icon has already + // been displayed, so start letting windows get + // shown immediately without any more transitions. + mSkipAppTransitionAnimation = true; + } + if (DEBUG_STARTING_WINDOW) Log.v(TAG, + "Moving existing starting from " + ttoken + + " to " + wtoken); + final long origId = Binder.clearCallingIdentity(); + + // Transfer the starting window over to the new + // token. + wtoken.startingData = ttoken.startingData; + wtoken.startingView = ttoken.startingView; + wtoken.startingWindow = startingWindow; + ttoken.startingData = null; + ttoken.startingView = null; + ttoken.startingWindow = null; + ttoken.startingMoved = true; + startingWindow.mToken = wtoken; + startingWindow.mAppToken = wtoken; + mWindows.remove(startingWindow); + ttoken.windows.remove(startingWindow); + ttoken.allAppWindows.remove(startingWindow); + addWindowToListInOrderLocked(startingWindow, true); + wtoken.allAppWindows.add(startingWindow); + + // Propagate other interesting state between the + // tokens. If the old token is displayed, we should + // immediately force the new one to be displayed. If + // it is animating, we need to move that animation to + // the new one. + if (ttoken.allDrawn) { + wtoken.allDrawn = true; + } + if (ttoken.firstWindowDrawn) { + wtoken.firstWindowDrawn = true; + } + if (!ttoken.hidden) { + wtoken.hidden = false; + wtoken.hiddenRequested = false; + wtoken.willBeHidden = false; + } + if (wtoken.clientHidden != ttoken.clientHidden) { + wtoken.clientHidden = ttoken.clientHidden; + wtoken.sendAppVisibilityToClients(); + } + if (ttoken.animation != null) { + wtoken.animation = ttoken.animation; + wtoken.animating = ttoken.animating; + wtoken.animLayerAdjustment = ttoken.animLayerAdjustment; + ttoken.animation = null; + ttoken.animLayerAdjustment = 0; + wtoken.updateLayers(); + ttoken.updateLayers(); + } + + updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES); + assignLayersLocked(); + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + Binder.restoreCallingIdentity(origId); + return; + } else if (ttoken.startingData != null) { + // The previous app was getting ready to show a + // starting window, but hasn't yet done so. Steal it! + if (DEBUG_STARTING_WINDOW) Log.v(TAG, + "Moving pending starting from " + ttoken + + " to " + wtoken); + wtoken.startingData = ttoken.startingData; + ttoken.startingData = null; + ttoken.startingMoved = true; + Message m = mH.obtainMessage(H.ADD_STARTING, wtoken); + // Note: we really want to do sendMessageAtFrontOfQueue() because we + // want to process the message ASAP, before any other queued + // messages. + mH.sendMessageAtFrontOfQueue(m); + return; + } + } + } + + // There is no existing starting window, and the caller doesn't + // want us to create one, so that's it! + if (!createIfNeeded) { + return; + } + + mStartingIconInTransition = true; + wtoken.startingData = new StartingData( + pkg, theme, nonLocalizedLabel, + labelRes, icon); + Message m = mH.obtainMessage(H.ADD_STARTING, wtoken); + // Note: we really want to do sendMessageAtFrontOfQueue() because we + // want to process the message ASAP, before any other queued + // messages. + mH.sendMessageAtFrontOfQueue(m); + } + } + + public void setAppWillBeHidden(IBinder token) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setAppWillBeHidden()")) { + return; + } + + AppWindowToken wtoken; + + synchronized(mWindowMap) { + wtoken = findAppWindowToken(token); + if (wtoken == null) { + Log.w(TAG, "Attempted to set will be hidden of non-existing app token: " + token); + return; + } + wtoken.willBeHidden = true; + } + } + + boolean setTokenVisibilityLocked(AppWindowToken wtoken, WindowManager.LayoutParams lp, + boolean visible, int transit, boolean performLayout) { + boolean delayed = false; + + if (wtoken.clientHidden == visible) { + wtoken.clientHidden = !visible; + wtoken.sendAppVisibilityToClients(); + } + + wtoken.willBeHidden = false; + if (wtoken.hidden == visible) { + final int N = wtoken.allAppWindows.size(); + boolean changed = false; + if (DEBUG_APP_TRANSITIONS) Log.v( + TAG, "Changing app " + wtoken + " hidden=" + wtoken.hidden + + " performLayout=" + performLayout); + + boolean runningAppAnimation = false; + + if (transit != WindowManagerPolicy.TRANSIT_NONE) { + if (wtoken.animation == sDummyAnimation) { + wtoken.animation = null; + } + applyAnimationLocked(wtoken, lp, transit, visible); + changed = true; + if (wtoken.animation != null) { + delayed = runningAppAnimation = true; + } + } + + for (int i=0; i<N; i++) { + WindowState win = wtoken.allAppWindows.get(i); + if (win == wtoken.startingWindow) { + continue; + } + + if (win.isAnimating()) { + delayed = true; + } + + //Log.i(TAG, "Window " + win + ": vis=" + win.isVisible()); + //win.dump(" "); + if (visible) { + if (!win.isVisibleNow()) { + if (!runningAppAnimation) { + applyAnimationLocked(win, + WindowManagerPolicy.TRANSIT_ENTER, true); + } + changed = true; + } + } else if (win.isVisibleNow()) { + if (!runningAppAnimation) { + applyAnimationLocked(win, + WindowManagerPolicy.TRANSIT_EXIT, false); + } + mKeyWaiter.finishedKey(win.mSession, win.mClient, true, + KeyWaiter.RETURN_NOTHING); + changed = true; + } + } + + wtoken.hidden = wtoken.hiddenRequested = !visible; + if (!visible) { + unsetAppFreezingScreenLocked(wtoken, true, true); + } else { + // If we are being set visible, and the starting window is + // not yet displayed, then make sure it doesn't get displayed. + WindowState swin = wtoken.startingWindow; + if (swin != null && (swin.mDrawPending + || swin.mCommitDrawPending)) { + swin.mPolicyVisibility = false; + swin.mPolicyVisibilityAfterAnim = false; + } + } + + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, "setTokenVisibilityLocked: " + wtoken + + ": hidden=" + wtoken.hidden + " hiddenRequested=" + + wtoken.hiddenRequested); + + if (changed && performLayout) { + mLayoutNeeded = true; + updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES); + assignLayersLocked(); + performLayoutAndPlaceSurfacesLocked(); + } + } + + if (wtoken.animation != null) { + delayed = true; + } + + return delayed; + } + + public void setAppVisibility(IBinder token, boolean visible) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setAppVisibility()")) { + return; + } + + AppWindowToken wtoken; + + synchronized(mWindowMap) { + wtoken = findAppWindowToken(token); + if (wtoken == null) { + Log.w(TAG, "Attempted to set visibility of non-existing app token: " + token); + return; + } + + if (DEBUG_APP_TRANSITIONS || DEBUG_ORIENTATION) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.v(TAG, "setAppVisibility(" + token + ", " + visible + + "): mNextAppTransition=" + mNextAppTransition + + " hidden=" + wtoken.hidden + + " hiddenRequested=" + wtoken.hiddenRequested, e); + } + + // If we are preparing an app transition, then delay changing + // the visibility of this token until we execute that transition. + if (!mDisplayFrozen && mNextAppTransition != WindowManagerPolicy.TRANSIT_NONE) { + // Already in requested state, don't do anything more. + if (wtoken.hiddenRequested != visible) { + return; + } + wtoken.hiddenRequested = !visible; + + if (DEBUG_APP_TRANSITIONS) Log.v( + TAG, "Setting dummy animation on: " + wtoken); + wtoken.setDummyAnimation(); + mOpeningApps.remove(wtoken); + mClosingApps.remove(wtoken); + wtoken.inPendingTransaction = true; + if (visible) { + mOpeningApps.add(wtoken); + wtoken.allDrawn = false; + wtoken.startingDisplayed = false; + wtoken.startingMoved = false; + + if (wtoken.clientHidden) { + // In the case where we are making an app visible + // but holding off for a transition, we still need + // to tell the client to make its windows visible so + // they get drawn. Otherwise, we will wait on + // performing the transition until all windows have + // been drawn, they never will be, and we are sad. + wtoken.clientHidden = false; + wtoken.sendAppVisibilityToClients(); + } + } else { + mClosingApps.add(wtoken); + } + return; + } + + final long origId = Binder.clearCallingIdentity(); + setTokenVisibilityLocked(wtoken, null, visible, WindowManagerPolicy.TRANSIT_NONE, true); + wtoken.updateReportedVisibilityLocked(); + Binder.restoreCallingIdentity(origId); + } + } + + void unsetAppFreezingScreenLocked(AppWindowToken wtoken, + boolean unfreezeSurfaceNow, boolean force) { + if (wtoken.freezingScreen) { + if (DEBUG_ORIENTATION) Log.v(TAG, "Clear freezing of " + wtoken + + " force=" + force); + final int N = wtoken.allAppWindows.size(); + boolean unfrozeWindows = false; + for (int i=0; i<N; i++) { + WindowState w = wtoken.allAppWindows.get(i); + if (w.mAppFreezing) { + w.mAppFreezing = false; + if (w.mSurface != null && !w.mOrientationChanging) { + w.mOrientationChanging = true; + } + unfrozeWindows = true; + } + } + if (force || unfrozeWindows) { + if (DEBUG_ORIENTATION) Log.v(TAG, "No longer freezing: " + wtoken); + wtoken.freezingScreen = false; + mAppsFreezingScreen--; + } + if (unfreezeSurfaceNow) { + if (unfrozeWindows) { + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + } + if (mAppsFreezingScreen == 0 && !mWindowsFreezingScreen) { + stopFreezingDisplayLocked(); + } + } + } + } + + public void startAppFreezingScreenLocked(AppWindowToken wtoken, + int configChanges) { + if (DEBUG_ORIENTATION) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.i(TAG, "Set freezing of " + wtoken.appToken + + ": hidden=" + wtoken.hidden + " freezing=" + + wtoken.freezingScreen, e); + } + if (!wtoken.hiddenRequested) { + if (!wtoken.freezingScreen) { + wtoken.freezingScreen = true; + mAppsFreezingScreen++; + if (mAppsFreezingScreen == 1) { + startFreezingDisplayLocked(); + mH.removeMessages(H.APP_FREEZE_TIMEOUT); + mH.sendMessageDelayed(mH.obtainMessage(H.APP_FREEZE_TIMEOUT), + 5000); + } + } + final int N = wtoken.allAppWindows.size(); + for (int i=0; i<N; i++) { + WindowState w = wtoken.allAppWindows.get(i); + w.mAppFreezing = true; + } + } + } + + public void startAppFreezingScreen(IBinder token, int configChanges) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setAppFreezingScreen()")) { + return; + } + + synchronized(mWindowMap) { + if (configChanges == 0 && !mDisplayFrozen) { + if (DEBUG_ORIENTATION) Log.v(TAG, "Skipping set freeze of " + token); + return; + } + + AppWindowToken wtoken = findAppWindowToken(token); + if (wtoken == null || wtoken.appToken == null) { + Log.w(TAG, "Attempted to freeze screen with non-existing app token: " + wtoken); + return; + } + final long origId = Binder.clearCallingIdentity(); + startAppFreezingScreenLocked(wtoken, configChanges); + Binder.restoreCallingIdentity(origId); + } + } + + public void stopAppFreezingScreen(IBinder token, boolean force) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "setAppFreezingScreen()")) { + return; + } + + synchronized(mWindowMap) { + AppWindowToken wtoken = findAppWindowToken(token); + if (wtoken == null || wtoken.appToken == null) { + return; + } + final long origId = Binder.clearCallingIdentity(); + if (DEBUG_ORIENTATION) Log.v(TAG, "Clear freezing of " + token + + ": hidden=" + wtoken.hidden + " freezing=" + wtoken.freezingScreen); + unsetAppFreezingScreenLocked(wtoken, true, force); + Binder.restoreCallingIdentity(origId); + } + } + + public void removeAppToken(IBinder token) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "removeAppToken()")) { + return; + } + + AppWindowToken wtoken = null; + AppWindowToken startingToken = null; + boolean delayed = false; + + final long origId = Binder.clearCallingIdentity(); + synchronized(mWindowMap) { + WindowToken basewtoken = mTokenMap.remove(token); + mTokenList.remove(basewtoken); + if (basewtoken != null && (wtoken=basewtoken.appWindowToken) != null) { + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, "Removing app token: " + wtoken); + delayed = setTokenVisibilityLocked(wtoken, null, false, WindowManagerPolicy.TRANSIT_NONE, true); + wtoken.inPendingTransaction = false; + mOpeningApps.remove(wtoken); + if (mClosingApps.contains(wtoken)) { + delayed = true; + } else if (mNextAppTransition != WindowManagerPolicy.TRANSIT_NONE) { + mClosingApps.add(wtoken); + delayed = true; + } + if (DEBUG_APP_TRANSITIONS) Log.v( + TAG, "Removing app " + wtoken + " delayed=" + delayed + + " animation=" + wtoken.animation + + " animating=" + wtoken.animating); + if (delayed) { + // set the token aside because it has an active animation to be finished + mExitingAppTokens.add(wtoken); + } + mAppTokens.remove(wtoken); + wtoken.removed = true; + if (wtoken.startingData != null) { + startingToken = wtoken; + } + unsetAppFreezingScreenLocked(wtoken, true, true); + if (mFocusedApp == wtoken) { + if (DEBUG_FOCUS) Log.v(TAG, "Removing focused app token:" + wtoken); + mFocusedApp = null; + updateFocusedWindowLocked(UPDATE_FOCUS_NORMAL); + mKeyWaiter.tickle(); + } + } else { + Log.w(TAG, "Attempted to remove non-existing app token: " + token); + } + + if (!delayed && wtoken != null) { + wtoken.updateReportedVisibilityLocked(); + } + } + Binder.restoreCallingIdentity(origId); + + if (startingToken != null) { + if (DEBUG_STARTING_WINDOW) Log.v(TAG, "Schedule remove starting " + + startingToken + ": app token removed"); + Message m = mH.obtainMessage(H.REMOVE_STARTING, startingToken); + mH.sendMessage(m); + } + } + + private boolean tmpRemoveAppWindowsLocked(WindowToken token) { + final int NW = token.windows.size(); + for (int i=0; i<NW; i++) { + WindowState win = token.windows.get(i); + mWindows.remove(win); + int j = win.mChildWindows.size(); + while (j > 0) { + j--; + mWindows.remove(win.mChildWindows.get(j)); + } + } + return NW > 0; + } + + void dumpAppTokensLocked() { + for (int i=mAppTokens.size()-1; i>=0; i--) { + Log.v(TAG, " #" + i + ": " + mAppTokens.get(i).token); + } + } + + void dumpWindowsLocked() { + for (int i=mWindows.size()-1; i>=0; i--) { + Log.v(TAG, " #" + i + ": " + mWindows.get(i)); + } + } + + private int findWindowOffsetLocked(int tokenPos) { + final int NW = mWindows.size(); + + if (tokenPos >= mAppTokens.size()) { + int i = NW; + while (i > 0) { + i--; + WindowState win = (WindowState)mWindows.get(i); + if (win.getAppToken() != null) { + return i+1; + } + } + } + + while (tokenPos > 0) { + // Find the first app token below the new position that has + // a window displayed. + final AppWindowToken wtoken = mAppTokens.get(tokenPos-1); + if (DEBUG_REORDER) Log.v(TAG, "Looking for lower windows @ " + + tokenPos + " -- " + wtoken.token); + int i = wtoken.windows.size(); + while (i > 0) { + i--; + WindowState win = wtoken.windows.get(i); + int j = win.mChildWindows.size(); + while (j > 0) { + j--; + WindowState cwin = (WindowState)win.mChildWindows.get(j); + if (cwin.mSubLayer >= 0 ) { + for (int pos=NW-1; pos>=0; pos--) { + if (mWindows.get(pos) == cwin) { + if (DEBUG_REORDER) Log.v(TAG, + "Found child win @" + (pos+1)); + return pos+1; + } + } + } + } + for (int pos=NW-1; pos>=0; pos--) { + if (mWindows.get(pos) == win) { + if (DEBUG_REORDER) Log.v(TAG, "Found win @" + (pos+1)); + return pos+1; + } + } + } + tokenPos--; + } + + return 0; + } + + private final int reAddWindowLocked(int index, WindowState win) { + final int NCW = win.mChildWindows.size(); + boolean added = false; + for (int j=0; j<NCW; j++) { + WindowState cwin = (WindowState)win.mChildWindows.get(j); + if (!added && cwin.mSubLayer >= 0) { + mWindows.add(index, win); + index++; + added = true; + } + mWindows.add(index, cwin); + index++; + } + if (!added) { + mWindows.add(index, win); + index++; + } + return index; + } + + private final int reAddAppWindowsLocked(int index, WindowToken token) { + final int NW = token.windows.size(); + for (int i=0; i<NW; i++) { + index = reAddWindowLocked(index, token.windows.get(i)); + } + return index; + } + + public void moveAppToken(int index, IBinder token) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "moveAppToken()")) { + return; + } + + synchronized(mWindowMap) { + if (DEBUG_REORDER) Log.v(TAG, "Initial app tokens:"); + if (DEBUG_REORDER) dumpAppTokensLocked(); + final AppWindowToken wtoken = findAppWindowToken(token); + if (wtoken == null || !mAppTokens.remove(wtoken)) { + Log.w(TAG, "Attempting to reorder token that doesn't exist: " + + token + " (" + wtoken + ")"); + return; + } + mAppTokens.add(index, wtoken); + if (DEBUG_REORDER) Log.v(TAG, "Moved " + token + " to " + index + ":"); + if (DEBUG_REORDER) dumpAppTokensLocked(); + + final long origId = Binder.clearCallingIdentity(); + if (DEBUG_REORDER) Log.v(TAG, "Removing windows in " + token + ":"); + if (DEBUG_REORDER) dumpWindowsLocked(); + if (tmpRemoveAppWindowsLocked(wtoken)) { + if (DEBUG_REORDER) Log.v(TAG, "Adding windows back in:"); + if (DEBUG_REORDER) dumpWindowsLocked(); + reAddAppWindowsLocked(findWindowOffsetLocked(index), wtoken); + if (DEBUG_REORDER) Log.v(TAG, "Final window list:"); + if (DEBUG_REORDER) dumpWindowsLocked(); + updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES); + assignLayersLocked(); + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + } + Binder.restoreCallingIdentity(origId); + } + } + + private void removeAppTokensLocked(List<IBinder> tokens) { + // XXX This should be done more efficiently! + // (take advantage of the fact that both lists should be + // ordered in the same way.) + int N = tokens.size(); + for (int i=0; i<N; i++) { + IBinder token = tokens.get(i); + final AppWindowToken wtoken = findAppWindowToken(token); + if (!mAppTokens.remove(wtoken)) { + Log.w(TAG, "Attempting to reorder token that doesn't exist: " + + token + " (" + wtoken + ")"); + i--; + N--; + } + } + } + + private void moveAppWindowsLocked(List<IBinder> tokens, int tokenPos) { + // First remove all of the windows from the list. + final int N = tokens.size(); + int i; + for (i=0; i<N; i++) { + WindowToken token = mTokenMap.get(tokens.get(i)); + if (token != null) { + tmpRemoveAppWindowsLocked(token); + } + } + + // Where to start adding? + int pos = findWindowOffsetLocked(tokenPos); + + // And now add them back at the correct place. + for (i=0; i<N; i++) { + WindowToken token = mTokenMap.get(tokens.get(i)); + if (token != null) { + pos = reAddAppWindowsLocked(pos, token); + } + } + + updateFocusedWindowLocked(UPDATE_FOCUS_WILL_PLACE_SURFACES); + assignLayersLocked(); + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + + //dump(); + } + + public void moveAppTokensToTop(List<IBinder> tokens) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "moveAppTokensToTop()")) { + return; + } + + final long origId = Binder.clearCallingIdentity(); + synchronized(mWindowMap) { + removeAppTokensLocked(tokens); + final int N = tokens.size(); + for (int i=0; i<N; i++) { + AppWindowToken wt = findAppWindowToken(tokens.get(i)); + if (wt != null) { + mAppTokens.add(wt); + } + } + moveAppWindowsLocked(tokens, mAppTokens.size()); + } + Binder.restoreCallingIdentity(origId); + } + + public void moveAppTokensToBottom(List<IBinder> tokens) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "moveAppTokensToBottom()")) { + return; + } + + final long origId = Binder.clearCallingIdentity(); + synchronized(mWindowMap) { + removeAppTokensLocked(tokens); + final int N = tokens.size(); + int pos = 0; + for (int i=0; i<N; i++) { + AppWindowToken wt = findAppWindowToken(tokens.get(i)); + if (wt != null) { + mAppTokens.add(pos, wt); + pos++; + } + } + moveAppWindowsLocked(tokens, 0); + } + Binder.restoreCallingIdentity(origId); + } + + // ------------------------------------------------------------- + // Misc IWindowSession methods + // ------------------------------------------------------------- + + public void disableKeyguard(IBinder token, String tag) { + if (mContext.checkCallingPermission(android.Manifest.permission.DISABLE_KEYGUARD) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires DISABLE_KEYGUARD permission"); + } + mKeyguardDisabled.acquire(token, tag); + } + + public void reenableKeyguard(IBinder token) { + if (mContext.checkCallingPermission(android.Manifest.permission.DISABLE_KEYGUARD) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires DISABLE_KEYGUARD permission"); + } + synchronized (mKeyguardDisabled) { + mKeyguardDisabled.release(token); + + if (!mKeyguardDisabled.isAcquired()) { + // if we are the last one to reenable the keyguard wait until + // we have actaully finished reenabling until returning + mWaitingUntilKeyguardReenabled = true; + while (mWaitingUntilKeyguardReenabled) { + try { + mKeyguardDisabled.wait(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + } + } + } + } + } + + /** + * @see android.app.KeyguardManager#exitKeyguardSecurely + */ + public void exitKeyguardSecurely(final IOnKeyguardExitResult callback) { + if (mContext.checkCallingPermission(android.Manifest.permission.DISABLE_KEYGUARD) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires DISABLE_KEYGUARD permission"); + } + mPolicy.exitKeyguardSecurely(new WindowManagerPolicy.OnKeyguardExitResult() { + public void onKeyguardExitResult(boolean success) { + try { + callback.onKeyguardExitResult(success); + } catch (RemoteException e) { + // Client has died, we don't care. + } + } + }); + } + + public boolean inKeyguardRestrictedInputMode() { + return mPolicy.inKeyguardRestrictedKeyInputMode(); + } + + static float fixScale(float scale) { + if (scale < 0) scale = 0; + else if (scale > 20) scale = 20; + return Math.abs(scale); + } + + public void setAnimationScale(int which, float scale) { + if (!checkCallingPermission(android.Manifest.permission.SET_ANIMATION_SCALE, + "setAnimationScale()")) { + return; + } + + if (scale < 0) scale = 0; + else if (scale > 20) scale = 20; + scale = Math.abs(scale); + switch (which) { + case 0: mWindowAnimationScale = fixScale(scale); break; + case 1: mTransitionAnimationScale = fixScale(scale); break; + } + + // Persist setting + mH.obtainMessage(H.PERSIST_ANIMATION_SCALE).sendToTarget(); + } + + public void setAnimationScales(float[] scales) { + if (!checkCallingPermission(android.Manifest.permission.SET_ANIMATION_SCALE, + "setAnimationScale()")) { + return; + } + + if (scales != null) { + if (scales.length >= 1) { + mWindowAnimationScale = fixScale(scales[0]); + } + if (scales.length >= 2) { + mTransitionAnimationScale = fixScale(scales[1]); + } + } + + // Persist setting + mH.obtainMessage(H.PERSIST_ANIMATION_SCALE).sendToTarget(); + } + + public float getAnimationScale(int which) { + switch (which) { + case 0: return mWindowAnimationScale; + case 1: return mTransitionAnimationScale; + } + return 0; + } + + public float[] getAnimationScales() { + return new float[] { mWindowAnimationScale, mTransitionAnimationScale }; + } + + public int getSwitchState(int sw) { + if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, + "getSwitchState()")) { + return -1; + } + return KeyInputQueue.getSwitchState(sw); + } + + public int getSwitchStateForDevice(int devid, int sw) { + if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, + "getSwitchStateForDevice()")) { + return -1; + } + return KeyInputQueue.getSwitchState(devid, sw); + } + + public int getScancodeState(int sw) { + if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, + "getScancodeState()")) { + return -1; + } + return KeyInputQueue.getScancodeState(sw); + } + + public int getScancodeStateForDevice(int devid, int sw) { + if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, + "getScancodeStateForDevice()")) { + return -1; + } + return KeyInputQueue.getScancodeState(devid, sw); + } + + public int getKeycodeState(int sw) { + if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, + "getKeycodeState()")) { + return -1; + } + return KeyInputQueue.getKeycodeState(sw); + } + + public int getKeycodeStateForDevice(int devid, int sw) { + if (!checkCallingPermission(android.Manifest.permission.READ_INPUT_STATE, + "getKeycodeStateForDevice()")) { + return -1; + } + return KeyInputQueue.getKeycodeState(devid, sw); + } + + public boolean hasKeys(int[] keycodes, boolean[] keyExists) { + return KeyInputQueue.hasKeys(keycodes, keyExists); + } + + public void enableScreenAfterBoot() { + synchronized(mWindowMap) { + if (mSystemBooted) { + return; + } + mSystemBooted = true; + } + + performEnableScreen(); + } + + public void enableScreenIfNeededLocked() { + if (mDisplayEnabled) { + return; + } + if (!mSystemBooted) { + return; + } + mH.sendMessage(mH.obtainMessage(H.ENABLE_SCREEN)); + } + + public void performEnableScreen() { + synchronized(mWindowMap) { + if (mDisplayEnabled) { + return; + } + if (!mSystemBooted) { + return; + } + + // Don't enable the screen until all existing windows + // have been drawn. + final int N = mWindows.size(); + for (int i=0; i<N; i++) { + WindowState w = (WindowState)mWindows.get(i); + if (w.isVisibleLw() && !w.isDisplayedLw()) { + return; + } + } + + mDisplayEnabled = true; + if (false) { + Log.i(TAG, "ENABLING SCREEN!"); + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + this.dump(null, pw, null); + Log.i(TAG, sw.toString()); + } + try { + IBinder surfaceFlinger = ServiceManager.getService("SurfaceFlinger"); + if (surfaceFlinger != null) { + //Log.i(TAG, "******* TELLING SURFACE FLINGER WE ARE BOOTED!"); + Parcel data = Parcel.obtain(); + data.writeInterfaceToken("android.ui.ISurfaceComposer"); + surfaceFlinger.transact(IBinder.FIRST_CALL_TRANSACTION, + data, null, 0); + data.recycle(); + } + } catch (RemoteException ex) { + Log.e(TAG, "Boot completed: SurfaceFlinger is dead!"); + } + } + + mPolicy.enableScreenAfterBoot(); + + // Make sure the last requested orientation has been applied. + setRotationUnchecked(WindowManagerPolicy.USE_LAST_ROTATION, false); + } + + public void setInTouchMode(boolean mode) { + synchronized(mWindowMap) { + mInTouchMode = mode; + } + } + + public void setRotation(int rotation, + boolean alwaysSendConfiguration) { + if (!checkCallingPermission(android.Manifest.permission.SET_ORIENTATION, + "setOrientation()")) { + return; + } + + setRotationUnchecked(rotation, alwaysSendConfiguration); + } + + public void setRotationUnchecked(int rotation, boolean alwaysSendConfiguration) { + if(DEBUG_ORIENTATION) Log.v(TAG, + "alwaysSendConfiguration set to "+alwaysSendConfiguration); + + long origId = Binder.clearCallingIdentity(); + boolean changed; + synchronized(mWindowMap) { + changed = setRotationUncheckedLocked(rotation); + } + + if (changed) { + sendNewConfiguration(); + synchronized(mWindowMap) { + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + } + } else if (alwaysSendConfiguration) { + //update configuration ignoring orientation change + sendNewConfiguration(); + } + + Binder.restoreCallingIdentity(origId); + } + + public boolean setRotationUncheckedLocked(int rotation) { + boolean changed; + if (rotation == WindowManagerPolicy.USE_LAST_ROTATION) { + rotation = mRequestedRotation; + } else { + mRequestedRotation = rotation; + } + if (DEBUG_ORIENTATION) Log.v(TAG, "Overwriting rotation value from " + rotation); + rotation = mPolicy.rotationForOrientation(mForcedAppOrientation, + mRotation, mDisplayEnabled); + if (DEBUG_ORIENTATION) Log.v(TAG, "new rotation is set to " + rotation); + changed = mDisplayEnabled && mRotation != rotation; + + if (changed) { + if (DEBUG_ORIENTATION) Log.v(TAG, + "Rotation changed to " + rotation + + " from " + mRotation + + " (forceApp=" + mForcedAppOrientation + + ", req=" + mRequestedRotation + ")"); + mRotation = rotation; + mWindowsFreezingScreen = true; + mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT); + mH.sendMessageDelayed(mH.obtainMessage(H.WINDOW_FREEZE_TIMEOUT), + 2000); + startFreezingDisplayLocked(); + mQueue.setOrientation(rotation); + if (mDisplayEnabled) { + Surface.setOrientation(0, rotation); + } + for (int i=mWindows.size()-1; i>=0; i--) { + WindowState w = (WindowState)mWindows.get(i); + if (w.mSurface != null) { + w.mOrientationChanging = true; + } + } + for (int i=mRotationWatchers.size()-1; i>=0; i--) { + try { + mRotationWatchers.get(i).onRotationChanged(rotation); + } catch (RemoteException e) { + } + } + } //end if changed + + return changed; + } + + public int getRotation() { + return mRotation; + } + + public int watchRotation(IRotationWatcher watcher) { + final IBinder watcherBinder = watcher.asBinder(); + IBinder.DeathRecipient dr = new IBinder.DeathRecipient() { + public void binderDied() { + synchronized (mWindowMap) { + for (int i=0; i<mRotationWatchers.size(); i++) { + if (watcherBinder == mRotationWatchers.get(i).asBinder()) { + mRotationWatchers.remove(i); + i--; + } + } + } + } + }; + + synchronized (mWindowMap) { + try { + watcher.asBinder().linkToDeath(dr, 0); + mRotationWatchers.add(watcher); + } catch (RemoteException e) { + // Client died, no cleanup needed. + } + + return mRotation; + } + } + + /** + * Starts the view server on the specified port. + * + * @param port The port to listener to. + * + * @return True if the server was successfully started, false otherwise. + * + * @see com.android.server.ViewServer + * @see com.android.server.ViewServer#VIEW_SERVER_DEFAULT_PORT + */ + public boolean startViewServer(int port) { + if ("1".equals(SystemProperties.get(SYSTEM_SECURE, "0"))) { + return false; + } + + if (!checkCallingPermission(Manifest.permission.DUMP, "startViewServer")) { + return false; + } + + if (port < 1024) { + return false; + } + + if (mViewServer != null) { + if (!mViewServer.isRunning()) { + try { + return mViewServer.start(); + } catch (IOException e) { + Log.w(TAG, "View server did not start"); + } + } + return false; + } + + try { + mViewServer = new ViewServer(this, port); + return mViewServer.start(); + } catch (IOException e) { + Log.w(TAG, "View server did not start"); + } + return false; + } + + /** + * Stops the view server if it exists. + * + * @return True if the server stopped, false if it wasn't started or + * couldn't be stopped. + * + * @see com.android.server.ViewServer + */ + public boolean stopViewServer() { + if ("1".equals(SystemProperties.get(SYSTEM_SECURE, "0"))) { + return false; + } + + if (!checkCallingPermission(Manifest.permission.DUMP, "stopViewServer")) { + return false; + } + + if (mViewServer != null) { + return mViewServer.stop(); + } + return false; + } + + /** + * Indicates whether the view server is running. + * + * @return True if the server is running, false otherwise. + * + * @see com.android.server.ViewServer + */ + public boolean isViewServerRunning() { + if ("1".equals(SystemProperties.get(SYSTEM_SECURE, "0"))) { + return false; + } + + if (!checkCallingPermission(Manifest.permission.DUMP, "isViewServerRunning")) { + return false; + } + + return mViewServer != null && mViewServer.isRunning(); + } + + /** + * Lists all availble windows in the system. The listing is written in the + * specified Socket's output stream with the following syntax: + * windowHashCodeInHexadecimal windowName + * Each line of the ouput represents a different window. + * + * @param client The remote client to send the listing to. + * @return False if an error occured, true otherwise. + */ + boolean viewServerListWindows(Socket client) { + if ("1".equals(SystemProperties.get(SYSTEM_SECURE, "0"))) { + return false; + } + + boolean result = true; + + Object[] windows; + synchronized (mWindowMap) { + windows = new Object[mWindows.size()]; + //noinspection unchecked + windows = mWindows.toArray(windows); + } + + BufferedWriter out = null; + + // Any uncaught exception will crash the system process + try { + OutputStream clientStream = client.getOutputStream(); + out = new BufferedWriter(new OutputStreamWriter(clientStream), 8 * 1024); + + final int count = windows.length; + for (int i = 0; i < count; i++) { + final WindowState w = (WindowState) windows[i]; + out.write(Integer.toHexString(System.identityHashCode(w))); + out.write(' '); + out.append(w.mAttrs.getTitle()); + out.write('\n'); + } + + out.write("DONE.\n"); + out.flush(); + } catch (Exception e) { + result = false; + } finally { + if (out != null) { + try { + out.close(); + } catch (IOException e) { + result = false; + } + } + } + + return result; + } + + /** + * Sends a command to a target window. The result of the command, if any, will be + * written in the output stream of the specified socket. + * + * The parameters must follow this syntax: + * windowHashcode extra + * + * Where XX is the length in characeters of the windowTitle. + * + * The first parameter is the target window. The window with the specified hashcode + * will be the target. If no target can be found, nothing happens. The extra parameters + * will be delivered to the target window and as parameters to the command itself. + * + * @param client The remote client to sent the result, if any, to. + * @param command The command to execute. + * @param parameters The command parameters. + * + * @return True if the command was successfully delivered, false otherwise. This does + * not indicate whether the command itself was successful. + */ + boolean viewServerWindowCommand(Socket client, String command, String parameters) { + if ("1".equals(SystemProperties.get(SYSTEM_SECURE, "0"))) { + return false; + } + + boolean success = true; + Parcel data = null; + Parcel reply = null; + + // Any uncaught exception will crash the system process + try { + // Find the hashcode of the window + int index = parameters.indexOf(' '); + if (index == -1) { + index = parameters.length(); + } + final String code = parameters.substring(0, index); + int hashCode = "ffffffff".equals(code) ? -1 : Integer.parseInt(code, 16); + + // Extract the command's parameter after the window description + if (index < parameters.length()) { + parameters = parameters.substring(index + 1); + } else { + parameters = ""; + } + + final WindowManagerService.WindowState window = findWindow(hashCode); + if (window == null) { + return false; + } + + data = Parcel.obtain(); + data.writeInterfaceToken("android.view.IWindow"); + data.writeString(command); + data.writeString(parameters); + data.writeInt(1); + ParcelFileDescriptor.fromSocket(client).writeToParcel(data, 0); + + reply = Parcel.obtain(); + + final IBinder binder = window.mClient.asBinder(); + // TODO: GET THE TRANSACTION CODE IN A SAFER MANNER + binder.transact(IBinder.FIRST_CALL_TRANSACTION, data, reply, 0); + + reply.readException(); + + } catch (Exception e) { + Log.w(TAG, "Could not send command " + command + " with parameters " + parameters, e); + success = false; + } finally { + if (data != null) { + data.recycle(); + } + if (reply != null) { + reply.recycle(); + } + } + + return success; + } + + private WindowState findWindow(int hashCode) { + if (hashCode == -1) { + return getFocusedWindow(); + } + + synchronized (mWindowMap) { + final ArrayList windows = mWindows; + final int count = windows.size(); + + for (int i = 0; i < count; i++) { + WindowState w = (WindowState) windows.get(i); + if (System.identityHashCode(w) == hashCode) { + return w; + } + } + } + + return null; + } + + /* + * Instruct the Activity Manager to fetch the current configuration and broadcast + * that to config-changed listeners if appropriate. + */ + void sendNewConfiguration() { + try { + mActivityManager.updateConfiguration(null); + } catch (RemoteException e) { + } + } + + public Configuration computeNewConfiguration() { + synchronized (mWindowMap) { + if (mDisplay == null) { + return null; + } + Configuration config = new Configuration(); + mQueue.getInputConfiguration(config); + final int dw = mDisplay.getWidth(); + final int dh = mDisplay.getHeight(); + int orientation = Configuration.ORIENTATION_SQUARE; + if (dw < dh) { + orientation = Configuration.ORIENTATION_PORTRAIT; + } else if (dw > dh) { + orientation = Configuration.ORIENTATION_LANDSCAPE; + } + config.orientation = orientation; + config.keyboardHidden = Configuration.KEYBOARDHIDDEN_NO; + config.hardKeyboardHidden = Configuration.HARDKEYBOARDHIDDEN_NO; + mPolicy.adjustConfigurationLw(config); + Log.i(TAG, "Input configuration changed: " + config); + long now = SystemClock.uptimeMillis(); + //Log.i(TAG, "Config changing, gc pending: " + mFreezeGcPending + ", now " + now); + if (mFreezeGcPending != 0) { + if (now > (mFreezeGcPending+1000)) { + //Log.i(TAG, "Gc! " + now + " > " + (mFreezeGcPending+1000)); + mH.removeMessages(H.FORCE_GC); + Runtime.getRuntime().gc(); + mFreezeGcPending = now; + } + } else { + mFreezeGcPending = now; + } + return config; + } + } + + // ------------------------------------------------------------- + // Input Events and Focus Management + // ------------------------------------------------------------- + + private final void wakeupIfNeeded(WindowState targetWin, int eventType) { + if (targetWin == null || + targetWin.mAttrs.type != WindowManager.LayoutParams.TYPE_KEYGUARD) { + mPowerManager.userActivity(SystemClock.uptimeMillis(), false, eventType); + } + } + + // tells if it's a cheek event or not -- this function is stateful + private static final int EVENT_NONE = 0; + private static final int EVENT_UNKNOWN = 0; + private static final int EVENT_CHEEK = 0; + private static final int EVENT_IGNORE_DURATION = 300; // ms + private static final float CHEEK_THRESHOLD = 0.6f; + private int mEventState = EVENT_NONE; + private float mEventSize; + private int eventType(MotionEvent ev) { + float size = ev.getSize(); + switch (ev.getAction()) { + case MotionEvent.ACTION_DOWN: + mEventSize = size; + return (mEventSize > CHEEK_THRESHOLD) ? CHEEK_EVENT : TOUCH_EVENT; + case MotionEvent.ACTION_UP: + if (size > mEventSize) mEventSize = size; + return (mEventSize > CHEEK_THRESHOLD) ? CHEEK_EVENT : OTHER_EVENT; + case MotionEvent.ACTION_MOVE: + final int N = ev.getHistorySize(); + if (size > mEventSize) mEventSize = size; + if (mEventSize > CHEEK_THRESHOLD) return CHEEK_EVENT; + for (int i=0; i<N; i++) { + size = ev.getHistoricalSize(i); + if (size > mEventSize) mEventSize = size; + if (mEventSize > CHEEK_THRESHOLD) return CHEEK_EVENT; + } + if (ev.getEventTime() < ev.getDownTime() + EVENT_IGNORE_DURATION) { + return TOUCH_EVENT; + } else { + return OTHER_EVENT; + } + default: + // not good + return OTHER_EVENT; + } + } + + /** + * @return Returns true if event was dispatched, false if it was dropped for any reason + */ + private boolean dispatchPointer(QueuedEvent qev, MotionEvent ev, int pid, int uid) { + if (DEBUG_INPUT || WindowManagerPolicy.WATCH_POINTER) Log.v(TAG, + "dispatchPointer " + ev); + + Object targetObj = mKeyWaiter.waitForNextEventTarget(null, qev, + ev, true, false); + + int action = ev.getAction(); + + if (action == MotionEvent.ACTION_UP) { + // let go of our target + mKeyWaiter.mMotionTarget = null; + mPowerManager.logPointerUpEvent(); + } else if (action == MotionEvent.ACTION_DOWN) { + mPowerManager.logPointerDownEvent(); + } + + if (targetObj == null) { + // In this case we are either dropping the event, or have received + // a move or up without a down. It is common to receive move + // events in such a way, since this means the user is moving the + // pointer without actually pressing down. All other cases should + // be atypical, so let's log them. + if (ev.getAction() != MotionEvent.ACTION_MOVE) { + Log.w(TAG, "No window to dispatch pointer action " + ev.getAction()); + } + if (qev != null) { + mQueue.recycleEvent(qev); + } + ev.recycle(); + return false; + } + if (targetObj == mKeyWaiter.CONSUMED_EVENT_TOKEN) { + if (qev != null) { + mQueue.recycleEvent(qev); + } + ev.recycle(); + return true; + } + + WindowState target = (WindowState)targetObj; + + final long eventTime = ev.getEventTime(); + + //Log.i(TAG, "Sending " + ev + " to " + target); + + if (uid != 0 && uid != target.mSession.mUid) { + if (mContext.checkPermission( + android.Manifest.permission.INJECT_EVENTS, pid, uid) + != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission denied: injecting pointer event from pid " + + pid + " uid " + uid + " to window " + target + + " owned by uid " + target.mSession.mUid); + if (qev != null) { + mQueue.recycleEvent(qev); + } + ev.recycle(); + return false; + } + } + + if ((target.mAttrs.flags & + WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES) != 0) { + //target wants to ignore fat touch events + boolean cheekPress = mPolicy.isCheekPressedAgainstScreen(ev); + //explicit flag to return without processing event further + boolean returnFlag = false; + if((action == MotionEvent.ACTION_DOWN)) { + mFatTouch = false; + if(cheekPress) { + mFatTouch = true; + returnFlag = true; + } + } else { + if(action == MotionEvent.ACTION_UP) { + if(mFatTouch) { + //earlier even was invalid doesnt matter if current up is cheekpress or not + mFatTouch = false; + returnFlag = true; + } else if(cheekPress) { + //cancel the earlier event + ev.setAction(MotionEvent.ACTION_CANCEL); + action = MotionEvent.ACTION_CANCEL; + } + } else if(action == MotionEvent.ACTION_MOVE) { + if(mFatTouch) { + //two cases here + //an invalid down followed by 0 or moves(valid or invalid) + //a valid down, invalid move, more moves. want to ignore till up + returnFlag = true; + } else if(cheekPress) { + //valid down followed by invalid moves + //an invalid move have to cancel earlier action + ev.setAction(MotionEvent.ACTION_CANCEL); + action = MotionEvent.ACTION_CANCEL; + if (DEBUG_INPUT) Log.v(TAG, "Sending cancel for invalid ACTION_MOVE"); + //note that the subsequent invalid moves will not get here + mFatTouch = true; + } + } + } //else if action + if(returnFlag) { + //recycle que, ev + if (qev != null) { + mQueue.recycleEvent(qev); + } + ev.recycle(); + return false; + } + } //end if target + + synchronized(mWindowMap) { + if (qev != null && action == MotionEvent.ACTION_MOVE) { + mKeyWaiter.bindTargetWindowLocked(target, + KeyWaiter.RETURN_PENDING_POINTER, qev); + ev = null; + } else { + if (action == MotionEvent.ACTION_DOWN) { + WindowState out = mKeyWaiter.mOutsideTouchTargets; + if (out != null) { + MotionEvent oev = MotionEvent.obtain(ev); + oev.setAction(MotionEvent.ACTION_OUTSIDE); + do { + final Rect frame = out.mFrame; + oev.offsetLocation(-(float)frame.left, -(float)frame.top); + try { + out.mClient.dispatchPointer(oev, eventTime); + } catch (android.os.RemoteException e) { + Log.i(TAG, "WINDOW DIED during outside motion dispatch: " + out); + } + oev.offsetLocation((float)frame.left, (float)frame.top); + out = out.mNextOutsideTouch; + } while (out != null); + mKeyWaiter.mOutsideTouchTargets = null; + } + } + final Rect frame = target.mFrame; + ev.offsetLocation(-(float)frame.left, -(float)frame.top); + mKeyWaiter.bindTargetWindowLocked(target); + } + } + + // finally offset the event to the target's coordinate system and + // dispatch the event. + try { + if (DEBUG_INPUT || DEBUG_FOCUS || WindowManagerPolicy.WATCH_POINTER) { + Log.v(TAG, "Delivering pointer " + qev + " to " + target); + } + target.mClient.dispatchPointer(ev, eventTime); + return true; + } catch (android.os.RemoteException e) { + Log.i(TAG, "WINDOW DIED during motion dispatch: " + target); + mKeyWaiter.mMotionTarget = null; + try { + removeWindow(target.mSession, target.mClient); + } catch (java.util.NoSuchElementException ex) { + // This will happen if the window has already been + // removed. + } + } + return false; + } + + /** + * @return Returns true if event was dispatched, false if it was dropped for any reason + */ + private boolean dispatchTrackball(QueuedEvent qev, MotionEvent ev, int pid, int uid) { + if (DEBUG_INPUT) Log.v( + TAG, "dispatchTrackball [" + ev.getAction() +"] <" + ev.getX() + ", " + ev.getY() + ">"); + + Object focusObj = mKeyWaiter.waitForNextEventTarget(null, qev, + ev, false, false); + if (focusObj == null) { + Log.w(TAG, "No focus window, dropping trackball: " + ev); + if (qev != null) { + mQueue.recycleEvent(qev); + } + ev.recycle(); + return false; + } + if (focusObj == mKeyWaiter.CONSUMED_EVENT_TOKEN) { + if (qev != null) { + mQueue.recycleEvent(qev); + } + ev.recycle(); + return true; + } + + WindowState focus = (WindowState)focusObj; + + if (uid != 0 && uid != focus.mSession.mUid) { + if (mContext.checkPermission( + android.Manifest.permission.INJECT_EVENTS, pid, uid) + != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission denied: injecting key event from pid " + + pid + " uid " + uid + " to window " + focus + + " owned by uid " + focus.mSession.mUid); + if (qev != null) { + mQueue.recycleEvent(qev); + } + ev.recycle(); + return false; + } + } + + final long eventTime = ev.getEventTime(); + + synchronized(mWindowMap) { + if (qev != null && ev.getAction() == MotionEvent.ACTION_MOVE) { + mKeyWaiter.bindTargetWindowLocked(focus, + KeyWaiter.RETURN_PENDING_TRACKBALL, qev); + // We don't deliver movement events to the client, we hold + // them and wait for them to call back. + ev = null; + } else { + mKeyWaiter.bindTargetWindowLocked(focus); + } + } + + try { + focus.mClient.dispatchTrackball(ev, eventTime); + return true; + } catch (android.os.RemoteException e) { + Log.i(TAG, "WINDOW DIED during key dispatch: " + focus); + try { + removeWindow(focus.mSession, focus.mClient); + } catch (java.util.NoSuchElementException ex) { + // This will happen if the window has already been + // removed. + } + } + + return false; + } + + /** + * @return Returns true if event was dispatched, false if it was dropped for any reason + */ + private boolean dispatchKey(KeyEvent event, int pid, int uid) { + if (DEBUG_INPUT) Log.v(TAG, "Dispatch key: " + event); + + Object focusObj = mKeyWaiter.waitForNextEventTarget(event, null, + null, false, false); + if (focusObj == null) { + Log.w(TAG, "No focus window, dropping: " + event); + return false; + } + if (focusObj == mKeyWaiter.CONSUMED_EVENT_TOKEN) { + return true; + } + + WindowState focus = (WindowState)focusObj; + + if (DEBUG_INPUT) Log.v( + TAG, "Dispatching to " + focus + ": " + event); + + if (uid != 0 && uid != focus.mSession.mUid) { + if (mContext.checkPermission( + android.Manifest.permission.INJECT_EVENTS, pid, uid) + != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission denied: injecting key event from pid " + + pid + " uid " + uid + " to window " + focus + + " owned by uid " + focus.mSession.mUid); + return false; + } + } + + synchronized(mWindowMap) { + mKeyWaiter.bindTargetWindowLocked(focus); + } + + // NOSHIP extra state logging + mKeyWaiter.recordDispatchState(event, focus); + // END NOSHIP + + try { + if (DEBUG_INPUT || DEBUG_FOCUS) { + Log.v(TAG, "Delivering key " + event.getKeyCode() + + " to " + focus); + } + focus.mClient.dispatchKey(event); + return true; + } catch (android.os.RemoteException e) { + Log.i(TAG, "WINDOW DIED during key dispatch: " + focus); + try { + removeWindow(focus.mSession, focus.mClient); + } catch (java.util.NoSuchElementException ex) { + // This will happen if the window has already been + // removed. + } + } + + return false; + } + + public void pauseKeyDispatching(IBinder _token) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "pauseKeyDispatching()")) { + return; + } + + synchronized (mWindowMap) { + WindowToken token = mTokenMap.get(_token); + if (token != null) { + mKeyWaiter.pauseDispatchingLocked(token); + } + } + } + + public void resumeKeyDispatching(IBinder _token) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "resumeKeyDispatching()")) { + return; + } + + synchronized (mWindowMap) { + WindowToken token = mTokenMap.get(_token); + if (token != null) { + mKeyWaiter.resumeDispatchingLocked(token); + } + } + } + + public void setEventDispatching(boolean enabled) { + if (!checkCallingPermission(android.Manifest.permission.MANAGE_APP_TOKENS, + "resumeKeyDispatching()")) { + return; + } + + synchronized (mWindowMap) { + mKeyWaiter.setEventDispatchingLocked(enabled); + } + } + + /** + * Injects a keystroke event into the UI. + * + * @param ev A motion event describing the keystroke action. (Be sure to use + * {@link SystemClock#uptimeMillis()} as the timebase.) + * @param sync If true, wait for the event to be completed before returning to the caller. + * @return Returns true if event was dispatched, false if it was dropped for any reason + */ + public boolean injectKeyEvent(KeyEvent ev, boolean sync) { + long downTime = ev.getDownTime(); + long eventTime = ev.getEventTime(); + + int action = ev.getAction(); + int code = ev.getKeyCode(); + int repeatCount = ev.getRepeatCount(); + int metaState = ev.getMetaState(); + int deviceId = ev.getDeviceId(); + int scancode = ev.getScanCode(); + + if (eventTime == 0) eventTime = SystemClock.uptimeMillis(); + if (downTime == 0) downTime = eventTime; + + KeyEvent newEvent = new KeyEvent(downTime, eventTime, action, code, repeatCount, metaState, + deviceId, scancode); + + boolean result = dispatchKey(newEvent, Binder.getCallingPid(), Binder.getCallingUid()); + if (sync) { + mKeyWaiter.waitForNextEventTarget(null, null, null, false, true); + } + return result; + } + + /** + * Inject a pointer (touch) event into the UI. + * + * @param ev A motion event describing the pointer (touch) action. (As noted in + * {@link MotionEvent#obtain(long, long, int, float, float, int)}, be sure to use + * {@link SystemClock#uptimeMillis()} as the timebase.) + * @param sync If true, wait for the event to be completed before returning to the caller. + * @return Returns true if event was dispatched, false if it was dropped for any reason + */ + public boolean injectPointerEvent(MotionEvent ev, boolean sync) { + boolean result = dispatchPointer(null, ev, Binder.getCallingPid(), Binder.getCallingUid()); + if (sync) { + mKeyWaiter.waitForNextEventTarget(null, null, null, false, true); + } + return result; + } + + /** + * Inject a trackball (navigation device) event into the UI. + * + * @param ev A motion event describing the trackball action. (As noted in + * {@link MotionEvent#obtain(long, long, int, float, float, int)}, be sure to use + * {@link SystemClock#uptimeMillis()} as the timebase.) + * @param sync If true, wait for the event to be completed before returning to the caller. + * @return Returns true if event was dispatched, false if it was dropped for any reason + */ + public boolean injectTrackballEvent(MotionEvent ev, boolean sync) { + boolean result = dispatchTrackball(null, ev, Binder.getCallingPid(), Binder.getCallingUid()); + if (sync) { + mKeyWaiter.waitForNextEventTarget(null, null, null, false, true); + } + return result; + } + + private WindowState getFocusedWindow() { + synchronized (mWindowMap) { + return getFocusedWindowLocked(); + } + } + + private WindowState getFocusedWindowLocked() { + return mCurrentFocus; + } + + /** + * This class holds the state for dispatching key events. This state + * is protected by the KeyWaiter instance, NOT by the window lock. You + * can be holding the main window lock while acquire the KeyWaiter lock, + * but not the other way around. + */ + final class KeyWaiter { + // NOSHIP debugging + public class DispatchState { + private KeyEvent event; + private WindowState focus; + private long time; + private WindowState lastWin; + private IBinder lastBinder; + private boolean finished; + private boolean gotFirstWindow; + private boolean eventDispatching; + private long timeToSwitch; + private boolean wasFrozen; + private boolean focusPaused; + + DispatchState(KeyEvent theEvent, WindowState theFocus) { + focus = theFocus; + event = theEvent; + time = System.currentTimeMillis(); + // snapshot KeyWaiter state + lastWin = mLastWin; + lastBinder = mLastBinder; + finished = mFinished; + gotFirstWindow = mGotFirstWindow; + eventDispatching = mEventDispatching; + timeToSwitch = mTimeToSwitch; + wasFrozen = mWasFrozen; + // cache the paused state at ctor time as well + if (theFocus == null || theFocus.mToken == null) { + Log.i(TAG, "focus " + theFocus + " mToken is null at event dispatch!"); + focusPaused = false; + } else { + focusPaused = theFocus.mToken.paused; + } + } + + public String toString() { + return "{{" + event + " to " + focus + " @ " + time + + " lw=" + lastWin + " lb=" + lastBinder + + " fin=" + finished + " gfw=" + gotFirstWindow + + " ed=" + eventDispatching + " tts=" + timeToSwitch + + " wf=" + wasFrozen + " fp=" + focusPaused + "}}"; + } + }; + private DispatchState mDispatchState = null; + public void recordDispatchState(KeyEvent theEvent, WindowState theFocus) { + mDispatchState = new DispatchState(theEvent, theFocus); + } + // END NOSHIP + + public static final int RETURN_NOTHING = 0; + public static final int RETURN_PENDING_POINTER = 1; + public static final int RETURN_PENDING_TRACKBALL = 2; + + final Object SKIP_TARGET_TOKEN = new Object(); + final Object CONSUMED_EVENT_TOKEN = new Object(); + + private WindowState mLastWin = null; + private IBinder mLastBinder = null; + private boolean mFinished = true; + private boolean mGotFirstWindow = false; + private boolean mEventDispatching = true; + private long mTimeToSwitch = 0; + /* package */ boolean mWasFrozen = false; + + // Target of Motion events + WindowState mMotionTarget; + + // Windows above the target who would like to receive an "outside" + // touch event for any down events outside of them. + WindowState mOutsideTouchTargets; + + /** + * Wait for the last event dispatch to complete, then find the next + * target that should receive the given event and wait for that one + * to be ready to receive it. + */ + Object waitForNextEventTarget(KeyEvent nextKey, QueuedEvent qev, + MotionEvent nextMotion, boolean isPointerEvent, + boolean failIfTimeout) { + long startTime = SystemClock.uptimeMillis(); + long keyDispatchingTimeout = 5 * 1000; + long waitedFor = 0; + + while (true) { + // Figure out which window we care about. It is either the + // last window we are waiting to have process the event or, + // if none, then the next window we think the event should go + // to. Note: we retrieve mLastWin outside of the lock, so + // it may change before we lock. Thus we must check it again. + WindowState targetWin = mLastWin; + boolean targetIsNew = targetWin == null; + if (DEBUG_INPUT) Log.v( + TAG, "waitForLastKey: mFinished=" + mFinished + + ", mLastWin=" + mLastWin); + if (targetIsNew) { + Object target = findTargetWindow(nextKey, qev, nextMotion, + isPointerEvent); + if (target == SKIP_TARGET_TOKEN) { + // The user has pressed a special key, and we are + // dropping all pending events before it. + if (DEBUG_INPUT) Log.v(TAG, "Skipping: " + nextKey + + " " + nextMotion); + return null; + } + if (target == CONSUMED_EVENT_TOKEN) { + if (DEBUG_INPUT) Log.v(TAG, "Consumed: " + nextKey + + " " + nextMotion); + return target; + } + targetWin = (WindowState)target; + } + + AppWindowToken targetApp = null; + + // Now: is it okay to send the next event to this window? + synchronized (this) { + // First: did we come here based on the last window not + // being null, but it changed by the time we got here? + // If so, try again. + if (!targetIsNew && mLastWin == null) { + continue; + } + + // We never dispatch events if not finished with the + // last one, or the display is frozen. + if (mFinished && !mDisplayFrozen) { + // If event dispatching is disabled, then we + // just consume the events. + if (!mEventDispatching) { + if (DEBUG_INPUT) Log.v(TAG, + "Skipping event; dispatching disabled: " + + nextKey + " " + nextMotion); + return null; + } + if (targetWin != null) { + // If this is a new target, and that target is not + // paused or unresponsive, then all looks good to + // handle the event. + if (targetIsNew && !targetWin.mToken.paused) { + return targetWin; + } + + // If we didn't find a target window, and there is no + // focused app window, then just eat the events. + } else if (mFocusedApp == null) { + if (DEBUG_INPUT) Log.v(TAG, + "Skipping event; no focused app: " + + nextKey + " " + nextMotion); + return null; + } + } + + if (DEBUG_INPUT) Log.v( + TAG, "Waiting for last key in " + mLastBinder + + " target=" + targetWin + + " mFinished=" + mFinished + + " mDisplayFrozen=" + mDisplayFrozen + + " targetIsNew=" + targetIsNew + + " paused=" + + (targetWin != null ? targetWin.mToken.paused : false) + + " mFocusedApp=" + mFocusedApp); + + targetApp = targetWin != null + ? targetWin.mAppToken : mFocusedApp; + + long curTimeout = keyDispatchingTimeout; + if (mTimeToSwitch != 0) { + long now = SystemClock.uptimeMillis(); + if (mTimeToSwitch <= now) { + // If an app switch key has been pressed, and we have + // waited too long for the current app to finish + // processing keys, then wait no more! + doFinishedKeyLocked(true); + continue; + } + long switchTimeout = mTimeToSwitch - now; + if (curTimeout > switchTimeout) { + curTimeout = switchTimeout; + } + } + + try { + // after that continue + // processing keys, so we don't get stuck. + if (DEBUG_INPUT) Log.v( + TAG, "Waiting for key dispatch: " + curTimeout); + wait(curTimeout); + if (DEBUG_INPUT) Log.v(TAG, "Finished waiting @" + + SystemClock.uptimeMillis() + " startTime=" + + startTime + " switchTime=" + mTimeToSwitch); + } catch (InterruptedException e) { + } + } + + // If we were frozen during configuration change, restart the + // timeout checks from now; otherwise look at whether we timed + // out before awakening. + if (mWasFrozen) { + waitedFor = 0; + mWasFrozen = false; + } else { + waitedFor = SystemClock.uptimeMillis() - startTime; + } + + if (waitedFor >= keyDispatchingTimeout && mTimeToSwitch == 0) { + IApplicationToken at = null; + synchronized (this) { + Log.w(TAG, "Key dispatching timed out sending to " + + (targetWin != null ? targetWin.mAttrs.getTitle() + : "<null>")); + // NOSHIP debugging + Log.w(TAG, "Dispatch state: " + mDispatchState); + Log.w(TAG, "Current state: " + new DispatchState(nextKey, targetWin)); + // END NOSHIP + //dump(); + if (targetWin != null) { + at = targetWin.getAppToken(); + } else if (targetApp != null) { + at = targetApp.appToken; + } + } + + boolean abort = true; + if (at != null) { + try { + long timeout = at.getKeyDispatchingTimeout(); + if (timeout > waitedFor) { + // we did not wait the proper amount of time for this application. + // set the timeout to be the real timeout and wait again. + keyDispatchingTimeout = timeout - waitedFor; + continue; + } else { + abort = at.keyDispatchingTimedOut(); + } + } catch (RemoteException ex) { + } + } + + synchronized (this) { + if (abort && (mLastWin == targetWin || targetWin == null)) { + mFinished = true; + if (mLastWin != null) { + if (DEBUG_INPUT) Log.v(TAG, + "Window " + mLastWin + + " timed out on key input"); + if (mLastWin.mToken.paused) { + Log.w(TAG, "Un-pausing dispatching to this window"); + mLastWin.mToken.paused = false; + } + } + if (mMotionTarget == targetWin) { + mMotionTarget = null; + } + mLastWin = null; + mLastBinder = null; + if (failIfTimeout || targetWin == null) { + return null; + } + } else { + Log.w(TAG, "Continuing to wait for key to be dispatched"); + startTime = SystemClock.uptimeMillis(); + } + } + } + } + } + + Object findTargetWindow(KeyEvent nextKey, QueuedEvent qev, + MotionEvent nextMotion, boolean isPointerEvent) { + mOutsideTouchTargets = null; + + if (nextKey != null) { + // Find the target window for a normal key event. + final int keycode = nextKey.getKeyCode(); + final int repeatCount = nextKey.getRepeatCount(); + final boolean down = nextKey.getAction() != KeyEvent.ACTION_UP; + boolean dispatch = mKeyWaiter.checkShouldDispatchKey(keycode); + if (!dispatch) { + mPolicy.interceptKeyTi(null, keycode, + nextKey.getMetaState(), down, repeatCount); + Log.w(TAG, "Event timeout during app switch: dropping " + + nextKey); + return SKIP_TARGET_TOKEN; + } + + // System.out.println("##### [" + SystemClock.uptimeMillis() + "] WindowManagerService.dispatchKey(" + keycode + ", " + down + ", " + repeatCount + ")"); + + WindowState focus = null; + synchronized(mWindowMap) { + focus = getFocusedWindowLocked(); + } + + wakeupIfNeeded(focus, LocalPowerManager.BUTTON_EVENT); + + if (mPolicy.interceptKeyTi(focus, + keycode, nextKey.getMetaState(), down, repeatCount)) { + return CONSUMED_EVENT_TOKEN; + } + + return focus; + + } else if (!isPointerEvent) { + boolean dispatch = mKeyWaiter.checkShouldDispatchKey(-1); + if (!dispatch) { + Log.w(TAG, "Event timeout during app switch: dropping trackball " + + nextMotion); + return SKIP_TARGET_TOKEN; + } + + WindowState focus = null; + synchronized(mWindowMap) { + focus = getFocusedWindowLocked(); + } + + wakeupIfNeeded(focus, LocalPowerManager.BUTTON_EVENT); + return focus; + } + + if (nextMotion == null) { + return SKIP_TARGET_TOKEN; + } + + boolean dispatch = mKeyWaiter.checkShouldDispatchKey( + KeyEvent.KEYCODE_UNKNOWN); + if (!dispatch) { + Log.w(TAG, "Event timeout during app switch: dropping pointer " + + nextMotion); + return SKIP_TARGET_TOKEN; + } + + // Find the target window for a pointer event. + int action = nextMotion.getAction(); + final float xf = nextMotion.getX(); + final float yf = nextMotion.getY(); + final long eventTime = nextMotion.getEventTime(); + + final boolean screenWasOff = qev != null + && (qev.flags&WindowManagerPolicy.FLAG_BRIGHT_HERE) != 0; + + WindowState target = null; + + synchronized(mWindowMap) { + synchronized (this) { + if (action == MotionEvent.ACTION_DOWN) { + if (mMotionTarget != null) { + // this is weird, we got a pen down, but we thought it was + // already down! + // XXX: We should probably send an ACTION_UP to the current + // target. + Log.w(TAG, "Pointer down received while already down in: " + + mMotionTarget); + mMotionTarget = null; + } + + // ACTION_DOWN is special, because we need to lock next events to + // the window we'll land onto. + final int x = (int)xf; + final int y = (int)yf; + + final ArrayList windows = mWindows; + final int N = windows.size(); + WindowState topErrWindow = null; + final Rect tmpRect = mTempRect; + for (int i=N-1; i>=0; i--) { + WindowState child = (WindowState)windows.get(i); + //Log.i(TAG, "Checking dispatch to: " + child); + final int flags = child.mAttrs.flags; + if ((flags & WindowManager.LayoutParams.FLAG_SYSTEM_ERROR) != 0) { + if (topErrWindow == null) { + topErrWindow = child; + } + } + if (!child.isVisibleLw()) { + //Log.i(TAG, "Not visible!"); + continue; + } + if ((flags & WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE) != 0) { + //Log.i(TAG, "Not touchable!"); + if ((flags & WindowManager.LayoutParams + .FLAG_WATCH_OUTSIDE_TOUCH) != 0) { + child.mNextOutsideTouch = mOutsideTouchTargets; + mOutsideTouchTargets = child; + } + continue; + } + tmpRect.set(child.mFrame); + if (child.mTouchableInsets == ViewTreeObserver + .InternalInsetsInfo.TOUCHABLE_INSETS_CONTENT) { + // The touch is inside of the window if it is + // inside the frame, AND the content part of that + // frame that was given by the application. + tmpRect.left += child.mGivenContentInsets.left; + tmpRect.top += child.mGivenContentInsets.top; + tmpRect.right -= child.mGivenContentInsets.right; + tmpRect.bottom -= child.mGivenContentInsets.bottom; + } else if (child.mTouchableInsets == ViewTreeObserver + .InternalInsetsInfo.TOUCHABLE_INSETS_VISIBLE) { + // The touch is inside of the window if it is + // inside the frame, AND the visible part of that + // frame that was given by the application. + tmpRect.left += child.mGivenVisibleInsets.left; + tmpRect.top += child.mGivenVisibleInsets.top; + tmpRect.right -= child.mGivenVisibleInsets.right; + tmpRect.bottom -= child.mGivenVisibleInsets.bottom; + } + final int touchFlags = flags & + (WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE + |WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL); + if (tmpRect.contains(x, y) || touchFlags == 0) { + //Log.i(TAG, "Using this target!"); + if (!screenWasOff || (flags & + WindowManager.LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING) != 0) { + mMotionTarget = child; + } else { + //Log.i(TAG, "Waking, skip!"); + mMotionTarget = null; + } + break; + } + + if ((flags & WindowManager.LayoutParams + .FLAG_WATCH_OUTSIDE_TOUCH) != 0) { + child.mNextOutsideTouch = mOutsideTouchTargets; + mOutsideTouchTargets = child; + //Log.i(TAG, "Adding to outside target list: " + child); + } + } + + // if there's an error window but it's not accepting + // focus (typically because it is not yet visible) just + // wait for it -- any other focused window may in fact + // be in ANR state. + if (topErrWindow != null && mMotionTarget != topErrWindow) { + mMotionTarget = null; + } + } + + target = mMotionTarget; + } + } + + wakeupIfNeeded(target, eventType(nextMotion)); + + // Pointer events are a little different -- if there isn't a + // target found for any event, then just drop it. + return target != null ? target : SKIP_TARGET_TOKEN; + } + + boolean checkShouldDispatchKey(int keycode) { + synchronized (this) { + if (mPolicy.isAppSwitchKeyTqTiLwLi(keycode)) { + mTimeToSwitch = 0; + return true; + } + if (mTimeToSwitch != 0 + && mTimeToSwitch < SystemClock.uptimeMillis()) { + return false; + } + return true; + } + } + + void bindTargetWindowLocked(WindowState win, + int pendingWhat, QueuedEvent pendingMotion) { + synchronized (this) { + bindTargetWindowLockedLocked(win, pendingWhat, pendingMotion); + } + } + + void bindTargetWindowLocked(WindowState win) { + synchronized (this) { + bindTargetWindowLockedLocked(win, RETURN_NOTHING, null); + } + } + + void bindTargetWindowLockedLocked(WindowState win, + int pendingWhat, QueuedEvent pendingMotion) { + mLastWin = win; + mLastBinder = win.mClient.asBinder(); + mFinished = false; + if (pendingMotion != null) { + final Session s = win.mSession; + if (pendingWhat == RETURN_PENDING_POINTER) { + releasePendingPointerLocked(s); + s.mPendingPointerMove = pendingMotion; + s.mPendingPointerWindow = win; + if (DEBUG_INPUT) Log.v(TAG, + "bindTargetToWindow " + s.mPendingPointerMove); + } else if (pendingWhat == RETURN_PENDING_TRACKBALL) { + releasePendingTrackballLocked(s); + s.mPendingTrackballMove = pendingMotion; + s.mPendingTrackballWindow = win; + } + } + } + + void releasePendingPointerLocked(Session s) { + if (DEBUG_INPUT) Log.v(TAG, + "releasePendingPointer " + s.mPendingPointerMove); + if (s.mPendingPointerMove != null) { + mQueue.recycleEvent(s.mPendingPointerMove); + s.mPendingPointerMove = null; + } + } + + void releasePendingTrackballLocked(Session s) { + if (s.mPendingTrackballMove != null) { + mQueue.recycleEvent(s.mPendingTrackballMove); + s.mPendingTrackballMove = null; + } + } + + MotionEvent finishedKey(Session session, IWindow client, boolean force, + int returnWhat) { + if (DEBUG_INPUT) Log.v( + TAG, "finishedKey: client=" + client + ", force=" + force); + + if (client == null) { + return null; + } + + synchronized (this) { + if (DEBUG_INPUT) Log.v( + TAG, "finishedKey: client=" + client.asBinder() + + ", force=" + force + ", last=" + mLastBinder + + " (token=" + (mLastWin != null ? mLastWin.mToken : null) + ")"); + + QueuedEvent qev = null; + WindowState win = null; + if (returnWhat == RETURN_PENDING_POINTER) { + qev = session.mPendingPointerMove; + win = session.mPendingPointerWindow; + session.mPendingPointerMove = null; + session.mPendingPointerWindow = null; + } else if (returnWhat == RETURN_PENDING_TRACKBALL) { + qev = session.mPendingTrackballMove; + win = session.mPendingTrackballWindow; + session.mPendingTrackballMove = null; + session.mPendingTrackballWindow = null; + } + + if (mLastBinder == client.asBinder()) { + if (DEBUG_INPUT) Log.v( + TAG, "finishedKey: last paused=" + + ((mLastWin != null) ? mLastWin.mToken.paused : "null")); + if (mLastWin != null && (!mLastWin.mToken.paused || force + || !mEventDispatching)) { + doFinishedKeyLocked(false); + } else { + // Make sure to wake up anyone currently waiting to + // dispatch a key, so they can re-evaluate their + // current situation. + mFinished = true; + notifyAll(); + } + } else { + if (DEBUG_INPUT || true) Log.v( + TAG, "finishedKey: " + client + " tried to finish but mLastBinder=" + + mLastBinder); + } + + if (qev != null) { + MotionEvent res = (MotionEvent)qev.event; + if (DEBUG_INPUT) Log.v(TAG, + "Returning pending motion: " + res); + mQueue.recycleEvent(qev); + if (win != null && returnWhat == RETURN_PENDING_POINTER) { + res.offsetLocation(-win.mFrame.left, -win.mFrame.top); + } + return res; + } + return null; + } + } + + void tickle() { + synchronized (this) { + notifyAll(); + } + } + + void handleNewWindowLocked(WindowState newWindow) { + if (!newWindow.canReceiveKeys()) { + return; + } + synchronized (this) { + if (DEBUG_INPUT || true) Log.v( + TAG, "New key dispatch window: win=" + + newWindow.mClient.asBinder() + + ", last=" + mLastBinder + + " (token=" + (mLastWin != null ? mLastWin.mToken : null) + + "), finished=" + mFinished + ", paused=" + + newWindow.mToken.paused); + + // Displaying a window implicitly causes dispatching to + // be unpaused. (This is to protect against bugs if someone + // pauses dispatching but forgets to resume.) + newWindow.mToken.paused = false; + + mGotFirstWindow = true; + boolean doNotify = true; + + if ((newWindow.mAttrs.flags & FLAG_SYSTEM_ERROR) != 0) { + if (DEBUG_INPUT) Log.v(TAG, + "New SYSTEM_ERROR window; resetting state"); + mLastWin = null; + mLastBinder = null; + mMotionTarget = null; + mFinished = true; + } else if (mLastWin != null) { + // If the new window is above the window we are + // waiting on, then stop waiting and let key dispatching + // start on the new guy. + if (DEBUG_INPUT) Log.v( + TAG, "Last win layer=" + mLastWin.mLayer + + ", new win layer=" + newWindow.mLayer); + if (newWindow.mLayer >= mLastWin.mLayer) { + if (!mLastWin.canReceiveKeys()) { + mLastWin.mToken.paused = false; + if (DEBUG_INPUT || true) Log.v(TAG, + "Finishing old key to " + mLastWin); + doFinishedKeyLocked(true); // does a notifyAll() + doNotify = false; + } else { + if (DEBUG_INPUT || true) Log.v(TAG, "mLastWin " + mLastWin + + " still receiving keys; not resetting dispatch to " + + newWindow); + } + } else { + // the new window is lower; no need to wake key waiters + if (DEBUG_INPUT || true) Log.v(TAG, + "New layer " + newWindow.mLayer + " is below last layer " + + mLastWin.mLayer + " - not resetting dispatch"); + doNotify = false; + } + } + + if (doNotify) { + notifyAll(); + } + } + } + + void pauseDispatchingLocked(WindowToken token) { + synchronized (this) + { + if (DEBUG_INPUT) Log.v(TAG, "Pausing WindowToken " + token); + token.paused = true; + + /* + if (mLastWin != null && !mFinished && mLastWin.mBaseLayer <= layer) { + mPaused = true; + } else { + if (mLastWin == null) { + if (Config.LOGI) Log.i( + TAG, "Key dispatching not paused: no last window."); + } else if (mFinished) { + if (Config.LOGI) Log.i( + TAG, "Key dispatching not paused: finished last key."); + } else { + if (Config.LOGI) Log.i( + TAG, "Key dispatching not paused: window in higher layer."); + } + } + */ + } + } + + void resumeDispatchingLocked(WindowToken token) { + synchronized (this) { + if (token.paused) { + if (DEBUG_INPUT) Log.v( + TAG, "Resuming WindowToken " + token + + ", last=" + mLastBinder + + " (token=" + (mLastWin != null ? mLastWin.mToken : null) + + "), finished=" + mFinished + ", paused=" + + token.paused); + token.paused = false; + if (mLastWin != null && mLastWin.mToken == token && mFinished) { + doFinishedKeyLocked(true); + } else { + notifyAll(); + } + } + } + } + + void setEventDispatchingLocked(boolean enabled) { + synchronized (this) { + mEventDispatching = enabled; + notifyAll(); + } + } + + void appSwitchComing() { + synchronized (this) { + // Don't wait for more than .5 seconds for app to finish + // processing the pending events. + long now = SystemClock.uptimeMillis() + 500; + if (DEBUG_INPUT) Log.v(TAG, "appSwitchComing: " + now); + if (mTimeToSwitch == 0 || now < mTimeToSwitch) { + mTimeToSwitch = now; + } + notifyAll(); + } + } + + private final void doFinishedKeyLocked(boolean doRecycle) { + if (mLastWin != null) { + releasePendingPointerLocked(mLastWin.mSession); + releasePendingTrackballLocked(mLastWin.mSession); + } + + if (mLastWin == null || !mLastWin.mToken.paused + || !mLastWin.isVisibleLw()) { + // If the current window has been paused, we aren't -really- + // finished... so let the waiters still wait. + mLastWin = null; + mLastBinder = null; + } + mFinished = true; + notifyAll(); + } + } + + private class KeyQ extends KeyInputQueue + implements KeyInputQueue.FilterCallback { + PowerManager.WakeLock mHoldingScreen; + + KeyQ() { + super(mContext); + PowerManager pm = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE); + mHoldingScreen = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, + "KEEP_SCREEN_ON_FLAG"); + mHoldingScreen.setReferenceCounted(false); + } + + @Override + boolean preprocessEvent(InputDevice device, RawInputEvent event) { + if (mPolicy.preprocessInputEventTq(event)) { + return true; + } + + switch (event.type) { + case RawInputEvent.EV_KEY: { + // XXX begin hack + if (DEBUG) { + if (event.keycode == KeyEvent.KEYCODE_G) { + if (event.value != 0) { + // G down + mPolicy.screenTurnedOff(WindowManagerPolicy.OFF_BECAUSE_OF_USER); + } + return false; + } + if (event.keycode == KeyEvent.KEYCODE_D) { + if (event.value != 0) { + //dump(); + } + return false; + } + } + // XXX end hack + + boolean screenIsOff = !mPowerManager.screenIsOn(); + boolean screenIsDim = !mPowerManager.screenIsBright(); + int actions = mPolicy.interceptKeyTq(event, !screenIsOff); + + if ((actions & WindowManagerPolicy.ACTION_GO_TO_SLEEP) != 0) { + mPowerManager.goToSleep(event.when); + } + + if (screenIsOff) { + event.flags |= WindowManagerPolicy.FLAG_WOKE_HERE; + } + if (screenIsDim) { + event.flags |= WindowManagerPolicy.FLAG_BRIGHT_HERE; + } + if ((actions & WindowManagerPolicy.ACTION_POKE_USER_ACTIVITY) != 0) { + mPowerManager.userActivity(event.when, false, + LocalPowerManager.BUTTON_EVENT); + } + + if ((actions & WindowManagerPolicy.ACTION_PASS_TO_USER) != 0) { + if (event.value != 0 && mPolicy.isAppSwitchKeyTqTiLwLi(event.keycode)) { + filterQueue(this); + mKeyWaiter.appSwitchComing(); + } + return true; + } else { + return false; + } + } + + case RawInputEvent.EV_REL: { + boolean screenIsOff = !mPowerManager.screenIsOn(); + boolean screenIsDim = !mPowerManager.screenIsBright(); + if (screenIsOff) { + if (!mPolicy.isWakeRelMovementTq(event.deviceId, + device.classes, event)) { + //Log.i(TAG, "dropping because screenIsOff and !isWakeKey"); + return false; + } + event.flags |= WindowManagerPolicy.FLAG_WOKE_HERE; + } + if (screenIsDim) { + event.flags |= WindowManagerPolicy.FLAG_BRIGHT_HERE; + } + return true; + } + + case RawInputEvent.EV_ABS: { + boolean screenIsOff = !mPowerManager.screenIsOn(); + boolean screenIsDim = !mPowerManager.screenIsBright(); + if (screenIsOff) { + if (!mPolicy.isWakeAbsMovementTq(event.deviceId, + device.classes, event)) { + //Log.i(TAG, "dropping because screenIsOff and !isWakeKey"); + return false; + } + event.flags |= WindowManagerPolicy.FLAG_WOKE_HERE; + } + if (screenIsDim) { + event.flags |= WindowManagerPolicy.FLAG_BRIGHT_HERE; + } + return true; + } + + default: + return true; + } + } + + public int filterEvent(QueuedEvent ev) { + switch (ev.classType) { + case RawInputEvent.CLASS_KEYBOARD: + KeyEvent ke = (KeyEvent)ev.event; + if (mPolicy.isMovementKeyTi(ke.getKeyCode())) { + Log.w(TAG, "Dropping movement key during app switch: " + + ke.getKeyCode() + ", action=" + ke.getAction()); + return FILTER_REMOVE; + } + return FILTER_ABORT; + default: + return FILTER_KEEP; + } + } + + /** + * Must be called with the main window manager lock held. + */ + void setHoldScreenLocked(boolean holding) { + boolean state = mHoldingScreen.isHeld(); + if (holding != state) { + if (holding) { + mHoldingScreen.acquire(); + } else { + mPolicy.screenOnStopped(); + mHoldingScreen.release(); + } + } + } + }; + + public boolean detectSafeMode() { + mSafeMode = mPolicy.detectSafeMode(); + return mSafeMode; + } + + public void systemReady() { + mPolicy.systemReady(); + } + + private final class InputDispatcherThread extends Thread { + // Time to wait when there is nothing to do: 9999 seconds. + static final int LONG_WAIT=9999*1000; + + public InputDispatcherThread() { + super("InputDispatcher"); + } + + @Override + public void run() { + while (true) { + try { + process(); + } catch (Exception e) { + Log.e(TAG, "Exception in input dispatcher", e); + } + } + } + + private void process() { + android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_URGENT_DISPLAY); + + // The last key event we saw + KeyEvent lastKey = null; + + // Last keydown time for auto-repeating keys + long lastKeyTime = SystemClock.uptimeMillis(); + long nextKeyTime = lastKeyTime+LONG_WAIT; + + // How many successive repeats we generated + int keyRepeatCount = 0; + + // Need to report that configuration has changed? + boolean configChanged = false; + + while (true) { + long curTime = SystemClock.uptimeMillis(); + + if (DEBUG_INPUT) Log.v( + TAG, "Waiting for next key: now=" + curTime + + ", repeat @ " + nextKeyTime); + + // Retrieve next event, waiting only as long as the next + // repeat timeout. If the configuration has changed, then + // don't wait at all -- we'll report the change as soon as + // we have processed all events. + QueuedEvent ev = mQueue.getEvent( + (int)((!configChanged && curTime < nextKeyTime) + ? (nextKeyTime-curTime) : 0)); + + if (DEBUG_INPUT && ev != null) Log.v( + TAG, "Event: type=" + ev.classType + " data=" + ev.event); + + try { + if (ev != null) { + curTime = ev.when; + int eventType; + if (ev.classType == RawInputEvent.CLASS_TOUCHSCREEN) { + eventType = eventType((MotionEvent)ev.event); + } else if (ev.classType == RawInputEvent.CLASS_KEYBOARD || + ev.classType == RawInputEvent.CLASS_TRACKBALL) { + eventType = LocalPowerManager.BUTTON_EVENT; + } else { + eventType = LocalPowerManager.OTHER_EVENT; + } + mPowerManager.userActivity(curTime, false, eventType); + switch (ev.classType) { + case RawInputEvent.CLASS_KEYBOARD: + KeyEvent ke = (KeyEvent)ev.event; + if (ke.isDown()) { + lastKey = ke; + keyRepeatCount = 0; + lastKeyTime = curTime; + nextKeyTime = lastKeyTime + + KEY_REPEAT_FIRST_DELAY; + if (DEBUG_INPUT) Log.v( + TAG, "Received key down: first repeat @ " + + nextKeyTime); + } else { + lastKey = null; + // Arbitrary long timeout. + lastKeyTime = curTime; + nextKeyTime = curTime + LONG_WAIT; + if (DEBUG_INPUT) Log.v( + TAG, "Received key up: ignore repeat @ " + + nextKeyTime); + } + dispatchKey((KeyEvent)ev.event, 0, 0); + mQueue.recycleEvent(ev); + break; + case RawInputEvent.CLASS_TOUCHSCREEN: + //Log.i(TAG, "Read next event " + ev); + dispatchPointer(ev, (MotionEvent)ev.event, 0, 0); + break; + case RawInputEvent.CLASS_TRACKBALL: + dispatchTrackball(ev, (MotionEvent)ev.event, 0, 0); + break; + case RawInputEvent.CLASS_CONFIGURATION_CHANGED: + configChanged = true; + break; + default: + mQueue.recycleEvent(ev); + break; + } + + } else if (configChanged) { + configChanged = false; + sendNewConfiguration(); + + } else if (lastKey != null) { + curTime = SystemClock.uptimeMillis(); + + // Timeout occurred while key was down. If it is at or + // past the key repeat time, dispatch the repeat. + if (DEBUG_INPUT) Log.v( + TAG, "Key timeout: repeat=" + nextKeyTime + + ", now=" + curTime); + if (curTime < nextKeyTime) { + continue; + } + + lastKeyTime = nextKeyTime; + nextKeyTime = nextKeyTime + KEY_REPEAT_DELAY; + keyRepeatCount++; + if (DEBUG_INPUT) Log.v( + TAG, "Key repeat: count=" + keyRepeatCount + + ", next @ " + nextKeyTime); + dispatchKey(new KeyEvent(lastKey, curTime, keyRepeatCount), 0, 0); + + } else { + curTime = SystemClock.uptimeMillis(); + + lastKeyTime = curTime; + nextKeyTime = curTime + LONG_WAIT; + } + + } catch (Exception e) { + Log.e(TAG, + "Input thread received uncaught exception: " + e, e); + } + } + } + } + + // ------------------------------------------------------------- + // Client Session State + // ------------------------------------------------------------- + + private final class Session extends IWindowSession.Stub + implements IBinder.DeathRecipient { + final IInputMethodClient mClient; + final IInputContext mInputContext; + final int mUid; + final int mPid; + SurfaceSession mSurfaceSession; + int mNumWindow = 0; + boolean mClientDead = false; + + /** + * Current pointer move event being dispatched to client window... must + * hold key lock to access. + */ + QueuedEvent mPendingPointerMove; + WindowState mPendingPointerWindow; + + /** + * Current trackball move event being dispatched to client window... must + * hold key lock to access. + */ + QueuedEvent mPendingTrackballMove; + WindowState mPendingTrackballWindow; + + public Session(IInputMethodClient client, IInputContext inputContext) { + mClient = client; + mInputContext = inputContext; + mUid = Binder.getCallingUid(); + mPid = Binder.getCallingPid(); + synchronized (mWindowMap) { + if (mInputMethodManager == null && mHaveInputMethods) { + IBinder b = ServiceManager.getService( + Context.INPUT_METHOD_SERVICE); + mInputMethodManager = IInputMethodManager.Stub.asInterface(b); + } + } + long ident = Binder.clearCallingIdentity(); + try { + // Note: it is safe to call in to the input method manager + // here because we are not holding our lock. + if (mInputMethodManager != null) { + mInputMethodManager.addClient(client, inputContext, + mUid, mPid); + } else { + client.setUsingInputMethod(false); + } + client.asBinder().linkToDeath(this, 0); + } catch (RemoteException e) { + // The caller has died, so we can just forget about this. + try { + if (mInputMethodManager != null) { + mInputMethodManager.removeClient(client); + } + } catch (RemoteException ee) { + } + } finally { + Binder.restoreCallingIdentity(ident); + } + } + + @Override + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) + throws RemoteException { + try { + return super.onTransact(code, data, reply, flags); + } catch (RuntimeException e) { + // Log all 'real' exceptions thrown to the caller + if (!(e instanceof SecurityException)) { + Log.e(TAG, "Window Session Crash", e); + } + throw e; + } + } + + public void binderDied() { + // Note: it is safe to call in to the input method manager + // here because we are not holding our lock. + try { + if (mInputMethodManager != null) { + mInputMethodManager.removeClient(mClient); + } + } catch (RemoteException e) { + } + synchronized(mWindowMap) { + mClientDead = true; + killSessionLocked(); + } + } + + public int add(IWindow window, WindowManager.LayoutParams attrs, + int viewVisibility, Rect outContentInsets) { + return addWindow(this, window, attrs, viewVisibility, outContentInsets); + } + + public void remove(IWindow window) { + removeWindow(this, window); + } + + public int relayout(IWindow window, WindowManager.LayoutParams attrs, + int requestedWidth, int requestedHeight, int viewFlags, + boolean insetsPending, Rect outFrame, Rect outContentInsets, + Rect outVisibleInsets, Surface outSurface) { + return relayoutWindow(this, window, attrs, + requestedWidth, requestedHeight, viewFlags, insetsPending, + outFrame, outContentInsets, outVisibleInsets, outSurface); + } + + public void setTransparentRegion(IWindow window, Region region) { + setTransparentRegionWindow(this, window, region); + } + + public void setInsets(IWindow window, int touchableInsets, + Rect contentInsets, Rect visibleInsets) { + setInsetsWindow(this, window, touchableInsets, contentInsets, + visibleInsets); + } + + public void getDisplayFrame(IWindow window, Rect outDisplayFrame) { + getWindowDisplayFrame(this, window, outDisplayFrame); + } + + public void finishDrawing(IWindow window) { + if (localLOGV) Log.v( + TAG, "IWindow finishDrawing called for " + window); + finishDrawingWindow(this, window); + } + + public void finishKey(IWindow window) { + if (localLOGV) Log.v( + TAG, "IWindow finishKey called for " + window); + mKeyWaiter.finishedKey(this, window, false, + KeyWaiter.RETURN_NOTHING); + } + + public MotionEvent getPendingPointerMove(IWindow window) { + if (localLOGV) Log.v( + TAG, "IWindow getPendingMotionEvent called for " + window); + return mKeyWaiter.finishedKey(this, window, false, + KeyWaiter.RETURN_PENDING_POINTER); + } + + public MotionEvent getPendingTrackballMove(IWindow window) { + if (localLOGV) Log.v( + TAG, "IWindow getPendingMotionEvent called for " + window); + return mKeyWaiter.finishedKey(this, window, false, + KeyWaiter.RETURN_PENDING_TRACKBALL); + } + + public void setInTouchMode(boolean mode) { + synchronized(mWindowMap) { + mInTouchMode = mode; + } + } + + public boolean getInTouchMode() { + synchronized(mWindowMap) { + return mInTouchMode; + } + } + + public boolean performHapticFeedback(IWindow window, int effectId, + boolean always) { + synchronized(mWindowMap) { + long ident = Binder.clearCallingIdentity(); + try { + return mPolicy.performHapticFeedback( + windowForClientLocked(this, window), effectId, always); + } finally { + Binder.restoreCallingIdentity(ident); + } + } + } + + void windowAddedLocked() { + if (mSurfaceSession == null) { + if (localLOGV) Log.v( + TAG, "First window added to " + this + ", creating SurfaceSession"); + mSurfaceSession = new SurfaceSession(); + mSessions.add(this); + } + mNumWindow++; + } + + void windowRemovedLocked() { + mNumWindow--; + killSessionLocked(); + } + + void killSessionLocked() { + if (mNumWindow <= 0 && mClientDead) { + mSessions.remove(this); + if (mSurfaceSession != null) { + if (localLOGV) Log.v( + TAG, "Last window removed from " + this + + ", destroying " + mSurfaceSession); + try { + mSurfaceSession.kill(); + } catch (Exception e) { + Log.w(TAG, "Exception thrown when killing surface session " + + mSurfaceSession + " in session " + this + + ": " + e.toString()); + } + mSurfaceSession = null; + } + } + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "mNumWindow=" + mNumWindow + + " mClientDead=" + mClientDead + + " mSurfaceSession=" + mSurfaceSession); + pw.println(prefix + "mPendingPointerWindow=" + mPendingPointerWindow + + " mPendingPointerMove=" + mPendingPointerMove); + pw.println(prefix + "mPendingTrackballWindow=" + mPendingTrackballWindow + + " mPendingTrackballMove=" + mPendingTrackballMove); + } + + @Override + public String toString() { + return "Session{" + + Integer.toHexString(System.identityHashCode(this)) + "}"; + } + } + + // ------------------------------------------------------------- + // Client Window State + // ------------------------------------------------------------- + + private final class WindowState implements WindowManagerPolicy.WindowState { + final Session mSession; + final IWindow mClient; + WindowToken mToken; + AppWindowToken mAppToken; + AppWindowToken mTargetAppToken; + final WindowManager.LayoutParams mAttrs = new WindowManager.LayoutParams(); + final DeathRecipient mDeathRecipient; + final WindowState mAttachedWindow; + final ArrayList mChildWindows = new ArrayList(); + final int mBaseLayer; + final int mSubLayer; + final boolean mLayoutAttached; + final boolean mIsImWindow; + int mViewVisibility; + boolean mPolicyVisibility = true; + boolean mPolicyVisibilityAfterAnim = true; + boolean mAppFreezing; + Surface mSurface; + boolean mAttachedHidden; // is our parent window hidden? + boolean mLastHidden; // was this window last hidden? + int mRequestedWidth; + int mRequestedHeight; + int mLastRequestedWidth; + int mLastRequestedHeight; + int mReqXPos; + int mReqYPos; + int mLayer; + int mAnimLayer; + int mLastLayer; + boolean mHaveFrame; + + WindowState mNextOutsideTouch; + + // Actual frame shown on-screen (may be modified by animation) + final Rect mShownFrame = new Rect(); + final Rect mLastShownFrame = new Rect(); + + /** + * Insets that determine the actually visible area + */ + final Rect mVisibleInsets = new Rect(); + final Rect mLastVisibleInsets = new Rect(); + boolean mVisibleInsetsChanged; + + /** + * Insets that are covered by system windows + */ + final Rect mContentInsets = new Rect(); + final Rect mLastContentInsets = new Rect(); + boolean mContentInsetsChanged; + + /** + * Set to true if we are waiting for this window to receive its + * given internal insets before laying out other windows based on it. + */ + boolean mGivenInsetsPending; + + /** + * These are the content insets that were given during layout for + * this window, to be applied to windows behind it. + */ + final Rect mGivenContentInsets = new Rect(); + + /** + * These are the visible insets that were given during layout for + * this window, to be applied to windows behind it. + */ + final Rect mGivenVisibleInsets = new Rect(); + + /** + * Flag indicating whether the touchable region should be adjusted by + * the visible insets; if false the area outside the visible insets is + * NOT touchable, so we must use those to adjust the frame during hit + * tests. + */ + int mTouchableInsets = ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_FRAME; + + // Current transformation being applied. + float mDsDx=1, mDtDx=0, mDsDy=0, mDtDy=1; + float mLastDsDx=1, mLastDtDx=0, mLastDsDy=0, mLastDtDy=1; + float mHScale=1, mVScale=1; + float mLastHScale=1, mLastVScale=1; + final Matrix mTmpMatrix = new Matrix(); + + // "Real" frame that the application sees. + final Rect mFrame = new Rect(); + final Rect mLastFrame = new Rect(); + + final Rect mContainingFrame = new Rect(); + final Rect mDisplayFrame = new Rect(); + final Rect mContentFrame = new Rect(); + final Rect mVisibleFrame = new Rect(); + + float mShownAlpha = 1; + float mAlpha = 1; + float mLastAlpha = 1; + + // Set to true if, when the window gets displayed, it should perform + // an enter animation. + boolean mEnterAnimationPending; + + // Currently running animation. + boolean mAnimating; + boolean mLocalAnimating; + Animation mAnimation; + boolean mAnimationIsEntrance; + boolean mHasTransformation; + boolean mHasLocalTransformation; + final Transformation mTransformation = new Transformation(); + + // This is set after IWindowSession.relayout() has been called at + // least once for the window. It allows us to detect the situation + // where we don't yet have a surface, but should have one soon, so + // we can give the window focus before waiting for the relayout. + boolean mRelayoutCalled; + + // This is set after the Surface has been created but before the + // window has been drawn. During this time the surface is hidden. + boolean mDrawPending; + + // This is set after the window has finished drawing for the first + // time but before its surface is shown. The surface will be + // displayed when the next layout is run. + boolean mCommitDrawPending; + + // This is set during the time after the window's drawing has been + // committed, and before its surface is actually shown. It is used + // to delay showing the surface until all windows in a token are ready + // to be shown. + boolean mReadyToShow; + + // Set when the window has been shown in the screen the first time. + boolean mHasDrawn; + + // Currently running an exit animation? + boolean mExiting; + + // Currently on the mDestroySurface list? + boolean mDestroying; + + // Completely remove from window manager after exit animation? + boolean mRemoveOnExit; + + // Set when the orientation is changing and this window has not yet + // been updated for the new orientation. + boolean mOrientationChanging; + + // Is this window now (or just being) removed? + boolean mRemoved; + + WindowState(Session s, IWindow c, WindowToken token, + WindowState attachedWindow, WindowManager.LayoutParams a, + int viewVisibility) { + mSession = s; + mClient = c; + mToken = token; + mAttrs.copyFrom(a); + mViewVisibility = viewVisibility; + DeathRecipient deathRecipient = new DeathRecipient(); + mAlpha = a.alpha; + if (localLOGV) Log.v( + TAG, "Window " + this + " client=" + c.asBinder() + + " token=" + token + " (" + mAttrs.token + ")"); + try { + c.asBinder().linkToDeath(deathRecipient, 0); + } catch (RemoteException e) { + mDeathRecipient = null; + mAttachedWindow = null; + mLayoutAttached = false; + mIsImWindow = false; + mBaseLayer = 0; + mSubLayer = 0; + return; + } + mDeathRecipient = deathRecipient; + + if ((mAttrs.type >= FIRST_SUB_WINDOW && + mAttrs.type <= LAST_SUB_WINDOW)) { + // The multiplier here is to reserve space for multiple + // windows in the same type layer. + mBaseLayer = mPolicy.windowTypeToLayerLw( + attachedWindow.mAttrs.type) * TYPE_LAYER_MULTIPLIER + + TYPE_LAYER_OFFSET; + mSubLayer = mPolicy.subWindowTypeToLayerLw(a.type); + mAttachedWindow = attachedWindow; + mAttachedWindow.mChildWindows.add(this); + mLayoutAttached = mAttrs.type != + WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG; + mIsImWindow = attachedWindow.mAttrs.type == TYPE_INPUT_METHOD + || attachedWindow.mAttrs.type == TYPE_INPUT_METHOD_DIALOG; + } else { + // The multiplier here is to reserve space for multiple + // windows in the same type layer. + mBaseLayer = mPolicy.windowTypeToLayerLw(a.type) + * TYPE_LAYER_MULTIPLIER + + TYPE_LAYER_OFFSET; + mSubLayer = 0; + mAttachedWindow = null; + mLayoutAttached = false; + mIsImWindow = mAttrs.type == TYPE_INPUT_METHOD + || mAttrs.type == TYPE_INPUT_METHOD_DIALOG; + } + + WindowState appWin = this; + while (appWin.mAttachedWindow != null) { + appWin = mAttachedWindow; + } + WindowToken appToken = appWin.mToken; + while (appToken.appWindowToken == null) { + WindowToken parent = mTokenMap.get(appToken.token); + if (parent == null || appToken == parent) { + break; + } + appToken = parent; + } + mAppToken = appToken.appWindowToken; + + mSurface = null; + mRequestedWidth = 0; + mRequestedHeight = 0; + mLastRequestedWidth = 0; + mLastRequestedHeight = 0; + mReqXPos = 0; + mReqYPos = 0; + mLayer = 0; + mAnimLayer = 0; + mLastLayer = 0; + } + + void attach() { + if (localLOGV) Log.v( + TAG, "Attaching " + this + " token=" + mToken + + ", list=" + mToken.windows); + mSession.windowAddedLocked(); + } + + public void computeFrameLw(Rect pf, Rect df, Rect cf, Rect vf) { + mHaveFrame = true; + + final int pw = pf.right-pf.left; + final int ph = pf.bottom-pf.top; + + int w,h; + if ((mAttrs.flags & mAttrs.FLAG_SCALED) != 0) { + w = mAttrs.width < 0 ? pw : mAttrs.width; + h = mAttrs.height< 0 ? ph : mAttrs.height; + } else { + w = mAttrs.width == mAttrs.FILL_PARENT ? pw : mRequestedWidth; + h = mAttrs.height== mAttrs.FILL_PARENT ? ph : mRequestedHeight; + } + + final Rect container = mContainingFrame; + container.set(pf); + + final Rect display = mDisplayFrame; + display.set(df); + + final Rect content = mContentFrame; + content.set(cf); + + final Rect visible = mVisibleFrame; + visible.set(vf); + + final Rect frame = mFrame; + + //System.out.println("In: w=" + w + " h=" + h + " container=" + + // container + " x=" + mAttrs.x + " y=" + mAttrs.y); + + Gravity.apply(mAttrs.gravity, w, h, container, + (int) (mAttrs.x + mAttrs.horizontalMargin * pw), + (int) (mAttrs.y + mAttrs.verticalMargin * ph), frame); + + //System.out.println("Out: " + mFrame); + + // Now make sure the window fits in the overall display. + Gravity.applyDisplay(mAttrs.gravity, df, frame); + + // Make sure the content and visible frames are inside of the + // final window frame. + if (content.left < frame.left) content.left = frame.left; + if (content.top < frame.top) content.top = frame.top; + if (content.right > frame.right) content.right = frame.right; + if (content.bottom > frame.bottom) content.bottom = frame.bottom; + if (visible.left < frame.left) visible.left = frame.left; + if (visible.top < frame.top) visible.top = frame.top; + if (visible.right > frame.right) visible.right = frame.right; + if (visible.bottom > frame.bottom) visible.bottom = frame.bottom; + + final Rect contentInsets = mContentInsets; + contentInsets.left = content.left-frame.left; + contentInsets.top = content.top-frame.top; + contentInsets.right = frame.right-content.right; + contentInsets.bottom = frame.bottom-content.bottom; + + final Rect visibleInsets = mVisibleInsets; + visibleInsets.left = visible.left-frame.left; + visibleInsets.top = visible.top-frame.top; + visibleInsets.right = frame.right-visible.right; + visibleInsets.bottom = frame.bottom-visible.bottom; + + if (localLOGV) { + //if ("com.google.android.youtube".equals(mAttrs.packageName) + // && mAttrs.type == WindowManager.LayoutParams.TYPE_APPLICATION_PANEL) { + Log.v(TAG, "Resolving (mRequestedWidth=" + + mRequestedWidth + ", mRequestedheight=" + + mRequestedHeight + ") to" + " (pw=" + pw + ", ph=" + ph + + "): frame=" + mFrame.toShortString() + + " ci=" + contentInsets.toShortString() + + " vi=" + visibleInsets.toShortString()); + //} + } + } + + public Rect getFrameLw() { + return mFrame; + } + + public Rect getShownFrameLw() { + return mShownFrame; + } + + public Rect getDisplayFrameLw() { + return mDisplayFrame; + } + + public Rect getContentFrameLw() { + return mContentFrame; + } + + public Rect getVisibleFrameLw() { + return mVisibleFrame; + } + + public boolean getGivenInsetsPendingLw() { + return mGivenInsetsPending; + } + + public Rect getGivenContentInsetsLw() { + return mGivenContentInsets; + } + + public Rect getGivenVisibleInsetsLw() { + return mGivenVisibleInsets; + } + + public WindowManager.LayoutParams getAttrs() { + return mAttrs; + } + + public int getSurfaceLayer() { + return mLayer; + } + + public IApplicationToken getAppToken() { + return mAppToken != null ? mAppToken.appToken : null; + } + + public boolean hasAppShownWindows() { + return mAppToken != null ? mAppToken.firstWindowDrawn : false; + } + + public boolean hasAppStartingIcon() { + return mAppToken != null ? (mAppToken.startingData != null) : false; + } + + public WindowManagerPolicy.WindowState getAppStartingWindow() { + return mAppToken != null ? mAppToken.startingWindow : null; + } + + public void setAnimation(Animation anim) { + if (localLOGV) Log.v( + TAG, "Setting animation in " + this + ": " + anim); + mAnimating = false; + mLocalAnimating = false; + mAnimation = anim; + mAnimation.restrictDuration(MAX_ANIMATION_DURATION); + mAnimation.scaleCurrentDuration(mWindowAnimationScale); + } + + public void clearAnimation() { + if (mAnimation != null) { + mAnimating = true; + mLocalAnimating = false; + mAnimation = null; + } + } + + Surface createSurfaceLocked() { + if (mSurface == null) { + mDrawPending = true; + mCommitDrawPending = false; + mReadyToShow = false; + if (mAppToken != null) { + mAppToken.allDrawn = false; + } + + int flags = 0; + if (mAttrs.memoryType == MEMORY_TYPE_HARDWARE) { + flags |= Surface.HARDWARE; + } else if (mAttrs.memoryType == MEMORY_TYPE_GPU) { + flags |= Surface.GPU; + } else if (mAttrs.memoryType == MEMORY_TYPE_PUSH_BUFFERS) { + flags |= Surface.PUSH_BUFFERS; + } + + if ((mAttrs.flags&WindowManager.LayoutParams.FLAG_SECURE) != 0) { + flags |= Surface.SECURE; + } + if (DEBUG_VISIBILITY) Log.v( + TAG, "Creating surface in session " + + mSession.mSurfaceSession + " window " + this + + " w=" + mFrame.width() + + " h=" + mFrame.height() + " format=" + + mAttrs.format + " flags=" + flags); + + int w = mFrame.width(); + int h = mFrame.height(); + if ((mAttrs.flags & LayoutParams.FLAG_SCALED) != 0) { + // for a scaled surface, we always want the requested + // size. + w = mRequestedWidth; + h = mRequestedHeight; + } + + try { + mSurface = new Surface( + mSession.mSurfaceSession, mSession.mPid, + 0, w, h, mAttrs.format, flags); + } catch (Surface.OutOfResourcesException e) { + Log.w(TAG, "OutOfResourcesException creating surface"); + reclaimSomeSurfaceMemoryLocked(this, "create"); + return null; + } catch (Exception e) { + Log.e(TAG, "Exception creating surface", e); + return null; + } + + if (localLOGV) Log.v( + TAG, "Got surface: " + mSurface + + ", set left=" + mFrame.left + " top=" + mFrame.top + + ", animLayer=" + mAnimLayer); + if (SHOW_TRANSACTIONS) { + Log.i(TAG, ">>> OPEN TRANSACTION"); + Log.i(TAG, " SURFACE " + mSurface + ": CREATE (" + + mAttrs.getTitle() + ") pos=(" + + mFrame.left + "," + mFrame.top + ") (" + + mFrame.width() + "x" + mFrame.height() + "), layer=" + + mAnimLayer + " HIDE"); + } + Surface.openTransaction(); + try { + try { + mSurface.setPosition(mFrame.left, mFrame.top); + mSurface.setLayer(mAnimLayer); + mSurface.hide(); + if ((mAttrs.flags&WindowManager.LayoutParams.FLAG_DITHER) != 0) { + mSurface.setFlags(Surface.SURFACE_DITHER, + Surface.SURFACE_DITHER); + } + } catch (RuntimeException e) { + Log.w(TAG, "Error creating surface in " + w, e); + reclaimSomeSurfaceMemoryLocked(this, "create-init"); + } + mLastHidden = true; + } finally { + if (SHOW_TRANSACTIONS) Log.i(TAG, "<<< CLOSE TRANSACTION"); + Surface.closeTransaction(); + } + if (localLOGV) Log.v( + TAG, "Created surface " + this); + } + return mSurface; + } + + void destroySurfaceLocked() { + // Window is no longer on-screen, so can no longer receive + // key events... if we were waiting for it to finish + // handling a key event, the wait is over! + mKeyWaiter.finishedKey(mSession, mClient, true, + KeyWaiter.RETURN_NOTHING); + mKeyWaiter.releasePendingPointerLocked(mSession); + mKeyWaiter.releasePendingTrackballLocked(mSession); + + if (mAppToken != null && this == mAppToken.startingWindow) { + mAppToken.startingDisplayed = false; + } + + if (localLOGV) Log.v( + TAG, "Window " + this + + " destroying surface " + mSurface + ", session " + mSession); + if (mSurface != null) { + try { + if (SHOW_TRANSACTIONS) { + RuntimeException ex = new RuntimeException(); + ex.fillInStackTrace(); + Log.i(TAG, " SURFACE " + mSurface + ": DESTROY (" + + mAttrs.getTitle() + ")", ex); + } + mSurface.clear(); + } catch (RuntimeException e) { + Log.w(TAG, "Exception thrown when destroying Window " + this + + " surface " + mSurface + " session " + mSession + + ": " + e.toString()); + } + mSurface = null; + mDrawPending = false; + mCommitDrawPending = false; + mReadyToShow = false; + + int i = mChildWindows.size(); + while (i > 0) { + i--; + WindowState c = (WindowState)mChildWindows.get(i); + c.mAttachedHidden = true; + } + } + } + + boolean finishDrawingLocked() { + if (mDrawPending) { + if (SHOW_TRANSACTIONS || DEBUG_ORIENTATION) Log.v( + TAG, "finishDrawingLocked: " + mSurface); + mCommitDrawPending = true; + mDrawPending = false; + return true; + } + return false; + } + + // This must be called while inside a transaction. + void commitFinishDrawingLocked(long currentTime) { + //Log.i(TAG, "commitFinishDrawingLocked: " + mSurface); + if (!mCommitDrawPending) { + return; + } + mCommitDrawPending = false; + mReadyToShow = true; + final boolean starting = mAttrs.type == TYPE_APPLICATION_STARTING; + final AppWindowToken atoken = mAppToken; + if (atoken == null || atoken.allDrawn || starting) { + performShowLocked(); + } + } + + // This must be called while inside a transaction. + boolean performShowLocked() { + if (DEBUG_VISIBILITY) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.v(TAG, "performShow on " + this + + ": readyToShow=" + mReadyToShow + " readyForDisplay=" + isReadyForDisplay() + + " starting=" + (mAttrs.type == TYPE_APPLICATION_STARTING), e); + } + if (mReadyToShow && isReadyForDisplay()) { + if (SHOW_TRANSACTIONS || DEBUG_ORIENTATION) Log.i( + TAG, " SURFACE " + mSurface + ": SHOW (performShowLocked)"); + if (DEBUG_VISIBILITY) Log.v(TAG, "Showing " + this + + " during animation: policyVis=" + mPolicyVisibility + + " attHidden=" + mAttachedHidden + + " tok.hiddenRequested=" + + (mAppToken != null ? mAppToken.hiddenRequested : false) + + " tok.idden=" + + (mAppToken != null ? mAppToken.hidden : false) + + " animating=" + mAnimating + + " tok animating=" + + (mAppToken != null ? mAppToken.animating : false)); + if (!showSurfaceRobustlyLocked(this)) { + return false; + } + mLastAlpha = -1; + mHasDrawn = true; + mLastHidden = false; + mReadyToShow = false; + enableScreenIfNeededLocked(); + + applyEnterAnimationLocked(this); + + int i = mChildWindows.size(); + while (i > 0) { + i--; + WindowState c = (WindowState)mChildWindows.get(i); + if (c.mSurface != null && c.mAttachedHidden) { + c.mAttachedHidden = false; + c.performShowLocked(); + } + } + + if (mAttrs.type != TYPE_APPLICATION_STARTING + && mAppToken != null) { + mAppToken.firstWindowDrawn = true; + if (mAnimation == null && mAppToken.startingData != null) { + if (DEBUG_STARTING_WINDOW) Log.v(TAG, "Finish starting " + + mToken + + ": first real window is shown, no animation"); + mFinishedStarting.add(mAppToken); + mH.sendEmptyMessage(H.FINISHED_STARTING); + } + mAppToken.updateReportedVisibilityLocked(); + } + } + return true; + } + + // This must be called while inside a transaction. Returns true if + // there is more animation to run. + boolean stepAnimationLocked(long currentTime, int dw, int dh) { + if (!mDisplayFrozen) { + // We will run animations as long as the display isn't frozen. + + if (!mDrawPending && !mCommitDrawPending && mAnimation != null) { + mHasTransformation = true; + mHasLocalTransformation = true; + if (!mLocalAnimating) { + if (DEBUG_ANIM) Log.v( + TAG, "Starting animation in " + this + + " @ " + currentTime + ": ww=" + mFrame.width() + " wh=" + mFrame.height() + + " dw=" + dw + " dh=" + dh + " scale=" + mWindowAnimationScale); + mAnimation.initialize(mFrame.width(), mFrame.height(), dw, dh); + mAnimation.setStartTime(currentTime); + mLocalAnimating = true; + mAnimating = true; + } + mTransformation.clear(); + final boolean more = mAnimation.getTransformation( + currentTime, mTransformation); + if (DEBUG_ANIM) Log.v( + TAG, "Stepped animation in " + this + + ": more=" + more + ", xform=" + mTransformation); + if (more) { + // we're not done! + return true; + } + if (DEBUG_ANIM) Log.v( + TAG, "Finished animation in " + this + + " @ " + currentTime); + mAnimation = null; + //WindowManagerService.this.dump(); + } + mHasLocalTransformation = false; + if ((!mLocalAnimating || mAnimationIsEntrance) && mAppToken != null + && mAppToken.hasTransformation) { + // When our app token is animating, we kind-of pretend like + // we are as well. Note the mLocalAnimating mAnimationIsEntrance + // part of this check means that we will only do this if + // our window is not currently exiting, or it is not + // locally animating itself. The idea being that one that + // is exiting and doing a local animation should be removed + // once that animation is done. + mAnimating = true; + mHasTransformation = true; + mTransformation.clear(); + return false; + } else if (mHasTransformation) { + // Little trick to get through the path below to act like + // we have finished an animation. + mAnimating = true; + } else if (isAnimating()) { + mAnimating = true; + } + } else if (mAnimation != null) { + // If the display is frozen, and there is a pending animation, + // clear it and make sure we run the cleanup code. + mAnimating = true; + mLocalAnimating = true; + mAnimation = null; + } + + if (!mAnimating && !mLocalAnimating) { + return false; + } + + if (DEBUG_ANIM) Log.v( + TAG, "Animation done in " + this + ": exiting=" + mExiting + + ", reportedVisible=" + + (mAppToken != null ? mAppToken.reportedVisible : false)); + + mAnimating = false; + mLocalAnimating = false; + mAnimation = null; + mAnimLayer = mLayer; + if (mIsImWindow) { + mAnimLayer += mInputMethodAnimLayerAdjustment; + } + if (DEBUG_LAYERS) Log.v(TAG, "Stepping win " + this + + " anim layer: " + mAnimLayer); + mHasTransformation = false; + mHasLocalTransformation = false; + mPolicyVisibility = mPolicyVisibilityAfterAnim; + mTransformation.clear(); + if (mHasDrawn + && mAttrs.type == WindowManager.LayoutParams.TYPE_APPLICATION_STARTING + && mAppToken != null + && mAppToken.firstWindowDrawn + && mAppToken.startingData != null) { + if (DEBUG_STARTING_WINDOW) Log.v(TAG, "Finish starting " + + mToken + ": first real window done animating"); + mFinishedStarting.add(mAppToken); + mH.sendEmptyMessage(H.FINISHED_STARTING); + } + + finishExit(); + + if (mAppToken != null) { + mAppToken.updateReportedVisibilityLocked(); + } + + return false; + } + + void finishExit() { + if (DEBUG_ANIM) Log.v( + TAG, "finishExit in " + this + + ": exiting=" + mExiting + + " remove=" + mRemoveOnExit + + " windowAnimating=" + isWindowAnimating()); + + final int N = mChildWindows.size(); + for (int i=0; i<N; i++) { + ((WindowState)mChildWindows.get(i)).finishExit(); + } + + if (!mExiting) { + return; + } + + if (isWindowAnimating()) { + return; + } + + if (localLOGV) Log.v( + TAG, "Exit animation finished in " + this + + ": remove=" + mRemoveOnExit); + if (mSurface != null) { + mDestroySurface.add(this); + mDestroying = true; + if (SHOW_TRANSACTIONS) Log.i( + TAG, " SURFACE " + mSurface + ": HIDE (finishExit)"); + try { + mSurface.hide(); + } catch (RuntimeException e) { + Log.w(TAG, "Error hiding surface in " + this, e); + } + mLastHidden = true; + mKeyWaiter.releasePendingPointerLocked(mSession); + } + mExiting = false; + if (mRemoveOnExit) { + mPendingRemove.add(this); + mRemoveOnExit = false; + } + } + + boolean isIdentityMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { + if (dsdx < .99999f || dsdx > 1.00001f) return false; + if (dtdy < .99999f || dtdy > 1.00001f) return false; + if (dtdx < -.000001f || dtdx > .000001f) return false; + if (dsdy < -.000001f || dsdy > .000001f) return false; + return true; + } + + void computeShownFrameLocked() { + final boolean selfTransformation = mHasLocalTransformation; + Transformation attachedTransformation = + (mAttachedWindow != null && mAttachedWindow.mHasLocalTransformation) + ? mAttachedWindow.mTransformation : null; + Transformation appTransformation = + (mAppToken != null && mAppToken.hasTransformation) + ? mAppToken.transformation : null; + if (selfTransformation || attachedTransformation != null + || appTransformation != null) { + // cache often used attributes locally + final Rect frame = mFrame; + final float tmpFloats[] = mTmpFloats; + final Matrix tmpMatrix = mTmpMatrix; + + // Compute the desired transformation. + tmpMatrix.setTranslate(frame.left, frame.top); + if (selfTransformation) { + tmpMatrix.preConcat(mTransformation.getMatrix()); + } + if (attachedTransformation != null) { + tmpMatrix.preConcat(attachedTransformation.getMatrix()); + } + if (appTransformation != null) { + tmpMatrix.preConcat(appTransformation.getMatrix()); + } + + // "convert" it into SurfaceFlinger's format + // (a 2x2 matrix + an offset) + // Here we must not transform the position of the surface + // since it is already included in the transformation. + //Log.i(TAG, "Transform: " + matrix); + + tmpMatrix.getValues(tmpFloats); + mDsDx = tmpFloats[Matrix.MSCALE_X]; + mDtDx = tmpFloats[Matrix.MSKEW_X]; + mDsDy = tmpFloats[Matrix.MSKEW_Y]; + mDtDy = tmpFloats[Matrix.MSCALE_Y]; + int x = (int)tmpFloats[Matrix.MTRANS_X]; + int y = (int)tmpFloats[Matrix.MTRANS_Y]; + int w = frame.width(); + int h = frame.height(); + mShownFrame.set(x, y, x+w, y+h); + + // Now set the alpha... but because our current hardware + // can't do alpha transformation on a non-opaque surface, + // turn it off if we are running an animation that is also + // transforming since it is more important to have that + // animation be smooth. + mShownAlpha = mAlpha; + if (!mLimitedAlphaCompositing + || (!PixelFormat.formatHasAlpha(mAttrs.format) + || (isIdentityMatrix(mDsDx, mDtDx, mDsDy, mDtDy) + && x == frame.left && y == frame.top))) { + //Log.i(TAG, "Applying alpha transform"); + if (selfTransformation) { + mShownAlpha *= mTransformation.getAlpha(); + } + if (attachedTransformation != null) { + mShownAlpha *= attachedTransformation.getAlpha(); + } + if (appTransformation != null) { + mShownAlpha *= appTransformation.getAlpha(); + } + } else { + //Log.i(TAG, "Not applying alpha transform"); + } + + if (localLOGV) Log.v( + TAG, "Continuing animation in " + this + + ": " + mShownFrame + + ", alpha=" + mTransformation.getAlpha()); + return; + } + + mShownFrame.set(mFrame); + mShownAlpha = mAlpha; + mDsDx = 1; + mDtDx = 0; + mDsDy = 0; + mDtDy = 1; + } + + /** + * Is this window visible? It is not visible if there is no + * surface, or we are in the process of running an exit animation + * that will remove the surface, or its app token has been hidden. + */ + public boolean isVisibleLw() { + final AppWindowToken atoken = mAppToken; + return mSurface != null && mPolicyVisibility && !mAttachedHidden + && (atoken == null || !atoken.hiddenRequested) + && !mExiting && !mDestroying; + } + + /** + * Is this window visible, ignoring its app token? It is not visible + * if there is no surface, or we are in the process of running an exit animation + * that will remove the surface. + */ + public boolean isWinVisibleLw() { + final AppWindowToken atoken = mAppToken; + return mSurface != null && mPolicyVisibility && !mAttachedHidden + && (atoken == null || !atoken.hiddenRequested || atoken.animating) + && !mExiting && !mDestroying; + } + + /** + * The same as isVisible(), but follows the current hidden state of + * the associated app token, not the pending requested hidden state. + */ + boolean isVisibleNow() { + return mSurface != null && mPolicyVisibility && !mAttachedHidden + && !mToken.hidden && !mExiting && !mDestroying; + } + + /** + * Same as isVisible(), but we also count it as visible between the + * call to IWindowSession.add() and the first relayout(). + */ + boolean isVisibleOrAdding() { + final AppWindowToken atoken = mAppToken; + return (mSurface != null + || (!mRelayoutCalled && mViewVisibility == View.VISIBLE)) + && mPolicyVisibility && !mAttachedHidden + && (atoken == null || !atoken.hiddenRequested) + && !mExiting && !mDestroying; + } + + /** + * Is this window currently on-screen? It is on-screen either if it + * is visible or it is currently running an animation before no longer + * being visible. + */ + boolean isOnScreen() { + final AppWindowToken atoken = mAppToken; + if (atoken != null) { + return mSurface != null && mPolicyVisibility && !mDestroying + && ((!mAttachedHidden && !atoken.hiddenRequested) + || mAnimating || atoken.animating); + } else { + return mSurface != null && mPolicyVisibility && !mDestroying + && (!mAttachedHidden || mAnimating); + } + } + + /** + * Like isOnScreen(), but we don't return true if the window is part + * of a transition that has not yet been started. + */ + boolean isReadyForDisplay() { + final AppWindowToken atoken = mAppToken; + final boolean animating = atoken != null ? atoken.animating : false; + return mSurface != null && mPolicyVisibility && !mDestroying + && ((!mAttachedHidden && !mToken.hidden) + || mAnimating || animating); + } + + /** Is the window or its container currently animating? */ + boolean isAnimating() { + final WindowState attached = mAttachedWindow; + final AppWindowToken atoken = mAppToken; + return mAnimation != null + || (attached != null && attached.mAnimation != null) + || (atoken != null && + (atoken.animation != null + || atoken.inPendingTransaction)); + } + + /** Is this window currently animating? */ + boolean isWindowAnimating() { + return mAnimation != null; + } + + /** + * Like isOnScreen, but returns false if the surface hasn't yet + * been drawn. + */ + public boolean isDisplayedLw() { + final AppWindowToken atoken = mAppToken; + return mSurface != null && mPolicyVisibility && !mDestroying + && !mDrawPending && !mCommitDrawPending + && ((!mAttachedHidden && + (atoken == null || !atoken.hiddenRequested)) + || mAnimating); + } + + public boolean fillsScreenLw(int screenWidth, int screenHeight, + boolean shownFrame, boolean onlyOpaque) { + if (mSurface == null) { + return false; + } + if (mAppToken != null && !mAppToken.appFullscreen) { + return false; + } + if (onlyOpaque && mAttrs.format != PixelFormat.OPAQUE) { + return false; + } + final Rect frame = shownFrame ? mShownFrame : mFrame; + if (frame.left <= 0 && frame.top <= 0 + && frame.right >= screenWidth + && frame.bottom >= screenHeight) { + return true; + } + return false; + } + + boolean isFullscreenOpaque(int screenWidth, int screenHeight) { + if (mAttrs.format != PixelFormat.OPAQUE || mSurface == null + || mAnimation != null || mDrawPending || mCommitDrawPending) { + return false; + } + if (mFrame.left <= 0 && mFrame.top <= 0 && + mFrame.right >= screenWidth && mFrame.bottom >= screenHeight) { + return true; + } + return false; + } + + void removeLocked() { + if (mAttachedWindow != null) { + mAttachedWindow.mChildWindows.remove(this); + } + destroySurfaceLocked(); + mSession.windowRemovedLocked(); + try { + mClient.asBinder().unlinkToDeath(mDeathRecipient, 0); + } catch (RuntimeException e) { + // Ignore if it has already been removed (usually because + // we are doing this as part of processing a death note.) + } + } + + private class DeathRecipient implements IBinder.DeathRecipient { + public void binderDied() { + try { + synchronized(mWindowMap) { + WindowState win = windowForClientLocked(mSession, mClient); + Log.i(TAG, "WIN DEATH: " + win); + if (win != null) { + removeWindowLocked(mSession, win); + } + } + } catch (IllegalArgumentException ex) { + // This will happen if the window has already been + // removed. + } + } + } + + /** Returns true if this window desires key events. */ + public final boolean canReceiveKeys() { + return isVisibleOrAdding() + && (mViewVisibility == View.VISIBLE) + && ((mAttrs.flags & WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE) == 0); + } + + public boolean hasDrawnLw() { + return mHasDrawn; + } + + public boolean showLw(boolean doAnimation) { + if (!mPolicyVisibility || !mPolicyVisibilityAfterAnim) { + mPolicyVisibility = true; + mPolicyVisibilityAfterAnim = true; + if (doAnimation) { + applyAnimationLocked(this, WindowManagerPolicy.TRANSIT_ENTER, true); + } + requestAnimationLocked(0); + return true; + } + return false; + } + + public boolean hideLw(boolean doAnimation) { + boolean current = doAnimation ? mPolicyVisibilityAfterAnim + : mPolicyVisibility; + if (current) { + if (doAnimation) { + applyAnimationLocked(this, WindowManagerPolicy.TRANSIT_EXIT, false); + if (mAnimation == null) { + doAnimation = false; + } + } + if (doAnimation) { + mPolicyVisibilityAfterAnim = false; + } else { + mPolicyVisibilityAfterAnim = false; + mPolicyVisibility = false; + } + requestAnimationLocked(0); + return true; + } + return false; + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "mSession=" + mSession + + " mClient=" + mClient.asBinder()); + pw.println(prefix + "mAttrs=" + mAttrs); + pw.println(prefix + "mAttachedWindow=" + mAttachedWindow + + " mLayoutAttached=" + mLayoutAttached + + " mIsImWindow=" + mIsImWindow); + pw.println(prefix + "mBaseLayer=" + mBaseLayer + + " mSubLayer=" + mSubLayer + + " mAnimLayer=" + mLayer + "+" + + (mTargetAppToken != null ? mTargetAppToken.animLayerAdjustment + : (mAppToken != null ? mAppToken.animLayerAdjustment : 0)) + + "=" + mAnimLayer + + " mLastLayer=" + mLastLayer); + pw.println(prefix + "mSurface=" + mSurface); + pw.println(prefix + "mToken=" + mToken); + pw.println(prefix + "mAppToken=" + mAppToken); + pw.println(prefix + "mTargetAppToken=" + mTargetAppToken); + pw.println(prefix + "mViewVisibility=0x" + Integer.toHexString(mViewVisibility) + + " mPolicyVisibility=" + mPolicyVisibility + + " (after=" + mPolicyVisibilityAfterAnim + + ") mAttachedHidden=" + mAttachedHidden + + " mLastHidden=" + mLastHidden + + " mHaveFrame=" + mHaveFrame); + pw.println(prefix + "Requested w=" + mRequestedWidth + " h=" + mRequestedHeight + + " x=" + mReqXPos + " y=" + mReqYPos); + pw.println(prefix + "mGivenContentInsets=" + mGivenContentInsets.toShortString() + + " mGivenVisibleInsets=" + mGivenVisibleInsets.toShortString() + + " mTouchableInsets=" + mTouchableInsets + + " pending=" + mGivenInsetsPending); + pw.println(prefix + "mShownFrame=" + mShownFrame.toShortString() + + " last=" + mLastShownFrame.toShortString()); + pw.println(prefix + "mFrame=" + mFrame.toShortString() + + " last=" + mLastFrame.toShortString()); + pw.println(prefix + "mContainingFrame=" + mContainingFrame.toShortString() + + " mDisplayFrame=" + mDisplayFrame.toShortString()); + pw.println(prefix + "mContentFrame=" + mContentFrame.toShortString() + + " mVisibleFrame=" + mVisibleFrame.toShortString()); + pw.println(prefix + "mContentInsets=" + mContentInsets.toShortString() + + " last=" + mLastContentInsets.toShortString() + + " mVisibleInsets=" + mVisibleInsets.toShortString() + + " last=" + mLastVisibleInsets.toShortString()); + pw.println(prefix + "mShownAlpha=" + mShownAlpha + + " mAlpha=" + mAlpha + " mLastAlpha=" + mLastAlpha); + pw.println(prefix + "mAnimating=" + mAnimating + + " mLocalAnimating=" + mLocalAnimating + + " mAnimationIsEntrance=" + mAnimationIsEntrance + + " mAnimation=" + mAnimation); + pw.println(prefix + "XForm: has=" + mHasTransformation + + " " + mTransformation.toShortString()); + pw.println(prefix + "mDrawPending=" + mDrawPending + + " mCommitDrawPending=" + mCommitDrawPending + + " mReadyToShow=" + mReadyToShow + + " mHasDrawn=" + mHasDrawn); + pw.println(prefix + "mExiting=" + mExiting + + " mRemoveOnExit=" + mRemoveOnExit + + " mDestroying=" + mDestroying + + " mRemoved=" + mRemoved); + pw.println(prefix + "mOrientationChanging=" + mOrientationChanging + + " mAppFreezing=" + mAppFreezing); + } + + @Override + public String toString() { + return "Window{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + mAttrs.getTitle() + " paused=" + mToken.paused + "}"; + } + } + + // ------------------------------------------------------------- + // Window Token State + // ------------------------------------------------------------- + + class WindowToken { + // The actual token. + final IBinder token; + + // The type of window this token is for, as per WindowManager.LayoutParams. + final int windowType; + + // Set if this token was explicitly added by a client, so should + // not be removed when all windows are removed. + final boolean explicit; + + // If this is an AppWindowToken, this is non-null. + AppWindowToken appWindowToken; + + // All of the windows associated with this token. + final ArrayList<WindowState> windows = new ArrayList<WindowState>(); + + // Is key dispatching paused for this token? + boolean paused = false; + + // Should this token's windows be hidden? + boolean hidden; + + // Temporary for finding which tokens no longer have visible windows. + boolean hasVisible; + + WindowToken(IBinder _token, int type, boolean _explicit) { + token = _token; + windowType = type; + explicit = _explicit; + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "token=" + token); + pw.println(prefix + "windows=" + windows); + pw.println(prefix + "windowType=" + windowType + " hidden=" + hidden + + " hasVisible=" + hasVisible); + } + + @Override + public String toString() { + return "WindowToken{" + + Integer.toHexString(System.identityHashCode(this)) + + " token=" + token + "}"; + } + }; + + class AppWindowToken extends WindowToken { + // Non-null only for application tokens. + final IApplicationToken appToken; + + // All of the windows and child windows that are included in this + // application token. Note this list is NOT sorted! + final ArrayList<WindowState> allAppWindows = new ArrayList<WindowState>(); + + int groupId = -1; + boolean appFullscreen; + int requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + + // These are used for determining when all windows associated with + // an activity have been drawn, so they can be made visible together + // at the same time. + int lastTransactionSequence = mTransactionSequence-1; + int numInterestingWindows; + int numDrawnWindows; + boolean inPendingTransaction; + boolean allDrawn; + + // Is this token going to be hidden in a little while? If so, it + // won't be taken into account for setting the screen orientation. + boolean willBeHidden; + + // Is this window's surface needed? This is almost like hidden, except + // it will sometimes be true a little earlier: when the token has + // been shown, but is still waiting for its app transition to execute + // before making its windows shown. + boolean hiddenRequested; + + // Have we told the window clients to hide themselves? + boolean clientHidden; + + // Last visibility state we reported to the app token. + boolean reportedVisible; + + // Set to true when the token has been removed from the window mgr. + boolean removed; + + // Have we been asked to have this token keep the screen frozen? + boolean freezingScreen; + + boolean animating; + Animation animation; + boolean hasTransformation; + final Transformation transformation = new Transformation(); + + // Offset to the window of all layers in the token, for use by + // AppWindowToken animations. + int animLayerAdjustment; + + // Information about an application starting window if displayed. + StartingData startingData; + WindowState startingWindow; + View startingView; + boolean startingDisplayed; + boolean startingMoved; + boolean firstWindowDrawn; + + AppWindowToken(IApplicationToken _token) { + super(_token.asBinder(), + WindowManager.LayoutParams.TYPE_APPLICATION, true); + appWindowToken = this; + appToken = _token; + } + + public void setAnimation(Animation anim) { + if (localLOGV) Log.v( + TAG, "Setting animation in " + this + ": " + anim); + animation = anim; + animating = false; + anim.restrictDuration(MAX_ANIMATION_DURATION); + anim.scaleCurrentDuration(mTransitionAnimationScale); + int zorder = anim.getZAdjustment(); + int adj = 0; + if (zorder == Animation.ZORDER_TOP) { + adj = TYPE_LAYER_OFFSET; + } else if (zorder == Animation.ZORDER_BOTTOM) { + adj = -TYPE_LAYER_OFFSET; + } + + if (animLayerAdjustment != adj) { + animLayerAdjustment = adj; + updateLayers(); + } + } + + public void setDummyAnimation() { + if (animation == null) { + if (localLOGV) Log.v( + TAG, "Setting dummy animation in " + this); + animation = sDummyAnimation; + } + } + + public void clearAnimation() { + if (animation != null) { + animation = null; + animating = true; + } + } + + void updateLayers() { + final int N = allAppWindows.size(); + final int adj = animLayerAdjustment; + for (int i=0; i<N; i++) { + WindowState w = allAppWindows.get(i); + w.mAnimLayer = w.mLayer + adj; + if (DEBUG_LAYERS) Log.v(TAG, "Updating layer " + w + ": " + + w.mAnimLayer); + if (w == mInputMethodTarget) { + setInputMethodAnimLayerAdjustment(adj); + } + } + } + + void sendAppVisibilityToClients() { + final int N = allAppWindows.size(); + for (int i=0; i<N; i++) { + WindowState win = allAppWindows.get(i); + if (win == startingWindow && clientHidden) { + // Don't hide the starting window. + continue; + } + try { + if (DEBUG_VISIBILITY) Log.v(TAG, + "Setting visibility of " + win + ": " + (!clientHidden)); + win.mClient.dispatchAppVisibility(!clientHidden); + } catch (RemoteException e) { + } + } + } + + void showAllWindowsLocked() { + final int NW = allAppWindows.size(); + for (int i=0; i<NW; i++) { + WindowState w = allAppWindows.get(i); + if (DEBUG_VISIBILITY) Log.v(TAG, + "performing show on: " + w); + w.performShowLocked(); + } + } + + // This must be called while inside a transaction. + boolean stepAnimationLocked(long currentTime, int dw, int dh) { + if (!mDisplayFrozen) { + // We will run animations as long as the display isn't frozen. + + if (animation == sDummyAnimation) { + // This guy is going to animate, but not yet. For now count + // it is not animating for purposes of scheduling transactions; + // when it is really time to animate, this will be set to + // a real animation and the next call will execute normally. + return false; + } + + if ((allDrawn || animating || startingDisplayed) && animation != null) { + if (!animating) { + if (DEBUG_ANIM) Log.v( + TAG, "Starting animation in " + this + + " @ " + currentTime + ": dw=" + dw + " dh=" + dh + + " scale=" + mTransitionAnimationScale + + " allDrawn=" + allDrawn + " animating=" + animating); + animation.initialize(dw, dh, dw, dh); + animation.setStartTime(currentTime); + animating = true; + } + transformation.clear(); + final boolean more = animation.getTransformation( + currentTime, transformation); + if (DEBUG_ANIM) Log.v( + TAG, "Stepped animation in " + this + + ": more=" + more + ", xform=" + transformation); + if (more) { + // we're done! + hasTransformation = true; + return true; + } + if (DEBUG_ANIM) Log.v( + TAG, "Finished animation in " + this + + " @ " + currentTime); + animation = null; + } + } else if (animation != null) { + // If the display is frozen, and there is a pending animation, + // clear it and make sure we run the cleanup code. + animating = true; + animation = null; + } + + hasTransformation = false; + + if (!animating) { + return false; + } + + clearAnimation(); + animating = false; + if (mInputMethodTarget != null && mInputMethodTarget.mAppToken == this) { + moveInputMethodWindowsIfNeededLocked(true); + } + + if (DEBUG_ANIM) Log.v( + TAG, "Animation done in " + this + + ": reportedVisible=" + reportedVisible); + + transformation.clear(); + if (animLayerAdjustment != 0) { + animLayerAdjustment = 0; + updateLayers(); + } + + final int N = windows.size(); + for (int i=0; i<N; i++) { + ((WindowState)windows.get(i)).finishExit(); + } + updateReportedVisibilityLocked(); + + return false; + } + + void updateReportedVisibilityLocked() { + if (appToken == null) { + return; + } + + int numInteresting = 0; + int numVisible = 0; + boolean nowGone = true; + + if (DEBUG_VISIBILITY) Log.v(TAG, "Update reported visibility: " + this); + final int N = allAppWindows.size(); + for (int i=0; i<N; i++) { + WindowState win = allAppWindows.get(i); + if (win == startingWindow || win.mAppFreezing) { + continue; + } + if (DEBUG_VISIBILITY) { + Log.v(TAG, "Win " + win + ": isDisplayed=" + + win.isDisplayedLw() + + ", isAnimating=" + win.isAnimating()); + if (!win.isDisplayedLw()) { + Log.v(TAG, "Not displayed: s=" + win.mSurface + + " pv=" + win.mPolicyVisibility + + " dp=" + win.mDrawPending + + " cdp=" + win.mCommitDrawPending + + " ah=" + win.mAttachedHidden + + " th=" + + (win.mAppToken != null + ? win.mAppToken.hiddenRequested : false) + + " a=" + win.mAnimating); + } + } + numInteresting++; + if (win.isDisplayedLw()) { + if (!win.isAnimating()) { + numVisible++; + } + nowGone = false; + } else if (win.isAnimating()) { + nowGone = false; + } + } + + boolean nowVisible = numInteresting > 0 && numVisible >= numInteresting; + if (DEBUG_VISIBILITY) Log.v(TAG, "VIS " + this + ": interesting=" + + numInteresting + " visible=" + numVisible); + if (nowVisible != reportedVisible) { + if (DEBUG_VISIBILITY) Log.v( + TAG, "Visibility changed in " + this + + ": vis=" + nowVisible); + reportedVisible = nowVisible; + Message m = mH.obtainMessage( + H.REPORT_APPLICATION_TOKEN_WINDOWS, + nowVisible ? 1 : 0, + nowGone ? 1 : 0, + this); + mH.sendMessage(m); + } + } + + void dump(PrintWriter pw, String prefix) { + super.dump(pw, prefix); + pw.println(prefix + "app=" + (appToken != null)); + pw.println(prefix + "allAppWindows=" + allAppWindows); + pw.println(prefix + "groupId=" + groupId + + " requestedOrientation=" + requestedOrientation); + pw.println(prefix + "hiddenRequested=" + hiddenRequested + + " clientHidden=" + clientHidden + + " willBeHidden=" + willBeHidden + + " reportedVisible=" + reportedVisible); + pw.println(prefix + "paused=" + paused + + " freezingScreen=" + freezingScreen); + pw.println(prefix + "numInterestingWindows=" + numInterestingWindows + + " numDrawnWindows=" + numDrawnWindows + + " inPendingTransaction=" + inPendingTransaction + + " allDrawn=" + allDrawn); + pw.println(prefix + "animating=" + animating + + " animation=" + animation); + pw.println(prefix + "animLayerAdjustment=" + animLayerAdjustment + + " transformation=" + transformation.toShortString()); + pw.println(prefix + "startingData=" + startingData + + " removed=" + removed + + " firstWindowDrawn=" + firstWindowDrawn); + pw.println(prefix + "startingWindow=" + startingWindow + + " startingView=" + startingView + + " startingDisplayed=" + startingDisplayed + + " startingMoved" + startingMoved); + } + + @Override + public String toString() { + return "AppWindowToken{" + + Integer.toHexString(System.identityHashCode(this)) + + " token=" + token + "}"; + } + } + + public static WindowManager.LayoutParams findAnimations( + ArrayList<AppWindowToken> order, + ArrayList<AppWindowToken> tokenList1, + ArrayList<AppWindowToken> tokenList2) { + // We need to figure out which animation to use... + WindowManager.LayoutParams animParams = null; + int animSrc = 0; + + //Log.i(TAG, "Looking for animations..."); + for (int i=order.size()-1; i>=0; i--) { + AppWindowToken wtoken = order.get(i); + //Log.i(TAG, "Token " + wtoken + " with " + wtoken.windows.size() + " windows"); + if (tokenList1.contains(wtoken) || tokenList2.contains(wtoken)) { + int j = wtoken.windows.size(); + while (j > 0) { + j--; + WindowState win = wtoken.windows.get(j); + //Log.i(TAG, "Window " + win + ": type=" + win.mAttrs.type); + if (win.mAttrs.type == WindowManager.LayoutParams.TYPE_BASE_APPLICATION + || win.mAttrs.type == WindowManager.LayoutParams.TYPE_APPLICATION_STARTING) { + //Log.i(TAG, "Found base or application window, done!"); + if (wtoken.appFullscreen) { + return win.mAttrs; + } + if (animSrc < 2) { + animParams = win.mAttrs; + animSrc = 2; + } + } else if (animSrc < 1 && win.mAttrs.type == WindowManager.LayoutParams.TYPE_APPLICATION) { + //Log.i(TAG, "Found normal window, we may use this..."); + animParams = win.mAttrs; + animSrc = 1; + } + } + } + } + + return animParams; + } + + // ------------------------------------------------------------- + // DummyAnimation + // ------------------------------------------------------------- + + // This is an animation that does nothing: it just immediately finishes + // itself every time it is called. It is used as a stub animation in cases + // where we want to synchronize multiple things that may be animating. + static final class DummyAnimation extends Animation { + public boolean getTransformation(long currentTime, Transformation outTransformation) { + return false; + } + } + static final Animation sDummyAnimation = new DummyAnimation(); + + // ------------------------------------------------------------- + // Async Handler + // ------------------------------------------------------------- + + static final class StartingData { + final String pkg; + final int theme; + final CharSequence nonLocalizedLabel; + final int labelRes; + final int icon; + + StartingData(String _pkg, int _theme, CharSequence _nonLocalizedLabel, + int _labelRes, int _icon) { + pkg = _pkg; + theme = _theme; + nonLocalizedLabel = _nonLocalizedLabel; + labelRes = _labelRes; + icon = _icon; + } + } + + private final class H extends Handler { + public static final int REPORT_FOCUS_CHANGE = 2; + public static final int REPORT_LOSING_FOCUS = 3; + public static final int ANIMATE = 4; + public static final int ADD_STARTING = 5; + public static final int REMOVE_STARTING = 6; + public static final int FINISHED_STARTING = 7; + public static final int REPORT_APPLICATION_TOKEN_WINDOWS = 8; + public static final int UPDATE_ORIENTATION = 10; + public static final int WINDOW_FREEZE_TIMEOUT = 11; + public static final int HOLD_SCREEN_CHANGED = 12; + public static final int APP_TRANSITION_TIMEOUT = 13; + public static final int PERSIST_ANIMATION_SCALE = 14; + public static final int FORCE_GC = 15; + public static final int ENABLE_SCREEN = 16; + public static final int APP_FREEZE_TIMEOUT = 17; + + private Session mLastReportedHold; + + public H() { + } + + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case REPORT_FOCUS_CHANGE: { + WindowState lastFocus; + WindowState newFocus; + + synchronized(mWindowMap) { + lastFocus = mLastFocus; + newFocus = mCurrentFocus; + if (lastFocus == newFocus) { + // Focus is not changing, so nothing to do. + return; + } + mLastFocus = newFocus; + //Log.i(TAG, "Focus moving from " + lastFocus + // + " to " + newFocus); + if (newFocus != null && lastFocus != null + && !newFocus.isDisplayedLw()) { + //Log.i(TAG, "Delaying loss of focus..."); + mLosingFocus.add(lastFocus); + lastFocus = null; + } + } + + if (lastFocus != newFocus) { + //System.out.println("Changing focus from " + lastFocus + // + " to " + newFocus); + if (newFocus != null) { + try { + //Log.i(TAG, "Gaining focus: " + newFocus); + newFocus.mClient.windowFocusChanged(true, mInTouchMode); + } catch (RemoteException e) { + // Ignore if process has died. + } + } + + if (lastFocus != null) { + try { + //Log.i(TAG, "Losing focus: " + lastFocus); + lastFocus.mClient.windowFocusChanged(false, mInTouchMode); + } catch (RemoteException e) { + // Ignore if process has died. + } + } + } + } break; + + case REPORT_LOSING_FOCUS: { + ArrayList<WindowState> losers; + + synchronized(mWindowMap) { + losers = mLosingFocus; + mLosingFocus = new ArrayList<WindowState>(); + } + + final int N = losers.size(); + for (int i=0; i<N; i++) { + try { + //Log.i(TAG, "Losing delayed focus: " + losers.get(i)); + losers.get(i).mClient.windowFocusChanged(false, mInTouchMode); + } catch (RemoteException e) { + // Ignore if process has died. + } + } + } break; + + case ANIMATE: { + synchronized(mWindowMap) { + mAnimationPending = false; + performLayoutAndPlaceSurfacesLocked(); + } + } break; + + case ADD_STARTING: { + final AppWindowToken wtoken = (AppWindowToken)msg.obj; + final StartingData sd = wtoken.startingData; + + if (sd == null) { + // Animation has been canceled... do nothing. + return; + } + + if (DEBUG_STARTING_WINDOW) Log.v(TAG, "Add starting " + + wtoken + ": pkg=" + sd.pkg); + + View view = null; + try { + view = mPolicy.addStartingWindow( + wtoken.token, sd.pkg, + sd.theme, sd.nonLocalizedLabel, sd.labelRes, + sd.icon); + } catch (Exception e) { + Log.w(TAG, "Exception when adding starting window", e); + } + + if (view != null) { + boolean abort = false; + + synchronized(mWindowMap) { + if (wtoken.removed || wtoken.startingData == null) { + // If the window was successfully added, then + // we need to remove it. + if (wtoken.startingWindow != null) { + if (DEBUG_STARTING_WINDOW) Log.v(TAG, + "Aborted starting " + wtoken + + ": removed=" + wtoken.removed + + " startingData=" + wtoken.startingData); + wtoken.startingWindow = null; + wtoken.startingData = null; + abort = true; + } + } else { + wtoken.startingView = view; + } + if (DEBUG_STARTING_WINDOW && !abort) Log.v(TAG, + "Added starting " + wtoken + + ": startingWindow=" + + wtoken.startingWindow + " startingView=" + + wtoken.startingView); + } + + if (abort) { + try { + mPolicy.removeStartingWindow(wtoken.token, view); + } catch (Exception e) { + Log.w(TAG, "Exception when removing starting window", e); + } + } + } + } break; + + case REMOVE_STARTING: { + final AppWindowToken wtoken = (AppWindowToken)msg.obj; + IBinder token = null; + View view = null; + synchronized (mWindowMap) { + if (DEBUG_STARTING_WINDOW) Log.v(TAG, "Remove starting " + + wtoken + ": startingWindow=" + + wtoken.startingWindow + " startingView=" + + wtoken.startingView); + if (wtoken.startingWindow != null) { + view = wtoken.startingView; + token = wtoken.token; + wtoken.startingData = null; + wtoken.startingView = null; + wtoken.startingWindow = null; + } + } + if (view != null) { + try { + mPolicy.removeStartingWindow(token, view); + } catch (Exception e) { + Log.w(TAG, "Exception when removing starting window", e); + } + } + } break; + + case FINISHED_STARTING: { + IBinder token = null; + View view = null; + while (true) { + synchronized (mWindowMap) { + final int N = mFinishedStarting.size(); + if (N <= 0) { + break; + } + AppWindowToken wtoken = mFinishedStarting.remove(N-1); + + if (DEBUG_STARTING_WINDOW) Log.v(TAG, + "Finished starting " + wtoken + + ": startingWindow=" + wtoken.startingWindow + + " startingView=" + wtoken.startingView); + + if (wtoken.startingWindow == null) { + continue; + } + + view = wtoken.startingView; + token = wtoken.token; + wtoken.startingData = null; + wtoken.startingView = null; + wtoken.startingWindow = null; + } + + try { + mPolicy.removeStartingWindow(token, view); + } catch (Exception e) { + Log.w(TAG, "Exception when removing starting window", e); + } + } + } break; + + case REPORT_APPLICATION_TOKEN_WINDOWS: { + final AppWindowToken wtoken = (AppWindowToken)msg.obj; + + boolean nowVisible = msg.arg1 != 0; + boolean nowGone = msg.arg2 != 0; + + try { + if (DEBUG_VISIBILITY) Log.v( + TAG, "Reporting visible in " + wtoken + + " visible=" + nowVisible + + " gone=" + nowGone); + if (nowVisible) { + wtoken.appToken.windowsVisible(); + } else { + wtoken.appToken.windowsGone(); + } + } catch (RemoteException ex) { + } + } break; + + case UPDATE_ORIENTATION: { + setRotationUnchecked(WindowManagerPolicy.USE_LAST_ROTATION, false); + break; + } + + case WINDOW_FREEZE_TIMEOUT: { + synchronized (mWindowMap) { + Log.w(TAG, "Window freeze timeout expired."); + int i = mWindows.size(); + while (i > 0) { + i--; + WindowState w = (WindowState)mWindows.get(i); + if (w.mOrientationChanging) { + w.mOrientationChanging = false; + Log.w(TAG, "Force clearing orientation change: " + w); + } + } + performLayoutAndPlaceSurfacesLocked(); + } + break; + } + + case HOLD_SCREEN_CHANGED: { + Session oldHold; + Session newHold; + synchronized (mWindowMap) { + oldHold = mLastReportedHold; + newHold = (Session)msg.obj; + mLastReportedHold = newHold; + } + + if (oldHold != newHold) { + try { + if (oldHold != null) { + mBatteryStats.noteStopWakelock(oldHold.mUid, + "window", + BatteryStats.WAKE_TYPE_WINDOW); + } + if (newHold != null) { + mBatteryStats.noteStartWakelock(newHold.mUid, + "window", + BatteryStats.WAKE_TYPE_WINDOW); + } + } catch (RemoteException e) { + } + } + break; + } + + case APP_TRANSITION_TIMEOUT: { + synchronized (mWindowMap) { + if (mNextAppTransition != WindowManagerPolicy.TRANSIT_NONE) { + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, + "*** APP TRANSITION TIMEOUT"); + mAppTransitionReady = true; + mAppTransitionTimeout = true; + performLayoutAndPlaceSurfacesLocked(); + } + } + break; + } + + case PERSIST_ANIMATION_SCALE: { + Settings.System.putFloat(mContext.getContentResolver(), + Settings.System.WINDOW_ANIMATION_SCALE, mWindowAnimationScale); + Settings.System.putFloat(mContext.getContentResolver(), + Settings.System.TRANSITION_ANIMATION_SCALE, mTransitionAnimationScale); + break; + } + + case FORCE_GC: { + synchronized(mWindowMap) { + if (mAnimationPending) { + // If we are animating, don't do the gc now but + // delay a bit so we don't interrupt the animation. + mH.sendMessageDelayed(mH.obtainMessage(H.FORCE_GC), + 2000); + return; + } + // If we are currently rotating the display, it will + // schedule a new message when done. + if (mDisplayFrozen) { + return; + } + mFreezeGcPending = 0; + } + Runtime.getRuntime().gc(); + break; + } + + case ENABLE_SCREEN: { + performEnableScreen(); + break; + } + + case APP_FREEZE_TIMEOUT: { + synchronized (mWindowMap) { + Log.w(TAG, "App freeze timeout expired."); + int i = mAppTokens.size(); + while (i > 0) { + i--; + AppWindowToken tok = mAppTokens.get(i); + if (tok.freezingScreen) { + Log.w(TAG, "Force clearing freeze: " + tok); + unsetAppFreezingScreenLocked(tok, true, true); + } + } + } + break; + } + + } + } + } + + // ------------------------------------------------------------- + // IWindowManager API + // ------------------------------------------------------------- + + public IWindowSession openSession(IInputMethodClient client, + IInputContext inputContext) { + if (client == null) throw new IllegalArgumentException("null client"); + if (inputContext == null) throw new IllegalArgumentException("null inputContext"); + return new Session(client, inputContext); + } + + public boolean inputMethodClientHasFocus(IInputMethodClient client) { + synchronized (mWindowMap) { + // The focus for the client is the window immediately below + // where we would place the input method window. + int idx = findDesiredInputMethodWindowIndexLocked(false); + WindowState imFocus; + if (idx > 0) { + imFocus = (WindowState)mWindows.get(idx-1); + if (imFocus != null) { + if (imFocus.mSession.mClient != null && + imFocus.mSession.mClient.asBinder() == client.asBinder()) { + return true; + } + } + } + } + return false; + } + + // ------------------------------------------------------------- + // Internals + // ------------------------------------------------------------- + + final WindowState windowForClientLocked(Session session, IWindow client) { + return windowForClientLocked(session, client.asBinder()); + } + + final WindowState windowForClientLocked(Session session, IBinder client) { + WindowState win = mWindowMap.get(client); + if (localLOGV) Log.v( + TAG, "Looking up client " + client + ": " + win); + if (win == null) { + RuntimeException ex = new RuntimeException(); + Log.w(TAG, "Requested window " + client + " does not exist", ex); + return null; + } + if (session != null && win.mSession != session) { + RuntimeException ex = new RuntimeException(); + Log.w(TAG, "Requested window " + client + " is in session " + + win.mSession + ", not " + session, ex); + return null; + } + + return win; + } + + private final void assignLayersLocked() { + int N = mWindows.size(); + int curBaseLayer = 0; + int curLayer = 0; + int i; + + for (i=0; i<N; i++) { + WindowState w = (WindowState)mWindows.get(i); + if (w.mBaseLayer == curBaseLayer || w.mIsImWindow) { + curLayer += WINDOW_LAYER_MULTIPLIER; + w.mLayer = curLayer; + } else { + curBaseLayer = curLayer = w.mBaseLayer; + w.mLayer = curLayer; + } + if (w.mTargetAppToken != null) { + w.mAnimLayer = w.mLayer + w.mTargetAppToken.animLayerAdjustment; + } else if (w.mAppToken != null) { + w.mAnimLayer = w.mLayer + w.mAppToken.animLayerAdjustment; + } else { + w.mAnimLayer = w.mLayer; + } + if (w.mIsImWindow) { + w.mAnimLayer += mInputMethodAnimLayerAdjustment; + } + if (DEBUG_LAYERS) Log.v(TAG, "Assign layer " + w + ": " + + w.mAnimLayer); + //System.out.println( + // "Assigned layer " + curLayer + " to " + w.mClient.asBinder()); + } + } + + private boolean mInLayout = false; + private final void performLayoutAndPlaceSurfacesLocked() { + if (mInLayout) { + if (Config.DEBUG) { + throw new RuntimeException("Recursive call!"); + } + Log.w(TAG, "performLayoutAndPlaceSurfacesLocked called while in layout"); + return; + } + + boolean recoveringMemory = false; + if (mForceRemoves != null) { + recoveringMemory = true; + // Wait a little it for things to settle down, and off we go. + for (int i=0; i<mForceRemoves.size(); i++) { + WindowState ws = mForceRemoves.get(i); + Log.i(TAG, "Force removing: " + ws); + removeWindowInnerLocked(ws.mSession, ws); + } + mForceRemoves = null; + Log.w(TAG, "Due to memory failure, waiting a bit for next layout"); + Object tmp = new Object(); + synchronized (tmp) { + try { + tmp.wait(250); + } catch (InterruptedException e) { + } + } + } + + mInLayout = true; + try { + performLayoutAndPlaceSurfacesLockedInner(recoveringMemory); + + int i = mPendingRemove.size()-1; + if (i >= 0) { + while (i >= 0) { + WindowState w = mPendingRemove.get(i); + removeWindowInnerLocked(w.mSession, w); + i--; + } + mPendingRemove.clear(); + + mInLayout = false; + assignLayersLocked(); + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + + } else { + mInLayout = false; + if (mLayoutNeeded) { + requestAnimationLocked(0); + } + } + } catch (RuntimeException e) { + mInLayout = false; + Log.e(TAG, "Unhandled exception while layout out windows", e); + } + } + + private final void performLayoutLockedInner() { + final int dw = mDisplay.getWidth(); + final int dh = mDisplay.getHeight(); + + final int N = mWindows.size(); + int i; + + // FIRST LOOP: Perform a layout, if needed. + + if (mLayoutNeeded) { + mPolicy.beginLayoutLw(dw, dh); + + // First perform layout of any root windows (not attached + // to another window). + int topAttached = -1; + for (i = N-1; i >= 0; i--) { + WindowState win = (WindowState) mWindows.get(i); + + boolean gone = win.mViewVisibility == View.GONE + || !win.mRelayoutCalled + || win.mToken.hidden; + + // If this view is GONE, then skip it -- keep the current + // frame, and let the caller know so they can ignore it + // if they want. (We do the normal layout for INVISIBLE + // windows, since that means "perform layout as normal, + // just don't display"). + if (!gone || !win.mHaveFrame) { + if (!win.mLayoutAttached) { + mPolicy.layoutWindowLw(win, win.mAttrs, null); + } else { + if (topAttached < 0) topAttached = i; + } + } + } + + // Now perform layout of attached windows, which usually + // depend on the position of the window they are attached to. + // XXX does not deal with windows that are attached to windows + // that are themselves attached. + for (i = topAttached; i >= 0; i--) { + WindowState win = (WindowState) mWindows.get(i); + + // If this view is GONE, then skip it -- keep the current + // frame, and let the caller know so they can ignore it + // if they want. (We do the normal layout for INVISIBLE + // windows, since that means "perform layout as normal, + // just don't display"). + if (win.mLayoutAttached) { + if ((win.mViewVisibility != View.GONE && win.mRelayoutCalled) + || !win.mHaveFrame) { + mPolicy.layoutWindowLw(win, win.mAttrs, win.mAttachedWindow); + } + } + } + + mPolicy.finishLayoutLw(); + mLayoutNeeded = false; + } + } + + private final void performLayoutAndPlaceSurfacesLockedInner( + boolean recoveringMemory) { + final long currentTime = SystemClock.uptimeMillis(); + final int dw = mDisplay.getWidth(); + final int dh = mDisplay.getHeight(); + + final int N = mWindows.size(); + int i; + + // FIRST LOOP: Perform a layout, if needed. + + performLayoutLockedInner(); + + if (mFxSession == null) { + mFxSession = new SurfaceSession(); + } + + if (SHOW_TRANSACTIONS) Log.i(TAG, ">>> OPEN TRANSACTION"); + + // Initialize state of exiting tokens. + for (i=mExitingTokens.size()-1; i>=0; i--) { + mExitingTokens.get(i).hasVisible = false; + } + + // Initialize state of exiting applications. + for (i=mExitingAppTokens.size()-1; i>=0; i--) { + mExitingAppTokens.get(i).hasVisible = false; + } + + // SECOND LOOP: Execute animations and update visibility of windows. + + boolean orientationChangeComplete = true; + Session holdScreen = null; + float screenBrightness = -1; + boolean focusDisplayed = false; + boolean animating = false; + + Surface.openTransaction(); + try { + boolean restart; + + do { + final int transactionSequence = ++mTransactionSequence; + + // Update animations of all applications, including those + // associated with exiting/removed apps + boolean tokensAnimating = false; + final int NAT = mAppTokens.size(); + for (i=0; i<NAT; i++) { + if (mAppTokens.get(i).stepAnimationLocked(currentTime, dw, dh)) { + tokensAnimating = true; + } + } + final int NEAT = mExitingAppTokens.size(); + for (i=0; i<NEAT; i++) { + if (mExitingAppTokens.get(i).stepAnimationLocked(currentTime, dw, dh)) { + tokensAnimating = true; + } + } + + animating = tokensAnimating; + restart = false; + + boolean tokenMayBeDrawn = false; + + mPolicy.beginAnimationLw(dw, dh); + + for (i=N-1; i>=0; i--) { + WindowState w = (WindowState)mWindows.get(i); + + final WindowManager.LayoutParams attrs = w.mAttrs; + + if (w.mSurface != null) { + // Execute animation. + w.commitFinishDrawingLocked(currentTime); + if (w.stepAnimationLocked(currentTime, dw, dh)) { + animating = true; + //w.dump(" "); + } + + mPolicy.animatingWindowLw(w, attrs); + } + + final AppWindowToken atoken = w.mAppToken; + if (atoken != null && (!atoken.allDrawn || atoken.freezingScreen)) { + if (atoken.lastTransactionSequence != transactionSequence) { + atoken.lastTransactionSequence = transactionSequence; + atoken.numInterestingWindows = atoken.numDrawnWindows = 0; + atoken.startingDisplayed = false; + } + if ((w.isOnScreen() || w.mAttrs.type + == WindowManager.LayoutParams.TYPE_BASE_APPLICATION) + && !w.mExiting && !w.mDestroying) { + if (DEBUG_VISIBILITY || DEBUG_ORIENTATION) { + Log.v(TAG, "Eval win " + w + ": isDisplayed=" + + w.isDisplayedLw() + + ", isAnimating=" + w.isAnimating()); + if (!w.isDisplayedLw()) { + Log.v(TAG, "Not displayed: s=" + w.mSurface + + " pv=" + w.mPolicyVisibility + + " dp=" + w.mDrawPending + + " cdp=" + w.mCommitDrawPending + + " ah=" + w.mAttachedHidden + + " th=" + atoken.hiddenRequested + + " a=" + w.mAnimating); + } + } + if (w != atoken.startingWindow) { + if (!atoken.freezingScreen || !w.mAppFreezing) { + atoken.numInterestingWindows++; + if (w.isDisplayedLw()) { + atoken.numDrawnWindows++; + if (DEBUG_VISIBILITY || DEBUG_ORIENTATION) Log.v(TAG, + "tokenMayBeDrawn: " + atoken + + " freezingScreen=" + atoken.freezingScreen + + " mAppFreezing=" + w.mAppFreezing); + tokenMayBeDrawn = true; + } + } + } else if (w.isDisplayedLw()) { + atoken.startingDisplayed = true; + } + } + } else if (w.mReadyToShow) { + w.performShowLocked(); + } + } + + if (mPolicy.finishAnimationLw()) { + restart = true; + } + + if (tokenMayBeDrawn) { + // See if any windows have been drawn, so they (and others + // associated with them) can now be shown. + final int NT = mTokenList.size(); + for (i=0; i<NT; i++) { + AppWindowToken wtoken = mTokenList.get(i).appWindowToken; + if (wtoken == null) { + continue; + } + if (wtoken.freezingScreen) { + int numInteresting = wtoken.numInterestingWindows; + if (numInteresting > 0 && wtoken.numDrawnWindows >= numInteresting) { + if (DEBUG_VISIBILITY) Log.v(TAG, + "allDrawn: " + wtoken + + " interesting=" + numInteresting + + " drawn=" + wtoken.numDrawnWindows); + wtoken.showAllWindowsLocked(); + unsetAppFreezingScreenLocked(wtoken, false, true); + orientationChangeComplete = true; + } + } else if (!wtoken.allDrawn) { + int numInteresting = wtoken.numInterestingWindows; + if (numInteresting > 0 && wtoken.numDrawnWindows >= numInteresting) { + if (DEBUG_VISIBILITY) Log.v(TAG, + "allDrawn: " + wtoken + + " interesting=" + numInteresting + + " drawn=" + wtoken.numDrawnWindows); + wtoken.allDrawn = true; + restart = true; + + // We can now show all of the drawn windows! + if (!mOpeningApps.contains(wtoken)) { + wtoken.showAllWindowsLocked(); + } + } + } + } + } + + // If we are ready to perform an app transition, check through + // all of the app tokens to be shown and see if they are ready + // to go. + if (mAppTransitionReady) { + int NN = mOpeningApps.size(); + boolean goodToGo = true; + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, + "Checking " + NN + " opening apps (frozen=" + + mDisplayFrozen + " timeout=" + + mAppTransitionTimeout + ")..."); + if (!mDisplayFrozen && !mAppTransitionTimeout) { + // If the display isn't frozen, wait to do anything until + // all of the apps are ready. Otherwise just go because + // we'll unfreeze the display when everyone is ready. + for (i=0; i<NN && goodToGo; i++) { + AppWindowToken wtoken = mOpeningApps.get(i); + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, + "Check opening app" + wtoken + ": allDrawn=" + + wtoken.allDrawn + " startingDisplayed=" + + wtoken.startingDisplayed); + if (!wtoken.allDrawn && !wtoken.startingDisplayed + && !wtoken.startingMoved) { + goodToGo = false; + } + } + } + if (goodToGo) { + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, "**** GOOD TO GO"); + int transit = mNextAppTransition; + if (mSkipAppTransitionAnimation) { + transit = WindowManagerPolicy.TRANSIT_NONE; + } + mNextAppTransition = WindowManagerPolicy.TRANSIT_NONE; + mAppTransitionReady = false; + mAppTransitionTimeout = false; + mStartingIconInTransition = false; + mSkipAppTransitionAnimation = false; + + mH.removeMessages(H.APP_TRANSITION_TIMEOUT); + + // We need to figure out which animation to use... + WindowManager.LayoutParams lp = findAnimations(mAppTokens, + mOpeningApps, mClosingApps); + + NN = mOpeningApps.size(); + for (i=0; i<NN; i++) { + AppWindowToken wtoken = mOpeningApps.get(i); + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, + "Now opening app" + wtoken); + wtoken.reportedVisible = false; + wtoken.inPendingTransaction = false; + setTokenVisibilityLocked(wtoken, lp, true, transit, false); + wtoken.updateReportedVisibilityLocked(); + wtoken.showAllWindowsLocked(); + } + NN = mClosingApps.size(); + for (i=0; i<NN; i++) { + AppWindowToken wtoken = mClosingApps.get(i); + if (DEBUG_APP_TRANSITIONS) Log.v(TAG, + "Now closing app" + wtoken); + wtoken.inPendingTransaction = false; + setTokenVisibilityLocked(wtoken, lp, false, transit, false); + wtoken.updateReportedVisibilityLocked(); + // Force the allDrawn flag, because we want to start + // this guy's animations regardless of whether it's + // gotten drawn. + wtoken.allDrawn = true; + } + + mOpeningApps.clear(); + mClosingApps.clear(); + + // This has changed the visibility of windows, so perform + // a new layout to get them all up-to-date. + mLayoutNeeded = true; + moveInputMethodWindowsIfNeededLocked(true); + performLayoutLockedInner(); + updateFocusedWindowLocked(UPDATE_FOCUS_PLACING_SURFACES); + + restart = true; + } + } + } while (restart); + + // THIRD LOOP: Update the surfaces of all windows. + + final boolean someoneLosingFocus = mLosingFocus.size() != 0; + + boolean obscured = false; + boolean blurring = false; + boolean dimming = false; + boolean covered = false; + + for (i=N-1; i>=0; i--) { + WindowState w = (WindowState)mWindows.get(i); + + boolean displayed = false; + final WindowManager.LayoutParams attrs = w.mAttrs; + final int attrFlags = attrs.flags; + + if (w.mSurface != null) { + w.computeShownFrameLocked(); + if (localLOGV) Log.v( + TAG, "Placing surface #" + i + " " + w.mSurface + + ": new=" + w.mShownFrame + ", old=" + + w.mLastShownFrame); + + boolean resize; + int width, height; + if ((w.mAttrs.flags & w.mAttrs.FLAG_SCALED) != 0) { + resize = w.mLastRequestedWidth != w.mRequestedWidth || + w.mLastRequestedHeight != w.mRequestedHeight; + // for a scaled surface, we just want to use + // the requested size. + width = w.mRequestedWidth; + height = w.mRequestedHeight; + w.mLastRequestedWidth = width; + w.mLastRequestedHeight = height; + w.mLastShownFrame.set(w.mShownFrame); + try { + w.mSurface.setPosition(w.mShownFrame.left, w.mShownFrame.top); + } catch (RuntimeException e) { + Log.w(TAG, "Error positioning surface in " + w, e); + if (!recoveringMemory) { + reclaimSomeSurfaceMemoryLocked(w, "position"); + } + } + } else { + resize = !w.mLastShownFrame.equals(w.mShownFrame); + width = w.mShownFrame.width(); + height = w.mShownFrame.height(); + w.mLastShownFrame.set(w.mShownFrame); + if (resize) { + if (SHOW_TRANSACTIONS) Log.i( + TAG, " SURFACE " + w.mSurface + ": (" + + w.mShownFrame.left + "," + + w.mShownFrame.top + ") (" + + w.mShownFrame.width() + "x" + + w.mShownFrame.height() + ")"); + } + } + + if (resize) { + if (width < 1) width = 1; + if (height < 1) height = 1; + if (w.mSurface != null) { + try { + w.mSurface.setSize(width, height); + w.mSurface.setPosition(w.mShownFrame.left, + w.mShownFrame.top); + } catch (RuntimeException e) { + // If something goes wrong with the surface (such + // as running out of memory), don't take down the + // entire system. + Log.e(TAG, "Failure updating surface of " + w + + "size=(" + width + "x" + height + + "), pos=(" + w.mShownFrame.left + + "," + w.mShownFrame.top + ")", e); + if (!recoveringMemory) { + reclaimSomeSurfaceMemoryLocked(w, "size"); + } + } + } + } + if (!w.mAppFreezing) { + w.mContentInsetsChanged = + !w.mLastContentInsets.equals(w.mContentInsets); + w.mVisibleInsetsChanged = + !w.mLastVisibleInsets.equals(w.mVisibleInsets); + if (!w.mLastFrame.equals(w.mFrame) + || w.mContentInsetsChanged + || w.mVisibleInsetsChanged) { + w.mLastFrame.set(w.mFrame); + w.mLastContentInsets.set(w.mContentInsets); + w.mLastVisibleInsets.set(w.mVisibleInsets); + // If the orientation is changing, then we need to + // hold off on unfreezing the display until this + // window has been redrawn; to do that, we need + // to go through the process of getting informed + // by the application when it has finished drawing. + if (w.mOrientationChanging) { + if (DEBUG_ORIENTATION) Log.v(TAG, + "Orientation start waiting for draw in " + + w + ", surface " + w.mSurface); + w.mDrawPending = true; + w.mCommitDrawPending = false; + w.mReadyToShow = false; + if (w.mAppToken != null) { + w.mAppToken.allDrawn = false; + } + } + if (DEBUG_ORIENTATION) Log.v(TAG, + "Resizing window " + w + " to " + w.mFrame); + mResizingWindows.add(w); + } else if (w.mOrientationChanging) { + if (!w.mDrawPending && !w.mCommitDrawPending) { + if (DEBUG_ORIENTATION) Log.v(TAG, + "Orientation not waiting for draw in " + + w + ", surface " + w.mSurface); + w.mOrientationChanging = false; + } + } + } + + if (w.mAttachedHidden) { + if (!w.mLastHidden) { + //dump(); + w.mLastHidden = true; + if (SHOW_TRANSACTIONS) Log.i( + TAG, " SURFACE " + w.mSurface + ": HIDE (performLayout-attached)"); + if (w.mSurface != null) { + try { + w.mSurface.hide(); + } catch (RuntimeException e) { + Log.w(TAG, "Exception hiding surface in " + w); + } + } + mKeyWaiter.releasePendingPointerLocked(w.mSession); + } + // If we are waiting for this window to handle an + // orientation change, well, it is hidden, so + // doesn't really matter. Note that this does + // introduce a potential glitch if the window + // becomes unhidden before it has drawn for the + // new orientation. + if (w.mOrientationChanging) { + w.mOrientationChanging = false; + if (DEBUG_ORIENTATION) Log.v(TAG, + "Orientation change skips hidden " + w); + } + } else if (!w.isReadyForDisplay()) { + if (!w.mLastHidden) { + //dump(); + w.mLastHidden = true; + if (SHOW_TRANSACTIONS) Log.i( + TAG, " SURFACE " + w.mSurface + ": HIDE (performLayout-ready)"); + if (w.mSurface != null) { + try { + w.mSurface.hide(); + } catch (RuntimeException e) { + Log.w(TAG, "Exception exception hiding surface in " + w); + } + } + mKeyWaiter.releasePendingPointerLocked(w.mSession); + } + // If we are waiting for this window to handle an + // orientation change, well, it is hidden, so + // doesn't really matter. Note that this does + // introduce a potential glitch if the window + // becomes unhidden before it has drawn for the + // new orientation. + if (w.mOrientationChanging) { + w.mOrientationChanging = false; + if (DEBUG_ORIENTATION) Log.v(TAG, + "Orientation change skips hidden " + w); + } + } else if (w.mLastLayer != w.mAnimLayer + || w.mLastAlpha != w.mShownAlpha + || w.mLastDsDx != w.mDsDx + || w.mLastDtDx != w.mDtDx + || w.mLastDsDy != w.mDsDy + || w.mLastDtDy != w.mDtDy + || w.mLastHScale != w.mHScale + || w.mLastVScale != w.mVScale + || w.mLastHidden) { + displayed = true; + w.mLastAlpha = w.mShownAlpha; + w.mLastLayer = w.mAnimLayer; + w.mLastDsDx = w.mDsDx; + w.mLastDtDx = w.mDtDx; + w.mLastDsDy = w.mDsDy; + w.mLastDtDy = w.mDtDy; + w.mLastHScale = w.mHScale; + w.mLastVScale = w.mVScale; + if (SHOW_TRANSACTIONS) Log.i( + TAG, " SURFACE " + w.mSurface + ": alpha=" + + w.mShownAlpha + " layer=" + w.mAnimLayer); + if (w.mSurface != null) { + try { + w.mSurface.setAlpha(w.mShownAlpha); + w.mSurface.setLayer(w.mAnimLayer); + w.mSurface.setMatrix( + w.mDsDx*w.mHScale, w.mDtDx*w.mVScale, + w.mDsDy*w.mHScale, w.mDtDy*w.mVScale); + } catch (RuntimeException e) { + Log.w(TAG, "Error updating surface in " + w, e); + if (!recoveringMemory) { + reclaimSomeSurfaceMemoryLocked(w, "update"); + } + } + } + + if (w.mLastHidden && !w.mDrawPending + && !w.mCommitDrawPending + && !w.mReadyToShow) { + if (SHOW_TRANSACTIONS) Log.i( + TAG, " SURFACE " + w.mSurface + ": SHOW (performLayout)"); + if (DEBUG_VISIBILITY) Log.v(TAG, "Showing " + w + + " during relayout"); + if (showSurfaceRobustlyLocked(w)) { + w.mHasDrawn = true; + w.mLastHidden = false; + } else { + w.mOrientationChanging = false; + } + } + if (w.mSurface != null) { + w.mToken.hasVisible = true; + } + } else { + displayed = true; + } + + if (displayed) { + if (!covered) { + if (attrs.width == LayoutParams.FILL_PARENT + && attrs.height == LayoutParams.FILL_PARENT) { + covered = true; + } + } + if (w.mOrientationChanging) { + if (w.mDrawPending || w.mCommitDrawPending) { + orientationChangeComplete = false; + if (DEBUG_ORIENTATION) Log.v(TAG, + "Orientation continue waiting for draw in " + w); + } else { + w.mOrientationChanging = false; + if (DEBUG_ORIENTATION) Log.v(TAG, + "Orientation change complete in " + w); + } + } + w.mToken.hasVisible = true; + } + } else if (w.mOrientationChanging) { + if (DEBUG_ORIENTATION) Log.v(TAG, + "Orientation change skips hidden " + w); + w.mOrientationChanging = false; + } + + final boolean canBeSeen = w.isDisplayedLw(); + + if (someoneLosingFocus && w == mCurrentFocus && canBeSeen) { + focusDisplayed = true; + } + + // Update effect. + if (!obscured) { + if (w.mSurface != null) { + if ((attrFlags&FLAG_KEEP_SCREEN_ON) != 0) { + holdScreen = w.mSession; + } + if (w.mAttrs.screenBrightness >= 0 && screenBrightness < 0) { + screenBrightness = w.mAttrs.screenBrightness; + } + } + if (w.isFullscreenOpaque(dw, dh)) { + // This window completely covers everything behind it, + // so we want to leave all of them as unblurred (for + // performance reasons). + obscured = true; + } else if (canBeSeen && !obscured && + (attrFlags&FLAG_BLUR_BEHIND|FLAG_DIM_BEHIND) != 0) { + if (localLOGV) Log.v(TAG, "Win " + w + + ": blurring=" + blurring + + " obscured=" + obscured + + " displayed=" + displayed); + if ((attrFlags&FLAG_DIM_BEHIND) != 0) { + if (!dimming) { + //Log.i(TAG, "DIM BEHIND: " + w); + dimming = true; + mDimShown = true; + if (mDimSurface == null) { + if (SHOW_TRANSACTIONS) Log.i(TAG, " DIM " + + mDimSurface + ": CREATE"); + try { + mDimSurface = new Surface(mFxSession, 0, + -1, 16, 16, + PixelFormat.OPAQUE, + Surface.FX_SURFACE_DIM); + } catch (Exception e) { + Log.e(TAG, "Exception creating Dim surface", e); + } + } + if (SHOW_TRANSACTIONS) Log.i(TAG, " DIM " + + mDimSurface + ": SHOW pos=(0,0) (" + + dw + "x" + dh + "), layer=" + (w.mAnimLayer-1)); + if (mDimSurface != null) { + try { + mDimSurface.setPosition(0, 0); + mDimSurface.setSize(dw, dh); + mDimSurface.show(); + } catch (RuntimeException e) { + Log.w(TAG, "Failure showing dim surface", e); + } + } + } + mDimSurface.setLayer(w.mAnimLayer-1); + final float target = w.mExiting ? 0 : attrs.dimAmount; + if (mDimTargetAlpha != target) { + // If the desired dim level has changed, then + // start an animation to it. + mLastDimAnimTime = currentTime; + long duration = (w.mAnimating && w.mAnimation != null) + ? w.mAnimation.computeDurationHint() + : DEFAULT_DIM_DURATION; + if (target > mDimTargetAlpha) { + // This is happening behind the activity UI, + // so we can make it run a little longer to + // give a stronger impression without disrupting + // the user. + duration *= DIM_DURATION_MULTIPLIER; + } + if (duration < 1) { + // Don't divide by zero + duration = 1; + } + mDimTargetAlpha = target; + mDimDeltaPerMs = (mDimTargetAlpha-mDimCurrentAlpha) + / duration; + } + } + if ((attrFlags&FLAG_BLUR_BEHIND) != 0) { + if (!blurring) { + //Log.i(TAG, "BLUR BEHIND: " + w); + blurring = true; + mBlurShown = true; + if (mBlurSurface == null) { + if (SHOW_TRANSACTIONS) Log.i(TAG, " BLUR " + + mBlurSurface + ": CREATE"); + try { + mBlurSurface = new Surface(mFxSession, 0, + -1, 16, 16, + PixelFormat.OPAQUE, + Surface.FX_SURFACE_BLUR); + } catch (Exception e) { + Log.e(TAG, "Exception creating Blur surface", e); + } + } + if (SHOW_TRANSACTIONS) Log.i(TAG, " BLUR " + + mBlurSurface + ": SHOW pos=(0,0) (" + + dw + "x" + dh + "), layer=" + (w.mAnimLayer-1)); + if (mBlurSurface != null) { + mBlurSurface.setPosition(0, 0); + mBlurSurface.setSize(dw, dh); + try { + mBlurSurface.show(); + } catch (RuntimeException e) { + Log.w(TAG, "Failure showing blur surface", e); + } + } + } + mBlurSurface.setLayer(w.mAnimLayer-2); + } + } + } + } + + if (!dimming && mDimShown) { + // Time to hide the dim surface... start fading. + if (mDimTargetAlpha != 0) { + mLastDimAnimTime = currentTime; + mDimTargetAlpha = 0; + mDimDeltaPerMs = (-mDimCurrentAlpha) / DEFAULT_DIM_DURATION; + } + } + + if (mDimShown && mLastDimAnimTime != 0) { + mDimCurrentAlpha += mDimDeltaPerMs + * (currentTime-mLastDimAnimTime); + boolean more = true; + if (mDisplayFrozen) { + // If the display is frozen, there is no reason to animate. + more = false; + } else if (mDimDeltaPerMs > 0) { + if (mDimCurrentAlpha > mDimTargetAlpha) { + more = false; + } + } else if (mDimDeltaPerMs < 0) { + if (mDimCurrentAlpha < mDimTargetAlpha) { + more = false; + } + } else { + more = false; + } + + // Do we need to continue animating? + if (more) { + if (SHOW_TRANSACTIONS) Log.i(TAG, " DIM " + + mDimSurface + ": alpha=" + mDimCurrentAlpha); + mLastDimAnimTime = currentTime; + mDimSurface.setAlpha(mDimCurrentAlpha); + animating = true; + } else { + mDimCurrentAlpha = mDimTargetAlpha; + mLastDimAnimTime = 0; + if (SHOW_TRANSACTIONS) Log.i(TAG, " DIM " + + mDimSurface + ": final alpha=" + mDimCurrentAlpha); + mDimSurface.setAlpha(mDimCurrentAlpha); + if (!dimming) { + if (SHOW_TRANSACTIONS) Log.i(TAG, " DIM " + mDimSurface + + ": HIDE"); + try { + mDimSurface.hide(); + } catch (RuntimeException e) { + Log.w(TAG, "Illegal argument exception hiding dim surface"); + } + mDimShown = false; + } + } + } + + if (!blurring && mBlurShown) { + if (SHOW_TRANSACTIONS) Log.i(TAG, " BLUR " + mBlurSurface + + ": HIDE"); + try { + mBlurSurface.hide(); + } catch (IllegalArgumentException e) { + Log.w(TAG, "Illegal argument exception hiding blur surface"); + } + mBlurShown = false; + } + + if (SHOW_TRANSACTIONS) Log.i(TAG, "<<< CLOSE TRANSACTION"); + } catch (RuntimeException e) { + Log.e(TAG, "Unhandled exception in Window Manager", e); + } + + Surface.closeTransaction(); + + if (DEBUG_ORIENTATION && mDisplayFrozen) Log.v(TAG, + "With display frozen, orientationChangeComplete=" + + orientationChangeComplete); + if (orientationChangeComplete) { + if (mWindowsFreezingScreen) { + mWindowsFreezingScreen = false; + mH.removeMessages(H.WINDOW_FREEZE_TIMEOUT); + } + if (mAppsFreezingScreen == 0) { + stopFreezingDisplayLocked(); + } + } + + i = mResizingWindows.size(); + if (i > 0) { + do { + i--; + WindowState win = mResizingWindows.get(i); + try { + win.mClient.resized(win.mFrame.width(), + win.mFrame.height(), win.mLastContentInsets, + win.mLastVisibleInsets, win.mDrawPending); + win.mContentInsetsChanged = false; + win.mVisibleInsetsChanged = false; + } catch (RemoteException e) { + win.mOrientationChanging = false; + } + } while (i > 0); + mResizingWindows.clear(); + } + + // Destroy the surface of any windows that are no longer visible. + i = mDestroySurface.size(); + if (i > 0) { + do { + i--; + WindowState win = mDestroySurface.get(i); + win.mDestroying = false; + if (mInputMethodWindow == win) { + mInputMethodWindow = null; + } + win.destroySurfaceLocked(); + } while (i > 0); + mDestroySurface.clear(); + } + + // Time to remove any exiting tokens? + for (i=mExitingTokens.size()-1; i>=0; i--) { + WindowToken token = mExitingTokens.get(i); + if (!token.hasVisible) { + mExitingTokens.remove(i); + } + } + + // Time to remove any exiting applications? + for (i=mExitingAppTokens.size()-1; i>=0; i--) { + AppWindowToken token = mExitingAppTokens.get(i); + if (!token.hasVisible && !mClosingApps.contains(token)) { + mAppTokens.remove(token); + mExitingAppTokens.remove(i); + } + } + + if (focusDisplayed) { + mH.sendEmptyMessage(H.REPORT_LOSING_FOCUS); + } + if (animating) { + requestAnimationLocked(currentTime+(1000/60)-SystemClock.uptimeMillis()); + } + mQueue.setHoldScreenLocked(holdScreen != null); + if (screenBrightness < 0 || screenBrightness > 1.0f) { + mPowerManager.setScreenBrightnessOverride(-1); + } else { + mPowerManager.setScreenBrightnessOverride((int) + (screenBrightness * Power.BRIGHTNESS_ON)); + } + if (holdScreen != mHoldingScreenOn) { + mHoldingScreenOn = holdScreen; + Message m = mH.obtainMessage(H.HOLD_SCREEN_CHANGED, holdScreen); + mH.sendMessage(m); + } + } + + void requestAnimationLocked(long delay) { + if (!mAnimationPending) { + mAnimationPending = true; + mH.sendMessageDelayed(mH.obtainMessage(H.ANIMATE), delay); + } + } + + /** + * Have the surface flinger show a surface, robustly dealing with + * error conditions. In particular, if there is not enough memory + * to show the surface, then we will try to get rid of other surfaces + * in order to succeed. + * + * @return Returns true if the surface was successfully shown. + */ + boolean showSurfaceRobustlyLocked(WindowState win) { + try { + if (win.mSurface != null) { + win.mSurface.show(); + } + return true; + } catch (RuntimeException e) { + Log.w(TAG, "Failure showing surface " + win.mSurface + " in " + win); + } + + reclaimSomeSurfaceMemoryLocked(win, "show"); + + return false; + } + + void reclaimSomeSurfaceMemoryLocked(WindowState win, String operation) { + final Surface surface = win.mSurface; + + EventLog.writeEvent(LOG_WM_NO_SURFACE_MEMORY, win.toString(), + win.mSession.mPid, operation); + + if (mForceRemoves == null) { + mForceRemoves = new ArrayList<WindowState>(); + } + + long callingIdentity = Binder.clearCallingIdentity(); + try { + // There was some problem... first, do a sanity check of the + // window list to make sure we haven't left any dangling surfaces + // around. + int N = mWindows.size(); + boolean leakedSurface = false; + Log.i(TAG, "Out of memory for surface! Looking for leaks..."); + for (int i=0; i<N; i++) { + WindowState ws = (WindowState)mWindows.get(i); + if (ws.mSurface != null) { + if (!mSessions.contains(ws.mSession)) { + Log.w(TAG, "LEAKED SURFACE (session doesn't exist): " + + ws + " surface=" + ws.mSurface + + " token=" + win.mToken + + " pid=" + ws.mSession.mPid + + " uid=" + ws.mSession.mUid); + ws.mSurface.clear(); + ws.mSurface = null; + mForceRemoves.add(ws); + i--; + N--; + leakedSurface = true; + } else if (win.mAppToken != null && win.mAppToken.clientHidden) { + Log.w(TAG, "LEAKED SURFACE (app token hidden): " + + ws + " surface=" + ws.mSurface + + " token=" + win.mAppToken); + ws.mSurface.clear(); + ws.mSurface = null; + leakedSurface = true; + } + } + } + + boolean killedApps = false; + if (!leakedSurface) { + Log.w(TAG, "No leaked surfaces; killing applicatons!"); + SparseIntArray pidCandidates = new SparseIntArray(); + for (int i=0; i<N; i++) { + WindowState ws = (WindowState)mWindows.get(i); + if (ws.mSurface != null) { + pidCandidates.append(ws.mSession.mPid, ws.mSession.mPid); + } + } + if (pidCandidates.size() > 0) { + int[] pids = new int[pidCandidates.size()]; + for (int i=0; i<pids.length; i++) { + pids[i] = pidCandidates.keyAt(i); + } + try { + if (mActivityManager.killPidsForMemory(pids)) { + killedApps = true; + } + } catch (RemoteException e) { + } + } + } + + if (leakedSurface || killedApps) { + // We managed to reclaim some memory, so get rid of the trouble + // surface and ask the app to request another one. + Log.w(TAG, "Looks like we have reclaimed some memory, clearing surface for retry."); + if (surface != null) { + surface.clear(); + win.mSurface = null; + } + + try { + win.mClient.dispatchGetNewSurface(); + } catch (RemoteException e) { + } + } + } finally { + Binder.restoreCallingIdentity(callingIdentity); + } + } + + private boolean updateFocusedWindowLocked(int mode) { + WindowState newFocus = computeFocusedWindowLocked(); + if (mCurrentFocus != newFocus) { + // This check makes sure that we don't already have the focus + // change message pending. + mH.removeMessages(H.REPORT_FOCUS_CHANGE); + mH.sendEmptyMessage(H.REPORT_FOCUS_CHANGE); + if (localLOGV) Log.v( + TAG, "Changing focus from " + mCurrentFocus + " to " + newFocus); + final WindowState oldFocus = mCurrentFocus; + mCurrentFocus = newFocus; + mLosingFocus.remove(newFocus); + if (newFocus != null) { + mKeyWaiter.handleNewWindowLocked(newFocus); + } + + final WindowState imWindow = mInputMethodWindow; + if (newFocus != imWindow && oldFocus != imWindow) { + moveInputMethodWindowsIfNeededLocked( + mode != UPDATE_FOCUS_WILL_ASSIGN_LAYERS && + mode != UPDATE_FOCUS_WILL_PLACE_SURFACES); + mLayoutNeeded = true; + if (mode == UPDATE_FOCUS_PLACING_SURFACES) { + performLayoutLockedInner(); + } else if (mode != UPDATE_FOCUS_WILL_PLACE_SURFACES) { + mLayoutNeeded = true; + performLayoutAndPlaceSurfacesLocked(); + } + } + return true; + } + return false; + } + + private WindowState computeFocusedWindowLocked() { + WindowState result = null; + WindowState win; + + int i = mWindows.size() - 1; + int nextAppIndex = mAppTokens.size()-1; + WindowToken nextApp = nextAppIndex >= 0 + ? mAppTokens.get(nextAppIndex) : null; + + while (i >= 0) { + win = (WindowState)mWindows.get(i); + + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Looking for focus: " + i + + " = " + win + + ", flags=" + win.mAttrs.flags + + ", canReceive=" + win.canReceiveKeys()); + + AppWindowToken thisApp = win.mAppToken; + + // If this window's application has been removed, just skip it. + if (thisApp != null && thisApp.removed) { + i--; + continue; + } + + // If there is a focused app, don't allow focus to go to any + // windows below it. If this is an application window, step + // through the app tokens until we find its app. + if (thisApp != null && nextApp != null && thisApp != nextApp + && win.mAttrs.type != TYPE_APPLICATION_STARTING) { + int origAppIndex = nextAppIndex; + while (nextAppIndex > 0) { + if (nextApp == mFocusedApp) { + // Whoops, we are below the focused app... no focus + // for you! + if (localLOGV || DEBUG_FOCUS) Log.v( + TAG, "Reached focused app: " + mFocusedApp); + return null; + } + nextAppIndex--; + nextApp = mAppTokens.get(nextAppIndex); + if (nextApp == thisApp) { + break; + } + } + if (thisApp != nextApp) { + // Uh oh, the app token doesn't exist! This shouldn't + // happen, but if it does we can get totally hosed... + // so restart at the original app. + nextAppIndex = origAppIndex; + nextApp = mAppTokens.get(nextAppIndex); + } + } + + // Dispatch to this window if it is wants key events. + if (win.canReceiveKeys()) { + if (DEBUG_FOCUS) Log.v( + TAG, "Found focus @ " + i + " = " + win); + result = win; + break; + } + + i--; + } + + return result; + } + + private void startFreezingDisplayLocked() { + if (mDisplayFrozen) { + return; + } + + mScreenFrozenLock.acquire(); + + long now = SystemClock.uptimeMillis(); + //Log.i(TAG, "Freezing, gc pending: " + mFreezeGcPending + ", now " + now); + if (mFreezeGcPending != 0) { + if (now > (mFreezeGcPending+1000)) { + //Log.i(TAG, "Gc! " + now + " > " + (mFreezeGcPending+1000)); + mH.removeMessages(H.FORCE_GC); + Runtime.getRuntime().gc(); + mFreezeGcPending = now; + } + } else { + mFreezeGcPending = now; + } + + mDisplayFrozen = true; + if (mNextAppTransition != WindowManagerPolicy.TRANSIT_NONE) { + mNextAppTransition = WindowManagerPolicy.TRANSIT_NONE; + mAppTransitionReady = true; + } + + if (PROFILE_ORIENTATION) { + File file = new File("/data/system/frozen"); + Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024); + } + Surface.freezeDisplay(0); + } + + private void stopFreezingDisplayLocked() { + if (!mDisplayFrozen) { + return; + } + + mDisplayFrozen = false; + mH.removeMessages(H.APP_FREEZE_TIMEOUT); + if (PROFILE_ORIENTATION) { + Debug.stopMethodTracing(); + } + Surface.unfreezeDisplay(0); + + // Freezing the display also suspends key event delivery, to + // keep events from going astray while the display is reconfigured. + // Now that we're back, notify the key waiter that we're alive + // again and it should restart its timeouts. + synchronized (mKeyWaiter) { + mKeyWaiter.mWasFrozen = true; + mKeyWaiter.notifyAll(); + } + + // A little kludge: a lot could have happened while the + // display was frozen, so now that we are coming back we + // do a gc so that any remote references the system + // processes holds on others can be released if they are + // no longer needed. + mH.removeMessages(H.FORCE_GC); + mH.sendMessageDelayed(mH.obtainMessage(H.FORCE_GC), + 2000); + + mScreenFrozenLock.release(); + } + + @Override + public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission("android.permission.DUMP") + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump WindowManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + synchronized(mWindowMap) { + pw.println("Current Window Manager state:"); + for (int i=mWindows.size()-1; i>=0; i--) { + WindowState w = (WindowState)mWindows.get(i); + pw.println(" Window #" + i + ":"); + w.dump(pw, " "); + } + if (mInputMethodDialogs.size() > 0) { + pw.println(" "); + pw.println(" Input method dialogs:"); + for (int i=mInputMethodDialogs.size()-1; i>=0; i--) { + WindowState w = mInputMethodDialogs.get(i); + pw.println(" IM Dialog #" + i + ": " + w); + } + } + if (mPendingRemove.size() > 0) { + pw.println(" "); + pw.println(" Remove pending for:"); + for (int i=mPendingRemove.size()-1; i>=0; i--) { + WindowState w = mPendingRemove.get(i); + pw.println(" Remove #" + i + ":"); + w.dump(pw, " "); + } + } + if (mForceRemoves != null && mForceRemoves.size() > 0) { + pw.println(" "); + pw.println(" Windows force removing:"); + for (int i=mForceRemoves.size()-1; i>=0; i--) { + WindowState w = mForceRemoves.get(i); + pw.println(" Removing #" + i + ":"); + w.dump(pw, " "); + } + } + if (mDestroySurface.size() > 0) { + pw.println(" "); + pw.println(" Windows waiting to destroy their surface:"); + for (int i=mDestroySurface.size()-1; i>=0; i--) { + WindowState w = mDestroySurface.get(i); + pw.println(" Destroy #" + i + ":"); + w.dump(pw, " "); + } + } + if (mLosingFocus.size() > 0) { + pw.println(" "); + pw.println(" Windows losing focus:"); + for (int i=mLosingFocus.size()-1; i>=0; i--) { + WindowState w = mLosingFocus.get(i); + pw.println(" Losing #" + i + ":"); + w.dump(pw, " "); + } + } + if (mSessions.size() > 0) { + pw.println(" "); + pw.println(" All active sessions:"); + Iterator<Session> it = mSessions.iterator(); + while (it.hasNext()) { + Session s = it.next(); + pw.println(" Session " + s); + s.dump(pw, " "); + } + } + if (mTokenMap.size() > 0) { + pw.println(" "); + pw.println(" All tokens:"); + Iterator<WindowToken> it = mTokenMap.values().iterator(); + while (it.hasNext()) { + WindowToken token = it.next(); + pw.println(" Token " + token.token); + token.dump(pw, " "); + } + } + if (mTokenList.size() > 0) { + pw.println(" "); + pw.println(" Window token list:"); + for (int i=0; i<mTokenList.size(); i++) { + pw.println(" WindowToken #" + i + ": " + mTokenList.get(i)); + } + } + if (mAppTokens.size() > 0) { + pw.println(" "); + pw.println(" Application tokens in Z order:"); + for (int i=mAppTokens.size()-1; i>=0; i--) { + pw.println(" AppWindowToken #" + i + ": " + mAppTokens.get(i)); + } + } + if (mFinishedStarting.size() > 0) { + pw.println(" "); + pw.println(" Finishing start of application tokens:"); + for (int i=mFinishedStarting.size()-1; i>=0; i--) { + WindowToken token = mFinishedStarting.get(i); + pw.println(" Finish Starting App Token #" + i + ":"); + token.dump(pw, " "); + } + } + if (mExitingTokens.size() > 0) { + pw.println(" "); + pw.println(" Exiting tokens:"); + for (int i=mExitingTokens.size()-1; i>=0; i--) { + WindowToken token = mExitingTokens.get(i); + pw.println(" Exiting Token #" + i + ":"); + token.dump(pw, " "); + } + } + if (mExitingAppTokens.size() > 0) { + pw.println(" "); + pw.println(" Exiting application tokens:"); + for (int i=mExitingAppTokens.size()-1; i>=0; i--) { + WindowToken token = mExitingAppTokens.get(i); + pw.println(" Exiting App Token #" + i + ":"); + token.dump(pw, " "); + } + } + pw.println(" "); + pw.println(" mCurrentFocus=" + mCurrentFocus); + pw.println(" mLastFocus=" + mLastFocus); + pw.println(" mFocusedApp=" + mFocusedApp); + pw.println(" mInputMethodTarget=" + mInputMethodTarget); + pw.println(" mInputMethodWindow=" + mInputMethodWindow); + pw.println(" mInTouchMode=" + mInTouchMode); + pw.println(" mSystemBooted=" + mSystemBooted + + " mDisplayEnabled=" + mDisplayEnabled); + pw.println(" mLayoutNeeded=" + mLayoutNeeded + + " mBlurShown=" + mBlurShown); + pw.println(" mDimShown=" + mDimShown + + " current=" + mDimCurrentAlpha + + " target=" + mDimTargetAlpha + + " delta=" + mDimDeltaPerMs + + " lastAnimTime=" + mLastDimAnimTime); + pw.println(" mInputMethodAnimLayerAdjustment=" + + mInputMethodAnimLayerAdjustment); + pw.println(" mDisplayFrozen=" + mDisplayFrozen + + " mWindowsFreezingScreen=" + mWindowsFreezingScreen + + " mAppsFreezingScreen=" + mAppsFreezingScreen); + pw.println(" mRotation=" + mRotation + + ", mForcedAppOrientation=" + mForcedAppOrientation + + ", mRequestedRotation=" + mRequestedRotation); + pw.println(" mAnimationPending=" + mAnimationPending + + " mWindowAnimationScale=" + mWindowAnimationScale + + " mTransitionWindowAnimationScale=" + mTransitionAnimationScale); + pw.println(" mNextAppTransition=0x" + + Integer.toHexString(mNextAppTransition) + + ", mAppTransitionReady=" + mAppTransitionReady + + ", mAppTransitionTimeout=" + mAppTransitionTimeout); + pw.println(" mStartingIconInTransition=" + mStartingIconInTransition + + ", mSkipAppTransitionAnimation=" + mSkipAppTransitionAnimation); + pw.println(" mOpeningApps=" + mOpeningApps); + pw.println(" mClosingApps=" + mClosingApps); + pw.println(" DisplayWidth=" + mDisplay.getWidth() + + " DisplayHeight=" + mDisplay.getHeight()); + pw.println(" KeyWaiter state:"); + pw.println(" mLastWin=" + mKeyWaiter.mLastWin + + " mLastBinder=" + mKeyWaiter.mLastBinder); + pw.println(" mFinished=" + mKeyWaiter.mFinished + + " mGotFirstWindow=" + mKeyWaiter.mGotFirstWindow + + " mEventDispatching=" + mKeyWaiter.mEventDispatching + + " mTimeToSwitch=" + mKeyWaiter.mTimeToSwitch); + } + } + + public void monitor() { + synchronized (mWindowMap) { } + synchronized (mKeyguardDisabled) { } + synchronized (mKeyWaiter) { } + } +} diff --git a/services/java/com/android/server/am/ActivityManagerService.java b/services/java/com/android/server/am/ActivityManagerService.java new file mode 100644 index 0000000..141569e --- /dev/null +++ b/services/java/com/android/server/am/ActivityManagerService.java @@ -0,0 +1,11790 @@ +/* + * Copyright (C) 2006-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.am; + +import com.android.internal.os.BatteryStatsImpl; +import com.android.internal.os.RuntimeInit; +import com.android.server.IntentResolver; +import com.android.server.ProcessMap; +import com.android.server.ProcessStats; +import com.android.server.SystemServer; +import com.android.server.Watchdog; +import com.android.server.WindowManagerService; + +import android.app.Activity; +import android.app.ActivityManager; +import android.app.ActivityManagerNative; +import android.app.ActivityThread; +import android.app.AlertDialog; +import android.app.Dialog; +import android.app.IActivityWatcher; +import android.app.IApplicationThread; +import android.app.IInstrumentationWatcher; +import android.app.IIntentReceiver; +import android.app.IIntentSender; +import android.app.IServiceConnection; +import android.app.IThumbnailReceiver; +import android.app.Instrumentation; +import android.app.PendingIntent; +import android.app.ResultInfo; +import android.content.ComponentName; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.pm.ConfigurationInfo; +import android.content.pm.IPackageDataObserver; +import android.content.pm.IPackageManager; +import android.content.pm.InstrumentationInfo; +import android.content.pm.PackageManager; +import android.content.pm.ProviderInfo; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.content.res.Configuration; +import android.graphics.Bitmap; +import android.net.Uri; +import android.os.Binder; +import android.os.Bundle; +import android.os.Environment; +import android.os.FileUtils; +import android.os.Handler; +import android.os.IBinder; +import android.os.IPermissionController; +import android.os.Looper; +import android.os.Message; +import android.os.Parcel; +import android.os.ParcelFileDescriptor; +import android.os.PowerManager; +import android.os.Process; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.provider.Checkin; +import android.provider.Settings; +import android.text.TextUtils; +import android.util.Config; +import android.util.EventLog; +import android.util.Log; +import android.util.PrintWriterPrinter; +import android.util.SparseArray; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.View; +import android.view.WindowManager; +import android.view.WindowManagerPolicy; + +import dalvik.system.Zygote; + +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.PrintWriter; +import java.lang.IllegalStateException; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; +import java.util.Map; + +public final class ActivityManagerService extends ActivityManagerNative implements Watchdog.Monitor { + static final String TAG = "ActivityManager"; + static final boolean DEBUG = false; + static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV; + static final boolean DEBUG_SWITCH = localLOGV || false; + static final boolean DEBUG_TASKS = localLOGV || false; + static final boolean DEBUG_PAUSE = localLOGV || false; + static final boolean DEBUG_OOM_ADJ = localLOGV || false; + static final boolean DEBUG_TRANSITION = localLOGV || false; + static final boolean DEBUG_BROADCAST = localLOGV || false; + static final boolean DEBUG_SERVICE = localLOGV || false; + static final boolean DEBUG_VISBILITY = localLOGV || false; + static final boolean DEBUG_PROCESSES = localLOGV || false; + static final boolean DEBUG_USER_LEAVING = localLOGV || false; + static final boolean VALIDATE_TOKENS = false; + static final boolean SHOW_ACTIVITY_START_TIME = true; + + // Control over CPU and battery monitoring. + static final long BATTERY_STATS_TIME = 30*60*1000; // write battery stats every 30 minutes. + static final boolean MONITOR_CPU_USAGE = true; + static final long MONITOR_CPU_MIN_TIME = 5*1000; // don't sample cpu less than every 5 seconds. + static final long MONITOR_CPU_MAX_TIME = 0x0fffffff; // wait possibly forever for next cpu sample. + static final boolean MONITOR_THREAD_CPU_USAGE = false; + + // Event log tags + static final int LOG_CONFIGURATION_CHANGED = 2719; + static final int LOG_CPU = 2721; + static final int LOG_AM_FINISH_ACTIVITY = 30001; + static final int LOG_TASK_TO_FRONT = 30002; + static final int LOG_AM_NEW_INTENT = 30003; + static final int LOG_AM_CREATE_TASK = 30004; + static final int LOG_AM_CREATE_ACTIVITY = 30005; + static final int LOG_AM_RESTART_ACTIVITY = 30006; + static final int LOG_AM_RESUME_ACTIVITY = 30007; + static final int LOG_ANR = 30008; + static final int LOG_ACTIVITY_LAUNCH_TIME = 30009; + static final int LOG_AM_PROCESS_BOUND = 30010; + static final int LOG_AM_PROCESS_DIED = 30011; + static final int LOG_AM_FAILED_TO_PAUSE_ACTIVITY = 30012; + static final int LOG_AM_PAUSE_ACTIVITY = 30013; + static final int LOG_AM_PROCESS_START = 30014; + static final int LOG_AM_PROCESS_BAD = 30015; + static final int LOG_AM_PROCESS_GOOD = 30016; + static final int LOG_AM_LOW_MEMORY = 30017; + static final int LOG_AM_DESTROY_ACTIVITY = 30018; + static final int LOG_AM_RELAUNCH_RESUME_ACTIVITY = 30019; + static final int LOG_AM_RELAUNCH_ACTIVITY = 30020; + static final int LOG_AM_KILL_FOR_MEMORY = 30023; + static final int LOG_AM_BROADCAST_DISCARD_FILTER = 30024; + static final int LOG_AM_BROADCAST_DISCARD_APP = 30025; + static final int LOG_AM_CREATE_SERVICE = 30030; + static final int LOG_AM_DESTROY_SERVICE = 30031; + static final int LOG_AM_PROCESS_CRASHED_TOO_MUCH = 30032; + static final int LOG_AM_DROP_PROCESS = 30033; + static final int LOG_AM_SERVICE_CRASHED_TOO_MUCH = 30034; + static final int LOG_AM_SCHEDULE_SERVICE_RESTART = 30035; + static final int LOG_AM_PROVIDER_LOST_PROCESS = 30036; + + static final int LOG_BOOT_PROGRESS_AMS_READY = 3040; + static final int LOG_BOOT_PROGRESS_ENABLE_SCREEN = 3050; + + private static final String SYSTEM_SECURE = "ro.secure"; + + // This is the maximum number of application processes we would like + // to have running. Due to the asynchronous nature of things, we can + // temporarily go beyond this limit. + static final int MAX_PROCESSES = 2; + + // Set to false to leave processes running indefinitely, relying on + // the kernel killing them as resources are required. + static final boolean ENFORCE_PROCESS_LIMIT = false; + + // This is the maximum number of activities that we would like to have + // running at a given time. + static final int MAX_ACTIVITIES = 20; + + // Maximum number of recent tasks that we can remember. + static final int MAX_RECENT_TASKS = 20; + + // How long until we reset a task when the user returns to it. Currently + // 30 minutes. + static final long ACTIVITY_INACTIVE_RESET_TIME = 1000*60*30; + + // Set to true to disable the icon that is shown while a new activity + // is being started. + static final boolean SHOW_APP_STARTING_ICON = true; + + // How long we wait until giving up on the last activity to pause. This + // is short because it directly impacts the responsiveness of starting the + // next activity. + static final int PAUSE_TIMEOUT = 500; + + /** + * How long we can hold the launch wake lock before giving up. + */ + static final int LAUNCH_TIMEOUT = 10*1000; + + // How long we wait for a launched process to attach to the activity manager + // before we decide it's never going to come up for real. + static final int PROC_START_TIMEOUT = 10*1000; + + // How long we wait until giving up on the last activity telling us it + // is idle. + static final int IDLE_TIMEOUT = 10*1000; + + // How long to wait after going idle before forcing apps to GC. + static final int GC_TIMEOUT = 5*1000; + + // How long we wait until giving up on an activity telling us it has + // finished destroying itself. + static final int DESTROY_TIMEOUT = 10*1000; + + // How long we allow a receiver to run before giving up on it. + static final int BROADCAST_TIMEOUT = 10*1000; + + // How long we wait for a service to finish executing. + static final int SERVICE_TIMEOUT = 20*1000; + + // How long a service needs to be running until restarting its process + // is no longer considered to be a relaunch of the service. + static final int SERVICE_RESTART_DURATION = 5*1000; + + // Maximum amount of time for there to be no activity on a service before + // we consider it non-essential and allow its process to go on the + // LRU background list. + static final int MAX_SERVICE_INACTIVITY = 10*60*1000; + + // How long we wait until we timeout on key dispatching. + static final int KEY_DISPATCHING_TIMEOUT = 5*1000; + + // The minimum time we allow between crashes, for us to consider this + // application to be bad and stop and its services and reject broadcasts. + static final int MIN_CRASH_INTERVAL = 60*1000; + + // How long we wait until we timeout on key dispatching during instrumentation. + static final int INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT = 60*1000; + + // OOM adjustments for processes in various states: + + // This is a process without anything currently running in it. Definitely + // the first to go! Value set in system/rootdir/init.rc on startup. + // This value is initalized in the constructor, careful when refering to + // this static variable externally. + static int EMPTY_APP_ADJ; + + // This is a process with a content provider that does not have any clients + // attached to it. If it did have any clients, its adjustment would be the + // one for the highest-priority of those processes. + static int CONTENT_PROVIDER_ADJ; + + // This is a process only hosting activities that are not visible, + // so it can be killed without any disruption. Value set in + // system/rootdir/init.rc on startup. + final int HIDDEN_APP_MAX_ADJ; + static int HIDDEN_APP_MIN_ADJ; + + // This is a process holding a secondary server -- killing it will not + // have much of an impact as far as the user is concerned. Value set in + // system/rootdir/init.rc on startup. + final int SECONDARY_SERVER_ADJ; + + // This is a process only hosting activities that are visible to the + // user, so we'd prefer they don't disappear. Value set in + // system/rootdir/init.rc on startup. + final int VISIBLE_APP_ADJ; + + // This is the process running the current foreground app. We'd really + // rather not kill it! Value set in system/rootdir/init.rc on startup. + final int FOREGROUND_APP_ADJ; + + // This is a process running a core server, such as telephony. Definitely + // don't want to kill it, but doing so is not completely fatal. + static final int CORE_SERVER_ADJ = -12; + + // The system process runs at the default adjustment. + static final int SYSTEM_ADJ = -16; + + // Memory pages are 4K. + static final int PAGE_SIZE = 4*1024; + + // Corresponding memory levels for above adjustments. + final int EMPTY_APP_MEM; + final int HIDDEN_APP_MEM; + final int SECONDARY_SERVER_MEM; + final int VISIBLE_APP_MEM; + final int FOREGROUND_APP_MEM; + + final int MY_PID; + + static final String[] EMPTY_STRING_ARRAY = new String[0]; + + enum ActivityState { + INITIALIZING, + RESUMED, + PAUSING, + PAUSED, + STOPPING, + STOPPED, + FINISHING, + DESTROYING, + DESTROYED + } + + /** + * The back history of all previous (and possibly still + * running) activities. It contains HistoryRecord objects. + */ + final ArrayList mHistory = new ArrayList(); + + /** + * List of all active broadcasts that are to be executed immediately + * (without waiting for another broadcast to finish). Currently this only + * contains broadcasts to registered receivers, to avoid spinning up + * a bunch of processes to execute IntentReceiver components. + */ + final ArrayList<BroadcastRecord> mParallelBroadcasts + = new ArrayList<BroadcastRecord>(); + + /** + * List of all active broadcasts that are to be executed one at a time. + * The object at the top of the list is the currently activity broadcasts; + * those after it are waiting for the top to finish.. + */ + final ArrayList<BroadcastRecord> mOrderedBroadcasts + = new ArrayList<BroadcastRecord>(); + + /** + * Set when we current have a BROADCAST_INTENT_MSG in flight. + */ + boolean mBroadcastsScheduled = false; + + /** + * Set to indicate whether to issue an onUserLeaving callback when a + * newly launched activity is being brought in front of us. + */ + boolean mUserLeaving = false; + + /** + * When we are in the process of pausing an activity, before starting the + * next one, this variable holds the activity that is currently being paused. + */ + HistoryRecord mPausingActivity = null; + + /** + * Current activity that is resumed, or null if there is none. + */ + HistoryRecord mResumedActivity = null; + + /** + * Activity we have told the window manager to have key focus. + */ + HistoryRecord mFocusedActivity = null; + + /** + * This is the last activity that we put into the paused state. This is + * used to determine if we need to do an activity transition while sleeping, + * when we normally hold the top activity paused. + */ + HistoryRecord mLastPausedActivity = null; + + /** + * List of activities that are waiting for a new activity + * to become visible before completing whatever operation they are + * supposed to do. + */ + final ArrayList mWaitingVisibleActivities = new ArrayList(); + + /** + * List of activities that are ready to be stopped, but waiting + * for the next activity to settle down before doing so. It contains + * HistoryRecord objects. + */ + final ArrayList<HistoryRecord> mStoppingActivities + = new ArrayList<HistoryRecord>(); + + /** + * List of intents that were used to start the most recent tasks. + */ + final ArrayList<TaskRecord> mRecentTasks + = new ArrayList<TaskRecord>(); + + /** + * List of activities that are ready to be finished, but waiting + * for the previous activity to settle down before doing so. It contains + * HistoryRecord objects. + */ + final ArrayList mFinishingActivities = new ArrayList(); + + /** + * All of the applications we currently have running organized by name. + * The keys are strings of the application package name (as + * returned by the package manager), and the keys are ApplicationRecord + * objects. + */ + final ProcessMap<ProcessRecord> mProcessNames + = new ProcessMap<ProcessRecord>(); + + /** + * The last time that various processes have crashed. + */ + final ProcessMap<Long> mProcessCrashTimes = new ProcessMap<Long>(); + + /** + * Set of applications that we consider to be bad, and will reject + * incoming broadcasts from (which the user has no control over). + * Processes are added to this set when they have crashed twice within + * a minimum amount of time; they are removed from it when they are + * later restarted (hopefully due to some user action). The value is the + * time it was added to the list. + */ + final ProcessMap<Long> mBadProcesses = new ProcessMap<Long>(); + + /** + * All of the processes we currently have running organized by pid. + * The keys are the pid running the application. + * + * <p>NOTE: This object is protected by its own lock, NOT the global + * activity manager lock! + */ + final SparseArray<ProcessRecord> mPidsSelfLocked + = new SparseArray<ProcessRecord>(); + + /** + * All of the processes that have been forced to be foreground. The key + * is the pid of the caller who requested it (we hold a death + * link on it). + */ + abstract class ForegroundToken implements IBinder.DeathRecipient { + int pid; + IBinder token; + } + final SparseArray<ForegroundToken> mForegroundProcesses + = new SparseArray<ForegroundToken>(); + + /** + * List of records for processes that someone had tried to start before the + * system was ready. We don't start them at that point, but ensure they + * are started by the time booting is complete. + */ + final ArrayList<ProcessRecord> mProcessesOnHold + = new ArrayList<ProcessRecord>(); + + /** + * List of records for processes that we have started and are waiting + * for them to call back. This is really only needed when running in + * single processes mode, in which case we do not have a unique pid for + * each process. + */ + final ArrayList<ProcessRecord> mStartingProcesses + = new ArrayList<ProcessRecord>(); + + /** + * List of persistent applications that are in the process + * of being started. + */ + final ArrayList<ProcessRecord> mPersistentStartingProcesses + = new ArrayList<ProcessRecord>(); + + /** + * Processes that are being forcibly torn down. + */ + final ArrayList<ProcessRecord> mRemovedProcesses + = new ArrayList<ProcessRecord>(); + + /** + * List of running applications, sorted by recent usage. + * The first entry in the list is the least recently used. + * It contains ApplicationRecord objects. This list does NOT include + * any persistent application records (since we never want to exit them). + */ + final ArrayList<ProcessRecord> mLRUProcesses + = new ArrayList<ProcessRecord>(); + + /** + * List of processes that should gc as soon as things are idle. + */ + final ArrayList<ProcessRecord> mProcessesToGc + = new ArrayList<ProcessRecord>(); + + /** + * List of running activities, sorted by recent usage. + * The first entry in the list is the least recently used. + * It contains HistoryRecord objects. + */ + private final ArrayList mLRUActivities = new ArrayList(); + + /** + * Set of PendingResultRecord objects that are currently active. + */ + final HashSet mPendingResultRecords = new HashSet(); + + /** + * Set of IntentSenderRecord objects that are currently active. + */ + final HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>> mIntentSenderRecords + = new HashMap<PendingIntentRecord.Key, WeakReference<PendingIntentRecord>>(); + + /** + * Intent broadcast that we have tried to start, but are + * waiting for its application's process to be created. We only + * need one (instead of a list) because we always process broadcasts + * one at a time, so no others can be started while waiting for this + * one. + */ + BroadcastRecord mPendingBroadcast = null; + + /** + * Keeps track of all IIntentReceivers that have been registered for + * broadcasts. Hash keys are the receiver IBinder, hash value is + * a ReceiverList. + */ + final HashMap mRegisteredReceivers = new HashMap(); + + /** + * Resolver for broadcast intents to registered receivers. + * Holds BroadcastFilter (subclass of IntentFilter). + */ + final IntentResolver<BroadcastFilter, BroadcastFilter> mReceiverResolver + = new IntentResolver<BroadcastFilter, BroadcastFilter>() { + @Override + protected boolean allowFilterResult( + BroadcastFilter filter, List<BroadcastFilter> dest) { + IBinder target = filter.receiverList.receiver.asBinder(); + for (int i=dest.size()-1; i>=0; i--) { + if (dest.get(i).receiverList.receiver.asBinder() == target) { + return false; + } + } + return true; + } + }; + + /** + * State of all active sticky broadcasts. Keys are the action of the + * sticky Intent, values are an ArrayList of all broadcasted intents with + * that action (which should usually be one). + */ + final HashMap<String, ArrayList<Intent>> mStickyBroadcasts = + new HashMap<String, ArrayList<Intent>>(); + + /** + * All currently running services. + */ + final HashMap<ComponentName, ServiceRecord> mServices = + new HashMap<ComponentName, ServiceRecord>(); + + /** + * All currently running services indexed by the Intent used to start them. + */ + final HashMap<Intent.FilterComparison, ServiceRecord> mServicesByIntent = + new HashMap<Intent.FilterComparison, ServiceRecord>(); + + /** + * All currently bound service connections. Keys are the IBinder of + * the client's IServiceConnection. + */ + final HashMap<IBinder, ConnectionRecord> mServiceConnections + = new HashMap<IBinder, ConnectionRecord>(); + + /** + * List of services that we have been asked to start, + * but haven't yet been able to. It is used to hold start requests + * while waiting for their corresponding application thread to get + * going. + */ + final ArrayList<ServiceRecord> mPendingServices + = new ArrayList<ServiceRecord>(); + + /** + * List of services that are scheduled to restart following a crash. + */ + final ArrayList<ServiceRecord> mRestartingServices + = new ArrayList<ServiceRecord>(); + + /** + * List of services that are in the process of being stopped. + */ + final ArrayList<ServiceRecord> mStoppingServices + = new ArrayList<ServiceRecord>(); + + /** + * List of PendingThumbnailsRecord objects of clients who are still + * waiting to receive all of the thumbnails for a task. + */ + final ArrayList mPendingThumbnails = new ArrayList(); + + /** + * List of HistoryRecord objects that have been finished and must + * still report back to a pending thumbnail receiver. + */ + final ArrayList mCancelledThumbnails = new ArrayList(); + + /** + * All of the currently running global content providers. Keys are a + * string containing the provider name and values are a + * ContentProviderRecord object containing the data about it. Note + * that a single provider may be published under multiple names, so + * there may be multiple entries here for a single one in mProvidersByClass. + */ + final HashMap mProvidersByName = new HashMap(); + + /** + * All of the currently running global content providers. Keys are a + * string containing the provider's implementation class and values are a + * ContentProviderRecord object containing the data about it. + */ + final HashMap mProvidersByClass = new HashMap(); + + /** + * List of content providers who have clients waiting for them. The + * application is currently being launched and the provider will be + * removed from this list once it is published. + */ + final ArrayList mLaunchingProviders = new ArrayList(); + + /** + * Global set of specific Uri permissions that have been granted. + */ + final private SparseArray<HashMap<Uri, UriPermission>> mGrantedUriPermissions + = new SparseArray<HashMap<Uri, UriPermission>>(); + + /** + * Thread-local storage used to carry caller permissions over through + * indirect content-provider access. + * @see #ActivityManagerService.openContentUri() + */ + private class Identity { + public int pid; + public int uid; + + Identity(int _pid, int _uid) { + pid = _pid; + uid = _uid; + } + } + private static ThreadLocal<Identity> sCallerIdentity = new ThreadLocal<Identity>(); + + /** + * All information we have collected about the runtime performance of + * any user id that can impact battery performance. + */ + final BatteryStatsService mBatteryStatsService; + + /** + * information about component usage + */ + final UsageStatsService mUsageStatsService; + + /** + * Current configuration information. HistoryRecord objects are given + * a reference to this object to indicate which configuration they are + * currently running in, so this object must be kept immutable. + */ + Configuration mConfiguration = new Configuration(); + + /** + * List of initialization arguments to pass to all processes when binding applications to them. + * For example, references to the commonly used services. + */ + HashMap<String, IBinder> mAppBindArgs; + + /** + * Used to control how we initialize the service. + */ + boolean mStartRunning = false; + ComponentName mTopComponent; + String mTopAction; + String mTopData; + boolean mSystemReady = false; + boolean mBooting = false; + + Context mContext; + + int mFactoryTest; + + /** + * Set while we are wanting to sleep, to prevent any + * activities from being started/resumed. + */ + boolean mSleeping = false; + + /** + * Set when the system is going to sleep, until we have + * successfully paused the current activity and released our wake lock. + * At that point the system is allowed to actually sleep. + */ + PowerManager.WakeLock mGoingToSleep; + + /** + * We don't want to allow the device to go to sleep while in the process + * of launching an activity. This is primarily to allow alarm intent + * receivers to launch an activity and get that to run before the device + * goes back to sleep. + */ + PowerManager.WakeLock mLaunchingActivity; + + /** + * Task identifier that activities are currently being started + * in. Incremented each time a new task is created. + * todo: Replace this with a TokenSpace class that generates non-repeating + * integers that won't wrap. + */ + int mCurTask = 1; + + /** + * Current sequence id for oom_adj computation traversal. + */ + int mAdjSeq = 0; + + /** + * Set to true if the ANDROID_SIMPLE_PROCESS_MANAGEMENT envvar + * is set, indicating the user wants processes started in such a way + * that they can use ANDROID_PROCESS_WRAPPER and know what will be + * running in each process (thus no pre-initialized process, etc). + */ + boolean mSimpleProcessManagement = false; + + /** + * System monitoring: number of processes that died since the last + * N procs were started. + */ + int[] mProcDeaths = new int[20]; + + String mDebugApp = null; + boolean mWaitForDebugger = false; + boolean mDebugTransient = false; + String mOrigDebugApp = null; + boolean mOrigWaitForDebugger = false; + boolean mAlwaysFinishActivities = false; + IActivityWatcher mWatcher = null; + + /** + * Callback of last caller to {@link #requestPss}. + */ + Runnable mRequestPssCallback; + + /** + * Remaining processes for which we are waiting results from the last + * call to {@link #requestPss}. + */ + final ArrayList<ProcessRecord> mRequestPssList + = new ArrayList<ProcessRecord>(); + + /** + * Runtime statistics collection thread. This object's lock is used to + * protect all related state. + */ + final Thread mProcessStatsThread; + + /** + * Used to collect process stats when showing not responding dialog. + * Protected by mProcessStatsThread. + */ + final ProcessStats mProcessStats = new ProcessStats( + MONITOR_THREAD_CPU_USAGE); + long mLastCpuTime = 0; + long mLastWriteTime = 0; + + /** + * Set to true after the system has finished booting. + */ + boolean mBooted = false; + + int mProcessLimit = 0; + + WindowManagerService mWindowManager; + + static ActivityManagerService mSelf; + static ActivityThread mSystemThread; + + private final class AppDeathRecipient implements IBinder.DeathRecipient { + final ProcessRecord mApp; + final int mPid; + final IApplicationThread mAppThread; + + AppDeathRecipient(ProcessRecord app, int pid, + IApplicationThread thread) { + if (localLOGV) Log.v( + TAG, "New death recipient " + this + + " for thread " + thread.asBinder()); + mApp = app; + mPid = pid; + mAppThread = thread; + } + + public void binderDied() { + if (localLOGV) Log.v( + TAG, "Death received in " + this + + " for thread " + mAppThread.asBinder()); + removeRequestedPss(mApp); + synchronized(ActivityManagerService.this) { + appDiedLocked(mApp, mPid, mAppThread); + } + } + } + + static final int SHOW_ERROR_MSG = 1; + static final int SHOW_NOT_RESPONDING_MSG = 2; + static final int SHOW_FACTORY_ERROR_MSG = 3; + static final int UPDATE_CONFIGURATION_MSG = 4; + static final int GC_BACKGROUND_PROCESSES_MSG = 5; + static final int WAIT_FOR_DEBUGGER_MSG = 6; + static final int BROADCAST_INTENT_MSG = 7; + static final int BROADCAST_TIMEOUT_MSG = 8; + static final int PAUSE_TIMEOUT_MSG = 9; + static final int IDLE_TIMEOUT_MSG = 10; + static final int IDLE_NOW_MSG = 11; + static final int SERVICE_TIMEOUT_MSG = 12; + static final int UPDATE_TIME_ZONE = 13; + static final int SHOW_UID_ERROR_MSG = 14; + static final int IM_FEELING_LUCKY_MSG = 15; + static final int LAUNCH_TIMEOUT_MSG = 16; + static final int DESTROY_TIMEOUT_MSG = 17; + static final int SERVICE_ERROR_MSG = 18; + static final int RESUME_TOP_ACTIVITY_MSG = 19; + static final int PROC_START_TIMEOUT_MSG = 20; + + AlertDialog mUidAlert; + + final Handler mHandler = new Handler() { + //public Handler() { + // if (localLOGV) Log.v(TAG, "Handler started!"); + //} + + public void handleMessage(Message msg) { + switch (msg.what) { + case SHOW_ERROR_MSG: { + HashMap data = (HashMap) msg.obj; + byte[] crashData = (byte[])data.get("crashData"); + if (crashData != null) { + // This needs to be *un*synchronized to avoid deadlock. + ContentResolver resolver = mContext.getContentResolver(); + Checkin.reportCrash(resolver, crashData); + } + synchronized (ActivityManagerService.this) { + ProcessRecord proc = (ProcessRecord)data.get("app"); + if (proc != null && proc.crashDialog != null) { + Log.e(TAG, "App already has crash dialog: " + proc); + return; + } + AppErrorResult res = (AppErrorResult) data.get("result"); + if (!mSleeping) { + Dialog d = new AppErrorDialog( + mContext, res, proc, + (Integer)data.get("flags"), + (String)data.get("shortMsg"), + (String)data.get("longMsg")); + d.show(); + proc.crashDialog = d; + } else { + // The device is asleep, so just pretend that the user + // saw a crash dialog and hit "force quit". + res.set(0); + } + } + } break; + case SHOW_NOT_RESPONDING_MSG: { + synchronized (ActivityManagerService.this) { + HashMap data = (HashMap) msg.obj; + ProcessRecord proc = (ProcessRecord)data.get("app"); + if (proc != null && proc.anrDialog != null) { + Log.e(TAG, "App already has anr dialog: " + proc); + return; + } + Dialog d = new AppNotRespondingDialog(ActivityManagerService.this, + mContext, proc, (HistoryRecord)data.get("activity")); + d.show(); + proc.anrDialog = d; + } + } break; + case SHOW_FACTORY_ERROR_MSG: { + Dialog d = new FactoryErrorDialog( + mContext, msg.getData().getCharSequence("msg")); + d.show(); + enableScreenAfterBoot(); + } break; + case UPDATE_CONFIGURATION_MSG: { + final ContentResolver resolver = mContext.getContentResolver(); + Settings.System.putConfiguration(resolver, (Configuration)msg.obj); + } break; + case GC_BACKGROUND_PROCESSES_MSG: { + synchronized (ActivityManagerService.this) { + performAppGcsIfAppropriateLocked(); + } + } break; + case WAIT_FOR_DEBUGGER_MSG: { + synchronized (ActivityManagerService.this) { + ProcessRecord app = (ProcessRecord)msg.obj; + if (msg.arg1 != 0) { + if (!app.waitedForDebugger) { + Dialog d = new AppWaitingForDebuggerDialog( + ActivityManagerService.this, + mContext, app); + app.waitDialog = d; + app.waitedForDebugger = true; + d.show(); + } + } else { + if (app.waitDialog != null) { + app.waitDialog.dismiss(); + app.waitDialog = null; + } + } + } + } break; + case BROADCAST_INTENT_MSG: { + if (DEBUG_BROADCAST) Log.v( + TAG, "Received BROADCAST_INTENT_MSG"); + processNextBroadcast(true); + } break; + case BROADCAST_TIMEOUT_MSG: { + broadcastTimeout(); + } break; + case PAUSE_TIMEOUT_MSG: { + IBinder token = (IBinder)msg.obj; + // We don't at this point know if the activity is fullscreen, + // so we need to be conservative and assume it isn't. + Log.w(TAG, "Activity pause timeout for " + token); + activityPaused(token, null, true); + } break; + case IDLE_TIMEOUT_MSG: { + IBinder token = (IBinder)msg.obj; + // We don't at this point know if the activity is fullscreen, + // so we need to be conservative and assume it isn't. + Log.w(TAG, "Activity idle timeout for " + token); + activityIdleInternal(token, true); + } break; + case DESTROY_TIMEOUT_MSG: { + IBinder token = (IBinder)msg.obj; + // We don't at this point know if the activity is fullscreen, + // so we need to be conservative and assume it isn't. + Log.w(TAG, "Activity destroy timeout for " + token); + activityDestroyed(token); + } break; + case IDLE_NOW_MSG: { + IBinder token = (IBinder)msg.obj; + activityIdle(token); + } break; + case SERVICE_TIMEOUT_MSG: { + serviceTimeout((ProcessRecord)msg.obj); + } break; + case UPDATE_TIME_ZONE: { + synchronized (ActivityManagerService.this) { + for (int i = mLRUProcesses.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = mLRUProcesses.get(i); + if (r.thread != null) { + try { + r.thread.updateTimeZone(); + } catch (RemoteException ex) { + Log.w(TAG, "Failed to update time zone for: " + r.info.processName); + } + } + } + } + break; + } + case SHOW_UID_ERROR_MSG: { + // XXX This is a temporary dialog, no need to localize. + AlertDialog d = new BaseErrorDialog(mContext); + d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ERROR); + d.setCancelable(false); + d.setTitle("System UIDs Inconsistent"); + d.setMessage("UIDs on the system are inconsistent, you need to wipe your data partition or your device will be unstable."); + d.setButton("I'm Feeling Lucky", + mHandler.obtainMessage(IM_FEELING_LUCKY_MSG)); + mUidAlert = d; + d.show(); + } break; + case IM_FEELING_LUCKY_MSG: { + if (mUidAlert != null) { + mUidAlert.dismiss(); + mUidAlert = null; + } + } break; + case LAUNCH_TIMEOUT_MSG: { + synchronized (ActivityManagerService.this) { + if (mLaunchingActivity.isHeld()) { + Log.w(TAG, "Launch timeout has expired, giving up wake lock!"); + mLaunchingActivity.release(); + } + } + } break; + case SERVICE_ERROR_MSG: { + ServiceRecord srv = (ServiceRecord)msg.obj; + // This needs to be *un*synchronized to avoid deadlock. + Checkin.logEvent(mContext.getContentResolver(), + Checkin.Events.Tag.SYSTEM_SERVICE_LOOPING, + srv.name.toShortString()); + } break; + case RESUME_TOP_ACTIVITY_MSG: { + synchronized (ActivityManagerService.this) { + resumeTopActivityLocked(null); + } + } + case PROC_START_TIMEOUT_MSG: { + ProcessRecord app = (ProcessRecord)msg.obj; + synchronized (ActivityManagerService.this) { + processStartTimedOutLocked(app); + } + } + } + } + }; + + public static void setSystemProcess() { + try { + ActivityManagerService m = mSelf; + + ServiceManager.addService("activity", m); + ServiceManager.addService("meminfo", new MemBinder(m)); + if (MONITOR_CPU_USAGE) { + ServiceManager.addService("cpuinfo", new CpuBinder(m)); + } + ServiceManager.addService("activity.broadcasts", new BroadcastsBinder(m)); + ServiceManager.addService("activity.services", new ServicesBinder(m)); + ServiceManager.addService("activity.senders", new SendersBinder(m)); + ServiceManager.addService("activity.providers", new ProvidersBinder(m)); + ServiceManager.addService("permission", new PermissionController(m)); + + ApplicationInfo info = + mSelf.mContext.getPackageManager().getApplicationInfo( + "android", PackageManager.GET_SHARED_LIBRARY_FILES); + synchronized (mSelf) { + ProcessRecord app = mSelf.newProcessRecordLocked( + mSystemThread.getApplicationThread(), info, + info.processName); + app.persistent = true; + app.pid = Process.myPid(); + app.maxAdj = SYSTEM_ADJ; + mSelf.mProcessNames.put(app.processName, app.info.uid, app); + synchronized (mSelf.mPidsSelfLocked) { + mSelf.mPidsSelfLocked.put(app.pid, app); + } + mSelf.updateLRUListLocked(app, true); + } + } catch (PackageManager.NameNotFoundException e) { + throw new RuntimeException( + "Unable to find android system package", e); + } + } + + public void setWindowManager(WindowManagerService wm) { + mWindowManager = wm; + } + + public static final Context main(int factoryTest) { + AThread thr = new AThread(); + thr.start(); + + synchronized (thr) { + while (thr.mService == null) { + try { + thr.wait(); + } catch (InterruptedException e) { + } + } + } + + ActivityManagerService m = thr.mService; + mSelf = m; + ActivityThread at = ActivityThread.systemMain(); + mSystemThread = at; + Context context = at.getSystemContext(); + m.mContext = context; + m.mFactoryTest = factoryTest; + PowerManager pm = + (PowerManager)context.getSystemService(Context.POWER_SERVICE); + m.mGoingToSleep = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Sleep"); + m.mLaunchingActivity = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "ActivityManager-Launch"); + m.mLaunchingActivity.setReferenceCounted(false); + + m.mBatteryStatsService.publish(context); + m.mUsageStatsService.publish(context); + + synchronized (thr) { + thr.mReady = true; + thr.notifyAll(); + } + + m.startRunning(null, null, null, null); + + return context; + } + + public static ActivityManagerService self() { + return mSelf; + } + + static class AThread extends Thread { + ActivityManagerService mService; + boolean mReady = false; + + public AThread() { + super("ActivityManager"); + } + + public void run() { + Looper.prepare(); + + android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_FOREGROUND); + + ActivityManagerService m = new ActivityManagerService(); + + synchronized (this) { + mService = m; + notifyAll(); + } + + synchronized (this) { + while (!mReady) { + try { + wait(); + } catch (InterruptedException e) { + } + } + } + + Looper.loop(); + } + } + + static class BroadcastsBinder extends Binder { + ActivityManagerService mActivityManagerService; + BroadcastsBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpBroadcasts(pw); + } + } + + static class ServicesBinder extends Binder { + ActivityManagerService mActivityManagerService; + ServicesBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpServices(pw); + } + } + + static class SendersBinder extends Binder { + ActivityManagerService mActivityManagerService; + SendersBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpSenders(pw); + } + } + + static class ProvidersBinder extends Binder { + ActivityManagerService mActivityManagerService; + ProvidersBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + mActivityManagerService.dumpProviders(pw); + } + } + + static class MemBinder extends Binder { + ActivityManagerService mActivityManagerService; + MemBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + ActivityManagerService service = mActivityManagerService; + ArrayList<ProcessRecord> procs; + synchronized (mActivityManagerService) { + if (args != null && args.length > 0 + && args[0].charAt(0) != '-') { + procs = new ArrayList<ProcessRecord>(); + int pid = -1; + try { + pid = Integer.parseInt(args[0]); + } catch (NumberFormatException e) { + + } + for (int i=0; i<service.mLRUProcesses.size(); i++) { + ProcessRecord proc = service.mLRUProcesses.get(i); + if (proc.pid == pid) { + procs.add(proc); + } else if (proc.processName.equals(args[0])) { + procs.add(proc); + } + } + if (procs.size() <= 0) { + pw.println("No process found for: " + args[0]); + return; + } + } else { + procs = service.mLRUProcesses; + } + } + dumpApplicationMemoryUsage(fd, pw, procs, " ", args); + } + } + + static class CpuBinder extends Binder { + ActivityManagerService mActivityManagerService; + CpuBinder(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (mActivityManagerService.mProcessStatsThread) { + pw.print(mActivityManagerService.mProcessStats.printCurrentState()); + } + } + } + + private ActivityManagerService() { + String v = System.getenv("ANDROID_SIMPLE_PROCESS_MANAGEMENT"); + if (v != null && Integer.getInteger(v) != 0) { + mSimpleProcessManagement = true; + } + v = System.getenv("ANDROID_DEBUG_APP"); + if (v != null) { + mSimpleProcessManagement = true; + } + + MY_PID = Process.myPid(); + + File dataDir = Environment.getDataDirectory(); + File systemDir = new File(dataDir, "system"); + systemDir.mkdirs(); + mBatteryStatsService = new BatteryStatsService(new File( + systemDir, "batterystats.bin").toString()); + mBatteryStatsService.getActiveStatistics().readLocked(); + mBatteryStatsService.getActiveStatistics().writeLocked(); + + mUsageStatsService = new UsageStatsService( new File( + systemDir, "usagestats.bin").toString()); + + mConfiguration.makeDefault(); + mProcessStats.init(); + + // Add ourself to the Watchdog monitors. + Watchdog.getInstance().addMonitor(this); + + // These values are set in system/rootdir/init.rc on startup. + FOREGROUND_APP_ADJ = + Integer.valueOf(SystemProperties.get("ro.FOREGROUND_APP_ADJ")); + VISIBLE_APP_ADJ = + Integer.valueOf(SystemProperties.get("ro.VISIBLE_APP_ADJ")); + SECONDARY_SERVER_ADJ = + Integer.valueOf(SystemProperties.get("ro.SECONDARY_SERVER_ADJ")); + HIDDEN_APP_MIN_ADJ = + Integer.valueOf(SystemProperties.get("ro.HIDDEN_APP_MIN_ADJ")); + CONTENT_PROVIDER_ADJ = + Integer.valueOf(SystemProperties.get("ro.CONTENT_PROVIDER_ADJ")); + HIDDEN_APP_MAX_ADJ = CONTENT_PROVIDER_ADJ-1; + EMPTY_APP_ADJ = + Integer.valueOf(SystemProperties.get("ro.EMPTY_APP_ADJ")); + FOREGROUND_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.FOREGROUND_APP_MEM"))*PAGE_SIZE; + VISIBLE_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.VISIBLE_APP_MEM"))*PAGE_SIZE; + SECONDARY_SERVER_MEM = + Integer.valueOf(SystemProperties.get("ro.SECONDARY_SERVER_MEM"))*PAGE_SIZE; + HIDDEN_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.HIDDEN_APP_MEM"))*PAGE_SIZE; + EMPTY_APP_MEM = + Integer.valueOf(SystemProperties.get("ro.EMPTY_APP_MEM"))*PAGE_SIZE; + + mProcessStatsThread = new Thread("ProcessStats") { + public void run() { + while (true) { + try { + try { + synchronized(this) { + final long now = SystemClock.uptimeMillis(); + long nextCpuDelay = (mLastCpuTime+MONITOR_CPU_MAX_TIME)-now; + long nextWriteDelay = (mLastWriteTime+BATTERY_STATS_TIME)-now; + //Log.i(TAG, "Cpu delay=" + nextCpuDelay + // + ", write delay=" + nextWriteDelay); + if (nextWriteDelay < nextCpuDelay) { + nextCpuDelay = nextWriteDelay; + } + if (nextCpuDelay > 0) { + this.wait(nextCpuDelay); + } + } + } catch (InterruptedException e) { + } + + updateCpuStatsNow(); + } catch (Exception e) { + Log.e(TAG, "Unexpected exception collecting process stats", e); + } + } + } + }; + mProcessStatsThread.start(); + } + + @Override + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) + throws RemoteException { + try { + return super.onTransact(code, data, reply, flags); + } catch (RuntimeException e) { + // The activity manager only throws security exceptions, so let's + // log all others. + if (!(e instanceof SecurityException)) { + Log.e(TAG, "Activity Manager Crash", e); + } + throw e; + } + } + + void updateCpuStats() { + synchronized (mProcessStatsThread) { + final long now = SystemClock.uptimeMillis(); + if (mLastCpuTime < (now-MONITOR_CPU_MIN_TIME)) { + mProcessStatsThread.notify(); + } + } + } + + void updateCpuStatsNow() { + synchronized (mProcessStatsThread) { + final long now = SystemClock.uptimeMillis(); + boolean haveNewCpuStats = false; + + if (MONITOR_CPU_USAGE && + mLastCpuTime < (now-MONITOR_CPU_MIN_TIME)) { + mLastCpuTime = now; + haveNewCpuStats = true; + mProcessStats.update(); + //Log.i(TAG, mProcessStats.printCurrentState()); + //Log.i(TAG, "Total CPU usage: " + // + mProcessStats.getTotalCpuPercent() + "%"); + + // Log the cpu usage if the property is set. + if ("true".equals(SystemProperties.get("events.cpu"))) { + int user = mProcessStats.getLastUserTime(); + int system = mProcessStats.getLastSystemTime(); + int iowait = mProcessStats.getLastIoWaitTime(); + int irq = mProcessStats.getLastIrqTime(); + int softIrq = mProcessStats.getLastSoftIrqTime(); + int idle = mProcessStats.getLastIdleTime(); + + int total = user + system + iowait + irq + softIrq + idle; + if (total == 0) total = 1; + + EventLog.writeEvent(LOG_CPU, + ((user+system+iowait+irq+softIrq) * 100) / total, + (user * 100) / total, + (system * 100) / total, + (iowait * 100) / total, + (irq * 100) / total, + (softIrq * 100) / total); + } + } + + synchronized(mBatteryStatsService.getActiveStatistics()) { + synchronized(mPidsSelfLocked) { + if (haveNewCpuStats) { + if (mBatteryStatsService.isOnBattery()) { + final int N = mProcessStats.countWorkingStats(); + for (int i=0; i<N; i++) { + ProcessStats.Stats st + = mProcessStats.getWorkingStats(i); + ProcessRecord pr = mPidsSelfLocked.get(st.pid); + if (pr != null) { + BatteryStatsImpl.Uid.Proc ps = pr.batteryStats; + ps.addCpuTimeLocked(st.rel_utime, st.rel_stime); + } + } + } + } + } + + if (mLastWriteTime < (now-BATTERY_STATS_TIME)) { + mLastWriteTime = now; + mBatteryStatsService.getActiveStatistics().writeLocked(); + } + } + } + } + + /** + * Initialize the application bind args. These are passed to each + * process when the bindApplication() IPC is sent to the process. They're + * lazily setup to make sure the services are running when they're asked for. + */ + private HashMap<String, IBinder> getCommonServicesLocked() { + if (mAppBindArgs == null) { + mAppBindArgs = new HashMap<String, IBinder>(); + + // Setup the application init args + mAppBindArgs.put("package", ServiceManager.getService("package")); + mAppBindArgs.put("window", ServiceManager.getService("window")); + mAppBindArgs.put(Context.ALARM_SERVICE, + ServiceManager.getService(Context.ALARM_SERVICE)); + } + return mAppBindArgs; + } + + private final void setFocusedActivityLocked(HistoryRecord r) { + if (mFocusedActivity != r) { + mFocusedActivity = r; + mWindowManager.setFocusedApp(r, true); + } + } + + private final void updateLRUListLocked(ProcessRecord app, + boolean oomAdj) { + // put it on the LRU to keep track of when it should be exited. + int lrui = mLRUProcesses.indexOf(app); + if (lrui >= 0) mLRUProcesses.remove(lrui); + mLRUProcesses.add(app); + //Log.i(TAG, "Putting proc to front: " + app.processName); + if (oomAdj) { + updateOomAdjLocked(); + } + } + + private final boolean updateLRUListLocked(HistoryRecord r) { + final boolean hadit = mLRUActivities.remove(r); + mLRUActivities.add(r); + return hadit; + } + + private final HistoryRecord topRunningActivityLocked(HistoryRecord notTop) { + int i = mHistory.size()-1; + while (i >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (!r.finishing && r != notTop) { + return r; + } + i--; + } + return null; + } + + /** + * This is a simplified version of topRunningActivityLocked that provides a number of + * optional skip-over modes. It is intended for use with the ActivityWatcher hook only. + * + * @param token If non-null, any history records matching this token will be skipped. + * @param taskId If non-zero, we'll attempt to skip over records with the same task ID. + * + * @return Returns the HistoryRecord of the next activity on the stack. + */ + private final HistoryRecord topRunningActivityLocked(IBinder token, int taskId) { + int i = mHistory.size()-1; + while (i >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + // Note: the taskId check depends on real taskId fields being non-zero + if (!r.finishing && (token != r) && (taskId != r.task.taskId)) { + return r; + } + i--; + } + return null; + } + + private final ProcessRecord getProcessRecordLocked( + String processName, int uid) { + if (uid == Process.SYSTEM_UID) { + // The system gets to run in any process. If there are multiple + // processes with the same uid, just pick the first (this + // should never happen). + SparseArray<ProcessRecord> procs = mProcessNames.getMap().get( + processName); + return procs != null ? procs.valueAt(0) : null; + } + ProcessRecord proc = mProcessNames.get(processName, uid); + return proc; + } + + private boolean isNextTransitionForward() { + int transit = mWindowManager.getPendingAppTransition(); + return transit == WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN + || transit == WindowManagerPolicy.TRANSIT_TASK_OPEN + || transit == WindowManagerPolicy.TRANSIT_TASK_TO_FRONT; + } + + private final boolean realStartActivityLocked(HistoryRecord r, + ProcessRecord app, boolean andResume, boolean checkConfig) + throws RemoteException { + + r.startFreezingScreenLocked(app, 0); + mWindowManager.setAppVisibility(r, true); + + // Have the window manager re-evaluate the orientation of + // the screen based on the new activity order. Note that + // as a result of this, it can call back into the activity + // manager with a new orientation. We don't care about that, + // because the activity is not currently running so we are + // just restarting it anyway. + if (checkConfig) { + Configuration config = mWindowManager.updateOrientationFromAppTokens( + r.mayFreezeScreenLocked(app) ? r : null); + updateConfigurationLocked(config, r); + } + + r.app = app; + + if (localLOGV) Log.v(TAG, "Launching: " + r); + + int idx = app.activities.indexOf(r); + if (idx < 0) { + app.activities.add(r); + } + updateLRUListLocked(app, true); + + try { + if (app.thread == null) { + throw new RemoteException(); + } + List<ResultInfo> results = null; + List<Intent> newIntents = null; + if (andResume) { + results = r.results; + newIntents = r.newIntents; + } + if (DEBUG_SWITCH) Log.v(TAG, "Launching: " + r + + " icicle=" + r.icicle + + " with results=" + results + " newIntents=" + newIntents + + " andResume=" + andResume); + if (andResume) { + EventLog.writeEvent(LOG_AM_RESTART_ACTIVITY, + System.identityHashCode(r), + r.task.taskId, r.shortComponentName); + } + app.thread.scheduleLaunchActivity(new Intent(r.intent), r, + r.info, r.icicle, results, newIntents, !andResume, + isNextTransitionForward()); + // Update usage stats for launched activity + updateUsageStats(r, true); + } catch (RemoteException e) { + if (r.launchFailed) { + // This is the second time we failed -- finish activity + // and give up. + Log.e(TAG, "Second failure launching " + + r.intent.getComponent().flattenToShortString() + + ", giving up", e); + appDiedLocked(app, app.pid, app.thread); + requestFinishActivityLocked(r, Activity.RESULT_CANCELED, null, + "2nd-crash"); + return false; + } + + // This is the first time we failed -- restart process and + // retry. + app.activities.remove(r); + throw e; + } + + r.launchFailed = false; + if (updateLRUListLocked(r)) { + Log.w(TAG, "Activity " + r + + " being launched, but already in LRU list"); + } + + if (andResume) { + // As part of the process of launching, ActivityThread also performs + // a resume. + r.state = ActivityState.RESUMED; + r.icicle = null; + r.haveState = false; + r.stopped = false; + mResumedActivity = r; + r.task.touchActiveTime(); + completeResumeLocked(r); + pauseIfSleepingLocked(); + } else { + // This activity is not starting in the resumed state... which + // should look like we asked it to pause+stop (but remain visible), + // and it has done so and reported back the current icicle and + // other state. + r.state = ActivityState.STOPPED; + r.stopped = true; + } + + return true; + } + + private final void startSpecificActivityLocked(HistoryRecord r, + boolean andResume, boolean checkConfig) { + // Is this activity's application already running? + ProcessRecord app = getProcessRecordLocked(r.processName, + r.info.applicationInfo.uid); + + if (r.startTime == 0) { + r.startTime = SystemClock.uptimeMillis(); + } + + if (app != null && app.thread != null) { + try { + realStartActivityLocked(r, app, andResume, checkConfig); + return; + } catch (RemoteException e) { + Log.w(TAG, "Exception when starting activity " + + r.intent.getComponent().flattenToShortString(), e); + } + + // If a dead object exception was thrown -- fall through to + // restart the application. + } + + startProcessLocked(r.processName, r.info.applicationInfo, true, 0, + "activity", r.intent.getComponent()); + } + + private final ProcessRecord startProcessLocked(String processName, + ApplicationInfo info, boolean knownToBeDead, int intentFlags, + String hostingType, ComponentName hostingName) { + ProcessRecord app = getProcessRecordLocked(processName, info.uid); + // We don't have to do anything more if: + // (1) There is an existing application record; and + // (2) The caller doesn't think it is dead, OR there is no thread + // object attached to it so we know it couldn't have crashed; and + // (3) There is a pid assigned to it, so it is either starting or + // already running. + if (DEBUG_PROCESSES) Log.v(TAG, "startProcess: name=" + processName + + " app=" + app + " knownToBeDead=" + knownToBeDead + + " thread=" + (app != null ? app.thread : null) + + " pid=" + (app != null ? app.pid : -1)); + if (app != null && + (!knownToBeDead || app.thread == null) && app.pid > 0) { + return app; + } + + String hostingNameStr = hostingName != null + ? hostingName.flattenToShortString() : null; + + if ((intentFlags&Intent.FLAG_FROM_BACKGROUND) != 0) { + // If we are in the background, then check to see if this process + // is bad. If so, we will just silently fail. + if (mBadProcesses.get(info.processName, info.uid) != null) { + return null; + } + } else { + // When the user is explicitly starting a process, then clear its + // crash count so that we won't make it bad until they see at + // least one crash dialog again, and make the process good again + // if it had been bad. + mProcessCrashTimes.remove(info.processName, info.uid); + if (mBadProcesses.get(info.processName, info.uid) != null) { + EventLog.writeEvent(LOG_AM_PROCESS_GOOD, info.uid, + info.processName); + mBadProcesses.remove(info.processName, info.uid); + if (app != null) { + app.bad = false; + } + } + } + + if (app == null) { + app = newProcessRecordLocked(null, info, processName); + mProcessNames.put(processName, info.uid, app); + } else { + // If this is a new package in the process, add the package to the list + app.addPackage(info.packageName); + } + + // If the system is not ready yet, then hold off on starting this + // process until it is. + if (!mSystemReady + && (info.flags&ApplicationInfo.FLAG_PERSISTENT) == 0) { + if (!mProcessesOnHold.contains(app)) { + mProcessesOnHold.add(app); + } + return app; + } + + startProcessLocked(app, hostingType, hostingNameStr); + return (app.pid != 0) ? app : null; + } + + private final void startProcessLocked(ProcessRecord app, + String hostingType, String hostingNameStr) { + if (app.pid > 0 && app.pid != MY_PID) { + synchronized (mPidsSelfLocked) { + mPidsSelfLocked.remove(app.pid); + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + } + app.pid = 0; + } + + mProcessesOnHold.remove(app); + + updateCpuStats(); + + System.arraycopy(mProcDeaths, 0, mProcDeaths, 1, mProcDeaths.length-1); + mProcDeaths[0] = 0; + + try { + int uid = app.info.uid; + int[] gids = null; + try { + gids = mContext.getPackageManager().getPackageGids( + app.info.packageName); + } catch (PackageManager.NameNotFoundException e) { + Log.w(TAG, "Unable to retrieve gids", e); + } + if (mFactoryTest != SystemServer.FACTORY_TEST_OFF) { + if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL + && mTopComponent != null + && app.processName.equals(mTopComponent.getPackageName())) { + uid = 0; + } + if (mFactoryTest == SystemServer.FACTORY_TEST_HIGH_LEVEL + && (app.info.flags&ApplicationInfo.FLAG_FACTORY_TEST) != 0) { + uid = 0; + } + } + int debugFlags = 0; + if ((app.info.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0) { + debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER; + } + if ("1".equals(SystemProperties.get("debug.checkjni"))) { + debugFlags |= Zygote.DEBUG_ENABLE_CHECKJNI; + } + if ("1".equals(SystemProperties.get("debug.assert"))) { + debugFlags |= Zygote.DEBUG_ENABLE_ASSERT; + } + int pid = Process.start("android.app.ActivityThread", + mSimpleProcessManagement ? app.processName : null, uid, uid, + gids, debugFlags, null); + BatteryStatsImpl bs = app.batteryStats.getBatteryStats(); + synchronized (bs) { + if (bs.isOnBattery()) { + app.batteryStats.incStartsLocked(); + } + } + + EventLog.writeEvent(LOG_AM_PROCESS_START, pid, uid, + app.processName, hostingType, + hostingNameStr != null ? hostingNameStr : ""); + + if (app.persistent) { + Watchdog.getInstance().processStarted(app, app.processName, pid); + } + + StringBuilder buf = new StringBuilder(128); + buf.append("Start proc "); + buf.append(app.processName); + buf.append(" for "); + buf.append(hostingType); + if (hostingNameStr != null) { + buf.append(" "); + buf.append(hostingNameStr); + } + buf.append(": pid="); + buf.append(pid); + buf.append(" uid="); + buf.append(uid); + buf.append(" gids={"); + if (gids != null) { + for (int gi=0; gi<gids.length; gi++) { + if (gi != 0) buf.append(", "); + buf.append(gids[gi]); + + } + } + buf.append("}"); + Log.i(TAG, buf.toString()); + if (pid == 0 || pid == MY_PID) { + // Processes are being emulated with threads. + app.pid = MY_PID; + app.removed = false; + mStartingProcesses.add(app); + } else if (pid > 0) { + app.pid = pid; + app.removed = false; + synchronized (mPidsSelfLocked) { + this.mPidsSelfLocked.put(pid, app); + Message msg = mHandler.obtainMessage(PROC_START_TIMEOUT_MSG); + msg.obj = app; + mHandler.sendMessageDelayed(msg, PROC_START_TIMEOUT); + } + } else { + app.pid = 0; + RuntimeException e = new RuntimeException( + "Failure starting process " + app.processName + + ": returned pid=" + pid); + Log.e(TAG, e.getMessage(), e); + } + } catch (RuntimeException e) { + // XXX do better error recovery. + app.pid = 0; + Log.e(TAG, "Failure starting process " + app.processName, e); + } + } + + private final void startPausingLocked(boolean userLeaving, boolean uiSleeping) { + if (mPausingActivity != null) { + RuntimeException e = new RuntimeException(); + Log.e(TAG, "Trying to pause when pause is already pending for " + + mPausingActivity, e); + } + HistoryRecord prev = mResumedActivity; + if (prev == null) { + RuntimeException e = new RuntimeException(); + Log.e(TAG, "Trying to pause when nothing is resumed", e); + resumeTopActivityLocked(null); + return; + } + if (DEBUG_PAUSE) Log.v(TAG, "Start pausing: " + prev); + mResumedActivity = null; + mPausingActivity = prev; + mLastPausedActivity = prev; + prev.state = ActivityState.PAUSING; + prev.task.touchActiveTime(); + + updateCpuStats(); + + if (prev.app != null && prev.app.thread != null) { + if (DEBUG_PAUSE) Log.v(TAG, "Enqueueing pending pause: " + prev); + try { + EventLog.writeEvent(LOG_AM_PAUSE_ACTIVITY, + System.identityHashCode(prev), + prev.shortComponentName); + prev.app.thread.schedulePauseActivity(prev, prev.finishing, userLeaving, + prev.configChangeFlags); + updateUsageStats(prev, false); + } catch (Exception e) { + // Ignore exception, if process died other code will cleanup. + Log.w(TAG, "Exception thrown during pause", e); + mPausingActivity = null; + mLastPausedActivity = null; + } + } else { + mPausingActivity = null; + mLastPausedActivity = null; + } + + // If we are not going to sleep, we want to ensure the device is + // awake until the next activity is started. + if (!mSleeping) { + mLaunchingActivity.acquire(); + if (!mHandler.hasMessages(LAUNCH_TIMEOUT_MSG)) { + // To be safe, don't allow the wake lock to be held for too long. + Message msg = mHandler.obtainMessage(LAUNCH_TIMEOUT_MSG); + mHandler.sendMessageDelayed(msg, LAUNCH_TIMEOUT); + } + } + + + if (mPausingActivity != null) { + // Have the window manager pause its key dispatching until the new + // activity has started. If we're pausing the activity just because + // the screen is being turned off and the UI is sleeping, don't interrupt + // key dispatch; the same activity will pick it up again on wakeup. + if (!uiSleeping) { + prev.pauseKeyDispatchingLocked(); + } else { + if (DEBUG_PAUSE) Log.v(TAG, "Key dispatch not paused for screen off"); + } + + // Schedule a pause timeout in case the app doesn't respond. + // We don't give it much time because this directly impacts the + // responsiveness seen by the user. + Message msg = mHandler.obtainMessage(PAUSE_TIMEOUT_MSG); + msg.obj = prev; + mHandler.sendMessageDelayed(msg, PAUSE_TIMEOUT); + if (DEBUG_PAUSE) Log.v(TAG, "Waiting for pause to complete..."); + } else { + // This activity failed to schedule the + // pause, so just treat it as being paused now. + if (DEBUG_PAUSE) Log.v(TAG, "Activity not running, resuming next."); + resumeTopActivityLocked(null); + } + } + + private final void completePauseLocked() { + HistoryRecord prev = mPausingActivity; + if (DEBUG_PAUSE) Log.v(TAG, "Complete pause: " + prev); + + if (prev != null) { + if (prev.finishing) { + if (DEBUG_PAUSE) Log.v(TAG, "Executing finish of activity: " + prev); + prev = finishCurrentActivityLocked(prev, FINISH_AFTER_VISIBLE); + } else if (prev.app != null) { + if (DEBUG_PAUSE) Log.v(TAG, "Enqueueing pending stop: " + prev); + if (prev.waitingVisible) { + prev.waitingVisible = false; + mWaitingVisibleActivities.remove(prev); + if (DEBUG_SWITCH || DEBUG_PAUSE) Log.v( + TAG, "Complete pause, no longer waiting: " + prev); + } + if (prev.configDestroy) { + // The previous is being paused because the configuration + // is changing, which means it is actually stopping... + // To juggle the fact that we are also starting a new + // instance right now, we need to first completely stop + // the current instance before starting the new one. + if (DEBUG_PAUSE) Log.v(TAG, "Destroying after pause: " + prev); + destroyActivityLocked(prev, true); + } else { + mStoppingActivities.add(prev); + if (mStoppingActivities.size() > 3) { + // If we already have a few activities waiting to stop, + // then give up on things going idle and start clearing + // them out. + if (DEBUG_PAUSE) Log.v(TAG, "To many pending stops, forcing idle"); + Message msg = Message.obtain(); + msg.what = ActivityManagerService.IDLE_NOW_MSG; + mHandler.sendMessage(msg); + } + } + } else { + if (DEBUG_PAUSE) Log.v(TAG, "App died during pause, not stopping: " + prev); + prev = null; + } + mPausingActivity = null; + } + + if (!mSleeping) { + resumeTopActivityLocked(prev); + } else { + if (mGoingToSleep.isHeld()) { + mGoingToSleep.release(); + } + } + + if (prev != null) { + prev.resumeKeyDispatchingLocked(); + } + } + + /** + * Once we know that we have asked an application to put an activity in + * the resumed state (either by launching it or explicitly telling it), + * this function updates the rest of our state to match that fact. + */ + private final void completeResumeLocked(HistoryRecord next) { + next.idle = false; + next.results = null; + next.newIntents = null; + + // schedule an idle timeout in case the app doesn't do it for us. + Message msg = mHandler.obtainMessage(IDLE_TIMEOUT_MSG); + msg.obj = next; + mHandler.sendMessageDelayed(msg, IDLE_TIMEOUT); + + if (false) { + // The activity was never told to pause, so just keep + // things going as-is. To maintain our own state, + // we need to emulate it coming back and saying it is + // idle. + msg = mHandler.obtainMessage(IDLE_NOW_MSG); + msg.obj = next; + mHandler.sendMessage(msg); + } + + next.thumbnail = null; + setFocusedActivityLocked(next); + next.resumeKeyDispatchingLocked(); + ensureActivitiesVisibleLocked(null, 0); + mWindowManager.executeAppTransition(); + } + + /** + * Make sure that all activities that need to be visible (that is, they + * currently can be seen by the user) actually are. + */ + private final void ensureActivitiesVisibleLocked(HistoryRecord top, + HistoryRecord starting, String onlyThisProcess, int configChanges) { + if (DEBUG_VISBILITY) Log.v( + TAG, "ensureActivitiesVisible behind " + top + + " configChanges=0x" + Integer.toHexString(configChanges)); + + // If the top activity is not fullscreen, then we need to + // make sure any activities under it are now visible. + final int count = mHistory.size(); + int i = count-1; + while (mHistory.get(i) != top) { + i--; + } + HistoryRecord r; + boolean behindFullscreen = false; + for (; i>=0; i--) { + r = (HistoryRecord)mHistory.get(i); + if (DEBUG_VISBILITY) Log.v( + TAG, "Make visible? " + r + " finishing=" + r.finishing + + " state=" + r.state); + if (r.finishing) { + continue; + } + + final boolean doThisProcess = onlyThisProcess == null + || onlyThisProcess.equals(r.processName); + + // First: if this is not the current activity being started, make + // sure it matches the current configuration. + if (r != starting && doThisProcess) { + ensureActivityConfigurationLocked(r, 0); + } + + if (r.app == null || r.app.thread == null) { + if (onlyThisProcess == null + || onlyThisProcess.equals(r.processName)) { + // This activity needs to be visible, but isn't even + // running... get it started, but don't resume it + // at this point. + if (DEBUG_VISBILITY) Log.v( + TAG, "Start and freeze screen for " + r); + if (r != starting) { + r.startFreezingScreenLocked(r.app, configChanges); + } + if (!r.visible) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Starting and making visible: " + r); + mWindowManager.setAppVisibility(r, true); + } + if (r != starting) { + startSpecificActivityLocked(r, false, false); + } + } + + } else if (r.visible) { + // If this activity is already visible, then there is nothing + // else to do here. + if (DEBUG_VISBILITY) Log.v( + TAG, "Skipping: already visible at " + r); + r.stopFreezingScreenLocked(false); + + } else if (onlyThisProcess == null) { + // This activity is not currently visible, but is running. + // Tell it to become visible. + r.visible = true; + if (r.state != ActivityState.RESUMED && r != starting) { + // If this activity is paused, tell it + // to now show its window. + if (DEBUG_VISBILITY) Log.v( + TAG, "Making visible and scheduling visibility: " + r); + try { + mWindowManager.setAppVisibility(r, true); + r.app.thread.scheduleWindowVisibility(r, true); + r.stopFreezingScreenLocked(false); + } catch (Exception e) { + // Just skip on any failure; we'll make it + // visible when it next restarts. + Log.w(TAG, "Exception thrown making visibile: " + + r.intent.getComponent(), e); + } + } + } + + // Aggregate current change flags. + configChanges |= r.configChangeFlags; + + if (r.fullscreen) { + // At this point, nothing else needs to be shown + if (DEBUG_VISBILITY) Log.v( + TAG, "Stopping: fullscreen at " + r); + behindFullscreen = true; + i--; + break; + } + } + + // Now for any activities that aren't visible to the user, make + // sure they no longer are keeping the screen frozen. + while (i >= 0) { + r = (HistoryRecord)mHistory.get(i); + if (DEBUG_VISBILITY) Log.v( + TAG, "Make invisible? " + r + " finishing=" + r.finishing + + " state=" + r.state + + " behindFullscreen=" + behindFullscreen); + if (!r.finishing) { + if (behindFullscreen) { + if (r.visible) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Making invisible: " + r); + r.visible = false; + try { + mWindowManager.setAppVisibility(r, false); + if ((r.state == ActivityState.STOPPING + || r.state == ActivityState.STOPPED) + && r.app != null && r.app.thread != null) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Scheduling invisibility: " + r); + r.app.thread.scheduleWindowVisibility(r, false); + } + } catch (Exception e) { + // Just skip on any failure; we'll make it + // visible when it next restarts. + Log.w(TAG, "Exception thrown making hidden: " + + r.intent.getComponent(), e); + } + } else { + if (DEBUG_VISBILITY) Log.v( + TAG, "Already invisible: " + r); + } + } else if (r.fullscreen) { + if (DEBUG_VISBILITY) Log.v( + TAG, "Now behindFullscreen: " + r); + behindFullscreen = true; + } + } + i--; + } + } + + /** + * Version of ensureActivitiesVisible that can easily be called anywhere. + */ + private final void ensureActivitiesVisibleLocked(HistoryRecord starting, + int configChanges) { + HistoryRecord r = topRunningActivityLocked(null); + if (r != null) { + ensureActivitiesVisibleLocked(r, starting, null, configChanges); + } + } + + private void updateUsageStats(HistoryRecord resumedComponent, boolean resumed) { + if (resumed) { + mUsageStatsService.noteResumeComponent(resumedComponent.realActivity); + } else { + mUsageStatsService.notePauseComponent(resumedComponent.realActivity); + } + } + + /** + * Ensure that the top activity in the stack is resumed. + * + * @param prev The previously resumed activity, for when in the process + * of pausing; can be null to call from elsewhere. + * + * @return Returns true if something is being resumed, or false if + * nothing happened. + */ + private final boolean resumeTopActivityLocked(HistoryRecord prev) { + // Find the first activity that is not finishing. + HistoryRecord next = topRunningActivityLocked(null); + + // Remember how we'll process this pause/resume situation, and ensure + // that the state is reset however we wind up proceeding. + final boolean userLeaving = mUserLeaving; + mUserLeaving = false; + + if (next == null) { + // There are no more activities! Let's just start up the + // Launcher... + if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL + && mTopAction == null) { + // We are running in factory test mode, but unable to find + // the factory test app, so just sit around displaying the + // error message and don't try to start anything. + return false; + } + Intent intent = new Intent( + mTopAction, + mTopData != null ? Uri.parse(mTopData) : null); + intent.setComponent(mTopComponent); + if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { + intent.addCategory(Intent.CATEGORY_HOME); + } + ActivityInfo aInfo = + intent.resolveActivityInfo(mContext.getPackageManager(), + PackageManager.GET_SHARED_LIBRARY_FILES); + if (aInfo != null) { + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + // Don't do this if the home app is currently being + // instrumented. + ProcessRecord app = getProcessRecordLocked(aInfo.processName, + aInfo.applicationInfo.uid); + if (app == null || app.instrumentationClass == null) { + intent.setFlags(intent.getFlags() | Intent.FLAG_ACTIVITY_NEW_TASK); + startActivityLocked(null, intent, null, null, 0, aInfo, + null, null, 0, 0, 0, false); + } + } + return true; + } + + // If the top activity is the resumed one, nothing to do. + if (mResumedActivity == next && next.state == ActivityState.RESUMED) { + // Make sure we have executed any pending transitions, since there + // should be nothing left to do at this point. + mWindowManager.executeAppTransition(); + return false; + } + + // If we are sleeping, and there is no resumed activity, and the top + // activity is paused, well that is the state we want. + if (mSleeping && mLastPausedActivity == next && next.state == ActivityState.PAUSED) { + // Make sure we have executed any pending transitions, since there + // should be nothing left to do at this point. + mWindowManager.executeAppTransition(); + return false; + } + + // The activity may be waiting for stop, but that is no longer + // appropriate for it. + mStoppingActivities.remove(next); + mWaitingVisibleActivities.remove(next); + + if (DEBUG_SWITCH) Log.v(TAG, "Resuming " + next); + + // If we are currently pausing an activity, then don't do anything + // until that is done. + if (mPausingActivity != null) { + if (DEBUG_SWITCH) Log.v(TAG, "Skip resume: pausing=" + mPausingActivity); + return false; + } + + // We need to start pausing the current activity so the top one + // can be resumed... + if (mResumedActivity != null) { + if (DEBUG_SWITCH) Log.v(TAG, "Skip resume: need to start pausing"); + startPausingLocked(userLeaving, false); + return true; + } + + if (prev != null && prev != next) { + if (!prev.waitingVisible && next != null && !next.nowVisible) { + prev.waitingVisible = true; + mWaitingVisibleActivities.add(prev); + if (DEBUG_SWITCH) Log.v( + TAG, "Resuming top, waiting visible to hide: " + prev); + } else { + // The next activity is already visible, so hide the previous + // activity's windows right now so we can show the new one ASAP. + // We only do this if the previous is finishing, which should mean + // it is on top of the one being resumed so hiding it quickly + // is good. Otherwise, we want to do the normal route of allowing + // the resumed activity to be shown so we can decide if the + // previous should actually be hidden depending on whether the + // new one is found to be full-screen or not. + if (prev.finishing) { + mWindowManager.setAppVisibility(prev, false); + if (DEBUG_SWITCH) Log.v(TAG, "Not waiting for visible to hide: " + + prev + ", waitingVisible=" + + (prev != null ? prev.waitingVisible : null) + + ", nowVisible=" + next.nowVisible); + } else { + if (DEBUG_SWITCH) Log.v(TAG, "Previous already visible but still waiting to hide: " + + prev + ", waitingVisible=" + + (prev != null ? prev.waitingVisible : null) + + ", nowVisible=" + next.nowVisible); + } + } + } + + // We are starting up the next activity, so tell the window manager + // that the previous one will be hidden soon. This way it can know + // to ignore it when computing the desired screen orientation. + if (prev != null) { + if (prev.finishing) { + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare close transition: prev=" + prev); + mWindowManager.prepareAppTransition(prev.task == next.task + ? WindowManagerPolicy.TRANSIT_ACTIVITY_CLOSE + : WindowManagerPolicy.TRANSIT_TASK_CLOSE); + mWindowManager.setAppWillBeHidden(prev); + mWindowManager.setAppVisibility(prev, false); + } else { + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare open transition: prev=" + prev); + mWindowManager.prepareAppTransition(prev.task == next.task + ? WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN + : WindowManagerPolicy.TRANSIT_TASK_OPEN); + } + if (false) { + mWindowManager.setAppWillBeHidden(prev); + mWindowManager.setAppVisibility(prev, false); + } + } else if (mHistory.size() > 1) { + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare open transition: no previous"); + mWindowManager.prepareAppTransition(WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN); + } + + if (next.app != null && next.app.thread != null) { + if (DEBUG_SWITCH) Log.v(TAG, "Resume running: " + next); + + // This activity is now becoming visible. + mWindowManager.setAppVisibility(next, true); + + HistoryRecord lastResumedActivity = mResumedActivity; + ActivityState lastState = next.state; + + updateCpuStats(); + + next.state = ActivityState.RESUMED; + mResumedActivity = next; + next.task.touchActiveTime(); + updateLRUListLocked(next.app, true); + updateLRUListLocked(next); + + // Have the window manager re-evaluate the orientation of + // the screen based on the new activity order. + Configuration config = mWindowManager.updateOrientationFromAppTokens( + next.mayFreezeScreenLocked(next.app) ? next : null); + if (config != null) { + next.frozenBeforeDestroy = true; + } + if (!updateConfigurationLocked(config, next)) { + // The configuration update wasn't able to keep the existing + // instance of the activity, and instead started a new one. + // We should be all done, but let's just make sure our activity + // is still at the top and schedule another run if something + // weird happened. + HistoryRecord nextNext = topRunningActivityLocked(null); + if (DEBUG_SWITCH) Log.i(TAG, + "Activity config changed during resume: " + next + + ", new next: " + nextNext); + if (nextNext != next) { + // Do over! + mHandler.sendEmptyMessage(RESUME_TOP_ACTIVITY_MSG); + } + mWindowManager.executeAppTransition(); + return true; + } + + try { + // Deliver all pending results. + ArrayList a = next.results; + if (a != null) { + final int N = a.size(); + if (!next.finishing && N > 0) { + if (localLOGV) Log.v( + TAG, "Delivering results to " + next + + ": " + a); + next.app.thread.scheduleSendResult(next, a); + } + } + + if (next.newIntents != null) { + next.app.thread.scheduleNewIntent(next.newIntents, next); + } + + EventLog.writeEvent(LOG_AM_RESUME_ACTIVITY, + System.identityHashCode(next), + next.task.taskId, next.shortComponentName); + updateUsageStats(next, true); + + next.app.thread.scheduleResumeActivity(next, + isNextTransitionForward()); + pauseIfSleepingLocked(); + + } catch (Exception e) { + // Whoops, need to restart this activity! + next.state = lastState; + mResumedActivity = lastResumedActivity; + if (Config.LOGD) Log.d(TAG, + "Restarting because process died: " + next); + if (!next.hasBeenLaunched) { + next.hasBeenLaunched = true; + } else { + if (SHOW_APP_STARTING_ICON) { + mWindowManager.setAppStartingWindow( + next, next.packageName, next.theme, + next.nonLocalizedLabel, + next.labelRes, next.icon, null, true); + } + } + startSpecificActivityLocked(next, true, false); + return true; + } + + // From this point on, if something goes wrong there is no way + // to recover the activity. + try { + next.visible = true; + completeResumeLocked(next); + } catch (Exception e) { + // If any exception gets thrown, toss away this + // activity and try the next one. + Log.w(TAG, "Exception thrown during resume of " + next, e); + requestFinishActivityLocked(next, Activity.RESULT_CANCELED, null, + "resume-exception"); + return true; + } + + // Didn't need to use the icicle, and it is now out of date. + next.icicle = null; + next.haveState = false; + next.stopped = false; + + } else { + // Whoops, need to restart this activity! + if (!next.hasBeenLaunched) { + next.hasBeenLaunched = true; + } else { + if (SHOW_APP_STARTING_ICON) { + mWindowManager.setAppStartingWindow( + next, next.packageName, next.theme, + next.nonLocalizedLabel, + next.labelRes, next.icon, null, true); + } + if (DEBUG_SWITCH) Log.v(TAG, "Restarting: " + next); + } + startSpecificActivityLocked(next, true, true); + } + + return true; + } + + private final void startActivityLocked(HistoryRecord r, boolean newTask) { + final int NH = mHistory.size(); + + int addPos = -1; + + if (!newTask) { + // If starting in an existing task, find where that is... + HistoryRecord next = null; + boolean startIt = true; + for (int i = NH-1; i >= 0; i--) { + HistoryRecord p = (HistoryRecord)mHistory.get(i); + if (p.finishing) { + continue; + } + if (p.task == r.task) { + // Here it is! Now, if this is not yet visible to the + // user, then just add it without starting; it will + // get started when the user navigates back to it. + addPos = i+1; + if (!startIt) { + mHistory.add(addPos, r); + r.inHistory = true; + r.task.numActivities++; + mWindowManager.addAppToken(addPos, r, r.task.taskId, + r.info.screenOrientation, r.fullscreen); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + return; + } + break; + } + if (p.fullscreen) { + startIt = false; + } + next = p; + } + } + + // Place a new activity at top of stack, so it is next to interact + // with the user. + if (addPos < 0) { + addPos = mHistory.size(); + } + + // If we are not placing the new activity frontmost, we do not want + // to deliver the onUserLeaving callback to the actual frontmost + // activity + if (addPos < NH) { + mUserLeaving = false; + if (DEBUG_USER_LEAVING) Log.v(TAG, "startActivity() behind front, mUserLeaving=false"); + } + + // Slot the activity into the history stack and proceed + mHistory.add(addPos, r); + r.inHistory = true; + r.frontOfTask = newTask; + r.task.numActivities++; + if (NH > 0) { + // We want to show the starting preview window if we are + // switching to a new task, or the next activity's process is + // not currently running. + boolean showStartingIcon = newTask; + ProcessRecord proc = r.app; + if (proc == null) { + proc = mProcessNames.get(r.processName, r.info.applicationInfo.uid); + } + if (proc == null || proc.thread == null) { + showStartingIcon = true; + } + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare open transition: starting " + r); + mWindowManager.prepareAppTransition(newTask + ? WindowManagerPolicy.TRANSIT_TASK_OPEN + : WindowManagerPolicy.TRANSIT_ACTIVITY_OPEN); + mWindowManager.addAppToken( + addPos, r, r.task.taskId, r.info.screenOrientation, r.fullscreen); + boolean doShow = true; + if (newTask) { + // Even though this activity is starting fresh, we still need + // to reset it to make sure we apply affinities to move any + // existing activities from other tasks in to it. + // If the caller has requested that the target task be + // reset, then do so. + if ((r.intent.getFlags() + &Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) { + resetTaskIfNeededLocked(r, r); + doShow = topRunningActivityLocked(null) == r; + } + } + if (SHOW_APP_STARTING_ICON && doShow) { + // Figure out if we are transitioning from another activity that is + // "has the same starting icon" as the next one. This allows the + // window manager to keep the previous window it had previously + // created, if it still had one. + HistoryRecord prev = mResumedActivity; + if (prev != null) { + // We don't want to reuse the previous starting preview if: + // (1) The current activity is in a different task. + if (prev.task != r.task) prev = null; + // (2) The current activity is already displayed. + else if (prev.nowVisible) prev = null; + } + mWindowManager.setAppStartingWindow( + r, r.packageName, r.theme, r.nonLocalizedLabel, + r.labelRes, r.icon, prev, showStartingIcon); + } + } else { + // If this is the first activity, don't do any fancy animations, + // because there is nothing for it to animate on top of. + mWindowManager.addAppToken(addPos, r, r.task.taskId, + r.info.screenOrientation, r.fullscreen); + } + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + + resumeTopActivityLocked(null); + } + + /** + * Perform clear operation as requested by + * {@link Intent#FLAG_ACTIVITY_CLEAR_TOP}: assuming the top task on the + * stack is the one that the new activity is being launched in, look for + * an instance of that activity in the stack and, if found, finish all + * activities on top of it and return the instance. + * + * @param newR Description of the new activity being started. + * @return Returns the old activity that should be continue to be used, + * or null if none was found. + */ + private final HistoryRecord performClearTopTaskLocked(int taskId, + HistoryRecord newR, boolean doClear) { + int i = mHistory.size(); + while (i > 0) { + i--; + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.finishing) { + continue; + } + if (r.task.taskId != taskId) { + return null; + } + if (r.realActivity.equals(newR.realActivity)) { + // Here it is! Now finish everything in front... + HistoryRecord ret = r; + if (doClear) { + while (i < (mHistory.size()-1)) { + i++; + r = (HistoryRecord)mHistory.get(i); + if (r.finishing) { + continue; + } + if (finishActivityLocked(r, i, Activity.RESULT_CANCELED, + null, "clear")) { + i--; + } + } + } + + // Finally, if this is a normal launch mode (that is, not + // expecting onNewIntent()), then we will finish the current + // instance of the activity so a new fresh one can be started. + if (ret.launchMode == ActivityInfo.LAUNCH_MULTIPLE) { + if (!ret.finishing) { + int index = indexOfTokenLocked(ret, false); + if (index >= 0) { + finishActivityLocked(ret, 0, Activity.RESULT_CANCELED, + null, "clear"); + } + return null; + } + } + + return ret; + } + } + + return null; + } + + /** + * Find the activity in the history stack within the given task. Returns + * the index within the history at which it's found, or < 0 if not found. + */ + private final int findActivityInHistoryLocked(HistoryRecord r, int task) { + int i = mHistory.size(); + while (i > 0) { + i--; + HistoryRecord candidate = (HistoryRecord)mHistory.get(i); + if (candidate.task.taskId != task) { + break; + } + if (candidate.realActivity.equals(r.realActivity)) { + return i; + } + } + + return -1; + } + + /** + * Reorder the history stack so that the activity at the given index is + * brought to the front. + */ + private final HistoryRecord moveActivityToFrontLocked(int where) { + HistoryRecord newTop = (HistoryRecord)mHistory.remove(where); + int top = mHistory.size(); + HistoryRecord oldTop = (HistoryRecord)mHistory.get(top-1); + mHistory.add(top, newTop); + oldTop.frontOfTask = false; + newTop.frontOfTask = true; + return newTop; + } + + /** + * Deliver a new Intent to an existing activity, so that its onNewIntent() + * method will be called at the proper time. + */ + private final void deliverNewIntentLocked(HistoryRecord r, Intent intent) { + boolean sent = false; + if (r.state == ActivityState.RESUMED + && r.app != null && r.app.thread != null) { + try { + ArrayList<Intent> ar = new ArrayList<Intent>(); + ar.add(new Intent(intent)); + r.app.thread.scheduleNewIntent(ar, r); + sent = true; + } catch (Exception e) { + Log.w(TAG, "Exception thrown sending new intent to " + r, e); + } + } + if (!sent) { + r.addNewIntentLocked(new Intent(intent)); + } + } + + private final void logStartActivity(int tag, HistoryRecord r, + TaskRecord task) { + EventLog.writeEvent(tag, + System.identityHashCode(r), task.taskId, + r.shortComponentName, r.intent.getAction(), + r.intent.getType(), r.intent.getDataString(), + r.intent.getFlags()); + } + + private final int startActivityLocked(IApplicationThread caller, + Intent intent, String resolvedType, + Uri[] grantedUriPermissions, + int grantedMode, ActivityInfo aInfo, IBinder resultTo, + String resultWho, int requestCode, + int callingPid, int callingUid, boolean onlyIfNeeded) { + Log.i(TAG, "Starting activity: " + intent); + + HistoryRecord sourceRecord = null; + HistoryRecord resultRecord = null; + if (resultTo != null) { + int index = indexOfTokenLocked(resultTo, false); + if (localLOGV) Log.v( + TAG, "Sending result to " + resultTo + " (index " + index + ")"); + if (index >= 0) { + sourceRecord = (HistoryRecord)mHistory.get(index); + if (requestCode >= 0 && !sourceRecord.finishing) { + resultRecord = sourceRecord; + } + } + } + + int launchFlags = intent.getFlags(); + + if ((launchFlags&Intent.FLAG_ACTIVITY_FORWARD_RESULT) != 0 + && sourceRecord != null) { + // Transfer the result target from the source activity to the new + // one being started, including any failures. + if (requestCode >= 0) { + return START_FORWARD_AND_REQUEST_CONFLICT; + } + resultRecord = sourceRecord.resultTo; + resultWho = sourceRecord.resultWho; + requestCode = sourceRecord.requestCode; + sourceRecord.resultTo = null; + if (resultRecord != null) { + resultRecord.removeResultsLocked( + sourceRecord, resultWho, requestCode); + } + } + + int err = START_SUCCESS; + + if (intent.getComponent() == null) { + // We couldn't find a class that can handle the given Intent. + // That's the end of that! + err = START_INTENT_NOT_RESOLVED; + } + + if (err == START_SUCCESS && aInfo == null) { + // We couldn't find the specific class specified in the Intent. + // Also the end of the line. + err = START_CLASS_NOT_FOUND; + } + + ProcessRecord callerApp = null; + if (err == START_SUCCESS && caller != null) { + callerApp = getRecordForAppLocked(caller); + if (callerApp != null) { + callingPid = callerApp.pid; + callingUid = callerApp.info.uid; + } else { + Log.w(TAG, "Unable to find app for caller " + caller + + " (pid=" + callingPid + ") when starting: " + + intent.toString()); + err = START_PERMISSION_DENIED; + } + } + + if (err != START_SUCCESS) { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + return err; + } + + final int perm = checkComponentPermission(aInfo.permission, callingPid, + callingUid, aInfo.exported ? -1 : aInfo.applicationInfo.uid); + if (perm != PackageManager.PERMISSION_GRANTED) { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + String msg = "Permission Denial: starting " + intent.toString() + + " from " + callerApp + " (pid=" + callingPid + + ", uid=" + callingUid + ")" + + " requires " + aInfo.permission; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + if (mWatcher != null) { + boolean abort = false; + try { + // The Intent we give to the watcher has the extra data + // stripped off, since it can contain private information. + Intent watchIntent = intent.cloneFilter(); + abort = !mWatcher.activityStarting(watchIntent, + aInfo.applicationInfo.packageName); + } catch (RemoteException e) { + mWatcher = null; + } + + if (abort) { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + // We pretend to the caller that it was really started, but + // they will just get a cancel result. + return START_SUCCESS; + } + } + + HistoryRecord r = new HistoryRecord(this, callerApp, callingUid, + intent, resolvedType, aInfo, mConfiguration, + resultRecord, resultWho, requestCode); + r.startTime = SystemClock.uptimeMillis(); + + HistoryRecord notTop = (launchFlags&Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP) + != 0 ? r : null; + + // We'll invoke onUserLeaving before onPause only if the launching + // activity did not explicitly state that this is an automated launch. + mUserLeaving = (launchFlags&Intent.FLAG_ACTIVITY_NO_USER_ACTION) == 0; + if (DEBUG_USER_LEAVING) Log.v(TAG, + "startActivity() => mUserLeaving=" + mUserLeaving); + + // If the onlyIfNeeded flag is set, then we can do this if the activity + // being launched is the same as the one making the call... or, as + // a special case, if we do not know the caller then we count the + // current top activity as the caller. + if (onlyIfNeeded) { + HistoryRecord checkedCaller = sourceRecord; + if (checkedCaller == null) { + checkedCaller = topRunningActivityLocked(notTop); + } + if (!checkedCaller.realActivity.equals(r.realActivity)) { + // Caller is not the same as launcher, so always needed. + onlyIfNeeded = false; + } + } + + if (grantedUriPermissions != null && callingUid > 0) { + for (int i=0; i<grantedUriPermissions.length; i++) { + grantUriPermissionLocked(callingUid, r.packageName, + grantedUriPermissions[i], grantedMode, r); + } + } + + grantUriPermissionFromIntentLocked(callingUid, r.packageName, + intent, r); + + if (sourceRecord == null) { + // This activity is not being started from another... in this + // case we -always- start a new task. + if ((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { + Log.w(TAG, "startActivity called from non-Activity context; forcing Intent.FLAG_ACTIVITY_NEW_TASK for: " + + intent); + launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; + } + } else if (sourceRecord.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + // The original activity who is starting us is running as a single + // instance... this new activity it is starting must go on its + // own task. + launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; + } else if (r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) { + // The activity being started is a single instance... it always + // gets launched into its own task. + launchFlags |= Intent.FLAG_ACTIVITY_NEW_TASK; + } + + if (resultRecord != null && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { + // For whatever reason this activity is being launched into a new + // task... yet the caller has requested a result back. Well, that + // is pretty messed up, so instead immediately send back a cancel + // and let the new task continue launched as normal without a + // dependency on its originator. + Log.w(TAG, "Activity is launching as a new task, so cancelling activity result."); + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + r.resultTo = null; + resultRecord = null; + } + + boolean addingToTask = false; + if (((launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0 && + (launchFlags&Intent.FLAG_ACTIVITY_MULTIPLE_TASK) == 0) + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + // If bring to front is requested, and no result is requested, and + // we can find a task that was started with this same + // component, then instead of launching bring that one to the front. + if (resultRecord == null) { + // See if there is a task to bring to the front. If this is + // a SINGLE_INSTANCE activity, there can be one and only one + // instance of it in the history, and it is always in its own + // unique task, so we do a special search. + HistoryRecord taskTop = r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE + ? findTaskLocked(intent, r.info) + : findActivityLocked(intent, r.info); + if (taskTop != null) { + if (taskTop.task.intent == null) { + // This task was started because of movement of + // the activity based on affinity... now that we + // are actually launching it, we can assign the + // base intent. + taskTop.task.setIntent(intent, r.info); + } + // If the target task is not in the front, then we need + // to bring it to the front... except... well, with + // SINGLE_TASK_LAUNCH it's not entirely clear. We'd like + // to have the same behavior as if a new instance was + // being started, which means not bringing it to the front + // if the caller is not itself in the front. + HistoryRecord curTop = topRunningActivityLocked(notTop); + if (curTop.task != taskTop.task) { + r.intent.addFlags(Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT); + boolean callerAtFront = sourceRecord == null + || curTop.task == sourceRecord.task; + if (callerAtFront) { + // We really do want to push this one into the + // user's face, right now. + moveTaskToFrontLocked(taskTop.task); + } + } + // If the caller has requested that the target task be + // reset, then do so. + if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) { + taskTop = resetTaskIfNeededLocked(taskTop, r); + } + if (onlyIfNeeded) { + // We don't need to start a new activity, and + // the client said not to do anything if that + // is the case, so this is it! And for paranoia, make + // sure we have correctly resumed the top activity. + resumeTopActivityLocked(null); + return START_RETURN_INTENT_TO_CALLER; + } + if ((launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0 + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + // In this situation we want to remove all activities + // from the task up to the one being started. In most + // cases this means we are resetting the task to its + // initial state. + HistoryRecord top = performClearTopTaskLocked( + taskTop.task.taskId, r, true); + if (top != null) { + if (top.frontOfTask) { + // Activity aliases may mean we use different + // intents for the top activity, so make sure + // the task now has the identity of the new + // intent. + top.task.setIntent(r.intent, r.info); + } + logStartActivity(LOG_AM_NEW_INTENT, r, top.task); + deliverNewIntentLocked(top, r.intent); + } else { + // A special case: we need to + // start the activity because it is not currently + // running, and the caller has asked to clear the + // current task to have this activity at the top. + addingToTask = true; + // Now pretend like this activity is being started + // by the top of its task, so it is put in the + // right place. + sourceRecord = taskTop; + } + } else if (r.realActivity.equals(taskTop.task.realActivity)) { + // In this case the top activity on the task is the + // same as the one being launched, so we take that + // as a request to bring the task to the foreground. + // If the top activity in the task is the root + // activity, deliver this new intent to it if it + // desires. + if ((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 + && taskTop.realActivity.equals(r.realActivity)) { + logStartActivity(LOG_AM_NEW_INTENT, r, taskTop.task); + if (taskTop.frontOfTask) { + taskTop.task.setIntent(r.intent, r.info); + } + deliverNewIntentLocked(taskTop, r.intent); + } else if (!r.intent.filterEquals(taskTop.task.intent)) { + // In this case we are launching the root activity + // of the task, but with a different intent. We + // should start a new instance on top. + addingToTask = true; + sourceRecord = taskTop; + } + } else if ((launchFlags&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) == 0) { + // In this case an activity is being launched in to an + // existing task, without resetting that task. This + // is typically the situation of launching an activity + // from a notification or shortcut. We want to place + // the new activity on top of the current task. + addingToTask = true; + sourceRecord = taskTop; + } else if (!taskTop.task.rootWasReset) { + // In this case we are launching in to an existing task + // that has not yet been started from its front door. + // The current task has been brought to the front. + // Ideally, we'd probably like to place this new task + // at the bottom of its stack, but that's a little hard + // to do with the current organization of the code so + // for now we'll just drop it. + taskTop.task.setIntent(r.intent, r.info); + } + if (!addingToTask) { + // We didn't do anything... but it was needed (a.k.a., client + // don't use that intent!) And for paranoia, make + // sure we have correctly resumed the top activity. + resumeTopActivityLocked(null); + return START_TASK_TO_FRONT; + } + } + } + } + + //String uri = r.intent.toURI(); + //Intent intent2 = new Intent(uri); + //Log.i(TAG, "Given intent: " + r.intent); + //Log.i(TAG, "URI is: " + uri); + //Log.i(TAG, "To intent: " + intent2); + + if (r.packageName != null) { + // If the activity being launched is the same as the one currently + // at the top, then we need to check if it should only be launched + // once. + HistoryRecord top = topRunningActivityLocked(notTop); + if (top != null && resultRecord == null) { + if (top.realActivity.equals(r.realActivity)) { + if (top.app != null && top.app.thread != null) { + if ((launchFlags&Intent.FLAG_ACTIVITY_SINGLE_TOP) != 0 + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP + || r.launchMode == ActivityInfo.LAUNCH_SINGLE_TASK) { + logStartActivity(LOG_AM_NEW_INTENT, top, top.task); + // For paranoia, make sure we have correctly + // resumed the top activity. + resumeTopActivityLocked(null); + if (onlyIfNeeded) { + // We don't need to start a new activity, and + // the client said not to do anything if that + // is the case, so this is it! + return START_RETURN_INTENT_TO_CALLER; + } + deliverNewIntentLocked(top, r.intent); + return START_DELIVERED_TO_TOP; + } + } + } + } + + } else { + if (resultRecord != null) { + sendActivityResultLocked(-1, + resultRecord, resultWho, requestCode, + Activity.RESULT_CANCELED, null); + } + return START_CLASS_NOT_FOUND; + } + + boolean newTask = false; + + // Should this be considered a new task? + if (resultRecord == null && !addingToTask + && (launchFlags&Intent.FLAG_ACTIVITY_NEW_TASK) != 0) { + // todo: should do better management of integers. + mCurTask++; + if (mCurTask <= 0) { + mCurTask = 1; + } + r.task = new TaskRecord(mCurTask, r.info, intent, + (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0); + if (DEBUG_TASKS) Log.v(TAG, "Starting new activity " + r + + " in new task " + r.task); + newTask = true; + addRecentTask(r.task); + + } else if (sourceRecord != null) { + if (!addingToTask && + (launchFlags&Intent.FLAG_ACTIVITY_CLEAR_TOP) != 0) { + // In this case, we are adding the activity to an existing + // task, but the caller has asked to clear that task if the + // activity is already running. + HistoryRecord top = performClearTopTaskLocked( + sourceRecord.task.taskId, r, true); + if (top != null) { + logStartActivity(LOG_AM_NEW_INTENT, r, top.task); + deliverNewIntentLocked(top, r.intent); + // For paranoia, make sure we have correctly + // resumed the top activity. + resumeTopActivityLocked(null); + return START_DELIVERED_TO_TOP; + } + } else if (!addingToTask && + (launchFlags&Intent.FLAG_ACTIVITY_REORDER_TO_FRONT) != 0) { + // In this case, we are launching an activity in our own task + // that may already be running somewhere in the history, and + // we want to shuffle it to the front of the stack if so. + int where = findActivityInHistoryLocked(r, sourceRecord.task.taskId); + if (where >= 0) { + HistoryRecord top = moveActivityToFrontLocked(where); + logStartActivity(LOG_AM_NEW_INTENT, r, top.task); + deliverNewIntentLocked(top, r.intent); + resumeTopActivityLocked(null); + return START_DELIVERED_TO_TOP; + } + } + // An existing activity is starting this new activity, so we want + // to keep the new one in the same task as the one that is starting + // it. + r.task = sourceRecord.task; + if (DEBUG_TASKS) Log.v(TAG, "Starting new activity " + r + + " in existing task " + r.task); + + } else { + // This not being started from an existing activity, and not part + // of a new task... just put it in the top task, though these days + // this case should never happen. + final int N = mHistory.size(); + HistoryRecord prev = + N > 0 ? (HistoryRecord)mHistory.get(N-1) : null; + r.task = prev != null + ? prev.task + : new TaskRecord(mCurTask, r.info, intent, + (r.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0); + if (DEBUG_TASKS) Log.v(TAG, "Starting new activity " + r + + " in new guessed " + r.task); + } + if (newTask) { + EventLog.writeEvent(LOG_AM_CREATE_TASK, r.task.taskId); + } + logStartActivity(LOG_AM_CREATE_ACTIVITY, r, r.task); + startActivityLocked(r, newTask); + return START_SUCCESS; + } + + public final int startActivity(IApplicationThread caller, + Intent intent, String resolvedType, Uri[] grantedUriPermissions, + int grantedMode, IBinder resultTo, + String resultWho, int requestCode, boolean onlyIfNeeded, + boolean debug) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + // Don't modify the client's object! + intent = new Intent(intent); + + // Collect information about the target of the Intent. + // Must do this before locking, because resolving the intent + // may require launching a process to run its content provider. + ActivityInfo aInfo; + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveIntent( + intent, resolvedType, + PackageManager.MATCH_DEFAULT_ONLY + | PackageManager.GET_SHARED_LIBRARY_FILES); + aInfo = rInfo != null ? rInfo.activityInfo : null; + } catch (RemoteException e) { + aInfo = null; + } + + if (aInfo != null) { + // Store the found target back into the intent, because now that + // we have it we never want to do this again. For example, if the + // user navigates back to this point in the history, we should + // always restart the exact same activity. + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + + // Don't debug things in the system process + if (debug) { + if (!aInfo.processName.equals("system")) { + setDebugApp(aInfo.processName, true, false); + } + } + } + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + int res = startActivityLocked(caller, intent, resolvedType, + grantedUriPermissions, grantedMode, aInfo, + resultTo, resultWho, requestCode, -1, -1, + onlyIfNeeded); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + public boolean startNextMatchingActivity(IBinder callingActivity, + Intent intent) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized (this) { + int index = indexOfTokenLocked(callingActivity, false); + if (index < 0) { + return false; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + if (r.app == null || r.app.thread == null) { + // The caller is not running... d'oh! + return false; + } + intent = new Intent(intent); + // The caller is not allowed to change the data. + intent.setDataAndType(r.intent.getData(), r.intent.getType()); + // And we are resetting to find the next component... + intent.setComponent(null); + + ActivityInfo aInfo = null; + try { + List<ResolveInfo> resolves = + ActivityThread.getPackageManager().queryIntentActivities( + intent, r.resolvedType, + PackageManager.MATCH_DEFAULT_ONLY + | PackageManager.GET_SHARED_LIBRARY_FILES); + + // Look for the original activity in the list... + final int N = resolves != null ? resolves.size() : 0; + for (int i=0; i<N; i++) { + ResolveInfo rInfo = resolves.get(i); + if (rInfo.activityInfo.packageName.equals(r.packageName) + && rInfo.activityInfo.name.equals(r.info.name)) { + // We found the current one... the next matching is + // after it. + i++; + if (i<N) { + aInfo = resolves.get(i).activityInfo; + } + break; + } + } + } catch (RemoteException e) { + } + + if (aInfo == null) { + // Nobody who is next! + return false; + } + + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + intent.setFlags(intent.getFlags()&~( + Intent.FLAG_ACTIVITY_FORWARD_RESULT| + Intent.FLAG_ACTIVITY_CLEAR_TOP| + Intent.FLAG_ACTIVITY_MULTIPLE_TASK| + Intent.FLAG_ACTIVITY_NEW_TASK)); + + // Okay now we need to start the new activity, replacing the + // currently running activity. This is a little tricky because + // we want to start the new one as if the current one is finished, + // but not finish the current one first so that there is no flicker. + // And thus... + final boolean wasFinishing = r.finishing; + r.finishing = true; + + // Propagate reply information over to the new activity. + final HistoryRecord resultTo = r.resultTo; + final String resultWho = r.resultWho; + final int requestCode = r.requestCode; + r.resultTo = null; + if (resultTo != null) { + resultTo.removeResultsLocked(r, resultWho, requestCode); + } + + final long origId = Binder.clearCallingIdentity(); + // XXX we are not dealing with propagating grantedUriPermissions... + // those are not yet exposed to user code, so there is no need. + int res = startActivityLocked(r.app.thread, intent, + r.resolvedType, null, 0, aInfo, resultTo, resultWho, + requestCode, -1, r.launchedFromUid, false); + Binder.restoreCallingIdentity(origId); + + r.finishing = wasFinishing; + if (res != START_SUCCESS) { + return false; + } + return true; + } + } + + final int startActivityInPackage(int uid, + Intent intent, String resolvedType, IBinder resultTo, + String resultWho, int requestCode, boolean onlyIfNeeded) { + // Don't modify the client's object! + intent = new Intent(intent); + + // Collect information about the target of the Intent. + // Must do this before locking, because resolving the intent + // may require launching a process to run its content provider. + ActivityInfo aInfo; + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveIntent( + intent, resolvedType, + PackageManager.MATCH_DEFAULT_ONLY + | PackageManager.GET_SHARED_LIBRARY_FILES); + aInfo = rInfo != null ? rInfo.activityInfo : null; + } catch (RemoteException e) { + aInfo = null; + } + + if (aInfo != null) { + // Store the found target back into the intent, because now that + // we have it we never want to do this again. For example, if the + // user navigates back to this point in the history, we should + // always restart the exact same activity. + intent.setComponent(new ComponentName( + aInfo.applicationInfo.packageName, aInfo.name)); + } + + synchronized(this) { + return startActivityLocked(null, intent, resolvedType, + null, 0, aInfo, resultTo, resultWho, requestCode, -1, uid, + onlyIfNeeded); + } + } + + private final void addRecentTask(TaskRecord task) { + // Remove any existing entries that are the same kind of task. + int N = mRecentTasks.size(); + for (int i=0; i<N; i++) { + TaskRecord tr = mRecentTasks.get(i); + if ((task.affinity != null && task.affinity.equals(tr.affinity)) + || (task.intent != null && task.intent.filterEquals(tr.intent))) { + mRecentTasks.remove(i); + i--; + N--; + if (task.intent == null) { + // If the new recent task we are adding is not fully + // specified, then replace it with the existing recent task. + task = tr; + } + } + } + if (N >= MAX_RECENT_TASKS) { + mRecentTasks.remove(N-1); + } + mRecentTasks.add(0, task); + } + + public void setRequestedOrientation(IBinder token, + int requestedOrientation) { + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + final long origId = Binder.clearCallingIdentity(); + mWindowManager.setAppOrientation(r, requestedOrientation); + Configuration config = mWindowManager.updateOrientationFromAppTokens( + r.mayFreezeScreenLocked(r.app) ? r : null); + if (config != null) { + r.frozenBeforeDestroy = true; + if (!updateConfigurationLocked(config, r)) { + resumeTopActivityLocked(null); + } + } + Binder.restoreCallingIdentity(origId); + } + } + + public int getRequestedOrientation(IBinder token) { + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + return mWindowManager.getAppOrientation(r); + } + } + + private final void stopActivityLocked(HistoryRecord r) { + if (DEBUG_SWITCH) Log.d(TAG, "Stopping: " + r); + if ((r.intent.getFlags()&Intent.FLAG_ACTIVITY_NO_HISTORY) != 0 + || (r.info.flags&ActivityInfo.FLAG_NO_HISTORY) != 0) { + if (!r.finishing) { + requestFinishActivityLocked(r, Activity.RESULT_CANCELED, null, + "no-history"); + } + } else if (r.app != null && r.app.thread != null) { + if (mFocusedActivity == r) { + setFocusedActivityLocked(topRunningActivityLocked(null)); + } + r.resumeKeyDispatchingLocked(); + try { + r.stopped = false; + r.state = ActivityState.STOPPING; + if (DEBUG_VISBILITY) Log.v( + TAG, "Stopping visible=" + r.visible + " for " + r); + if (!r.visible) { + mWindowManager.setAppVisibility(r, false); + } + r.app.thread.scheduleStopActivity(r, r.visible, r.configChangeFlags); + } catch (Exception e) { + // Maybe just ignore exceptions here... if the process + // has crashed, our death notification will clean things + // up. + Log.w(TAG, "Exception thrown during pause", e); + // Just in case, assume it to be stopped. + r.stopped = true; + r.state = ActivityState.STOPPED; + if (r.configDestroy) { + destroyActivityLocked(r, true); + } + } + } + } + + /** + * @return Returns true if the activity is being finished, false if for + * some reason it is being left as-is. + */ + private final boolean requestFinishActivityLocked(IBinder token, int resultCode, + Intent resultData, String reason) { + if (localLOGV) Log.v( + TAG, "Finishing activity: token=" + token + + ", result=" + resultCode + ", data=" + resultData); + + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return false; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + + // Is this the last activity left? + boolean lastActivity = true; + for (int i=mHistory.size()-1; i>=0; i--) { + HistoryRecord p = (HistoryRecord)mHistory.get(i); + if (!p.finishing && p != r) { + lastActivity = false; + break; + } + } + + // If this is the last activity, but it is the home activity, then + // just don't finish it. + if (lastActivity) { + if (r.intent.hasCategory(Intent.CATEGORY_HOME)) { + return false; + } + } + + finishActivityLocked(r, index, resultCode, resultData, reason); + return true; + } + + /** + * @return Returns true if this activity has been removed from the history + * list, or false if it is still in the list and will be removed later. + */ + private final boolean finishActivityLocked(HistoryRecord r, int index, + int resultCode, Intent resultData, String reason) { + if (r.finishing) { + Log.w(TAG, "Duplicate finish request for " + r); + return false; + } + + r.finishing = true; + EventLog.writeEvent(LOG_AM_FINISH_ACTIVITY, + System.identityHashCode(r), + r.task.taskId, r.shortComponentName, reason); + r.task.numActivities--; + if (r.frontOfTask && index < (mHistory.size()-1)) { + HistoryRecord next = (HistoryRecord)mHistory.get(index+1); + if (next.task == r.task) { + next.frontOfTask = true; + } + } + + r.pauseKeyDispatchingLocked(); + if (mFocusedActivity == r) { + setFocusedActivityLocked(topRunningActivityLocked(null)); + } + + // send the result + HistoryRecord resultTo = r.resultTo; + if (resultTo != null) { + if (localLOGV) Log.v(TAG, "Adding result to " + resultTo); + if (r.info.applicationInfo.uid > 0) { + grantUriPermissionFromIntentLocked(r.info.applicationInfo.uid, + r.packageName, resultData, r); + } + resultTo.addResultLocked(r, r.resultWho, r.requestCode, resultCode, + resultData); + r.resultTo = null; + } + + // Make sure this HistoryRecord is not holding on to other resources, + // because clients have remote IPC references to this object so we + // can't assume that will go away and want to avoid circular IPC refs. + r.results = null; + r.pendingResults = null; + r.newIntents = null; + r.icicle = null; + + if (mPendingThumbnails.size() > 0) { + // There are clients waiting to receive thumbnails so, in case + // this is an activity that someone is waiting for, add it + // to the pending list so we can correctly update the clients. + mCancelledThumbnails.add(r); + } + + if (mResumedActivity == r) { + boolean endTask = index <= 0 + || ((HistoryRecord)mHistory.get(index-1)).task != r.task; + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare close transition: finishing " + r); + mWindowManager.prepareAppTransition(endTask + ? WindowManagerPolicy.TRANSIT_TASK_CLOSE + : WindowManagerPolicy.TRANSIT_ACTIVITY_CLOSE); + + // Tell window manager to prepare for this one to be removed. + mWindowManager.setAppVisibility(r, false); + + if (mPausingActivity == null) { + if (DEBUG_PAUSE) Log.v(TAG, "Finish needs to pause: " + r); + if (DEBUG_USER_LEAVING) Log.v(TAG, "finish() => pause with userLeaving=false"); + startPausingLocked(false, false); + } + + } else if (r.state != ActivityState.PAUSING) { + // If the activity is PAUSING, we will complete the finish once + // it is done pausing; else we can just directly finish it here. + if (DEBUG_PAUSE) Log.v(TAG, "Finish not pausing: " + r); + return finishCurrentActivityLocked(r, index, + FINISH_AFTER_PAUSE) == null; + } else { + if (DEBUG_PAUSE) Log.v(TAG, "Finish waiting for pause of: " + r); + } + + return false; + } + + private static final int FINISH_IMMEDIATELY = 0; + private static final int FINISH_AFTER_PAUSE = 1; + private static final int FINISH_AFTER_VISIBLE = 2; + + private final HistoryRecord finishCurrentActivityLocked(HistoryRecord r, + int mode) { + final int index = indexOfTokenLocked(r, false); + if (index < 0) { + return null; + } + + return finishCurrentActivityLocked(r, index, mode); + } + + private final HistoryRecord finishCurrentActivityLocked(HistoryRecord r, + int index, int mode) { + // First things first: if this activity is currently visible, + // and the resumed activity is not yet visible, then hold off on + // finishing until the resumed one becomes visible. + if (mode == FINISH_AFTER_VISIBLE && r.nowVisible) { + if (!mStoppingActivities.contains(r)) { + mStoppingActivities.add(r); + if (mStoppingActivities.size() > 3) { + // If we already have a few activities waiting to stop, + // then give up on things going idle and start clearing + // them out. + Message msg = Message.obtain(); + msg.what = ActivityManagerService.IDLE_NOW_MSG; + mHandler.sendMessage(msg); + } + } + r.state = ActivityState.STOPPING; + updateOomAdjLocked(); + return r; + } + + // make sure the record is cleaned out of other places. + mStoppingActivities.remove(r); + mWaitingVisibleActivities.remove(r); + if (mResumedActivity == r) { + mResumedActivity = null; + } + final ActivityState prevState = r.state; + r.state = ActivityState.FINISHING; + + if (mode == FINISH_IMMEDIATELY + || prevState == ActivityState.STOPPED + || prevState == ActivityState.INITIALIZING) { + // If this activity is already stopped, we can just finish + // it right now. + return destroyActivityLocked(r, true) ? null : r; + } else { + // Need to go through the full pause cycle to get this + // activity into the stopped state and then finish it. + if (localLOGV) Log.v(TAG, "Enqueueing pending finish: " + r); + mFinishingActivities.add(r); + resumeTopActivityLocked(null); + } + return r; + } + + /** + * This is the internal entry point for handling Activity.finish(). + * + * @param token The Binder token referencing the Activity we want to finish. + * @param resultCode Result code, if any, from this Activity. + * @param resultData Result data (Intent), if any, from this Activity. + * + * @result Returns true if the activity successfully finished, or false if it is still running. + */ + public final boolean finishActivity(IBinder token, int resultCode, Intent resultData) { + // Refuse possible leaked file descriptors + if (resultData != null && resultData.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (mWatcher != null) { + // Find the first activity that is not finishing. + HistoryRecord next = topRunningActivityLocked(token, 0); + if (next != null) { + // ask watcher if this is allowed + boolean resumeOK = true; + try { + resumeOK = mWatcher.activityResuming(next.packageName); + } catch (RemoteException e) { + mWatcher = null; + } + + if (!resumeOK) { + return false; + } + } + } + final long origId = Binder.clearCallingIdentity(); + boolean res = requestFinishActivityLocked(token, resultCode, + resultData, "app-request"); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + void sendActivityResultLocked(int callingUid, HistoryRecord r, + String resultWho, int requestCode, int resultCode, Intent data) { + + if (callingUid > 0) { + grantUriPermissionFromIntentLocked(callingUid, r.packageName, + data, r); + } + + if (mResumedActivity == r && r.app != null && r.app.thread != null) { + try { + ArrayList<ResultInfo> list = new ArrayList<ResultInfo>(); + list.add(new ResultInfo(resultWho, requestCode, + resultCode, data)); + r.app.thread.scheduleSendResult(r, list); + return; + } catch (Exception e) { + Log.w(TAG, "Exception thrown sending result to " + r, e); + } + } + + r.addResultLocked(null, resultWho, requestCode, resultCode, data); + } + + public final void finishSubActivity(IBinder token, String resultWho, + int requestCode) { + synchronized(this) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return; + } + HistoryRecord self = (HistoryRecord)mHistory.get(index); + + final long origId = Binder.clearCallingIdentity(); + + int i; + for (i=mHistory.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.resultTo == self && r.requestCode == requestCode) { + if ((r.resultWho == null && resultWho == null) || + (r.resultWho != null && r.resultWho.equals(resultWho))) { + finishActivityLocked(r, i, + Activity.RESULT_CANCELED, null, "request-sub"); + } + } + } + + Binder.restoreCallingIdentity(origId); + } + } + + /** + * Perform clean-up of service connections in an activity record. + */ + private final void cleanUpActivityServicesLocked(HistoryRecord r) { + // Throw away any services that have been bound by this activity. + if (r.connections != null) { + Iterator<ConnectionRecord> it = r.connections.iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + removeConnectionLocked(c, null, r); + } + r.connections = null; + } + } + + /** + * Perform the common clean-up of an activity record. This is called both + * as part of destroyActivityLocked() (when destroying the client-side + * representation) and cleaning things up as a result of its hosting + * processing going away, in which case there is no remaining client-side + * state to destroy so only the cleanup here is needed. + */ + private final void cleanUpActivityLocked(HistoryRecord r, boolean cleanServices) { + if (mResumedActivity == r) { + mResumedActivity = null; + } + if (mFocusedActivity == r) { + mFocusedActivity = null; + } + + r.configDestroy = false; + r.frozenBeforeDestroy = false; + + // Make sure this record is no longer in the pending finishes list. + // This could happen, for example, if we are trimming activities + // down to the max limit while they are still waiting to finish. + mFinishingActivities.remove(r); + mWaitingVisibleActivities.remove(r); + + // Remove any pending results. + if (r.finishing && r.pendingResults != null) { + for (WeakReference<PendingIntentRecord> apr : r.pendingResults) { + PendingIntentRecord rec = apr.get(); + if (rec != null) { + cancelIntentSenderLocked(rec, false); + } + } + r.pendingResults = null; + } + + if (cleanServices) { + cleanUpActivityServicesLocked(r); + } + + if (mPendingThumbnails.size() > 0) { + // There are clients waiting to receive thumbnails so, in case + // this is an activity that someone is waiting for, add it + // to the pending list so we can correctly update the clients. + mCancelledThumbnails.add(r); + } + + // Get rid of any pending idle timeouts. + mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r); + mHandler.removeMessages(IDLE_TIMEOUT_MSG, r); + } + + private final void removeActivityFromHistoryLocked(HistoryRecord r) { + if (r.state != ActivityState.DESTROYED) { + mHistory.remove(r); + r.inHistory = false; + r.state = ActivityState.DESTROYED; + mWindowManager.removeAppToken(r); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + cleanUpActivityServicesLocked(r); + removeActivityUriPermissionsLocked(r); + } + } + + /** + * Destroy the current CLIENT SIDE instance of an activity. This may be + * called both when actually finishing an activity, or when performing + * a configuration switch where we destroy the current client-side object + * but then create a new client-side object for this same HistoryRecord. + */ + private final boolean destroyActivityLocked(HistoryRecord r, + boolean removeFromApp) { + if (DEBUG_SWITCH) Log.v( + TAG, "Removing activity: token=" + r + + ", app=" + (r.app != null ? r.app.processName : "(null)")); + EventLog.writeEvent(LOG_AM_DESTROY_ACTIVITY, + System.identityHashCode(r), + r.task.taskId, r.shortComponentName); + + boolean removedFromHistory = false; + + cleanUpActivityLocked(r, false); + + if (r.app != null) { + if (removeFromApp) { + int idx = r.app.activities.indexOf(r); + if (idx >= 0) { + r.app.activities.remove(idx); + } + if (r.persistent) { + decPersistentCountLocked(r.app); + } + } + + boolean skipDestroy = false; + + try { + if (DEBUG_SWITCH) Log.i(TAG, "Destroying: " + r); + r.app.thread.scheduleDestroyActivity(r, r.finishing, + r.configChangeFlags); + } catch (Exception e) { + // We can just ignore exceptions here... if the process + // has crashed, our death notification will clean things + // up. + //Log.w(TAG, "Exception thrown during finish", e); + if (r.finishing) { + removeActivityFromHistoryLocked(r); + removedFromHistory = true; + skipDestroy = true; + } + } + + r.app = null; + r.nowVisible = false; + + if (r.finishing && !skipDestroy) { + r.state = ActivityState.DESTROYING; + Message msg = mHandler.obtainMessage(DESTROY_TIMEOUT_MSG); + msg.obj = r; + mHandler.sendMessageDelayed(msg, DESTROY_TIMEOUT); + } else { + r.state = ActivityState.DESTROYED; + } + } else { + // remove this record from the history. + if (r.finishing) { + removeActivityFromHistoryLocked(r); + removedFromHistory = true; + } else { + r.state = ActivityState.DESTROYED; + } + } + + r.configChangeFlags = 0; + + if (!mLRUActivities.remove(r)) { + Log.w(TAG, "Activity " + r + " being finished, but not in LRU list"); + } + + return removedFromHistory; + } + + private static void removeHistoryRecordsForAppLocked(ArrayList list, + ProcessRecord app) + { + int i = list.size(); + if (localLOGV) Log.v( + TAG, "Removing app " + app + " from list " + list + + " with " + i + " entries"); + while (i > 0) { + i--; + HistoryRecord r = (HistoryRecord)list.get(i); + if (localLOGV) Log.v( + TAG, "Record #" + i + " " + r + ": app=" + r.app); + if (r.app == app) { + if (localLOGV) Log.v(TAG, "Removing this entry!"); + list.remove(i); + } + } + } + + /** + * Main function for removing an existing process from the activity manager + * as a result of that process going away. Clears out all connections + * to the process. + */ + private final void handleAppDiedLocked(ProcessRecord app, + boolean restarting) { + cleanUpApplicationRecordLocked(app, restarting, -1); + if (!restarting) { + mLRUProcesses.remove(app); + } + + // Just in case... + if (mPausingActivity != null && mPausingActivity.app == app) { + if (DEBUG_PAUSE) Log.v(TAG, "App died while pausing: " + mPausingActivity); + mPausingActivity = null; + } + if (mLastPausedActivity != null && mLastPausedActivity.app == app) { + mLastPausedActivity = null; + } + + // Remove this application's activities from active lists. + removeHistoryRecordsForAppLocked(mLRUActivities, app); + removeHistoryRecordsForAppLocked(mStoppingActivities, app); + removeHistoryRecordsForAppLocked(mWaitingVisibleActivities, app); + removeHistoryRecordsForAppLocked(mFinishingActivities, app); + + boolean atTop = true; + boolean hasVisibleActivities = false; + + // Clean out the history list. + int i = mHistory.size(); + if (localLOGV) Log.v( + TAG, "Removing app " + app + " from history with " + i + " entries"); + while (i > 0) { + i--; + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (localLOGV) Log.v( + TAG, "Record #" + i + " " + r + ": app=" + r.app); + if (r.app == app) { + if ((!r.haveState && !r.stateNotNeeded) || r.finishing) { + if (localLOGV) Log.v( + TAG, "Removing this entry! frozen=" + r.haveState + + " finishing=" + r.finishing); + mHistory.remove(i); + + r.inHistory = false; + mWindowManager.removeAppToken(r); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + removeActivityUriPermissionsLocked(r); + + } else { + // We have the current state for this activity, so + // it can be restarted later when needed. + if (localLOGV) Log.v( + TAG, "Keeping entry, setting app to null"); + if (r.visible) { + hasVisibleActivities = true; + } + r.app = null; + r.nowVisible = false; + if (!r.haveState) { + r.icicle = null; + } + } + + cleanUpActivityLocked(r, true); + r.state = ActivityState.STOPPED; + } + atTop = false; + } + + app.activities.clear(); + + if (app.instrumentationClass != null) { + Log.w(TAG, "Crash of app " + app.processName + + " running instrumentation " + app.instrumentationClass); + Bundle info = new Bundle(); + info.putString("shortMsg", "Process crashed."); + finishInstrumentationLocked(app, Activity.RESULT_CANCELED, info); + } + + if (!restarting) { + if (!resumeTopActivityLocked(null)) { + // If there was nothing to resume, and we are not already + // restarting this process, but there is a visible activity that + // is hosted by the process... then make sure all visible + // activities are running, taking care of restarting this + // process. + if (hasVisibleActivities) { + ensureActivitiesVisibleLocked(null, 0); + } + } + } + } + + private final int getLRURecordIndexForAppLocked(IApplicationThread thread) { + IBinder threadBinder = thread.asBinder(); + + // Find the application record. + int count = mLRUProcesses.size(); + int i; + for (i=0; i<count; i++) { + ProcessRecord rec = mLRUProcesses.get(i); + if (rec.thread != null && rec.thread.asBinder() == threadBinder) { + return i; + } + } + return -1; + } + + private final ProcessRecord getRecordForAppLocked( + IApplicationThread thread) { + if (thread == null) { + return null; + } + + int appIndex = getLRURecordIndexForAppLocked(thread); + return appIndex >= 0 ? mLRUProcesses.get(appIndex) : null; + } + + private final void appDiedLocked(ProcessRecord app, int pid, + IApplicationThread thread) { + + mProcDeaths[0]++; + + if (app.thread != null && app.thread.asBinder() == thread.asBinder()) { + Log.i(TAG, "Process " + app.processName + " (pid " + pid + + ") has died."); + EventLog.writeEvent(LOG_AM_PROCESS_DIED, app.pid, app.processName); + if (localLOGV) Log.v( + TAG, "Dying app: " + app + ", pid: " + pid + + ", thread: " + thread.asBinder()); + boolean doLowMem = app.instrumentationClass == null; + handleAppDiedLocked(app, false); + + if (doLowMem) { + // If there are no longer any background processes running, + // and the app that died was not running instrumentation, + // then tell everyone we are now low on memory. + boolean haveBg = false; + int count = mLRUProcesses.size(); + int i; + for (i=0; i<count; i++) { + ProcessRecord rec = mLRUProcesses.get(i); + if (rec.thread != null && rec.setAdj >= HIDDEN_APP_MIN_ADJ) { + haveBg = true; + break; + } + } + + if (!haveBg) { + Log.i(TAG, "Low Memory: No more background processes."); + EventLog.writeEvent(LOG_AM_LOW_MEMORY, mLRUProcesses.size()); + for (i=0; i<count; i++) { + ProcessRecord rec = mLRUProcesses.get(i); + if (rec.thread != null) { + rec.lastRequestedGc = SystemClock.uptimeMillis(); + try { + rec.thread.scheduleLowMemory(); + } catch (RemoteException e) { + // Don't care if the process is gone. + } + } + } + } + } + } else if (Config.LOGD) { + Log.d(TAG, "Received spurious death notification for thread " + + thread.asBinder()); + } + } + + final String readFile(String filename) { + try { + FileInputStream fs = new FileInputStream(filename); + byte[] inp = new byte[8192]; + int size = fs.read(inp); + fs.close(); + return new String(inp, 0, 0, size); + } catch (java.io.IOException e) { + } + return ""; + } + + final void appNotRespondingLocked(ProcessRecord app, HistoryRecord activity, + final String annotation) { + if (app.notResponding || app.crashing) { + return; + } + + // Log the ANR to the event log. + EventLog.writeEvent(LOG_ANR, app.pid, app.processName, annotation); + + // If we are on a secure build and the application is not interesting to the user (it is + // not visible or in the background), just kill it instead of displaying a dialog. + boolean isSecure = "1".equals(SystemProperties.get(SYSTEM_SECURE, "0")); + if (isSecure && !app.isInterestingToUserLocked() && Process.myPid() != app.pid) { + Process.killProcess(app.pid); + return; + } + + // DeviceMonitor.start(); + + String processInfo = null; + if (MONITOR_CPU_USAGE) { + updateCpuStatsNow(); + synchronized (mProcessStatsThread) { + processInfo = mProcessStats.printCurrentState(); + } + } + + StringBuilder info = new StringBuilder(); + info.append("ANR (application not responding) in process: "); + info.append(app.processName); + if (annotation != null) { + info.append("\nAnnotation: "); + info.append(annotation); + } + if (MONITOR_CPU_USAGE) { + info.append("\nCPU usage:\n"); + info.append(processInfo); + } + Log.i(TAG, info.toString()); + + // The application is not responding. Dump as many thread traces as we can. + boolean fileDump = prepareTraceFile(true); + if (!fileDump) { + // Dumping traces to the log, just dump the process that isn't responding so + // we don't overflow the log + Process.sendSignal(app.pid, Process.SIGNAL_QUIT); + } else { + // Dumping traces to a file so dump all active processes we know about + synchronized (this) { + for (int i = mLRUProcesses.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = mLRUProcesses.get(i); + if (r.thread != null) { + Process.sendSignal(r.pid, Process.SIGNAL_QUIT); + } + } + } + } + + if (mWatcher != null) { + try { + int res = mWatcher.appNotResponding(app.processName, + app.pid, info.toString()); + if (res != 0) { + if (res < 0) { + // wait until the SIGQUIT has had a chance to process before killing the + // process. + try { + wait(2000); + } catch (InterruptedException e) { + } + + Process.killProcess(app.pid); + return; + } + } + } catch (RemoteException e) { + mWatcher = null; + } + } + + makeAppNotRespondingLocked(app, + activity != null ? activity.shortComponentName : null, + annotation != null ? "ANR " + annotation : "ANR", + info.toString(), null); + Message msg = Message.obtain(); + HashMap map = new HashMap(); + msg.what = SHOW_NOT_RESPONDING_MSG; + msg.obj = map; + map.put("app", app); + if (activity != null) { + map.put("activity", activity); + } + + mHandler.sendMessage(msg); + return; + } + + /** + * If a stack trace file has been configured, prepare the filesystem + * by creating the directory if it doesn't exist and optionally + * removing the old trace file. + * + * @param removeExisting If set, the existing trace file will be removed. + * @return Returns true if the trace file preparations succeeded + */ + public static boolean prepareTraceFile(boolean removeExisting) { + String tracesPath = SystemProperties.get("dalvik.vm.stack-trace-file", null); + boolean fileReady = false; + if (!TextUtils.isEmpty(tracesPath)) { + File f = new File(tracesPath); + if (!f.exists()) { + // Ensure the enclosing directory exists + File dir = f.getParentFile(); + if (!dir.exists()) { + fileReady = dir.mkdirs(); + FileUtils.setPermissions(dir.getAbsolutePath(), + FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IRWXO, -1, -1); + } else if (dir.isDirectory()) { + fileReady = true; + } + } else if (removeExisting) { + // Remove the previous traces file, so we don't fill the disk. + // The VM will recreate it + Log.i(TAG, "Removing old ANR trace file from " + tracesPath); + fileReady = f.delete(); + } + } + + return fileReady; + } + + + private final void decPersistentCountLocked(ProcessRecord app) + { + app.persistentActivities--; + if (app.persistentActivities > 0) { + // Still more of 'em... + return; + } + if (app.persistent) { + // Ah, but the application itself is persistent. Whatever! + return; + } + + // App is no longer persistent... make sure it and the ones + // following it in the LRU list have the correc oom_adj. + updateOomAdjLocked(); + } + + public void setPersistent(IBinder token, boolean isPersistent) { + if (checkCallingPermission(android.Manifest.permission.PERSISTENT_ACTIVITY) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: setPersistent() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.PERSISTENT_ACTIVITY; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + synchronized(this) { + int index = indexOfTokenLocked(token, true); + if (index < 0) { + return; + } + HistoryRecord r = (HistoryRecord)mHistory.get(index); + ProcessRecord app = r.app; + + if (localLOGV) Log.v( + TAG, "Setting persistence " + isPersistent + ": " + r); + + if (isPersistent) { + if (r.persistent) { + // Okay okay, I heard you already! + if (localLOGV) Log.v(TAG, "Already persistent!"); + return; + } + r.persistent = true; + app.persistentActivities++; + if (localLOGV) Log.v(TAG, "Num persistent now: " + app.persistentActivities); + if (app.persistentActivities > 1) { + // We aren't the first... + if (localLOGV) Log.v(TAG, "Not the first!"); + return; + } + if (app.persistent) { + // This would be redundant. + if (localLOGV) Log.v(TAG, "App is persistent!"); + return; + } + + // App is now persistent... make sure it and the ones + // following it now have the correct oom_adj. + final long origId = Binder.clearCallingIdentity(); + updateOomAdjLocked(); + Binder.restoreCallingIdentity(origId); + + } else { + if (!r.persistent) { + // Okay okay, I heard you already! + return; + } + r.persistent = false; + final long origId = Binder.clearCallingIdentity(); + decPersistentCountLocked(app); + Binder.restoreCallingIdentity(origId); + + } + } + } + + public boolean clearApplicationUserData(final String packageName, + final IPackageDataObserver observer) { + int uid = Binder.getCallingUid(); + int pid = Binder.getCallingPid(); + long callingId = Binder.clearCallingIdentity(); + try { + IPackageManager pm = ActivityThread.getPackageManager(); + int pkgUid = -1; + synchronized(this) { + try { + pkgUid = pm.getPackageUid(packageName); + } catch (RemoteException e) { + } + if (pkgUid == -1) { + Log.w(TAG, "Invalid packageName:" + packageName); + return false; + } + if (uid == pkgUid || checkComponentPermission( + android.Manifest.permission.CLEAR_APP_USER_DATA, + pid, uid, -1) + == PackageManager.PERMISSION_GRANTED) { + restartPackageLocked(packageName, pkgUid); + } else { + throw new SecurityException(pid+" does not have permission:"+ + android.Manifest.permission.CLEAR_APP_USER_DATA+" to clear data" + + "for process:"+packageName); + } + } + + try { + //clear application user data + pm.clearApplicationUserData(packageName, observer); + Intent intent = new Intent(Intent.ACTION_PACKAGE_DATA_CLEARED, + Uri.fromParts("package", packageName, null)); + intent.putExtra(Intent.EXTRA_UID, pkgUid); + broadcastIntentLocked(null, null, intent, + null, null, 0, null, null, null, + false, false, MY_PID, Process.SYSTEM_UID); + } catch (RemoteException e) { + } + } finally { + Binder.restoreCallingIdentity(callingId); + } + return true; + } + + public void restartPackage(final String packageName) { + if (checkCallingPermission(android.Manifest.permission.RESTART_PACKAGES) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: restartPackage() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.RESTART_PACKAGES; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + long callingId = Binder.clearCallingIdentity(); + try { + IPackageManager pm = ActivityThread.getPackageManager(); + int pkgUid = -1; + synchronized(this) { + try { + pkgUid = pm.getPackageUid(packageName); + } catch (RemoteException e) { + } + if (pkgUid == -1) { + Log.w(TAG, "Invalid packageName: " + packageName); + return; + } + restartPackageLocked(packageName, pkgUid); + } + } finally { + Binder.restoreCallingIdentity(callingId); + } + } + + private void restartPackageLocked(final String packageName, int uid) { + uninstallPackageLocked(packageName, uid, false); + Intent intent = new Intent(Intent.ACTION_PACKAGE_RESTARTED, + Uri.fromParts("package", packageName, null)); + intent.putExtra(Intent.EXTRA_UID, uid); + broadcastIntentLocked(null, null, intent, + null, null, 0, null, null, null, + false, false, MY_PID, Process.SYSTEM_UID); + } + + private final void uninstallPackageLocked(String name, int uid, + boolean callerWillRestart) { + if (Config.LOGD) Log.d(TAG, "Uninstalling process " + name); + + int i, N; + + final String procNamePrefix = name + ":"; + if (uid < 0) { + try { + uid = ActivityThread.getPackageManager().getPackageUid(name); + } catch (RemoteException e) { + } + } + + Iterator<SparseArray<Long>> badApps = mProcessCrashTimes.getMap().values().iterator(); + while (badApps.hasNext()) { + SparseArray<Long> ba = badApps.next(); + if (ba.get(uid) != null) { + badApps.remove(); + } + } + + ArrayList<ProcessRecord> procs = new ArrayList<ProcessRecord>(); + + // Remove all processes this package may have touched: all with the + // same UID (except for the system or root user), and all whose name + // matches the package name. + for (SparseArray<ProcessRecord> apps : mProcessNames.getMap().values()) { + final int NA = apps.size(); + for (int ia=0; ia<NA; ia++) { + ProcessRecord app = apps.valueAt(ia); + if (app.removed) { + procs.add(app); + } else if ((uid > 0 && uid != Process.SYSTEM_UID && app.info.uid == uid) + || app.processName.equals(name) + || app.processName.startsWith(procNamePrefix)) { + app.removed = true; + procs.add(app); + } + } + } + + N = procs.size(); + for (i=0; i<N; i++) { + removeProcessLocked(procs.get(i), callerWillRestart); + } + + for (i=mHistory.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.packageName.equals(name)) { + if (Config.LOGD) Log.d( + TAG, " Force finishing activity " + + r.intent.getComponent().flattenToShortString()); + if (r.app != null) { + r.app.removed = true; + } + r.app = null; + finishActivityLocked(r, i, Activity.RESULT_CANCELED, null, "uninstall"); + } + } + + ArrayList<ServiceRecord> services = new ArrayList<ServiceRecord>(); + for (ServiceRecord service : mServices.values()) { + if (service.packageName.equals(name)) { + if (service.app != null) { + service.app.removed = true; + } + service.app = null; + services.add(service); + } + } + + N = services.size(); + for (i=0; i<N; i++) { + bringDownServiceLocked(services.get(i), true); + } + + resumeTopActivityLocked(null); + } + + private final boolean removeProcessLocked(ProcessRecord app, boolean callerWillRestart) { + final String name = app.processName; + final int uid = app.info.uid; + if (Config.LOGD) Log.d( + TAG, "Force removing process " + app + " (" + name + + "/" + uid + ")"); + + mProcessNames.remove(name, uid); + boolean needRestart = false; + if (app.pid > 0 && app.pid != MY_PID) { + int pid = app.pid; + synchronized (mPidsSelfLocked) { + mPidsSelfLocked.remove(pid); + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + } + handleAppDiedLocked(app, true); + mLRUProcesses.remove(app); + Process.killProcess(pid); + + if (app.persistent) { + if (!callerWillRestart) { + addAppLocked(app.info); + } else { + needRestart = true; + } + } + } else { + mRemovedProcesses.add(app); + } + + return needRestart; + } + + private final void processStartTimedOutLocked(ProcessRecord app) { + final int pid = app.pid; + boolean gone = false; + synchronized (mPidsSelfLocked) { + ProcessRecord knownApp = mPidsSelfLocked.get(pid); + if (knownApp != null && knownApp.thread == null) { + mPidsSelfLocked.remove(pid); + gone = true; + } + } + + if (gone) { + Log.w(TAG, "Process " + app + " failed to attach"); + mProcessNames.remove(app.processName, app.info.uid); + Process.killProcess(pid); + if (mPendingBroadcast != null && mPendingBroadcast.curApp.pid == pid) { + Log.w(TAG, "Unattached app died before broadcast acknowledged, skipping"); + mPendingBroadcast = null; + scheduleBroadcastsLocked(); + } + } else { + Log.w(TAG, "Spurious process start timeout - pid not known for " + app); + } + } + + private final boolean attachApplicationLocked(IApplicationThread thread, + int pid) { + + // Find the application record that is being attached... either via + // the pid if we are running in multiple processes, or just pull the + // next app record if we are emulating process with anonymous threads. + ProcessRecord app; + if (pid != MY_PID && pid >= 0) { + synchronized (mPidsSelfLocked) { + app = mPidsSelfLocked.get(pid); + } + } else if (mStartingProcesses.size() > 0) { + app = mStartingProcesses.remove(0); + app.pid = pid; + } else { + app = null; + } + + if (app == null) { + Log.w(TAG, "No pending application record for pid " + pid + + " (IApplicationThread " + thread + "); dropping process"); + EventLog.writeEvent(LOG_AM_DROP_PROCESS, pid); + if (pid > 0 && pid != MY_PID) { + Process.killProcess(pid); + } else { + try { + thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + return false; + } + + // If this application record is still attached to a previous + // process, clean it up now. + if (app.thread != null) { + handleAppDiedLocked(app, true); + } + + // Tell the process all about itself. + + if (localLOGV) Log.v( + TAG, "Binding process pid " + pid + " to record " + app); + + String processName = app.processName; + try { + thread.asBinder().linkToDeath(new AppDeathRecipient( + app, pid, thread), 0); + } catch (RemoteException e) { + app.resetPackageList(); + startProcessLocked(app, "link fail", processName); + return false; + } + + EventLog.writeEvent(LOG_AM_PROCESS_BOUND, app.pid, app.processName); + + app.thread = thread; + app.curAdj = app.setAdj = -100; + app.forcingToForeground = null; + app.foregroundServices = false; + app.debugging = false; + + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + + List providers = generateApplicationProvidersLocked(app); + + if (localLOGV) Log.v( + TAG, "New app record " + app + + " thread=" + thread.asBinder() + " pid=" + pid); + try { + int testMode = IApplicationThread.DEBUG_OFF; + if (mDebugApp != null && mDebugApp.equals(processName)) { + testMode = mWaitForDebugger + ? IApplicationThread.DEBUG_WAIT + : IApplicationThread.DEBUG_ON; + app.debugging = true; + if (mDebugTransient) { + mDebugApp = mOrigDebugApp; + mWaitForDebugger = mOrigWaitForDebugger; + } + } + thread.bindApplication(processName, app.info, providers, + app.instrumentationClass, app.instrumentationProfileFile, + app.instrumentationArguments, app.instrumentationWatcher, testMode, + mConfiguration, getCommonServicesLocked()); + updateLRUListLocked(app, false); + app.lastRequestedGc = SystemClock.uptimeMillis(); + } catch (Exception e) { + // todo: Yikes! What should we do? For now we will try to + // start another process, but that could easily get us in + // an infinite loop of restarting processes... + Log.w(TAG, "Exception thrown during bind!", e); + + app.resetPackageList(); + startProcessLocked(app, "bind fail", processName); + return false; + } + + // Remove this record from the list of starting applications. + mPersistentStartingProcesses.remove(app); + mProcessesOnHold.remove(app); + + boolean badApp = false; + boolean didSomething = false; + + // See if the top visible activity is waiting to run in this process... + HistoryRecord hr = topRunningActivityLocked(null); + if (hr != null) { + if (hr.app == null && app.info.uid == hr.info.applicationInfo.uid + && processName.equals(hr.processName)) { + try { + if (realStartActivityLocked(hr, app, true, true)) { + didSomething = true; + } + } catch (Exception e) { + Log.w(TAG, "Exception in new application when starting activity " + + hr.intent.getComponent().flattenToShortString(), e); + badApp = true; + } + } else { + ensureActivitiesVisibleLocked(hr, null, processName, 0); + } + } + + // Find any services that should be running in this process... + if (!badApp && mPendingServices.size() > 0) { + ServiceRecord sr = null; + try { + for (int i=0; i<mPendingServices.size(); i++) { + sr = mPendingServices.get(i); + if (app.info.uid != sr.appInfo.uid + || !processName.equals(sr.processName)) { + continue; + } + + mPendingServices.remove(i); + i--; + realStartServiceLocked(sr, app); + didSomething = true; + } + } catch (Exception e) { + Log.w(TAG, "Exception in new application when starting service " + + sr.shortName, e); + badApp = true; + } + } + + // Check if the next broadcast receiver is in this process... + BroadcastRecord br = mPendingBroadcast; + if (!badApp && br != null && br.curApp == app) { + try { + mPendingBroadcast = null; + processCurBroadcastLocked(br, app); + didSomething = true; + } catch (Exception e) { + Log.w(TAG, "Exception in new application when starting receiver " + + br.curComponent.flattenToShortString(), e); + badApp = true; + logBroadcastReceiverDiscard(br); + finishReceiverLocked(br.receiver, br.resultCode, br.resultData, + br.resultExtras, br.resultAbort, true); + scheduleBroadcastsLocked(); + } + } + + if (badApp) { + // todo: Also need to kill application to deal with all + // kinds of exceptions. + handleAppDiedLocked(app, false); + return false; + } + + if (!didSomething) { + updateOomAdjLocked(); + } + + return true; + } + + public final void attachApplication(IApplicationThread thread) { + synchronized (this) { + int callingPid = Binder.getCallingPid(); + final long origId = Binder.clearCallingIdentity(); + attachApplicationLocked(thread, callingPid); + Binder.restoreCallingIdentity(origId); + } + } + + public final void activityIdle(IBinder token) { + final long origId = Binder.clearCallingIdentity(); + activityIdleInternal(token, false); + Binder.restoreCallingIdentity(origId); + } + + final ArrayList<HistoryRecord> processStoppingActivitiesLocked( + boolean remove) { + int N = mStoppingActivities.size(); + if (N <= 0) return null; + + ArrayList<HistoryRecord> stops = null; + + final boolean nowVisible = mResumedActivity != null + && mResumedActivity.nowVisible + && !mResumedActivity.waitingVisible; + for (int i=0; i<N; i++) { + HistoryRecord s = mStoppingActivities.get(i); + if (localLOGV) Log.v(TAG, "Stopping " + s + ": nowVisible=" + + nowVisible + " waitingVisible=" + s.waitingVisible + + " finishing=" + s.finishing); + if (s.waitingVisible && nowVisible) { + mWaitingVisibleActivities.remove(s); + s.waitingVisible = false; + if (s.finishing) { + // If this activity is finishing, it is sitting on top of + // everyone else but we now know it is no longer needed... + // so get rid of it. Otherwise, we need to go through the + // normal flow and hide it once we determine that it is + // hidden by the activities in front of it. + if (localLOGV) Log.v(TAG, "Before stopping, can hide: " + s); + mWindowManager.setAppVisibility(s, false); + } + } + if (!s.waitingVisible && remove) { + if (localLOGV) Log.v(TAG, "Ready to stop: " + s); + if (stops == null) { + stops = new ArrayList<HistoryRecord>(); + } + stops.add(s); + mStoppingActivities.remove(i); + N--; + i--; + } + } + + return stops; + } + + void enableScreenAfterBoot() { + mWindowManager.enableScreenAfterBoot(); + } + + final void activityIdleInternal(IBinder token, boolean fromTimeout) { + if (localLOGV) Log.v(TAG, "Activity idle: " + token); + + ArrayList<HistoryRecord> stops = null; + ArrayList<HistoryRecord> finishes = null; + ArrayList<HistoryRecord> thumbnails = null; + int NS = 0; + int NF = 0; + int NT = 0; + IApplicationThread sendThumbnail = null; + boolean booting = false; + boolean enableScreen = false; + + synchronized (this) { + if (token != null) { + mHandler.removeMessages(IDLE_TIMEOUT_MSG, token); + } + + // Get the activity record. + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + + // No longer need to keep the device awake. + if (mResumedActivity == r && mLaunchingActivity.isHeld()) { + mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); + mLaunchingActivity.release(); + } + + // We are now idle. If someone is waiting for a thumbnail from + // us, we can now deliver. + r.idle = true; + scheduleAppGcsLocked(); + if (r.thumbnailNeeded && r.app != null && r.app.thread != null) { + sendThumbnail = r.app.thread; + r.thumbnailNeeded = false; + } + + // If this activity is fullscreen, set up to hide those under it. + + if (DEBUG_VISBILITY) Log.v(TAG, "Idle activity for " + r); + ensureActivitiesVisibleLocked(null, 0); + + //Log.i(TAG, "IDLE: mBooted=" + mBooted + ", fromTimeout=" + fromTimeout); + if (!mBooted && !fromTimeout) { + mBooted = true; + enableScreen = true; + } + } + + // Atomically retrieve all of the other things to do. + stops = processStoppingActivitiesLocked(true); + NS = stops != null ? stops.size() : 0; + if ((NF=mFinishingActivities.size()) > 0) { + finishes = new ArrayList<HistoryRecord>(mFinishingActivities); + mFinishingActivities.clear(); + } + if ((NT=mCancelledThumbnails.size()) > 0) { + thumbnails = new ArrayList<HistoryRecord>(mCancelledThumbnails); + mCancelledThumbnails.clear(); + } + + booting = mBooting; + mBooting = false; + } + + int i; + + // Send thumbnail if requested. + if (sendThumbnail != null) { + try { + sendThumbnail.requestThumbnail(token); + } catch (Exception e) { + Log.w(TAG, "Exception thrown when requesting thumbnail", e); + sendPendingThumbnail(null, token, null, null, true); + } + } + + // Stop any activities that are scheduled to do so but have been + // waiting for the next one to start. + for (i=0; i<NS; i++) { + HistoryRecord r = (HistoryRecord)stops.get(i); + synchronized (this) { + if (r.finishing) { + finishCurrentActivityLocked(r, FINISH_IMMEDIATELY); + } else { + stopActivityLocked(r); + } + } + } + + // Finish any activities that are scheduled to do so but have been + // waiting for the next one to start. + for (i=0; i<NF; i++) { + HistoryRecord r = (HistoryRecord)finishes.get(i); + synchronized (this) { + destroyActivityLocked(r, true); + } + } + + // Report back to any thumbnail receivers. + for (i=0; i<NT; i++) { + HistoryRecord r = (HistoryRecord)thumbnails.get(i); + sendPendingThumbnail(r, null, null, null, true); + } + + if (booting) { + // Ensure that any processes we had put on hold are now started + // up. + final int NP = mProcessesOnHold.size(); + if (NP > 0) { + ArrayList<ProcessRecord> procs = + new ArrayList<ProcessRecord>(mProcessesOnHold); + for (int ip=0; ip<NP; ip++) { + this.startProcessLocked(procs.get(ip), "on-hold", null); + } + } + if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { + // Tell anyone interested that we are done booting! + synchronized (this) { + broadcastIntentLocked(null, null, + new Intent(Intent.ACTION_BOOT_COMPLETED, null), + null, null, 0, null, null, + android.Manifest.permission.RECEIVE_BOOT_COMPLETED, + false, false, MY_PID, Process.SYSTEM_UID); + } + } + } + + trimApplications(); + //dump(); + //mWindowManager.dump(); + + if (enableScreen) { + EventLog.writeEvent(LOG_BOOT_PROGRESS_ENABLE_SCREEN, + SystemClock.uptimeMillis()); + enableScreenAfterBoot(); + } + } + + public final void activityPaused(IBinder token, Bundle icicle) { + // Refuse possible leaked file descriptors + if (icicle != null && icicle.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Bundle"); + } + + final long origId = Binder.clearCallingIdentity(); + activityPaused(token, icicle, false); + Binder.restoreCallingIdentity(origId); + } + + final void activityPaused(IBinder token, Bundle icicle, boolean timeout) { + if (DEBUG_PAUSE) Log.v( + TAG, "Activity paused: token=" + token + ", icicle=" + icicle + + ", timeout=" + timeout); + + HistoryRecord r = null; + + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + r = (HistoryRecord)mHistory.get(index); + if (!timeout) { + r.icicle = icicle; + r.haveState = true; + } + mHandler.removeMessages(PAUSE_TIMEOUT_MSG, r); + if (mPausingActivity == r) { + r.state = ActivityState.PAUSED; + completePauseLocked(); + } else { + EventLog.writeEvent(LOG_AM_FAILED_TO_PAUSE_ACTIVITY, + System.identityHashCode(r), r.shortComponentName, + mPausingActivity != null + ? mPausingActivity.shortComponentName : "(none)"); + } + } + } + } + + public final void activityStopped(IBinder token, Bitmap thumbnail, + CharSequence description) { + if (localLOGV) Log.v( + TAG, "Activity stopped: token=" + token); + + HistoryRecord r = null; + + final long origId = Binder.clearCallingIdentity(); + + synchronized (this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + r = (HistoryRecord)mHistory.get(index); + r.thumbnail = thumbnail; + r.description = description; + r.stopped = true; + r.state = ActivityState.STOPPED; + if (!r.finishing) { + if (r.configDestroy) { + destroyActivityLocked(r, true); + resumeTopActivityLocked(null); + } + } + } + } + + if (r != null) { + sendPendingThumbnail(r, null, null, null, false); + } + + trimApplications(); + + Binder.restoreCallingIdentity(origId); + } + + public final void activityDestroyed(IBinder token) { + if (DEBUG_SWITCH) Log.v(TAG, "ACTIVITY DESTROYED: " + token); + synchronized (this) { + mHandler.removeMessages(DESTROY_TIMEOUT_MSG, token); + + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + if (r.state == ActivityState.DESTROYING) { + final long origId = Binder.clearCallingIdentity(); + removeActivityFromHistoryLocked(r); + Binder.restoreCallingIdentity(origId); + } + } + } + } + + public String getCallingPackage(IBinder token) { + synchronized (this) { + HistoryRecord r = getCallingRecordLocked(token); + return r != null && r.app != null ? r.app.processName : null; + } + } + + public ComponentName getCallingActivity(IBinder token) { + synchronized (this) { + HistoryRecord r = getCallingRecordLocked(token); + return r != null ? r.intent.getComponent() : null; + } + } + + private HistoryRecord getCallingRecordLocked(IBinder token) { + int index = indexOfTokenLocked(token, true); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + if (r != null) { + return r.resultTo; + } + } + return null; + } + + public ComponentName getActivityClassForToken(IBinder token) { + synchronized(this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + return r.intent.getComponent(); + } + return null; + } + } + + public String getPackageForToken(IBinder token) { + synchronized(this) { + int index = indexOfTokenLocked(token, false); + if (index >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(index); + return r.packageName; + } + return null; + } + } + + public IIntentSender getIntentSender(int type, + String packageName, IBinder token, String resultWho, + int requestCode, Intent intent, String resolvedType, int flags) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + int callingUid = Binder.getCallingUid(); + try { + if (callingUid != 0 && callingUid != Process.SYSTEM_UID && + Process.supportsProcesses()) { + int uid = ActivityThread.getPackageManager() + .getPackageUid(packageName); + if (uid != Binder.getCallingUid()) { + String msg = "Permission Denial: getIntentSender() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + ", (need uid=" + uid + ")" + + " is not allowed to send as package " + packageName; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + } + } catch (RemoteException e) { + throw new SecurityException(e); + } + HistoryRecord activity = null; + if (type == INTENT_SENDER_ACTIVITY_RESULT) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return null; + } + activity = (HistoryRecord)mHistory.get(index); + if (activity.finishing) { + return null; + } + } + + final boolean noCreate = (flags&PendingIntent.FLAG_NO_CREATE) != 0; + final boolean cancelCurrent = (flags&PendingIntent.FLAG_CANCEL_CURRENT) != 0; + final boolean updateCurrent = (flags&PendingIntent.FLAG_UPDATE_CURRENT) != 0; + flags &= ~(PendingIntent.FLAG_NO_CREATE|PendingIntent.FLAG_CANCEL_CURRENT + |PendingIntent.FLAG_UPDATE_CURRENT); + + PendingIntentRecord.Key key = new PendingIntentRecord.Key( + type, packageName, activity, resultWho, + requestCode, intent, resolvedType, flags); + WeakReference<PendingIntentRecord> ref; + ref = mIntentSenderRecords.get(key); + PendingIntentRecord rec = ref != null ? ref.get() : null; + if (rec != null) { + if (!cancelCurrent) { + if (updateCurrent) { + rec.key.requestIntent.replaceExtras(intent); + } + return rec; + } + rec.canceled = true; + mIntentSenderRecords.remove(key); + } + if (noCreate) { + return rec; + } + rec = new PendingIntentRecord(this, key, callingUid); + mIntentSenderRecords.put(key, rec.ref); + if (type == INTENT_SENDER_ACTIVITY_RESULT) { + if (activity.pendingResults == null) { + activity.pendingResults + = new HashSet<WeakReference<PendingIntentRecord>>(); + } + activity.pendingResults.add(rec.ref); + } + return rec; + } + } + + public void cancelIntentSender(IIntentSender sender) { + if (!(sender instanceof PendingIntentRecord)) { + return; + } + synchronized(this) { + PendingIntentRecord rec = (PendingIntentRecord)sender; + try { + int uid = ActivityThread.getPackageManager() + .getPackageUid(rec.key.packageName); + if (uid != Binder.getCallingUid()) { + String msg = "Permission Denial: cancelIntentSender() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " is not allowed to cancel packges " + + rec.key.packageName; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + } catch (RemoteException e) { + throw new SecurityException(e); + } + cancelIntentSenderLocked(rec, true); + } + } + + void cancelIntentSenderLocked(PendingIntentRecord rec, boolean cleanActivity) { + rec.canceled = true; + mIntentSenderRecords.remove(rec.key); + if (cleanActivity && rec.key.activity != null) { + rec.key.activity.pendingResults.remove(rec.ref); + } + } + + public String getPackageForIntentSender(IIntentSender pendingResult) { + if (!(pendingResult instanceof PendingIntentRecord)) { + return null; + } + synchronized(this) { + try { + PendingIntentRecord res = (PendingIntentRecord)pendingResult; + return res.key.packageName; + } catch (ClassCastException e) { + } + } + return null; + } + + public void setProcessLimit(int max) { + enforceCallingPermission(android.Manifest.permission.SET_PROCESS_LIMIT, + "setProcessLimit()"); + mProcessLimit = max; + } + + public int getProcessLimit() { + return mProcessLimit; + } + + void foregroundTokenDied(ForegroundToken token) { + synchronized (ActivityManagerService.this) { + synchronized (mPidsSelfLocked) { + ForegroundToken cur + = mForegroundProcesses.get(token.pid); + if (cur != token) { + return; + } + mForegroundProcesses.remove(token.pid); + ProcessRecord pr = mPidsSelfLocked.get(token.pid); + if (pr == null) { + return; + } + pr.forcingToForeground = null; + pr.foregroundServices = false; + } + updateOomAdjLocked(); + } + } + + public void setProcessForeground(IBinder token, int pid, boolean isForeground) { + enforceCallingPermission(android.Manifest.permission.SET_PROCESS_LIMIT, + "setProcessForeground()"); + synchronized(this) { + boolean changed = false; + + synchronized (mPidsSelfLocked) { + ProcessRecord pr = mPidsSelfLocked.get(pid); + if (pr == null) { + Log.w(TAG, "setProcessForeground called on unknown pid: " + pid); + return; + } + ForegroundToken oldToken = mForegroundProcesses.get(pid); + if (oldToken != null) { + oldToken.token.unlinkToDeath(oldToken, 0); + mForegroundProcesses.remove(pid); + pr.forcingToForeground = null; + changed = true; + } + if (isForeground && token != null) { + ForegroundToken newToken = new ForegroundToken() { + public void binderDied() { + foregroundTokenDied(this); + } + }; + newToken.pid = pid; + newToken.token = token; + try { + token.linkToDeath(newToken, 0); + mForegroundProcesses.put(pid, newToken); + pr.forcingToForeground = token; + changed = true; + } catch (RemoteException e) { + // If the process died while doing this, we will later + // do the cleanup with the process death link. + } + } + } + + if (changed) { + updateOomAdjLocked(); + } + } + } + + // ========================================================= + // PERMISSIONS + // ========================================================= + + static class PermissionController extends IPermissionController.Stub { + ActivityManagerService mActivityManagerService; + PermissionController(ActivityManagerService activityManagerService) { + mActivityManagerService = activityManagerService; + } + + public boolean checkPermission(String permission, int pid, int uid) { + return mActivityManagerService.checkPermission(permission, pid, + uid) == PackageManager.PERMISSION_GRANTED; + } + } + + /** + * This can be called with or without the global lock held. + */ + int checkComponentPermission(String permission, int pid, int uid, + int reqUid) { + // We might be performing an operation on behalf of an indirect binder + // invocation, e.g. via {@link #openContentUri}. Check and adjust the + // client identity accordingly before proceeding. + Identity tlsIdentity = sCallerIdentity.get(); + if (tlsIdentity != null) { + Log.d(TAG, "checkComponentPermission() adjusting {pid,uid} to {" + + tlsIdentity.pid + "," + tlsIdentity.uid + "}"); + uid = tlsIdentity.uid; + pid = tlsIdentity.pid; + } + + // Root, system server and our own process get to do everything. + if (uid == 0 || uid == Process.SYSTEM_UID || pid == MY_PID || + !Process.supportsProcesses()) { + return PackageManager.PERMISSION_GRANTED; + } + // If the target requires a specific UID, always fail for others. + if (reqUid >= 0 && uid != reqUid) { + return PackageManager.PERMISSION_DENIED; + } + if (permission == null) { + return PackageManager.PERMISSION_GRANTED; + } + try { + return ActivityThread.getPackageManager() + .checkUidPermission(permission, uid); + } catch (RemoteException e) { + // Should never happen, but if it does... deny! + Log.e(TAG, "PackageManager is dead?!?", e); + } + return PackageManager.PERMISSION_DENIED; + } + + /** + * As the only public entry point for permissions checking, this method + * can enforce the semantic that requesting a check on a null global + * permission is automatically denied. (Internally a null permission + * string is used when calling {@link #checkComponentPermission} in cases + * when only uid-based security is needed.) + * + * This can be called with or without the global lock held. + */ + public int checkPermission(String permission, int pid, int uid) { + if (permission == null) { + return PackageManager.PERMISSION_DENIED; + } + return checkComponentPermission(permission, pid, uid, -1); + } + + /** + * Binder IPC calls go through the public entry point. + * This can be called with or without the global lock held. + */ + int checkCallingPermission(String permission) { + return checkPermission(permission, + Binder.getCallingPid(), + Binder.getCallingUid()); + } + + /** + * This can be called with or without the global lock held. + */ + void enforceCallingPermission(String permission, String func) { + if (checkCallingPermission(permission) + == PackageManager.PERMISSION_GRANTED) { + return; + } + + String msg = "Permission Denial: " + func + " from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + permission; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + private final boolean checkHoldingPermissionsLocked(IPackageManager pm, + ProviderInfo pi, int uid, int modeFlags) { + try { + if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { + if ((pi.readPermission != null) && + (pm.checkUidPermission(pi.readPermission, uid) + != PackageManager.PERMISSION_GRANTED)) { + return false; + } + } + if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { + if ((pi.writePermission != null) && + (pm.checkUidPermission(pi.writePermission, uid) + != PackageManager.PERMISSION_GRANTED)) { + return false; + } + } + return true; + } catch (RemoteException e) { + return false; + } + } + + private final boolean checkUriPermissionLocked(Uri uri, int uid, + int modeFlags) { + // Root gets to do everything. + if (uid == 0 || !Process.supportsProcesses()) { + return true; + } + HashMap<Uri, UriPermission> perms = mGrantedUriPermissions.get(uid); + if (perms == null) return false; + UriPermission perm = perms.get(uri); + if (perm == null) return false; + return (modeFlags&perm.modeFlags) == modeFlags; + } + + public int checkUriPermission(Uri uri, int pid, int uid, int modeFlags) { + // Another redirected-binder-call permissions check as in + // {@link checkComponentPermission}. + Identity tlsIdentity = sCallerIdentity.get(); + if (tlsIdentity != null) { + uid = tlsIdentity.uid; + pid = tlsIdentity.pid; + } + + // Our own process gets to do everything. + if (pid == MY_PID) { + return PackageManager.PERMISSION_GRANTED; + } + synchronized(this) { + return checkUriPermissionLocked(uri, uid, modeFlags) + ? PackageManager.PERMISSION_GRANTED + : PackageManager.PERMISSION_DENIED; + } + } + + private void grantUriPermissionLocked(int callingUid, + String targetPkg, Uri uri, int modeFlags, HistoryRecord activity) { + modeFlags &= (Intent.FLAG_GRANT_READ_URI_PERMISSION + | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); + if (modeFlags == 0) { + return; + } + + final IPackageManager pm = ActivityThread.getPackageManager(); + + // If this is not a content: uri, we can't do anything with it. + if (!ContentResolver.SCHEME_CONTENT.equals(uri.getScheme())) { + return; + } + + String name = uri.getAuthority(); + ProviderInfo pi = null; + ContentProviderRecord cpr + = (ContentProviderRecord)mProvidersByName.get(name); + if (cpr != null) { + pi = cpr.info; + } else { + try { + pi = pm.resolveContentProvider(name, + PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + } + if (pi == null) { + Log.w(TAG, "No content provider found for: " + name); + return; + } + + int targetUid; + try { + targetUid = pm.getPackageUid(targetPkg); + if (targetUid < 0) { + return; + } + } catch (RemoteException ex) { + return; + } + + // First... does the target actually need this permission? + if (checkHoldingPermissionsLocked(pm, pi, targetUid, modeFlags)) { + // No need to grant the target this permission. + return; + } + + // Second... maybe someone else has already granted the + // permission? + if (checkUriPermissionLocked(uri, targetUid, modeFlags)) { + // No need to grant the target this permission. + return; + } + + // Third... is the provider allowing granting of URI permissions? + if (!pi.grantUriPermissions) { + throw new SecurityException("Provider " + pi.packageName + + "/" + pi.name + + " does not allow granting of Uri permissions (uri " + + uri + ")"); + } + if (pi.uriPermissionPatterns != null) { + final int N = pi.uriPermissionPatterns.length; + boolean allowed = false; + for (int i=0; i<N; i++) { + if (pi.uriPermissionPatterns[i] != null + && pi.uriPermissionPatterns[i].match(uri.getPath())) { + allowed = true; + break; + } + } + if (!allowed) { + throw new SecurityException("Provider " + pi.packageName + + "/" + pi.name + + " does not allow granting of permission to path of Uri " + + uri); + } + } + + // Fourth... does the caller itself have permission to access + // this uri? + if (!checkHoldingPermissionsLocked(pm, pi, callingUid, modeFlags)) { + if (!checkUriPermissionLocked(uri, callingUid, modeFlags)) { + throw new SecurityException("Uid " + callingUid + + " does not have permission to uri " + uri); + } + } + + // Okay! So here we are: the caller has the assumed permission + // to the uri, and the target doesn't. Let's now give this to + // the target. + + HashMap<Uri, UriPermission> targetUris + = mGrantedUriPermissions.get(targetUid); + if (targetUris == null) { + targetUris = new HashMap<Uri, UriPermission>(); + mGrantedUriPermissions.put(targetUid, targetUris); + } + + UriPermission perm = targetUris.get(uri); + if (perm == null) { + perm = new UriPermission(targetUid, uri); + targetUris.put(uri, perm); + + } + perm.modeFlags |= modeFlags; + if (activity == null) { + perm.globalModeFlags |= modeFlags; + } else if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { + perm.readActivities.add(activity); + if (activity.readUriPermissions == null) { + activity.readUriPermissions = new HashSet<UriPermission>(); + } + activity.readUriPermissions.add(perm); + } else if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { + perm.writeActivities.add(activity); + if (activity.writeUriPermissions == null) { + activity.writeUriPermissions = new HashSet<UriPermission>(); + } + activity.writeUriPermissions.add(perm); + } + } + + private void grantUriPermissionFromIntentLocked(int callingUid, + String targetPkg, Intent intent, HistoryRecord activity) { + if (intent == null) { + return; + } + Uri data = intent.getData(); + if (data == null) { + return; + } + grantUriPermissionLocked(callingUid, targetPkg, data, + intent.getFlags(), activity); + } + + public void grantUriPermission(IApplicationThread caller, String targetPkg, + Uri uri, int modeFlags) { + synchronized(this) { + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException("Unable to find app for caller " + + caller + + " when granting permission to uri " + uri); + } + if (targetPkg == null) { + Log.w(TAG, "grantUriPermission: null target"); + return; + } + if (uri == null) { + Log.w(TAG, "grantUriPermission: null uri"); + return; + } + + grantUriPermissionLocked(r.info.uid, targetPkg, uri, modeFlags, + null); + } + } + + private void removeUriPermissionIfNeededLocked(UriPermission perm) { + if ((perm.modeFlags&(Intent.FLAG_GRANT_READ_URI_PERMISSION + |Intent.FLAG_GRANT_WRITE_URI_PERMISSION)) == 0) { + HashMap<Uri, UriPermission> perms + = mGrantedUriPermissions.get(perm.uid); + if (perms != null) { + perms.remove(perm.uri); + if (perms.size() == 0) { + mGrantedUriPermissions.remove(perm.uid); + } + } + } + } + + private void removeActivityUriPermissionsLocked(HistoryRecord activity) { + if (activity.readUriPermissions != null) { + for (UriPermission perm : activity.readUriPermissions) { + perm.readActivities.remove(activity); + if (perm.readActivities.size() == 0 && (perm.globalModeFlags + &Intent.FLAG_GRANT_READ_URI_PERMISSION) == 0) { + perm.modeFlags &= ~Intent.FLAG_GRANT_READ_URI_PERMISSION; + removeUriPermissionIfNeededLocked(perm); + } + } + } + if (activity.writeUriPermissions != null) { + for (UriPermission perm : activity.writeUriPermissions) { + perm.writeActivities.remove(activity); + if (perm.writeActivities.size() == 0 && (perm.globalModeFlags + &Intent.FLAG_GRANT_WRITE_URI_PERMISSION) == 0) { + perm.modeFlags &= ~Intent.FLAG_GRANT_WRITE_URI_PERMISSION; + removeUriPermissionIfNeededLocked(perm); + } + } + } + } + + private void revokeUriPermissionLocked(int callingUid, Uri uri, + int modeFlags) { + modeFlags &= (Intent.FLAG_GRANT_READ_URI_PERMISSION + | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); + if (modeFlags == 0) { + return; + } + + final IPackageManager pm = ActivityThread.getPackageManager(); + + final String authority = uri.getAuthority(); + ProviderInfo pi = null; + ContentProviderRecord cpr + = (ContentProviderRecord)mProvidersByName.get(authority); + if (cpr != null) { + pi = cpr.info; + } else { + try { + pi = pm.resolveContentProvider(authority, + PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + } + if (pi == null) { + Log.w(TAG, "No content provider found for: " + authority); + return; + } + + // Does the caller have this permission on the URI? + if (!checkHoldingPermissionsLocked(pm, pi, callingUid, modeFlags)) { + // Right now, if you are not the original owner of the permission, + // you are not allowed to revoke it. + //if (!checkUriPermissionLocked(uri, callingUid, modeFlags)) { + throw new SecurityException("Uid " + callingUid + + " does not have permission to uri " + uri); + //} + } + + // Go through all of the permissions and remove any that match. + final List<String> SEGMENTS = uri.getPathSegments(); + if (SEGMENTS != null) { + final int NS = SEGMENTS.size(); + int N = mGrantedUriPermissions.size(); + for (int i=0; i<N; i++) { + HashMap<Uri, UriPermission> perms + = mGrantedUriPermissions.valueAt(i); + Iterator<UriPermission> it = perms.values().iterator(); + toploop: + while (it.hasNext()) { + UriPermission perm = it.next(); + Uri targetUri = perm.uri; + if (!authority.equals(targetUri.getAuthority())) { + continue; + } + List<String> targetSegments = targetUri.getPathSegments(); + if (targetSegments == null) { + continue; + } + if (targetSegments.size() < NS) { + continue; + } + for (int j=0; j<NS; j++) { + if (!SEGMENTS.get(j).equals(targetSegments.get(j))) { + continue toploop; + } + } + perm.clearModes(modeFlags); + if (perm.modeFlags == 0) { + it.remove(); + } + } + if (perms.size() == 0) { + mGrantedUriPermissions.remove( + mGrantedUriPermissions.keyAt(i)); + N--; + i--; + } + } + } + } + + public void revokeUriPermission(IApplicationThread caller, Uri uri, + int modeFlags) { + synchronized(this) { + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException("Unable to find app for caller " + + caller + + " when revoking permission to uri " + uri); + } + if (uri == null) { + Log.w(TAG, "revokeUriPermission: null uri"); + return; + } + + modeFlags &= (Intent.FLAG_GRANT_READ_URI_PERMISSION + | Intent.FLAG_GRANT_WRITE_URI_PERMISSION); + if (modeFlags == 0) { + return; + } + + final IPackageManager pm = ActivityThread.getPackageManager(); + + final String authority = uri.getAuthority(); + ProviderInfo pi = null; + ContentProviderRecord cpr + = (ContentProviderRecord)mProvidersByName.get(authority); + if (cpr != null) { + pi = cpr.info; + } else { + try { + pi = pm.resolveContentProvider(authority, + PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + } + if (pi == null) { + Log.w(TAG, "No content provider found for: " + authority); + return; + } + + revokeUriPermissionLocked(r.info.uid, uri, modeFlags); + } + } + + public void showWaitingForDebugger(IApplicationThread who, boolean waiting) { + synchronized (this) { + ProcessRecord app = + who != null ? getRecordForAppLocked(who) : null; + if (app == null) return; + + Message msg = Message.obtain(); + msg.what = WAIT_FOR_DEBUGGER_MSG; + msg.obj = app; + msg.arg1 = waiting ? 1 : 0; + mHandler.sendMessage(msg); + } + } + + public void getMemoryInfo(ActivityManager.MemoryInfo outInfo) { + outInfo.availMem = Process.getFreeMemory(); + outInfo.threshold = SECONDARY_SERVER_MEM; + outInfo.lowMemory = outInfo.availMem < + (SECONDARY_SERVER_MEM + ((HIDDEN_APP_MEM-SECONDARY_SERVER_MEM)/2)); + } + + // ========================================================= + // TASK MANAGEMENT + // ========================================================= + + public List getTasks(int maxNum, int flags, + IThumbnailReceiver receiver) { + ArrayList list = new ArrayList(); + + PendingThumbnailsRecord pending = null; + IApplicationThread topThumbnail = null; + HistoryRecord topRecord = null; + + synchronized(this) { + if (localLOGV) Log.v( + TAG, "getTasks: max=" + maxNum + ", flags=" + flags + + ", receiver=" + receiver); + + if (checkCallingPermission(android.Manifest.permission.GET_TASKS) + != PackageManager.PERMISSION_GRANTED) { + if (receiver != null) { + // If the caller wants to wait for pending thumbnails, + // it ain't gonna get them. + try { + receiver.finished(); + } catch (RemoteException ex) { + } + } + String msg = "Permission Denial: getTasks() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.GET_TASKS; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + int pos = mHistory.size()-1; + HistoryRecord next = + pos >= 0 ? (HistoryRecord)mHistory.get(pos) : null; + HistoryRecord top = null; + CharSequence topDescription = null; + TaskRecord curTask = null; + int numActivities = 0; + int numRunning = 0; + while (pos >= 0 && maxNum > 0) { + final HistoryRecord r = next; + pos--; + next = pos >= 0 ? (HistoryRecord)mHistory.get(pos) : null; + + // Initialize state for next task if needed. + if (top == null || + (top.state == ActivityState.INITIALIZING + && top.task == r.task)) { + top = r; + topDescription = r.description; + curTask = r.task; + numActivities = numRunning = 0; + } + + // Add 'r' into the current task. + numActivities++; + if (r.app != null && r.app.thread != null) { + numRunning++; + } + if (topDescription == null) { + topDescription = r.description; + } + + if (localLOGV) Log.v( + TAG, r.intent.getComponent().flattenToShortString() + + ": task=" + r.task); + + // If the next one is a different task, generate a new + // TaskInfo entry for what we have. + if (next == null || next.task != curTask) { + ActivityManager.RunningTaskInfo ci + = new ActivityManager.RunningTaskInfo(); + ci.id = curTask.taskId; + ci.baseActivity = r.intent.getComponent(); + ci.topActivity = top.intent.getComponent(); + ci.thumbnail = top.thumbnail; + ci.description = topDescription; + ci.numActivities = numActivities; + ci.numRunning = numRunning; + //System.out.println( + // "#" + maxNum + ": " + " descr=" + ci.description); + if (ci.thumbnail == null && receiver != null) { + if (localLOGV) Log.v( + TAG, "State=" + top.state + "Idle=" + top.idle + + " app=" + top.app + + " thr=" + (top.app != null ? top.app.thread : null)); + if (top.state == ActivityState.RESUMED + || top.state == ActivityState.PAUSING) { + if (top.idle && top.app != null + && top.app.thread != null) { + topRecord = top; + topThumbnail = top.app.thread; + } else { + top.thumbnailNeeded = true; + } + } + if (pending == null) { + pending = new PendingThumbnailsRecord(receiver); + } + pending.pendingRecords.add(top); + } + list.add(ci); + maxNum--; + top = null; + } + } + + if (pending != null) { + mPendingThumbnails.add(pending); + } + } + + if (localLOGV) Log.v(TAG, "We have pending thumbnails: " + pending); + + if (topThumbnail != null) { + if (localLOGV) Log.v(TAG, "Requesting top thumbnail"); + try { + topThumbnail.requestThumbnail(topRecord); + } catch (Exception e) { + Log.w(TAG, "Exception thrown when requesting thumbnail", e); + sendPendingThumbnail(null, topRecord, null, null, true); + } + } + + if (pending == null && receiver != null) { + // In this case all thumbnails were available and the client + // is being asked to be told when the remaining ones come in... + // which is unusually, since the top-most currently running + // activity should never have a canned thumbnail! Oh well. + try { + receiver.finished(); + } catch (RemoteException ex) { + } + } + + return list; + } + + public List<ActivityManager.RecentTaskInfo> getRecentTasks(int maxNum, + int flags) { + synchronized (this) { + enforceCallingPermission(android.Manifest.permission.GET_TASKS, + "getRecentTasks()"); + + final int N = mRecentTasks.size(); + ArrayList<ActivityManager.RecentTaskInfo> res + = new ArrayList<ActivityManager.RecentTaskInfo>( + maxNum < N ? maxNum : N); + for (int i=0; i<N && maxNum > 0; i++) { + TaskRecord tr = mRecentTasks.get(i); + if (((flags&ActivityManager.RECENT_WITH_EXCLUDED) != 0) + || (tr.intent == null) + || ((tr.intent.getFlags() + &Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS) == 0)) { + ActivityManager.RecentTaskInfo rti + = new ActivityManager.RecentTaskInfo(); + rti.id = tr.numActivities > 0 ? tr.taskId : -1; + rti.baseIntent = new Intent( + tr.intent != null ? tr.intent : tr.affinityIntent); + rti.origActivity = tr.origActivity; + res.add(rti); + maxNum--; + } + } + return res; + } + } + + private final int findAffinityTaskTopLocked(int startIndex, String affinity) { + int j; + TaskRecord startTask = ((HistoryRecord)mHistory.get(startIndex)).task; + TaskRecord jt = startTask; + + // First look backwards + for (j=startIndex-1; j>=0; j--) { + HistoryRecord r = (HistoryRecord)mHistory.get(j); + if (r.task != jt) { + jt = r.task; + if (affinity.equals(jt.affinity)) { + return j; + } + } + } + + // Now look forwards + final int N = mHistory.size(); + jt = startTask; + for (j=startIndex+1; j<N; j++) { + HistoryRecord r = (HistoryRecord)mHistory.get(j); + if (r.task != jt) { + if (affinity.equals(jt.affinity)) { + return j; + } + jt = r.task; + } + } + + // Might it be at the top? + if (affinity.equals(((HistoryRecord)mHistory.get(N-1)).task.affinity)) { + return N-1; + } + + return -1; + } + + /** + * Perform a reset of the given task, if needed as part of launching it. + * Returns the new HistoryRecord at the top of the task. + */ + private final HistoryRecord resetTaskIfNeededLocked(HistoryRecord taskTop, + HistoryRecord newActivity) { + boolean forceReset = (newActivity.info.flags + &ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0; + if (taskTop.task.getInactiveDuration() > ACTIVITY_INACTIVE_RESET_TIME) { + if ((newActivity.info.flags + &ActivityInfo.FLAG_ALWAYS_RETAIN_TASK_STATE) == 0) { + forceReset = true; + } + } + + final TaskRecord task = taskTop.task; + + // We are going to move through the history list so that we can look + // at each activity 'target' with 'below' either the interesting + // activity immediately below it in the stack or null. + HistoryRecord target = null; + int targetI = 0; + int taskTopI = -1; + int replyChainEnd = -1; + int lastReparentPos = -1; + for (int i=mHistory.size()-1; i>=-1; i--) { + HistoryRecord below = i >= 0 ? (HistoryRecord)mHistory.get(i) : null; + + if (below != null && below.finishing) { + continue; + } + if (target == null) { + target = below; + targetI = i; + // If we were in the middle of a reply chain before this + // task, it doesn't appear like the root of the chain wants + // anything interesting, so drop it. + replyChainEnd = -1; + continue; + } + + final int flags = target.info.flags; + + final boolean finishOnTaskLaunch = + (flags&ActivityInfo.FLAG_FINISH_ON_TASK_LAUNCH) != 0; + final boolean allowTaskReparenting = + (flags&ActivityInfo.FLAG_ALLOW_TASK_REPARENTING) != 0; + + if (target.task == task) { + // We are inside of the task being reset... we'll either + // finish this activity, push it out for another task, + // or leave it as-is. We only do this + // for activities that are not the root of the task (since + // if we finish the root, we may no longer have the task!). + if (taskTopI < 0) { + taskTopI = targetI; + } + if (below != null && below.task == task) { + final boolean clearWhenTaskReset = + (target.intent.getFlags() + &Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) != 0; + if (!finishOnTaskLaunch && target.resultTo != null) { + // If this activity is sending a reply to a previous + // activity, we can't do anything with it now until + // we reach the start of the reply chain. + // XXX note that we are assuming the result is always + // to the previous activity, which is almost always + // the case but we really shouldn't count on. + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + } else if (!finishOnTaskLaunch && allowTaskReparenting + && target.taskAffinity != null + && !target.taskAffinity.equals(task.affinity)) { + // If this activity has an affinity for another + // task, then we need to move it out of here. We will + // move it as far out of the way as possible, to the + // bottom of the activity stack. This also keeps it + // correctly ordered with any activities we previously + // moved. + HistoryRecord p = (HistoryRecord)mHistory.get(0); + if (target.taskAffinity != null + && target.taskAffinity.equals(p.task.affinity)) { + // If the activity currently at the bottom has the + // same task affinity as the one we are moving, + // then merge it into the same task. + target.task = p.task; + if (DEBUG_TASKS) Log.v(TAG, "Start pushing activity " + target + + " out to bottom task " + p.task); + } else { + mCurTask++; + if (mCurTask <= 0) { + mCurTask = 1; + } + target.task = new TaskRecord(mCurTask, target.info, null, + (target.info.flags&ActivityInfo.FLAG_CLEAR_TASK_ON_LAUNCH) != 0); + target.task.affinityIntent = target.intent; + if (DEBUG_TASKS) Log.v(TAG, "Start pushing activity " + target + + " out to new task " + target.task); + } + mWindowManager.setAppGroupId(target, task.taskId); + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + int dstPos = 0; + for (int srcPos=targetI; srcPos<=replyChainEnd; srcPos++) { + p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (DEBUG_TASKS) Log.v(TAG, "Pushing next activity " + p + + " out to target's task " + target.task); + task.numActivities--; + p.task = target.task; + target.task.numActivities++; + mHistory.remove(srcPos); + mHistory.add(dstPos, p); + mWindowManager.moveAppToken(dstPos, p); + mWindowManager.setAppGroupId(p, p.task.taskId); + dstPos++; + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + i++; + } + if (taskTop == p) { + taskTop = below; + } + if (taskTopI == replyChainEnd) { + taskTopI = -1; + } + replyChainEnd = -1; + addRecentTask(target.task); + } else if (forceReset || finishOnTaskLaunch + || clearWhenTaskReset) { + // If the activity should just be removed -- either + // because it asks for it, or the task should be + // cleared -- then finish it and anything that is + // part of its reply chain. + if (clearWhenTaskReset) { + // In this case, we want to finish this activity + // and everything above it, so be sneaky and pretend + // like these are all in the reply chain. + replyChainEnd = targetI+1; + while (replyChainEnd < mHistory.size() && + ((HistoryRecord)mHistory.get( + replyChainEnd)).task == task) { + replyChainEnd++; + } + replyChainEnd--; + } else if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + HistoryRecord p = null; + for (int srcPos=targetI; srcPos<=replyChainEnd; srcPos++) { + p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (finishActivityLocked(p, srcPos, + Activity.RESULT_CANCELED, null, "reset")) { + replyChainEnd--; + srcPos--; + } + } + if (taskTop == p) { + taskTop = below; + } + if (taskTopI == replyChainEnd) { + taskTopI = -1; + } + replyChainEnd = -1; + } else { + // If we were in the middle of a chain, well the + // activity that started it all doesn't want anything + // special, so leave it all as-is. + replyChainEnd = -1; + } + } else { + // Reached the bottom of the task -- any reply chain + // should be left as-is. + replyChainEnd = -1; + } + + } else if (target.resultTo != null) { + // If this activity is sending a reply to a previous + // activity, we can't do anything with it now until + // we reach the start of the reply chain. + // XXX note that we are assuming the result is always + // to the previous activity, which is almost always + // the case but we really shouldn't count on. + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + + } else if (taskTopI >= 0 && allowTaskReparenting + && task.affinity != null + && task.affinity.equals(target.taskAffinity)) { + // We are inside of another task... if this activity has + // an affinity for our task, then either remove it if we are + // clearing or move it over to our task. Note that + // we currently punt on the case where we are resetting a + // task that is not at the top but who has activities above + // with an affinity to it... this is really not a normal + // case, and we will need to later pull that task to the front + // and usually at that point we will do the reset and pick + // up those remaining activities. (This only happens if + // someone starts an activity in a new task from an activity + // in a task that is not currently on top.) + if (forceReset || finishOnTaskLaunch) { + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + HistoryRecord p = null; + for (int srcPos=targetI; srcPos<=replyChainEnd; srcPos++) { + p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (finishActivityLocked(p, srcPos, + Activity.RESULT_CANCELED, null, "reset")) { + taskTopI--; + lastReparentPos--; + replyChainEnd--; + srcPos--; + } + } + replyChainEnd = -1; + } else { + if (replyChainEnd < 0) { + replyChainEnd = targetI; + } + for (int srcPos=replyChainEnd; srcPos>=targetI; srcPos--) { + HistoryRecord p = (HistoryRecord)mHistory.get(srcPos); + if (p.finishing) { + continue; + } + if (lastReparentPos < 0) { + lastReparentPos = taskTopI; + taskTop = p; + } else { + lastReparentPos--; + } + mHistory.remove(srcPos); + p.task.numActivities--; + p.task = task; + mHistory.add(lastReparentPos, p); + if (DEBUG_TASKS) Log.v(TAG, "Pulling activity " + p + + " in to resetting task " + task); + task.numActivities++; + mWindowManager.moveAppToken(lastReparentPos, p); + mWindowManager.setAppGroupId(p, p.task.taskId); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + } + replyChainEnd = -1; + + // Now we've moved it in to place... but what if this is + // a singleTop activity and we have put it on top of another + // instance of the same activity? Then we drop the instance + // below so it remains singleTop. + if (target.info.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) { + for (int j=lastReparentPos-1; j>=0; j--) { + HistoryRecord p = (HistoryRecord)mHistory.get(j); + if (p.finishing) { + continue; + } + if (p.intent.getComponent().equals(target.intent.getComponent())) { + if (finishActivityLocked(p, j, + Activity.RESULT_CANCELED, null, "replace")) { + taskTopI--; + lastReparentPos--; + } + } + } + } + } + } + + target = below; + targetI = i; + } + + return taskTop; + } + + /** + * TODO: Add mWatcher hook + */ + public void moveTaskToFront(int task) { + enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, + "moveTaskToFront()"); + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + try { + int N = mRecentTasks.size(); + for (int i=0; i<N; i++) { + TaskRecord tr = mRecentTasks.get(i); + if (tr.taskId == task) { + moveTaskToFrontLocked(tr); + return; + } + } + for (int i=mHistory.size()-1; i>=0; i--) { + HistoryRecord hr = (HistoryRecord)mHistory.get(i); + if (hr.task.taskId == task) { + moveTaskToFrontLocked(hr.task); + return; + } + } + } finally { + Binder.restoreCallingIdentity(origId); + } + } + } + + private final void moveTaskToFrontLocked(TaskRecord tr) { + if (DEBUG_SWITCH) Log.v(TAG, "moveTaskToFront: " + tr); + + final int task = tr.taskId; + int top = mHistory.size()-1; + + if (top < 0 || ((HistoryRecord)mHistory.get(top)).task.taskId == task) { + // nothing to do! + return; + } + + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare to front transition: task=" + tr); + mWindowManager.prepareAppTransition(WindowManagerPolicy.TRANSIT_TASK_TO_FRONT); + + ArrayList moved = new ArrayList(); + + // Applying the affinities may have removed entries from the history, + // so get the size again. + top = mHistory.size()-1; + int pos = top; + + // Shift all activities with this task up to the top + // of the stack, keeping them in the same internal order. + while (pos >= 0) { + HistoryRecord r = (HistoryRecord)mHistory.get(pos); + if (localLOGV) Log.v( + TAG, "At " + pos + " ckp " + r.task + ": " + r); + boolean first = true; + if (r.task.taskId == task) { + if (localLOGV) Log.v(TAG, "Removing and adding at " + top); + mHistory.remove(pos); + mHistory.add(top, r); + moved.add(0, r); + top--; + if (first) { + addRecentTask(r.task); + first = false; + } + } + pos--; + } + + mWindowManager.moveAppTokensToTop(moved); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + + finishTaskMove(task); + EventLog.writeEvent(LOG_TASK_TO_FRONT, task); + } + + private final void finishTaskMove(int task) { + resumeTopActivityLocked(null); + } + + public void moveTaskToBack(int task) { + enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, + "moveTaskToBack()"); + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + moveTaskToBackLocked(task); + Binder.restoreCallingIdentity(origId); + } + } + + /** + * Moves an activity, and all of the other activities within the same task, to the bottom + * of the history stack. The activity's order within the task is unchanged. + * + * @param token A reference to the activity we wish to move + * @param nonRoot If false then this only works if the activity is the root + * of a task; if true it will work for any activity in a task. + * @return Returns true if the move completed, false if not. + */ + public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + int taskId = getTaskForActivityLocked(token, !nonRoot); + if (taskId >= 0) { + return moveTaskToBackLocked(taskId); + } + Binder.restoreCallingIdentity(origId); + } + return false; + } + + /** + * Worker method for rearranging history stack. Implements the function of moving all + * activities for a specific task (gathering them if disjoint) into a single group at the + * bottom of the stack. + * + * If a watcher is installed, the action is preflighted and the watcher has an opportunity + * to premeptively cancel the move. + * + * @param task The taskId to collect and move to the bottom. + * @return Returns true if the move completed, false if not. + */ + private final boolean moveTaskToBackLocked(int task) { + Log.i(TAG, "moveTaskToBack: " + task); + + // If we have a watcher, preflight the move before committing to it. First check + // for *other* available tasks, but if none are available, then try again allowing the + // current task to be selected. + if (mWatcher != null) { + HistoryRecord next = topRunningActivityLocked(null, task); + if (next == null) { + next = topRunningActivityLocked(null, 0); + } + if (next != null) { + // ask watcher if this is allowed + boolean moveOK = true; + try { + moveOK = mWatcher.activityResuming(next.packageName); + } catch (RemoteException e) { + mWatcher = null; + } + if (!moveOK) { + return false; + } + } + } + + ArrayList moved = new ArrayList(); + + if (DEBUG_TRANSITION) Log.v(TAG, + "Prepare to back transition: task=" + task); + mWindowManager.prepareAppTransition(WindowManagerPolicy.TRANSIT_TASK_TO_BACK); + + final int N = mHistory.size(); + int bottom = 0; + int pos = 0; + + // Shift all activities with this task down to the bottom + // of the stack, keeping them in the same internal order. + while (pos < N) { + HistoryRecord r = (HistoryRecord)mHistory.get(pos); + if (localLOGV) Log.v( + TAG, "At " + pos + " ckp " + r.task + ": " + r); + if (r.task.taskId == task) { + if (localLOGV) Log.v(TAG, "Removing and adding at " + (N-1)); + mHistory.remove(pos); + mHistory.add(bottom, r); + moved.add(r); + bottom++; + } + pos++; + } + + mWindowManager.moveAppTokensToBottom(moved); + if (VALIDATE_TOKENS) { + mWindowManager.validateAppTokens(mHistory); + } + + finishTaskMove(task); + return true; + } + + public void moveTaskBackwards(int task) { + enforceCallingPermission(android.Manifest.permission.REORDER_TASKS, + "moveTaskBackwards()"); + + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + moveTaskBackwardsLocked(task); + Binder.restoreCallingIdentity(origId); + } + } + + private final void moveTaskBackwardsLocked(int task) { + Log.e(TAG, "moveTaskBackwards not yet implemented!"); + } + + public int getTaskForActivity(IBinder token, boolean onlyRoot) { + synchronized(this) { + return getTaskForActivityLocked(token, onlyRoot); + } + } + + int getTaskForActivityLocked(IBinder token, boolean onlyRoot) { + final int N = mHistory.size(); + TaskRecord lastTask = null; + for (int i=0; i<N; i++) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r == token) { + if (!onlyRoot || lastTask != r.task) { + return r.task.taskId; + } + return -1; + } + lastTask = r.task; + } + + return -1; + } + + /** + * Returns the top activity in any existing task matching the given + * Intent. Returns null if no such task is found. + */ + private HistoryRecord findTaskLocked(Intent intent, ActivityInfo info) { + ComponentName cls = intent.getComponent(); + if (info.targetActivity != null) { + cls = new ComponentName(info.packageName, info.targetActivity); + } + + TaskRecord cp = null; + + final int N = mHistory.size(); + for (int i=(N-1); i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (!r.finishing && r.task != cp + && r.launchMode != ActivityInfo.LAUNCH_SINGLE_INSTANCE) { + cp = r.task; + //Log.i(TAG, "Comparing existing cls=" + r.task.intent.getComponent().flattenToShortString() + // + "/aff=" + r.task.affinity + " to new cls=" + // + intent.getComponent().flattenToShortString() + "/aff=" + taskAffinity); + if (r.task.affinity != null) { + if (r.task.affinity.equals(info.taskAffinity)) { + //Log.i(TAG, "Found matching affinity!"); + return r; + } + } else if (r.task.intent != null + && r.task.intent.getComponent().equals(cls)) { + //Log.i(TAG, "Found matching class!"); + //dump(); + //Log.i(TAG, "For Intent " + intent + " bringing to top: " + r.intent); + return r; + } else if (r.task.affinityIntent != null + && r.task.affinityIntent.getComponent().equals(cls)) { + //Log.i(TAG, "Found matching class!"); + //dump(); + //Log.i(TAG, "For Intent " + intent + " bringing to top: " + r.intent); + return r; + } + } + } + + return null; + } + + /** + * Returns the first activity (starting from the top of the stack) that + * is the same as the given activity. Returns null if no such activity + * is found. + */ + private HistoryRecord findActivityLocked(Intent intent, ActivityInfo info) { + ComponentName cls = intent.getComponent(); + if (info.targetActivity != null) { + cls = new ComponentName(info.packageName, info.targetActivity); + } + + final int N = mHistory.size(); + for (int i=(N-1); i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (!r.finishing) { + if (r.intent.getComponent().equals(cls)) { + //Log.i(TAG, "Found matching class!"); + //dump(); + //Log.i(TAG, "For Intent " + intent + " bringing to top: " + r.intent); + return r; + } + } + } + + return null; + } + + public void finishOtherInstances(IBinder token, ComponentName className) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + + int N = mHistory.size(); + TaskRecord lastTask = null; + for (int i=0; i<N; i++) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.realActivity.equals(className) + && r != token && lastTask != r.task) { + if (finishActivityLocked(r, i, Activity.RESULT_CANCELED, + null, "others")) { + i--; + N--; + } + } + lastTask = r.task; + } + + Binder.restoreCallingIdentity(origId); + } + } + + // ========================================================= + // THUMBNAILS + // ========================================================= + + public void reportThumbnail(IBinder token, + Bitmap thumbnail, CharSequence description) { + //System.out.println("Report thumbnail for " + token + ": " + thumbnail); + final long origId = Binder.clearCallingIdentity(); + sendPendingThumbnail(null, token, thumbnail, description, true); + Binder.restoreCallingIdentity(origId); + } + + final void sendPendingThumbnail(HistoryRecord r, IBinder token, + Bitmap thumbnail, CharSequence description, boolean always) { + TaskRecord task = null; + ArrayList receivers = null; + + //System.out.println("Send pending thumbnail: " + r); + + synchronized(this) { + if (r == null) { + int index = indexOfTokenLocked(token, false); + if (index < 0) { + return; + } + r = (HistoryRecord)mHistory.get(index); + } + if (thumbnail == null) { + thumbnail = r.thumbnail; + description = r.description; + } + if (thumbnail == null && !always) { + // If there is no thumbnail, and this entry is not actually + // going away, then abort for now and pick up the next + // thumbnail we get. + return; + } + task = r.task; + + int N = mPendingThumbnails.size(); + int i=0; + while (i<N) { + PendingThumbnailsRecord pr = + (PendingThumbnailsRecord)mPendingThumbnails.get(i); + //System.out.println("Looking in " + pr.pendingRecords); + if (pr.pendingRecords.remove(r)) { + if (receivers == null) { + receivers = new ArrayList(); + } + receivers.add(pr); + if (pr.pendingRecords.size() == 0) { + pr.finished = true; + mPendingThumbnails.remove(i); + N--; + continue; + } + } + i++; + } + } + + if (receivers != null) { + final int N = receivers.size(); + for (int i=0; i<N; i++) { + try { + PendingThumbnailsRecord pr = + (PendingThumbnailsRecord)receivers.get(i); + pr.receiver.newThumbnail( + task != null ? task.taskId : -1, thumbnail, description); + if (pr.finished) { + pr.receiver.finished(); + } + } catch (Exception e) { + Log.w(TAG, "Exception thrown when sending thumbnail", e); + } + } + } + } + + // ========================================================= + // CONTENT PROVIDERS + // ========================================================= + + private final List generateApplicationProvidersLocked(ProcessRecord app) { + List providers = null; + try { + providers = ActivityThread.getPackageManager(). + queryContentProviders(app.processName, app.info.uid, + PackageManager.GET_SHARED_LIBRARY_FILES + | PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + if (providers != null) { + final int N = providers.size(); + for (int i=0; i<N; i++) { + ProviderInfo cpi = + (ProviderInfo)providers.get(i); + ContentProviderRecord cpr = + (ContentProviderRecord)mProvidersByClass.get(cpi.name); + if (cpr == null) { + cpr = new ContentProviderRecord(cpi, app.info); + mProvidersByClass.put(cpi.name, cpr); + } + app.pubProviders.put(cpi.name, cpr); + app.addPackage(cpi.applicationInfo.packageName); + } + } + return providers; + } + + private final String checkContentProviderPermissionLocked( + ProviderInfo cpi, ProcessRecord r, int mode) { + final int callingPid = (r != null) ? r.pid : Binder.getCallingPid(); + final int callingUid = (r != null) ? r.info.uid : Binder.getCallingUid(); + if (checkComponentPermission(cpi.readPermission, callingPid, callingUid, + cpi.exported ? -1 : cpi.applicationInfo.uid) + == PackageManager.PERMISSION_GRANTED + && mode == ParcelFileDescriptor.MODE_READ_ONLY || mode == -1) { + return null; + } + if (checkComponentPermission(cpi.writePermission, callingPid, callingUid, + cpi.exported ? -1 : cpi.applicationInfo.uid) + == PackageManager.PERMISSION_GRANTED) { + return null; + } + String msg = "Permission Denial: opening provider " + cpi.name + + " from " + (r != null ? r : "(null)") + " (pid=" + callingPid + + ", uid=" + callingUid + ") requires " + + cpi.readPermission + " or " + cpi.writePermission; + Log.w(TAG, msg); + return msg; + } + + private final ContentProviderHolder getContentProviderImpl( + IApplicationThread caller, String name) { + ContentProviderRecord cpr; + ProviderInfo cpi = null; + + synchronized(this) { + ProcessRecord r = null; + if (caller != null) { + r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when getting content provider " + name); + } + } + + // First check if this content provider has been published... + cpr = (ContentProviderRecord)mProvidersByName.get(name); + if (cpr != null) { + cpi = cpr.info; + if (checkContentProviderPermissionLocked(cpi, r, -1) != null) { + return new ContentProviderHolder(cpi, + cpi.readPermission != null + ? cpi.readPermission : cpi.writePermission); + } + + if (r != null && cpr.canRunHere(r)) { + // This provider has been published or is in the process + // of being published... but it is also allowed to run + // in the caller's process, so don't make a connection + // and just let the caller instantiate its own instance. + if (cpr.provider != null) { + // don't give caller the provider object, it needs + // to make its own. + cpr = new ContentProviderRecord(cpr); + } + return cpr; + } + + final long origId = Binder.clearCallingIdentity(); + + // In this case the provider is a single instance, so we can + // return it right away. + if (r != null) { + r.conProviders.add(cpr); + cpr.clients.add(r); + } else { + cpr.externals++; + } + + if (cpr.app != null) { + updateOomAdjLocked(cpr.app); + } + + Binder.restoreCallingIdentity(origId); + + } else { + try { + cpi = ActivityThread.getPackageManager(). + resolveContentProvider(name, PackageManager.GET_URI_PERMISSION_PATTERNS); + } catch (RemoteException ex) { + } + if (cpi == null) { + return null; + } + + if (checkContentProviderPermissionLocked(cpi, r, -1) != null) { + return new ContentProviderHolder(cpi, + cpi.readPermission != null + ? cpi.readPermission : cpi.writePermission); + } + + cpr = (ContentProviderRecord)mProvidersByClass.get(cpi.name); + final boolean firstClass = cpr == null; + if (firstClass) { + try { + ApplicationInfo ai = + ActivityThread.getPackageManager(). + getApplicationInfo( + cpi.applicationInfo.packageName, + PackageManager.GET_SHARED_LIBRARY_FILES); + if (ai == null) { + Log.w(TAG, "No package info for content provider " + + cpi.name); + return null; + } + cpr = new ContentProviderRecord(cpi, ai); + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + + if (r != null && cpr.canRunHere(r)) { + // If this is a multiprocess provider, then just return its + // info and allow the caller to instantiate it. Only do + // this if the provider is the same user as the caller's + // process, or can run as root (so can be in any process). + return cpr; + } + + if (false) { + RuntimeException e = new RuntimeException("foo"); + //Log.w(TAG, "LAUNCHING REMOTE PROVIDER (myuid " + r.info.uid + // + " pruid " + ai.uid + "): " + cpi.className, e); + } + + // This is single process, and our app is now connecting to it. + // See if we are already in the process of launching this + // provider. + final int N = mLaunchingProviders.size(); + int i; + for (i=0; i<N; i++) { + if (mLaunchingProviders.get(i) == cpr) { + break; + } + if (false) { + final ContentProviderRecord rec = + (ContentProviderRecord)mLaunchingProviders.get(i); + if (rec.info.name.equals(cpr.info.name)) { + cpr = rec; + break; + } + } + } + + // If the provider is not already being launched, then get it + // started. + if (i >= N) { + final long origId = Binder.clearCallingIdentity(); + ProcessRecord proc = startProcessLocked(cpi.processName, + cpr.appInfo, false, 0, "content provider", + new ComponentName(cpi.applicationInfo.packageName, + cpi.name)); + if (proc == null) { + Log.w(TAG, "Unable to launch app " + + cpi.applicationInfo.packageName + "/" + + cpi.applicationInfo.uid + " for provider " + + name + ": process is bad"); + return null; + } + cpr.launchingApp = proc; + mLaunchingProviders.add(cpr); + Binder.restoreCallingIdentity(origId); + } + + // Make sure the provider is published (the same provider class + // may be published under multiple names). + if (firstClass) { + mProvidersByClass.put(cpi.name, cpr); + } + mProvidersByName.put(name, cpr); + + if (r != null) { + r.conProviders.add(cpr); + cpr.clients.add(r); + } else { + cpr.externals++; + } + } + } + + // Wait for the provider to be published... + synchronized (cpr) { + while (cpr.provider == null) { + if (cpr.launchingApp == null) { + Log.w(TAG, "Unable to launch app " + + cpi.applicationInfo.packageName + "/" + + cpi.applicationInfo.uid + " for provider " + + name + ": launching app became null"); + EventLog.writeEvent(LOG_AM_PROVIDER_LOST_PROCESS, + cpi.applicationInfo.packageName, + cpi.applicationInfo.uid, name); + return null; + } + try { + cpr.wait(); + } catch (InterruptedException ex) { + } + } + } + return cpr; + } + + public final ContentProviderHolder getContentProvider( + IApplicationThread caller, String name) { + if (caller == null) { + String msg = "null IApplicationThread when getting content provider " + + name; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + + return getContentProviderImpl(caller, name); + } + + private ContentProviderHolder getContentProviderExternal(String name) { + return getContentProviderImpl(null, name); + } + + /** + * Drop a content provider from a ProcessRecord's bookkeeping + * @param cpr + */ + public void removeContentProvider(IApplicationThread caller, String name) { + synchronized (this) { + ContentProviderRecord cpr = (ContentProviderRecord)mProvidersByName.get(name); + if(cpr == null) { + //remove from mProvidersByClass + if(localLOGV) Log.v(TAG, name+" content provider not found in providers list"); + return; + } + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " when removing content provider " + name); + } + //update content provider record entry info + ContentProviderRecord localCpr = (ContentProviderRecord) mProvidersByClass.get(cpr.info.name); + if(localLOGV) Log.v(TAG, "Removing content provider requested by "+ + r.info.processName+" from process "+localCpr.appInfo.processName); + if(localCpr.appInfo.processName == r.info.processName) { + //should not happen. taken care of as a local provider + if(localLOGV) Log.v(TAG, "local provider doing nothing Ignoring other names"); + return; + } else { + localCpr.clients.remove(r); + r.conProviders.remove(localCpr); + } + updateOomAdjLocked(); + } + } + + private void removeContentProviderExternal(String name) { + synchronized (this) { + ContentProviderRecord cpr = (ContentProviderRecord)mProvidersByName.get(name); + if(cpr == null) { + //remove from mProvidersByClass + if(localLOGV) Log.v(TAG, name+" content provider not found in providers list"); + return; + } + + //update content provider record entry info + ContentProviderRecord localCpr = (ContentProviderRecord) mProvidersByClass.get(cpr.info.name); + localCpr.externals--; + if (localCpr.externals < 0) { + Log.e(TAG, "Externals < 0 for content provider " + localCpr); + } + updateOomAdjLocked(); + } + } + + public final void publishContentProviders(IApplicationThread caller, + List<ContentProviderHolder> providers) { + if (providers == null) { + return; + } + + synchronized(this) { + final ProcessRecord r = getRecordForAppLocked(caller); + if (r == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when publishing content providers"); + } + + final long origId = Binder.clearCallingIdentity(); + + final int N = providers.size(); + for (int i=0; i<N; i++) { + ContentProviderHolder src = providers.get(i); + if (src == null || src.info == null || src.provider == null) { + continue; + } + ContentProviderRecord dst = + (ContentProviderRecord)r.pubProviders.get(src.info.name); + if (dst != null) { + mProvidersByClass.put(dst.info.name, dst); + String names[] = dst.info.authority.split(";"); + for (int j = 0; j < names.length; j++) { + mProvidersByName.put(names[j], dst); + } + + int NL = mLaunchingProviders.size(); + int j; + for (j=0; j<NL; j++) { + if (mLaunchingProviders.get(j) == dst) { + mLaunchingProviders.remove(j); + j--; + NL--; + } + } + synchronized (dst) { + dst.provider = src.provider; + dst.app = r; + dst.notifyAll(); + } + updateOomAdjLocked(r); + } + } + + Binder.restoreCallingIdentity(origId); + } + } + + public static final void installSystemProviders() { + ProcessRecord app = mSelf.mProcessNames.get("system", Process.SYSTEM_UID); + List providers = mSelf.generateApplicationProvidersLocked(app); + mSystemThread.installSystemProviders(providers); + } + + // ========================================================= + // GLOBAL MANAGEMENT + // ========================================================= + + final ProcessRecord newProcessRecordLocked(IApplicationThread thread, + ApplicationInfo info, String customProcess) { + String proc = customProcess != null ? customProcess : info.processName; + BatteryStatsImpl.Uid.Proc ps = null; + BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); + synchronized (stats) { + ps = stats.getProcessStatsLocked(info.uid, proc); + } + return new ProcessRecord(ps, thread, info, proc); + } + + final ProcessRecord addAppLocked(ApplicationInfo info) { + ProcessRecord app = getProcessRecordLocked(info.processName, info.uid); + + if (app == null) { + app = newProcessRecordLocked(null, info, null); + mProcessNames.put(info.processName, info.uid, app); + updateLRUListLocked(app, true); + } + + if ((info.flags&(ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT)) + == (ApplicationInfo.FLAG_SYSTEM|ApplicationInfo.FLAG_PERSISTENT)) { + app.persistent = true; + app.maxAdj = CORE_SERVER_ADJ; + } + if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) { + mPersistentStartingProcesses.add(app); + startProcessLocked(app, "added application", app.processName); + } + + return app; + } + + public void unhandledBack() { + enforceCallingPermission(android.Manifest.permission.FORCE_BACK, + "unhandledBack()"); + + synchronized(this) { + int count = mHistory.size(); + if (Config.LOGD) Log.d( + TAG, "Performing unhandledBack(): stack size = " + count); + if (count > 1) { + final long origId = Binder.clearCallingIdentity(); + finishActivityLocked((HistoryRecord)mHistory.get(count-1), + count-1, Activity.RESULT_CANCELED, null, "unhandled-back"); + Binder.restoreCallingIdentity(origId); + } + } + } + + public ParcelFileDescriptor openContentUri(Uri uri) throws RemoteException { + String name = uri.getAuthority(); + ContentProviderHolder cph = getContentProviderExternal(name); + ParcelFileDescriptor pfd = null; + if (cph != null) { + // We record the binder invoker's uid in thread-local storage before + // going to the content provider to open the file. Later, in the code + // that handles all permissions checks, we look for this uid and use + // that rather than the Activity Manager's own uid. The effect is that + // we do the check against the caller's permissions even though it looks + // to the content provider like the Activity Manager itself is making + // the request. + sCallerIdentity.set(new Identity( + Binder.getCallingPid(), Binder.getCallingUid())); + try { + pfd = cph.provider.openFile(uri, "r"); + } catch (FileNotFoundException e) { + // do nothing; pfd will be returned null + } finally { + // Ensure that whatever happens, we clean up the identity state + sCallerIdentity.remove(); + } + + // We've got the fd now, so we're done with the provider. + removeContentProviderExternal(name); + } else { + Log.d(TAG, "Failed to get provider for authority '" + name + "'"); + } + return pfd; + } + + public void goingToSleep() { + synchronized(this) { + mSleeping = true; + mWindowManager.setEventDispatching(false); + + if (mResumedActivity != null) { + pauseIfSleepingLocked(); + } else { + Log.w(TAG, "goingToSleep with no resumed activity!"); + } + } + } + + void pauseIfSleepingLocked() { + if (mSleeping) { + if (!mGoingToSleep.isHeld()) { + mGoingToSleep.acquire(); + if (mLaunchingActivity.isHeld()) { + mLaunchingActivity.release(); + mHandler.removeMessages(LAUNCH_TIMEOUT_MSG); + } + } + + // If we are not currently pausing an activity, get the current + // one to pause. If we are pausing one, we will just let that stuff + // run and release the wake lock when all done. + if (mPausingActivity == null) { + if (DEBUG_PAUSE) Log.v(TAG, "Sleep needs to pause..."); + if (DEBUG_USER_LEAVING) Log.v(TAG, "Sleep => pause with userLeaving=false"); + startPausingLocked(false, true); + } + } + } + + public void wakingUp() { + synchronized(this) { + if (mGoingToSleep.isHeld()) { + mGoingToSleep.release(); + } + mWindowManager.setEventDispatching(true); + mSleeping = false; + resumeTopActivityLocked(null); + } + } + + public void setDebugApp(String packageName, boolean waitForDebugger, + boolean persistent) { + enforceCallingPermission(android.Manifest.permission.SET_DEBUG_APP, + "setDebugApp()"); + + // Note that this is not really thread safe if there are multiple + // callers into it at the same time, but that's not a situation we + // care about. + if (persistent) { + final ContentResolver resolver = mContext.getContentResolver(); + Settings.System.putString( + resolver, Settings.System.DEBUG_APP, + packageName); + Settings.System.putInt( + resolver, Settings.System.WAIT_FOR_DEBUGGER, + waitForDebugger ? 1 : 0); + } + + synchronized (this) { + if (!persistent) { + mOrigDebugApp = mDebugApp; + mOrigWaitForDebugger = mWaitForDebugger; + } + mDebugApp = packageName; + mWaitForDebugger = waitForDebugger; + mDebugTransient = !persistent; + if (packageName != null) { + final long origId = Binder.clearCallingIdentity(); + uninstallPackageLocked(packageName, -1, false); + Binder.restoreCallingIdentity(origId); + } + } + } + + public void setAlwaysFinish(boolean enabled) { + enforceCallingPermission(android.Manifest.permission.SET_ALWAYS_FINISH, + "setAlwaysFinish()"); + + Settings.System.putInt( + mContext.getContentResolver(), + Settings.System.ALWAYS_FINISH_ACTIVITIES, enabled ? 1 : 0); + + synchronized (this) { + mAlwaysFinishActivities = enabled; + } + } + + public void setActivityWatcher(IActivityWatcher watcher) { + enforceCallingPermission(android.Manifest.permission.SET_ACTIVITY_WATCHER, + "setActivityWatcher()"); + synchronized (this) { + mWatcher = watcher; + } + } + + public final void enterSafeMode() { + synchronized(this) { + // It only makes sense to do this before the system is ready + // and started launching other packages. + if (!mSystemReady) { + try { + ActivityThread.getPackageManager().enterSafeMode(); + } catch (RemoteException e) { + } + + View v = LayoutInflater.from(mContext).inflate( + com.android.internal.R.layout.safe_mode, null); + WindowManager.LayoutParams lp = new WindowManager.LayoutParams(); + lp.type = WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY; + lp.width = WindowManager.LayoutParams.WRAP_CONTENT; + lp.height = WindowManager.LayoutParams.WRAP_CONTENT; + lp.gravity = Gravity.BOTTOM | Gravity.LEFT; + lp.format = v.getBackground().getOpacity(); + lp.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE + | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; + ((WindowManager)mContext.getSystemService( + Context.WINDOW_SERVICE)).addView(v, lp); + } + } + } + + public void noteWakeupAlarm(IIntentSender sender) { + if (!(sender instanceof PendingIntentRecord)) { + return; + } + BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); + synchronized (stats) { + if (mBatteryStatsService.isOnBattery()) { + mBatteryStatsService.enforceCallingPermission(); + PendingIntentRecord rec = (PendingIntentRecord)sender; + int MY_UID = Binder.getCallingUid(); + int uid = rec.uid == MY_UID ? Process.SYSTEM_UID : rec.uid; + BatteryStatsImpl.Uid.Pkg pkg = + stats.getPackageStatsLocked(uid, rec.key.packageName); + pkg.incWakeupsLocked(); + } + } + } + + public boolean killPidsForMemory(int[] pids) { + if (Binder.getCallingUid() != Process.SYSTEM_UID) { + throw new SecurityException("killPidsForMemory only available to the system"); + } + + // XXX Note: don't acquire main activity lock here, because the window + // manager calls in with its locks held. + + boolean killed = false; + synchronized (mPidsSelfLocked) { + int[] types = new int[pids.length]; + int worstType = 0; + for (int i=0; i<pids.length; i++) { + ProcessRecord proc = mPidsSelfLocked.get(pids[i]); + if (proc != null) { + int type = proc.setAdj; + types[i] = type; + if (type > worstType) { + worstType = type; + } + } + } + + // If the worse oom_adj is somewhere in the hidden proc LRU range, + // then constrain it so we will kill all hidden procs. + if (worstType < EMPTY_APP_ADJ && worstType > HIDDEN_APP_MIN_ADJ) { + worstType = HIDDEN_APP_MIN_ADJ; + } + Log.w(TAG, "Killing processes for memory at adjustment " + worstType); + for (int i=0; i<pids.length; i++) { + ProcessRecord proc = mPidsSelfLocked.get(pids[i]); + if (proc == null) { + continue; + } + int adj = proc.setAdj; + if (adj >= worstType) { + Log.w(TAG, "Killing for memory: " + proc + " (adj " + + adj + ")"); + EventLog.writeEvent(LOG_AM_KILL_FOR_MEMORY, proc.pid, + proc.processName, adj); + killed = true; + Process.killProcess(pids[i]); + } + } + } + return killed; + } + + public void reportPss(IApplicationThread caller, int pss) { + Watchdog.PssRequestor req; + String name; + ProcessRecord callerApp; + synchronized (this) { + if (caller == null) { + return; + } + callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + return; + } + callerApp.lastPss = pss; + req = callerApp; + name = callerApp.processName; + } + Watchdog.getInstance().reportPss(req, name, pss); + if (!callerApp.persistent) { + removeRequestedPss(callerApp); + } + } + + public void requestPss(Runnable completeCallback) { + ArrayList<ProcessRecord> procs; + synchronized (this) { + mRequestPssCallback = completeCallback; + mRequestPssList.clear(); + for (int i=mLRUProcesses.size()-1; i>=0; i--) { + ProcessRecord proc = mLRUProcesses.get(i); + if (!proc.persistent) { + mRequestPssList.add(proc); + } + } + procs = new ArrayList<ProcessRecord>(mRequestPssList); + } + + int oldPri = Process.getThreadPriority(Process.myTid()); + Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); + for (int i=procs.size()-1; i>=0; i--) { + ProcessRecord proc = procs.get(i); + proc.lastPss = 0; + proc.requestPss(); + } + Process.setThreadPriority(oldPri); + } + + void removeRequestedPss(ProcessRecord proc) { + Runnable callback = null; + synchronized (this) { + if (mRequestPssList.remove(proc)) { + if (mRequestPssList.size() == 0) { + callback = mRequestPssCallback; + mRequestPssCallback = null; + } + } + } + + if (callback != null) { + callback.run(); + } + } + + public void collectPss(Watchdog.PssStats stats) { + stats.mEmptyPss = 0; + stats.mEmptyCount = 0; + stats.mBackgroundPss = 0; + stats.mBackgroundCount = 0; + stats.mServicePss = 0; + stats.mServiceCount = 0; + stats.mVisiblePss = 0; + stats.mVisibleCount = 0; + stats.mForegroundPss = 0; + stats.mForegroundCount = 0; + stats.mNoPssCount = 0; + synchronized (this) { + int i; + int NPD = mProcDeaths.length < stats.mProcDeaths.length + ? mProcDeaths.length : stats.mProcDeaths.length; + int aggr = 0; + for (i=0; i<NPD; i++) { + aggr += mProcDeaths[i]; + stats.mProcDeaths[i] = aggr; + } + while (i<stats.mProcDeaths.length) { + stats.mProcDeaths[i] = 0; + i++; + } + + for (i=mLRUProcesses.size()-1; i>=0; i--) { + ProcessRecord proc = mLRUProcesses.get(i); + if (proc.persistent) { + continue; + } + //Log.i(TAG, "Proc " + proc + ": pss=" + proc.lastPss); + if (proc.lastPss == 0) { + stats.mNoPssCount++; + continue; + } + if (proc.setAdj == EMPTY_APP_ADJ) { + stats.mEmptyPss += proc.lastPss; + stats.mEmptyCount++; + } else if (proc.setAdj == CONTENT_PROVIDER_ADJ) { + stats.mEmptyPss += proc.lastPss; + stats.mEmptyCount++; + } else if (proc.setAdj >= HIDDEN_APP_MIN_ADJ) { + stats.mBackgroundPss += proc.lastPss; + stats.mBackgroundCount++; + } else if (proc.setAdj >= VISIBLE_APP_ADJ) { + stats.mVisiblePss += proc.lastPss; + stats.mVisibleCount++; + } else { + stats.mForegroundPss += proc.lastPss; + stats.mForegroundCount++; + } + } + } + } + + public final void startRunning(String pkg, String cls, String action, + String data) { + synchronized(this) { + if (mStartRunning) { + return; + } + mStartRunning = true; + mTopComponent = pkg != null && cls != null + ? new ComponentName(pkg, cls) : null; + mTopAction = action != null ? action : Intent.ACTION_MAIN; + mTopData = data; + if (!mSystemReady) { + return; + } + } + + systemReady(); + } + + private void retrieveSettings() { + final ContentResolver resolver = mContext.getContentResolver(); + String debugApp = Settings.System.getString( + resolver, Settings.System.DEBUG_APP); + boolean waitForDebugger = Settings.System.getInt( + resolver, Settings.System.WAIT_FOR_DEBUGGER, 0) != 0; + boolean alwaysFinishActivities = Settings.System.getInt( + resolver, Settings.System.ALWAYS_FINISH_ACTIVITIES, 0) != 0; + + Configuration configuration = new Configuration(); + Settings.System.getConfiguration(resolver, configuration); + + synchronized (this) { + mDebugApp = mOrigDebugApp = debugApp; + mWaitForDebugger = mOrigWaitForDebugger = waitForDebugger; + mAlwaysFinishActivities = alwaysFinishActivities; + // This happens before any activities are started, so we can + // change mConfiguration in-place. + mConfiguration.updateFrom(configuration); + } + } + + public boolean testIsSystemReady() { + // no need to synchronize(this) just to read & return the value + return mSystemReady; + } + + public void systemReady() { + // In the simulator, startRunning will never have been called, which + // normally sets a few crucial variables. Do it here instead. + if (!Process.supportsProcesses()) { + mStartRunning = true; + mTopAction = Intent.ACTION_MAIN; + } + + synchronized(this) { + if (mSystemReady) { + return; + } + mSystemReady = true; + if (!mStartRunning) { + return; + } + } + + if (Config.LOGD) Log.d(TAG, "Start running!"); + EventLog.writeEvent(LOG_BOOT_PROGRESS_AMS_READY, + SystemClock.uptimeMillis()); + + synchronized(this) { + if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) { + ResolveInfo ri = mContext.getPackageManager() + .resolveActivity(new Intent(Intent.ACTION_FACTORY_TEST), + 0); + CharSequence errorMsg = null; + if (ri != null) { + ActivityInfo ai = ri.activityInfo; + ApplicationInfo app = ai.applicationInfo; + if ((app.flags&ApplicationInfo.FLAG_SYSTEM) != 0) { + mTopAction = Intent.ACTION_FACTORY_TEST; + mTopData = null; + mTopComponent = new ComponentName(app.packageName, + ai.name); + } else { + errorMsg = mContext.getResources().getText( + com.android.internal.R.string.factorytest_not_system); + } + } else { + errorMsg = mContext.getResources().getText( + com.android.internal.R.string.factorytest_no_action); + } + if (errorMsg != null) { + mTopAction = null; + mTopData = null; + mTopComponent = null; + Message msg = Message.obtain(); + msg.what = SHOW_FACTORY_ERROR_MSG; + msg.getData().putCharSequence("msg", errorMsg); + mHandler.sendMessage(msg); + } + } + } + + retrieveSettings(); + + synchronized (this) { + if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) { + try { + List apps = ActivityThread.getPackageManager(). + getPersistentApplications(PackageManager.GET_SHARED_LIBRARY_FILES); + if (apps != null) { + int N = apps.size(); + int i; + for (i=0; i<N; i++) { + ApplicationInfo info + = (ApplicationInfo)apps.get(i); + if (info != null && + !info.packageName.equals("android")) { + addAppLocked(info); + } + } + } + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + + try { + if (ActivityThread.getPackageManager().hasSystemUidErrors()) { + Message msg = Message.obtain(); + msg.what = SHOW_UID_ERROR_MSG; + mHandler.sendMessage(msg); + } + } catch (RemoteException e) { + } + + // Start up initial activity. + mBooting = true; + resumeTopActivityLocked(null); + } + } + + boolean makeAppCrashingLocked(ProcessRecord app, + String tag, String shortMsg, String longMsg, byte[] crashData) { + app.crashing = true; + app.crashingReport = generateProcessError(app, + ActivityManager.ProcessErrorStateInfo.CRASHED, tag, shortMsg, longMsg, crashData); + startAppProblemLocked(app); + app.stopFreezingAllLocked(); + return handleAppCrashLocked(app); + } + + void makeAppNotRespondingLocked(ProcessRecord app, + String tag, String shortMsg, String longMsg, byte[] crashData) { + app.notResponding = true; + app.notRespondingReport = generateProcessError(app, + ActivityManager.ProcessErrorStateInfo.NOT_RESPONDING, tag, shortMsg, longMsg, + crashData); + startAppProblemLocked(app); + app.stopFreezingAllLocked(); + } + + /** + * Generate a process error record, suitable for attachment to a ProcessRecord. + * + * @param app The ProcessRecord in which the error occurred. + * @param condition Crashing, Application Not Responding, etc. Values are defined in + * ActivityManager.AppErrorStateInfo + * @param tag The tag that was passed into handleApplicationError(). Typically the classname. + * @param shortMsg Short message describing the crash. + * @param longMsg Long message describing the crash. + * @param crashData Raw data passed into handleApplicationError(). Typically a stack trace. + * + * @return Returns a fully-formed AppErrorStateInfo record. + */ + private ActivityManager.ProcessErrorStateInfo generateProcessError(ProcessRecord app, + int condition, String tag, String shortMsg, String longMsg, byte[] crashData) { + ActivityManager.ProcessErrorStateInfo report = new ActivityManager.ProcessErrorStateInfo(); + + report.condition = condition; + report.processName = app.processName; + report.pid = app.pid; + report.uid = app.info.uid; + report.tag = tag; + report.shortMsg = shortMsg; + report.longMsg = longMsg; + report.crashData = crashData; + + return report; + } + + void killAppAtUsersRequest(ProcessRecord app, Dialog fromDialog, + boolean crashed) { + synchronized (this) { + app.crashing = false; + app.crashingReport = null; + app.notResponding = false; + app.notRespondingReport = null; + if (app.anrDialog == fromDialog) { + app.anrDialog = null; + } + if (app.waitDialog == fromDialog) { + app.waitDialog = null; + } + if (app.pid > 0 && app.pid != MY_PID) { + if (crashed) { + handleAppCrashLocked(app); + } + Log.i(ActivityManagerService.TAG, "Killing process " + + app.processName + + " (pid=" + app.pid + ") at user's request"); + Process.killProcess(app.pid); + } + + } + } + + boolean handleAppCrashLocked(ProcessRecord app) { + long now = SystemClock.uptimeMillis(); + + Long crashTime = mProcessCrashTimes.get(app.info.processName, + app.info.uid); + if (crashTime != null && now < crashTime+MIN_CRASH_INTERVAL) { + // This process loses! + Log.w(TAG, "Process " + app.info.processName + + " has crashed too many times: killing!"); + EventLog.writeEvent(LOG_AM_PROCESS_CRASHED_TOO_MUCH, + app.info.processName, app.info.uid); + killServicesLocked(app, false); + for (int i=mHistory.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)mHistory.get(i); + if (r.app == app) { + if (Config.LOGD) Log.d( + TAG, " Force finishing activity " + + r.intent.getComponent().flattenToShortString()); + finishActivityLocked(r, i, Activity.RESULT_CANCELED, null, "crashed"); + } + } + if (!app.persistent) { + // We don't want to start this process again until the user + // explicitly does so... but for persistent process, we really + // need to keep it running. If a persistent process is actually + // repeatedly crashing, then badness for everyone. + EventLog.writeEvent(LOG_AM_PROCESS_BAD, app.info.uid, + app.info.processName); + mBadProcesses.put(app.info.processName, app.info.uid, now); + app.bad = true; + mProcessCrashTimes.remove(app.info.processName, app.info.uid); + app.removed = true; + removeProcessLocked(app, false); + return false; + } + } + + // Bump up the crash count of any services currently running in the proc. + if (app.services.size() != 0) { + // Any services running in the application need to be placed + // back in the pending list. + Iterator it = app.services.iterator(); + while (it.hasNext()) { + ServiceRecord sr = (ServiceRecord)it.next(); + sr.crashCount++; + } + } + + mProcessCrashTimes.put(app.info.processName, app.info.uid, now); + return true; + } + + void startAppProblemLocked(ProcessRecord app) { + skipCurrentReceiverLocked(app); + } + + void skipCurrentReceiverLocked(ProcessRecord app) { + boolean reschedule = false; + BroadcastRecord r = app.curReceiver; + if (r != null) { + // The current broadcast is waiting for this app's receiver + // to be finished. Looks like that's not going to happen, so + // let the broadcast continue. + logBroadcastReceiverDiscard(r); + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + reschedule = true; + } + r = mPendingBroadcast; + if (r != null && r.curApp == app) { + if (DEBUG_BROADCAST) Log.v(TAG, + "skip & discard pending app " + r); + logBroadcastReceiverDiscard(r); + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + reschedule = true; + } + if (reschedule) { + scheduleBroadcastsLocked(); + } + } + + public int handleApplicationError(IBinder app, int flags, + String tag, String shortMsg, String longMsg, byte[] crashData) { + AppErrorResult result = new AppErrorResult(); + + ProcessRecord r = null; + synchronized (this) { + if (app != null) { + for (SparseArray<ProcessRecord> apps : mProcessNames.getMap().values()) { + final int NA = apps.size(); + for (int ia=0; ia<NA; ia++) { + ProcessRecord p = apps.valueAt(ia); + if (p.thread != null && p.thread.asBinder() == app) { + r = p; + break; + } + } + } + } + + if (r != null) { + // The application has crashed. Send the SIGQUIT to the process so + // that it can dump its state. + Process.sendSignal(r.pid, Process.SIGNAL_QUIT); + //Log.i(TAG, "Current system threads:"); + //Process.sendSignal(MY_PID, Process.SIGNAL_QUIT); + } + + if (mWatcher != null) { + try { + String name = r != null ? r.processName : null; + int pid = r != null ? r.pid : Binder.getCallingPid(); + if (!mWatcher.appCrashed(name, pid, + shortMsg, longMsg, crashData)) { + Log.w(TAG, "Force-killing crashed app " + name + + " at watcher's request"); + Process.killProcess(pid); + return 0; + } + } catch (RemoteException e) { + mWatcher = null; + } + } + + final long origId = Binder.clearCallingIdentity(); + + // If this process is running instrumentation, finish it. + if (r != null && r.instrumentationClass != null) { + Log.w(TAG, "Error in app " + r.processName + + " running instrumentation " + r.instrumentationClass + ":"); + if (shortMsg != null) Log.w(TAG, " " + shortMsg); + if (longMsg != null) Log.w(TAG, " " + longMsg); + Bundle info = new Bundle(); + info.putString("shortMsg", shortMsg); + info.putString("longMsg", longMsg); + finishInstrumentationLocked(r, Activity.RESULT_CANCELED, info); + Binder.restoreCallingIdentity(origId); + return 0; + } + + if (r != null) { + if (!makeAppCrashingLocked(r, tag, shortMsg, longMsg, crashData)) { + return 0; + } + } else { + Log.w(TAG, "Some application object " + app + " tag " + tag + + " has crashed, but I don't know who it is."); + Log.w(TAG, "ShortMsg:" + shortMsg); + Log.w(TAG, "LongMsg:" + longMsg); + Binder.restoreCallingIdentity(origId); + return 0; + } + + Message msg = Message.obtain(); + msg.what = SHOW_ERROR_MSG; + HashMap data = new HashMap(); + data.put("result", result); + data.put("app", r); + data.put("flags", flags); + data.put("shortMsg", shortMsg); + data.put("longMsg", longMsg); + if (r != null && (r.info.flags&ApplicationInfo.FLAG_SYSTEM) != 0) { + // For system processes, submit crash data to the server. + data.put("crashData", crashData); + } + msg.obj = data; + mHandler.sendMessage(msg); + + Binder.restoreCallingIdentity(origId); + } + + int res = result.get(); + + synchronized (this) { + if (r != null) { + mProcessCrashTimes.put(r.info.processName, r.info.uid, + SystemClock.uptimeMillis()); + } + } + + return res; + } + + public List<ActivityManager.ProcessErrorStateInfo> getProcessesInErrorState() { + // assume our apps are happy - lazy create the list + List<ActivityManager.ProcessErrorStateInfo> errList = null; + + synchronized (this) { + + // iterate across all processes + final int N = mLRUProcesses.size(); + for (int i = 0; i < N; i++) { + ProcessRecord app = mLRUProcesses.get(i); + if ((app.thread != null) && (app.crashing || app.notResponding)) { + // This one's in trouble, so we'll generate a report for it + // crashes are higher priority (in case there's a crash *and* an anr) + ActivityManager.ProcessErrorStateInfo report = null; + if (app.crashing) { + report = app.crashingReport; + } else if (app.notResponding) { + report = app.notRespondingReport; + } + + if (report != null) { + if (errList == null) { + errList = new ArrayList<ActivityManager.ProcessErrorStateInfo>(1); + } + errList.add(report); + } else { + Log.w(TAG, "Missing app error report, app = " + app.processName + + " crashing = " + app.crashing + + " notResponding = " + app.notResponding); + } + } + } + } + + return errList; + } + + public List<ActivityManager.RunningAppProcessInfo> getRunningAppProcesses() { + // Lazy instantiation of list + List<ActivityManager.RunningAppProcessInfo> runList = null; + synchronized (this) { + // Iterate across all processes + final int N = mLRUProcesses.size(); + for (int i = 0; i < N; i++) { + ProcessRecord app = mLRUProcesses.get(i); + if ((app.thread != null) && (!app.crashing && !app.notResponding)) { + // Generate process state info for running application + ActivityManager.RunningAppProcessInfo currApp = + new ActivityManager.RunningAppProcessInfo(app.processName, + app.pid, app.getPackageList()); + int adj = app.curAdj; + if (adj >= CONTENT_PROVIDER_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_EMPTY; + } else if (adj >= HIDDEN_APP_MIN_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_BACKGROUND; + currApp.lru = adj - HIDDEN_APP_MIN_ADJ; + } else if (adj >= SECONDARY_SERVER_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_SERVICE; + } else if (adj >= VISIBLE_APP_ADJ) { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_VISIBLE; + } else { + currApp.importance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND; + } + //Log.v(TAG, "Proc " + app.processName + ": imp=" + currApp.importance + // + " lru=" + currApp.lru); + if (runList == null) { + runList = new ArrayList<ActivityManager.RunningAppProcessInfo>(); + } + runList.add(currApp); + } + } + } + return runList; + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + if (args.length != 0 && "service".equals(args[0])) { + dumpService(fd, pw, args); + return; + } + pw.println("Activities in Current Activity Manager State:"); + dumpHistoryList(pw, mHistory, " ", "History"); + pw.println(" "); + pw.println(" Running activities (most recent first):"); + dumpHistoryList(pw, mLRUActivities, " ", "Running"); + if (mWaitingVisibleActivities.size() > 0) { + pw.println(" "); + pw.println(" Activities waiting for another to become visible:"); + dumpHistoryList(pw, mWaitingVisibleActivities, " ", "Waiting"); + } + if (mStoppingActivities.size() > 0) { + pw.println(" "); + pw.println(" Activities waiting to stop:"); + dumpHistoryList(pw, mStoppingActivities, " ", "Stopping"); + } + if (mFinishingActivities.size() > 0) { + pw.println(" "); + pw.println(" Activities waiting to finish:"); + dumpHistoryList(pw, mFinishingActivities, " ", "Finishing"); + } + + pw.println(" "); + pw.println(" mPausingActivity: " + mPausingActivity); + pw.println(" mResumedActivity: " + mResumedActivity); + pw.println(" mFocusedActivity: " + mFocusedActivity); + pw.println(" mLastPausedActivity: " + mLastPausedActivity); + + if (mRecentTasks.size() > 0) { + pw.println(" "); + pw.println("Recent tasks in Current Activity Manager State:"); + + final int N = mRecentTasks.size(); + for (int i=0; i<N; i++) { + pw.println(" Recent Task #" + i); + mRecentTasks.get(i).dump(pw, " "); + } + } + + pw.println(" "); + pw.println(" mCurTask: " + mCurTask); + + pw.println(" "); + pw.println("Processes in Current Activity Manager State:"); + + boolean needSep = false; + int numPers = 0; + + for (SparseArray<ProcessRecord> procs : mProcessNames.getMap().values()) { + final int NA = procs.size(); + for (int ia=0; ia<NA; ia++) { + if (!needSep) { + pw.println(" All known processes:"); + needSep = true; + } + ProcessRecord r = procs.valueAt(ia); + pw.println((r.persistent ? " *PERSISTENT* Process [" : " Process [") + + r.processName + "] UID " + procs.keyAt(ia)); + r.dump(pw, " "); + if (r.persistent) { + numPers++; + } + } + } + + if (mLRUProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Running processes (most recent first):"); + dumpProcessList(pw, mLRUProcesses, " ", + "Running Norm Proc", "Running PERS Proc", true); + needSep = true; + } + + synchronized (mPidsSelfLocked) { + if (mPidsSelfLocked.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" PID mappings:"); + for (int i=0; i<mPidsSelfLocked.size(); i++) { + pw.println(" PID #" + mPidsSelfLocked.keyAt(i) + + ": " + mPidsSelfLocked.valueAt(i)); + } + } + } + + if (mForegroundProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Foreground Processes:"); + for (int i=0; i<mForegroundProcesses.size(); i++) { + pw.println(" PID #" + mForegroundProcesses.keyAt(i) + + ": " + mForegroundProcesses.valueAt(i)); + } + } + + if (mPersistentStartingProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Persisent processes that are starting:"); + dumpProcessList(pw, mPersistentStartingProcesses, " ", + "Starting Initial Proc", "Restarting PERS Proc", false); + } + + if (mStartingProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Processes that are starting:"); + dumpProcessList(pw, mStartingProcesses, " ", + "Starting Norm Proc", "Starting PERS Proc", false); + } + + if (mRemovedProcesses.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Processes that are being removed:"); + dumpProcessList(pw, mRemovedProcesses, " ", + "Removed Norm Proc", "Removed PERS Proc", false); + } + + if (mProcessesOnHold.size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Processes that are on old until the system is ready:"); + dumpProcessList(pw, mProcessesOnHold, " ", + "OnHold Norm Proc", "OnHold PERS Proc", false); + } + + if (mProcessCrashTimes.getMap().size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Time since processes crashed:"); + long now = SystemClock.uptimeMillis(); + for (Map.Entry<String, SparseArray<Long>> procs + : mProcessCrashTimes.getMap().entrySet()) { + SparseArray<Long> uids = procs.getValue(); + final int N = uids.size(); + for (int i=0; i<N; i++) { + pw.println(" Process " + procs.getKey() + + " uid " + uids.keyAt(i) + + ": last crashed " + + (now-uids.valueAt(i)) + " ms ago"); + } + } + } + + if (mBadProcesses.getMap().size() > 0) { + if (needSep) pw.println(" "); + needSep = true; + pw.println(" Bad processes:"); + for (Map.Entry<String, SparseArray<Long>> procs + : mBadProcesses.getMap().entrySet()) { + SparseArray<Long> uids = procs.getValue(); + final int N = uids.size(); + for (int i=0; i<N; i++) { + pw.println(" Bad process " + procs.getKey() + + " uid " + uids.keyAt(i) + + ": crashed at time " + uids.valueAt(i)); + } + } + } + + pw.println(" "); + pw.println(" Total persistent processes: " + numPers); + pw.println(" mConfiguration: " + mConfiguration); + pw.println(" mStartRunning=" + mStartRunning + + " mSystemReady=" + mSystemReady + + " mBooting=" + mBooting + + " mBooted=" + mBooted + + " mFactoryTest=" + mFactoryTest); + pw.println(" mSleeping=" + mSleeping); + pw.println(" mGoingToSleep=" + mGoingToSleep); + pw.println(" mLaunchingActivity=" + mLaunchingActivity); + pw.println(" mDebugApp=" + mDebugApp + "/orig=" + mOrigDebugApp + + " mDebugTransient=" + mDebugTransient + + " mOrigWaitForDebugger=" + mOrigWaitForDebugger); + pw.println(" mAlwaysFinishActivities=" + mAlwaysFinishActivities + + " mWatcher=" + mWatcher); + } + } + + /** + * There are three ways to call this: + * - no service specified: dump all the services + * - a flattened component name that matched an existing service was specified as the + * first arg: dump that one service + * - the first arg isn't the flattened component name of an existing service: + * dump all services whose component contains the first arg as a substring + */ + protected void dumpService(FileDescriptor fd, PrintWriter pw, String[] args) { + String[] newArgs; + String componentNameString; + ServiceRecord r; + if (args.length == 1) { + componentNameString = null; + newArgs = EMPTY_STRING_ARRAY; + r = null; + } else { + componentNameString = args[1]; + ComponentName componentName = ComponentName.unflattenFromString(componentNameString); + r = componentName != null ? mServices.get(componentName) : null; + newArgs = new String[args.length - 2]; + if (args.length > 2) System.arraycopy(args, 2, newArgs, 0, args.length - 2); + } + + if (r != null) { + dumpService(fd, pw, r, newArgs); + } else { + for (ServiceRecord r1 : mServices.values()) { + if (componentNameString == null + || r1.name.flattenToString().contains(componentNameString)) { + dumpService(fd, pw, r1, newArgs); + } + } + } + } + + /** + * Invokes IApplicationThread.dumpService() on the thread of the specified service if + * there is a thread associated with the service. + */ + private void dumpService(FileDescriptor fd, PrintWriter pw, ServiceRecord r, String[] args) { + pw.println(" Service " + r.name.flattenToString()); + if (r.app != null && r.app.thread != null) { + try { + // flush anything that is already in the PrintWriter since the thread is going + // to write to the file descriptor directly + pw.flush(); + r.app.thread.dumpService(fd, r, args); + pw.print("\n"); + } catch (RemoteException e) { + pw.println("got a RemoteException while dumping the service"); + } + } + } + + void dumpBroadcasts(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + pw.println("Broadcasts in Current Activity Manager State:"); + + if (mRegisteredReceivers.size() > 0) { + pw.println(" "); + pw.println(" Registered Receivers:"); + Iterator it = mRegisteredReceivers.values().iterator(); + while (it.hasNext()) { + ReceiverList r = (ReceiverList)it.next(); + pw.println(" Receiver " + r.receiver); + r.dump(pw, " "); + } + } + + pw.println(" "); + pw.println("Receiver Resolver Table:"); + mReceiverResolver.dump(new PrintWriterPrinter(pw), " "); + + if (mParallelBroadcasts.size() > 0 || mOrderedBroadcasts.size() > 0 + || mPendingBroadcast != null) { + if (mParallelBroadcasts.size() > 0) { + pw.println(" "); + pw.println(" Active broadcasts:"); + } + for (int i=mParallelBroadcasts.size()-1; i>=0; i--) { + pw.println(" Broadcast #" + i + ":"); + mParallelBroadcasts.get(i).dump(pw, " "); + } + if (mOrderedBroadcasts.size() > 0) { + pw.println(" "); + pw.println(" Active serialized broadcasts:"); + } + for (int i=mOrderedBroadcasts.size()-1; i>=0; i--) { + pw.println(" Serialized Broadcast #" + i + ":"); + mOrderedBroadcasts.get(i).dump(pw, " "); + } + pw.println(" "); + pw.println(" Pending broadcast:"); + if (mPendingBroadcast != null) { + mPendingBroadcast.dump(pw, " "); + } else { + pw.println(" (null)"); + } + } + + pw.println(" "); + pw.println(" mBroadcastsScheduled=" + mBroadcastsScheduled); + if (mStickyBroadcasts != null) { + pw.println(" "); + pw.println(" Sticky broadcasts:"); + for (Map.Entry<String, ArrayList<Intent>> ent + : mStickyBroadcasts.entrySet()) { + pw.println(" Sticky action " + ent.getKey() + ":"); + ArrayList<Intent> intents = ent.getValue(); + final int N = intents.size(); + for (int i=0; i<N; i++) { + pw.println(" " + intents.get(i)); + } + } + } + + pw.println(" "); + pw.println(" mHandler:"); + mHandler.dump(new PrintWriterPrinter(pw), " "); + } + } + + void dumpServices(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + pw.println("Services in Current Activity Manager State:"); + + boolean needSep = false; + + if (mServices.size() > 0) { + pw.println(" Active services:"); + Iterator<ServiceRecord> it = mServices.values().iterator(); + while (it.hasNext()) { + ServiceRecord r = it.next(); + pw.println(" Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mPendingServices.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Pending services:"); + for (int i=0; i<mPendingServices.size(); i++) { + ServiceRecord r = mPendingServices.get(i); + pw.println(" Pending Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mRestartingServices.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Restarting services:"); + for (int i=0; i<mRestartingServices.size(); i++) { + ServiceRecord r = mRestartingServices.get(i); + pw.println(" Restarting Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mStoppingServices.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Stopping services:"); + for (int i=0; i<mStoppingServices.size(); i++) { + ServiceRecord r = mStoppingServices.get(i); + pw.println(" Stopping Service " + r.shortName); + r.dump(pw, " "); + } + needSep = true; + } + + if (mServiceConnections.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Connection bindings to services:"); + Iterator<ConnectionRecord> it + = mServiceConnections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord r = it.next(); + pw.println(" " + r.binding.service.shortName + + " -> " + r.conn.asBinder()); + r.dump(pw, " "); + } + } + } + } + + void dumpProviders(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + + pw.println("Content Providers in Current Activity Manager State:"); + + boolean needSep = false; + + if (mProvidersByName.size() > 0) { + pw.println(" Published content providers (by name):"); + Iterator it = mProvidersByName.entrySet().iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry)it.next(); + ContentProviderRecord r = (ContentProviderRecord)e.getValue(); + pw.println(" Provider " + (String)e.getKey()); + r.dump(pw, " "); + } + needSep = true; + } + + if (mProvidersByClass.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Published content providers (by class):"); + Iterator it = mProvidersByClass.entrySet().iterator(); + while (it.hasNext()) { + Map.Entry e = (Map.Entry)it.next(); + ContentProviderRecord r = (ContentProviderRecord)e.getValue(); + pw.println(" Provider " + (String)e.getKey()); + r.dump(pw, " "); + } + needSep = true; + } + + if (mLaunchingProviders.size() > 0) { + if (needSep) pw.println(" "); + pw.println(" Launching content providers:"); + for (int i=mLaunchingProviders.size()-1; i>=0; i--) { + pw.println(" Provider #" + i + ":"); + ((ContentProviderRecord)mLaunchingProviders.get(i)).dump(pw, " "); + } + needSep = true; + } + + pw.println(); + pw.println("Granted Uri Permissions:"); + for (int i=0; i<mGrantedUriPermissions.size(); i++) { + int uid = mGrantedUriPermissions.keyAt(i); + HashMap<Uri, UriPermission> perms + = mGrantedUriPermissions.valueAt(i); + pw.println(" Uris granted to uid " + uid + ":"); + for (UriPermission perm : perms.values()) { + perm.dump(pw, " "); + } + } + } + } + + void dumpSenders(PrintWriter pw) { + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump ActivityManager from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " without permission " + + android.Manifest.permission.DUMP); + return; + } + + pw.println("Intent Senders in Current Activity Manager State:"); + + if (this.mIntentSenderRecords.size() > 0) { + Iterator<WeakReference<PendingIntentRecord>> it + = mIntentSenderRecords.values().iterator(); + while (it.hasNext()) { + WeakReference<PendingIntentRecord> ref = it.next(); + PendingIntentRecord rec = ref != null ? ref.get(): null; + if (rec != null) { + pw.println(" IntentSender " + rec); + rec.dump(pw, " "); + } else { + pw.println(" IntentSender " + ref); + } + } + } + } + } + + private static final void dumpHistoryList(PrintWriter pw, List list, + String prefix, String label) { + TaskRecord lastTask = null; + for (int i=list.size()-1; i>=0; i--) { + HistoryRecord r = (HistoryRecord)list.get(i); + if (lastTask != r.task) { + lastTask = r.task; + lastTask.dump(pw, prefix + " "); + } + pw.println(prefix + " " + label + " #" + i + ":"); + r.dump(pw, prefix + " "); + } + } + + private static final int dumpProcessList(PrintWriter pw, List list, + String prefix, String normalLabel, String persistentLabel, + boolean inclOomAdj) { + int numPers = 0; + for (int i=list.size()-1; i>=0; i--) { + ProcessRecord r = (ProcessRecord)list.get(i); + if (false) { + pw.println(prefix + (r.persistent ? persistentLabel : normalLabel) + + " #" + i + ":"); + r.dump(pw, prefix + " "); + } else if (inclOomAdj) { + pw.println(String.format("%s%s #%2d: oom_adj=%3d %s", + prefix, (r.persistent ? persistentLabel : normalLabel), + i, r.setAdj, r.toString())); + } else { + pw.println(String.format("%s%s #%2d: %s", + prefix, (r.persistent ? persistentLabel : normalLabel), + i, r.toString())); + } + if (r.persistent) { + numPers++; + } + } + return numPers; + } + + private static final void dumpApplicationMemoryUsage(FileDescriptor fd, + PrintWriter pw, List list, String prefix, String[] args) { + final boolean isCheckinRequest = scanArgs(args, "-c"); + long uptime = SystemClock.uptimeMillis(); + long realtime = SystemClock.elapsedRealtime(); + + if (isCheckinRequest) { + // short checkin version + pw.println(uptime + "," + realtime); + pw.flush(); + } else { + pw.println("Applications Memory Usage (kB):"); + pw.println("Uptime: " + uptime + " Realtime: " + realtime); + } + for (int i = list.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = (ProcessRecord)list.get(i); + if (r.thread != null) { + if (!isCheckinRequest) { + pw.println("\n** MEMINFO in pid " + r.pid + " [" + r.processName + "] **"); + pw.flush(); + } + try { + r.thread.asBinder().dump(fd, args); + } catch (RemoteException e) { + if (!isCheckinRequest) { + pw.println("Got RemoteException!"); + pw.flush(); + } + } + } + } + } + + /** + * Searches array of arguments for the specified string + * @param args array of argument strings + * @param value value to search for + * @return true if the value is contained in the array + */ + private static boolean scanArgs(String[] args, String value) { + if (args != null) { + for (String arg : args) { + if (value.equals(arg)) { + return true; + } + } + } + return false; + } + + private final int indexOfTokenLocked(IBinder token, boolean required) { + int count = mHistory.size(); + + // convert the token to an entry in the history. + HistoryRecord r = null; + int index = -1; + for (int i=count-1; i>=0; i--) { + Object o = mHistory.get(i); + if (o == token) { + r = (HistoryRecord)o; + index = i; + break; + } + } + if (index < 0 && required) { + RuntimeInit.crash(TAG, new InvalidTokenException(token)); + } + + return index; + } + + static class InvalidTokenException extends Exception { + InvalidTokenException(IBinder token) { + super("Bad activity token: " + token); + } + } + + private final void killServicesLocked(ProcessRecord app, + boolean allowRestart) { + // Report disconnected services. + if (false) { + // XXX we are letting the client link to the service for + // death notifications. + if (app.services.size() > 0) { + Iterator it = app.services.iterator(); + while (it.hasNext()) { + ServiceRecord r = (ServiceRecord)it.next(); + if (r.connections.size() > 0) { + Iterator<ConnectionRecord> jt + = r.connections.values().iterator(); + while (jt.hasNext()) { + ConnectionRecord c = jt.next(); + if (c.binding.client != app) { + try { + //c.conn.connected(r.className, null); + } catch (Exception e) { + // todo: this should be asynchronous! + Log.w(TAG, "Exception thrown disconnected servce " + + r.shortName + + " from app " + app.processName, e); + } + } + } + } + } + } + } + + // Clean up any connections this application has to other services. + if (app.connections.size() > 0) { + Iterator<ConnectionRecord> it = app.connections.iterator(); + while (it.hasNext()) { + ConnectionRecord r = it.next(); + removeConnectionLocked(r, app, null); + } + } + app.connections.clear(); + + if (app.services.size() != 0) { + // Any services running in the application need to be placed + // back in the pending list. + Iterator it = app.services.iterator(); + while (it.hasNext()) { + ServiceRecord sr = (ServiceRecord)it.next(); + synchronized (sr.stats.getBatteryStats()) { + sr.stats.stopLaunchedLocked(); + } + sr.app = null; + sr.executeNesting = 0; + mStoppingServices.remove(sr); + if (sr.bindings.size() > 0) { + Iterator<IntentBindRecord> bindings + = sr.bindings.values().iterator(); + while (bindings.hasNext()) { + IntentBindRecord b = bindings.next(); + if (DEBUG_SERVICE) Log.v(TAG, "Killing binding " + b + + ": shouldUnbind=" + b.hasBound); + b.binder = null; + b.requested = b.received = b.hasBound = false; + } + } + + if (sr.crashCount >= 2) { + Log.w(TAG, "Service crashed " + sr.crashCount + + " times, stopping: " + sr); + EventLog.writeEvent(LOG_AM_SERVICE_CRASHED_TOO_MUCH, + sr.crashCount, sr.shortName, app.pid); + bringDownServiceLocked(sr, true); + } else if (!allowRestart) { + bringDownServiceLocked(sr, true); + } else { + scheduleServiceRestartLocked(sr); + } + } + + if (!allowRestart) { + app.services.clear(); + } + } + + app.executingServices.clear(); + } + + private final void removeDyingProviderLocked(ProcessRecord proc, + ContentProviderRecord cpr) { + synchronized (cpr) { + cpr.launchingApp = null; + cpr.notifyAll(); + } + + mProvidersByClass.remove(cpr.info.name); + String names[] = cpr.info.authority.split(";"); + for (int j = 0; j < names.length; j++) { + mProvidersByName.remove(names[j]); + } + + Iterator<ProcessRecord> cit = cpr.clients.iterator(); + while (cit.hasNext()) { + ProcessRecord capp = cit.next(); + if (!capp.persistent && capp.thread != null + && capp.pid != 0 + && capp.pid != MY_PID) { + Log.i(TAG, "Killing app " + capp.processName + + " (pid " + capp.pid + + ") because provider " + cpr.info.name + + " is in dying process " + proc.processName); + Process.killProcess(capp.pid); + } + } + + mLaunchingProviders.remove(cpr); + } + + /** + * Main code for cleaning up a process when it has gone away. This is + * called both as a result of the process dying, or directly when stopping + * a process when running in single process mode. + */ + private final void cleanUpApplicationRecordLocked(ProcessRecord app, + boolean restarting, int index) { + if (index >= 0) { + mLRUProcesses.remove(index); + } + + // Dismiss any open dialogs. + if (app.crashDialog != null) { + app.crashDialog.dismiss(); + app.crashDialog = null; + } + if (app.anrDialog != null) { + app.anrDialog.dismiss(); + app.anrDialog = null; + } + if (app.waitDialog != null) { + app.waitDialog.dismiss(); + app.waitDialog = null; + } + + app.crashing = false; + app.notResponding = false; + + app.resetPackageList(); + app.thread = null; + app.forcingToForeground = null; + app.foregroundServices = false; + + killServicesLocked(app, true); + + boolean restart = false; + + int NL = mLaunchingProviders.size(); + + // Remove published content providers. + if (!app.pubProviders.isEmpty()) { + Iterator it = app.pubProviders.values().iterator(); + while (it.hasNext()) { + ContentProviderRecord cpr = (ContentProviderRecord)it.next(); + cpr.provider = null; + cpr.app = null; + + // See if someone is waiting for this provider... in which + // case we don't remove it, but just let it restart. + int i = 0; + if (!app.bad) { + for (; i<NL; i++) { + if (mLaunchingProviders.get(i) == cpr) { + restart = true; + break; + } + } + } else { + i = NL; + } + + if (i >= NL) { + removeDyingProviderLocked(app, cpr); + NL = mLaunchingProviders.size(); + } + } + app.pubProviders.clear(); + } + + // Look through the content providers we are waiting to have launched, + // and if any run in this process then either schedule a restart of + // the process or kill the client waiting for it if this process has + // gone bad. + for (int i=0; i<NL; i++) { + ContentProviderRecord cpr = (ContentProviderRecord) + mLaunchingProviders.get(i); + if (cpr.launchingApp == app) { + if (!app.bad) { + restart = true; + } else { + removeDyingProviderLocked(app, cpr); + NL = mLaunchingProviders.size(); + } + } + } + + // Unregister from connected content providers. + if (!app.conProviders.isEmpty()) { + Iterator it = app.conProviders.iterator(); + while (it.hasNext()) { + ContentProviderRecord cpr = (ContentProviderRecord)it.next(); + cpr.clients.remove(app); + } + app.conProviders.clear(); + } + + skipCurrentReceiverLocked(app); + + // Unregister any receivers. + if (app.receivers.size() > 0) { + Iterator<ReceiverList> it = app.receivers.iterator(); + while (it.hasNext()) { + removeReceiverLocked(it.next()); + } + app.receivers.clear(); + } + + // If the caller is restarting this app, then leave it in its + // current lists and let the caller take care of it. + if (restarting) { + return; + } + + if (!app.persistent) { + if (DEBUG_PROCESSES) Log.v(TAG, + "Removing non-persistent process during cleanup: " + app); + mProcessNames.remove(app.processName, app.info.uid); + } else if (!app.removed) { + // This app is persistent, so we need to keep its record around. + // If it is not already on the pending app list, add it there + // and start a new process for it. + app.thread = null; + app.forcingToForeground = null; + app.foregroundServices = false; + if (mPersistentStartingProcesses.indexOf(app) < 0) { + mPersistentStartingProcesses.add(app); + restart = true; + } + } + mProcessesOnHold.remove(app); + + if (restart) { + // We have components that still need to be running in the + // process, so re-launch it. + mProcessNames.put(app.processName, app.info.uid, app); + startProcessLocked(app, "restart", app.processName); + } else if (app.pid > 0 && app.pid != MY_PID) { + // Goodbye! + synchronized (mPidsSelfLocked) { + mPidsSelfLocked.remove(app.pid); + mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app); + } + app.pid = 0; + } + } + + // ========================================================= + // SERVICES + // ========================================================= + + ActivityManager.RunningServiceInfo makeRunningServiceInfoLocked(ServiceRecord r) { + ActivityManager.RunningServiceInfo info = + new ActivityManager.RunningServiceInfo(); + info.service = r.name; + if (r.app != null) { + info.pid = r.app.pid; + } + info.process = r.processName; + info.foreground = r.isForeground; + info.activeSince = r.createTime; + info.started = r.startRequested; + info.clientCount = r.connections.size(); + info.crashCount = r.crashCount; + info.lastActivityTime = r.lastActivity; + return info; + } + + public List<ActivityManager.RunningServiceInfo> getServices(int maxNum, + int flags) { + synchronized (this) { + ArrayList<ActivityManager.RunningServiceInfo> res + = new ArrayList<ActivityManager.RunningServiceInfo>(); + + if (mServices.size() > 0) { + Iterator<ServiceRecord> it = mServices.values().iterator(); + while (it.hasNext() && res.size() < maxNum) { + res.add(makeRunningServiceInfoLocked(it.next())); + } + } + + for (int i=0; i<mRestartingServices.size() && res.size() < maxNum; i++) { + ServiceRecord r = mRestartingServices.get(i); + ActivityManager.RunningServiceInfo info = + makeRunningServiceInfoLocked(r); + info.restarting = r.nextRestartTime; + res.add(info); + } + + return res; + } + } + + private final ServiceRecord findServiceLocked(ComponentName name, + IBinder token) { + ServiceRecord r = mServices.get(name); + return r == token ? r : null; + } + + private final class ServiceLookupResult { + final ServiceRecord record; + final String permission; + + ServiceLookupResult(ServiceRecord _record, String _permission) { + record = _record; + permission = _permission; + } + }; + + private ServiceLookupResult findServiceLocked(Intent service, + String resolvedType) { + ServiceRecord r = null; + if (service.getComponent() != null) { + r = mServices.get(service.getComponent()); + } + if (r == null) { + Intent.FilterComparison filter = new Intent.FilterComparison(service); + r = mServicesByIntent.get(filter); + } + + if (r == null) { + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveService( + service, resolvedType, 0); + ServiceInfo sInfo = + rInfo != null ? rInfo.serviceInfo : null; + if (sInfo == null) { + return null; + } + + ComponentName name = new ComponentName( + sInfo.applicationInfo.packageName, sInfo.name); + r = mServices.get(name); + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + if (r != null) { + int callingPid = Binder.getCallingPid(); + int callingUid = Binder.getCallingUid(); + if (checkComponentPermission(r.permission, + callingPid, callingUid, r.exported ? -1 : r.appInfo.uid) + != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: Accessing service " + r.name + + " from pid=" + callingPid + + ", uid=" + callingUid + + " requires " + r.permission); + return new ServiceLookupResult(null, r.permission); + } + return new ServiceLookupResult(r, null); + } + return null; + } + + private class ServiceRestarter implements Runnable { + private ServiceRecord mService; + + void setService(ServiceRecord service) { + mService = service; + } + + public void run() { + synchronized(ActivityManagerService.this) { + performServiceRestartLocked(mService); + } + } + } + + private ServiceLookupResult retrieveServiceLocked(Intent service, + String resolvedType, int callingPid, int callingUid) { + ServiceRecord r = null; + if (service.getComponent() != null) { + r = mServices.get(service.getComponent()); + } + Intent.FilterComparison filter = new Intent.FilterComparison(service); + r = mServicesByIntent.get(filter); + if (r == null) { + try { + ResolveInfo rInfo = + ActivityThread.getPackageManager().resolveService( + service, resolvedType, PackageManager.GET_SHARED_LIBRARY_FILES); + ServiceInfo sInfo = + rInfo != null ? rInfo.serviceInfo : null; + if (sInfo == null) { + Log.w(TAG, "Unable to start service " + service + + ": not found"); + return null; + } + + ComponentName name = new ComponentName( + sInfo.applicationInfo.packageName, sInfo.name); + r = mServices.get(name); + if (r == null) { + filter = new Intent.FilterComparison(service.cloneFilter()); + ServiceRestarter res = new ServiceRestarter(); + BatteryStatsImpl.Uid.Pkg.Serv ss = null; + BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics(); + synchronized (stats) { + ss = stats.getServiceStatsLocked( + sInfo.applicationInfo.uid, sInfo.packageName, + sInfo.name); + } + r = new ServiceRecord(ss, name, filter, sInfo, res); + res.setService(r); + mServices.put(name, r); + mServicesByIntent.put(filter, r); + + // Make sure this component isn't in the pending list. + int N = mPendingServices.size(); + for (int i=0; i<N; i++) { + ServiceRecord pr = mPendingServices.get(i); + if (pr.name.equals(name)) { + mPendingServices.remove(i); + i--; + N--; + } + } + } + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + } + if (r != null) { + if (checkComponentPermission(r.permission, + callingPid, callingUid, r.exported ? -1 : r.appInfo.uid) + != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: Accessing service " + r.name + + " from pid=" + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + r.permission); + return new ServiceLookupResult(null, r.permission); + } + return new ServiceLookupResult(r, null); + } + return null; + } + + private final void bumpServiceExecutingLocked(ServiceRecord r) { + long now = SystemClock.uptimeMillis(); + if (r.executeNesting == 0 && r.app != null) { + if (r.app.executingServices.size() == 0) { + Message msg = mHandler.obtainMessage(SERVICE_TIMEOUT_MSG); + msg.obj = r.app; + mHandler.sendMessageAtTime(msg, now+SERVICE_TIMEOUT); + } + r.app.executingServices.add(r); + } + r.executeNesting++; + r.executingStart = now; + } + + private final void sendServiceArgsLocked(ServiceRecord r, + boolean oomAdjusted) { + final int N = r.startArgs.size(); + if (N == 0) { + return; + } + + final int BASEID = r.lastStartId - N + 1; + int i = 0; + while (i < N) { + try { + Intent args = r.startArgs.get(i); + if (DEBUG_SERVICE) Log.v(TAG, "Sending arguments to service: " + + r.name + " " + r.intent + " args=" + args); + bumpServiceExecutingLocked(r); + if (!oomAdjusted) { + oomAdjusted = true; + updateOomAdjLocked(r.app); + } + r.app.thread.scheduleServiceArgs(r, BASEID+i, args); + i++; + } catch (Exception e) { + break; + } + } + if (i == N) { + r.startArgs.clear(); + } else { + while (i > 0) { + r.startArgs.remove(0); + i--; + } + } + } + + private final boolean requestServiceBindingLocked(ServiceRecord r, + IntentBindRecord i, boolean rebind) { + if (r.app == null || r.app.thread == null) { + // If service is not currently running, can't yet bind. + return false; + } + if ((!i.requested || rebind) && i.apps.size() > 0) { + try { + bumpServiceExecutingLocked(r); + if (DEBUG_SERVICE) Log.v(TAG, "Connecting binding " + i + + ": shouldUnbind=" + i.hasBound); + r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind); + if (!rebind) { + i.requested = true; + } + i.hasBound = true; + i.doRebind = false; + } catch (RemoteException e) { + return false; + } + } + return true; + } + + private final void requestServiceBindingsLocked(ServiceRecord r) { + Iterator<IntentBindRecord> bindings = r.bindings.values().iterator(); + while (bindings.hasNext()) { + IntentBindRecord i = bindings.next(); + if (!requestServiceBindingLocked(r, i, false)) { + break; + } + } + } + + private final void realStartServiceLocked(ServiceRecord r, + ProcessRecord app) throws RemoteException { + if (app.thread == null) { + throw new RemoteException(); + } + + r.app = app; + r.restartTime = SystemClock.uptimeMillis(); + + app.services.add(r); + bumpServiceExecutingLocked(r); + updateLRUListLocked(app, true); + + boolean created = false; + try { + if (DEBUG_SERVICE) Log.v(TAG, "Scheduling start service: " + + r.name + " " + r.intent); + EventLog.writeEvent(LOG_AM_CREATE_SERVICE, + System.identityHashCode(r), r.shortName, + r.intent.getIntent().toString(), r.app.pid); + synchronized (r.stats.getBatteryStats()) { + r.stats.startLaunchedLocked(); + } + app.thread.scheduleCreateService(r, r.serviceInfo); + created = true; + } finally { + if (!created) { + app.services.remove(r); + scheduleServiceRestartLocked(r); + } + } + + requestServiceBindingsLocked(r); + sendServiceArgsLocked(r, true); + } + + private final void scheduleServiceRestartLocked(ServiceRecord r) { + r.totalRestartCount++; + if (r.restartDelay == 0) { + r.restartCount++; + r.restartDelay = SERVICE_RESTART_DURATION; + } else { + // If it has been a "reasonably long time" since the service + // was started, then reset our restart duration back to + // the beginning, so we don't infinitely increase the duration + // on a service that just occasionally gets killed (which is + // a normal case, due to process being killed to reclaim memory). + long now = SystemClock.uptimeMillis(); + if (now > (r.restartTime+(SERVICE_RESTART_DURATION*2*2*2))) { + r.restartCount = 1; + r.restartDelay = SERVICE_RESTART_DURATION; + } else { + r.restartDelay *= 2; + } + } + if (!mRestartingServices.contains(r)) { + mRestartingServices.add(r); + } + mHandler.removeCallbacks(r.restarter); + mHandler.postDelayed(r.restarter, r.restartDelay); + r.nextRestartTime = SystemClock.uptimeMillis() + r.restartDelay; + Log.w(TAG, "Scheduling restart of crashed service " + + r.shortName + " in " + r.restartDelay + "ms"); + EventLog.writeEvent(LOG_AM_SCHEDULE_SERVICE_RESTART, + r.shortName, r.restartDelay); + + Message msg = Message.obtain(); + msg.what = SERVICE_ERROR_MSG; + msg.obj = r; + mHandler.sendMessage(msg); + } + + final void performServiceRestartLocked(ServiceRecord r) { + if (!mRestartingServices.contains(r)) { + return; + } + bringUpServiceLocked(r, r.intent.getIntent().getFlags(), true); + } + + private final boolean unscheduleServiceRestartLocked(ServiceRecord r) { + if (r.restartDelay == 0) { + return false; + } + r.resetRestartCounter(); + mRestartingServices.remove(r); + mHandler.removeCallbacks(r.restarter); + return true; + } + + private final boolean bringUpServiceLocked(ServiceRecord r, + int intentFlags, boolean whileRestarting) { + //Log.i(TAG, "Bring up service:"); + //r.dump(" "); + + if (r.app != null) { + sendServiceArgsLocked(r, false); + return true; + } + + if (!whileRestarting && r.restartDelay > 0) { + // If waiting for a restart, then do nothing. + return true; + } + + if (DEBUG_SERVICE) Log.v(TAG, "Bringing up service " + r.name + + " " + r.intent); + + final String appName = r.processName; + ProcessRecord app = getProcessRecordLocked(appName, r.appInfo.uid); + if (app != null && app.thread != null) { + try { + realStartServiceLocked(r, app); + return true; + } catch (RemoteException e) { + Log.w(TAG, "Exception when starting service " + r.shortName, e); + } + + // If a dead object exception was thrown -- fall through to + // restart the application. + } + + if (!mPendingServices.contains(r)) { + // Not running -- get it started, and enqueue this service record + // to be executed when the app comes up. + if (startProcessLocked(appName, r.appInfo, true, intentFlags, + "service", r.name) == null) { + Log.w(TAG, "Unable to launch app " + + r.appInfo.packageName + "/" + + r.appInfo.uid + " for service " + + r.intent.getIntent() + ": process is bad"); + bringDownServiceLocked(r, true); + return false; + } + mPendingServices.add(r); + } + return true; + } + + private final void bringDownServiceLocked(ServiceRecord r, boolean force) { + //Log.i(TAG, "Bring down service:"); + //r.dump(" "); + + // Does it still need to run? + if (!force && r.startRequested) { + return; + } + if (r.connections.size() > 0) { + if (!force) { + // XXX should probably keep a count of the number of auto-create + // connections directly in the service. + Iterator<ConnectionRecord> it = r.connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord cr = it.next(); + if ((cr.flags&Context.BIND_AUTO_CREATE) != 0) { + return; + } + } + } + + // Report to all of the connections that the service is no longer + // available. + Iterator<ConnectionRecord> it = r.connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + try { + // todo: shouldn't be a synchronous call! + c.conn.connected(r.name, null); + } catch (Exception e) { + Log.w(TAG, "Failure disconnecting service " + r.name + + " to connection " + c.conn.asBinder() + + " (in " + c.binding.client.processName + ")", e); + } + } + } + + // Tell the service that it has been unbound. + if (r.bindings.size() > 0 && r.app != null && r.app.thread != null) { + Iterator<IntentBindRecord> it = r.bindings.values().iterator(); + while (it.hasNext()) { + IntentBindRecord ibr = it.next(); + if (DEBUG_SERVICE) Log.v(TAG, "Bringing down binding " + ibr + + ": hasBound=" + ibr.hasBound); + if (r.app != null && r.app.thread != null && ibr.hasBound) { + try { + bumpServiceExecutingLocked(r); + updateOomAdjLocked(r.app); + ibr.hasBound = false; + r.app.thread.scheduleUnbindService(r, + ibr.intent.getIntent()); + } catch (Exception e) { + Log.w(TAG, "Exception when unbinding service " + + r.shortName, e); + serviceDoneExecutingLocked(r, true); + } + } + } + } + + if (DEBUG_SERVICE) Log.v(TAG, "Bringing down service " + r.name + + " " + r.intent); + EventLog.writeEvent(LOG_AM_DESTROY_SERVICE, + System.identityHashCode(r), r.shortName, + (r.app != null) ? r.app.pid : -1); + + mServices.remove(r.name); + mServicesByIntent.remove(r.intent); + if (localLOGV) Log.v(TAG, "BRING DOWN SERVICE: " + r.shortName); + r.totalRestartCount = 0; + unscheduleServiceRestartLocked(r); + + // Also make sure it is not on the pending list. + int N = mPendingServices.size(); + for (int i=0; i<N; i++) { + if (mPendingServices.get(i) == r) { + mPendingServices.remove(i); + if (DEBUG_SERVICE) Log.v( + TAG, "Removed pending service: " + r.shortName); + i--; + N--; + } + } + + if (r.app != null) { + synchronized (r.stats.getBatteryStats()) { + r.stats.stopLaunchedLocked(); + } + r.app.services.remove(r); + if (r.app.thread != null) { + updateServiceForegroundLocked(r.app, false); + try { + Log.i(TAG, "Stopping service: " + r.shortName); + bumpServiceExecutingLocked(r); + mStoppingServices.add(r); + updateOomAdjLocked(r.app); + r.app.thread.scheduleStopService(r); + } catch (Exception e) { + Log.w(TAG, "Exception when stopping service " + + r.shortName, e); + serviceDoneExecutingLocked(r, true); + } + } else { + if (DEBUG_SERVICE) Log.v( + TAG, "Removed service that has no process: " + r.shortName); + } + } else { + if (DEBUG_SERVICE) Log.v( + TAG, "Removed service that is not running: " + r.shortName); + } + } + + ComponentName startServiceLocked(IApplicationThread caller, + Intent service, String resolvedType, + int callingPid, int callingUid) { + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "startService: " + service + + " type=" + resolvedType + " args=" + service.getExtras()); + + if (caller != null) { + final ProcessRecord callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when starting service " + service); + } + } + + ServiceLookupResult res = + retrieveServiceLocked(service, resolvedType, + callingPid, callingUid); + if (res == null) { + return null; + } + if (res.record == null) { + return new ComponentName("!", res.permission != null + ? res.permission : "private to package"); + } + ServiceRecord r = res.record; + if (unscheduleServiceRestartLocked(r)) { + if (DEBUG_SERVICE) Log.v(TAG, "START SERVICE WHILE RESTART PENDING: " + + r.shortName); + } + r.startRequested = true; + r.startArgs.add(service); + r.lastStartId++; + if (r.lastStartId < 1) { + r.lastStartId = 1; + } + r.lastActivity = SystemClock.uptimeMillis(); + synchronized (r.stats.getBatteryStats()) { + r.stats.startRunningLocked(); + } + if (!bringUpServiceLocked(r, service.getFlags(), false)) { + return new ComponentName("!", "Service process is bad"); + } + return r.name; + } + } + + public ComponentName startService(IApplicationThread caller, Intent service, + String resolvedType) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + final int callingPid = Binder.getCallingPid(); + final int callingUid = Binder.getCallingUid(); + final long origId = Binder.clearCallingIdentity(); + ComponentName res = startServiceLocked(caller, service, + resolvedType, callingPid, callingUid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + ComponentName startServiceInPackage(int uid, + Intent service, String resolvedType) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + ComponentName res = startServiceLocked(null, service, + resolvedType, -1, uid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + public int stopService(IApplicationThread caller, Intent service, + String resolvedType) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "stopService: " + service + + " type=" + resolvedType); + + final ProcessRecord callerApp = getRecordForAppLocked(caller); + if (caller != null && callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when stopping service " + service); + } + + // If this service is active, make sure it is stopped. + ServiceLookupResult r = findServiceLocked(service, resolvedType); + if (r != null) { + if (r.record != null) { + synchronized (r.record.stats.getBatteryStats()) { + r.record.stats.stopRunningLocked(); + } + r.record.startRequested = false; + final long origId = Binder.clearCallingIdentity(); + bringDownServiceLocked(r.record, false); + Binder.restoreCallingIdentity(origId); + return 1; + } + return -1; + } + } + + return 0; + } + + public IBinder peekService(Intent service, String resolvedType) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + IBinder ret = null; + + synchronized(this) { + ServiceLookupResult r = findServiceLocked(service, resolvedType); + + if (r != null) { + // r.record is null if findServiceLocked() failed the caller permission check + if (r.record == null) { + throw new SecurityException( + "Permission Denial: Accessing service " + r.record.name + + " from pid=" + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + r.permission); + } + IntentBindRecord ib = r.record.bindings.get(r.record.intent); + if (ib != null) { + ret = ib.binder; + } + } + } + + return ret; + } + + public boolean stopServiceToken(ComponentName className, IBinder token, + int startId) { + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "stopServiceToken: " + className + + " " + token + " startId=" + startId); + ServiceRecord r = findServiceLocked(className, token); + if (r != null && (startId < 0 || r.lastStartId == startId)) { + synchronized (r.stats.getBatteryStats()) { + r.stats.stopRunningLocked(); + r.startRequested = false; + } + final long origId = Binder.clearCallingIdentity(); + bringDownServiceLocked(r, false); + Binder.restoreCallingIdentity(origId); + return true; + } + } + return false; + } + + public void setServiceForeground(ComponentName className, IBinder token, + boolean isForeground) { + synchronized(this) { + ServiceRecord r = findServiceLocked(className, token); + if (r != null) { + if (r.isForeground != isForeground) { + final long origId = Binder.clearCallingIdentity(); + r.isForeground = isForeground; + if (r.app != null) { + updateServiceForegroundLocked(r.app, true); + } + Binder.restoreCallingIdentity(origId); + } + } + } + } + + public void updateServiceForegroundLocked(ProcessRecord proc, boolean oomAdj) { + boolean anyForeground = false; + for (ServiceRecord sr : (HashSet<ServiceRecord>)proc.services) { + if (sr.isForeground) { + anyForeground = true; + break; + } + } + if (anyForeground != proc.foregroundServices) { + proc.foregroundServices = anyForeground; + if (oomAdj) { + updateOomAdjLocked(); + } + } + } + + public int bindService(IApplicationThread caller, IBinder token, + Intent service, String resolvedType, + IServiceConnection connection, int flags) { + // Refuse possible leaked file descriptors + if (service != null && service.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (DEBUG_SERVICE) Log.v(TAG, "bindService: " + service + + " type=" + resolvedType + " conn=" + connection.asBinder() + + " flags=0x" + Integer.toHexString(flags)); + final ProcessRecord callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when binding service " + service); + } + + HistoryRecord activity = null; + if (token != null) { + int aindex = indexOfTokenLocked(token, false); + if (aindex < 0) { + Log.w(TAG, "Binding with unknown activity: " + token); + return 0; + } + activity = (HistoryRecord)mHistory.get(aindex); + } + + ServiceLookupResult res = + retrieveServiceLocked(service, resolvedType, + Binder.getCallingPid(), Binder.getCallingUid()); + if (res == null) { + return 0; + } + if (res.record == null) { + return -1; + } + ServiceRecord s = res.record; + + final long origId = Binder.clearCallingIdentity(); + + if (unscheduleServiceRestartLocked(s)) { + if (DEBUG_SERVICE) Log.v(TAG, "BIND SERVICE WHILE RESTART PENDING: " + + s.shortName); + } + + AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp); + ConnectionRecord c = new ConnectionRecord(b, activity, + connection, flags); + + IBinder binder = connection.asBinder(); + s.connections.put(binder, c); + b.connections.add(c); + if (activity != null) { + if (activity.connections == null) { + activity.connections = new HashSet<ConnectionRecord>(); + } + activity.connections.add(c); + } + b.client.connections.add(c); + mServiceConnections.put(binder, c); + + if ((flags&Context.BIND_AUTO_CREATE) != 0) { + s.lastActivity = SystemClock.uptimeMillis(); + if (!bringUpServiceLocked(s, service.getFlags(), false)) { + return 0; + } + } + + if (s.app != null) { + // This could have made the service more important. + updateOomAdjLocked(s.app); + } + + if (DEBUG_SERVICE) Log.v(TAG, "Bind " + s + " with " + b + + ": received=" + b.intent.received + + " apps=" + b.intent.apps.size() + + " doRebind=" + b.intent.doRebind); + + if (s.app != null && b.intent.received) { + // Service is already running, so we can immediately + // publish the connection. + try { + c.conn.connected(s.name, b.intent.binder); + } catch (Exception e) { + Log.w(TAG, "Failure sending service " + s.shortName + + " to connection " + c.conn.asBinder() + + " (in " + c.binding.client.processName + ")", e); + } + + // If this is the first app connected back to this binding, + // and the service had previously asked to be told when + // rebound, then do so. + if (b.intent.apps.size() == 1 && b.intent.doRebind) { + requestServiceBindingLocked(s, b.intent, true); + } + } else if (!b.intent.requested) { + requestServiceBindingLocked(s, b.intent, false); + } + + Binder.restoreCallingIdentity(origId); + } + + return 1; + } + + private void removeConnectionLocked( + ConnectionRecord c, ProcessRecord skipApp, HistoryRecord skipAct) { + IBinder binder = c.conn.asBinder(); + AppBindRecord b = c.binding; + ServiceRecord s = b.service; + s.connections.remove(binder); + b.connections.remove(c); + if (c.activity != null && c.activity != skipAct) { + if (c.activity.connections != null) { + c.activity.connections.remove(c); + } + } + if (b.client != skipApp) { + b.client.connections.remove(c); + } + mServiceConnections.remove(binder); + + if (b.connections.size() == 0) { + b.intent.apps.remove(b.client); + } + + if (DEBUG_SERVICE) Log.v(TAG, "Disconnecting binding " + b.intent + + ": shouldUnbind=" + b.intent.hasBound); + if (s.app != null && s.app.thread != null && b.intent.apps.size() == 0 + && b.intent.hasBound) { + try { + bumpServiceExecutingLocked(s); + updateOomAdjLocked(s.app); + b.intent.hasBound = false; + // Assume the client doesn't want to know about a rebind; + // we will deal with that later if it asks for one. + b.intent.doRebind = false; + s.app.thread.scheduleUnbindService(s, b.intent.intent.getIntent()); + } catch (Exception e) { + Log.w(TAG, "Exception when unbinding service " + s.shortName, e); + serviceDoneExecutingLocked(s, true); + } + } + + if ((c.flags&Context.BIND_AUTO_CREATE) != 0) { + bringDownServiceLocked(s, false); + } + } + + public boolean unbindService(IServiceConnection connection) { + synchronized (this) { + IBinder binder = connection.asBinder(); + if (DEBUG_SERVICE) Log.v(TAG, "unbindService: conn=" + binder); + ConnectionRecord r = mServiceConnections.get(binder); + if (r == null) { + Log.w(TAG, "Unbind failed: could not find connection for " + + connection.asBinder()); + return false; + } + + final long origId = Binder.clearCallingIdentity(); + + removeConnectionLocked(r, null, null); + + if (r.binding.service.app != null) { + // This could have made the service less important. + updateOomAdjLocked(r.binding.service.app); + } + + Binder.restoreCallingIdentity(origId); + } + + return true; + } + + public void publishService(IBinder token, Intent intent, IBinder service) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (!(token instanceof ServiceRecord)) { + throw new IllegalArgumentException("Invalid service token"); + } + ServiceRecord r = (ServiceRecord)token; + + final long origId = Binder.clearCallingIdentity(); + + if (DEBUG_SERVICE) Log.v(TAG, "PUBLISHING SERVICE " + r.name + + " " + intent + ": " + service); + if (r != null) { + Intent.FilterComparison filter + = new Intent.FilterComparison(intent); + IntentBindRecord b = r.bindings.get(filter); + if (b != null && !b.received) { + b.binder = service; + b.requested = true; + b.received = true; + if (r.connections.size() > 0) { + Iterator<ConnectionRecord> it + = r.connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + if (!filter.equals(c.binding.intent.intent)) { + if (DEBUG_SERVICE) Log.v( + TAG, "Not publishing to: " + c); + if (DEBUG_SERVICE) Log.v( + TAG, "Bound intent: " + c.binding.intent.intent); + if (DEBUG_SERVICE) Log.v( + TAG, "Published intent: " + intent); + continue; + } + if (DEBUG_SERVICE) Log.v(TAG, "Publishing to: " + c); + try { + c.conn.connected(r.name, service); + } catch (Exception e) { + Log.w(TAG, "Failure sending service " + r.name + + " to connection " + c.conn.asBinder() + + " (in " + c.binding.client.processName + ")", e); + } + } + } + } + + serviceDoneExecutingLocked(r, mStoppingServices.contains(r)); + + Binder.restoreCallingIdentity(origId); + } + } + } + + public void unbindFinished(IBinder token, Intent intent, boolean doRebind) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (!(token instanceof ServiceRecord)) { + throw new IllegalArgumentException("Invalid service token"); + } + ServiceRecord r = (ServiceRecord)token; + + final long origId = Binder.clearCallingIdentity(); + + if (r != null) { + Intent.FilterComparison filter + = new Intent.FilterComparison(intent); + IntentBindRecord b = r.bindings.get(filter); + if (DEBUG_SERVICE) Log.v(TAG, "unbindFinished in " + r + + " at " + b + ": apps=" + + (b != null ? b.apps.size() : 0)); + if (b != null) { + if (b.apps.size() > 0) { + // Applications have already bound since the last + // unbind, so just rebind right here. + requestServiceBindingLocked(r, b, true); + } else { + // Note to tell the service the next time there is + // a new client. + b.doRebind = true; + } + } + + serviceDoneExecutingLocked(r, mStoppingServices.contains(r)); + + Binder.restoreCallingIdentity(origId); + } + } + } + + public void serviceDoneExecuting(IBinder token) { + synchronized(this) { + if (!(token instanceof ServiceRecord)) { + throw new IllegalArgumentException("Invalid service token"); + } + ServiceRecord r = (ServiceRecord)token; + boolean inStopping = mStoppingServices.contains(token); + if (r != null) { + if (DEBUG_SERVICE) Log.v(TAG, "DONE EXECUTING SERVICE " + r.name + + ": nesting=" + r.executeNesting + + ", inStopping=" + inStopping); + if (r != token) { + Log.w(TAG, "Done executing service " + r.name + + " with incorrect token: given " + token + + ", expected " + r); + return; + } + + final long origId = Binder.clearCallingIdentity(); + serviceDoneExecutingLocked(r, inStopping); + Binder.restoreCallingIdentity(origId); + } else { + Log.w(TAG, "Done executing unknown service " + r.name + + " with token " + token); + } + } + } + + public void serviceDoneExecutingLocked(ServiceRecord r, boolean inStopping) { + r.executeNesting--; + if (r.executeNesting <= 0 && r.app != null) { + r.app.executingServices.remove(r); + if (r.app.executingServices.size() == 0) { + mHandler.removeMessages(SERVICE_TIMEOUT_MSG, r.app); + } + if (inStopping) { + mStoppingServices.remove(r); + } + updateOomAdjLocked(r.app); + } + } + + void serviceTimeout(ProcessRecord proc) { + synchronized(this) { + if (proc.executingServices.size() == 0 || proc.thread == null) { + return; + } + long maxTime = SystemClock.uptimeMillis() - SERVICE_TIMEOUT; + Iterator<ServiceRecord> it = proc.executingServices.iterator(); + ServiceRecord timeout = null; + long nextTime = 0; + while (it.hasNext()) { + ServiceRecord sr = it.next(); + if (sr.executingStart < maxTime) { + timeout = sr; + break; + } + if (sr.executingStart > nextTime) { + nextTime = sr.executingStart; + } + } + if (timeout != null && mLRUProcesses.contains(proc)) { + Log.w(TAG, "Timeout executing service: " + timeout); + appNotRespondingLocked(proc, null, "Executing service " + + timeout.name); + } else { + Message msg = mHandler.obtainMessage(SERVICE_TIMEOUT_MSG); + msg.obj = proc; + mHandler.sendMessageAtTime(msg, nextTime+SERVICE_TIMEOUT); + } + } + } + + // ========================================================= + // BROADCASTS + // ========================================================= + + private final List getStickies(String action, IntentFilter filter, + List cur) { + final ContentResolver resolver = mContext.getContentResolver(); + final ArrayList<Intent> list = mStickyBroadcasts.get(action); + if (list == null) { + return cur; + } + int N = list.size(); + for (int i=0; i<N; i++) { + Intent intent = list.get(i); + if (filter.match(resolver, intent, true, TAG) >= 0) { + if (cur == null) { + cur = new ArrayList<Intent>(); + } + cur.add(intent); + } + } + return cur; + } + + private final void scheduleBroadcastsLocked() { + if (DEBUG_BROADCAST) Log.v(TAG, "Schedule broadcasts: current=" + + mBroadcastsScheduled); + + if (mBroadcastsScheduled) { + return; + } + mHandler.sendEmptyMessage(BROADCAST_INTENT_MSG); + mBroadcastsScheduled = true; + } + + public Intent registerReceiver(IApplicationThread caller, + IIntentReceiver receiver, IntentFilter filter, String permission) { + synchronized(this) { + ProcessRecord callerApp = null; + if (caller != null) { + callerApp = getRecordForAppLocked(caller); + if (callerApp == null) { + throw new SecurityException( + "Unable to find app for caller " + caller + + " (pid=" + Binder.getCallingPid() + + ") when registering receiver " + receiver); + } + } + + List allSticky = null; + + // Look for any matching sticky broadcasts... + Iterator actions = filter.actionsIterator(); + if (actions != null) { + while (actions.hasNext()) { + String action = (String)actions.next(); + allSticky = getStickies(action, filter, allSticky); + } + } else { + allSticky = getStickies(null, filter, allSticky); + } + + // The first sticky in the list is returned directly back to + // the client. + Intent sticky = allSticky != null ? (Intent)allSticky.get(0) : null; + + if (DEBUG_BROADCAST) Log.v(TAG, "Register receiver " + filter + + ": " + sticky); + + if (receiver == null) { + return sticky; + } + + ReceiverList rl + = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder()); + if (rl == null) { + rl = new ReceiverList(this, callerApp, + Binder.getCallingPid(), + Binder.getCallingUid(), receiver); + if (rl.app != null) { + rl.app.receivers.add(rl); + } else { + try { + receiver.asBinder().linkToDeath(rl, 0); + } catch (RemoteException e) { + return sticky; + } + rl.linkedToDeath = true; + } + mRegisteredReceivers.put(receiver.asBinder(), rl); + } + BroadcastFilter bf = new BroadcastFilter(filter, rl, permission); + rl.add(bf); + if (!bf.debugCheck()) { + Log.w(TAG, "==> For Dynamic broadast"); + } + mReceiverResolver.addFilter(bf); + + // Enqueue broadcasts for all existing stickies that match + // this filter. + if (allSticky != null) { + ArrayList receivers = new ArrayList(); + receivers.add(bf); + + int N = allSticky.size(); + for (int i=0; i<N; i++) { + Intent intent = (Intent)allSticky.get(i); + BroadcastRecord r = new BroadcastRecord(intent, null, + null, -1, -1, null, receivers, null, 0, null, null, + false); + if (mParallelBroadcasts.size() == 0) { + scheduleBroadcastsLocked(); + } + mParallelBroadcasts.add(r); + } + } + + return sticky; + } + } + + public void unregisterReceiver(IIntentReceiver receiver) { + if (DEBUG_BROADCAST) Log.v(TAG, "Unregister receiver: " + receiver); + + boolean doNext = false; + + synchronized(this) { + ReceiverList rl + = (ReceiverList)mRegisteredReceivers.get(receiver.asBinder()); + if (rl != null) { + if (rl.curBroadcast != null) { + BroadcastRecord r = rl.curBroadcast; + doNext = finishReceiverLocked( + receiver.asBinder(), r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + } + + if (rl.app != null) { + rl.app.receivers.remove(rl); + } + removeReceiverLocked(rl); + if (rl.linkedToDeath) { + rl.linkedToDeath = false; + rl.receiver.asBinder().unlinkToDeath(rl, 0); + } + } + } + + if (!doNext) { + return; + } + + final long origId = Binder.clearCallingIdentity(); + processNextBroadcast(false); + trimApplications(); + Binder.restoreCallingIdentity(origId); + } + + void removeReceiverLocked(ReceiverList rl) { + mRegisteredReceivers.remove(rl.receiver.asBinder()); + int N = rl.size(); + for (int i=0; i<N; i++) { + mReceiverResolver.removeFilter(rl.get(i)); + } + } + + private final int broadcastIntentLocked(ProcessRecord callerApp, + String callerPackage, Intent intent, String resolvedType, + IIntentReceiver resultTo, int resultCode, String resultData, + Bundle map, String requiredPermission, + boolean ordered, boolean sticky, int callingPid, int callingUid) { + intent = new Intent(intent); + + if (DEBUG_BROADCAST) Log.v( + TAG, (sticky ? "Broadcast sticky: ": "Broadcast: ") + intent + + " ordered=" + ordered); + if ((resultTo != null) && !ordered) { + Log.w(TAG, "Broadcast " + intent + " not ordered but result callback requested!"); + } + + // Handle special intents: if this broadcast is from the package + // manager about a package being removed, we need to remove all of + // its activities from the history stack. + final boolean uidRemoved = intent.ACTION_UID_REMOVED.equals( + intent.getAction()); + if (intent.ACTION_PACKAGE_REMOVED.equals(intent.getAction()) + || intent.ACTION_PACKAGE_CHANGED.equals(intent.getAction()) + || uidRemoved) { + if (checkComponentPermission( + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED, + callingPid, callingUid, -1) + == PackageManager.PERMISSION_GRANTED) { + if (uidRemoved) { + final Bundle intentExtras = intent.getExtras(); + final int uid = intentExtras != null + ? intentExtras.getInt(Intent.EXTRA_UID) : -1; + if (uid >= 0) { + BatteryStatsImpl bs = mBatteryStatsService.getActiveStatistics(); + synchronized (bs) { + bs.removeUidStatsLocked(uid); + } + } + } else { + Uri data = intent.getData(); + String ssp; + if (data != null && (ssp=data.getSchemeSpecificPart()) != null) { + if (!intent.getBooleanExtra(Intent.EXTRA_DONT_KILL_APP, false)) { + uninstallPackageLocked(ssp, + intent.getIntExtra(Intent.EXTRA_UID, -1), false); + } + } + } + } else { + String msg = "Permission Denial: " + intent.getAction() + + " broadcast from " + callerPackage + " (pid=" + callingPid + + ", uid=" + callingUid + ")" + + " requires " + + android.Manifest.permission.BROADCAST_PACKAGE_REMOVED; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + } + + /* + * If this is the time zone changed action, queue up a message that will reset the timezone + * of all currently running processes. This message will get queued up before the broadcast + * happens. + */ + if (intent.ACTION_TIMEZONE_CHANGED.equals(intent.getAction())) { + mHandler.sendEmptyMessage(UPDATE_TIME_ZONE); + } + + // Add to the sticky list if requested. + if (sticky) { + if (checkPermission(android.Manifest.permission.BROADCAST_STICKY, + callingPid, callingUid) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: broadcastIntent() requesting a sticky broadcast from pid=" + + callingPid + ", uid=" + callingUid + + " requires " + android.Manifest.permission.BROADCAST_STICKY; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + if (requiredPermission != null) { + Log.w(TAG, "Can't broadcast sticky intent " + intent + + " and enforce permission " + requiredPermission); + return BROADCAST_STICKY_CANT_HAVE_PERMISSION; + } + if (intent.getComponent() != null) { + throw new SecurityException( + "Sticky broadcasts can't target a specific component"); + } + ArrayList<Intent> list = mStickyBroadcasts.get(intent.getAction()); + if (list == null) { + list = new ArrayList<Intent>(); + mStickyBroadcasts.put(intent.getAction(), list); + } + int N = list.size(); + int i; + for (i=0; i<N; i++) { + if (intent.filterEquals(list.get(i))) { + // This sticky already exists, replace it. + list.set(i, new Intent(intent)); + break; + } + } + if (i >= N) { + list.add(new Intent(intent)); + } + } + + final ContentResolver resolver = mContext.getContentResolver(); + + // Figure out who all will receive this broadcast. + List receivers = null; + List<BroadcastFilter> registeredReceivers = null; + try { + if (intent.getComponent() != null) { + // Broadcast is going to one specific receiver class... + ActivityInfo ai = ActivityThread.getPackageManager(). + getReceiverInfo(intent.getComponent(), 0); + if (ai != null) { + receivers = new ArrayList(); + ResolveInfo ri = new ResolveInfo(); + ri.activityInfo = ai; + receivers.add(ri); + } + } else { + // Need to resolve the intent to interested receivers... + if ((intent.getFlags()&Intent.FLAG_RECEIVER_REGISTERED_ONLY) + == 0) { + receivers = + ActivityThread.getPackageManager().queryIntentReceivers( + intent, resolvedType, PackageManager.GET_SHARED_LIBRARY_FILES); + } + registeredReceivers = mReceiverResolver.queryIntent(resolver, + intent, resolvedType, false); + } + } catch (RemoteException ex) { + // pm is in same process, this will never happen. + } + + int NR = registeredReceivers != null ? registeredReceivers.size() : 0; + if (!ordered && NR > 0) { + // If we are not serializing this broadcast, then send the + // registered receivers separately so they don't wait for the + // components to be launched. + BroadcastRecord r = new BroadcastRecord(intent, callerApp, + callerPackage, callingPid, callingUid, requiredPermission, + registeredReceivers, resultTo, resultCode, resultData, map, + ordered); + if (DEBUG_BROADCAST) Log.v( + TAG, "Enqueueing parallel broadcast " + r + + ": prev had " + mParallelBroadcasts.size()); + mParallelBroadcasts.add(r); + scheduleBroadcastsLocked(); + registeredReceivers = null; + NR = 0; + } + + // Merge into one list. + int ir = 0; + if (receivers != null) { + // A special case for PACKAGE_ADDED: do not allow the package + // being added to see this broadcast. This prevents them from + // using this as a back door to get run as soon as they are + // installed. Maybe in the future we want to have a special install + // broadcast or such for apps, but we'd like to deliberately make + // this decision. + String skipPackage = (intent.ACTION_PACKAGE_ADDED.equals( + intent.getAction()) && intent.getData() != null) + ? intent.getData().getSchemeSpecificPart() + : null; + if (skipPackage != null && receivers != null) { + int NT = receivers.size(); + for (int it=0; it<NT; it++) { + ResolveInfo curt = (ResolveInfo)receivers.get(it); + if (curt.activityInfo.packageName.equals(skipPackage)) { + receivers.remove(it); + it--; + NT--; + } + } + } + + int NT = receivers != null ? receivers.size() : 0; + int it = 0; + ResolveInfo curt = null; + BroadcastFilter curr = null; + while (it < NT && ir < NR) { + if (curt == null) { + curt = (ResolveInfo)receivers.get(it); + } + if (curr == null) { + curr = registeredReceivers.get(ir); + } + if (curr.getPriority() >= curt.priority) { + // Insert this broadcast record into the final list. + receivers.add(it, curr); + ir++; + curr = null; + it++; + NT++; + } else { + // Skip to the next ResolveInfo in the final list. + it++; + curt = null; + } + } + } + while (ir < NR) { + if (receivers == null) { + receivers = new ArrayList(); + } + receivers.add(registeredReceivers.get(ir)); + ir++; + } + + if ((receivers != null && receivers.size() > 0) + || resultTo != null) { + BroadcastRecord r = new BroadcastRecord(intent, callerApp, + callerPackage, callingPid, callingUid, requiredPermission, + receivers, resultTo, resultCode, resultData, map, ordered); + if (DEBUG_BROADCAST) Log.v( + TAG, "Enqueueing ordered broadcast " + r + + ": prev had " + mOrderedBroadcasts.size()); + if (DEBUG_BROADCAST) { + int seq = r.intent.getIntExtra("seq", -1); + Log.i(TAG, "Enqueueing broadcast " + r.intent.getAction() + " seq=" + seq); + } + mOrderedBroadcasts.add(r); + scheduleBroadcastsLocked(); + } + + return BROADCAST_SUCCESS; + } + + public final int broadcastIntent(IApplicationThread caller, + Intent intent, String resolvedType, IIntentReceiver resultTo, + int resultCode, String resultData, Bundle map, + String requiredPermission, boolean serialized, boolean sticky) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (!mSystemReady) { + // if the caller really truly claims to know what they're doing, go + // ahead and allow the broadcast without launching any receivers + int flags = intent.getFlags(); + if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT) != 0) { + intent = new Intent(intent); + intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); + } else if ((flags&Intent.FLAG_RECEIVER_REGISTERED_ONLY) == 0){ + Log.e(TAG, "Attempt to launch receivers of broadcast intent " + intent + + " before boot completion"); + throw new IllegalStateException("Cannot broadcast before boot completed"); + } + } + + final ProcessRecord callerApp = getRecordForAppLocked(caller); + final int callingPid = Binder.getCallingPid(); + final int callingUid = Binder.getCallingUid(); + final long origId = Binder.clearCallingIdentity(); + int res = broadcastIntentLocked(callerApp, + callerApp != null ? callerApp.info.packageName : null, + intent, resolvedType, resultTo, + resultCode, resultData, map, requiredPermission, serialized, + sticky, callingPid, callingUid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + int broadcastIntentInPackage(String packageName, int uid, + Intent intent, String resolvedType, IIntentReceiver resultTo, + int resultCode, String resultData, Bundle map, + String requiredPermission, boolean serialized, boolean sticky) { + synchronized(this) { + final long origId = Binder.clearCallingIdentity(); + int res = broadcastIntentLocked(null, packageName, intent, resolvedType, + resultTo, resultCode, resultData, map, requiredPermission, + serialized, sticky, -1, uid); + Binder.restoreCallingIdentity(origId); + return res; + } + } + + public final void unbroadcastIntent(IApplicationThread caller, + Intent intent) { + // Refuse possible leaked file descriptors + if (intent != null && intent.hasFileDescriptors() == true) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + if (checkCallingPermission(android.Manifest.permission.BROADCAST_STICKY) + != PackageManager.PERMISSION_GRANTED) { + String msg = "Permission Denial: unbroadcastIntent() from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid() + + " requires " + android.Manifest.permission.BROADCAST_STICKY; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + ArrayList<Intent> list = mStickyBroadcasts.get(intent.getAction()); + if (list != null) { + int N = list.size(); + int i; + for (i=0; i<N; i++) { + if (intent.filterEquals(list.get(i))) { + list.remove(i); + break; + } + } + } + } + } + + private final boolean finishReceiverLocked(IBinder receiver, int resultCode, + String resultData, Bundle resultExtras, boolean resultAbort, + boolean explicit) { + if (mOrderedBroadcasts.size() == 0) { + if (explicit) { + Log.w(TAG, "finishReceiver called but no pending broadcasts"); + } + return false; + } + BroadcastRecord r = mOrderedBroadcasts.get(0); + if (r.receiver == null) { + if (explicit) { + Log.w(TAG, "finishReceiver called but none active"); + } + return false; + } + if (r.receiver != receiver) { + Log.w(TAG, "finishReceiver called but active receiver is different"); + return false; + } + int state = r.state; + r.state = r.IDLE; + if (state == r.IDLE) { + if (explicit) { + Log.w(TAG, "finishReceiver called but state is IDLE"); + } + } + r.receiver = null; + r.intent.setComponent(null); + if (r.curApp != null) { + r.curApp.curReceiver = null; + } + if (r.curFilter != null) { + r.curFilter.receiverList.curBroadcast = null; + } + r.curFilter = null; + r.curApp = null; + r.curComponent = null; + r.curReceiver = null; + mPendingBroadcast = null; + + r.resultCode = resultCode; + r.resultData = resultData; + r.resultExtras = resultExtras; + r.resultAbort = resultAbort; + + // We will process the next receiver right now if this is finishing + // an app receiver (which is always asynchronous) or after we have + // come back from calling a receiver. + return state == BroadcastRecord.APP_RECEIVE + || state == BroadcastRecord.CALL_DONE_RECEIVE; + } + + public void finishReceiver(IBinder who, int resultCode, String resultData, + Bundle resultExtras, boolean resultAbort) { + if (DEBUG_BROADCAST) Log.v(TAG, "Finish receiver: " + who); + + // Refuse possible leaked file descriptors + if (resultExtras != null && resultExtras.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Bundle"); + } + + boolean doNext; + + final long origId = Binder.clearCallingIdentity(); + + synchronized(this) { + doNext = finishReceiverLocked( + who, resultCode, resultData, resultExtras, resultAbort, true); + } + + if (doNext) { + processNextBroadcast(false); + } + trimApplications(); + + Binder.restoreCallingIdentity(origId); + } + + private final void logBroadcastReceiverDiscard(BroadcastRecord r) { + if (r.nextReceiver > 0) { + Object curReceiver = r.receivers.get(r.nextReceiver-1); + if (curReceiver instanceof BroadcastFilter) { + BroadcastFilter bf = (BroadcastFilter) curReceiver; + EventLog.writeEvent(LOG_AM_BROADCAST_DISCARD_FILTER, + System.identityHashCode(r), + r.intent.getAction(), + r.nextReceiver - 1, + System.identityHashCode(bf)); + } else { + EventLog.writeEvent(LOG_AM_BROADCAST_DISCARD_APP, + System.identityHashCode(r), + r.intent.getAction(), + r.nextReceiver - 1, + ((ResolveInfo)curReceiver).toString()); + } + } else { + Log.w(TAG, "Discarding broadcast before first receiver is invoked: " + + r); + EventLog.writeEvent(LOG_AM_BROADCAST_DISCARD_APP, + System.identityHashCode(r), + r.intent.getAction(), + r.nextReceiver, + "NONE"); + } + } + + private final void broadcastTimeout() { + synchronized (this) { + if (mOrderedBroadcasts.size() == 0) { + return; + } + long now = SystemClock.uptimeMillis(); + BroadcastRecord r = mOrderedBroadcasts.get(0); + if ((r.startTime+BROADCAST_TIMEOUT) > now) { + if (DEBUG_BROADCAST) Log.v(TAG, + "Premature timeout @ " + now + ": resetting BROADCAST_TIMEOUT_MSG for " + + (r.startTime + BROADCAST_TIMEOUT)); + Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG); + mHandler.sendMessageAtTime(msg, r.startTime+BROADCAST_TIMEOUT); + return; + } + + Log.w(TAG, "Timeout of broadcast " + r + " - receiver=" + r.receiver); + r.startTime = now; + r.anrCount++; + + // Current receiver has passed its expiration date. + if (r.nextReceiver <= 0) { + Log.w(TAG, "Timeout on receiver with nextReceiver <= 0"); + return; + } + + ProcessRecord app = null; + + Object curReceiver = r.receivers.get(r.nextReceiver-1); + Log.w(TAG, "Receiver during timeout: " + curReceiver); + logBroadcastReceiverDiscard(r); + if (curReceiver instanceof BroadcastFilter) { + BroadcastFilter bf = (BroadcastFilter)curReceiver; + if (bf.receiverList.pid != 0 + && bf.receiverList.pid != MY_PID) { + synchronized (this.mPidsSelfLocked) { + app = this.mPidsSelfLocked.get( + bf.receiverList.pid); + } + } + } else { + app = r.curApp; + } + + if (app != null) { + appNotRespondingLocked(app, null, "Broadcast of " + r.intent.toString()); + } + + if (mPendingBroadcast == r) { + mPendingBroadcast = null; + } + + // Move on to the next receiver. + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + scheduleBroadcastsLocked(); + } + } + + private final void processCurBroadcastLocked(BroadcastRecord r, + ProcessRecord app) throws RemoteException { + if (app.thread == null) { + throw new RemoteException(); + } + r.receiver = app.thread.asBinder(); + r.curApp = app; + app.curReceiver = r; + updateLRUListLocked(app, true); + + // Tell the application to launch this receiver. + r.intent.setComponent(r.curComponent); + + boolean started = false; + try { + if (DEBUG_BROADCAST) Log.v(TAG, + "Delivering to component " + r.curComponent + + ": " + r); + app.thread.scheduleReceiver(new Intent(r.intent), r.curReceiver, + r.resultCode, r.resultData, r.resultExtras, r.ordered); + started = true; + } finally { + if (!started) { + r.receiver = null; + r.curApp = null; + app.curReceiver = null; + } + } + + } + + static void performReceive(ProcessRecord app, IIntentReceiver receiver, + Intent intent, int resultCode, String data, + Bundle extras, boolean ordered) throws RemoteException { + if (app != null && app.thread != null) { + // If we have an app thread, do the call through that so it is + // correctly ordered with other one-way calls. + app.thread.scheduleRegisteredReceiver(receiver, intent, resultCode, + data, extras, ordered); + } else { + receiver.performReceive(intent, resultCode, data, extras, ordered); + } + } + + private final void deliverToRegisteredReceiver(BroadcastRecord r, + BroadcastFilter filter, boolean ordered) { + boolean skip = false; + if (filter.requiredPermission != null) { + int perm = checkComponentPermission(filter.requiredPermission, + r.callingPid, r.callingUid, -1); + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: broadcasting " + + r.intent.toString() + + " from " + r.callerPackage + " (pid=" + + r.callingPid + ", uid=" + r.callingUid + ")" + + " requires " + filter.requiredPermission + + " due to registered receiver " + filter); + skip = true; + } + } + if (r.requiredPermission != null) { + int perm = checkComponentPermission(r.requiredPermission, + filter.receiverList.pid, filter.receiverList.uid, -1); + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: receiving " + + r.intent.toString() + + " to " + filter.receiverList.app + + " (pid=" + filter.receiverList.pid + + ", uid=" + filter.receiverList.uid + ")" + + " requires " + r.requiredPermission + + " due to sender " + r.callerPackage + + " (uid " + r.callingUid + ")"); + skip = true; + } + } + + if (!skip) { + // If this is not being sent as an ordered broadcast, then we + // don't want to touch the fields that keep track of the current + // state of ordered broadcasts. + if (ordered) { + r.receiver = filter.receiverList.receiver.asBinder(); + r.curFilter = filter; + filter.receiverList.curBroadcast = r; + r.state = BroadcastRecord.CALL_IN_RECEIVE; + } + try { + if (DEBUG_BROADCAST) { + int seq = r.intent.getIntExtra("seq", -1); + Log.i(TAG, "Sending broadcast " + r.intent.getAction() + " seq=" + seq + + " app=" + filter.receiverList.app); + } + performReceive(filter.receiverList.app, filter.receiverList.receiver, + new Intent(r.intent), r.resultCode, + r.resultData, r.resultExtras, r.ordered); + if (ordered) { + r.state = BroadcastRecord.CALL_DONE_RECEIVE; + } + } catch (RemoteException e) { + Log.w(TAG, "Failure sending broadcast " + r.intent, e); + if (ordered) { + r.receiver = null; + r.curFilter = null; + filter.receiverList.curBroadcast = null; + } + } + } + } + + private final void processNextBroadcast(boolean fromMsg) { + synchronized(this) { + BroadcastRecord r; + + if (DEBUG_BROADCAST) Log.v(TAG, "processNextBroadcast: " + + mParallelBroadcasts.size() + " broadcasts, " + + mOrderedBroadcasts.size() + " serialized broadcasts"); + + updateCpuStats(); + + if (fromMsg) { + mBroadcastsScheduled = false; + } + + // First, deliver any non-serialized broadcasts right away. + while (mParallelBroadcasts.size() > 0) { + r = mParallelBroadcasts.remove(0); + final int N = r.receivers.size(); + for (int i=0; i<N; i++) { + Object target = r.receivers.get(i); + if (DEBUG_BROADCAST) Log.v(TAG, + "Delivering non-serialized to registered " + + target + ": " + r); + deliverToRegisteredReceiver(r, (BroadcastFilter)target, false); + } + } + + // Now take care of the next serialized one... + + // If we are waiting for a process to come up to handle the next + // broadcast, then do nothing at this point. Just in case, we + // check that the process we're waiting for still exists. + if (mPendingBroadcast != null) { + Log.i(TAG, "processNextBroadcast: waiting for " + + mPendingBroadcast.curApp); + + boolean isDead; + synchronized (mPidsSelfLocked) { + isDead = (mPidsSelfLocked.get(mPendingBroadcast.curApp.pid) == null); + } + if (!isDead) { + // It's still alive, so keep waiting + return; + } else { + Log.w(TAG, "pending app " + mPendingBroadcast.curApp + + " died before responding to broadcast"); + mPendingBroadcast = null; + } + } + + do { + if (mOrderedBroadcasts.size() == 0) { + // No more broadcasts pending, so all done! + scheduleAppGcsLocked(); + return; + } + r = mOrderedBroadcasts.get(0); + boolean forceReceive = false; + + // Ensure that even if something goes awry with the timeout + // detection, we catch "hung" broadcasts here, discard them, + // and continue to make progress. + int numReceivers = (r.receivers != null) ? r.receivers.size() : 0; + long now = SystemClock.uptimeMillis(); + if (r.dispatchTime > 0) { + if ((numReceivers > 0) && + (now > r.dispatchTime + (2*BROADCAST_TIMEOUT*numReceivers))) { + Log.w(TAG, "Hung broadcast discarded after timeout failure:" + + " now=" + now + + " dispatchTime=" + r.dispatchTime + + " startTime=" + r.startTime + + " intent=" + r.intent + + " numReceivers=" + numReceivers + + " nextReceiver=" + r.nextReceiver + + " state=" + r.state); + broadcastTimeout(); // forcibly finish this broadcast + forceReceive = true; + r.state = BroadcastRecord.IDLE; + } + } + + if (r.state != BroadcastRecord.IDLE) { + if (DEBUG_BROADCAST) Log.d(TAG, + "processNextBroadcast() called when not idle (state=" + + r.state + ")"); + return; + } + + if (r.receivers == null || r.nextReceiver >= numReceivers + || r.resultAbort || forceReceive) { + // No more receivers for this broadcast! Send the final + // result if requested... + if (r.resultTo != null) { + try { + if (DEBUG_BROADCAST) { + int seq = r.intent.getIntExtra("seq", -1); + Log.i(TAG, "Finishing broadcast " + r.intent.getAction() + + " seq=" + seq + " app=" + r.callerApp); + } + performReceive(r.callerApp, r.resultTo, + new Intent(r.intent), r.resultCode, + r.resultData, r.resultExtras, false); + } catch (RemoteException e) { + Log.w(TAG, "Failure sending broadcast result of " + r.intent, e); + } + } + + if (DEBUG_BROADCAST) Log.v(TAG, "Cancelling BROADCAST_TIMEOUT_MSG"); + mHandler.removeMessages(BROADCAST_TIMEOUT_MSG); + + // ... and on to the next... + mOrderedBroadcasts.remove(0); + r = null; + continue; + } + } while (r == null); + + // Get the next receiver... + int recIdx = r.nextReceiver++; + + // Keep track of when this receiver started, and make sure there + // is a timeout message pending to kill it if need be. + r.startTime = SystemClock.uptimeMillis(); + if (recIdx == 0) { + r.dispatchTime = r.startTime; + + if (DEBUG_BROADCAST) Log.v(TAG, + "Submitting BROADCAST_TIMEOUT_MSG for " + + (r.startTime + BROADCAST_TIMEOUT)); + Message msg = mHandler.obtainMessage(BROADCAST_TIMEOUT_MSG); + mHandler.sendMessageAtTime(msg, r.startTime+BROADCAST_TIMEOUT); + } + + Object nextReceiver = r.receivers.get(recIdx); + if (nextReceiver instanceof BroadcastFilter) { + // Simple case: this is a registered receiver who gets + // a direct call. + BroadcastFilter filter = (BroadcastFilter)nextReceiver; + if (DEBUG_BROADCAST) Log.v(TAG, + "Delivering serialized to registered " + + filter + ": " + r); + deliverToRegisteredReceiver(r, filter, r.ordered); + if (r.receiver == null || !r.ordered) { + // The receiver has already finished, so schedule to + // process the next one. + r.state = BroadcastRecord.IDLE; + scheduleBroadcastsLocked(); + } + return; + } + + // Hard case: need to instantiate the receiver, possibly + // starting its application process to host it. + + ResolveInfo info = + (ResolveInfo)nextReceiver; + + boolean skip = false; + int perm = checkComponentPermission(info.activityInfo.permission, + r.callingPid, r.callingUid, + info.activityInfo.exported + ? -1 : info.activityInfo.applicationInfo.uid); + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: broadcasting " + + r.intent.toString() + + " from " + r.callerPackage + " (pid=" + r.callingPid + + ", uid=" + r.callingUid + ")" + + " requires " + info.activityInfo.permission + + " due to receiver " + info.activityInfo.packageName + + "/" + info.activityInfo.name); + skip = true; + } + if (r.callingUid != Process.SYSTEM_UID && + r.requiredPermission != null) { + try { + perm = ActivityThread.getPackageManager(). + checkPermission(r.requiredPermission, + info.activityInfo.applicationInfo.packageName); + } catch (RemoteException e) { + perm = PackageManager.PERMISSION_DENIED; + } + if (perm != PackageManager.PERMISSION_GRANTED) { + Log.w(TAG, "Permission Denial: receiving " + + r.intent + " to " + + info.activityInfo.applicationInfo.packageName + + " requires " + r.requiredPermission + + " due to sender " + r.callerPackage + + " (uid " + r.callingUid + ")"); + skip = true; + } + } + if (r.curApp != null && r.curApp.crashing) { + // If the target process is crashing, just skip it. + skip = true; + } + + if (skip) { + r.receiver = null; + r.curFilter = null; + r.state = BroadcastRecord.IDLE; + scheduleBroadcastsLocked(); + return; + } + + r.state = BroadcastRecord.APP_RECEIVE; + String targetProcess = info.activityInfo.processName; + r.curComponent = new ComponentName( + info.activityInfo.applicationInfo.packageName, + info.activityInfo.name); + r.curReceiver = info.activityInfo; + + // Is this receiver's application already running? + ProcessRecord app = getProcessRecordLocked(targetProcess, + info.activityInfo.applicationInfo.uid); + if (app != null && app.thread != null) { + try { + processCurBroadcastLocked(r, app); + return; + } catch (RemoteException e) { + Log.w(TAG, "Exception when sending broadcast to " + + r.curComponent, e); + } + + // If a dead object exception was thrown -- fall through to + // restart the application. + } + + // Not running -- get it started, and enqueue this history record + // to be executed when the app comes up. + if ((r.curApp=startProcessLocked(targetProcess, + info.activityInfo.applicationInfo, true, + r.intent.getFlags() | Intent.FLAG_FROM_BACKGROUND, + "broadcast", r.curComponent)) == null) { + // Ah, this recipient is unavailable. Finish it if necessary, + // and mark the broadcast record as ready for the next. + Log.w(TAG, "Unable to launch app " + + info.activityInfo.applicationInfo.packageName + "/" + + info.activityInfo.applicationInfo.uid + " for broadcast " + + r.intent + ": process is bad"); + logBroadcastReceiverDiscard(r); + finishReceiverLocked(r.receiver, r.resultCode, r.resultData, + r.resultExtras, r.resultAbort, true); + scheduleBroadcastsLocked(); + r.state = BroadcastRecord.IDLE; + return; + } + + mPendingBroadcast = r; + } + } + + // ========================================================= + // INSTRUMENTATION + // ========================================================= + + public boolean startInstrumentation(ComponentName className, + String profileFile, int flags, Bundle arguments, + IInstrumentationWatcher watcher) { + // Refuse possible leaked file descriptors + if (arguments != null && arguments.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Bundle"); + } + + synchronized(this) { + InstrumentationInfo ii = null; + ApplicationInfo ai = null; + try { + ii = mContext.getPackageManager().getInstrumentationInfo( + className, 0); + ai = mContext.getPackageManager().getApplicationInfo( + ii.targetPackage, PackageManager.GET_SHARED_LIBRARY_FILES); + } catch (PackageManager.NameNotFoundException e) { + } + if (ii == null) { + reportStartInstrumentationFailure(watcher, className, + "Unable to find instrumentation info for: " + className); + return false; + } + if (ai == null) { + reportStartInstrumentationFailure(watcher, className, + "Unable to find instrumentation target package: " + ii.targetPackage); + return false; + } + + int match = mContext.getPackageManager().checkSignatures( + ii.targetPackage, ii.packageName); + if (match < 0 && match != PackageManager.SIGNATURE_FIRST_NOT_SIGNED) { + String msg = "Permission Denial: starting instrumentation " + + className + " from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingPid() + + " not allowed because package " + ii.packageName + + " does not have a signature matching the target " + + ii.targetPackage; + reportStartInstrumentationFailure(watcher, className, msg); + throw new SecurityException(msg); + } + + final long origId = Binder.clearCallingIdentity(); + uninstallPackageLocked(ii.targetPackage, -1, true); + ProcessRecord app = addAppLocked(ai); + app.instrumentationClass = className; + app.instrumentationProfileFile = profileFile; + app.instrumentationArguments = arguments; + app.instrumentationWatcher = watcher; + app.instrumentationResultClass = className; + Binder.restoreCallingIdentity(origId); + } + + return true; + } + + /** + * Report errors that occur while attempting to start Instrumentation. Always writes the + * error to the logs, but if somebody is watching, send the report there too. This enables + * the "am" command to report errors with more information. + * + * @param watcher The IInstrumentationWatcher. Null if there isn't one. + * @param cn The component name of the instrumentation. + * @param report The error report. + */ + private void reportStartInstrumentationFailure(IInstrumentationWatcher watcher, + ComponentName cn, String report) { + Log.w(TAG, report); + try { + if (watcher != null) { + Bundle results = new Bundle(); + results.putString(Instrumentation.REPORT_KEY_IDENTIFIER, "ActivityManagerService"); + results.putString("Error", report); + watcher.instrumentationStatus(cn, -1, results); + } + } catch (RemoteException e) { + Log.w(TAG, e); + } + } + + void finishInstrumentationLocked(ProcessRecord app, int resultCode, Bundle results) { + if (app.instrumentationWatcher != null) { + try { + // NOTE: IInstrumentationWatcher *must* be oneway here + app.instrumentationWatcher.instrumentationFinished( + app.instrumentationClass, + resultCode, + results); + } catch (RemoteException e) { + } + } + app.instrumentationWatcher = null; + app.instrumentationClass = null; + app.instrumentationProfileFile = null; + app.instrumentationArguments = null; + + uninstallPackageLocked(app.processName, -1, false); + } + + public void finishInstrumentation(IApplicationThread target, + int resultCode, Bundle results) { + // Refuse possible leaked file descriptors + if (results != null && results.hasFileDescriptors()) { + throw new IllegalArgumentException("File descriptors passed in Intent"); + } + + synchronized(this) { + ProcessRecord app = getRecordForAppLocked(target); + if (app == null) { + Log.w(TAG, "finishInstrumentation: no app for " + target); + return; + } + final long origId = Binder.clearCallingIdentity(); + finishInstrumentationLocked(app, resultCode, results); + Binder.restoreCallingIdentity(origId); + } + } + + // ========================================================= + // CONFIGURATION + // ========================================================= + + public ConfigurationInfo getDeviceConfigurationInfo() { + ConfigurationInfo config = new ConfigurationInfo(); + synchronized (this) { + config.reqTouchScreen = mConfiguration.touchscreen; + config.reqKeyboardType = mConfiguration.keyboard; + config.reqNavigation = mConfiguration.navigation; + if (mConfiguration.navigation != Configuration.NAVIGATION_NONAV) { + config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_FIVE_WAY_NAV; + } + if (mConfiguration.keyboard != Configuration.KEYBOARD_UNDEFINED) { + config.reqInputFeatures |= ConfigurationInfo.INPUT_FEATURE_HARD_KEYBOARD; + } + } + return config; + } + + public Configuration getConfiguration() { + Configuration ci; + synchronized(this) { + ci = new Configuration(mConfiguration); + } + return ci; + } + + public void updateConfiguration(Configuration values) { + enforceCallingPermission(android.Manifest.permission.CHANGE_CONFIGURATION, + "updateConfiguration()"); + + synchronized(this) { + if (values == null && mWindowManager != null) { + // sentinel: fetch the current configuration from the window manager + values = mWindowManager.computeNewConfiguration(); + } + + final long origId = Binder.clearCallingIdentity(); + updateConfigurationLocked(values, null); + Binder.restoreCallingIdentity(origId); + } + } + + /** + * Do either or both things: (1) change the current configuration, and (2) + * make sure the given activity is running with the (now) current + * configuration. Returns true if the activity has been left running, or + * false if <var>starting</var> is being destroyed to match the new + * configuration. + */ + public boolean updateConfigurationLocked(Configuration values, + HistoryRecord starting) { + int changes = 0; + + boolean kept = true; + + if (values != null) { + Configuration newConfig = new Configuration(mConfiguration); + changes = newConfig.updateFrom(values); + if (changes != 0) { + if (DEBUG_SWITCH) { + Log.i(TAG, "Updating configuration to: " + values); + } + + EventLog.writeEvent(LOG_CONFIGURATION_CHANGED, changes); + + if (values.locale != null) { + saveLocaleLocked(values.locale, + !values.locale.equals(mConfiguration.locale), + values.userSetLocale); + } + + mConfiguration = newConfig; + + Message msg = mHandler.obtainMessage(UPDATE_CONFIGURATION_MSG); + msg.obj = new Configuration(mConfiguration); + mHandler.sendMessage(msg); + + final int N = mLRUProcesses.size(); + for (int i=0; i<N; i++) { + ProcessRecord app = mLRUProcesses.get(i); + try { + if (app.thread != null) { + app.thread.scheduleConfigurationChanged(mConfiguration); + } + } catch (Exception e) { + } + } + Intent intent = new Intent(Intent.ACTION_CONFIGURATION_CHANGED); + broadcastIntentLocked(null, null, intent, null, null, 0, null, null, + null, false, false, MY_PID, Process.SYSTEM_UID); + } + } + + if (changes != 0 && starting == null) { + // If the configuration changed, and the caller is not already + // in the process of starting an activity, then find the top + // activity to check if its configuration needs to change. + starting = topRunningActivityLocked(null); + } + + if (starting != null) { + kept = ensureActivityConfigurationLocked(starting, changes); + if (kept) { + // If this didn't result in the starting activity being + // destroyed, then we need to make sure at this point that all + // other activities are made visible. + if (DEBUG_SWITCH) Log.i(TAG, "Config didn't destroy " + starting + + ", ensuring others are correct."); + ensureActivitiesVisibleLocked(starting, changes); + } + } + + return kept; + } + + private final boolean relaunchActivityLocked(HistoryRecord r, + int changes, boolean andResume) { + List<ResultInfo> results = null; + List<Intent> newIntents = null; + if (andResume) { + results = r.results; + newIntents = r.newIntents; + } + if (DEBUG_SWITCH) Log.v(TAG, "Relaunching: " + r + + " with results=" + results + " newIntents=" + newIntents + + " andResume=" + andResume); + EventLog.writeEvent(andResume ? LOG_AM_RELAUNCH_RESUME_ACTIVITY + : LOG_AM_RELAUNCH_ACTIVITY, System.identityHashCode(r), + r.task.taskId, r.shortComponentName); + + r.startFreezingScreenLocked(r.app, 0); + + try { + if (DEBUG_SWITCH) Log.i(TAG, "Switch is restarting resumed " + r); + r.app.thread.scheduleRelaunchActivity(r, results, newIntents, + changes, !andResume); + // Note: don't need to call pauseIfSleepingLocked() here, because + // the caller will only pass in 'andResume' if this activity is + // currently resumed, which implies we aren't sleeping. + } catch (RemoteException e) { + return false; + } + + if (andResume) { + r.results = null; + r.newIntents = null; + } + + return true; + } + + /** + * Make sure the given activity matches the current configuration. Returns + * false if the activity had to be destroyed. Returns true if the + * configuration is the same, or the activity will remain running as-is + * for whatever reason. Ensures the HistoryRecord is updated with the + * correct configuration and all other bookkeeping is handled. + */ + private final boolean ensureActivityConfigurationLocked(HistoryRecord r, + int globalChanges) { + if (DEBUG_SWITCH) Log.i(TAG, "Ensuring correct configuration: " + r); + + // Short circuit: if the two configurations are the exact same + // object (the common case), then there is nothing to do. + Configuration newConfig = mConfiguration; + if (r.configuration == newConfig) { + if (DEBUG_SWITCH) Log.i(TAG, "Configuration unchanged in " + r); + return true; + } + + // We don't worry about activities that are finishing. + if (r.finishing) { + if (DEBUG_SWITCH) Log.i(TAG, + "Configuration doesn't matter in finishing " + r); + r.stopFreezingScreenLocked(false); + return true; + } + + // Okay we now are going to make this activity have the new config. + // But then we need to figure out how it needs to deal with that. + Configuration oldConfig = r.configuration; + r.configuration = newConfig; + + // If the activity isn't currently running, just leave the new + // configuration and it will pick that up next time it starts. + if (r.app == null || r.app.thread == null) { + if (DEBUG_SWITCH) Log.i(TAG, + "Configuration doesn't matter not running " + r); + r.stopFreezingScreenLocked(false); + return true; + } + + // If the activity isn't persistent, there is a chance we will + // need to restart it. + if (!r.persistent) { + + // Figure out what has changed between the two configurations. + int changes = oldConfig.diff(newConfig); + if (DEBUG_SWITCH) { + Log.i(TAG, "Checking to restart " + r.info.name + ": changed=0x" + + Integer.toHexString(changes) + ", handles=0x" + + Integer.toHexString(r.info.configChanges)); + } + if ((changes&(~r.info.configChanges)) != 0) { + // Aha, the activity isn't handling the change, so DIE DIE DIE. + r.configChangeFlags |= changes; + r.startFreezingScreenLocked(r.app, globalChanges); + if (r.app == null || r.app.thread == null) { + if (DEBUG_SWITCH) Log.i(TAG, "Switch is destroying non-running " + r); + destroyActivityLocked(r, true); + } else if (r.state == ActivityState.PAUSING) { + // A little annoying: we are waiting for this activity to + // finish pausing. Let's not do anything now, but just + // flag that it needs to be restarted when done pausing. + r.configDestroy = true; + return true; + } else if (r.state == ActivityState.RESUMED) { + // Try to optimize this case: the configuration is changing + // and we need to restart the top, resumed activity. + // Instead of doing the normal handshaking, just say + // "restart!". + if (DEBUG_SWITCH) Log.i(TAG, "Switch is restarting resumed " + r); + relaunchActivityLocked(r, r.configChangeFlags, true); + r.configChangeFlags = 0; + } else { + if (DEBUG_SWITCH) Log.i(TAG, "Switch is restarting non-resumed " + r); + relaunchActivityLocked(r, r.configChangeFlags, false); + r.configChangeFlags = 0; + } + + // All done... tell the caller we weren't able to keep this + // activity around. + return false; + } + } + + // Default case: the activity can handle this new configuration, so + // hand it over. Note that we don't need to give it the new + // configuration, since we always send configuration changes to all + // process when they happen so it can just use whatever configuration + // it last got. + if (r.app != null && r.app.thread != null) { + try { + r.app.thread.scheduleActivityConfigurationChanged(r); + } catch (RemoteException e) { + // If process died, whatever. + } + } + r.stopFreezingScreenLocked(false); + + return true; + } + + /** + * Save the locale. You must be inside a synchronized (this) block. + */ + private void saveLocaleLocked(Locale l, boolean isDiff, boolean isPersist) { + if(isDiff) { + SystemProperties.set("user.language", l.getLanguage()); + SystemProperties.set("user.region", l.getCountry()); + } + + if(isPersist) { + SystemProperties.set("persist.sys.language", l.getLanguage()); + SystemProperties.set("persist.sys.country", l.getCountry()); + SystemProperties.set("persist.sys.localevar", l.getVariant()); + } + } + + // ========================================================= + // LIFETIME MANAGEMENT + // ========================================================= + + private final int computeOomAdjLocked( + ProcessRecord app, int hiddenAdj, ProcessRecord TOP_APP) { + if (mAdjSeq == app.adjSeq) { + // This adjustment has already been computed. + return app.curAdj; + } + + if (app.thread == null) { + app.adjSeq = mAdjSeq; + return (app.curAdj=EMPTY_APP_ADJ); + } + + app.isForeground = false; + + // Right now there are three interesting states: it is + // either the foreground app, background with activities, + // or background without activities. + int adj; + int N; + if (app == TOP_APP || app.instrumentationClass != null + || app.persistentActivities > 0) { + // The last app on the list is the foreground app. + adj = FOREGROUND_APP_ADJ; + app.isForeground = true; + } else if (app.curReceiver != null || + (mPendingBroadcast != null && mPendingBroadcast.curApp == app)) { + // An app that is currently receiving a broadcast also + // counts as being in the foreground. + adj = FOREGROUND_APP_ADJ; + } else if (app.executingServices.size() > 0) { + // An app that is currently executing a service callback also + // counts as being in the foreground. + adj = FOREGROUND_APP_ADJ; + } else if (app.foregroundServices || app.forcingToForeground != null) { + // The user is aware of this app, so make it visible. + adj = VISIBLE_APP_ADJ; + } else if ((N=app.activities.size()) != 0) { + // This app is in the background with paused activities. + adj = hiddenAdj; + for (int j=0; j<N; j++) { + if (((HistoryRecord)app.activities.get(j)).visible) { + // This app has a visible activity! + adj = VISIBLE_APP_ADJ; + break; + } + } + } else { + // A very not-needed process. + adj = EMPTY_APP_ADJ; + } + + // By default, we use the computed adjusted. It may be changed if + // there are applications dependent on our services or providers, but + // this gives us a baseline and makes sure we don't get into an + // infinite recursion. + app.adjSeq = mAdjSeq; + app.curRawAdj = adj; + app.curAdj = adj <= app.maxAdj ? adj : app.maxAdj; + + if (app.services.size() != 0 && adj > FOREGROUND_APP_ADJ) { + // If this process has active services running in it, we would + // like to avoid killing it unless it would prevent the current + // application from running. + if (adj > hiddenAdj) { + adj = hiddenAdj; + } + final long now = SystemClock.uptimeMillis(); + // This process is more important if the top activity is + // bound to the service. + Iterator jt = app.services.iterator(); + while (jt.hasNext() && adj > FOREGROUND_APP_ADJ) { + ServiceRecord s = (ServiceRecord)jt.next(); + if (s.startRequested) { + if (now < (s.lastActivity+MAX_SERVICE_INACTIVITY)) { + // This service has seen some activity within + // recent memory, so we will keep its process ahead + // of the background processes. + if (adj > SECONDARY_SERVER_ADJ) { + adj = SECONDARY_SERVER_ADJ; + } + } else { + // This service has been inactive for too long, just + // put it with the rest of the background processes. + if (adj > hiddenAdj) { + adj = hiddenAdj; + } + } + } + if (s.connections.size() > 0 && adj > FOREGROUND_APP_ADJ) { + Iterator<ConnectionRecord> kt + = s.connections.values().iterator(); + while (kt.hasNext() && adj > FOREGROUND_APP_ADJ) { + // XXX should compute this based on the max of + // all connected clients. + ConnectionRecord cr = kt.next(); + if ((cr.flags&Context.BIND_AUTO_CREATE) != 0) { + ProcessRecord client = cr.binding.client; + int myHiddenAdj = hiddenAdj; + if (myHiddenAdj > client.hiddenAdj) { + if (client.hiddenAdj > VISIBLE_APP_ADJ) { + myHiddenAdj = client.hiddenAdj; + } else { + myHiddenAdj = VISIBLE_APP_ADJ; + } + } + int clientAdj = computeOomAdjLocked( + client, myHiddenAdj, TOP_APP); + if (adj > clientAdj) { + adj = clientAdj > VISIBLE_APP_ADJ + ? clientAdj : VISIBLE_APP_ADJ; + } + } + HistoryRecord a = cr.activity; + //if (a != null) { + // Log.i(TAG, "Connection to " + a ": state=" + a.state); + //} + if (a != null && adj > FOREGROUND_APP_ADJ && + (a.state == ActivityState.RESUMED + || a.state == ActivityState.PAUSING)) { + adj = FOREGROUND_APP_ADJ; + } + } + } + } + } + + if (app.pubProviders.size() != 0 && adj > FOREGROUND_APP_ADJ) { + // If this process has published any content providers, then + // its adjustment makes it at least as important as any of the + // processes using those providers, and no less important than + // CONTENT_PROVIDER_ADJ, which is just shy of EMPTY. + if (adj > CONTENT_PROVIDER_ADJ) { + adj = CONTENT_PROVIDER_ADJ; + } + Iterator jt = app.pubProviders.values().iterator(); + while (jt.hasNext() && adj > FOREGROUND_APP_ADJ) { + ContentProviderRecord cpr = (ContentProviderRecord)jt.next(); + if (cpr.clients.size() != 0) { + Iterator<ProcessRecord> kt = cpr.clients.iterator(); + while (kt.hasNext() && adj > FOREGROUND_APP_ADJ) { + ProcessRecord client = kt.next(); + int myHiddenAdj = hiddenAdj; + if (myHiddenAdj > client.hiddenAdj) { + if (client.hiddenAdj > FOREGROUND_APP_ADJ) { + myHiddenAdj = client.hiddenAdj; + } else { + myHiddenAdj = FOREGROUND_APP_ADJ; + } + } + int clientAdj = computeOomAdjLocked( + client, myHiddenAdj, TOP_APP); + if (adj > clientAdj) { + adj = clientAdj > FOREGROUND_APP_ADJ + ? clientAdj : FOREGROUND_APP_ADJ; + } + } + } + // If the provider has external (non-framework) process + // dependencies, ensure that its adjustment is at least + // FOREGROUND_APP_ADJ. + if (cpr.externals != 0) { + if (adj > FOREGROUND_APP_ADJ) { + adj = FOREGROUND_APP_ADJ; + } + } + } + } + + app.curRawAdj = adj; + + //Log.i(TAG, "OOM ADJ " + app + ": pid=" + app.pid + + // " adj=" + adj + " curAdj=" + app.curAdj + " maxAdj=" + app.maxAdj); + if (adj > app.maxAdj) { + adj = app.maxAdj; + } + + app.curAdj = adj; + + return adj; + } + + /** + * Ask a given process to GC right now. + */ + final void performAppGcLocked(ProcessRecord app) { + try { + app.lastRequestedGc = SystemClock.uptimeMillis(); + if (app.thread != null) { + app.thread.processInBackground(); + } + } catch (Exception e) { + // whatever. + } + } + + /** + * Returns true if things are idle enough to perform GCs. + */ + private final boolean canGcNow() { + return mParallelBroadcasts.size() == 0 + && mOrderedBroadcasts.size() == 0 + && (mSleeping || (mResumedActivity != null && + mResumedActivity.idle)); + } + + /** + * Perform GCs on all processes that are waiting for it, but only + * if things are idle. + */ + final void performAppGcsLocked() { + final int N = mProcessesToGc.size(); + if (N <= 0) { + return; + } + if (canGcNow()) { + while (mProcessesToGc.size() > 0) { + ProcessRecord proc = mProcessesToGc.remove(0); + if (proc.curRawAdj > VISIBLE_APP_ADJ) { + // To avoid spamming the system, we will GC processes one + // at a time, waiting a few seconds between each. + performAppGcLocked(proc); + scheduleAppGcsLocked(); + return; + } + } + } + } + + /** + * If all looks good, perform GCs on all processes waiting for them. + */ + final void performAppGcsIfAppropriateLocked() { + if (canGcNow()) { + performAppGcsLocked(); + return; + } + // Still not idle, wait some more. + scheduleAppGcsLocked(); + } + + /** + * Schedule the execution of all pending app GCs. + */ + final void scheduleAppGcsLocked() { + mHandler.removeMessages(GC_BACKGROUND_PROCESSES_MSG); + Message msg = mHandler.obtainMessage(GC_BACKGROUND_PROCESSES_MSG); + mHandler.sendMessageDelayed(msg, GC_TIMEOUT); + } + + /** + * Set up to ask a process to GC itself. This will either do it + * immediately, or put it on the list of processes to gc the next + * time things are idle. + */ + final void scheduleAppGcLocked(ProcessRecord app) { + long now = SystemClock.uptimeMillis(); + if ((app.lastRequestedGc+5000) > now) { + return; + } + if (!mProcessesToGc.contains(app)) { + mProcessesToGc.add(app); + scheduleAppGcsLocked(); + } + } + + private final boolean updateOomAdjLocked( + ProcessRecord app, int hiddenAdj, ProcessRecord TOP_APP) { + app.hiddenAdj = hiddenAdj; + + if (app.thread == null) { + return true; + } + + int adj = computeOomAdjLocked(app, hiddenAdj, TOP_APP); + + //Log.i(TAG, "Computed adj " + adj + " for app " + app.processName); + //Thread priority adjustment is disabled out to see + //how the kernel scheduler performs. + if (false) { + if (app.pid != 0 && app.isForeground != app.setIsForeground) { + app.setIsForeground = app.isForeground; + if (app.pid != MY_PID) { + if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Log.v(TAG, "Setting priority of " + app + + " to " + (app.isForeground + ? Process.THREAD_PRIORITY_FOREGROUND + : Process.THREAD_PRIORITY_DEFAULT)); + try { + Process.setThreadPriority(app.pid, app.isForeground + ? Process.THREAD_PRIORITY_FOREGROUND + : Process.THREAD_PRIORITY_DEFAULT); + } catch (RuntimeException e) { + Log.w(TAG, "Exception trying to set priority of application thread " + + app.pid, e); + } + } + } + } + if (app.pid != 0 && app.pid != MY_PID) { + if (app.curRawAdj != app.setRawAdj) { + if (app.curRawAdj > FOREGROUND_APP_ADJ + && app.setRawAdj <= FOREGROUND_APP_ADJ) { + // If this app is transitioning from foreground to + // non-foreground, have it do a gc. + scheduleAppGcLocked(app); + } else if (app.curRawAdj >= HIDDEN_APP_MIN_ADJ + && app.setRawAdj < HIDDEN_APP_MIN_ADJ) { + // Likewise do a gc when an app is moving in to the + // background (such as a service stopping). + scheduleAppGcLocked(app); + } + app.setRawAdj = app.curRawAdj; + } + if (adj != app.setAdj) { + if (Process.setOomAdj(app.pid, adj)) { + if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Log.v( + TAG, "Set app " + app.processName + + " oom adj to " + adj); + app.setAdj = adj; + } else { + return false; + } + } + } + + return true; + } + + private final HistoryRecord resumedAppLocked() { + HistoryRecord resumedActivity = mResumedActivity; + if (resumedActivity == null || resumedActivity.app == null) { + resumedActivity = mPausingActivity; + if (resumedActivity == null || resumedActivity.app == null) { + resumedActivity = topRunningActivityLocked(null); + } + } + return resumedActivity; + } + + private final boolean updateOomAdjLocked(ProcessRecord app) { + final HistoryRecord TOP_ACT = resumedAppLocked(); + final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null; + int curAdj = app.curAdj; + final boolean wasHidden = app.curAdj >= HIDDEN_APP_MIN_ADJ + && app.curAdj <= HIDDEN_APP_MAX_ADJ; + + mAdjSeq++; + + final boolean res = updateOomAdjLocked(app, app.hiddenAdj, TOP_APP); + if (res) { + final boolean nowHidden = app.curAdj >= HIDDEN_APP_MIN_ADJ + && app.curAdj <= HIDDEN_APP_MAX_ADJ; + if (nowHidden != wasHidden) { + // Changed to/from hidden state, so apps after it in the LRU + // list may also be changed. + updateOomAdjLocked(); + } + } + return res; + } + + private final boolean updateOomAdjLocked() { + boolean didOomAdj = true; + final HistoryRecord TOP_ACT = resumedAppLocked(); + final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null; + + if (false) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.i(TAG, "updateOomAdj: top=" + TOP_ACT, e); + } + + mAdjSeq++; + + // First try updating the OOM adjustment for each of the + // application processes based on their current state. + int i = mLRUProcesses.size(); + int curHiddenAdj = HIDDEN_APP_MIN_ADJ; + while (i > 0) { + i--; + ProcessRecord app = mLRUProcesses.get(i); + if (updateOomAdjLocked(app, curHiddenAdj, TOP_APP)) { + if (curHiddenAdj < HIDDEN_APP_MAX_ADJ + && app.curAdj == curHiddenAdj) { + curHiddenAdj++; + } + } else { + didOomAdj = false; + } + } + + // todo: for now pretend like OOM ADJ didn't work, because things + // aren't behaving as expected on Linux -- it's not killing processes. + return ENFORCE_PROCESS_LIMIT || mProcessLimit > 0 ? false : didOomAdj; + } + + private final void trimApplications() { + synchronized (this) { + int i; + + // First remove any unused application processes whose package + // has been removed. + for (i=mRemovedProcesses.size()-1; i>=0; i--) { + final ProcessRecord app = mRemovedProcesses.get(i); + if (app.activities.size() == 0 + && app.curReceiver == null && app.services.size() == 0) { + Log.i( + TAG, "Exiting empty application process " + + app.processName + " (" + + (app.thread != null ? app.thread.asBinder() : null) + + ")\n"); + if (app.pid > 0 && app.pid != MY_PID) { + Process.killProcess(app.pid); + } else { + try { + app.thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + cleanUpApplicationRecordLocked(app, false, -1); + mRemovedProcesses.remove(i); + + if (app.persistent) { + if (app.persistent) { + addAppLocked(app.info); + } + } + } + } + + // Now try updating the OOM adjustment for each of the + // application processes based on their current state. + // If the setOomAdj() API is not supported, then go with our + // back-up plan... + if (!updateOomAdjLocked()) { + + // Count how many processes are running services. + int numServiceProcs = 0; + for (i=mLRUProcesses.size()-1; i>=0; i--) { + final ProcessRecord app = mLRUProcesses.get(i); + + if (app.persistent || app.services.size() != 0 + || app.curReceiver != null + || app.persistentActivities > 0) { + // Don't count processes holding services against our + // maximum process count. + if (localLOGV) Log.v( + TAG, "Not trimming app " + app + " with services: " + + app.services); + numServiceProcs++; + } + } + + int curMaxProcs = mProcessLimit; + if (curMaxProcs <= 0) curMaxProcs = MAX_PROCESSES; + if (mAlwaysFinishActivities) { + curMaxProcs = 1; + } + curMaxProcs += numServiceProcs; + + // Quit as many processes as we can to get down to the desired + // process count. First remove any processes that no longer + // have activites running in them. + for ( i=0; + i<mLRUProcesses.size() + && mLRUProcesses.size() > curMaxProcs; + i++) { + final ProcessRecord app = mLRUProcesses.get(i); + // Quit an application only if it is not currently + // running any activities. + if (!app.persistent && app.activities.size() == 0 + && app.curReceiver == null && app.services.size() == 0) { + Log.i( + TAG, "Exiting empty application process " + + app.processName + " (" + + (app.thread != null ? app.thread.asBinder() : null) + + ")\n"); + if (app.pid > 0 && app.pid != MY_PID) { + Process.killProcess(app.pid); + } else { + try { + app.thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + // todo: For now we assume the application is not buggy + // or evil, and will quit as a result of our request. + // Eventually we need to drive this off of the death + // notification, and kill the process if it takes too long. + cleanUpApplicationRecordLocked(app, false, i); + i--; + } + } + + // If we still have too many processes, now from the least + // recently used process we start finishing activities. + if (Config.LOGV) Log.v( + TAG, "*** NOW HAVE " + mLRUProcesses.size() + + " of " + curMaxProcs + " processes"); + for ( i=0; + i<mLRUProcesses.size() + && mLRUProcesses.size() > curMaxProcs; + i++) { + final ProcessRecord app = mLRUProcesses.get(i); + // Quit the application only if we have a state saved for + // all of its activities. + boolean canQuit = !app.persistent && app.curReceiver == null + && app.services.size() == 0 + && app.persistentActivities == 0; + int NUMA = app.activities.size(); + int j; + if (Config.LOGV) Log.v( + TAG, "Looking to quit " + app.processName); + for (j=0; j<NUMA && canQuit; j++) { + HistoryRecord r = (HistoryRecord)app.activities.get(j); + if (Config.LOGV) Log.v( + TAG, " " + r.intent.getComponent().flattenToShortString() + + ": frozen=" + r.haveState + ", visible=" + r.visible); + canQuit = (r.haveState || !r.stateNotNeeded) + && !r.visible && r.stopped; + } + if (canQuit) { + // Finish all of the activities, and then the app itself. + for (j=0; j<NUMA; j++) { + HistoryRecord r = (HistoryRecord)app.activities.get(j); + if (!r.finishing) { + destroyActivityLocked(r, false); + } + r.resultTo = null; + } + Log.i(TAG, "Exiting application process " + + app.processName + " (" + + (app.thread != null ? app.thread.asBinder() : null) + + ")\n"); + if (app.pid > 0 && app.pid != MY_PID) { + Process.killProcess(app.pid); + } else { + try { + app.thread.scheduleExit(); + } catch (Exception e) { + // Ignore exceptions. + } + } + // todo: For now we assume the application is not buggy + // or evil, and will quit as a result of our request. + // Eventually we need to drive this off of the death + // notification, and kill the process if it takes too long. + cleanUpApplicationRecordLocked(app, false, i); + i--; + //dump(); + } + } + + } + + int curMaxActivities = MAX_ACTIVITIES; + if (mAlwaysFinishActivities) { + curMaxActivities = 1; + } + + // Finally, if there are too many activities now running, try to + // finish as many as we can to get back down to the limit. + for ( i=0; + i<mLRUActivities.size() + && mLRUActivities.size() > curMaxActivities; + i++) { + final HistoryRecord r + = (HistoryRecord)mLRUActivities.get(i); + + // We can finish this one if we have its icicle saved and + // it is not persistent. + if ((r.haveState || !r.stateNotNeeded) && !r.visible + && r.stopped && !r.persistent && !r.finishing) { + final int origSize = mLRUActivities.size(); + destroyActivityLocked(r, true); + + // This will remove it from the LRU list, so keep + // our index at the same value. Note that this check to + // see if the size changes is just paranoia -- if + // something unexpected happens, we don't want to end up + // in an infinite loop. + if (origSize > mLRUActivities.size()) { + i--; + } + } + } + } + } + + /** This method sends the specified signal to each of the persistent apps */ + public void signalPersistentProcesses(int sig) throws RemoteException { + if (sig != Process.SIGNAL_USR1) { + throw new SecurityException("Only SIGNAL_USR1 is allowed"); + } + + synchronized (this) { + if (checkCallingPermission(android.Manifest.permission.SIGNAL_PERSISTENT_PROCESSES) + != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("Requires permission " + + android.Manifest.permission.SIGNAL_PERSISTENT_PROCESSES); + } + + for (int i = mLRUProcesses.size() - 1 ; i >= 0 ; i--) { + ProcessRecord r = mLRUProcesses.get(i); + if (r.thread != null && r.persistent) { + Process.sendSignal(r.pid, sig); + } + } + } + } + + /** In this method we try to acquire our lock to make sure that we have not deadlocked */ + public void monitor() { + synchronized (this) { } + } +} diff --git a/services/java/com/android/server/am/ActivityResult.java b/services/java/com/android/server/am/ActivityResult.java new file mode 100644 index 0000000..3cc2725 --- /dev/null +++ b/services/java/com/android/server/am/ActivityResult.java @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2006 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.am; + +import android.app.ResultInfo; +import android.content.Intent; +import android.os.Bundle; + +/** + * Pending result information to send back to an activity. + */ +class ActivityResult extends ResultInfo { + final HistoryRecord mFrom; + + public ActivityResult(HistoryRecord from, String resultWho, + int requestCode, int resultCode, Intent data) { + super(resultWho, requestCode, resultCode, data); + mFrom = from; + } +} diff --git a/services/java/com/android/server/am/AppBindRecord.java b/services/java/com/android/server/am/AppBindRecord.java new file mode 100644 index 0000000..ce6f6dc --- /dev/null +++ b/services/java/com/android/server/am/AppBindRecord.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2006 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.am; + +import java.io.PrintWriter; +import java.util.HashSet; +import java.util.Iterator; + +/** + * An association between a service and one of its client applications. + */ +class AppBindRecord { + final ServiceRecord service; // The running service. + final IntentBindRecord intent; // The intent we are bound to. + final ProcessRecord client; // Who has started/bound the service. + + final HashSet<ConnectionRecord> connections = new HashSet<ConnectionRecord>(); + // All ConnectionRecord for this client. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "service=" + service); + pw.println(prefix + "client=" + client); + if (connections.size() > 0) { + pw.println(prefix + "Per-process Connections:"); + Iterator<ConnectionRecord> it = connections.iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + pw.println(prefix + " " + c); + } + } + } + + AppBindRecord(ServiceRecord _service, IntentBindRecord _intent, + ProcessRecord _client) { + service = _service; + intent = _intent; + client = _client; + } + + public String toString() { + return "AppBindRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + service.shortName + ":" + client.processName + "}"; + } +} diff --git a/services/java/com/android/server/am/AppErrorDialog.java b/services/java/com/android/server/am/AppErrorDialog.java new file mode 100644 index 0000000..3fcfad0 --- /dev/null +++ b/services/java/com/android/server/am/AppErrorDialog.java @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2006 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.am; + +import static android.view.WindowManager.LayoutParams.FLAG_SYSTEM_ERROR; + +import android.content.Context; +import android.content.res.Resources; +import android.os.Handler; +import android.os.Message; + +class AppErrorDialog extends BaseErrorDialog { + private final AppErrorResult mResult; + private final ProcessRecord mProc; + + // Event 'what' codes + static final int FORCE_QUIT = 0; + static final int DEBUG = 1; + + // 5-minute timeout, then we automatically dismiss the crash dialog + static final long DISMISS_TIMEOUT = 1000 * 60 * 5; + + public AppErrorDialog(Context context, AppErrorResult result, + ProcessRecord app, int flags, + String shortMsg, String longMsg) { + super(context); + + Resources res = context.getResources(); + + mProc = app; + mResult = result; + CharSequence name; + if ((app.pkgList.size() == 1) && + (name=context.getPackageManager().getApplicationLabel(app.info)) != null) { + setMessage(res.getString( + com.android.internal.R.string.aerr_application, + name.toString(), app.info.processName)); + } else { + name = app.processName; + setMessage(res.getString( + com.android.internal.R.string.aerr_process, + name.toString())); + } + + setCancelable(false); + + setButton(res.getText(com.android.internal.R.string.force_close), + mHandler.obtainMessage(FORCE_QUIT)); + if ((flags&1) != 0) { + setButton(res.getText(com.android.internal.R.string.debug), + mHandler.obtainMessage(DEBUG)); + } + setTitle(res.getText(com.android.internal.R.string.aerr_title)); + getWindow().addFlags(FLAG_SYSTEM_ERROR); + getWindow().setTitle("Application Error: " + app.info.processName); + + // After the timeout, pretend the user clicked the quit button + mHandler.sendMessageDelayed( + mHandler.obtainMessage(FORCE_QUIT), + DISMISS_TIMEOUT); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + synchronized (mProc) { + if (mProc != null && mProc.crashDialog == AppErrorDialog.this) { + mProc.crashDialog = null; + } + } + mResult.set(msg.what); + + // If this is a timeout we won't be automatically closed, so go + // ahead and explicitly dismiss ourselves just in case. + dismiss(); + } + }; +} diff --git a/services/java/com/android/server/am/AppErrorResult.java b/services/java/com/android/server/am/AppErrorResult.java new file mode 100644 index 0000000..ebfcfe2 --- /dev/null +++ b/services/java/com/android/server/am/AppErrorResult.java @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2006 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.am; + + +class AppErrorResult { + public void set(int res) { + synchronized (this) { + mHasResult = true; + mResult = res; + notifyAll(); + } + } + + public int get() { + synchronized (this) { + while (!mHasResult) { + try { + wait(); + } catch (InterruptedException e) { + } + } + } + return mResult; + } + + boolean mHasResult = false; + int mResult; +} diff --git a/services/java/com/android/server/am/AppNotRespondingDialog.java b/services/java/com/android/server/am/AppNotRespondingDialog.java new file mode 100644 index 0000000..7390ed0 --- /dev/null +++ b/services/java/com/android/server/am/AppNotRespondingDialog.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2006 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.am; + +import static android.view.WindowManager.LayoutParams.FLAG_SYSTEM_ERROR; + +import android.content.Context; +import android.content.res.Resources; +import android.os.Handler; +import android.os.Message; +import android.os.Process; +import android.util.Log; + +class AppNotRespondingDialog extends BaseErrorDialog { + private final ActivityManagerService mService; + private final ProcessRecord mProc; + + public AppNotRespondingDialog(ActivityManagerService service, Context context, + ProcessRecord app, HistoryRecord activity) { + super(context); + + mService = service; + mProc = app; + Resources res = context.getResources(); + + setCancelable(false); + + int resid; + CharSequence name1 = activity != null + ? activity.info.loadLabel(context.getPackageManager()) + : null; + CharSequence name2 = null; + if ((app.pkgList.size() == 1) && + (name2=context.getPackageManager().getApplicationLabel(app.info)) != null) { + if (name1 != null) { + resid = com.android.internal.R.string.anr_activity_application; + } else { + name1 = name2; + name2 = app.processName; + resid = com.android.internal.R.string.anr_application_process; + } + } else { + if (name1 != null) { + name2 = app.processName; + resid = com.android.internal.R.string.anr_activity_process; + } else { + name1 = app.processName; + resid = com.android.internal.R.string.anr_process; + } + } + + setMessage(name2 != null + ? res.getString(resid, name1.toString(), name2.toString()) + : res.getString(resid, name1.toString())); + + setButton(res.getText(com.android.internal.R.string.force_close), + mHandler.obtainMessage(1)); + setButton2(res.getText(com.android.internal.R.string.wait), + mHandler.obtainMessage(2)); + setTitle(res.getText(com.android.internal.R.string.anr_title)); + getWindow().addFlags(FLAG_SYSTEM_ERROR); + getWindow().setTitle("Application Not Responding: " + app.info.processName); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + switch (msg.what) { + case 1: + // Kill the application. + mService.killAppAtUsersRequest(mProc, + AppNotRespondingDialog.this, true); + break; + case 2: + // Continue waiting for the application. + synchronized (mService) { + ProcessRecord app = mProc; + app.notResponding = false; + app.notRespondingReport = null; + if (app.anrDialog == AppNotRespondingDialog.this) { + app.anrDialog = null; + } + } + break; + } + } + }; +} diff --git a/services/java/com/android/server/am/AppWaitingForDebuggerDialog.java b/services/java/com/android/server/am/AppWaitingForDebuggerDialog.java new file mode 100644 index 0000000..0992d4d --- /dev/null +++ b/services/java/com/android/server/am/AppWaitingForDebuggerDialog.java @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2006 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.am; + +import android.content.Context; +import android.os.Handler; +import android.os.Message; + +class AppWaitingForDebuggerDialog extends BaseErrorDialog { + final ActivityManagerService mService; + final ProcessRecord mProc; + private CharSequence mAppName; + + public AppWaitingForDebuggerDialog(ActivityManagerService service, + Context context, ProcessRecord app) { + super(context); + mService = service; + mProc = app; + mAppName = context.getPackageManager().getApplicationLabel(app.info); + + setCancelable(false); + + StringBuilder text = new StringBuilder(); + if (mAppName != null && mAppName.length() > 0) { + text.append("Application "); + text.append(mAppName); + text.append(" (process "); + text.append(app.processName); + text.append(")"); + } else { + text.append("Process "); + text.append(app.processName); + } + + text.append(" is waiting for the debugger to attach."); + + setMessage(text.toString()); + setButton("Force Close", mHandler.obtainMessage(1, app)); + setTitle("Waiting For Debugger"); + getWindow().setTitle("Waiting For Debugger: " + app.info.processName); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + switch (msg.what) { + case 1: + // Kill the application. + mService.killAppAtUsersRequest(mProc, + AppWaitingForDebuggerDialog.this, true); + break; + } + } + }; +} diff --git a/services/java/com/android/server/am/BaseErrorDialog.java b/services/java/com/android/server/am/BaseErrorDialog.java new file mode 100644 index 0000000..bed2768 --- /dev/null +++ b/services/java/com/android/server/am/BaseErrorDialog.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2006 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.am; + +import com.android.internal.R; + +import android.app.AlertDialog; +import android.content.Context; +import android.os.Handler; +import android.os.Message; +import android.view.KeyEvent; +import android.view.WindowManager; +import android.widget.Button; + +class BaseErrorDialog extends AlertDialog { + public BaseErrorDialog(Context context) { + super(context, com.android.internal.R.style.Theme_Dialog_AppError); + + getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); + getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, + WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); + getWindow().setTitle("Error Dialog"); + setIcon(R.drawable.ic_dialog_alert); + } + + public void onStart() { + super.onStart(); + setEnabled(false); + mHandler.sendMessageDelayed(mHandler.obtainMessage(0), 1000); + } + + public boolean dispatchKeyEvent(KeyEvent event) { + if (mConsuming) { + //Log.i(TAG, "Consuming: " + event); + return true; + } + //Log.i(TAG, "Dispatching: " + event); + return super.dispatchKeyEvent(event); + } + + private void setEnabled(boolean enabled) { + Button b = (Button)findViewById(R.id.button1); + if (b != null) { + b.setEnabled(enabled); + } + b = (Button)findViewById(R.id.button2); + if (b != null) { + b.setEnabled(enabled); + } + } + + private Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + if (msg.what == 0) { + mConsuming = false; + setEnabled(true); + } + } + }; + + private boolean mConsuming = true; +} diff --git a/services/java/com/android/server/am/BatteryStatsService.java b/services/java/com/android/server/am/BatteryStatsService.java new file mode 100644 index 0000000..27d0401 --- /dev/null +++ b/services/java/com/android/server/am/BatteryStatsService.java @@ -0,0 +1,197 @@ +/* + * Copyright (C) 2006-2007 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.am; + +import com.android.internal.app.IBatteryStats; +import com.android.internal.os.BatteryStatsImpl; + +import android.content.Context; +import android.os.Binder; +import android.os.IBinder; +import android.os.Parcel; +import android.os.Process; +import android.os.ServiceManager; +import android.util.PrintWriterPrinter; + +import java.io.FileDescriptor; +import java.io.PrintWriter; + +/** + * All information we are collecting about things that can happen that impact + * battery life. + */ +public final class BatteryStatsService extends IBatteryStats.Stub { + static IBatteryStats sService; + + final BatteryStatsImpl mStats; + Context mContext; + + BatteryStatsService(String filename) { + mStats = new BatteryStatsImpl(filename); + } + + public void publish(Context context) { + mContext = context; + ServiceManager.addService("batteryinfo", asBinder()); + } + + public static IBatteryStats getService() { + if (sService != null) { + return sService; + } + IBinder b = ServiceManager.getService("batteryinfo"); + sService = asInterface(b); + return sService; + } + + /** + * @return the current statistics object, which may be modified + * to reflect events that affect battery usage. You must lock the + * stats object before doing anything with it. + */ + public BatteryStatsImpl getActiveStatistics() { + return mStats; + } + + public byte[] getStatistics() { + mContext.enforceCallingPermission( + android.Manifest.permission.BATTERY_STATS, null); + //Log.i("foo", "SENDING BATTERY INFO:"); + //mStats.dumpLocked(new LogPrinter(Log.INFO, "foo")); + Parcel out = Parcel.obtain(); + mStats.writeToParcel(out, 0); + byte[] data = out.marshall(); + out.recycle(); + return data; + } + + public void noteStartWakelock(int uid, String name, int type) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStartWakeLocked(name, type); + } + } + + public void noteStopWakelock(int uid, String name, int type) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStopWakeLocked(name, type); + } + } + + public void noteStartSensor(int uid, int sensor) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStartSensor(sensor); + } + } + + public void noteStopSensor(int uid, int sensor) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.getUidStatsLocked(uid).noteStopSensor(sensor); + } + } + + public void noteStartGps(int uid) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteStartGps(uid); + } + } + + public void noteStopGps(int uid) { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteStopGps(uid); + } + } + + public void noteScreenOn() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteScreenOnLocked(); + } + } + + public void noteScreenOff() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.noteScreenOffLocked(); + } + } + + public void notePhoneOn() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.notePhoneOnLocked(); + } + } + + public void notePhoneOff() { + enforceCallingPermission(); + synchronized (mStats) { + mStats.notePhoneOffLocked(); + } + } + + public boolean isOnBattery() { + return mStats.isOnBattery(); + } + + public void setOnBattery(boolean onBattery) { + enforceCallingPermission(); + mStats.setOnBattery(onBattery); + } + + public long getAwakeTimeBattery() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.BATTERY_STATS, null); + return mStats.getAwakeTimeBattery(); + } + + public long getAwakeTimePlugged() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.BATTERY_STATS, null); + return mStats.getAwakeTimePlugged(); + } + + public void enforceCallingPermission() { + if (Binder.getCallingPid() == Process.myPid()) { + return; + } + mContext.enforcePermission(android.Manifest.permission.UPDATE_DEVICE_STATS, + Binder.getCallingPid(), Binder.getCallingUid(), null); + } + + @Override + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (mStats) { + boolean isCheckin = false; + if (args != null) { + for (String arg : args) { + if ("-c".equals(arg)) { + isCheckin = true; + break; + } + } + } + if (isCheckin) mStats.dumpCheckinLocked(pw, args); + else mStats.dumpLocked(new PrintWriterPrinter(pw)); + } + } +} diff --git a/services/java/com/android/server/am/BroadcastFilter.java b/services/java/com/android/server/am/BroadcastFilter.java new file mode 100644 index 0000000..cd7f720 --- /dev/null +++ b/services/java/com/android/server/am/BroadcastFilter.java @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2006 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.am; + +import android.content.IntentFilter; +import android.util.PrintWriterPrinter; + +import java.io.PrintWriter; + +class BroadcastFilter extends IntentFilter { + // Back-pointer to the list this filter is in. + final ReceiverList receiverList; + final String requiredPermission; + + BroadcastFilter(IntentFilter _filter, ReceiverList _receiverList, + String _requiredPermission) { + super(_filter); + receiverList = _receiverList; + requiredPermission = _requiredPermission; + } + + public void dumpLocal(PrintWriter pw, String prefix) { + super.dump(new PrintWriterPrinter(pw), prefix); + } + + public void dump(PrintWriter pw, String prefix) { + dumpLocal(pw, prefix); + pw.println(prefix + "requiredPermission=" + requiredPermission); + receiverList.dumpLocal(pw, prefix); + } + + public String toString() { + return "BroadcastFilter{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + receiverList + "}"; + } +} diff --git a/services/java/com/android/server/am/BroadcastRecord.java b/services/java/com/android/server/am/BroadcastRecord.java new file mode 100644 index 0000000..4057ae8 --- /dev/null +++ b/services/java/com/android/server/am/BroadcastRecord.java @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2006 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.am; + +import android.app.IIntentReceiver; +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.content.pm.ResolveInfo; +import android.os.Binder; +import android.os.Bundle; +import android.os.IBinder; +import android.os.SystemClock; +import android.util.PrintWriterPrinter; + +import java.io.PrintWriter; +import java.util.List; + +/** + * An active intent broadcast. + */ +class BroadcastRecord extends Binder { + final Intent intent; // the original intent that generated us + final ProcessRecord callerApp; // process that sent this + final String callerPackage; // who sent this + final int callingPid; // the pid of who sent this + final int callingUid; // the uid of who sent this + String requiredPermission; // a permission the caller has required + final List receivers; // contains BroadcastFilter and ResolveInfo + final IIntentReceiver resultTo; // who receives final result if non-null + long dispatchTime; // when dispatch started on this set of receivers + long startTime; // when current receiver started for timeouts. + int resultCode; // current result code value. + String resultData; // current result data value. + Bundle resultExtras; // current result extra data values. + boolean resultAbort; // current result abortBroadcast value. + boolean ordered; // serialize the send to receivers? + int nextReceiver; // next receiver to be executed. + IBinder receiver; // who is currently running, null if none. + int state; + int anrCount; // has this broadcast record hit any ANRs? + + static final int IDLE = 0; + static final int APP_RECEIVE = 1; + static final int CALL_IN_RECEIVE = 2; + static final int CALL_DONE_RECEIVE = 3; + + // The following are set when we are calling a receiver (one that + // was found in our list of registered receivers). + BroadcastFilter curFilter; + + // The following are set only when we are launching a receiver (one + // that was found by querying the package manager). + ProcessRecord curApp; // hosting application of current receiver. + ComponentName curComponent; // the receiver class that is currently running. + ActivityInfo curReceiver; // info about the receiver that is currently running. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + intent); + pw.println(prefix + "proc=" + callerApp); + pw.println(prefix + "caller=" + callerPackage + + " callingPid=" + callingPid + + " callingUid=" + callingUid); + pw.println(prefix + "requiredPermission=" + requiredPermission); + pw.println(prefix + "dispatchTime=" + dispatchTime + " (" + + (SystemClock.uptimeMillis()-dispatchTime) + " since now)"); + pw.println(prefix + "startTime=" + startTime + " (" + + (SystemClock.uptimeMillis()-startTime) + " since now)"); + pw.println(prefix + "anrCount=" + anrCount); + pw.println(prefix + "resultTo=" + resultTo + + " resultCode=" + resultCode + " resultData=" + resultData); + pw.println(prefix + "resultExtras=" + resultExtras); + pw.println(prefix + "resultAbort=" + resultAbort + + " ordered=" + ordered); + pw.println(prefix + "nextReceiver=" + nextReceiver + + " receiver=" + receiver); + pw.println(prefix + "curFilter=" + curFilter); + pw.println(prefix + "curReceiver=" + + ((curReceiver != null) ? curReceiver : "(null)")); + pw.println(prefix + "curApp=" + curApp); + if (curApp != null) { + pw.println(prefix + "curComponent=" + + (curComponent != null ? curComponent.toShortString() : "--")); + pw.println(prefix + "curSourceDir=" + curReceiver.applicationInfo.sourceDir); + } + String stateStr = " (?)"; + switch (state) { + case IDLE: stateStr=" (IDLE)"; break; + case APP_RECEIVE: stateStr=" (APP_RECEIVE)"; break; + case CALL_IN_RECEIVE: stateStr=" (CALL_IN_RECEIVE)"; break; + case CALL_DONE_RECEIVE: stateStr=" (CALL_DONE_RECEIVE)"; break; + } + pw.println(prefix + "state=" + state + stateStr); + final int N = receivers != null ? receivers.size() : 0; + String p2 = prefix + " "; + PrintWriterPrinter printer = new PrintWriterPrinter(pw); + for (int i=0; i<N; i++) { + Object o = receivers.get(i); + pw.println(prefix + "Receiver #" + i + ": " + o); + if (o instanceof BroadcastFilter) + ((BroadcastFilter)o).dump(pw, p2); + else if (o instanceof ResolveInfo) + ((ResolveInfo)o).dump(printer, p2); + } + } + + BroadcastRecord(Intent _intent, ProcessRecord _callerApp, String _callerPackage, + int _callingPid, int _callingUid, String _requiredPermission, + List _receivers, IIntentReceiver _resultTo, int _resultCode, + String _resultData, Bundle _resultExtras, boolean _serialized) { + intent = _intent; + callerApp = _callerApp; + callerPackage = _callerPackage; + callingPid = _callingPid; + callingUid = _callingUid; + requiredPermission = _requiredPermission; + receivers = _receivers; + resultTo = _resultTo; + resultCode = _resultCode; + resultData = _resultData; + resultExtras = _resultExtras; + ordered = _serialized; + nextReceiver = 0; + state = IDLE; + } + + public String toString() { + return "BroadcastRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + intent.getAction() + "}"; + } +} diff --git a/services/java/com/android/server/am/ConnectionRecord.java b/services/java/com/android/server/am/ConnectionRecord.java new file mode 100644 index 0000000..41a783f --- /dev/null +++ b/services/java/com/android/server/am/ConnectionRecord.java @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2006 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.am; + +import android.app.IServiceConnection; + +import java.io.PrintWriter; + +/** + * Description of a single binding to a service. + */ +class ConnectionRecord { + final AppBindRecord binding; // The application/service binding. + final HistoryRecord activity; // If non-null, the owning activity. + final IServiceConnection conn; // The client connection. + final int flags; // Binding options. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "binding=" + binding); + pw.println(prefix + "activity=" + activity); + pw.println(prefix + "conn=" + conn.asBinder() + + " flags=0x" + Integer.toHexString(flags)); + } + + ConnectionRecord(AppBindRecord _binding, HistoryRecord _activity, + IServiceConnection _conn, int _flags) { + binding = _binding; + activity = _activity; + conn = _conn; + flags = _flags; + } + + public String toString() { + return "ConnectionRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + binding.service.shortName + + ":@" + Integer.toHexString(System.identityHashCode(conn.asBinder())) + "}"; + } +} diff --git a/services/java/com/android/server/am/ContentProviderRecord.java b/services/java/com/android/server/am/ContentProviderRecord.java new file mode 100644 index 0000000..9f37c14 --- /dev/null +++ b/services/java/com/android/server/am/ContentProviderRecord.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2006 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.am; + +import android.app.IActivityManager.ContentProviderHolder; +import android.content.pm.ApplicationInfo; +import android.content.pm.ProviderInfo; +import android.os.Process; + +import java.io.PrintWriter; +import java.util.HashSet; + +class ContentProviderRecord extends ContentProviderHolder { + // All attached clients + final HashSet<ProcessRecord> clients = new HashSet<ProcessRecord>(); + final int uid; + final ApplicationInfo appInfo; + int externals; // number of non-framework processes supported by this provider + ProcessRecord app; // if non-null, hosting application + ProcessRecord launchingApp; // if non-null, waiting for this app to be launched. + + public ContentProviderRecord(ProviderInfo _info, ApplicationInfo ai) { + super(_info); + uid = ai.uid; + appInfo = ai; + noReleaseNeeded = uid == 0 || uid == Process.SYSTEM_UID; + } + + public ContentProviderRecord(ContentProviderRecord cpr) { + super(cpr.info); + uid = cpr.uid; + appInfo = cpr.appInfo; + noReleaseNeeded = cpr.noReleaseNeeded; + } + + public boolean canRunHere(ProcessRecord app) { + return (info.multiprocess || info.processName.equals(app.processName)) + && (uid == Process.SYSTEM_UID || uid == app.info.uid); + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "package=" + info.applicationInfo.packageName + + " process=" + info.processName); + pw.println(prefix + "app=" + app); + pw.println(prefix + "launchingApp=" + launchingApp); + pw.println(prefix + "provider=" + provider); + pw.println(prefix + "name=" + info.authority); + pw.println(prefix + "isSyncable=" + info.isSyncable); + pw.println(prefix + "multiprocess=" + info.multiprocess + + " initOrder=" + info.initOrder + + " uid=" + uid); + pw.println(prefix + "clients=" + clients); + pw.println(prefix + "externals=" + externals); + } + + public String toString() { + return "ContentProviderRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + info.name + "}"; + } +} diff --git a/services/java/com/android/server/am/DeviceMonitor.java b/services/java/com/android/server/am/DeviceMonitor.java new file mode 100644 index 0000000..ce07430 --- /dev/null +++ b/services/java/com/android/server/am/DeviceMonitor.java @@ -0,0 +1,230 @@ +/* + * 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.am; + +import android.util.Log; + +import java.io.*; +import java.util.Arrays; + +/** + * Monitors device resources periodically for some period of time. Useful for + * tracking down performance problems. + */ +class DeviceMonitor { + + private static final String LOG_TAG = DeviceMonitor.class.getName(); + + /** Number of samples to take. */ + private static final int SAMPLE_COUNT = 10; + + /** Time to wait in ms between samples. */ + private static final int INTERVAL = 1000; + + /** Time to wait in ms between samples. */ + private static final int MAX_FILES = 30; + + private final byte[] buffer = new byte[1024]; + + /** Is the monitor currently running? */ + private boolean running = false; + + private DeviceMonitor() { + new Thread() { + public void run() { + monitor(); + } + }.start(); + } + + /** + * Loops continuously. Pauses until someone tells us to start monitoring. + */ + @SuppressWarnings("InfiniteLoopStatement") + private void monitor() { + while (true) { + waitForStart(); + + purge(); + + for (int i = 0; i < SAMPLE_COUNT; i++) { + try { + dump(); + } catch (IOException e) { + Log.w(LOG_TAG, "Dump failed.", e); + } + pause(); + } + + stop(); + } + } + + private static final File PROC = new File("/proc"); + private static final File BASE = new File("/data/anr/"); + static { + if (!BASE.isDirectory() && !BASE.mkdirs()) { + throw new AssertionError("Couldn't create " + BASE + "."); + } + } + + private static final File[] PATHS = { + new File(PROC, "zoneinfo"), + new File(PROC, "interrupts"), + new File(PROC, "meminfo"), + new File(PROC, "slabinfo"), + }; + + + /** + * Deletes old files. + */ + private void purge() { + File[] files = BASE.listFiles(); + int count = files.length - MAX_FILES; + if (count > 0) { + Arrays.sort(files); + for (int i = 0; i < count; i++) { + if (!files[i].delete()) { + Log.w(LOG_TAG, "Couldn't delete " + files[i] + "."); + } + } + } + } + + /** + * Dumps the current device stats to a new file. + */ + private void dump() throws IOException { + OutputStream out = new FileOutputStream( + new File(BASE, String.valueOf(System.currentTimeMillis()))); + try { + // Copy /proc/*/stat + for (File processDirectory : PROC.listFiles()) { + if (isProcessDirectory(processDirectory)) { + dump(new File(processDirectory, "stat"), out); + } + } + + // Copy other files. + for (File file : PATHS) { + dump(file, out); + } + } finally { + closeQuietly(out); + } + } + + /** + * Returns true if the given file represents a process directory. + */ + private static boolean isProcessDirectory(File file) { + try { + Integer.parseInt(file.getName()); + return file.isDirectory(); + } catch (NumberFormatException e) { + return false; + } + } + + /** + * Copies from a file to an output stream. + */ + private void dump(File from, OutputStream out) throws IOException { + writeHeader(from, out); + + FileInputStream in = null; + try { + in = new FileInputStream(from); + int count; + while ((count = in.read(buffer)) != -1) { + out.write(buffer, 0, count); + } + } finally { + closeQuietly(in); + } + } + + /** + * Writes a header for the given file. + */ + private static void writeHeader(File file, OutputStream out) + throws IOException { + String header = "*** " + file.toString() + "\n"; + out.write(header.getBytes()); + } + + /** + * Closes the given resource. Logs exceptions. + * @param closeable + */ + private static void closeQuietly(Closeable closeable) { + try { + if (closeable != null) { + closeable.close(); + } + } catch (IOException e) { + Log.w(LOG_TAG, e); + } + } + + /** + * Pauses momentarily before we start the next dump. + */ + private void pause() { + try { + Thread.sleep(INTERVAL); + } catch (InterruptedException e) { /* ignore */ } + } + + /** + * Stops dumping. + */ + private synchronized void stop() { + running = false; + } + + /** + * Waits until someone starts us. + */ + private synchronized void waitForStart() { + while (!running) { + try { + wait(); + } catch (InterruptedException e) { /* ignore */ } + } + } + + /** + * Instructs the monitoring to start if it hasn't already. + */ + private synchronized void startMonitoring() { + if (!running) { + running = true; + notifyAll(); + } + } + + private static DeviceMonitor instance = new DeviceMonitor(); + + /** + * Starts monitoring if it hasn't started already. + */ + static void start() { + instance.startMonitoring(); + } +} diff --git a/services/java/com/android/server/am/FactoryErrorDialog.java b/services/java/com/android/server/am/FactoryErrorDialog.java new file mode 100644 index 0000000..2e25474 --- /dev/null +++ b/services/java/com/android/server/am/FactoryErrorDialog.java @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2006 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.am; + +import android.content.Context; +import android.os.Handler; +import android.os.Message; + +class FactoryErrorDialog extends BaseErrorDialog { + public FactoryErrorDialog(Context context, CharSequence msg) { + super(context); + setCancelable(false); + setTitle(context.getText(com.android.internal.R.string.factorytest_failed)); + setMessage(msg); + setButton(context.getText(com.android.internal.R.string.factorytest_reboot), + mHandler.obtainMessage(0)); + getWindow().setTitle("Factory Error"); + } + + public void onStop() { + } + + private final Handler mHandler = new Handler() { + public void handleMessage(Message msg) { + throw new RuntimeException("Rebooting from failed factory test"); + } + }; +} diff --git a/services/java/com/android/server/am/HistoryRecord.java b/services/java/com/android/server/am/HistoryRecord.java new file mode 100644 index 0000000..b407208 --- /dev/null +++ b/services/java/com/android/server/am/HistoryRecord.java @@ -0,0 +1,429 @@ +/* + * Copyright (C) 2006 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.am; + +import com.android.server.AttributeCache; +import com.android.server.am.ActivityManagerService.ActivityState; + +import android.app.Activity; +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.content.pm.ApplicationInfo; +import android.content.res.Configuration; +import android.graphics.Bitmap; +import android.os.Bundle; +import android.os.Message; +import android.os.Process; +import android.os.SystemClock; +import android.util.EventLog; +import android.util.Log; +import android.view.IApplicationToken; + +import java.io.PrintWriter; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.HashSet; + +/** + * An entry in the history stack, representing an activity. + */ +class HistoryRecord extends IApplicationToken.Stub { + final ActivityManagerService service; // owner + final ActivityInfo info; // all about me + final int launchedFromUid; // always the uid who started the activity. + final Intent intent; // the original intent that generated us + final ComponentName realActivity; // the intent component, or target of an alias. + final String shortComponentName; // the short component name of the intent + final String resolvedType; // as per original caller; + final String packageName; // the package implementing intent's component + final String processName; // process where this component wants to run + final String taskAffinity; // as per ActivityInfo.taskAffinity + final boolean stateNotNeeded; // As per ActivityInfo.flags + final boolean fullscreen; // covers the full screen? + final String baseDir; // where activity source (resources etc) located + final String resDir; // where public activity source (public resources etc) located + final String dataDir; // where activity data should go + CharSequence nonLocalizedLabel; // the label information from the package mgr. + int labelRes; // the label information from the package mgr. + int icon; // resource identifier of activity's icon. + int theme; // resource identifier of activity's theme. + TaskRecord task; // the task this is in. + long startTime; // when we starting launching this activity + Configuration configuration; // configuration activity was last running in + HistoryRecord resultTo; // who started this entry, so will get our reply + final String resultWho; // additional identifier for use by resultTo. + final int requestCode; // code given by requester (resultTo) + ArrayList results; // pending ActivityResult objs we have received + HashSet<WeakReference<PendingIntentRecord>> pendingResults; // all pending intents for this act + ArrayList newIntents; // any pending new intents for single-top mode + HashSet<ConnectionRecord> connections; // All ConnectionRecord we hold + HashSet<UriPermission> readUriPermissions; // special access to reading uris. + HashSet<UriPermission> writeUriPermissions; // special access to writing uris. + ProcessRecord app; // if non-null, hosting application + Bitmap thumbnail; // icon representation of paused screen + CharSequence description; // textual description of paused screen + ActivityManagerService.ActivityState state; // current state we are in + Bundle icicle; // last saved activity state + boolean frontOfTask; // is this the root activity of its task? + boolean launchFailed; // set if a launched failed, to abort on 2nd try + boolean haveState; // have we gotten the last activity state? + boolean stopped; // is activity pause finished? + boolean finishing; // activity in pending finish list? + boolean configDestroy; // need to destroy due to config change? + int configChangeFlags; // which config values have changed + boolean keysPaused; // has key dispatching been paused for it? + boolean inHistory; // are we in the history stack? + boolean persistent; // requested to be persistent? + int launchMode; // the launch mode activity attribute. + boolean visible; // does this activity's window need to be shown? + boolean waitingVisible; // true if waiting for a new act to become vis + boolean nowVisible; // is this activity's window visible? + boolean thumbnailNeeded;// has someone requested a thumbnail? + boolean idle; // has the activity gone idle? + boolean hasBeenLaunched;// has this activity ever been launched? + boolean frozenBeforeDestroy;// has been frozen but not yet destroyed. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "packageName=" + packageName + + " processName=" + processName); + pw.println(prefix + "app=" + app); + pw.println(prefix + "launchedFromUid=" + launchedFromUid); + pw.println(prefix + intent); + pw.println(prefix + "frontOfTask=" + frontOfTask + " task=" + task); + pw.println(prefix + "taskAffinity=" + taskAffinity); + pw.println(prefix + "realActivity=" + realActivity); + pw.println(prefix + "dir=" + baseDir + " res=" + resDir + " data=" + dataDir); + pw.println(prefix + "labelRes=0x" + Integer.toHexString(labelRes) + + " icon=0x" + Integer.toHexString(icon) + + " theme=0x" + Integer.toHexString(theme)); + pw.println(prefix + "configuration=" + configuration); + pw.println(prefix + "resultTo=" + resultTo + + " resultWho=" + resultWho + " resultCode=" + requestCode); + pw.println(prefix + "results=" + results); + pw.println(prefix + "pendingResults=" + pendingResults); + pw.println(prefix + "readUriPermissions=" + readUriPermissions); + pw.println(prefix + "writeUriPermissions=" + writeUriPermissions); + pw.println(prefix + "launchFailed=" + launchFailed + + " haveState=" + haveState + " icicle=" + icicle); + pw.println(prefix + "state=" + state + + " stopped=" + stopped + " finishing=" + finishing); + pw.println(prefix + "keysPaused=" + keysPaused + + " inHistory=" + inHistory + " persistent=" + persistent + + " launchMode=" + launchMode); + pw.println(prefix + "fullscreen=" + fullscreen + + " visible=" + visible + + " frozenBeforeDestroy=" + frozenBeforeDestroy + + " thumbnailNeeded=" + thumbnailNeeded + " idle=" + idle); + pw.println(prefix + "waitingVisible=" + waitingVisible + + " nowVisible=" + nowVisible); + pw.println(prefix + "configDestroy=" + configDestroy + + " configChangeFlags=" + Integer.toHexString(configChangeFlags)); + pw.println(prefix + "connections=" + connections); + } + + HistoryRecord(ActivityManagerService _service, ProcessRecord _caller, + int _launchedFromUid, Intent _intent, String _resolvedType, + ActivityInfo aInfo, Configuration _configuration, + HistoryRecord _resultTo, String _resultWho, int _reqCode) { + service = _service; + info = aInfo; + launchedFromUid = _launchedFromUid; + intent = _intent; + shortComponentName = _intent.getComponent().flattenToShortString(); + resolvedType = _resolvedType; + configuration = _configuration; + resultTo = _resultTo; + resultWho = _resultWho; + requestCode = _reqCode; + state = ActivityManagerService.ActivityState.INITIALIZING; + frontOfTask = false; + launchFailed = false; + haveState = false; + stopped = false; + finishing = false; + configDestroy = false; + keysPaused = false; + inHistory = false; + persistent = false; + visible = true; + waitingVisible = false; + nowVisible = false; + thumbnailNeeded = false; + idle = false; + hasBeenLaunched = false; + + if (aInfo != null) { + if (aInfo.targetActivity == null + || aInfo.launchMode == ActivityInfo.LAUNCH_MULTIPLE + || aInfo.launchMode == ActivityInfo.LAUNCH_SINGLE_TOP) { + realActivity = _intent.getComponent(); + } else { + realActivity = new ComponentName(aInfo.packageName, + aInfo.targetActivity); + } + taskAffinity = aInfo.taskAffinity; + stateNotNeeded = (aInfo.flags& + ActivityInfo.FLAG_STATE_NOT_NEEDED) != 0; + baseDir = aInfo.applicationInfo.sourceDir; + resDir = aInfo.applicationInfo.publicSourceDir; + dataDir = aInfo.applicationInfo.dataDir; + nonLocalizedLabel = aInfo.nonLocalizedLabel; + labelRes = aInfo.labelRes; + if (nonLocalizedLabel == null && labelRes == 0) { + ApplicationInfo app = aInfo.applicationInfo; + nonLocalizedLabel = app.nonLocalizedLabel; + labelRes = app.labelRes; + } + icon = aInfo.getIconResource(); + theme = aInfo.getThemeResource(); + if ((aInfo.flags&ActivityInfo.FLAG_MULTIPROCESS) != 0 + && _caller != null + && (aInfo.applicationInfo.uid == Process.SYSTEM_UID + || aInfo.applicationInfo.uid == _caller.info.uid)) { + processName = _caller.processName; + } else { + processName = aInfo.processName; + } + + if (intent != null && (aInfo.flags & ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS) != 0) { + intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); + } + + packageName = aInfo.applicationInfo.packageName; + launchMode = aInfo.launchMode; + + AttributeCache.Entry ent = AttributeCache.instance().get(packageName, + theme != 0 ? theme : android.R.style.Theme, + com.android.internal.R.styleable.Window); + fullscreen = ent != null && !ent.array.getBoolean( + com.android.internal.R.styleable.Window_windowIsFloating, false) + && !ent.array.getBoolean( + com.android.internal.R.styleable.Window_windowIsTranslucent, false); + + } else { + realActivity = null; + taskAffinity = null; + stateNotNeeded = false; + baseDir = null; + resDir = null; + dataDir = null; + processName = null; + packageName = null; + fullscreen = true; + } + } + + void addResultLocked(HistoryRecord from, String resultWho, + int requestCode, int resultCode, + Intent resultData) { + ActivityResult r = new ActivityResult(from, resultWho, + requestCode, resultCode, resultData); + if (results == null) { + results = new ArrayList(); + } + results.add(r); + } + + void removeResultsLocked(HistoryRecord from, String resultWho, + int requestCode) { + if (results != null) { + for (int i=results.size()-1; i>=0; i--) { + ActivityResult r = (ActivityResult)results.get(i); + if (r.mFrom != from) continue; + if (r.mResultWho == null) { + if (resultWho != null) continue; + } else { + if (!r.mResultWho.equals(resultWho)) continue; + } + if (r.mRequestCode != requestCode) continue; + + results.remove(i); + } + } + } + + void addNewIntentLocked(Intent intent) { + if (newIntents == null) { + newIntents = new ArrayList(); + } + newIntents.add(intent); + } + + void pauseKeyDispatchingLocked() { + if (!keysPaused) { + keysPaused = true; + service.mWindowManager.pauseKeyDispatching(this); + } + } + + void resumeKeyDispatchingLocked() { + if (keysPaused) { + keysPaused = false; + service.mWindowManager.resumeKeyDispatching(this); + } + } + + // IApplicationToken + + public boolean mayFreezeScreenLocked(ProcessRecord app) { + // Only freeze the screen if this activity is currently attached to + // an application, and that application is not blocked or unresponding. + // In any other case, we can't count on getting the screen unfrozen, + // so it is best to leave as-is. + return app == null || (!app.crashing && !app.notResponding); + } + + public void startFreezingScreenLocked(ProcessRecord app, int configChanges) { + if (mayFreezeScreenLocked(app)) { + service.mWindowManager.startAppFreezingScreen(this, configChanges); + } + } + + public void stopFreezingScreenLocked(boolean force) { + if (force || frozenBeforeDestroy) { + frozenBeforeDestroy = false; + service.mWindowManager.stopAppFreezingScreen(this, force); + } + } + + public void windowsVisible() { + synchronized(service) { + if (ActivityManagerService.SHOW_ACTIVITY_START_TIME + && startTime != 0) { + long time = SystemClock.uptimeMillis() - startTime; + EventLog.writeEvent(ActivityManagerService.LOG_ACTIVITY_LAUNCH_TIME, + System.identityHashCode(this), shortComponentName, time); + Log.i(ActivityManagerService.TAG, "Displayed activity " + + shortComponentName + + ": " + time + " ms"); + startTime = 0; + } + if (ActivityManagerService.DEBUG_SWITCH) Log.v( + ActivityManagerService.TAG, "windowsVisible(): " + this); + if (!nowVisible) { + nowVisible = true; + if (!idle) { + // Instead of doing the full stop routine here, let's just + // hide any activities we now can, and let them stop when + // the normal idle happens. + service.processStoppingActivitiesLocked(false); + } else { + // If this activity was already idle, then we now need to + // make sure we perform the full stop of any activities + // that are waiting to do so. This is because we won't + // do that while they are still waiting for this one to + // become visible. + final int N = service.mWaitingVisibleActivities.size(); + if (N > 0) { + for (int i=0; i<N; i++) { + HistoryRecord r = (HistoryRecord) + service.mWaitingVisibleActivities.get(i); + r.waitingVisible = false; + if (ActivityManagerService.DEBUG_SWITCH) Log.v( + ActivityManagerService.TAG, + "Was waiting for visible: " + r); + } + service.mWaitingVisibleActivities.clear(); + Message msg = Message.obtain(); + msg.what = ActivityManagerService.IDLE_NOW_MSG; + service.mHandler.sendMessage(msg); + } + } + service.scheduleAppGcsLocked(); + } + } + } + + public void windowsGone() { + if (ActivityManagerService.DEBUG_SWITCH) Log.v( + ActivityManagerService.TAG, "windowsGone(): " + this); + nowVisible = false; + } + + private HistoryRecord getWaitingHistoryRecordLocked() { + // First find the real culprit... if we are waiting + // for another app to start, then we have paused dispatching + // for this activity. + HistoryRecord r = this; + if (r.waitingVisible) { + // Hmmm, who might we be waiting for? + r = service.mResumedActivity; + if (r == null) { + r = service.mPausingActivity; + } + // Both of those null? Fall back to 'this' again + if (r == null) { + r = this; + } + } + + return r; + } + + public boolean keyDispatchingTimedOut() { + synchronized(service) { + HistoryRecord r = getWaitingHistoryRecordLocked(); + if (r != null && r.app != null) { + if (r.app.debugging) { + return false; + } + + if (r.app.instrumentationClass == null) { + service.appNotRespondingLocked(r.app, r, "keyDispatchingTimedOut"); + } else { + Bundle info = new Bundle(); + info.putString("shortMsg", "keyDispatchingTimedOut"); + info.putString("longMsg", "Timed out while dispatching key event"); + service.finishInstrumentationLocked( + r.app, Activity.RESULT_CANCELED, info); + } + } + return true; + } + } + + /** Returns the key dispatching timeout for this application token. */ + public long getKeyDispatchingTimeout() { + synchronized(service) { + HistoryRecord r = getWaitingHistoryRecordLocked(); + if (r == null || r.app == null + || r.app.instrumentationClass == null) { + return ActivityManagerService.KEY_DISPATCHING_TIMEOUT; + } + + return ActivityManagerService.INSTRUMENTATION_KEY_DISPATCHING_TIMEOUT; + } + } + + /** + * This method will return true if the activity is either visible, is becoming visible, is + * currently pausing, or is resumed. + */ + public boolean isInterestingToUserLocked() { + return visible || nowVisible || state == ActivityState.PAUSING || + state == ActivityState.RESUMED; + } + + + public String toString() { + return "HistoryRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + intent.getComponent().toShortString() + "}"; + } +} diff --git a/services/java/com/android/server/am/IntentBindRecord.java b/services/java/com/android/server/am/IntentBindRecord.java new file mode 100644 index 0000000..24c3943 --- /dev/null +++ b/services/java/com/android/server/am/IntentBindRecord.java @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2006 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.am; + +import android.content.Intent; +import android.os.IBinder; + +import java.io.PrintWriter; +import java.util.HashMap; +import java.util.Iterator; + +/** + * A particular Intent that has been bound to a Service. + */ +class IntentBindRecord { + /** The running service. */ + final ServiceRecord service; + /** The intent that is bound.*/ + final Intent.FilterComparison intent; // + /** All apps that have bound to this Intent. */ + final HashMap<ProcessRecord, AppBindRecord> apps + = new HashMap<ProcessRecord, AppBindRecord>(); + /** Binder published from service. */ + IBinder binder; + /** Set when we have initiated a request for this binder. */ + boolean requested; + /** Set when we have received the requested binder. */ + boolean received; + /** Set when we still need to tell the service all clients are unbound. */ + boolean hasBound; + /** Set when the service's onUnbind() has asked to be told about new clients. */ + boolean doRebind; + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "service=" + service); + pw.println(prefix + "intent=" + intent.getIntent()); + pw.println(prefix + "binder=" + binder + + " requested=" + requested + + " received=" + received + + " hasBound=" + hasBound + + " doRebind=" + doRebind); + if (apps.size() > 0) { + pw.println(prefix + "Application Bindings:"); + Iterator<AppBindRecord> it = apps.values().iterator(); + while (it.hasNext()) { + AppBindRecord a = it.next(); + pw.println(prefix + "Client " + a.client); + a.dump(pw, prefix + " "); + } + } + } + + IntentBindRecord(ServiceRecord _service, Intent.FilterComparison _intent) { + service = _service; + intent = _intent; + } + + public String toString() { + return "IntentBindRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + service.name.toShortString() + + ":" + intent + "}"; + } +} diff --git a/services/java/com/android/server/am/PendingIntentRecord.java b/services/java/com/android/server/am/PendingIntentRecord.java new file mode 100644 index 0000000..b18aaf7 --- /dev/null +++ b/services/java/com/android/server/am/PendingIntentRecord.java @@ -0,0 +1,278 @@ +/* + * Copyright (C) 2006 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.am; + +import android.app.IActivityManager; +import android.app.IIntentSender; +import android.app.IIntentReceiver; +import android.app.PendingIntent; +import android.content.Intent; +import android.os.Binder; +import android.os.RemoteException; +import android.util.Log; + +import java.io.PrintWriter; +import java.lang.ref.WeakReference; + +class PendingIntentRecord extends IIntentSender.Stub { + final ActivityManagerService owner; + final Key key; + final int uid; + final WeakReference<PendingIntentRecord> ref; + boolean sent = false; + boolean canceled = false; + + final static class Key { + final int type; + final String packageName; + final HistoryRecord activity; + final String who; + final int requestCode; + final Intent requestIntent; + final String requestResolvedType; + final int flags; + final int hashCode; + + private static final int ODD_PRIME_NUMBER = 37; + + Key(int _t, String _p, HistoryRecord _a, String _w, + int _r, Intent _i, String _it, int _f) { + type = _t; + packageName = _p; + activity = _a; + who = _w; + requestCode = _r; + requestIntent = _i; + requestResolvedType = _it; + flags = _f; + + int hash = 23; + hash = (ODD_PRIME_NUMBER*hash) + _f; + hash = (ODD_PRIME_NUMBER*hash) + _r; + if (_w != null) { + hash = (ODD_PRIME_NUMBER*hash) + _w.hashCode(); + } + if (_a != null) { + hash = (ODD_PRIME_NUMBER*hash) + _a.hashCode(); + } + if (_i != null) { + hash = (ODD_PRIME_NUMBER*hash) + _i.filterHashCode(); + } + if (_it != null) { + hash = (ODD_PRIME_NUMBER*hash) + _it.hashCode(); + } + hash = (ODD_PRIME_NUMBER*hash) + _p.hashCode(); + hash = (ODD_PRIME_NUMBER*hash) + _t; + hashCode = hash; + //Log.i(ActivityManagerService.TAG, this + " hashCode=0x" + // + Integer.toHexString(hashCode)); + } + + public boolean equals(Object otherObj) { + if (otherObj == null) { + return false; + } + try { + Key other = (Key)otherObj; + if (type != other.type) { + return false; + } + if (!packageName.equals(other.packageName)) { + return false; + } + if (activity != other.activity) { + return false; + } + if (who != other.who) { + if (who != null) { + if (!who.equals(other.who)) { + return false; + } + } else if (other.who != null) { + return false; + } + } + if (requestCode != other.requestCode) { + return false; + } + if (requestIntent != other.requestIntent) { + if (requestIntent != null) { + if (!requestIntent.filterEquals(other.requestIntent)) { + return false; + } + } else if (other.requestIntent != null) { + return false; + } + } + if (requestResolvedType != other.requestResolvedType) { + if (requestResolvedType != null) { + if (!requestResolvedType.equals(other.requestResolvedType)) { + return false; + } + } else if (other.requestResolvedType != null) { + return false; + } + } + if (flags != other.flags) { + return false; + } + return true; + } catch (ClassCastException e) { + } + return false; + } + + public int hashCode() { + return hashCode; + } + + public String toString() { + return "Key{" + typeName() + " pkg=" + packageName + + " intent=" + requestIntent + " flags=0x" + + Integer.toHexString(flags) + "}"; + } + + String typeName() { + switch (type) { + case IActivityManager.INTENT_SENDER_ACTIVITY: + return "startActivity"; + case IActivityManager.INTENT_SENDER_BROADCAST: + return "broadcastIntent"; + case IActivityManager.INTENT_SENDER_SERVICE: + return "startService"; + case IActivityManager.INTENT_SENDER_ACTIVITY_RESULT: + return "activityResult"; + } + return Integer.toString(type); + } + } + + PendingIntentRecord(ActivityManagerService _owner, Key _k, int _u) { + owner = _owner; + key = _k; + uid = _u; + ref = new WeakReference<PendingIntentRecord>(this); + } + + public int send(int code, Intent intent, String resolvedType, + IIntentReceiver finishedReceiver) { + synchronized(owner) { + if (!canceled) { + sent = true; + if ((key.flags&PendingIntent.FLAG_ONE_SHOT) != 0) { + owner.cancelIntentSenderLocked(this, true); + canceled = true; + } + Intent finalIntent = key.requestIntent != null + ? new Intent(key.requestIntent) : new Intent(); + if (intent != null) { + int changes = finalIntent.fillIn(intent, key.flags); + if ((changes&Intent.FILL_IN_DATA) == 0) { + resolvedType = key.requestResolvedType; + } + } else { + resolvedType = key.requestResolvedType; + } + + final long origId = Binder.clearCallingIdentity(); + + boolean sendFinish = finishedReceiver != null; + switch (key.type) { + case IActivityManager.INTENT_SENDER_ACTIVITY: + try { + owner.startActivityInPackage(uid, + finalIntent, resolvedType, + null, null, 0, false); + } catch (RuntimeException e) { + Log.w(ActivityManagerService.TAG, + "Unable to send startActivity intent", e); + } + break; + case IActivityManager.INTENT_SENDER_ACTIVITY_RESULT: + owner.sendActivityResultLocked(-1, key.activity, + key.who, key.requestCode, code, finalIntent); + break; + case IActivityManager.INTENT_SENDER_BROADCAST: + try { + // If a completion callback has been requested, require + // that the broadcast be delivered synchronously + owner.broadcastIntentInPackage(key.packageName, uid, + finalIntent, resolvedType, + finishedReceiver, code, null, null, null, + (finishedReceiver != null), false); + sendFinish = false; + } catch (RuntimeException e) { + Log.w(ActivityManagerService.TAG, + "Unable to send startActivity intent", e); + } + break; + case IActivityManager.INTENT_SENDER_SERVICE: + try { + owner.startServiceInPackage(uid, + finalIntent, resolvedType); + } catch (RuntimeException e) { + Log.w(ActivityManagerService.TAG, + "Unable to send startService intent", e); + } + break; + } + + if (sendFinish) { + try { + finishedReceiver.performReceive(new Intent(finalIntent), 0, + null, null, false); + } catch (RemoteException e) { + } + } + + Binder.restoreCallingIdentity(origId); + + return 0; + } + } + return -1; + } + + protected void finalize() throws Throwable { + if (!canceled) { + synchronized(owner) { + WeakReference<PendingIntentRecord> current = + owner.mIntentSenderRecords.get(key); + if (current == ref) { + owner.mIntentSenderRecords.remove(key); + } + } + } + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + "packageName=" + key.packageName + + " type=" + key.typeName() + + " flags=0x" + Integer.toHexString(key.flags)); + pw.println(prefix + "activity=" + key.activity + " who=" + key.who); + pw.println(prefix + "requestCode=" + key.requestCode + + " requestResolvedType=" + key.requestResolvedType); + pw.println(prefix + "requestIntent=" + key.requestIntent); + pw.println(prefix + "sent=" + sent + " canceled=" + canceled); + } + + public String toString() { + return "IntentSenderRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + key.packageName + " " + key.typeName() + "}"; + } +} diff --git a/services/java/com/android/server/am/PendingThumbnailsRecord.java b/services/java/com/android/server/am/PendingThumbnailsRecord.java new file mode 100644 index 0000000..ed478c9 --- /dev/null +++ b/services/java/com/android/server/am/PendingThumbnailsRecord.java @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2006 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.am; + +import android.app.IThumbnailReceiver; + +import java.util.HashSet; + +/** + * This class keeps track of calls to getTasks() that are still + * waiting for thumbnail images. + */ +class PendingThumbnailsRecord +{ + final IThumbnailReceiver receiver; // who is waiting. + HashSet pendingRecords; // HistoryRecord objects we still wait for. + boolean finished; // Is pendingRecords empty? + + PendingThumbnailsRecord(IThumbnailReceiver _receiver) + { + receiver = _receiver; + pendingRecords = new HashSet(); + finished = false; + } +} diff --git a/services/java/com/android/server/am/ProcessRecord.java b/services/java/com/android/server/am/ProcessRecord.java new file mode 100644 index 0000000..a1320df --- /dev/null +++ b/services/java/com/android/server/am/ProcessRecord.java @@ -0,0 +1,224 @@ +/* + * Copyright (C) 2006 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.am; + +import com.android.internal.os.BatteryStatsImpl; +import com.android.server.Watchdog; + +import android.app.ActivityManager; +import android.app.Dialog; +import android.app.IApplicationThread; +import android.app.IInstrumentationWatcher; +import android.content.ComponentName; +import android.content.pm.ApplicationInfo; +import android.os.Bundle; +import android.os.IBinder; +import android.os.RemoteException; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; + +/** + * Full information about a particular process that + * is currently running. + */ +class ProcessRecord implements Watchdog.PssRequestor { + final BatteryStatsImpl.Uid.Proc batteryStats; // where to collect runtime statistics + final ApplicationInfo info; // all about the first app in the process + final String processName; // name of the process + // List of packages running in the process + final HashSet<String> pkgList = new HashSet(); + IApplicationThread thread; // the actual proc... may be null only if + // 'persistent' is true (in which case we + // are in the process of launching the app) + int pid; // The process of this application; 0 if none + boolean starting; // True if the process is being started + int maxAdj; // Maximum OOM adjustment for this process + int hiddenAdj; // If hidden, this is the adjustment to use + int curRawAdj; // Current OOM unlimited adjustment for this process + int setRawAdj; // Last set OOM unlimited adjustment for this process + int curAdj; // Current OOM adjustment for this process + int setAdj; // Last set OOM adjustment for this process + boolean isForeground; // Is this app running the foreground UI? + boolean setIsForeground; // Running foreground UI when last set? + boolean foregroundServices; // Running any services that are foreground? + boolean bad; // True if disabled in the bad process list + IBinder forcingToForeground;// Token that is forcing this process to be foreground + int adjSeq; // Sequence id for identifying repeated trav + ComponentName instrumentationClass;// class installed to instrument app + String instrumentationProfileFile; // where to save profiling + IInstrumentationWatcher instrumentationWatcher; // who is waiting + Bundle instrumentationArguments;// as given to us + ComponentName instrumentationResultClass;// copy of instrumentationClass + BroadcastRecord curReceiver;// receiver currently running in the app + long lastRequestedGc; // When we last asked the app to do a gc + int lastPss; // Last pss size reported by app. + + // contains HistoryRecord objects + final ArrayList activities = new ArrayList(); + // all ServiceRecord running in this process + final HashSet services = new HashSet(); + // services that are currently executing code (need to remain foreground). + final HashSet<ServiceRecord> executingServices + = new HashSet<ServiceRecord>(); + // All ConnectionRecord this process holds + final HashSet<ConnectionRecord> connections + = new HashSet<ConnectionRecord>(); + // all IIntentReceivers that are registered from this process. + final HashSet<ReceiverList> receivers = new HashSet<ReceiverList>(); + // class (String) -> ContentProviderRecord + final HashMap pubProviders = new HashMap(); + // All ContentProviderRecord process is using + final HashSet conProviders = new HashSet(); + + boolean persistent; // always keep this application running? + boolean crashing; // are we in the process of crashing? + Dialog crashDialog; // dialog being displayed due to crash. + boolean notResponding; // does the app have a not responding dialog? + Dialog anrDialog; // dialog being displayed due to app not resp. + boolean removed; // has app package been removed from device? + boolean debugging; // was app launched for debugging? + int persistentActivities; // number of activities that are persistent + boolean waitedForDebugger; // has process show wait for debugger dialog? + Dialog waitDialog; // current wait for debugger dialog + + // These reports are generated & stored when an app gets into an error condition. + // They will be "null" when all is OK. + ActivityManager.ProcessErrorStateInfo crashingReport; + ActivityManager.ProcessErrorStateInfo notRespondingReport; + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "class=" + info.className); + pw.println(prefix+"manageSpaceActivityName="+info.manageSpaceActivityName); + pw.println(prefix + "dir=" + info.sourceDir + " publicDir=" + info.publicSourceDir + + " data=" + info.dataDir); + pw.println(prefix + "packageList=" + pkgList); + pw.println(prefix + "instrumentationClass=" + instrumentationClass + + " instrumentationProfileFile=" + instrumentationProfileFile); + pw.println(prefix + "instrumentationArguments=" + instrumentationArguments); + pw.println(prefix + "thread=" + thread + " curReceiver=" + curReceiver); + pw.println(prefix + "pid=" + pid + " starting=" + starting + + " lastPss=" + lastPss); + pw.println(prefix + "maxAdj=" + maxAdj + " hiddenAdj=" + hiddenAdj + + " curRawAdj=" + curRawAdj + " setRawAdj=" + setRawAdj + + " curAdj=" + curAdj + " setAdj=" + setAdj); + pw.println(prefix + "isForeground=" + isForeground + + " setIsForeground=" + setIsForeground + + " foregroundServices=" + foregroundServices + + " forcingToForeground=" + forcingToForeground); + pw.println(prefix + "persistent=" + persistent + " removed=" + removed + + " persistentActivities=" + persistentActivities); + pw.println(prefix + "debugging=" + debugging + + " crashing=" + crashing + " " + crashDialog + + " notResponding=" + notResponding + " " + anrDialog + + " bad=" + bad); + pw.println(prefix + "activities=" + activities); + pw.println(prefix + "services=" + services); + pw.println(prefix + "executingServices=" + executingServices); + pw.println(prefix + "connections=" + connections); + pw.println(prefix + "pubProviders=" + pubProviders); + pw.println(prefix + "conProviders=" + conProviders); + pw.println(prefix + "receivers=" + receivers); + } + + ProcessRecord(BatteryStatsImpl.Uid.Proc _batteryStats, IApplicationThread _thread, + ApplicationInfo _info, String _processName) { + batteryStats = _batteryStats; + info = _info; + processName = _processName; + pkgList.add(_info.packageName); + thread = _thread; + maxAdj = ActivityManagerService.EMPTY_APP_ADJ; + hiddenAdj = ActivityManagerService.HIDDEN_APP_MIN_ADJ; + curRawAdj = setRawAdj = -100; + curAdj = setAdj = -100; + persistent = false; + removed = false; + persistentActivities = 0; + } + + /** + * This method returns true if any of the activities within the process record are interesting + * to the user. See HistoryRecord.isInterestingToUserLocked() + */ + public boolean isInterestingToUserLocked() { + final int size = activities.size(); + for (int i = 0 ; i < size ; i++) { + HistoryRecord r = (HistoryRecord) activities.get(i); + if (r.isInterestingToUserLocked()) { + return true; + } + } + return false; + } + + public void stopFreezingAllLocked() { + int i = activities.size(); + while (i > 0) { + i--; + ((HistoryRecord)activities.get(i)).stopFreezingScreenLocked(true); + } + } + + public void requestPss() { + IApplicationThread localThread = thread; + if (localThread != null) { + try { + localThread.requestPss(); + } catch (RemoteException e) { + } + } + } + + public String toString() { + return "ProcessRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + pid + ":" + processName + "/" + info.uid + "}"; + } + + /* + * Return true if package has been added false if not + */ + public boolean addPackage(String pkg) { + if (!pkgList.contains(pkg)) { + pkgList.add(pkg); + return true; + } + return false; + } + + /* + * Delete all packages from list except the package indicated in info + */ + public void resetPackageList() { + pkgList.clear(); + pkgList.add(info.packageName); + } + + public String[] getPackageList() { + int size = pkgList.size(); + if (size == 0) { + return null; + } + String list[] = new String[size]; + pkgList.toArray(list); + return list; + } +} diff --git a/services/java/com/android/server/am/ReceiverList.java b/services/java/com/android/server/am/ReceiverList.java new file mode 100644 index 0000000..6ac527b --- /dev/null +++ b/services/java/com/android/server/am/ReceiverList.java @@ -0,0 +1,92 @@ +/* + * Copyright (C) 2006 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.am; + +import android.app.IIntentReceiver; +import android.content.Intent; +import android.os.Bundle; +import android.os.IBinder; +import android.os.RemoteException; + +import java.io.PrintWriter; +import java.util.ArrayList; + +/** + * A receiver object that has registered for one or more broadcasts. + * The ArrayList holds BroadcastFilter objects. + */ +class ReceiverList extends ArrayList<BroadcastFilter> + implements IBinder.DeathRecipient { + final ActivityManagerService owner; + public final IIntentReceiver receiver; + public final ProcessRecord app; + public final int pid; + public final int uid; + BroadcastRecord curBroadcast = null; + boolean linkedToDeath = false; + + ReceiverList(ActivityManagerService _owner, ProcessRecord _app, + int _pid, int _uid, IIntentReceiver _receiver) { + owner = _owner; + receiver = _receiver; + app = _app; + pid = _pid; + uid = _uid; + } + + // Want object identity, not the array identity we are inheriting. + public boolean equals(Object o) { + return this == o; + } + public int hashCode() { + return System.identityHashCode(this); + } + + public void binderDied() { + linkedToDeath = false; + owner.unregisterReceiver(receiver); + } + + void dumpLocal(PrintWriter pw, String prefix) { + pw.println(prefix + "receiver=IBinder " + + Integer.toHexString(System.identityHashCode(receiver.asBinder()))); + pw.println(prefix + "app=" + app + " pid=" + pid + " uid=" + uid); + pw.println(prefix + "curBroadcast=" + curBroadcast + + " linkedToDeath=" + linkedToDeath); + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + dumpLocal(pw, prefix); + String p2 = prefix + " "; + final int N = size(); + for (int i=0; i<N; i++) { + BroadcastFilter bf = get(i); + pw.println(prefix + "Filter #" + i + ": " + bf); + bf.dump(pw, p2); + } + } + + public String toString() { + return "ReceiverList{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + pid + " " + (app != null ? app.processName : "(unknown name)") + + "/" + uid + " client " + + Integer.toHexString(System.identityHashCode(receiver.asBinder())) + + "}"; + } +} diff --git a/services/java/com/android/server/am/ServiceRecord.java b/services/java/com/android/server/am/ServiceRecord.java new file mode 100644 index 0000000..4b90600 --- /dev/null +++ b/services/java/com/android/server/am/ServiceRecord.java @@ -0,0 +1,166 @@ +/* + * Copyright (C) 2006 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.am; + +import com.android.internal.os.BatteryStatsImpl; + +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ApplicationInfo; +import android.content.pm.ServiceInfo; +import android.os.Binder; +import android.os.IBinder; +import android.os.SystemClock; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; + +/** + * A running application service. + */ +class ServiceRecord extends Binder { + final BatteryStatsImpl.Uid.Pkg.Serv stats; + final ComponentName name; // service component. + final String shortName; // name.flattenToShortString(). + final Intent.FilterComparison intent; + // original intent used to find service. + final ServiceInfo serviceInfo; + // all information about the service. + final ApplicationInfo appInfo; + // information about service's app. + final String packageName; // the package implementing intent's component + final String processName; // process where this component wants to run + final String permission;// permission needed to access service + final String baseDir; // where activity source (resources etc) located + final String resDir; // where public activity source (public resources etc) located + final String dataDir; // where activity data should go + final boolean exported; // from ServiceInfo.exported + final Runnable restarter; // used to schedule retries of starting the service + final long createTime; // when this service was created + final HashMap<Intent.FilterComparison, IntentBindRecord> bindings + = new HashMap<Intent.FilterComparison, IntentBindRecord>(); + // All active bindings to the service. + final HashMap<IBinder, ConnectionRecord> connections + = new HashMap<IBinder, ConnectionRecord>(); + // IBinder -> ConnectionRecord of all bound clients + final List<Intent> startArgs = new ArrayList<Intent>(); + // start() arguments that haven't yet been delivered. + + ProcessRecord app; // where this service is running or null. + boolean isForeground; // asked to run as a foreground service? + long lastActivity; // last time there was some activity on the service. + boolean startRequested; // someone explicitly called start? + int lastStartId; // identifier of most recent start request. + int executeNesting; // number of outstanding operations keeping foreground. + long executingStart; // start time of last execute request. + int crashCount; // number of times proc has crashed with service running + int totalRestartCount; // number of times we have had to restart. + int restartCount; // number of restarts performed in a row. + long restartDelay; // delay until next restart attempt. + long restartTime; // time of last restart. + long nextRestartTime; // time when restartDelay will expire. + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "intent=" + intent.getIntent()); + pw.println(prefix + "packageName=" + packageName); + pw.println(prefix + "processName=" + processName); + pw.println(prefix + "permission=" + permission); + pw.println(prefix + "baseDir=" + baseDir+ " resDir=" + resDir + " dataDir=" + dataDir); + pw.println(prefix + "app=" + app); + pw.println(prefix + "isForeground=" + isForeground + + " lastActivity=" + lastActivity); + pw.println(prefix + "startRequested=" + startRequested + + " startId=" + lastStartId + + " executeNesting=" + executeNesting + + " executingStart=" + executingStart + + " crashCount=" + crashCount); + pw.println(prefix + "totalRestartCount=" + totalRestartCount + + " restartCount=" + restartCount + + " restartDelay=" + restartDelay + + " restartTime=" + restartTime + + " nextRestartTime=" + nextRestartTime); + if (bindings.size() > 0) { + pw.println(prefix + "Bindings:"); + Iterator<IntentBindRecord> it = bindings.values().iterator(); + while (it.hasNext()) { + IntentBindRecord b = it.next(); + pw.println(prefix + "Binding " + b); + b.dump(pw, prefix + " "); + } + } + if (connections.size() > 0) { + pw.println(prefix + "All Connections:"); + Iterator<ConnectionRecord> it = connections.values().iterator(); + while (it.hasNext()) { + ConnectionRecord c = it.next(); + pw.println(prefix + " " + c); + } + } + } + + ServiceRecord(BatteryStatsImpl.Uid.Pkg.Serv servStats, ComponentName name, + Intent.FilterComparison intent, ServiceInfo sInfo, Runnable restarter) { + this.stats = servStats; + this.name = name; + shortName = name.flattenToShortString(); + this.intent = intent; + serviceInfo = sInfo; + appInfo = sInfo.applicationInfo; + packageName = sInfo.applicationInfo.packageName; + processName = sInfo.processName; + permission = sInfo.permission; + baseDir = sInfo.applicationInfo.sourceDir; + resDir = sInfo.applicationInfo.publicSourceDir; + dataDir = sInfo.applicationInfo.dataDir; + exported = sInfo.exported; + this.restarter = restarter; + createTime = lastActivity = SystemClock.uptimeMillis(); + } + + public AppBindRecord retrieveAppBindingLocked(Intent intent, + ProcessRecord app) { + Intent.FilterComparison filter = new Intent.FilterComparison(intent); + IntentBindRecord i = bindings.get(filter); + if (i == null) { + i = new IntentBindRecord(this, filter); + bindings.put(filter, i); + } + AppBindRecord a = i.apps.get(app); + if (a != null) { + return a; + } + a = new AppBindRecord(this, i, app); + i.apps.put(app, a); + return a; + } + + public void resetRestartCounter() { + restartCount = 0; + restartDelay = 0; + restartTime = 0; + } + + public String toString() { + return "ServiceRecord{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + shortName + "}"; + } +} diff --git a/services/java/com/android/server/am/TaskRecord.java b/services/java/com/android/server/am/TaskRecord.java new file mode 100644 index 0000000..aab3736 --- /dev/null +++ b/services/java/com/android/server/am/TaskRecord.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2006 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.am; + +import android.content.ComponentName; +import android.content.Intent; +import android.content.pm.ActivityInfo; +import android.os.SystemClock; + +import java.io.PrintWriter; + +class TaskRecord { + final int taskId; // Unique identifier for this task. + final String affinity; // The affinity name for this task, or null. + final boolean clearOnBackground; // As per the original activity. + Intent intent; // The original intent that started the task. + Intent affinityIntent; // Intent of affinity-moved activity that started this task. + ComponentName origActivity; // The non-alias activity component of the intent. + ComponentName realActivity; // The actual activity component that started the task. + int numActivities; // Current number of activities in this task. + long lastActiveTime; // Last time this task was active, including sleep. + boolean rootWasReset; // True if the intent at the root of the task had + // the FLAG_ACTIVITY_RESET_TASK_IF_NEEDED flag. + + TaskRecord(int _taskId, ActivityInfo info, Intent _intent, + boolean _clearOnBackground) { + taskId = _taskId; + affinity = info.taskAffinity; + clearOnBackground = _clearOnBackground; + setIntent(_intent, info); + } + + void touchActiveTime() { + lastActiveTime = android.os.SystemClock.elapsedRealtime(); + } + + long getInactiveDuration() { + return android.os.SystemClock.elapsedRealtime() - lastActiveTime; + } + + void setIntent(Intent _intent, ActivityInfo info) { + if (info.targetActivity == null) { + intent = _intent; + realActivity = _intent != null ? _intent.getComponent() : null; + origActivity = null; + } else { + ComponentName targetComponent = new ComponentName( + info.packageName, info.targetActivity); + if (_intent != null) { + Intent targetIntent = new Intent(_intent); + targetIntent.setComponent(targetComponent); + intent = targetIntent; + realActivity = targetComponent; + origActivity = _intent.getComponent(); + } else { + intent = null; + realActivity = targetComponent; + origActivity = new ComponentName(info.packageName, info.name); + } + } + + if (intent != null && + (intent.getFlags()&Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED) != 0) { + // Once we are set to an Intent with this flag, we count this + // task as having a true root activity. + rootWasReset = true; + } + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + "clearOnBackground=" + clearOnBackground + + " numActivities=" + numActivities + + " rootWasReset=" + rootWasReset); + pw.println(prefix + "affinity=" + affinity); + pw.println(prefix + "intent=" + intent); + pw.println(prefix + "affinityIntent=" + affinityIntent); + pw.println(prefix + "origActivity=" + origActivity); + pw.println(prefix + "lastActiveTime=" + lastActiveTime + +" (inactive for " + (getInactiveDuration()/1000) + "s)"); + } + + public String toString() { + return "Task{" + taskId + " " + + (affinity != null ? affinity + : (intent != null ? intent.getComponent().flattenToShortString() + : affinityIntent != null ? affinityIntent.getComponent().flattenToShortString() : "??")) + + "}"; + } +} diff --git a/services/java/com/android/server/am/UriPermission.java b/services/java/com/android/server/am/UriPermission.java new file mode 100644 index 0000000..fb7a745 --- /dev/null +++ b/services/java/com/android/server/am/UriPermission.java @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2006 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.am; + +import android.content.Intent; +import android.net.Uri; + +import java.io.PrintWriter; +import java.util.HashSet; + +class UriPermission { + final int uid; + final Uri uri; + int modeFlags = 0; + int globalModeFlags = 0; + final HashSet<HistoryRecord> readActivities = new HashSet<HistoryRecord>(); + final HashSet<HistoryRecord> writeActivities = new HashSet<HistoryRecord>(); + + UriPermission(int _uid, Uri _uri) { + uid = _uid; + uri = _uri; + } + + void clearModes(int modeFlags) { + if ((modeFlags&Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) { + globalModeFlags &= ~Intent.FLAG_GRANT_READ_URI_PERMISSION; + modeFlags &= ~Intent.FLAG_GRANT_READ_URI_PERMISSION; + if (readActivities.size() > 0) { + for (HistoryRecord r : readActivities) { + r.readUriPermissions.remove(this); + if (r.readUriPermissions.size() == 0) { + r.readUriPermissions = null; + } + } + readActivities.clear(); + } + } + if ((modeFlags&Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) { + globalModeFlags &= ~Intent.FLAG_GRANT_WRITE_URI_PERMISSION; + modeFlags &= ~Intent.FLAG_GRANT_WRITE_URI_PERMISSION; + if (readActivities.size() > 0) { + for (HistoryRecord r : readActivities) { + r.writeUriPermissions.remove(this); + if (r.writeUriPermissions.size() == 0) { + r.writeUriPermissions = null; + } + } + readActivities.clear(); + } + } + } + + public String toString() { + return "UriPermission{" + + Integer.toHexString(System.identityHashCode(this)) + + " " + uri + "}"; + } + + void dump(PrintWriter pw, String prefix) { + pw.println(prefix + this); + pw.println(prefix + " modeFlags=0x" + Integer.toHexString(modeFlags) + + " uid=" + uid + + " globalModeFlags=0x" + + Integer.toHexString(globalModeFlags)); + pw.println(prefix + " readActivities=" + readActivities); + pw.println(prefix + " writeActivities=" + writeActivities); + } +} diff --git a/services/java/com/android/server/am/UsageStatsService.java b/services/java/com/android/server/am/UsageStatsService.java new file mode 100755 index 0000000..3922f39 --- /dev/null +++ b/services/java/com/android/server/am/UsageStatsService.java @@ -0,0 +1,532 @@ +/* + * Copyright (C) 2006-2007 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.am; + +import com.android.internal.app.IUsageStats; +import android.content.ComponentName; +import android.content.Context; +import android.os.Binder; +import android.os.IBinder; +import com.android.internal.os.PkgUsageStats; +import android.os.Parcel; +import android.os.Process; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.util.Log; +import java.io.File; +import java.io.FileDescriptor; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Collections; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * This service collects the statistics associated with usage + * of various components, like when a particular package is launched or + * paused and aggregates events like number of time a component is launched + * total duration of a component launch. + */ +public final class UsageStatsService extends IUsageStats.Stub { + public static final String SERVICE_NAME = "usagestats"; + private static final boolean localLOGV = false; + private static final String TAG = "UsageStats"; + static IUsageStats sService; + private Context mContext; + // structure used to maintain statistics since the last checkin. + final private Map<String, PkgUsageStatsExtended> mStats; + // Lock to update package stats. Methods suffixed by SLOCK should invoked with + // this lock held + final Object mStatsLock; + // Lock to write to file. Methods suffixed by FLOCK should invoked with + // this lock held. + final Object mFileLock; + // Order of locks is mFileLock followed by mStatsLock to avoid deadlocks + private String mResumedPkg; + private File mFile; + //private File mBackupFile; + private long mLastWriteRealTime; + private int _FILE_WRITE_INTERVAL = 30*60*1000; //ms + private static final String _PREFIX_DELIMIT="."; + private String mFilePrefix; + private Calendar mCal; + private static final int _MAX_NUM_FILES = 10; + private long mLastTime; + + private class PkgUsageStatsExtended { + int mLaunchCount; + long mUsageTime; + long mPausedTime; + long mResumedTime; + + PkgUsageStatsExtended() { + mLaunchCount = 0; + mUsageTime = 0; + } + void updateResume() { + mLaunchCount ++; + mResumedTime = SystemClock.elapsedRealtime(); + } + void updatePause() { + mPausedTime = SystemClock.elapsedRealtime(); + mUsageTime += (mPausedTime - mResumedTime); + } + void clear() { + mLaunchCount = 0; + mUsageTime = 0; + } + } + + UsageStatsService(String fileName) { + mStats = new HashMap<String, PkgUsageStatsExtended>(); + mStatsLock = new Object(); + mFileLock = new Object(); + mFilePrefix = fileName; + mCal = Calendar.getInstance(); + // Update current stats which are binned by date + String uFileName = getCurrentDateStr(mFilePrefix); + mFile = new File(uFileName); + readStatsFromFile(); + mLastWriteRealTime = SystemClock.elapsedRealtime(); + mLastTime = new Date().getTime(); + } + + /* + * Utility method to convert date into string. + */ + private String getCurrentDateStr(String prefix) { + mCal.setTime(new Date()); + StringBuilder sb = new StringBuilder(); + if (prefix != null) { + sb.append(prefix); + sb.append("."); + } + int mm = mCal.get(Calendar.MONTH) - Calendar.JANUARY +1; + if (mm < 10) { + sb.append("0"); + } + sb.append(mm); + int dd = mCal.get(Calendar.DAY_OF_MONTH); + if (dd < 10) { + sb.append("0"); + } + sb.append(dd); + sb.append(mCal.get(Calendar.YEAR)); + return sb.toString(); + } + + private Parcel getParcelForFile(File file) throws IOException { + FileInputStream stream = new FileInputStream(file); + byte[] raw = readFully(stream); + Parcel in = Parcel.obtain(); + in.unmarshall(raw, 0, raw.length); + in.setDataPosition(0); + stream.close(); + return in; + } + + private void readStatsFromFile() { + File newFile = mFile; + synchronized (mFileLock) { + try { + if (newFile.exists()) { + readStatsFLOCK(newFile); + } else { + // Check for file limit before creating a new file + checkFileLimitFLOCK(); + newFile.createNewFile(); + } + } catch (IOException e) { + Log.w(TAG,"Error : " + e + " reading data from file:" + newFile); + } + } + } + + private void readStatsFLOCK(File file) throws IOException { + Parcel in = getParcelForFile(file); + while (in.dataAvail() > 0) { + String pkgName = in.readString(); + PkgUsageStatsExtended pus = new PkgUsageStatsExtended(); + pus.mLaunchCount = in.readInt(); + pus.mUsageTime = in.readLong(); + synchronized (mStatsLock) { + mStats.put(pkgName, pus); + } + } + } + + private ArrayList<String> getUsageStatsFileListFLOCK() { + File dir = getUsageFilesDir(); + if (dir == null) { + Log.w(TAG, "Couldnt find writable directory for usage stats file"); + return null; + } + // Check if there are too many files in the system and delete older files + String fList[] = dir.list(); + if (fList == null) { + return null; + } + File pre = new File(mFilePrefix); + String filePrefix = pre.getName(); + // file name followed by dot + int prefixLen = filePrefix.length()+1; + ArrayList<String> fileList = new ArrayList<String>(); + for (String file : fList) { + int index = file.indexOf(filePrefix); + if (index == -1) { + continue; + } + if (file.endsWith(".bak")) { + continue; + } + fileList.add(file); + } + return fileList; + } + + private File getUsageFilesDir() { + if (mFilePrefix == null) { + return null; + } + File pre = new File(mFilePrefix); + return new File(pre.getParent()); + } + + private void checkFileLimitFLOCK() { + File dir = getUsageFilesDir(); + if (dir == null) { + Log.w(TAG, "Couldnt find writable directory for usage stats file"); + return; + } + // Get all usage stats output files + ArrayList<String> fileList = getUsageStatsFileListFLOCK(); + if (fileList == null) { + // Strange but we dont have to delete any thing + return; + } + int count = fileList.size(); + if (count <= _MAX_NUM_FILES) { + return; + } + // Sort files + Collections.sort(fileList); + count -= _MAX_NUM_FILES; + // Delete older files + for (int i = 0; i < count; i++) { + String fileName = fileList.get(i); + File file = new File(dir, fileName); + Log.i(TAG, "Deleting file : "+fileName); + file.delete(); + } + } + + private void writeStatsToFile() { + synchronized (mFileLock) { + long currTime = new Date().getTime(); + boolean dayChanged = ((currTime - mLastTime) >= (24*60*60*1000)); + long currRealTime = SystemClock.elapsedRealtime(); + if (((currRealTime-mLastWriteRealTime) < _FILE_WRITE_INTERVAL) && + (!dayChanged)) { + // wait till the next update + return; + } + // Get the most recent file + String todayStr = getCurrentDateStr(mFilePrefix); + // Copy current file to back up + File backupFile = new File(mFile.getPath() + ".bak"); + mFile.renameTo(backupFile); + try { + checkFileLimitFLOCK(); + mFile.createNewFile(); + // Write mStats to file + writeStatsFLOCK(); + mLastWriteRealTime = currRealTime; + mLastTime = currTime; + if (dayChanged) { + // clear stats + synchronized (mStats) { + mStats.clear(); + } + mFile = new File(todayStr); + } + // Delete the backup file + if (backupFile != null) { + backupFile.delete(); + } + } catch (IOException e) { + Log.w(TAG, "Failed writing stats to file:" + mFile); + if (backupFile != null) { + backupFile.renameTo(mFile); + } + } + } + } + + private void writeStatsFLOCK() throws IOException { + FileOutputStream stream = new FileOutputStream(mFile); + Parcel out = Parcel.obtain(); + writeStatsToParcelFLOCK(out); + stream.write(out.marshall()); + out.recycle(); + stream.flush(); + stream.close(); + } + + private void writeStatsToParcelFLOCK(Parcel out) { + synchronized (mStatsLock) { + Set<String> keys = mStats.keySet(); + for (String key : keys) { + PkgUsageStatsExtended pus = mStats.get(key); + out.writeString(key); + out.writeInt(pus.mLaunchCount); + out.writeLong(pus.mUsageTime); + } + } + } + + public void publish(Context context) { + mContext = context; + ServiceManager.addService(SERVICE_NAME, asBinder()); + } + + public static IUsageStats getService() { + if (sService != null) { + return sService; + } + IBinder b = ServiceManager.getService(SERVICE_NAME); + sService = asInterface(b); + return sService; + } + + public void noteResumeComponent(ComponentName componentName) { + enforceCallingPermission(); + String pkgName; + if ((componentName == null) || + ((pkgName = componentName.getPackageName()) == null)) { + return; + } + if ((mResumedPkg != null) && (mResumedPkg.equalsIgnoreCase(pkgName))) { + // Moving across activities in same package. just return + return; + } + if (localLOGV) Log.i(TAG, "started component:"+pkgName); + synchronized (mStatsLock) { + PkgUsageStatsExtended pus = mStats.get(pkgName); + if (pus == null) { + pus = new PkgUsageStatsExtended(); + mStats.put(pkgName, pus); + } + pus.updateResume(); + } + mResumedPkg = pkgName; + } + + public void notePauseComponent(ComponentName componentName) { + enforceCallingPermission(); + String pkgName; + if ((componentName == null) || + ((pkgName = componentName.getPackageName()) == null)) { + return; + } + if ((mResumedPkg == null) || (!pkgName.equalsIgnoreCase(mResumedPkg))) { + Log.w(TAG, "Something wrong here, Didn't expect "+pkgName+" to be paused"); + return; + } + if (localLOGV) Log.i(TAG, "paused component:"+pkgName); + synchronized (mStatsLock) { + PkgUsageStatsExtended pus = mStats.get(pkgName); + if (pus == null) { + // Weird some error here + Log.w(TAG, "No package stats for pkg:"+pkgName); + return; + } + pus.updatePause(); + } + // Persist data to file + writeStatsToFile(); + } + + public void enforceCallingPermission() { + if (Binder.getCallingPid() == Process.myPid()) { + return; + } + mContext.enforcePermission(android.Manifest.permission.UPDATE_DEVICE_STATS, + Binder.getCallingPid(), Binder.getCallingUid(), null); + } + + public PkgUsageStats getPkgUsageStats(ComponentName componentName) { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.PACKAGE_USAGE_STATS, null); + String pkgName; + if ((componentName == null) || + ((pkgName = componentName.getPackageName()) == null)) { + return null; + } + synchronized (mStatsLock) { + PkgUsageStatsExtended pus = mStats.get(pkgName); + if (pus == null) { + return null; + } + return new PkgUsageStats(pkgName, pus.mLaunchCount, pus.mUsageTime); + } + } + + public PkgUsageStats[] getAllPkgUsageStats() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.PACKAGE_USAGE_STATS, null); + synchronized (mStatsLock) { + Set<String> keys = mStats.keySet(); + int size = keys.size(); + if (size <= 0) { + return null; + } + PkgUsageStats retArr[] = new PkgUsageStats[size]; + int i = 0; + for (String key: keys) { + PkgUsageStatsExtended pus = mStats.get(key); + retArr[i] = new PkgUsageStats(key, pus.mLaunchCount, pus.mUsageTime); + i++; + } + return retArr; + } + } + + static byte[] readFully(FileInputStream stream) throws java.io.IOException { + int pos = 0; + int avail = stream.available(); + byte[] data = new byte[avail]; + while (true) { + int amt = stream.read(data, pos, data.length-pos); + if (amt <= 0) { + return data; + } + pos += amt; + avail = stream.available(); + if (avail > data.length-pos) { + byte[] newData = new byte[pos+avail]; + System.arraycopy(data, 0, newData, 0, pos); + data = newData; + } + } + } + + private void collectDumpInfoFLOCK(PrintWriter pw, String[] args) { + List<String> fileList = getUsageStatsFileListFLOCK(); + if (fileList == null) { + return; + } + final boolean isCheckinRequest = scanArgs(args, "-c"); + Collections.sort(fileList); + File usageFile = new File(mFilePrefix); + String dirName = usageFile.getParent(); + File dir = new File(dirName); + String filePrefix = usageFile.getName(); + // file name followed by dot + int prefixLen = filePrefix.length()+1; + String todayStr = getCurrentDateStr(null); + for (String file : fileList) { + File dFile = new File(dir, file); + String dateStr = file.substring(prefixLen); + try { + Parcel in = getParcelForFile(dFile); + collectDumpInfoFromParcelFLOCK(in, pw, dateStr, isCheckinRequest); + if (isCheckinRequest && !todayStr.equalsIgnoreCase(dateStr)) { + // Delete old file after collecting info only for checkin requests + dFile.delete(); + } + } catch (FileNotFoundException e) { + Log.w(TAG, "Failed with "+e+" when collecting dump info from file : " + file); + return; + } catch (IOException e) { + Log.w(TAG, "Failed with "+e+" when collecting dump info from file : "+file); + } + } + } + + private void collectDumpInfoFromParcelFLOCK(Parcel in, PrintWriter pw, + String date, boolean isCheckinRequest) { + StringBuilder sb = new StringBuilder(); + sb.append("Date:"); + sb.append(date); + boolean first = true; + while (in.dataAvail() > 0) { + String pkgName = in.readString(); + int launchCount = in.readInt(); + long usageTime = in.readLong(); + if (isCheckinRequest) { + if (!first) { + sb.append(","); + } + sb.append(pkgName); + sb.append(","); + sb.append(launchCount); + sb.append(","); + sb.append(usageTime); + sb.append("ms"); + } else { + if (first) { + sb.append("\n"); + } + sb.append("pkg="); + sb.append(pkgName); + sb.append(", launchCount="); + sb.append(launchCount); + sb.append(", usageTime="); + sb.append(usageTime); + sb.append(" ms\n"); + } + first = false; + } + pw.write(sb.toString()); + } + + /** + * Searches array of arguments for the specified string + * @param args array of argument strings + * @param value value to search for + * @return true if the value is contained in the array + */ + private static boolean scanArgs(String[] args, String value) { + if (args != null) { + for (String arg : args) { + if (value.equals(arg)) { + return true; + } + } + } + return false; + } + + @Override + /* + * The data persisted to file is parsed and the stats are computed. + */ + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + synchronized (mFileLock) { + collectDumpInfoFLOCK(pw, args); + } + } + +} diff --git a/services/java/com/android/server/am/package.html b/services/java/com/android/server/am/package.html new file mode 100755 index 0000000..c9f96a6 --- /dev/null +++ b/services/java/com/android/server/am/package.html @@ -0,0 +1,5 @@ +<body> + +{@hide} + +</body> diff --git a/services/java/com/android/server/status/AnimatedImageView.java b/services/java/com/android/server/status/AnimatedImageView.java new file mode 100644 index 0000000..cd581c4 --- /dev/null +++ b/services/java/com/android/server/status/AnimatedImageView.java @@ -0,0 +1,69 @@ +package com.android.server.status; + +import android.content.Context; +import android.graphics.drawable.AnimationDrawable; +import android.graphics.drawable.Drawable; +import android.util.AttributeSet; +import android.widget.ImageView; +import android.widget.RemoteViews.RemoteView; + +@RemoteView +public class AnimatedImageView extends ImageView { + AnimationDrawable mAnim; + boolean mAttached; + + public AnimatedImageView(Context context) { + super(context); + } + + public AnimatedImageView(Context context, AttributeSet attrs) { + super(context, attrs); + } + + private void updateAnim() { + Drawable drawable = getDrawable(); + if (mAttached && mAnim != null) { + mAnim.stop(); + } + if (drawable instanceof AnimationDrawable) { + mAnim = (AnimationDrawable)drawable; + if (mAttached) { + mAnim.start(); + } + } else { + mAnim = null; + } + } + + @Override + public void setImageDrawable(Drawable drawable) { + super.setImageDrawable(drawable); + updateAnim(); + } + + @Override + @android.view.RemotableViewMethod + public void setImageResource(int resid) { + super.setImageResource(resid); + updateAnim(); + } + + @Override + public void onAttachedToWindow() { + super.onAttachedToWindow(); + if (mAnim != null) { + mAnim.start(); + } + mAttached = true; + } + + @Override + public void onDetachedFromWindow() { + super.onDetachedFromWindow(); + if (mAnim != null) { + mAnim.stop(); + } + mAttached = false; + } +} + diff --git a/services/java/com/android/server/status/CloseDragHandle.java b/services/java/com/android/server/status/CloseDragHandle.java new file mode 100644 index 0000000..fabf2ba --- /dev/null +++ b/services/java/com/android/server/status/CloseDragHandle.java @@ -0,0 +1,35 @@ +package com.android.server.status; + +import android.content.Context; +import android.util.AttributeSet; +import android.view.MotionEvent; +import android.widget.LinearLayout; + + +public class CloseDragHandle extends LinearLayout { + StatusBarService mService; + + public CloseDragHandle(Context context, AttributeSet attrs) { + super(context, attrs); + } + + /** + * Ensure that, if there is no target under us to receive the touch, + * that we process it ourself. This makes sure that onInterceptTouchEvent() + * is always called for the entire gesture. + */ + @Override + public boolean onTouchEvent(MotionEvent event) { + if (event.getAction() != MotionEvent.ACTION_DOWN) { + mService.interceptTouchEvent(event); + } + return true; + } + + @Override + public boolean onInterceptTouchEvent(MotionEvent event) { + return mService.interceptTouchEvent(event) + ? true : super.onInterceptTouchEvent(event); + } +} + diff --git a/services/java/com/android/server/status/DateView.java b/services/java/com/android/server/status/DateView.java new file mode 100644 index 0000000..7c44d67 --- /dev/null +++ b/services/java/com/android/server/status/DateView.java @@ -0,0 +1,73 @@ +package com.android.server.status; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.text.format.DateFormat; +import android.util.AttributeSet; +import android.util.Log; +import android.widget.TextView; +import android.view.MotionEvent; + +import java.util.Date; + +public final class DateView extends TextView { + private static final String TAG = "DateView"; + + private boolean mUpdating = false; + + private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (action.equals(Intent.ACTION_TIME_TICK) + || action.equals(Intent.ACTION_TIMEZONE_CHANGED)) { + updateClock(); + } + } + }; + + public DateView(Context context, AttributeSet attrs) { + super(context, attrs); + } + + @Override + protected void onAttachedToWindow() { + super.onAttachedToWindow(); + } + + @Override + protected void onDetachedFromWindow() { + super.onDetachedFromWindow(); + setUpdates(false); + } + + @Override + protected int getSuggestedMinimumWidth() { + // makes the large background bitmap not force us to full width + return 0; + } + + private final void updateClock() { + Date now = new Date(); + setText(DateFormat.getLongDateFormat(getContext()).format(now)); + } + + void setUpdates(boolean update) { + if (update != mUpdating) { + mUpdating = update; + if (update) { + // Register for Intent broadcasts for the clock and battery + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_TIME_TICK); + filter.addAction(Intent.ACTION_TIMEZONE_CHANGED); + mContext.registerReceiver(mIntentReceiver, filter, null, null); + updateClock(); + } else { + mContext.unregisterReceiver(mIntentReceiver); + } + } + } +} + diff --git a/services/java/com/android/server/status/ExpandedView.java b/services/java/com/android/server/status/ExpandedView.java new file mode 100644 index 0000000..d0f14cb --- /dev/null +++ b/services/java/com/android/server/status/ExpandedView.java @@ -0,0 +1,61 @@ +package com.android.server.status; + +import android.content.Context; +import android.util.AttributeSet; +import android.view.Display; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.WindowManager; +import android.widget.LinearLayout; +import android.util.Log; + + +public class ExpandedView extends LinearLayout { + final Display mDisplay; + StatusBarService mService; + boolean mTracking; + int mStartX, mStartY; + int mMaxHeight = 0; + int mPrevHeight = -1; + + public ExpandedView(Context context, AttributeSet attrs) { + super(context, attrs); + mDisplay = ((WindowManager)context.getSystemService( + Context.WINDOW_SERVICE)).getDefaultDisplay(); + } + + @Override + protected void onFinishInflate() { + super.onFinishInflate(); + } + + /** We want to shrink down to 0, and ignore the background. */ + @Override + public int getSuggestedMinimumHeight() { + return 0; + } + + @Override + protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { + super.onMeasure(widthMeasureSpec, + MeasureSpec.makeMeasureSpec(mMaxHeight, MeasureSpec.AT_MOST)); + } + + @Override + protected void onLayout(boolean changed, int left, int top, int right, int bottom) { + super.onLayout(changed, left, top, right, bottom); + int height = bottom - top; + if (height != mPrevHeight) { + //Log.d(StatusBarService.TAG, "height changed old=" + mPrevHeight + " new=" + height); + mPrevHeight = height; + mService.updateExpandedViewPos(StatusBarService.EXPANDED_LEAVE_ALONE); + } + } + + void setMaxHeight(int h) { + if (h != mMaxHeight) { + mMaxHeight = h; + requestLayout(); + } + } +} diff --git a/services/java/com/android/server/status/FixedSizeDrawable.java b/services/java/com/android/server/status/FixedSizeDrawable.java new file mode 100644 index 0000000..fe5abca --- /dev/null +++ b/services/java/com/android/server/status/FixedSizeDrawable.java @@ -0,0 +1,50 @@ +package com.android.server.status; + +import android.graphics.drawable.Drawable; +import android.graphics.Canvas; +import android.graphics.ColorFilter; +import android.graphics.Rect; +import android.util.Log; + +class FixedSizeDrawable extends Drawable { + Drawable mDrawable; + int mLeft; + int mTop; + int mRight; + int mBottom; + + FixedSizeDrawable(Drawable that) { + mDrawable = that; + } + + public void setFixedBounds(int l, int t, int r, int b) { + mLeft = l; + mTop = t; + mRight = r; + mBottom = b; + } + + public void setBounds(Rect bounds) { + mDrawable.setBounds(mLeft, mTop, mRight, mBottom); + } + + public void setBounds(int l, int t, int r, int b) { + mDrawable.setBounds(mLeft, mTop, mRight, mBottom); + } + + public void draw(Canvas canvas) { + mDrawable.draw(canvas); + } + + public int getOpacity() { + return mDrawable.getOpacity(); + } + + public void setAlpha(int alpha) { + mDrawable.setAlpha(alpha); + } + + public void setColorFilter(ColorFilter cf) { + mDrawable.setColorFilter(cf); + } +} diff --git a/services/java/com/android/server/status/IconData.java b/services/java/com/android/server/status/IconData.java new file mode 100644 index 0000000..8a61eb5 --- /dev/null +++ b/services/java/com/android/server/status/IconData.java @@ -0,0 +1,106 @@ +package com.android.server.status; + +import android.util.Log; + +public class IconData { + /** + * Indicates ths item represents a piece of text. + */ + public static final int TEXT = 1; + + /** + * Indicates ths item represents an icon. + */ + public static final int ICON = 2; + + /** + * The type of this item. One of TEXT, ICON, or LEVEL_ICON. + */ + public int type; + + /** + * The slot that this icon will be in if it is not a notification + */ + public String slot; + + /** + * The package containting the icon to draw for this item. Valid if this is + * an ICON type. + */ + public String iconPackage; + + /** + * The icon to draw for this item. Valid if this is an ICON type. + */ + public int iconId; + + /** + * The level associated with the icon. Valid if this is a LEVEL_ICON type. + */ + public int iconLevel; + + /** + * The "count" number. + */ + public int number; + + /** + * The text associated with the icon. Valid if this is a TEXT type. + */ + public CharSequence text; + + private IconData() { + } + + public static IconData makeIcon(String slot, + String iconPackage, int iconId, int iconLevel, int number) { + IconData data = new IconData(); + data.type = ICON; + data.slot = slot; + data.iconPackage = iconPackage; + data.iconId = iconId; + data.iconLevel = iconLevel; + data.number = number; + return data; + } + + public static IconData makeText(String slot, CharSequence text) { + IconData data = new IconData(); + data.type = TEXT; + data.slot = slot; + data.text = text; + return data; + } + + public void copyFrom(IconData that) { + this.type = that.type; + this.slot = that.slot; + this.iconPackage = that.iconPackage; + this.iconId = that.iconId; + this.iconLevel = that.iconLevel; + this.number = that.number; + this.text = that.text; // should we clone this? + } + + public IconData clone() { + IconData that = new IconData(); + that.copyFrom(this); + return that; + } + + public String toString() { + if (this.type == TEXT) { + return "IconData(slot=" + (this.slot != null ? "'" + this.slot + "'" : "null") + + " text='" + this.text + "')"; + } + else if (this.type == ICON) { + return "IconData(slot=" + (this.slot != null ? "'" + this.slot + "'" : "null") + + " package=" + this.iconPackage + + " iconId=" + Integer.toHexString(this.iconId) + + " iconLevel=" + this.iconLevel + ")"; + } + else { + return "IconData(type=" + type + ")"; + } + } +} diff --git a/services/java/com/android/server/status/IconMerger.java b/services/java/com/android/server/status/IconMerger.java new file mode 100644 index 0000000..37fdbfb --- /dev/null +++ b/services/java/com/android/server/status/IconMerger.java @@ -0,0 +1,119 @@ +package com.android.server.status; + +import android.content.Context; +import android.os.Handler; +import android.util.AttributeSet; +import android.view.View; +import android.widget.LinearLayout; + + +public class IconMerger extends LinearLayout { + private static final boolean SPEW = false; + + StatusBarService service; + StatusBarIcon moreIcon; + + public IconMerger(Context context, AttributeSet attrs) { + super(context, attrs); + } + + @Override + protected void onLayout(boolean changed, int l, int t, int r, int b) { + super.onLayout(changed, l, t, r, b); + + final int maxWidth = r - l; + final int N = getChildCount(); + int i; + + // get the rightmost one, and see if we even need to do anything + int fitRight = -1; + for (i=N-1; i>=0; i--) { + final View child = getChildAt(i); + if (child != null && child.getVisibility() != GONE) { + fitRight = child.getRight(); + break; + } + } + + // find the first visible one that isn't the more icon + View moreView = null; + int fitLeft = -1; + int startIndex = -1; + for (i=0; i<N; i++) { + final View child = getChildAt(i); + if (com.android.internal.R.drawable.stat_notify_more == child.getId()) { + moreView = child; + startIndex = i+1; + } + else if (child != null && child.getVisibility() != GONE) { + fitLeft = child.getLeft(); + break; + } + } + + if (moreView == null || startIndex < 0) { + throw new RuntimeException("Status Bar / IconMerger moreView == null"); + } + + // if it fits without the more icon, then hide the more icon and update fitLeft + // so everything gets pushed left + int adjust = 0; + if (fitRight - fitLeft <= maxWidth) { + adjust = fitLeft - moreView.getLeft(); + fitLeft -= adjust; + fitRight -= adjust; + moreView.layout(0, moreView.getTop(), 0, moreView.getBottom()); + } + int extra = fitRight - r; + int shift = -1; + + int breakingPoint = fitLeft + extra + adjust; + int number = 0; + for (i=startIndex; i<N; i++) { + final View child = getChildAt(i); + if (child != null && child.getVisibility() != GONE) { + int childLeft = child.getLeft(); + int childRight = child.getRight(); + if (childLeft < breakingPoint) { + // hide this one + child.layout(0, child.getTop(), 0, child.getBottom()); + int n = this.service.getIconNumberForView(child); + if (n == 0) { + number += 1; + } else if (n > 0) { + number += n; + } + } else { + // decide how much to shift by + if (shift < 0) { + shift = childLeft - fitLeft; + } + // shift this left by shift + child.layout(childLeft-shift, child.getTop(), + childRight-shift, child.getBottom()); + } + } + } + + // BUG: Updating the text during the layout here doesn't seem to cause + // the view to be redrawn fully. The text view gets resized correctly, but the + // text contents aren't drawn properly. To work around this, we post a message + // and provide the value later. We're the only one changing this value show it + // should be ordered correctly. + if (false) { + this.moreIcon.update(number); + } else { + mBugWorkaroundNumber = number; + mBugWorkaroundHandler.post(mBugWorkaroundRunnable); + } + } + + private int mBugWorkaroundNumber; + private Handler mBugWorkaroundHandler = new Handler(); + private Runnable mBugWorkaroundRunnable = new Runnable() { + public void run() { + IconMerger.this.moreIcon.update(mBugWorkaroundNumber); + IconMerger.this.moreIcon.view.invalidate(); + } + }; +} diff --git a/services/java/com/android/server/status/LatestItemView.java b/services/java/com/android/server/status/LatestItemView.java new file mode 100644 index 0000000..a47f6ad --- /dev/null +++ b/services/java/com/android/server/status/LatestItemView.java @@ -0,0 +1,18 @@ +package com.android.server.status; + +import android.content.Context; +import android.util.AttributeSet; +import android.util.Log; +import android.view.MotionEvent; +import android.widget.FrameLayout; + +public class LatestItemView extends FrameLayout { + + public LatestItemView(Context context, AttributeSet attrs) { + super(context, attrs); + } + + public boolean dispatchTouchEvent(MotionEvent ev) { + return onTouchEvent(ev); + } +} diff --git a/services/java/com/android/server/status/NotificationData.java b/services/java/com/android/server/status/NotificationData.java new file mode 100644 index 0000000..63a7d70 --- /dev/null +++ b/services/java/com/android/server/status/NotificationData.java @@ -0,0 +1,30 @@ +package com.android.server.status; + +import android.app.PendingIntent; +import android.widget.RemoteViews; + +public class NotificationData { + public String pkg; + public int id; + public CharSequence tickerText; + + public long when; + public boolean ongoingEvent; + public boolean clearable; + + public RemoteViews contentView; + public PendingIntent contentIntent; + + public PendingIntent deleteIntent; + + public NotificationData() { + } + + public String toString() { + return "NotificationData(package=" + pkg + " tickerText=" + tickerText + + " ongoingEvent=" + ongoingEvent + " contentIntent=" + contentIntent + + " deleteIntent=" + deleteIntent + + " clearable=" + clearable + + " contentView=" + contentView + " when=" + when + ")"; + } +} diff --git a/services/java/com/android/server/status/NotificationLinearLayout.java b/services/java/com/android/server/status/NotificationLinearLayout.java new file mode 100644 index 0000000..ac2e44d --- /dev/null +++ b/services/java/com/android/server/status/NotificationLinearLayout.java @@ -0,0 +1,13 @@ +package com.android.server.status; + +import android.content.Context; +import android.util.AttributeSet; +import android.widget.LinearLayout; + + +public class NotificationLinearLayout extends LinearLayout { + public NotificationLinearLayout(Context context, AttributeSet attrs) { + super(context, attrs); + } +} + diff --git a/services/java/com/android/server/status/NotificationViewList.java b/services/java/com/android/server/status/NotificationViewList.java new file mode 100644 index 0000000..6229292 --- /dev/null +++ b/services/java/com/android/server/status/NotificationViewList.java @@ -0,0 +1,223 @@ +package com.android.server.status; + +import android.os.IBinder; +import android.util.Log; +import android.view.View; +import java.util.ArrayList; + +class NotificationViewList { + private ArrayList<StatusBarNotification> mOngoing = new ArrayList(); + private ArrayList<StatusBarNotification> mLatest = new ArrayList(); + + NotificationViewList() { + } + + private static final int indexInList(ArrayList<StatusBarNotification> list, NotificationData n){ + final int N = list.size(); + for (int i=0; i<N; i++) { + StatusBarNotification that = list.get(i); + if (that.data == n) { + return i; + } + } + return -1; + } + + int getIconIndex(NotificationData n) { + final int ongoingSize = mOngoing.size(); + final int latestSize = mLatest.size(); + if (n.ongoingEvent) { + int index = indexInList(mOngoing, n); + if (index >= 0) { + return latestSize + index + 1; + } else { + return -1; + } + } else { + return indexInList(mLatest, n) + 1; + } + } + + void remove(StatusBarNotification notification) { + NotificationData n = notification.data; + int index; + index = indexInList(mOngoing, n); + if (index >= 0) { + mOngoing.remove(index); + return; + } + index = indexInList(mLatest, n); + if (index >= 0) { + mLatest.remove(index); + return; + } + } + + ArrayList<StatusBarNotification> notificationsForPackage(String packageName) { + ArrayList<StatusBarNotification> list = new ArrayList<StatusBarNotification>(); + int N = mOngoing.size(); + for (int i=0; i<N; i++) { + if (matchPackage(mOngoing.get(i), packageName)) { + list.add(mOngoing.get(i)); + } + } + N = mLatest.size(); + for (int i=0; i<N; i++) { + if (matchPackage(mLatest.get(i), packageName)) { + list.add(mLatest.get(i)); + } + } + return list; + } + + private final boolean matchPackage(StatusBarNotification snb, String packageName) { + if (snb.data.contentIntent != null) { + if (snb.data.contentIntent.getTargetPackage().equals(packageName)) { + return true; + } + } else if (snb.data.pkg != null && snb.data.pkg.equals(packageName)) { + return true; + } + return false; + } + + private static final int indexForKey(ArrayList<StatusBarNotification> list, IBinder key) { + final int N = list.size(); + for (int i=0; i<N; i++) { + if (list.get(i).key == key) { + return i; + } + } + return -1; + } + + StatusBarNotification get(IBinder key) { + int index; + index = indexForKey(mOngoing, key); + if (index >= 0) { + return mOngoing.get(index); + } + index = indexForKey(mLatest, key); + if (index >= 0) { + return mLatest.get(index); + } + return null; + } + + // gets the index of the notification in its expanded parent view + int getExpandedIndex(StatusBarNotification notification) { + ArrayList<StatusBarNotification> list = notification.data.ongoingEvent ? mOngoing : mLatest; + return list.size() - indexForKey(list, notification.key) - 1; + } + + void clearViews() { + int N = mOngoing.size(); + for (int i=0; i<N; i++) { + mOngoing.get(i).view = null; + } + N = mLatest.size(); + for (int i=0; i<N; i++) { + mLatest.get(i).view = null; + } + } + + int ongoingCount() { + return mOngoing.size(); + } + + int latestCount() { + return mLatest.size(); + } + + StatusBarNotification getOngoing(int index) { + return mOngoing.get(index); + } + + StatusBarNotification getLatest(int index) { + return mLatest.get(index); + } + + int size() { + return mOngoing.size() + mLatest.size(); + } + + void add(StatusBarNotification notification) { + ArrayList<StatusBarNotification> list = notification.data.ongoingEvent ? mOngoing : mLatest; + long when = notification.data.when; + final int N = list.size(); + int index = N; + for (int i=0; i<N; i++) { + StatusBarNotification that = list.get(i); + if (that.data.when > when) { + index = i; + break; + } + } + list.add(index, notification); + + if (StatusBarService.SPEW) { + String s = ""; + for (int i=0; i<mOngoing.size(); i++) { + StatusBarNotification that = mOngoing.get(i); + if (that.key == notification.key) { + s += "["; + } + s += that.data.when; + if (that.key == notification.key) { + s += "]"; + } + s += " "; + } + Log.d(StatusBarService.TAG, "NotificationViewList ongoing index=" + index + ": " + s); + + s = ""; + for (int i=0; i<mLatest.size(); i++) { + StatusBarNotification that = mLatest.get(i); + if (that.key == notification.key) { + s += "["; + } + s += that.data.when; + if (that.key == notification.key) { + s += "]"; + } + s += " "; + } + Log.d(StatusBarService.TAG, "NotificationViewList latest index=" + index + ": " + s); + } + } + + StatusBarNotification get(View view) { + int N = mOngoing.size(); + for (int i=0; i<N; i++) { + StatusBarNotification notification = mOngoing.get(i); + View v = notification.view; + if (v == view) { + return notification; + } + } + N = mLatest.size(); + for (int i=0; i<N; i++) { + StatusBarNotification notification = mLatest.get(i); + View v = notification.view; + if (v == view) { + return notification; + } + } + return null; + } + + void update(StatusBarNotification notification) { + remove(notification); + add(notification); + } + + boolean hasClearableItems() { + int N = mLatest.size(); + for (int i=0; i<N; i++) { + if (mLatest.get(i).data.clearable) { + return true; + } + } + return false; + } +} diff --git a/services/java/com/android/server/status/StatusBarException.java b/services/java/com/android/server/status/StatusBarException.java new file mode 100644 index 0000000..8e93ca7 --- /dev/null +++ b/services/java/com/android/server/status/StatusBarException.java @@ -0,0 +1,7 @@ +package com.android.server.status; + +public class StatusBarException extends RuntimeException { + StatusBarException(String msg) { + super(msg); + } +} diff --git a/services/java/com/android/server/status/StatusBarIcon.java b/services/java/com/android/server/status/StatusBarIcon.java new file mode 100644 index 0000000..6d09919 --- /dev/null +++ b/services/java/com/android/server/status/StatusBarIcon.java @@ -0,0 +1,167 @@ +package com.android.server.status; + +import android.content.Context; +import android.content.pm.PackageManager; +import android.content.res.Resources; +import android.graphics.Typeface; +import android.graphics.drawable.AnimationDrawable; +import android.graphics.drawable.Drawable; +import android.text.TextUtils; +import android.util.Log; +import android.view.Gravity; +import android.view.LayoutInflater; +import android.view.View; +import android.view.ViewGroup; +import android.widget.FrameLayout; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; + +class StatusBarIcon { + // TODO: get this from a resource + private static final int ICON_GAP = 8; + private static final int ICON_WIDTH = 25; + private static final int ICON_HEIGHT = 25; + + public View view; + + IconData mData; + + private TextView mTextView; + private AnimatedImageView mImageView; + private TextView mNumberView; + + public StatusBarIcon(Context context, IconData data, ViewGroup parent) { + mData = data.clone(); + + switch (data.type) { + case IconData.TEXT: { + TextView t; + t = new TextView(context); + mTextView = t; + LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams( + LinearLayout.LayoutParams.WRAP_CONTENT, + LinearLayout.LayoutParams.FILL_PARENT); + t.setTextSize(16); + t.setTextColor(0xff000000); + t.setTypeface(Typeface.DEFAULT_BOLD); + t.setGravity(Gravity.CENTER_VERTICAL | Gravity.LEFT); + t.setPadding(6, 0, 0, 0); + t.setLayoutParams(layoutParams); + t.setText(data.text); + this.view = t; + break; + } + + case IconData.ICON: { + // container + LayoutInflater inflater = (LayoutInflater)context.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + View v = inflater.inflate(com.android.internal.R.layout.status_bar_icon, parent, false); + this.view = v; + + // icon + AnimatedImageView im = (AnimatedImageView)v.findViewById(com.android.internal.R.id.image); + im.setImageDrawable(getIcon(context, data)); + im.setImageLevel(data.iconLevel); + mImageView = im; + + // number + TextView nv = (TextView)v.findViewById(com.android.internal.R.id.number); + mNumberView = nv; + if (data.number > 0) { + nv.setText("" + data.number); + nv.setVisibility(View.VISIBLE); + } else { + nv.setVisibility(View.GONE); + } + break; + } + } + } + + public void update(Context context, IconData data) throws StatusBarException { + if (mData.type != data.type) { + throw new StatusBarException("status bar entry type can't change"); + } + switch (data.type) { + case IconData.TEXT: + if (!TextUtils.equals(mData.text, data.text)) { + TextView tv = mTextView; + tv.setText(data.text); + } + break; + case IconData.ICON: + if (((mData.iconPackage != null && data.iconPackage != null) + && !mData.iconPackage.equals(data.iconPackage)) + || mData.iconId != data.iconId + || mData.iconLevel != data.iconLevel) { + ImageView im = mImageView; + im.setImageDrawable(getIcon(context, data)); + im.setImageLevel(data.iconLevel); + } + if (mData.number != data.number) { + TextView nv = mNumberView; + if (data.number > 0) { + nv.setText("" + data.number); + } else { + nv.setText(""); + } + } + break; + } + mData.copyFrom(data); + } + + public void update(int number) { + if (mData.number != number) { + TextView nv = mNumberView; + if (number > 0) { + nv.setText("" + number); + } else { + nv.setText(""); + } + } + mData.number = number; + } + + + /** + * Returns the right icon to use for this item, respecting the iconId and + * iconPackage (if set) + * + * @param context Context to use to get resources if iconPackage is not set + * @return Drawable for this item, or null if the package or item could not + * be found + */ + static Drawable getIcon(Context context, IconData data) { + + Resources r = null; + + if (data.iconPackage != null) { + try { + r = context.getPackageManager().getResourcesForApplication(data.iconPackage); + } catch (PackageManager.NameNotFoundException ex) { + Log.e(StatusBarService.TAG, "Icon package not found: " + data.iconPackage, ex); + return null; + } + } else { + r = context.getResources(); + } + + try { + return r.getDrawable(data.iconId); + } catch (RuntimeException e) { + Log.w(StatusBarService.TAG, "Icon not found in " + + (data.iconPackage != null ? data.iconId : "<system>") + + ": " + Integer.toHexString(data.iconId)); + } + + return null; + } + + int getNumber() { + return mData.number; + } +} + diff --git a/services/java/com/android/server/status/StatusBarNotification.java b/services/java/com/android/server/status/StatusBarNotification.java new file mode 100644 index 0000000..4636cba --- /dev/null +++ b/services/java/com/android/server/status/StatusBarNotification.java @@ -0,0 +1,11 @@ +package com.android.server.status; + +import android.os.IBinder; +import android.view.View; + +class StatusBarNotification { + IBinder key; + NotificationData data; + View view; + View contentView; +} diff --git a/services/java/com/android/server/status/StatusBarPolicy.java b/services/java/com/android/server/status/StatusBarPolicy.java new file mode 100644 index 0000000..8433227 --- /dev/null +++ b/services/java/com/android/server/status/StatusBarPolicy.java @@ -0,0 +1,916 @@ +/* + * 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.status; + +import com.android.internal.R; +import com.android.internal.location.GpsLocationProvider; +import com.android.internal.telephony.SimCard; +import com.android.internal.telephony.TelephonyIntents; + +import android.app.AlertDialog; +import android.bluetooth.BluetoothA2dp; +import android.bluetooth.BluetoothDevice; +import android.bluetooth.BluetoothHeadset; +import android.bluetooth.BluetoothIntent; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.res.TypedArray; +import android.graphics.PixelFormat; +import android.graphics.drawable.Drawable; +import android.media.AudioManager; +import android.net.NetworkInfo; +import android.net.wifi.WifiManager; +import android.os.Handler; +import android.os.IBinder; +import android.os.Message; +import android.provider.Settings; +import android.telephony.PhoneStateListener; +import android.telephony.ServiceState; +import android.telephony.TelephonyManager; +import android.text.format.DateFormat; +import android.util.Log; +import android.view.View; +import android.view.ViewGroup; +import android.view.WindowManager; +import android.view.WindowManagerImpl; +import android.widget.ImageView; +import android.widget.LinearLayout; +import android.widget.TextView; + +import java.util.Calendar; +import java.util.TimeZone; + +/** + * This class contains all of the policy about which icons are installed in the status + * bar at boot time. In reality, it should go into the android.policy package, but + * putting it here is the first step from extracting it. + */ +public class StatusBarPolicy { + private static final String TAG = "StatusBarPolicy"; + + private static StatusBarPolicy sInstance; + + // message codes for the handler + private static final int EVENT_DATA_CONN_STATE_CHANGED = 2; + private static final int EVENT_DATA_ACTIVITY = 3; + private static final int EVENT_BATTERY_CLOSE = 4; + + // indices into mBatteryThresholds + private static final int BATTERY_THRESHOLD_CLOSE_WARNING = 0; + private static final int BATTERY_THRESHOLD_WARNING = 1; + private static final int BATTERY_THRESHOLD_EMPTY = 2; + + private Context mContext; + private StatusBarService mService; + private Handler mHandler = new StatusBarHandler(); + + // clock + private Calendar mCalendar; + private IBinder mClockIcon; + private IconData mClockData; + + // battery + private IBinder mBatteryIcon; + private IconData mBatteryData; + private boolean mBatteryFirst = true; + private boolean mBatteryPlugged; + private int mBatteryLevel; + private int mBatteryThreshold = 0; // index into mBatteryThresholds + private int[] mBatteryThresholds = new int[] { 20, 15, -1 }; + private AlertDialog mLowBatteryDialog; + private TextView mBatteryLevelTextView; + private View mBatteryView; + private int mBatteryViewSequence; + private boolean mBatteryShowLowOnEndCall = false; + private static final boolean SHOW_LOW_BATTERY_WARNING = true; + + // phone + private TelephonyManager mPhone; + private IBinder mPhoneIcon; + private IconData mPhoneData; + private static final int[] sSignalImages = new int[] { + com.android.internal.R.drawable.stat_sys_signal_0, + com.android.internal.R.drawable.stat_sys_signal_1, + com.android.internal.R.drawable.stat_sys_signal_2, + com.android.internal.R.drawable.stat_sys_signal_3, + com.android.internal.R.drawable.stat_sys_signal_4 + }; + private static final int[] sSignalImages_r = new int[] { + com.android.internal.R.drawable.stat_sys_r_signal_0, + com.android.internal.R.drawable.stat_sys_r_signal_1, + com.android.internal.R.drawable.stat_sys_r_signal_2, + com.android.internal.R.drawable.stat_sys_r_signal_3, + com.android.internal.R.drawable.stat_sys_r_signal_4 + }; + private int[] mDataIconList = sDataNetType_g; + private static final int[] sDataNetType_g = new int[] { + com.android.internal.R.drawable.stat_sys_data_connected_g, + com.android.internal.R.drawable.stat_sys_data_in_g, + com.android.internal.R.drawable.stat_sys_data_out_g, + com.android.internal.R.drawable.stat_sys_data_inandout_g, + }; + private static final int[] sDataNetType_3g = new int[] { + com.android.internal.R.drawable.stat_sys_data_connected_3g, + com.android.internal.R.drawable.stat_sys_data_in_3g, + com.android.internal.R.drawable.stat_sys_data_out_3g, + com.android.internal.R.drawable.stat_sys_data_inandout_3g, + }; + private static final int[] sDataNetType_e = new int[] { + com.android.internal.R.drawable.stat_sys_data_connected_e, + com.android.internal.R.drawable.stat_sys_data_in_e, + com.android.internal.R.drawable.stat_sys_data_out_e, + com.android.internal.R.drawable.stat_sys_data_inandout_e, + }; + // Assume it's all good unless we hear otherwise. We don't always seem + // to get broadcasts that it *is* there. + SimCard.State mSimState = SimCard.State.READY; + int mPhoneState = TelephonyManager.CALL_STATE_IDLE; + int mDataState = TelephonyManager.DATA_DISCONNECTED; + int mDataActivity = TelephonyManager.DATA_ACTIVITY_NONE; + ServiceState mServiceState; + int mSignalAsu = -1; + + // data connection + private IBinder mDataIcon; + private IconData mDataData; + private boolean mDataIconVisible; + + // ringer volume + private IBinder mVolumeIcon; + private IconData mVolumeData; + private boolean mVolumeVisible; + + // bluetooth device status + private IBinder mBluetoothIcon; + private IconData mBluetoothData; + private int mBluetoothHeadsetState; + private int mBluetoothA2dpState; + private boolean mBluetoothEnabled; + + // wifi + private static final int[] sWifiSignalImages = new int[] { + com.android.internal.R.drawable.stat_sys_wifi_signal_1, + com.android.internal.R.drawable.stat_sys_wifi_signal_2, + com.android.internal.R.drawable.stat_sys_wifi_signal_3, + com.android.internal.R.drawable.stat_sys_wifi_signal_4, + }; + private static final int sWifiTemporarilyNotConnectedImage = + com.android.internal.R.drawable.stat_sys_wifi_signal_0; + + private int mLastWifiSignalLevel = -1; + private boolean mIsWifiConnected = false; + private IBinder mWifiIcon; + private IconData mWifiData; + + // gps + private IBinder mGpsIcon; + private IconData mGpsEnabledIconData; + private IconData mGpsFixIconData; + + // alarm clock + // Icon lit when clock is set + private IBinder mAlarmClockIcon; + private IconData mAlarmClockIconData; + + // sync state + // If sync is active the SyncActive icon is displayed. If sync is not active but + // sync is failing the SyncFailing icon is displayed. Otherwise neither are displayed. + private IBinder mSyncActiveIcon; + private IBinder mSyncFailingIcon; + + private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() { + @Override + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (action.equals(Intent.ACTION_TIME_TICK)) { + updateClock(); + } + else if (action.equals(Intent.ACTION_TIME_CHANGED)) { + updateClock(); + } + else if (action.equals(Intent.ACTION_CONFIGURATION_CHANGED)) { + updateClock(); + } + else if (action.equals(Intent.ACTION_TIMEZONE_CHANGED)) { + String tz = intent.getStringExtra("time-zone"); + mCalendar = Calendar.getInstance(TimeZone.getTimeZone(tz)); + updateClock(); + } + else if (action.equals(Intent.ACTION_ALARM_CHANGED)) { + updateAlarm(intent); + } + else if (action.equals(Intent.ACTION_SYNC_STATE_CHANGED)) { + updateSyncState(intent); + } + else if (action.equals(Intent.ACTION_BATTERY_CHANGED)) { + updateBattery(intent); + } + else if (action.equals(BluetoothIntent.ENABLED_ACTION) || + action.equals(BluetoothIntent.DISABLED_ACTION) || + action.equals(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION) || + action.equals(BluetoothA2dp.SINK_STATE_CHANGED_ACTION)) { + updateBluetooth(intent); + } + else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION) || + action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION) || + action.equals(WifiManager.RSSI_CHANGED_ACTION)) { + updateWifi(intent); + } + else if (action.equals(GpsLocationProvider.GPS_ENABLED_CHANGE_ACTION) || + action.equals(GpsLocationProvider.GPS_FIX_CHANGE_ACTION)) { + updateGps(intent); + } + else if (action.equals(AudioManager.RINGER_MODE_CHANGED_ACTION) || + action.equals(AudioManager.VIBRATE_SETTING_CHANGED_ACTION)) { + updateVolume(); + } + else if (action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) { + updateSimState(intent); + } + } + }; + + private StatusBarPolicy(Context context, StatusBarService service) { + mContext = context; + mService = service; + + // clock + mCalendar = Calendar.getInstance(TimeZone.getDefault()); + mClockData = IconData.makeText("clock", ""); + mClockIcon = service.addIcon(mClockData, null); + updateClock(); + + // battery + mBatteryData = IconData.makeIcon("battery", + null, com.android.internal.R.drawable.stat_sys_battery_unknown, 0, 0); + mBatteryIcon = service.addIcon(mBatteryData, null); + + // phone_signal + mPhone = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE); + mPhoneData = IconData.makeIcon("phone_signal", + null, com.android.internal.R.drawable.stat_sys_signal_null, 0, 0); + mPhoneIcon = service.addIcon(mPhoneData, null); + // register for phone state notifications. + ((TelephonyManager)mContext.getSystemService(Context.TELEPHONY_SERVICE)) + .listen(mPhoneStateListener, + PhoneStateListener.LISTEN_SERVICE_STATE + | PhoneStateListener.LISTEN_SIGNAL_STRENGTH + | PhoneStateListener.LISTEN_CALL_STATE + | PhoneStateListener.LISTEN_DATA_CONNECTION_STATE + | PhoneStateListener.LISTEN_DATA_ACTIVITY); + + // data_connection + mDataData = IconData.makeIcon("data_connection", + null, com.android.internal.R.drawable.stat_sys_data_connected_g, 0, 0); + mDataIcon = service.addIcon(mDataData, null); + service.setIconVisibility(mDataIcon, false); + + // wifi + mWifiData = IconData.makeIcon("wifi", null, sWifiSignalImages[0], 0, 0); + mWifiIcon = service.addIcon(mWifiData, null); + service.setIconVisibility(mWifiIcon, false); + // wifi will get updated by the sticky intents + + // bluetooth status + mBluetoothData = IconData.makeIcon("bluetooth", + null, com.android.internal.R.drawable.stat_sys_data_bluetooth, 0, 0); + mBluetoothIcon = service.addIcon(mBluetoothData, null); + BluetoothDevice bluetooth = + (BluetoothDevice) mContext.getSystemService(Context.BLUETOOTH_SERVICE); + if (bluetooth != null) { + mBluetoothEnabled = bluetooth.isEnabled(); + } else { + mBluetoothEnabled = false; + } + mBluetoothA2dpState = BluetoothA2dp.STATE_DISCONNECTED; + mBluetoothHeadsetState = BluetoothHeadset.STATE_DISCONNECTED; + mService.setIconVisibility(mBluetoothIcon, mBluetoothEnabled); + + // Gps status + mGpsEnabledIconData = IconData.makeIcon("gps", + null, com.android.internal.R.drawable.stat_sys_gps_acquiring_anim, 0, 0); + mGpsFixIconData = IconData.makeIcon("gps", + null, com.android.internal.R.drawable.stat_sys_gps_on, 0, 0); + mGpsIcon = service.addIcon(mGpsEnabledIconData, null); + service.setIconVisibility(mGpsIcon, false); + + // Alarm clock + mAlarmClockIconData = IconData.makeIcon( + "alarm_clock", + null, com.android.internal.R.drawable.stat_notify_alarm, 0, 0); + mAlarmClockIcon = service.addIcon(mAlarmClockIconData, null); + service.setIconVisibility(mAlarmClockIcon, false); + + // Sync state + mSyncActiveIcon = service.addIcon(IconData.makeIcon("sync_active", + null, R.drawable.stat_notify_sync_anim0, 0, 0), null); + mSyncFailingIcon = service.addIcon(IconData.makeIcon("sync_failing", + null, R.drawable.stat_notify_sync_error, 0, 0), null); + service.setIconVisibility(mSyncActiveIcon, false); + service.setIconVisibility(mSyncFailingIcon, false); + + // volume + mVolumeData = IconData.makeIcon("volume", + null, com.android.internal.R.drawable.stat_sys_ringer_silent, 0, 0); + mVolumeIcon = service.addIcon(mVolumeData, null); + service.setIconVisibility(mVolumeIcon, false); + updateVolume(); + + IntentFilter filter = new IntentFilter(); + + // Register for Intent broadcasts for... + filter.addAction(Intent.ACTION_TIME_TICK); + filter.addAction(Intent.ACTION_TIME_CHANGED); + filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED); + filter.addAction(Intent.ACTION_BATTERY_CHANGED); + filter.addAction(Intent.ACTION_TIMEZONE_CHANGED); + filter.addAction(Intent.ACTION_ALARM_CHANGED); + filter.addAction(Intent.ACTION_SYNC_STATE_CHANGED); + filter.addAction(AudioManager.RINGER_MODE_CHANGED_ACTION); + filter.addAction(AudioManager.VIBRATE_SETTING_CHANGED_ACTION); + filter.addAction(BluetoothIntent.ENABLED_ACTION); + filter.addAction(BluetoothIntent.DISABLED_ACTION); + filter.addAction(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION); + filter.addAction(BluetoothA2dp.SINK_STATE_CHANGED_ACTION); + filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION); + filter.addAction(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION); + filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION); + filter.addAction(WifiManager.RSSI_CHANGED_ACTION); + filter.addAction(GpsLocationProvider.GPS_ENABLED_CHANGE_ACTION); + filter.addAction(GpsLocationProvider.GPS_FIX_CHANGE_ACTION); + filter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED); + mContext.registerReceiver(mIntentReceiver, filter, null, mHandler); + } + + public static void installIcons(Context context, StatusBarService service) { + sInstance = new StatusBarPolicy(context, service); + } + + private final void updateClock() { + mCalendar.setTimeInMillis(System.currentTimeMillis()); + mClockData.text = DateFormat.getTimeFormat(mContext) + .format(mCalendar.getTime()); + mService.updateIcon(mClockIcon, mClockData, null); + } + + private final void updateAlarm(Intent intent) { + boolean alarmSet = intent.getBooleanExtra("alarmSet", false); + mService.setIconVisibility(mAlarmClockIcon, alarmSet); + } + + private final void updateSyncState(Intent intent) { + boolean isActive = intent.getBooleanExtra("active", false); + boolean isFailing = intent.getBooleanExtra("failing", false); + mService.setIconVisibility(mSyncActiveIcon, isActive); + // Don't display sync failing icon: BUG 1297963 Set sync error timeout to "never" + //mService.setIconVisibility(mSyncFailingIcon, isFailing && !isActive); + } + + private void pickNextBatteryLevel(int level) { + final int N = mBatteryThresholds.length; + for (int i=0; i<N; i++) { + if (level >= mBatteryThresholds[i]) { + mBatteryThreshold = i; + break; + } + } + if (mBatteryThreshold >= N) { + mBatteryThreshold = N-1; + } + } + + private final void updateBattery(Intent intent) { + mBatteryData.iconId = intent.getIntExtra("icon-small", 0); + mBatteryData.iconLevel = intent.getIntExtra("level", 0); + mService.updateIcon(mBatteryIcon, mBatteryData, null); + + boolean plugged = intent.getIntExtra("plugged", 0) != 0; + int level = intent.getIntExtra("level", -1); + if (false) { + Log.d(TAG, "updateBattery level=" + level + + " plugged=" + plugged + + " mBatteryPlugged=" + mBatteryPlugged + + " mBatteryLevel=" + mBatteryLevel + + " mBatteryThreshold=" + mBatteryThreshold + + " mBatteryFirst=" + mBatteryFirst); + } + + boolean oldPlugged = mBatteryPlugged; + int oldThreshold = mBatteryThreshold; + pickNextBatteryLevel(level); + + mBatteryPlugged = plugged; + mBatteryLevel = level; + + if (mBatteryFirst) { + mBatteryFirst = false; + } + /* + * No longer showing the battery view because it draws attention away + * from the USB storage notification. We could still show it when + * connected to a brick, but that could lead to the user into thinking + * the device does not charge when plugged into USB (since he/she would + * not see the same battery screen on USB as he sees on brick). + */ + /* else { + if (plugged && !oldPlugged) { + showBatteryView(); + } + } + */ + if (false) { + Log.d(TAG, "plugged=" + plugged + " oldPlugged=" + oldPlugged + " level=" + level + + " mBatteryThreshold=" + mBatteryThreshold + " oldThreshold=" + oldThreshold); + } + if (!plugged + && ((oldPlugged && level < mBatteryThresholds[BATTERY_THRESHOLD_WARNING]) + || (mBatteryThreshold > oldThreshold + && mBatteryThreshold > BATTERY_THRESHOLD_WARNING))) { + // Broadcast the low battery warning + mContext.sendBroadcast(new Intent(Intent.ACTION_BATTERY_LOW)); + + if (SHOW_LOW_BATTERY_WARNING) { + if (false) { + Log.d(TAG, "mPhoneState=" + mPhoneState + + " mLowBatteryDialog=" + mLowBatteryDialog + + " mBatteryShowLowOnEndCall=" + mBatteryShowLowOnEndCall); + } + + if (mPhoneState == TelephonyManager.CALL_STATE_IDLE) { + showLowBatteryWarning(); + } else { + mBatteryShowLowOnEndCall = true; + } + } + } else if (mBatteryThreshold == BATTERY_THRESHOLD_CLOSE_WARNING) { + if (SHOW_LOW_BATTERY_WARNING) { + if (mLowBatteryDialog != null) { + mLowBatteryDialog.dismiss(); + mBatteryShowLowOnEndCall = false; + } + } + } + } + + private void showBatteryView() { + closeLastBatteryView(); + if (mLowBatteryDialog != null) { + mLowBatteryDialog.dismiss(); + } + + int level = mBatteryLevel; + + View v = View.inflate(mContext, com.android.internal.R.layout.battery_status, null); + mBatteryView = v; + int pixelFormat = PixelFormat.TRANSLUCENT; + Drawable bg = v.getBackground(); + if (bg != null) { + pixelFormat = bg.getOpacity(); + } + + WindowManager.LayoutParams lp = new WindowManager.LayoutParams( + ViewGroup.LayoutParams.WRAP_CONTENT, + ViewGroup.LayoutParams.WRAP_CONTENT, + WindowManager.LayoutParams.TYPE_TOAST, + WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE + | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE + | WindowManager.LayoutParams.FLAG_BLUR_BEHIND + | WindowManager.LayoutParams.FLAG_DIM_BEHIND, + pixelFormat); + + // Get the dim amount from the theme + TypedArray a = mContext.obtainStyledAttributes( + com.android.internal.R.styleable.Theme); + lp.dimAmount = a.getFloat(android.R.styleable.Theme_backgroundDimAmount, 0.5f); + a.recycle(); + + lp.setTitle("Battery"); + + TextView levelTextView = (TextView)v.findViewById(com.android.internal.R.id.level_percent); + levelTextView.setText(mContext.getString( + com.android.internal.R.string.battery_status_text_percent_format, level)); + + setBatteryLevel(v, com.android.internal.R.id.spacer, 100-level, 0, 0); + setBatteryLevel(v, com.android.internal.R.id.level, level, + com.android.internal.R.drawable.battery_charge_fill, level); + + WindowManagerImpl.getDefault().addView(v, lp); + + scheduleCloseBatteryView(); + } + + private void setBatteryLevel(View parent, int id, int height, int background, int level) { + ImageView v = (ImageView)parent.findViewById(id); + LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)v.getLayoutParams(); + lp.weight = height; + if (background != 0) { + v.setBackgroundResource(background); + Drawable bkg = v.getBackground(); + bkg.setLevel(level); + } + } + + private void showLowBatteryWarning() { + closeLastBatteryView(); + + int level = mBatteryThresholds[mBatteryThreshold > 1 ? mBatteryThreshold - 1 : 0]; + CharSequence levelText = mContext.getString( + com.android.internal.R.string.battery_low_percent_format, level); + + if (mBatteryLevelTextView != null) { + mBatteryLevelTextView.setText(levelText); + } else { + View v = View.inflate(mContext, com.android.internal.R.layout.battery_low, null); + mBatteryLevelTextView=(TextView)v.findViewById(com.android.internal.R.id.level_percent); + + mBatteryLevelTextView.setText(levelText); + + AlertDialog.Builder b = new AlertDialog.Builder(mContext); + b.setCancelable(true); + b.setTitle(com.android.internal.R.string.battery_low_title); + b.setView(v); + b.setIcon(android.R.drawable.ic_dialog_alert); + b.setPositiveButton(android.R.string.ok, null); + + AlertDialog d = b.create(); + d.setOnDismissListener(mLowBatteryListener); + d.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT); + d.show(); + mLowBatteryDialog = d; + } + } + + private final void updateCallState(int state) { + mPhoneState = state; + if (false) { + Log.d(TAG, "mPhoneState=" + mPhoneState + + " mLowBatteryDialog=" + mLowBatteryDialog + + " mBatteryShowLowOnEndCall=" + mBatteryShowLowOnEndCall); + } + if (mPhoneState == TelephonyManager.CALL_STATE_IDLE) { + if (mBatteryShowLowOnEndCall) { + if (!mBatteryPlugged) { + showLowBatteryWarning(); + } + mBatteryShowLowOnEndCall = false; + } + } else { + if (mLowBatteryDialog != null) { + mLowBatteryDialog.dismiss(); + mBatteryShowLowOnEndCall = true; + } + } + } + + private DialogInterface.OnDismissListener mLowBatteryListener + = new DialogInterface.OnDismissListener() { + public void onDismiss(DialogInterface dialog) { + mLowBatteryDialog = null; + mBatteryLevelTextView = null; + } + }; + + private void scheduleCloseBatteryView() { + Message m = mHandler.obtainMessage(EVENT_BATTERY_CLOSE); + m.arg1 = (++mBatteryViewSequence); + mHandler.sendMessageDelayed(m, 3000); + } + + private void closeLastBatteryView() { + if (mBatteryView != null) { + //mBatteryView.debug(); + WindowManagerImpl.getDefault().removeView(mBatteryView); + mBatteryView = null; + } + } + + private PhoneStateListener mPhoneStateListener = new PhoneStateListener() { + @Override + public void onSignalStrengthChanged(int asu) { + mSignalAsu = asu; + updateSignalStrength(); + } + + @Override + public void onServiceStateChanged(ServiceState state) { + mServiceState = state; + updateSignalStrength(); + updateDataIcon(); + } + + @Override + public void onCallStateChanged(int state, String incomingNumber) { + updateCallState(state); + } + + @Override + public void onDataConnectionStateChanged(int state) { + mDataState = state; + updateDataNetType(); + updateDataIcon(); + } + + @Override + public void onDataActivity(int direction) { + mDataActivity = direction; + updateDataIcon(); + } + }; + + + private final void updateSimState(Intent intent) { + String stateExtra = intent.getStringExtra(SimCard.INTENT_KEY_SIM_STATE); + if (SimCard.INTENT_VALUE_SIM_ABSENT.equals(stateExtra)) { + mSimState = SimCard.State.ABSENT; + } + else if (SimCard.INTENT_VALUE_SIM_READY.equals(stateExtra)) { + mSimState = SimCard.State.READY; + } + else if (SimCard.INTENT_VALUE_SIM_LOCKED.equals(stateExtra)) { + final String lockedReason = intent.getStringExtra(SimCard.INTENT_KEY_LOCKED_REASON); + if (SimCard.INTENT_VALUE_LOCKED_ON_PIN.equals(lockedReason)) { + mSimState = SimCard.State.PIN_REQUIRED; + } + else if (SimCard.INTENT_VALUE_LOCKED_ON_PUK.equals(lockedReason)) { + mSimState = SimCard.State.PUK_REQUIRED; + } + else { + mSimState = SimCard.State.NETWORK_LOCKED; + } + } else { + mSimState = SimCard.State.UNKNOWN; + } + updateDataIcon(); + } + + private final void updateSignalStrength() { + int asu = mSignalAsu; + ServiceState ss = mServiceState; + + boolean hasService = true; + + if (ss != null) { + int state = ss.getState(); + switch (state) { + case ServiceState.STATE_OUT_OF_SERVICE: + case ServiceState.STATE_POWER_OFF: + hasService = false; + break; + } + } else { + hasService = false; + } + + if (!hasService) { + //Log.d(TAG, "updateSignalStrength: no service"); + if (Settings.System.getInt(mContext.getContentResolver(), + Settings.System.AIRPLANE_MODE_ON, 0) == 1) { + mPhoneData.iconId = com.android.internal.R.drawable.stat_sys_signal_flightmode; + } else { + mPhoneData.iconId = com.android.internal.R.drawable.stat_sys_signal_null; + } + mService.updateIcon(mPhoneIcon, mPhoneData, null); + return; + } + + // ASU ranges from 0 to 31 - TS 27.007 Sec 8.5 + // asu = 0 (-113dB or less) is very weak + // signal, its better to show 0 bars to the user in such cases. + // asu = 99 is a special case, where the signal strength is unknown. + if (asu <= 0 || asu == 99) asu = 0; + else if (asu >= 16) asu = 4; + else if (asu >= 8) asu = 3; + else if (asu >= 4) asu = 2; + else asu = 1; + + int[] iconList; + if (mPhone.isNetworkRoaming()) { + iconList = sSignalImages_r; + } else { + iconList = sSignalImages; + } + + mPhoneData.iconId = iconList[asu]; + mService.updateIcon(mPhoneIcon, mPhoneData, null); + } + + private final void updateDataNetType() { + int net = mPhone.getNetworkType(); + switch (net) { + case TelephonyManager.NETWORK_TYPE_EDGE: + mDataIconList = sDataNetType_e; + break; + case TelephonyManager.NETWORK_TYPE_UMTS: + mDataIconList = sDataNetType_3g; + break; + default: + mDataIconList = sDataNetType_g; + break; + } + } + + private final void updateDataIcon() { + int iconId; + boolean visible = true; + + if (mSimState == SimCard.State.READY || mSimState == SimCard.State.UNKNOWN) { + int data = mDataState; + + int[] list = mDataIconList; + + ServiceState ss = mServiceState; + + boolean hasService = false; + + if (ss != null) { + hasService = (ss.getState() == ServiceState.STATE_IN_SERVICE); + } + + if (hasService && data == TelephonyManager.DATA_CONNECTED) { + switch (mDataActivity) { + case TelephonyManager.DATA_ACTIVITY_IN: + iconId = list[1]; + break; + case TelephonyManager.DATA_ACTIVITY_OUT: + iconId = list[2]; + break; + case TelephonyManager.DATA_ACTIVITY_INOUT: + iconId = list[3]; + break; + default: + iconId = list[0]; + break; + } + mDataData.iconId = iconId; + mService.updateIcon(mDataIcon, mDataData, null); + } else { + visible = false; + } + } else { + mDataData.iconId = com.android.internal.R.drawable.stat_sys_no_sim; + mService.updateIcon(mDataIcon, mDataData, null); + } + if (mDataIconVisible != visible) { + mService.setIconVisibility(mDataIcon, visible); + mDataIconVisible = visible; + } + } + + private final void updateVolume() { + AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE); + final int ringerMode = audioManager.getRingerMode(); + final boolean visible = ringerMode == AudioManager.RINGER_MODE_SILENT || + ringerMode == AudioManager.RINGER_MODE_VIBRATE; + final int iconId = audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_RINGER) + ? com.android.internal.R.drawable.stat_sys_ringer_vibrate + : com.android.internal.R.drawable.stat_sys_ringer_silent; + + if (visible) { + mVolumeData.iconId = iconId; + mService.updateIcon(mVolumeIcon, mVolumeData, null); + } + if (visible != mVolumeVisible) { + mService.setIconVisibility(mVolumeIcon, visible); + mVolumeVisible = visible; + } + } + + private final void updateBluetooth(Intent intent) { + int iconId = com.android.internal.R.drawable.stat_sys_data_bluetooth; + + String action = intent.getAction(); + if (action.equals(BluetoothIntent.DISABLED_ACTION)) { + mBluetoothEnabled = false; + } else if (action.equals(BluetoothIntent.ENABLED_ACTION)) { + mBluetoothEnabled = true; + } else if (action.equals(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION)) { + mBluetoothHeadsetState = intent.getIntExtra(BluetoothIntent.HEADSET_STATE, + BluetoothHeadset.STATE_ERROR); + } else if (action.equals(BluetoothA2dp.SINK_STATE_CHANGED_ACTION)) { + mBluetoothA2dpState = intent.getIntExtra(BluetoothA2dp.SINK_STATE, + BluetoothA2dp.STATE_DISCONNECTED); + } else { + return; + } + + if (mBluetoothHeadsetState == BluetoothHeadset.STATE_CONNECTED || + mBluetoothA2dpState == BluetoothA2dp.STATE_CONNECTED || + mBluetoothA2dpState == BluetoothA2dp.STATE_PLAYING) { + iconId = com.android.internal.R.drawable.stat_sys_data_bluetooth_connected; + } + + mBluetoothData.iconId = iconId; + mService.updateIcon(mBluetoothIcon, mBluetoothData, null); + mService.setIconVisibility(mBluetoothIcon, mBluetoothEnabled); + } + + private final void updateWifi(Intent intent) { + final String action = intent.getAction(); + if (action.equals(WifiManager.WIFI_STATE_CHANGED_ACTION)) { + + final boolean enabled = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, + WifiManager.WIFI_STATE_UNKNOWN) == WifiManager.WIFI_STATE_ENABLED; + + if (!enabled) { + // If disabled, hide the icon. (We show icon when connected.) + mService.setIconVisibility(mWifiIcon, false); + } + + } else if (action.equals(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION)) { + final boolean enabled = intent.getBooleanExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, + false); + if (!enabled) { + mService.setIconVisibility(mWifiIcon, false); + } + } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) { + + final NetworkInfo networkInfo = (NetworkInfo) + intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO); + + int iconId; + if (networkInfo != null && networkInfo.isConnected()) { + mIsWifiConnected = true; + if (mLastWifiSignalLevel == -1) { + iconId = sWifiSignalImages[0]; + } else { + iconId = sWifiSignalImages[mLastWifiSignalLevel]; + } + + // Show the icon since wi-fi is connected + mService.setIconVisibility(mWifiIcon, true); + + } else { + mLastWifiSignalLevel = -1; + mIsWifiConnected = false; + iconId = sWifiSignalImages[0]; + + // Hide the icon since we're not connected + mService.setIconVisibility(mWifiIcon, false); + } + + mWifiData.iconId = iconId; + mService.updateIcon(mWifiIcon, mWifiData, null); + } else if (action.equals(WifiManager.RSSI_CHANGED_ACTION)) { + final int newRssi = intent.getIntExtra(WifiManager.EXTRA_NEW_RSSI, -200); + int newSignalLevel = WifiManager.calculateSignalLevel(newRssi, + sWifiSignalImages.length); + if (newSignalLevel != mLastWifiSignalLevel) { + mLastWifiSignalLevel = newSignalLevel; + if (mIsWifiConnected) { + mWifiData.iconId = sWifiSignalImages[newSignalLevel]; + } else { + mWifiData.iconId = sWifiTemporarilyNotConnectedImage; + } + mService.updateIcon(mWifiIcon, mWifiData, null); + } + } + } + + private final void updateGps(Intent intent) { + final String action = intent.getAction(); + final boolean enabled = intent.getBooleanExtra(GpsLocationProvider.EXTRA_ENABLED, false); + + if (action.equals(GpsLocationProvider.GPS_FIX_CHANGE_ACTION) && enabled) { + // GPS is getting fixes + mService.updateIcon(mGpsIcon, mGpsFixIconData, null); + mService.setIconVisibility(mGpsIcon, true); + } else if (action.equals(GpsLocationProvider.GPS_ENABLED_CHANGE_ACTION) && !enabled) { + // GPS is off + mService.setIconVisibility(mGpsIcon, false); + } else { + // GPS is on, but not receiving fixes + mService.updateIcon(mGpsIcon, mGpsEnabledIconData, null); + mService.setIconVisibility(mGpsIcon, true); + } + } + + private class StatusBarHandler extends Handler { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case EVENT_BATTERY_CLOSE: + if (msg.arg1 == mBatteryViewSequence) { + closeLastBatteryView(); + } + break; + } + } + } +} diff --git a/services/java/com/android/server/status/StatusBarService.java b/services/java/com/android/server/status/StatusBarService.java new file mode 100644 index 0000000..5442e1d --- /dev/null +++ b/services/java/com/android/server/status/StatusBarService.java @@ -0,0 +1,1774 @@ +/* + * Copyright (C) 2007 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.status; + +import com.android.internal.R; +import com.android.internal.util.CharSequences; + +import android.app.Dialog; +import android.app.IStatusBar; +import android.app.PendingIntent; +import android.app.StatusBarManager; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.content.res.Resources; +import android.graphics.PixelFormat; +import android.graphics.drawable.Drawable; +import android.net.Uri; +import android.os.IBinder; +import android.os.RemoteException; +import android.os.Binder; +import android.os.Handler; +import android.os.Message; +import android.os.SystemClock; +import android.provider.Telephony; +import android.util.Log; +import android.view.Display; +import android.view.Gravity; +import android.view.KeyEvent; +import android.view.LayoutInflater; +import android.view.MotionEvent; +import android.view.VelocityTracker; +import android.view.View; +import android.view.ViewGroup; +import android.view.Window; +import android.view.WindowManager; +import android.view.WindowManagerImpl; +import android.view.animation.Animation; +import android.view.animation.AnimationUtils; +import android.widget.LinearLayout; +import android.widget.RemoteViews; +import android.widget.ScrollView; +import android.widget.TextView; +import java.io.FileDescriptor; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Set; + + +/** + * The public (ok, semi-public) service for the status bar. + * <p> + * This interesting thing to note about this class is that most of the methods that + * are called from other classes just post a message, and everything else is batched + * and coalesced into a series of calls to methods that all start with "perform." + * There are two reasons for this. The first is that some of the methods (activate/deactivate) + * are on IStatusBar, so they're called from the thread pool and they need to make their + * way onto the UI thread. The second is that the message queue is stopped while animations + * are happening in order to make for smoother transitions. + * <p> + * Each icon is either an icon or an icon and a notification. They're treated mostly + * separately throughout the code, although they both use the same key, which is assigned + * when they are created. + */ +public class StatusBarService extends IStatusBar.Stub +{ + static final String TAG = "StatusBar"; + static final boolean DEBUG = false; + static final boolean SPEW = false; + static final boolean DBG = false; + + static final int EXPANDED_LEAVE_ALONE = -10000; + static final int EXPANDED_FULL_OPEN = -10001; + + private static final int MSG_ANIMATE = 1000; + private static final int MSG_ANIMATE_REVEAL = 1001; + + private static final int OP_ADD_ICON = 1; + private static final int OP_UPDATE_ICON = 2; + private static final int OP_REMOVE_ICON = 3; + private static final int OP_SET_VISIBLE = 4; + private static final int OP_EXPAND = 5; + private static final int OP_TOGGLE = 6; + private static final int OP_DISABLE = 7; + private class PendingOp { + IBinder key; + int code; + IconData iconData; + NotificationData notificationData; + boolean visible; + int integer; + } + + private class DisableRecord implements IBinder.DeathRecipient { + String pkg; + int what; + IBinder token; + + public void binderDied() { + Log.i(TAG, "binder died for pkg=" + pkg); + disable(0, token, pkg); + } + } + + public interface NotificationCallbacks { + void onSetDisabled(int status); + void onClearAll(); + void onNotificationClick(String pkg, int id); + void onPanelRevealed(); + } + + private class ExpandedDialog extends Dialog { + ExpandedDialog(Context context) { + super(context, com.android.internal.R.style.Theme_Light_NoTitleBar); + } + + @Override + public boolean dispatchKeyEvent(KeyEvent event) { + boolean down = event.getAction() == KeyEvent.ACTION_DOWN; + switch (event.getKeyCode()) { + case KeyEvent.KEYCODE_BACK: + if (down) { + StatusBarService.this.deactivate(); + } + return true; + } + return super.dispatchKeyEvent(event); + } + } + + final Context mContext; + final Display mDisplay; + StatusBarView mStatusBarView; + int mPixelFormat; + H mHandler = new H(); + ArrayList<PendingOp> mQueue = new ArrayList<PendingOp>(); + NotificationCallbacks mNotificationCallbacks; + + // All accesses to mIconMap and mNotificationData are syncronized on those objects, + // but this is only so dump() can work correctly. Modifying these outside of the UI + // thread will not work, there are places in the code that unlock and reaquire between + // reads and require them to not be modified. + + // icons + HashMap<IBinder,StatusBarIcon> mIconMap = new HashMap<IBinder,StatusBarIcon>(); + ArrayList<StatusBarIcon> mIconList = new ArrayList<StatusBarIcon>(); + String[] mRightIconSlots; + StatusBarIcon[] mRightIcons; + LinearLayout mIcons; + IconMerger mNotificationIcons; + LinearLayout mStatusIcons; + StatusBarIcon mMoreIcon; + private UninstallReceiver mUninstallReceiver; + + // expanded notifications + NotificationViewList mNotificationData = new NotificationViewList(); + Dialog mExpandedDialog; + ExpandedView mExpandedView; + WindowManager.LayoutParams mExpandedParams; + ScrollView mScrollView; + View mNotificationLinearLayout; + TextView mOngoingTitle; + LinearLayout mOngoingItems; + TextView mLatestTitle; + LinearLayout mLatestItems; + TextView mNoNotificationsTitle; + TextView mSpnLabel; + TextView mPlmnLabel; + TextView mClearButton; + CloseDragHandle mCloseView; + int[] mCloseLocation = new int[2]; + boolean mExpanded; + boolean mExpandedVisible; + + // the date view + DateView mDateView; + + // the tracker view + TrackingView mTrackingView; + WindowManager.LayoutParams mTrackingParams; + int mTrackingPosition; + + // ticker + private Ticker mTicker; + private View mTickerView; + private boolean mTicking; + + // Tracking finger for opening/closing. + boolean mTracking; + VelocityTracker mVelocityTracker; + + static final int ANIM_FRAME_DURATION = (1000/60); + + boolean mAnimating; + long mCurAnimationTime; + float mDisplayHeight; + float mAnimY; + float mAnimVel; + float mAnimAccel; + long mAnimLastTime; + boolean mAnimatingReveal = false; + int mViewDelta; + int[] mAbsPos = new int[2]; + + // for disabling the status bar + ArrayList<DisableRecord> mDisableRecords = new ArrayList<DisableRecord>(); + int mDisabled = 0; + + /** + * Construct the service, add the status bar view to the window manager + */ + public StatusBarService(Context context) { + mContext = context; + mDisplay = ((WindowManager)context.getSystemService( + Context.WINDOW_SERVICE)).getDefaultDisplay(); + makeStatusBarView(context); + mUninstallReceiver = new UninstallReceiver(); + } + + public void setNotificationCallbacks(NotificationCallbacks listener) { + mNotificationCallbacks = listener; + } + + // ================================================================================ + // Constructing the view + // ================================================================================ + private void makeStatusBarView(Context context) { + Resources res = context.getResources(); + mRightIconSlots = res.getStringArray(com.android.internal.R.array.status_bar_icon_order); + mRightIcons = new StatusBarIcon[mRightIconSlots.length]; + + ExpandedView expanded = (ExpandedView)View.inflate(context, + com.android.internal.R.layout.status_bar_expanded, null); + expanded.mService = this; + StatusBarView sb = (StatusBarView)View.inflate(context, + com.android.internal.R.layout.status_bar, null); + sb.mService = this; + + // figure out which pixel-format to use for the status bar. + mPixelFormat = PixelFormat.TRANSLUCENT; + Drawable bg = sb.getBackground(); + if (bg != null) { + mPixelFormat = bg.getOpacity(); + } + + mStatusBarView = sb; + mStatusIcons = (LinearLayout)sb.findViewById(R.id.statusIcons); + mNotificationIcons = (IconMerger)sb.findViewById(R.id.notificationIcons); + mNotificationIcons.service = this; + mIcons = (LinearLayout)sb.findViewById(R.id.icons); + mTickerView = sb.findViewById(R.id.ticker); + mDateView = (DateView)sb.findViewById(R.id.date); + + mExpandedDialog = new ExpandedDialog(context); + mExpandedView = expanded; + mOngoingTitle = (TextView)expanded.findViewById(R.id.ongoingTitle); + mOngoingItems = (LinearLayout)expanded.findViewById(R.id.ongoingItems); + mLatestTitle = (TextView)expanded.findViewById(R.id.latestTitle); + mLatestItems = (LinearLayout)expanded.findViewById(R.id.latestItems); + mNoNotificationsTitle = (TextView)expanded.findViewById(R.id.noNotificationsTitle); + mClearButton = (TextView)expanded.findViewById(R.id.clear_all_button); + mClearButton.setOnClickListener(mClearButtonListener); + mSpnLabel = (TextView)expanded.findViewById(R.id.spnLabel); + mPlmnLabel = (TextView)expanded.findViewById(R.id.plmnLabel); + mScrollView = (ScrollView)expanded.findViewById(R.id.scroll); + mNotificationLinearLayout = expanded.findViewById(R.id.notificationLinearLayout); + + mOngoingTitle.setVisibility(View.GONE); + mLatestTitle.setVisibility(View.GONE); + + mTicker = new MyTicker(context, sb); + + TickerView tickerView = (TickerView)sb.findViewById(R.id.tickerText); + tickerView.mTicker = mTicker; + + mTrackingView = (TrackingView)View.inflate(context, + com.android.internal.R.layout.status_bar_tracking, null); + mTrackingView.mService = this; + mCloseView = (CloseDragHandle)mTrackingView.findViewById(R.id.close); + mCloseView.mService = this; + + // add the more icon for the notifications + IconData moreData = IconData.makeIcon(null, context.getPackageName(), + R.drawable.stat_notify_more, 0, 42); + mMoreIcon = new StatusBarIcon(context, moreData, mNotificationIcons); + mMoreIcon.view.setId(R.drawable.stat_notify_more); + mNotificationIcons.moreIcon = mMoreIcon; + mNotificationIcons.addView(mMoreIcon.view); + + // set the inital view visibility + setAreThereNotifications(); + mDateView.setVisibility(View.INVISIBLE); + + // before we register for broadcasts + mPlmnLabel.setText(R.string.lockscreen_carrier_default); + mPlmnLabel.setVisibility(View.VISIBLE); + mSpnLabel.setText(""); + mSpnLabel.setVisibility(View.GONE); + + // receive broadcasts + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_CONFIGURATION_CHANGED); + filter.addAction(Intent.ACTION_CLOSE_SYSTEM_DIALOGS); + filter.addAction(Telephony.Intents.SPN_STRINGS_UPDATED_ACTION); + context.registerReceiver(mBroadcastReceiver, filter); + } + + public void systemReady() { + final StatusBarView view = mStatusBarView; + WindowManager.LayoutParams lp = new WindowManager.LayoutParams( + ViewGroup.LayoutParams.FILL_PARENT, + view.getContext().getResources().getDimensionPixelSize( + com.android.internal.R.dimen.status_bar_height), + WindowManager.LayoutParams.TYPE_STATUS_BAR, + WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE| + WindowManager.LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING, + mPixelFormat); + lp.gravity = Gravity.TOP | Gravity.FILL_HORIZONTAL; + lp.setTitle("StatusBar"); + lp.windowAnimations = R.style.Animation_StatusBar; + + WindowManagerImpl.getDefault().addView(view, lp); + } + + // ================================================================================ + // From IStatusBar + // ================================================================================ + public void activate() { + enforceExpandStatusBar(); + addPendingOp(OP_EXPAND, null, true); + } + + public void deactivate() { + enforceExpandStatusBar(); + addPendingOp(OP_EXPAND, null, false); + } + + public void toggle() { + enforceExpandStatusBar(); + addPendingOp(OP_TOGGLE, null, false); + } + + public void disable(int what, IBinder token, String pkg) { + enforceStatusBar(); + synchronized (mNotificationCallbacks) { + // This is a little gross, but I think it's safe as long as nobody else + // synchronizes on mNotificationCallbacks. It's important that the the callback + // and the pending op get done in the correct order and not interleaved with + // other calls, otherwise they'll get out of sync. + int net; + synchronized (mDisableRecords) { + manageDisableListLocked(what, token, pkg); + net = gatherDisableActionsLocked(); + mNotificationCallbacks.onSetDisabled(net); + } + addPendingOp(OP_DISABLE, net); + } + } + + public IBinder addIcon(String slot, String iconPackage, int iconId, int iconLevel) { + enforceStatusBar(); + return addIcon(IconData.makeIcon(slot, iconPackage, iconId, iconLevel, 0), null); + } + + public void updateIcon(IBinder key, + String slot, String iconPackage, int iconId, int iconLevel) { + enforceStatusBar(); + updateIcon(key, IconData.makeIcon(slot, iconPackage, iconId, iconLevel, 0), null); + } + + public void removeIcon(IBinder key) { + enforceStatusBar(); + addPendingOp(OP_REMOVE_ICON, key, null, null, -1); + } + + private void enforceStatusBar() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.STATUS_BAR, + "StatusBarService"); + } + + private void enforceExpandStatusBar() { + mContext.enforceCallingOrSelfPermission( + android.Manifest.permission.EXPAND_STATUS_BAR, + "StatusBarService"); + } + + // ================================================================================ + // Can be called from any thread + // ================================================================================ + public IBinder addIcon(IconData data, NotificationData n) { + int slot; + // assert early-on if they using a slot that doesn't exist. + if (data != null && n == null) { + slot = getRightIconIndex(data.slot); + if (slot < 0) { + throw new SecurityException("invalid status bar icon slot: " + + (data.slot != null ? "'" + data.slot + "'" : "null")); + } + } else { + slot = -1; + } + IBinder key = new Binder(); + addPendingOp(OP_ADD_ICON, key, data, n, -1); + return key; + } + + public void updateIcon(IBinder key, IconData data, NotificationData n) { + addPendingOp(OP_UPDATE_ICON, key, data, n, -1); + } + + public void setIconVisibility(IBinder key, boolean visible) { + addPendingOp(OP_SET_VISIBLE, key, visible); + } + + private void addPendingOp(int code, IBinder key, IconData data, NotificationData n, int i) { + synchronized (mQueue) { + PendingOp op = new PendingOp(); + op.key = key; + op.code = code; + op.iconData = data == null ? null : data.clone(); + op.notificationData = n; + op.integer = i; + mQueue.add(op); + if (mQueue.size() == 1) { + mHandler.sendEmptyMessage(2); + } + } + } + + private void addPendingOp(int code, IBinder key, boolean visible) { + synchronized (mQueue) { + PendingOp op = new PendingOp(); + op.key = key; + op.code = code; + op.visible = visible; + mQueue.add(op); + if (mQueue.size() == 1) { + mHandler.sendEmptyMessage(1); + } + } + } + + private void addPendingOp(int code, int integer) { + synchronized (mQueue) { + PendingOp op = new PendingOp(); + op.code = code; + op.integer = integer; + mQueue.add(op); + if (mQueue.size() == 1) { + mHandler.sendEmptyMessage(1); + } + } + } + + // lock on mDisableRecords + void manageDisableListLocked(int what, IBinder token, String pkg) { + if (SPEW) { + Log.d(TAG, "manageDisableList what=0x" + Integer.toHexString(what) + + " pkg=" + pkg); + } + // update the list + synchronized (mDisableRecords) { + final int N = mDisableRecords.size(); + DisableRecord tok = null; + int i; + for (i=0; i<N; i++) { + DisableRecord t = mDisableRecords.get(i); + if (t.token == token) { + tok = t; + break; + } + } + if (what == 0 || !token.isBinderAlive()) { + if (tok != null) { + mDisableRecords.remove(i); + } + } else { + if (tok == null) { + tok = new DisableRecord(); + try { + token.linkToDeath(tok, 0); + } + catch (RemoteException ex) { + return; // give up + } + mDisableRecords.add(tok); + } + tok.what = what; + tok.token = token; + tok.pkg = pkg; + } + } + } + + // lock on mDisableRecords + int gatherDisableActionsLocked() { + final int N = mDisableRecords.size(); + // gather the new net flags + int net = 0; + for (int i=0; i<N; i++) { + net |= mDisableRecords.get(i).what; + } + return net; + } + + private int getRightIconIndex(String slot) { + final int N = mRightIconSlots.length; + for (int i=0; i<N; i++) { + if (mRightIconSlots[i].equals(slot)) { + return i; + } + } + return -1; + } + + // ================================================================================ + // Always called from UI thread + // ================================================================================ + /** + * All changes to the status bar and notifications funnel through here and are batched. + */ + private class H extends Handler { + public void handleMessage(Message m) { + if (m.what == MSG_ANIMATE) { + doAnimation(); + return; + } + if (m.what == MSG_ANIMATE_REVEAL) { + doRevealAnimation(); + return; + } + synchronized (mQueue) { + boolean wasExpanded = mExpanded; + + // for each one in the queue, find all of the ones with the same key + // and collapse that down into a final op and/or call to setVisibility, etc + boolean expand = wasExpanded; + boolean doExpand = false; + boolean doDisable = false; + int disableWhat = 0; + int N = mQueue.size(); + while (N > 0) { + PendingOp op = mQueue.get(0); + boolean doOp = false; + boolean visible = false; + boolean doVisibility = false; + if (op.code == OP_SET_VISIBLE) { + doVisibility = true; + visible = op.visible; + } + else if (op.code == OP_EXPAND) { + doExpand = true; + expand = op.visible; + } + else if (op.code == OP_TOGGLE) { + doExpand = true; + expand = !expand; + } + else { + doOp = true; + } + + if (alwaysHandle(op.code)) { + // coalesce these + for (int i=1; i<N; i++) { + PendingOp o = mQueue.get(i); + if (!alwaysHandle(o.code) && o.key == op.key) { + if (o.code == OP_SET_VISIBLE) { + visible = o.visible; + doVisibility = true; + } + else if (o.code == OP_EXPAND) { + expand = o.visible; + doExpand = true; + } + else { + op.code = o.code; + op.iconData = o.iconData; + op.notificationData = o.notificationData; + } + mQueue.remove(i); + i--; + N--; + } + } + } + + mQueue.remove(0); + N--; + + if (doOp) { + switch (op.code) { + case OP_ADD_ICON: + case OP_UPDATE_ICON: + performAddUpdateIcon(op.key, op.iconData, op.notificationData); + break; + case OP_REMOVE_ICON: + performRemoveIcon(op.key); + break; + case OP_DISABLE: + doDisable = true; + disableWhat = op.integer; + break; + } + } + if (doVisibility && op.code != OP_REMOVE_ICON) { + performSetIconVisibility(op.key, visible); + } + } + + if (mQueue.size() != 0) { + throw new RuntimeException("Assertion failed: mQueue.size=" + mQueue.size()); + } + if (doExpand) { + // this is last so that we capture all of the pending changes before doing it + if (expand) { + animateExpand(); + } else { + animateCollapse(); + } + } + if (doDisable) { + performDisableActions(disableWhat); + } + } + } + } + + private boolean alwaysHandle(int code) { + return code == OP_DISABLE; + } + + /* private */ void performAddUpdateIcon(IBinder key, IconData data, NotificationData n) + throws StatusBarException { + if (DBG) { + Log.d(TAG, "performAddUpdateIcon icon=" + data + " notification=" + n + " key=" + key); + } + // notification + if (n != null) { + StatusBarNotification notification = getNotification(key); + NotificationData oldData = null; + if (notification == null) { + // add + notification = new StatusBarNotification(); + notification.key = key; + notification.data = n; + synchronized (mNotificationData) { + mNotificationData.add(notification); + } + addNotificationView(notification); + setAreThereNotifications(); + } else { + // update + oldData = notification.data; + notification.data = n; + updateNotificationView(notification, oldData); + } + // Show the ticker if one is requested, and the text is different + // than the currently displayed ticker. Also don't do this + // until status bar window is attached to the window manager, + // because... well, what's the point otherwise? And trying to + // run a ticker without being attached will crash! + if (n.tickerText != null && mStatusBarView.getWindowToken() != null + && (oldData == null + || oldData.tickerText == null + || !CharSequences.equals(oldData.tickerText, n.tickerText))) { + if ((mDisabled & StatusBarManager.DISABLE_NOTIFICATION_ICONS) == 0) { + mTicker.addEntry(n, StatusBarIcon.getIcon(mContext, data), n.tickerText); + } + } + } + + // icon + synchronized (mIconMap) { + StatusBarIcon icon = mIconMap.get(key); + if (icon == null) { + // add + LinearLayout v = n == null ? mStatusIcons : mNotificationIcons; + + icon = new StatusBarIcon(mContext, data, v); + mIconMap.put(key, icon); + mIconList.add(icon); + + if (n == null) { + int slotIndex = getRightIconIndex(data.slot); + StatusBarIcon[] rightIcons = mRightIcons; + if (rightIcons[slotIndex] == null) { + int pos = 0; + for (int i=mRightIcons.length-1; i>slotIndex; i--) { + StatusBarIcon ic = rightIcons[i]; + if (ic != null) { + pos++; + } + } + rightIcons[slotIndex] = icon; + mStatusIcons.addView(icon.view, pos); + } else { + Log.e(TAG, "duplicate icon in slot " + slotIndex + "/" + data.slot); + mIconMap.remove(key); + mIconList.remove(icon); + return ; + } + } else { + int iconIndex = mNotificationData.getIconIndex(n); + mNotificationIcons.addView(icon.view, iconIndex); + } + } else { + if (n == null) { + // right hand side icons -- these don't reorder + icon.update(mContext, data); + } else { + // remove old + ViewGroup parent = (ViewGroup)icon.view.getParent(); + parent.removeView(icon.view); + // add new + icon.update(mContext, data); + int iconIndex = mNotificationData.getIconIndex(n); + mNotificationIcons.addView(icon.view, iconIndex); + } + } + } + } + + /* private */ void performSetIconVisibility(IBinder key, boolean visible) { + synchronized (mIconMap) { + if (DBG) { + Log.d(TAG, "performSetIconVisibility key=" + key + " visible=" + visible); + } + StatusBarIcon icon = mIconMap.get(key); + icon.view.setVisibility(visible ? View.VISIBLE : View.GONE); + } + } + + /* private */ void performRemoveIcon(IBinder key) { + synchronized (this) { + if (DBG) { + Log.d(TAG, "performRemoveIcon key=" + key); + } + StatusBarIcon icon = mIconMap.remove(key); + mIconList.remove(icon); + if (icon != null) { + ViewGroup parent = (ViewGroup)icon.view.getParent(); + parent.removeView(icon.view); + int slotIndex = getRightIconIndex(icon.mData.slot); + if (slotIndex >= 0) { + mRightIcons[slotIndex] = null; + } + } + StatusBarNotification notification = getNotification(key); + if (notification != null) { + removeNotificationView(notification); + synchronized (mNotificationData) { + mNotificationData.remove(notification); + } + setAreThereNotifications(); + } + } + } + + int getIconNumberForView(View v) { + synchronized (mIconMap) { + StatusBarIcon icon = null; + final int N = mIconList.size(); + for (int i=0; i<N; i++) { + StatusBarIcon ic = mIconList.get(i); + if (ic.view == v) { + icon = ic; + break; + } + } + if (icon != null) { + return icon.getNumber(); + } else { + return -1; + } + } + } + + + StatusBarNotification getNotification(IBinder key) { + synchronized (mNotificationData) { + return mNotificationData.get(key); + } + } + + View.OnFocusChangeListener mFocusChangeListener = new View.OnFocusChangeListener() { + public void onFocusChange(View v, boolean hasFocus) { + // Because 'v' is a ViewGroup, all its children will be (un)selected + // too, which allows marqueeing to work. + v.setSelected(hasFocus); + } + }; + + View makeNotificationView(StatusBarNotification notification, ViewGroup parent) { + NotificationData n = notification.data; + RemoteViews remoteViews = n.contentView; + if (remoteViews == null) { + return null; + } + + // create the row view + LayoutInflater inflater = (LayoutInflater)mContext.getSystemService( + Context.LAYOUT_INFLATER_SERVICE); + View row = inflater.inflate(com.android.internal.R.layout.status_bar_latest_event, parent, false); + + // bind the click event to the content area + ViewGroup content = (ViewGroup)row.findViewById(com.android.internal.R.id.content); + content.setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS); + content.setOnFocusChangeListener(mFocusChangeListener); + PendingIntent contentIntent = n.contentIntent; + if (contentIntent != null) { + content.setOnClickListener(new Launcher(contentIntent, n.pkg, n.id)); + } + + View child = null; + Exception exception = null; + try { + child = remoteViews.apply(mContext, content); + } + catch (RuntimeException e) { + exception = e; + } + if (child == null) { + Log.e(TAG, "couldn't inflate view for package " + n.pkg, exception); + return null; + } + content.addView(child); + + row.setDrawingCacheEnabled(true); + + notification.view = row; + notification.contentView = child; + + return row; + } + + void addNotificationView(StatusBarNotification notification) { + if (notification.view != null) { + throw new RuntimeException("Assertion failed: notification.view=" + + notification.view); + } + + LinearLayout parent = notification.data.ongoingEvent ? mOngoingItems : mLatestItems; + + View child = makeNotificationView(notification, parent); + if (child == null) { + return ; + } + + int index = mNotificationData.getExpandedIndex(notification); + parent.addView(child, index); + } + + /** + * Remove the old one and put the new one in its place. + * @param notification the notification + */ + void updateNotificationView(StatusBarNotification notification, NotificationData oldData) { + NotificationData n = notification.data; + if (oldData != null && n != null + && n.contentView != null && oldData.contentView != null + && n.contentView.getPackage() != null + && oldData.contentView.getPackage() != null + && oldData.contentView.getPackage().equals(n.contentView.getPackage()) + && oldData.contentView.getLayoutId() == n.contentView.getLayoutId()) { + mNotificationData.update(notification); + try { + n.contentView.reapply(mContext, notification.contentView); + + // update the contentIntent + ViewGroup content = (ViewGroup)notification.view.findViewById( + com.android.internal.R.id.content); + PendingIntent contentIntent = n.contentIntent; + if (contentIntent != null) { + content.setOnClickListener(new Launcher(contentIntent, n.pkg, n.id)); + } + } + catch (RuntimeException e) { + // It failed to add cleanly. Log, and remove the view from the panel. + Log.w(TAG, "couldn't reapply views for package " + n.contentView.getPackage(), e); + removeNotificationView(notification); + } + } else { + mNotificationData.update(notification); + removeNotificationView(notification); + addNotificationView(notification); + } + setAreThereNotifications(); + } + + void removeNotificationView(StatusBarNotification notification) { + View v = notification.view; + if (v != null) { + ViewGroup parent = (ViewGroup)v.getParent(); + parent.removeView(v); + notification.view = null; + } + } + + private void setAreThereNotifications() { + boolean ongoing = mOngoingItems.getChildCount() != 0; + boolean latest = mLatestItems.getChildCount() != 0; + + if (mNotificationData.hasClearableItems()) { + mClearButton.setVisibility(View.VISIBLE); + } else { + mClearButton.setVisibility(View.INVISIBLE); + } + + mOngoingTitle.setVisibility(ongoing ? View.VISIBLE : View.GONE); + mLatestTitle.setVisibility(latest ? View.VISIBLE : View.GONE); + + if (ongoing || latest) { + mNoNotificationsTitle.setVisibility(View.GONE); + } else { + mNoNotificationsTitle.setVisibility(View.VISIBLE); + } + } + + private void makeExpandedVisible() { + if (SPEW) Log.d(TAG, "Make expanded visible: expanded visible=" + mExpandedVisible); + if (mExpandedVisible) { + return; + } + mExpandedVisible = true; + panelSlightlyVisible(true); + + updateExpandedViewPos(EXPANDED_LEAVE_ALONE); + mExpandedDialog.show(); + mExpandedView.requestFocus(View.FOCUS_FORWARD); + mTrackingView.setVisibility(View.VISIBLE); + + if (!mTicking) { + setDateViewVisibility(true, com.android.internal.R.anim.fade_in); + } + } + + void animateExpand() { + if (SPEW) Log.d(TAG, "Animate expand: expanded=" + mExpanded); + if ((mDisabled & StatusBarManager.DISABLE_EXPAND) != 0) { + return ; + } + if (mExpanded) { + return; + } + + prepareTracking(0); + performFling(0, 2000.0f, true); + } + + void animateCollapse() { + if (SPEW) Log.d(TAG, "Animate collapse: expanded=" + mExpanded + + " expanded visible=" + mExpandedVisible); + + if (!mExpandedVisible) { + return; + } + + prepareTracking(mDisplay.getHeight()-1); + performFling(mDisplay.getHeight()-1, -2000.0f, true); + } + + void performExpand() { + if (SPEW) Log.d(TAG, "Perform expand: expanded=" + mExpanded); + if ((mDisabled & StatusBarManager.DISABLE_EXPAND) != 0) { + return ; + } + if (mExpanded) { + return; + } + + // It seems strange to sometimes not expand... + if (false) { + synchronized (mNotificationData) { + if (mNotificationData.size() == 0) { + return; + } + } + } + + mExpanded = true; + makeExpandedVisible(); + updateExpandedViewPos(EXPANDED_FULL_OPEN); + + if (false) postStartTracing(); + } + + void performCollapse() { + if (SPEW) Log.d(TAG, "Perform collapse: expanded=" + mExpanded + + " expanded visible=" + mExpandedVisible); + + if (!mExpandedVisible) { + return; + } + mExpandedVisible = false; + panelSlightlyVisible(false); + mExpandedDialog.hide(); + mTrackingView.setVisibility(View.GONE); + + if ((mDisabled & StatusBarManager.DISABLE_NOTIFICATION_ICONS) == 0) { + setNotificationIconVisibility(true, com.android.internal.R.anim.fade_in); + } + setDateViewVisibility(false, com.android.internal.R.anim.fade_out); + + if (!mExpanded) { + return; + } + mExpanded = false; + } + + void doAnimation() { + if (mAnimating) { + if (SPEW) Log.d(TAG, "doAnimation"); + if (SPEW) Log.d(TAG, "doAnimation before mAnimY=" + mAnimY); + incrementAnim(); + if (SPEW) Log.d(TAG, "doAnimation after mAnimY=" + mAnimY); + if (mAnimY >= mDisplay.getHeight()-1) { + if (SPEW) Log.d(TAG, "Animation completed to expanded state."); + mAnimating = false; + updateExpandedViewPos(EXPANDED_FULL_OPEN); + performExpand(); + } + else if (mAnimY < mStatusBarView.getHeight()) { + if (SPEW) Log.d(TAG, "Animation completed to collapsed state."); + mAnimating = false; + performCollapse(); + } + else { + updateExpandedViewPos((int)mAnimY); + mCurAnimationTime += ANIM_FRAME_DURATION; + mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE), mCurAnimationTime); + } + } + } + + void stopTracking() { + mTracking = false; + mVelocityTracker.recycle(); + mVelocityTracker = null; + } + + void incrementAnim() { + long now = SystemClock.uptimeMillis(); + float t = ((float)(now - mAnimLastTime)) / 1000; // ms -> s + final float y = mAnimY; + final float v = mAnimVel; // px/s + final float a = mAnimAccel; // px/s/s + mAnimY = y + (v*t) + (0.5f*a*t*t); // px + mAnimVel = v + (a*t); // px/s + mAnimLastTime = now; // ms + //Log.d(TAG, "y=" + y + " v=" + v + " a=" + a + " t=" + t + " mAnimY=" + mAnimY + // + " mAnimAccel=" + mAnimAccel); + } + + void doRevealAnimation() { + final int h = mCloseView.getHeight() + mStatusBarView.getHeight(); + if (mAnimatingReveal && mAnimating && mAnimY < h) { + incrementAnim(); + if (mAnimY >= h) { + mAnimY = h; + updateExpandedViewPos((int)mAnimY); + } else { + updateExpandedViewPos((int)mAnimY); + mCurAnimationTime += ANIM_FRAME_DURATION; + mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE_REVEAL), + mCurAnimationTime); + } + } + } + + void prepareTracking(int y) { + mTracking = true; + mVelocityTracker = VelocityTracker.obtain(); + boolean opening = !mExpanded; + if (!mExpanded) { + mAnimAccel = 2000.0f; + mAnimVel = 200; + mAnimY = mStatusBarView.getHeight(); + updateExpandedViewPos((int)mAnimY); + mAnimating = true; + mAnimatingReveal = true; + mHandler.removeMessages(MSG_ANIMATE); + mHandler.removeMessages(MSG_ANIMATE_REVEAL); + long now = SystemClock.uptimeMillis(); + mAnimLastTime = now; + mCurAnimationTime = now + ANIM_FRAME_DURATION; + mAnimating = true; + mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE_REVEAL), + mCurAnimationTime); + } else { + // it's open, close it? + if (mAnimating) { + mAnimating = false; + mHandler.removeMessages(MSG_ANIMATE); + } + } + if (opening) { + makeExpandedVisible(); + } else { + updateExpandedViewPos(y + mViewDelta); + } + } + + void performFling(int y, float vel, boolean always) { + mAnimatingReveal = false; + mDisplayHeight = mDisplay.getHeight(); + + mAnimY = y; + mAnimVel = vel; + + //Log.d(TAG, "starting with mAnimY=" + mAnimY + " mAnimVel=" + mAnimVel); + + if (mExpanded) { + if (!always && ( + vel > 200.0f + || (y > (mDisplayHeight-25) && vel > -200.0f))) { + // We are expanded, but they didn't move sufficiently to cause + // us to retract. Animate back to the expanded position. + mAnimAccel = 2000.0f; + if (vel < 0) { + mAnimVel = 0; + } + } + else { + // We are expanded and are now going to animate away. + mAnimAccel = -2000.0f; + if (vel > 0) { + mAnimVel = 0; + } + } + } else { + if (always || ( + vel > 200.0f + || (y > (mDisplayHeight/2) && vel > -200.0f))) { + // We are collapsed, and they moved enough to allow us to + // expand. Animate in the notifications. + mAnimAccel = 2000.0f; + if (vel < 0) { + mAnimVel = 0; + } + } + else { + // We are collapsed, but they didn't move sufficiently to cause + // us to retract. Animate back to the collapsed position. + mAnimAccel = -2000.0f; + if (vel > 0) { + mAnimVel = 0; + } + } + } + //Log.d(TAG, "mAnimY=" + mAnimY + " mAnimVel=" + mAnimVel + // + " mAnimAccel=" + mAnimAccel); + + long now = SystemClock.uptimeMillis(); + mAnimLastTime = now; + mCurAnimationTime = now + ANIM_FRAME_DURATION; + mAnimating = true; + mHandler.removeMessages(MSG_ANIMATE); + mHandler.removeMessages(MSG_ANIMATE_REVEAL); + mHandler.sendMessageAtTime(mHandler.obtainMessage(MSG_ANIMATE), mCurAnimationTime); + stopTracking(); + } + + boolean interceptTouchEvent(MotionEvent event) { + if (SPEW) Log.d(TAG, "Touch: rawY=" + event.getRawY() + " event=" + event); + + if ((mDisabled & StatusBarManager.DISABLE_EXPAND) != 0) { + return true; + } + + final int statusBarSize = mStatusBarView.getHeight(); + final int hitSize = statusBarSize*2; + if (event.getAction() == MotionEvent.ACTION_DOWN) { + int y = (int)event.getRawY(); + + if (!mExpanded) { + mViewDelta = statusBarSize - y; + } else { + mTrackingView.getLocationOnScreen(mAbsPos); + mViewDelta = mAbsPos[1] + mTrackingView.getHeight() - y; + } + if ((!mExpanded && y < hitSize) || + (mExpanded && y > (mDisplay.getHeight()-hitSize))) { + prepareTracking(y); + mVelocityTracker.addMovement(event); + } + } else if (mTracking) { + mVelocityTracker.addMovement(event); + final int minY = statusBarSize + mCloseView.getHeight(); + if (event.getAction() == MotionEvent.ACTION_MOVE) { + int y = (int)event.getRawY(); + if (mAnimatingReveal && y < minY) { + // nothing + } else { + mAnimatingReveal = false; + updateExpandedViewPos(y + mViewDelta); + } + } else if (event.getAction() == MotionEvent.ACTION_UP) { + mVelocityTracker.computeCurrentVelocity(1000); + + float yVel = mVelocityTracker.getYVelocity(); + boolean negative = yVel < 0; + + float xVel = mVelocityTracker.getXVelocity(); + if (xVel < 0) { + xVel = -xVel; + } + if (xVel > 150.0f) { + xVel = 150.0f; // limit how much we care about the x axis + } + + float vel = (float)Math.hypot(yVel, xVel); + if (negative) { + vel = -vel; + } + + performFling((int)event.getRawY(), vel, false); + } + + } + return false; + } + + private class Launcher implements View.OnClickListener { + private PendingIntent mIntent; + private String mPkg; + private int mId; + + Launcher(PendingIntent intent, String pkg, int id) { + mIntent = intent; + mPkg = pkg; + mId = id; + } + + public void onClick(View v) { + try { + mIntent.send(); + mNotificationCallbacks.onNotificationClick(mPkg, mId); + } catch (PendingIntent.CanceledException e) { + // the stack trace isn't very helpful here. Just log the exception message. + Log.w(TAG, "Sending contentIntent failed: " + e); + } + deactivate(); + } + } + + private class MyTicker extends Ticker { + MyTicker(Context context, StatusBarView sb) { + super(context, sb); + } + + @Override + void tickerStarting() { + mTicking = true; + mIcons.setVisibility(View.GONE); + mTickerView.setVisibility(View.VISIBLE); + mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.push_up_in, null)); + mIcons.startAnimation(loadAnim(com.android.internal.R.anim.push_up_out, null)); + if (mExpandedVisible) { + setDateViewVisibility(false, com.android.internal.R.anim.push_up_out); + } + } + + @Override + void tickerDone() { + mIcons.setVisibility(View.VISIBLE); + mTickerView.setVisibility(View.GONE); + mIcons.startAnimation(loadAnim(com.android.internal.R.anim.push_down_in, null)); + mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.push_down_out, + mTickingDoneListener)); + if (mExpandedVisible) { + setDateViewVisibility(true, com.android.internal.R.anim.push_down_in); + } + } + + void tickerHalting() { + mIcons.setVisibility(View.VISIBLE); + mTickerView.setVisibility(View.GONE); + mIcons.startAnimation(loadAnim(com.android.internal.R.anim.fade_in, null)); + mTickerView.startAnimation(loadAnim(com.android.internal.R.anim.fade_out, + mTickingDoneListener)); + if (mExpandedVisible) { + setDateViewVisibility(true, com.android.internal.R.anim.fade_in); + } + } + } + + Animation.AnimationListener mTickingDoneListener = new Animation.AnimationListener() {; + public void onAnimationEnd(Animation animation) { + mTicking = false; + } + public void onAnimationRepeat(Animation animation) { + } + public void onAnimationStart(Animation animation) { + } + }; + + private Animation loadAnim(int id, Animation.AnimationListener listener) { + Animation anim = AnimationUtils.loadAnimation(mContext, id); + if (listener != null) { + anim.setAnimationListener(listener); + } + return anim; + } + + public String viewInfo(View v) { + return "(" + v.getLeft() + "," + v.getTop() + ")(" + v.getRight() + "," + v.getBottom() + + " " + v.getWidth() + "x" + v.getHeight() + ")"; + } + + protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { + if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) + != PackageManager.PERMISSION_GRANTED) { + pw.println("Permission Denial: can't dump StatusBar from from pid=" + + Binder.getCallingPid() + + ", uid=" + Binder.getCallingUid()); + return; + } + + synchronized (mQueue) { + pw.println("Current Status Bar state:"); + pw.println(" mExpanded=" + mExpanded + + ", mExpandedVisible=" + mExpandedVisible); + pw.println(" mTicking=" + mTicking); + pw.println(" mTracking=" + mTracking); + pw.println(" mAnimating=" + mAnimating + + ", mAnimY=" + mAnimY + ", mAnimVel=" + mAnimVel + + ", mAnimAccel=" + mAnimAccel); + pw.println(" mCurAnimationTime=" + mCurAnimationTime + + " mAnimLastTime=" + mAnimLastTime); + pw.println(" mDisplayHeight=" + mDisplayHeight + + " mAnimatingReveal=" + mAnimatingReveal + + " mViewDelta=" + mViewDelta); + pw.println(" mDisplayHeight=" + mDisplayHeight); + final int N = mQueue.size(); + pw.println(" mQueue.size=" + N); + for (int i=0; i<N; i++) { + PendingOp op = mQueue.get(i); + pw.println(" [" + i + "] key=" + op.key + " code=" + op.code + " visible=" + + op.visible); + pw.println(" iconData=" + op.iconData); + pw.println(" notificationData=" + op.notificationData); + } + pw.println(" mExpandedParams: " + mExpandedParams); + pw.println(" mExpandedView: " + viewInfo(mExpandedView)); + pw.println(" mExpandedDialog: " + mExpandedDialog); + pw.println(" mTrackingParams: " + mTrackingParams); + pw.println(" mTrackingView: " + viewInfo(mTrackingView)); + pw.println(" mOngoingTitle: " + viewInfo(mOngoingTitle)); + pw.println(" mOngoingItems: " + viewInfo(mOngoingItems)); + pw.println(" mLatestTitle: " + viewInfo(mLatestTitle)); + pw.println(" mLatestItems: " + viewInfo(mLatestItems)); + pw.println(" mNoNotificationsTitle: " + viewInfo(mNoNotificationsTitle)); + pw.println(" mCloseView: " + viewInfo(mCloseView)); + pw.println(" mTickerView: " + viewInfo(mTickerView)); + pw.println(" mScrollView: " + viewInfo(mScrollView) + + " scroll " + mScrollView.getScrollX() + "," + mScrollView.getScrollY()); + pw.println("mNotificationLinearLayout: " + viewInfo(mNotificationLinearLayout)); + } + synchronized (mIconMap) { + final int N = mIconMap.size(); + pw.println(" mIconMap.size=" + N); + Set<IBinder> keys = mIconMap.keySet(); + int i=0; + for (IBinder key: keys) { + StatusBarIcon icon = mIconMap.get(key); + pw.println(" [" + i + "] key=" + key); + pw.println(" data=" + icon.mData); + i++; + } + } + synchronized (mNotificationData) { + int N = mNotificationData.ongoingCount(); + pw.println(" ongoingCount.size=" + N); + for (int i=0; i<N; i++) { + StatusBarNotification n = mNotificationData.getOngoing(i); + pw.println(" [" + i + "] key=" + n.key + " view=" + n.view); + pw.println(" data=" + n.data); + } + N = mNotificationData.latestCount(); + pw.println(" ongoingCount.size=" + N); + for (int i=0; i<N; i++) { + StatusBarNotification n = mNotificationData.getLatest(i); + pw.println(" [" + i + "] key=" + n.key + " view=" + n.view); + pw.println(" data=" + n.data); + } + } + synchronized (mDisableRecords) { + final int N = mDisableRecords.size(); + pw.println(" mDisableRecords.size=" + N + + " mDisabled=0x" + Integer.toHexString(mDisabled)); + for (int i=0; i<N; i++) { + DisableRecord tok = mDisableRecords.get(i); + pw.println(" [" + i + "] what=0x" + Integer.toHexString(tok.what) + + " pkg=" + tok.pkg + " token=" + tok.token); + } + } + + if (false) { + pw.println("see the logcat for a dump of the views we have created."); + // must happen on ui thread + mHandler.post(new Runnable() { + public void run() { + mStatusBarView.getLocationOnScreen(mAbsPos); + Log.d(TAG, "mStatusBarView: ----- (" + mAbsPos[0] + "," + mAbsPos[1] + + ") " + mStatusBarView.getWidth() + "x" + + mStatusBarView.getHeight()); + mStatusBarView.debug(); + + mExpandedView.getLocationOnScreen(mAbsPos); + Log.d(TAG, "mExpandedView: ----- (" + mAbsPos[0] + "," + mAbsPos[1] + + ") " + mExpandedView.getWidth() + "x" + + mExpandedView.getHeight()); + mExpandedView.debug(); + + mTrackingView.getLocationOnScreen(mAbsPos); + Log.d(TAG, "mTrackingView: ----- (" + mAbsPos[0] + "," + mAbsPos[1] + + ") " + mTrackingView.getWidth() + "x" + + mTrackingView.getHeight()); + mTrackingView.debug(); + } + }); + } + } + + void onBarViewAttached() { + WindowManager.LayoutParams lp; + int pixelFormat; + Drawable bg; + + /// ---------- Tracking View -------------- + pixelFormat = PixelFormat.TRANSLUCENT; + bg = mTrackingView.getBackground(); + if (bg != null) { + pixelFormat = bg.getOpacity(); + } + + lp = new WindowManager.LayoutParams( + ViewGroup.LayoutParams.FILL_PARENT, + ViewGroup.LayoutParams.FILL_PARENT, + WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL, + WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN + | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS + | WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, + pixelFormat); +// lp.token = mStatusBarView.getWindowToken(); + lp.gravity = Gravity.TOP | Gravity.FILL_HORIZONTAL; + lp.setTitle("TrackingView"); + mTrackingParams = lp; + + WindowManagerImpl.getDefault().addView(mTrackingView, lp); + } + + void onTrackingViewAttached() { + WindowManager.LayoutParams lp; + int pixelFormat; + Drawable bg; + + /// ---------- Expanded View -------------- + pixelFormat = PixelFormat.TRANSLUCENT; + bg = mExpandedView.getBackground(); + if (bg != null) { + pixelFormat = bg.getOpacity(); + } + + lp = mExpandedDialog.getWindow().getAttributes(); + lp.width = ViewGroup.LayoutParams.FILL_PARENT; + lp.height = ViewGroup.LayoutParams.WRAP_CONTENT; + lp.x = 0; + lp.y = 0; + lp.type = WindowManager.LayoutParams.TYPE_STATUS_BAR_PANEL; + lp.flags = WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN + | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS + | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL + | WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM; + lp.format = pixelFormat; + lp.gravity = Gravity.TOP | Gravity.FILL_HORIZONTAL; + lp.setTitle("StatusBarExpanded"); + mExpandedDialog.getWindow().setAttributes(lp); + mExpandedParams = lp; + + mExpandedDialog.getWindow().requestFeature(Window.FEATURE_NO_TITLE); + mExpandedDialog.setContentView(mExpandedView, + new ViewGroup.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT, + ViewGroup.LayoutParams.WRAP_CONTENT)); + mExpandedDialog.show(); + mExpandedDialog.hide(); + View hack = (View)mExpandedView.getParent(); + } + + void setDateViewVisibility(boolean visible, int anim) { + mDateView.setUpdates(visible); + mDateView.setVisibility(visible ? View.VISIBLE : View.INVISIBLE); + mDateView.startAnimation(loadAnim(anim, null)); + } + + void setNotificationIconVisibility(boolean visible, int anim) { + int old = mNotificationIcons.getVisibility(); + int v = visible ? View.VISIBLE : View.INVISIBLE; + if (old != v) { + mNotificationIcons.setVisibility(v); + mNotificationIcons.startAnimation(loadAnim(anim, null)); + } + } + + void updateExpandedViewPos(int expandedPosition) { + if (SPEW) { + Log.d(TAG, "updateExpandedViewPos before pos=" + expandedPosition + + " mTrackingParams.y=" + mTrackingParams.y + + " mTrackingPosition=" + mTrackingPosition); + } + + // If the expanded view is not visible, there is no reason to do + // any work. + if (!mExpandedVisible) { + return; + } + + // tracking view... + int h = mStatusBarView.getHeight(); + int disph = mDisplay.getHeight(); + int pos; + if (expandedPosition == EXPANDED_FULL_OPEN) { + pos = h; + } + else if (expandedPosition == EXPANDED_LEAVE_ALONE) { + pos = mTrackingPosition; + } + else { + if (expandedPosition <= disph) { + pos = expandedPosition; + } else { + pos = disph; + } + pos -= disph-h; + } + mTrackingPosition = mTrackingParams.y = pos; + mTrackingParams.height = disph-h; + WindowManagerImpl.getDefault().updateViewLayout(mTrackingView, mTrackingParams); + + mCloseView.getLocationInWindow(mCloseLocation); + + if (mExpandedParams != null) { + mExpandedParams.y = pos + mTrackingView.getHeight() + - (mTrackingParams.height-mCloseLocation[1]) - mExpandedView.getHeight(); + int max = h; + if (mExpandedParams.y > max) { + mExpandedParams.y = max; + } + int min = mTrackingPosition; + if (mExpandedParams.y < min) { + mExpandedParams.y = min; + } + + /* + Log.d(TAG, "mTrackingPosition=" + mTrackingPosition + + " mTrackingView.height=" + mTrackingView.getHeight() + + " diff=" + (mTrackingPosition + mTrackingView.getHeight()) + + " h=" + h); + */ + panelSlightlyVisible((mTrackingPosition + mTrackingView.getHeight()) > h); + mExpandedDialog.getWindow().setAttributes(mExpandedParams); + } + + if (SPEW) { + Log.d(TAG, "updateExpandedViewPos after expandedPosition=" + expandedPosition + + " mTrackingParams.y=" + mTrackingParams.y + + " mTrackingPosition=" + mTrackingPosition + + " mExpandedParams.y=" + mExpandedParams.y); + } + } + + void updateAvailableHeight() { + if (mExpandedView != null) { + int disph = mDisplay.getHeight(); + int h = mStatusBarView.getHeight(); + int max = disph - (mCloseView.getHeight() + h); + mExpandedView.setMaxHeight(max); + } + } + + /** + * The LEDs are turned o)ff when the notification panel is shown, even just a little bit. + * This was added last-minute and is inconsistent with the way the rest of the notifications + * are handled, because the notification isn't really cancelled. The lights are just + * turned off. If any other notifications happen, the lights will turn back on. Steve says + * this is what he wants. (see bug 1131461) + */ + private boolean mPanelSlightlyVisible; + void panelSlightlyVisible(boolean visible) { + if (mPanelSlightlyVisible != visible) { + mPanelSlightlyVisible = visible; + if (visible) { + // tell the notification manager to turn off the lights. + mNotificationCallbacks.onPanelRevealed(); + } + } + } + + void performDisableActions(int net) { + int old = mDisabled; + int diff = net ^ old; + mDisabled = net; + + // act accordingly + if ((diff & StatusBarManager.DISABLE_EXPAND) != 0) { + if ((net & StatusBarManager.DISABLE_EXPAND) != 0) { + performCollapse(); + } + } + if ((diff & StatusBarManager.DISABLE_NOTIFICATION_ICONS) != 0) { + if ((net & StatusBarManager.DISABLE_NOTIFICATION_ICONS) != 0) { + Log.d(TAG, "DISABLE_NOTIFICATION_ICONS: yes"); + if (mTicking) { + mNotificationIcons.setVisibility(View.INVISIBLE); + mTicker.halt(); + } else { + setNotificationIconVisibility(false, com.android.internal.R.anim.fade_out); + } + } else { + Log.d(TAG, "DISABLE_NOTIFICATION_ICONS: no"); + if (!mExpandedVisible) { + setNotificationIconVisibility(true, com.android.internal.R.anim.fade_in); + } + } + } + } + + private View.OnClickListener mClearButtonListener = new View.OnClickListener() { + public void onClick(View v) { + mNotificationCallbacks.onClearAll(); + performCollapse(); + } + }; + + private BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { + public void onReceive(Context context, Intent intent) { + String action = intent.getAction(); + if (Intent.ACTION_CLOSE_SYSTEM_DIALOGS.equals(action)) { + deactivate(); + } + else if (Telephony.Intents.SPN_STRINGS_UPDATED_ACTION.equals(action)) { + updateNetworkName(intent.getBooleanExtra(Telephony.Intents.EXTRA_SHOW_SPN, false), + intent.getStringExtra(Telephony.Intents.EXTRA_SPN), + intent.getBooleanExtra(Telephony.Intents.EXTRA_SHOW_PLMN, false), + intent.getStringExtra(Telephony.Intents.EXTRA_PLMN)); + } + else if (Intent.ACTION_CONFIGURATION_CHANGED.equals(action)) { + updateResources(); + } + } + }; + + void updateNetworkName(boolean showSpn, String spn, boolean showPlmn, String plmn) { + if (false) { + Log.d(TAG, "updateNetworkName showSpn=" + showSpn + " spn=" + spn + + " showPlmn=" + showPlmn + " plmn=" + plmn); + } + boolean something = false; + if (showPlmn) { + mPlmnLabel.setVisibility(View.VISIBLE); + if (plmn != null) { + mPlmnLabel.setText(plmn); + } else { + mPlmnLabel.setText(R.string.lockscreen_carrier_default); + } + } else { + mPlmnLabel.setText(""); + mPlmnLabel.setVisibility(View.GONE); + } + if (showSpn && spn != null) { + mSpnLabel.setText(spn); + mSpnLabel.setVisibility(View.VISIBLE); + something = true; + } else { + mSpnLabel.setText(""); + mSpnLabel.setVisibility(View.GONE); + } + } + + /** + * Reload some of our resources when the configuration changes. + * + * We don't reload everything when the configuration changes -- we probably + * should, but getting that smooth is tough. Someday we'll fix that. In the + * meantime, just update the things that we know change. + */ + void updateResources() { + mClearButton.setText(mContext.getText(R.string.status_bar_clear_all_button)); + mOngoingTitle.setText(mContext.getText(R.string.status_bar_ongoing_events_title)); + mLatestTitle.setText(mContext.getText(R.string.status_bar_latest_events_title)); + mNoNotificationsTitle.setText(mContext.getText(R.string.status_bar_no_notifications_title)); + Log.d(TAG, "updateResources"); + } + + // + // tracing + // + + void postStartTracing() { + mHandler.postDelayed(mStartTracing, 3000); + } + + void vibrate() { + android.os.Vibrator vib = (android.os.Vibrator)mContext.getSystemService( + Context.VIBRATOR_SERVICE); + vib.vibrate(250); + } + + Runnable mStartTracing = new Runnable() { + public void run() { + vibrate(); + SystemClock.sleep(250); + Log.d(TAG, "startTracing"); + android.os.Debug.startMethodTracing("/data/statusbar-traces/trace"); + mHandler.postDelayed(mStopTracing, 10000); + } + }; + + Runnable mStopTracing = new Runnable() { + public void run() { + android.os.Debug.stopMethodTracing(); + Log.d(TAG, "stopTracing"); + vibrate(); + } + }; + + class UninstallReceiver extends BroadcastReceiver { + public UninstallReceiver() { + IntentFilter filter = new IntentFilter(); + filter.addAction(Intent.ACTION_PACKAGE_REMOVED); + filter.addAction(Intent.ACTION_PACKAGE_RESTARTED); + filter.addDataScheme("package"); + mContext.registerReceiver(this, filter); + } + + @Override + public void onReceive(Context context, Intent intent) { + ArrayList<StatusBarNotification> list = null; + synchronized (StatusBarService.this) { + Uri data = intent.getData(); + if (data != null) { + String pkg = data.getSchemeSpecificPart(); + list = mNotificationData.notificationsForPackage(pkg); + } + } + + if (list != null) { + final int N = list.size(); + for (int i=0; i<N; i++) { + removeIcon(list.get(i).key); + } + } + } + } +} diff --git a/services/java/com/android/server/status/StatusBarView.java b/services/java/com/android/server/status/StatusBarView.java new file mode 100644 index 0000000..35dfb81 --- /dev/null +++ b/services/java/com/android/server/status/StatusBarView.java @@ -0,0 +1,134 @@ +package com.android.server.status; + +import android.content.Context; +import android.util.AttributeSet; +import android.util.Log; +import android.view.KeyEvent; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewGroup; +import android.view.ViewParent; +import android.widget.FrameLayout; + +import com.android.internal.R; + +public class StatusBarView extends FrameLayout { + private static final String TAG = "StatusBarView"; + + StatusBarService mService; + boolean mTracking; + int mStartX, mStartY; + ViewGroup mNotificationIcons; + ViewGroup mStatusIcons; + View mDate; + FixedSizeDrawable mBackground; + + public StatusBarView(Context context, AttributeSet attrs) { + super(context, attrs); + } + + @Override + protected void onFinishInflate() { + super.onFinishInflate(); + mNotificationIcons = (ViewGroup)findViewById(R.id.notificationIcons); + mStatusIcons = (ViewGroup)findViewById(R.id.statusIcons); + mDate = findViewById(R.id.date); + + mBackground = new FixedSizeDrawable(mDate.getBackground()); + mBackground.setFixedBounds(0, 0, 0, 0); + mDate.setBackgroundDrawable(mBackground); + } + + @Override + protected void onAttachedToWindow() { + super.onAttachedToWindow(); + mService.onBarViewAttached(); + } + + @Override + protected void onSizeChanged(int w, int h, int oldw, int oldh) { + super.onSizeChanged(w, h, oldw, oldh); + mService.updateExpandedViewPos(StatusBarService.EXPANDED_LEAVE_ALONE); + } + + @Override + protected void onLayout(boolean changed, int l, int t, int r, int b) { + super.onLayout(changed, l, t, r, b); + + // put the date date view quantized to the icons + int oldDateRight = mDate.getRight(); + int newDateRight; + + newDateRight = getDateSize(mNotificationIcons, oldDateRight, + getViewOffset(mNotificationIcons)); + if (newDateRight < 0) { + int offset = getViewOffset(mStatusIcons); + if (oldDateRight < offset) { + newDateRight = oldDateRight; + } else { + newDateRight = getDateSize(mStatusIcons, oldDateRight, offset); + if (newDateRight < 0) { + newDateRight = r; + } + } + } + int max = r - getPaddingRight(); + if (newDateRight > max) { + newDateRight = max; + } + + mDate.layout(mDate.getLeft(), mDate.getTop(), newDateRight, mDate.getBottom()); + mBackground.setFixedBounds(-mDate.getLeft(), -mDate.getTop(), (r-l), (b-t)); + } + + /** + * Gets the left position of v in this view. Throws if v is not + * a child of this. + */ + private int getViewOffset(View v) { + int offset = 0; + while (v != this) { + offset += v.getLeft(); + ViewParent p = v.getParent(); + if (v instanceof View) { + v = (View)p; + } else { + throw new RuntimeException(v + " is not a child of " + this); + } + } + return offset; + } + + private int getDateSize(ViewGroup g, int w, int offset) { + final int N = g.getChildCount(); + for (int i=0; i<N; i++) { + View v = g.getChildAt(i); + int l = v.getLeft() + offset; + int r = v.getRight() + offset; + if (w >= l && w <= r) { + return r; + } + } + return -1; + } + + /** + * Ensure that, if there is no target under us to receive the touch, + * that we process it ourself. This makes sure that onInterceptTouchEvent() + * is always called for the entire gesture. + */ + @Override + public boolean onTouchEvent(MotionEvent event) { + if (event.getAction() != MotionEvent.ACTION_DOWN) { + mService.interceptTouchEvent(event); + } + return true; + } + + @Override + public boolean onInterceptTouchEvent(MotionEvent event) { + return mService.interceptTouchEvent(event) + ? true : super.onInterceptTouchEvent(event); + } +} + diff --git a/services/java/com/android/server/status/Ticker.java b/services/java/com/android/server/status/Ticker.java new file mode 100644 index 0000000..c93ee0d --- /dev/null +++ b/services/java/com/android/server/status/Ticker.java @@ -0,0 +1,230 @@ +package com.android.server.status; + +import com.android.internal.R; + +import android.content.Context; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.text.StaticLayout; +import android.text.Layout.Alignment; +import android.text.TextPaint; +import android.text.TextUtils; +import android.util.Log; +import android.view.View; +import android.view.animation.Animation; +import android.view.animation.AnimationUtils; +import android.widget.TextSwitcher; +import android.widget.TextView; +import android.widget.ImageSwitcher; + +import java.util.ArrayList; + + +abstract class Ticker { + private static final int TICKER_SEGMENT_DELAY = 3000; + + private final class Segment { + NotificationData notificationData; + Drawable icon; + CharSequence text; + int current; + int next; + boolean first; + + StaticLayout getLayout(CharSequence substr) { + int w = mTextSwitcher.getWidth() - mTextSwitcher.getPaddingLeft() + - mTextSwitcher.getPaddingRight(); + return new StaticLayout(substr, mPaint, w, Alignment.ALIGN_NORMAL, 1, 0, true); + } + + CharSequence rtrim(CharSequence substr, int start, int end) { + while (end > start && !TextUtils.isGraphic(substr.charAt(end-1))) { + end--; + } + if (end > start) { + return substr.subSequence(start, end); + } + return null; + } + + /** returns null if there is no more text */ + CharSequence getText() { + if (this.current > this.text.length()) { + return null; + } + CharSequence substr = this.text.subSequence(this.current, this.text.length()); + StaticLayout l = getLayout(substr); + int lineCount = l.getLineCount(); + if (lineCount > 0) { + int start = l.getLineStart(0); + int end = l.getLineEnd(0); + this.next = this.current + end; + return rtrim(substr, start, end); + } else { + throw new RuntimeException("lineCount=" + lineCount + " current=" + current + + " text=" + text); + } + } + + /** returns null if there is no more text */ + CharSequence advance() { + this.first = false; + int index = this.next; + final int len = this.text.length(); + while (index < len && !TextUtils.isGraphic(this.text.charAt(index))) { + index++; + } + if (index >= len) { + return null; + } + + CharSequence substr = this.text.subSequence(index, this.text.length()); + StaticLayout l = getLayout(substr); + final int lineCount = l.getLineCount(); + int i; + for (i=0; i<lineCount; i++) { + int start = l.getLineStart(i); + int end = l.getLineEnd(i); + if (i == lineCount-1) { + this.next = len; + } else { + this.next = index + l.getLineStart(i+1); + } + CharSequence result = rtrim(substr, start, end); + if (result != null) { + this.current = index + start; + return result; + } + } + this.current = len; + return null; + } + + Segment(NotificationData n, Drawable icon, CharSequence text) { + this.notificationData = n; + this.icon = icon; + this.text = text; + int index = 0; + final int len = text.length(); + while (index < len && !TextUtils.isGraphic(text.charAt(index))) { + index++; + } + this.current = index; + this.next = index; + this.first = true; + } + }; + + private Handler mHandler = new Handler(); + private ArrayList<Segment> mSegments = new ArrayList(); + private TextPaint mPaint; + private View mTickerView; + private ImageSwitcher mIconSwitcher; + private TextSwitcher mTextSwitcher; + + Ticker(Context context, StatusBarView sb) { + mTickerView = sb.findViewById(R.id.ticker); + + mIconSwitcher = (ImageSwitcher)sb.findViewById(R.id.tickerIcon); + mIconSwitcher.setInAnimation( + AnimationUtils.loadAnimation(context, com.android.internal.R.anim.push_up_in)); + mIconSwitcher.setOutAnimation( + AnimationUtils.loadAnimation(context, com.android.internal.R.anim.push_up_out)); + + mTextSwitcher = (TextSwitcher)sb.findViewById(R.id.tickerText); + mTextSwitcher.setInAnimation( + AnimationUtils.loadAnimation(context, com.android.internal.R.anim.push_up_in)); + mTextSwitcher.setOutAnimation( + AnimationUtils.loadAnimation(context, com.android.internal.R.anim.push_up_out)); + + // Copy the paint style of one of the TextSwitchers children to use later for measuring + TextView text = (TextView)mTextSwitcher.getChildAt(0); + mPaint = text.getPaint(); + } + + void addEntry(NotificationData n, Drawable icon, CharSequence text) { + int initialCount = mSegments.size(); + + Segment newSegment = new Segment(n, icon, text); + + // prune out any preexisting ones for this notification, but not the current one. + // let that finish, even if it's the same id + for (int i=1; i<initialCount; i++) { + Segment seg = mSegments.get(i); + if (n.id == seg.notificationData.id && n.pkg.equals(seg.notificationData.pkg)) { + // just update that one to use this new data instead + mSegments.set(i, newSegment); + // and since we know initialCount != 0, just return + return ; + } + } + + mSegments.add(newSegment); + + if (initialCount == 0 && mSegments.size() > 0) { + Segment seg = mSegments.get(0); + seg.first = false; + + mIconSwitcher.setAnimateFirstView(false); + mIconSwitcher.reset(); + mIconSwitcher.setImageDrawable(seg.icon); + + mTextSwitcher.setAnimateFirstView(false); + mTextSwitcher.reset(); + mTextSwitcher.setText(seg.getText()); + + tickerStarting(); + scheduleAdvance(); + } + } + + void halt() { + mHandler.removeCallbacks(mAdvanceTicker); + mSegments.clear(); + tickerHalting(); + } + + void reflowText() { + if (mSegments.size() > 0) { + Segment seg = mSegments.get(0); + CharSequence text = seg.getText(); + mTextSwitcher.setCurrentText(text); + } + } + + private Runnable mAdvanceTicker = new Runnable() { + public void run() { + while (mSegments.size() > 0) { + Segment seg = mSegments.get(0); + + if (seg.first) { + // this makes the icon slide in for the first one for a given + // notification even if there are two notifications with the + // same icon in a row + mIconSwitcher.setImageDrawable(seg.icon); + } + CharSequence text = seg.advance(); + if (text == null) { + mSegments.remove(0); + continue; + } + mTextSwitcher.setText(text); + + scheduleAdvance(); + break; + } + if (mSegments.size() == 0) { + tickerDone(); + } + } + }; + + private void scheduleAdvance() { + mHandler.postDelayed(mAdvanceTicker, TICKER_SEGMENT_DELAY); + } + + abstract void tickerStarting(); + abstract void tickerDone(); + abstract void tickerHalting(); +} + diff --git a/services/java/com/android/server/status/TickerView.java b/services/java/com/android/server/status/TickerView.java new file mode 100644 index 0000000..349c7f4 --- /dev/null +++ b/services/java/com/android/server/status/TickerView.java @@ -0,0 +1,23 @@ + +package com.android.server.status; + +import android.content.Context; +import android.util.AttributeSet; +import android.widget.TextSwitcher; + + +public class TickerView extends TextSwitcher +{ + Ticker mTicker; + + public TickerView(Context context, AttributeSet attrs) { + super(context, attrs); + } + + @Override + protected void onSizeChanged(int w, int h, int oldw, int oldh) { + super.onSizeChanged(w, h, oldw, oldh); + mTicker.reflowText(); + } +} + diff --git a/services/java/com/android/server/status/TrackingView.java b/services/java/com/android/server/status/TrackingView.java new file mode 100644 index 0000000..722d10c --- /dev/null +++ b/services/java/com/android/server/status/TrackingView.java @@ -0,0 +1,47 @@ +package com.android.server.status; + +import android.content.Context; +import android.util.AttributeSet; +import android.view.Display; +import android.view.KeyEvent; +import android.view.WindowManager; +import android.widget.LinearLayout; + + +public class TrackingView extends LinearLayout { + final Display mDisplay; + StatusBarService mService; + boolean mTracking; + int mStartX, mStartY; + + public TrackingView(Context context, AttributeSet attrs) { + super(context, attrs); + mDisplay = ((WindowManager)context.getSystemService( + Context.WINDOW_SERVICE)).getDefaultDisplay(); + } + + @Override + protected void onLayout(boolean changed, int left, int top, int right, int bottom) { + super.onLayout(changed, left, top, right, bottom); + mService.updateAvailableHeight(); + } + + @Override + public boolean dispatchKeyEvent(KeyEvent event) { + boolean down = event.getAction() == KeyEvent.ACTION_DOWN; + switch (event.getKeyCode()) { + case KeyEvent.KEYCODE_BACK: + if (down) { + mService.deactivate(); + } + return true; + } + return super.dispatchKeyEvent(event); + } + + @Override + protected void onAttachedToWindow() { + super.onAttachedToWindow(); + mService.onTrackingViewAttached(); + } +} diff --git a/services/java/com/android/server/status/package.html b/services/java/com/android/server/status/package.html new file mode 100755 index 0000000..c9f96a6 --- /dev/null +++ b/services/java/com/android/server/status/package.html @@ -0,0 +1,5 @@ +<body> + +{@hide} + +</body> |