Instead of a raw AIDL interface, give DropBox a Java (95240270) · Commits · e / os / android_frameworks_base

Android.mk

+2 −2

Original line number	Diff line number	Diff line
		@@ -108,7 +108,6 @@ LOCAL_SRC_FILES += \
		core/java/android/hardware/ISensorService.aidl \
		core/java/android/net/IConnectivityManager.aidl \
		core/java/android/os/ICheckinService.aidl \
		core/java/android/os/IDropBox.aidl \
		core/java/android/os/IHardwareService.aidl \
		core/java/android/os/IMessenger.aidl \
		core/java/android/os/IMountService.aidl \
		@@ -137,6 +136,7 @@ LOCAL_SRC_FILES += \
		core/java/com/android/internal/appwidget/IAppWidgetService.aidl \
		core/java/com/android/internal/appwidget/IAppWidgetHost.aidl \
		core/java/com/android/internal/backup/IBackupTransport.aidl \
		core/java/com/android/internal/os/IDropBoxService.aidl \
		core/java/com/android/internal/os/IResultReceiver.aidl \
		core/java/com/android/internal/view/IInputContext.aidl \
		core/java/com/android/internal/view/IInputContextCallback.aidl \
		@@ -217,7 +217,7 @@ aidl_files := \
		frameworks/base/core/java/android/appwidget/AppWidgetProviderInfo.aidl \
		frameworks/base/core/java/android/net/Uri.aidl \
		frameworks/base/core/java/android/os/Bundle.aidl \
		frameworks/base/core/java/android/os/DropBoxEntry.aidl \
		frameworks/base/core/java/android/os/DropBox.aidl \
		frameworks/base/core/java/android/os/ParcelFileDescriptor.aidl \
		frameworks/base/core/java/android/os/ParcelUuid.aidl \
		frameworks/base/core/java/android/view/KeyEvent.aidl \

core/java/android/app/ApplicationContext.java

+18 −1

Original line number	Diff line number	Diff line
		@@ -70,6 +70,7 @@ import android.net.wifi.IWifiManager;
		import android.net.wifi.WifiManager;
		import android.os.Binder;
		import android.os.Bundle;
		import android.os.DropBox;
		import android.os.FileUtils;
		import android.os.Handler;
		import android.os.IBinder;
		@@ -93,6 +94,8 @@ import android.view.inputmethod.InputMethodManager;
		import android.accounts.AccountManager;
		import android.accounts.IAccountManager;

		import com.android.internal.os.IDropBoxService;

		import java.io.File;
		import java.io.FileInputStream;
		import java.io.FileNotFoundException;
		@@ -182,6 +185,7 @@ class ApplicationContext extends Context {
		private ClipboardManager mClipboardManager = null;
		private boolean mRestricted;
		private AccountManager mAccountManager; // protected by mSync
		private DropBox mDropBox = null;

		private final Object mSync = new Object();

		@@ -896,6 +900,8 @@ class ApplicationContext extends Context {
		return getClipboardManager();
		} else if (WALLPAPER_SERVICE.equals(name)) {
		return getWallpaperManager();
		} else if (DROPBOX_SERVICE.equals(name)) {
		return getDropBox();
		}

		return null;
		@@ -1054,6 +1060,17 @@ class ApplicationContext extends Context {
		return mAudioManager;
		}

		private DropBox getDropBox() {
		synchronized (mSync) {
		if (mDropBox == null) {
		IBinder b = ServiceManager.getService(DROPBOX_SERVICE);
		IDropBoxService service = IDropBoxService.Stub.asInterface(b);
		mDropBox = new DropBox(service);
		}
		}
		return mDropBox;
		}

		@Override
		public int checkPermission(String permission, int pid, int uid) {
		if (permission == null) {

core/java/android/content/Context.java

+11 −2

Original line number	Diff line number	Diff line
		@@ -1320,6 +1320,15 @@ public abstract class Context {
		*/
		public static final String BACKUP_SERVICE = "backup";

		/**
		* Use with {@link #getSystemService} to retrieve a
		* {@blink android.os.DropBox DropBox} instance for recording
		* diagnostic logs.
		* @hide
		* @see #getSystemService
		*/
		public static final String DROPBOX_SERVICE = "dropbox";

		/**
		* Determine whether the given permission is allowed for a particular
		* process and user ID running in the system.

core/java/android/os/DropBoxEntry.aidl→core/java/android/os/DropBox.aidl

+1 −1

Original line number	Diff line number	Diff line
		@@ -16,4 +16,4 @@

		package android.os;

		parcelable DropBoxEntry;
		parcelable DropBox.Entry;

core/java/android/os/DropBox.java

0 → 100644

+276 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 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 android.os;

		import android.util.Log;

		import com.android.internal.os.IDropBoxService;

		import java.io.ByteArrayInputStream;
		import java.io.File;
		import java.io.FileInputStream;
		import java.io.IOException;
		import java.io.InputStream;
		import java.util.zip.GZIPInputStream;

		/**
		* Enqueues chunks of data (from various sources -- application crashes, kernel
		* log records, etc.). The queue is size bounded and will drop old data if the
		* enqueued data exceeds the maximum size. You can think of this as a
		* persistent, system-wide, blob-oriented "logcat".
		*
		* <p>You can obtain an instance of this class by calling
		* {@link android.content.Context#getSystemService}
		* with {@link android.content.Context#DROPBOX_SERVICE}.
		*
		* <p>DropBox entries are not sent anywhere directly, but other system services
		* and debugging tools may scan and upload entries for processing.
		*
		* {@pending}
		*/
		public class DropBox {
		private static final String TAG = "DropBox";
		private final IDropBoxService mService;

		/** Flag value: Entry's content was deleted to save space. */
		public static final int IS_EMPTY = 1;

		/** Flag value: Content is human-readable UTF-8 text (can be combined with IS_GZIPPED). */
		public static final int IS_TEXT = 2;

		/** Flag value: Content can be decompressed with {@link GZIPOutputStream}. */
		public static final int IS_GZIPPED = 4;

		/**
		* A single entry retrieved from the drop box.
		* This may include a reference to a stream, so you must call
		* {@link #close()} when you are done using it.
		*/
		public static class Entry implements Parcelable {
		private final String mTag;
		private final long mTimeMillis;

		private final byte[] mData;
		private final ParcelFileDescriptor mFileDescriptor;
		private final int mFlags;

		/** Create a new empty Entry with no contents. */
		public Entry(String tag, long millis) {
		this(tag, millis, (Object) null, IS_EMPTY);
		}

		/** Create a new Entry with plain text contents. */
		public Entry(String tag, long millis, String text) {
		this(tag, millis, (Object) text.getBytes(), IS_TEXT);
		}

		/**
		* Create a new Entry with byte array contents.
		* The data array must not be modified after creating this entry.
		*/
		public Entry(String tag, long millis, byte[] data, int flags) {
		this(tag, millis, (Object) data, flags);
		}

		/**
		* Create a new Entry with streaming data contents.
		* Takes ownership of the ParcelFileDescriptor.
		*/
		public Entry(String tag, long millis, ParcelFileDescriptor data, int flags) {
		this(tag, millis, (Object) data, flags);
		}

		/**
		* Create a new Entry with the contents read from a file.
		* The file will be read when the entry's contents are requested.
		*/
		public Entry(String tag, long millis, File data, int flags) throws IOException {
		this(tag, millis, (Object) ParcelFileDescriptor.open(
		data, ParcelFileDescriptor.MODE_READ_ONLY), flags);
		}

		/** Internal constructor for CREATOR.createFromParcel(). */
		private Entry(String tag, long millis, Object value, int flags) {
		if (tag == null) throw new NullPointerException();
		if (((flags & IS_EMPTY) != 0) != (value == null)) throw new IllegalArgumentException();

		mTag = tag;
		mTimeMillis = millis;
		mFlags = flags;

		if (value == null) {
		mData = null;
		mFileDescriptor = null;
		} else if (value instanceof byte[]) {
		mData = (byte[]) value;
		mFileDescriptor = null;
		} else if (value instanceof ParcelFileDescriptor) {
		mData = null;
		mFileDescriptor = (ParcelFileDescriptor) value;
		} else {
		throw new IllegalArgumentException();
		}
		}

		/** Close the input stream associated with this entry. */
		public void close() {
		try { if (mFileDescriptor != null) mFileDescriptor.close(); } catch (IOException e) { }
		}

		/** @return the tag originally attached to the entry. */
		public String getTag() { return mTag; }

		/** @return time when the entry was originally created. */
		public long getTimeMillis() { return mTimeMillis; }

		/** @return flags describing the content returned by @{link #getInputStream()}. */
		public int getFlags() { return mFlags & ~IS_GZIPPED; } // getInputStream() decompresses.

		/**
		* @param maxBytes of string to return (will truncate at this length).
		* @return the uncompressed text contents of the entry, null if the entry is not text.
		*/
		public String getText(int maxBytes) {
		if ((mFlags & IS_TEXT) == 0) return null;
		if (mData != null) return new String(mData, 0, Math.min(maxBytes, mData.length));

		InputStream is = null;
		try {
		is = getInputStream();
		byte[] buf = new byte[maxBytes];
		return new String(buf, 0, Math.max(0, is.read(buf)));
		} catch (IOException e) {
		return null;
		} finally {
		try { if (is != null) is.close(); } catch (IOException e) {}
		}
		}

		/** @return the uncompressed contents of the entry, or null if the contents were lost */
		public InputStream getInputStream() throws IOException {
		InputStream is;
		if (mData != null) {
		is = new ByteArrayInputStream(mData);
		} else if (mFileDescriptor != null) {
		is = new ParcelFileDescriptor.AutoCloseInputStream(mFileDescriptor);
		} else {
		return null;
		}
		return (mFlags & IS_GZIPPED) != 0 ? new GZIPInputStream(is) : is;
		}

		public static final Parcelable.Creator<Entry> CREATOR = new Parcelable.Creator() {
		public Entry[] newArray(int size) { return new Entry[size]; }
		public Entry createFromParcel(Parcel in) {
		return new Entry(
		in.readString(), in.readLong(), in.readValue(null), in.readInt());
		}
		};

		public int describeContents() {
		return mFileDescriptor != null ? Parcelable.CONTENTS_FILE_DESCRIPTOR : 0;
		}

		public void writeToParcel(Parcel out, int flags) {
		out.writeString(mTag);
		out.writeLong(mTimeMillis);
		if (mFileDescriptor != null) {
		out.writeValue(mFileDescriptor);
		} else {
		out.writeValue(mData);
		}
		out.writeInt(mFlags);
		}
		}

		/** {@hide} */
		public DropBox(IDropBoxService service) { mService = service; }

		/**
		* Create a dummy instance for testing. All methods will fail unless
		* overridden with an appropriate mock implementation. To obtain a
		* functional instance, use {@link android.content.Context#getSystemService}.
		*/
		protected DropBox() { mService = null; }

		/**
		* Stores human-readable text. The data may be discarded eventually (or even
		* immediately) if space is limited, or ignored entirely if the tag has been
		* blocked (see {@link #isTagEnabled}).
		*
		* @param tag describing the type of entry being stored
		* @param data value to store
		*/
		public void addText(String tag, String data) {
		try { mService.add(new Entry(tag, 0, data)); } catch (RemoteException e) {}
		}

		/**
		* Stores binary data, which may be ignored or discarded as with {@link #addText}.
		*
		* @param tag describing the type of entry being stored
		* @param data value to store
		* @param flags describing the data
		*/
		public void addData(String tag, byte[] data, int flags) {
		if (data == null) throw new NullPointerException();
		try { mService.add(new Entry(tag, 0, data, flags)); } catch (RemoteException e) {}
		}

		/**
		* Stores data read from a file descriptor. The data may be ignored or
		* discarded as with {@link #addText}. You must close your
		* ParcelFileDescriptor object after calling this method!
		*
		* @param tag describing the type of entry being stored
		* @param fd file descriptor to read from
		* @param flags describing the data
		*/
		public void addFile(String tag, ParcelFileDescriptor fd, int flags) {
		if (fd == null) throw new NullPointerException();
		try { mService.add(new Entry(tag, 0, fd, flags)); } catch (RemoteException e) {}
		}

		/**
		* Checks any blacklists (set in system settings) to see whether a certain
		* tag is allowed. Entries with disabled tags will be dropped immediately,
		* so you can save the work of actually constructing and sending the data.
		*
		* @param tag that would be used in {@link #addText} or {@link #addFile}
		* @return whether events with that tag would be accepted
		*/
		public boolean isTagEnabled(String tag) {
		try { return mService.isTagEnabled(tag); } catch (RemoteException e) { return false; }
		}

		/**
		* Gets the next entry from the drop box after the specified time.
		* Requires android.permission.READ_LOGS. You must always call
		* {@link Entry#close()} on the return value!
		*
		* @param tag of entry to look for, null for all tags
		* @param msec time of the last entry seen
		* @return the next entry, or null if there are no more entries
		*/
		public Entry getNextEntry(String tag, long msec) {
		try { return mService.getNextEntry(tag, msec); } catch (RemoteException e) { return null; }
		}

		// TODO: It may be useful to have some sort of notification mechanism
		// when data is added to the dropbox, for demand-driven readers --
		// for now readers need to poll the dropbox to find new data.
		}