I'm working through the exercises in Beginning Android™ Application Development, ISBN: 978-1-118-01711-1.

When the 'Show Map' button in the 'Intent' exercise (pages 56-59) is invoked there's an error.

I created a 'source' file where the Android-sdk is located, C:\Program Files\Android\android-sdk\platforms\android-8\sources
as part of a solution I discovered in stackoverflow (http://stackoverflow.com/questions/6...entation-class)
which pointed me to http://blog.michael-forster.de/2008/...n-eclipse.html
where I found part of the solution contributed by "Volure said..."

I've attached the LogCat and the Instrumentation Class output.

I'm finding this book to be the best so I'm not letting this slow me down.

/*
* 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 android.app;

import android.content.ActivityNotFoundException;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.ActivityInfo;
import android.content.res.Configuration;
import android.os.Bundle;
import android.os.PerformanceCollector;
import android.os.RemoteException;
import android.os.Debug;
import android.os.IBinder;
import android.os.MessageQueue;
import android.os.Process;
import android.os.SystemClock;
import android.os.ServiceManager;
import android.util.AndroidRuntimeException;
import android.util.Config;
import android.util.Log;
import android.view.IWindowManager;
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.ViewConfiguration;
import android.view.Window;
import android.view.inputmethod.InputMethodManager;

import java.io.File;
import java.util.ArrayList;
import java.util.List;


/**
* Base class for implementing application instrumentation code. When running
* with instrumentation turned on, this class will be instantiated for you
* before any of the application code, allowing you to monitor all of the
* interaction the system has with the application. An Instrumentation
* implementation is described to the system through an AndroidManifest.xml's
* <instrumentation> tag.
*/
public class Instrumentation {
/**
* If included in the status or final bundle sent to an IInstrumentationWatcher, this key
* identifies the class that is writing the report. This can be used to provide more structured
* logging or reporting capabilities in the IInstrumentationWatcher.
*/
public static final String REPORT_KEY_IDENTIFIER = "id";
/**
* If included in the status or final bundle sent to an IInstrumentationWatcher, this key
* identifies a string which can simply be printed to the output stream. Using these streams
* provides a "pretty printer" version of the status & final packets. Any bundles including
* this key should also include the complete set of raw key/value pairs, so that the
* instrumentation can also be launched, and results collected, by an automated system.
*/
public static final String REPORT_KEY_STREAMRESULT = "stream";

private static final String TAG = "Instrumentation";

private final Object mSync = new Object();
private ActivityThread mThread = null;
private MessageQueue mMessageQueue = null;
private Context mInstrContext;
private Context mAppContext;
private ComponentName mComponent;
private Thread mRunner;
private List<ActivityWaiter> mWaitingActivities;
private List<ActivityMonitor> mActivityMonitors;
private IInstrumentationWatcher mWatcher;
private boolean mAutomaticPerformanceSnapshots = false;
private PerformanceCollector mPerformanceCollector;
private Bundle mPerfMetrics = new Bundle();

public Instrumentation() {
}

/**
* Called when the instrumentation is starting, before any application code
* has been loaded. Usually this will be implemented to simply call
* {@link #start} to begin the instrumentation thread, which will then
* continue execution in {@link #onStart}.
*
* <p>If you do not need your own thread -- that is you are writing your
* instrumentation to be completely asynchronous (returning to the event
* loop so that the application can run), you can simply begin your
* instrumentation here, for example call {@link Context#startActivity} to
* begin the appropriate first activity of the application.
*
* @param arguments Any additional arguments that were supplied when the
* instrumentation was started.
*/
public void onCreate(Bundle arguments) {
}

/**
* Create and start a new thread in which to run instrumentation. This new
* thread will call to {@link #onStart} where you can implement the
* instrumentation.
*/
public void start() {
if (mRunner != null) {
throw new RuntimeException("Instrumentation already started");
}
mRunner = new InstrumentationThread("Instr: " + getClass().getName());
mRunner.start();
}

/**
* Method where the instrumentation thread enters execution. This allows
* you to run your instrumentation code in a separate thread than the
* application, so that it can perform blocking operation such as
* {@link #sendKeySync} or {@link #startActivitySync}.
*
* <p>You will typically want to call finish() when this function is done,
* to end your instrumentation.
*/
public void onStart() {
}

/**
* This is called whenever the system captures an unhandled exception that
* was thrown by the application. The default implementation simply
* returns false, allowing normal system handling of the exception to take
* place.
*
* @param obj The client object that generated the exception. May be an
* Application, Activity, BroadcastReceiver, Service, or null.
* @param e The exception that was thrown.
*
* @return To allow normal system exception process to occur, return false.
* If true is returned, the system will proceed as if the exception
* didn't happen.
*/
public boolean onException(Object obj, Throwable e) {
return false;
}

/**
* Provide a status report about the application.
*
* @param resultCode Current success/failure of instrumentation.
* @param results Any results to send back to the code that started the instrumentation.
*/
public void sendStatus(int resultCode, Bundle results) {
if (mWatcher != null) {
try {
mWatcher.instrumentationStatus(mComponent, resultCode, results);
}
catch (RemoteException e) {
mWatcher = null;
}
}
}

/**
* Terminate instrumentation of the application. This will cause the
* application process to exit, removing this instrumentation from the next
* time the application is started.
*
* @param resultCode Overall success/failure of instrumentation.
* @param results Any results to send back to the code that started the
* instrumentation.
*/
public void finish(int resultCode, Bundle results) {
if (mAutomaticPerformanceSnapshots) {
endPerformanceSnapshot();
}
if (mPerfMetrics != null) {
results.putAll(mPerfMetrics);
}
mThread.finishInstrumentation(resultCode, results);
}

public void setAutomaticPerformanceSnapshots() {
mAutomaticPerformanceSnapshots = true;
mPerformanceCollector = new PerformanceCollector();
}

public void startPerformanceSnapshot() {
if (!isProfiling()) {
mPerformanceCollector.beginSnapshot(null);
}
}

public void endPerformanceSnapshot() {
if (!isProfiling()) {
mPerfMetrics = mPerformanceCollector.endSnapshot();
}
}

/**
* Called when the instrumented application is stopping, after all of the
* normal application cleanup has occurred.
*/
public void onDestroy() {
}

/**
* Return the Context of this instrumentation's package. Note that this is
* often different than the Context of the application being
* instrumentated, since the instrumentation code often lives is a
* different package than that of the application it is running against.
* See {@link #getTargetContext} to retrieve a Context for the target
* application.
*
* @return The instrumentation's package context.
*
* @see #getTargetContext
*/
public Context getContext() {
return mInstrContext;
}

/**
* Returns complete component name of this instrumentation.
*
* @return Returns the complete component name for this instrumentation.
*/
public ComponentName getComponentName() {
return mComponent;
}

/**
* Return a Context for the target application being instrumented. Note
* that this is often different than the Context of the instrumentation
* code, since the instrumentation code often lives is a different package
* than that of the application it is running against. See
* {@link #getContext} to retrieve a Context for the instrumentation code.
*
* @return A Context in the target application.
*
* @see #getContext
*/
public Context getTargetContext() {
return mAppContext;
}

/**
* Check whether this instrumentation was started with profiling enabled.
*
* @return Returns true if profiling was enabled when starting, else false.
*/
public boolean isProfiling() {
return mThread.isProfiling();
}

/**
* This method will start profiling if isProfiling() returns true. You should
* only call this method if you set the handleProfiling attribute in the
* manifest file for this Instrumentation to true.
*/
public void startProfiling() {
if (mThread.isProfiling()) {
File file = new File(mThread.getProfileFilePath());
file.getParentFile().mkdirs();
Debug.startMethodTracing(file.toString(), 8 * 1024 * 1024);
}
}

/**
* Stops profiling if isProfiling() returns true.
*/
public void stopProfiling() {
if (mThread.isProfiling()) {
Debug.stopMethodTracing();
}
}

/**
* Force the global system in or out of touch mode. This can be used if
* your instrumentation relies on the UI being in one more or the other
* when it starts.
*
* @param inTouch Set to true to be in touch mode, false to be in
* focus mode.
*/
public void setInTouchMode(boolean inTouch) {
try {
IWindowManager.Stub.asInterface(
ServiceManager.getService("window")).setInTouchMod e(inTouch);
} catch (RemoteException e) {
// Shouldn't happen!
}
}

/**
* Schedule a callback for when the application's main thread goes idle
* (has no more events to process).
*
* @param recipient Called the next time the thread's message queue is
* idle.
*/
public void waitForIdle(Runnable recipient) {
mMessageQueue.addIdleHandler(new Idler(recipient));
mThread.getHandler().post(new EmptyRunnable());
}

/**
* Synchronously wait for the application to be idle. Can not be called
* from the main application thread -- use {@link #start} to execute
* instrumentation in its own thread.
*/
public void waitForIdleSync() {
validateNotAppThread();
Idler idler = new Idler(null);
mMessageQueue.addIdleHandler(idler);
mThread.getHandler().post(new EmptyRunnable());
idler.waitForIdle();
}

/**
* Execute a call on the application's main thread, blocking until it is
* complete. Useful for doing things that are not thread-safe, such as
* looking at or modifying the view hierarchy.
*
* @param runner The code to run on the main thread.
*/
public void runOnMainSync(Runnable runner) {
validateNotAppThread();
SyncRunnable sr = new SyncRunnable(runner);
mThread.getHandler().post(sr);
sr.waitForComplete();
}

/**
* Start a new activity and wait for it to begin running before returning.
* In addition to being synchronous, this method as some semantic
* differences from the standard {@link Context#startActivity} call: the
* activity component is resolved before talking with the activity manager
* (its class name is specified in the Intent that this method ultimately
* starts), and it does not allow you to start activities that run in a
* different process. In addition, if the given Intent resolves to
* multiple activities, instead of displaying a dialog for the user to
* select an activity, an exception will be thrown.
*
* <p>The function returns as soon as the activity goes idle following the
* call to its {@link Activity#onCreate}. Generally this means it has gone
* through the full initialization including {@link Activity#onResume} and
* drawn and displayed its initial window.
*
* @param intent Description of the activity to start.
*
* @see Context#startActivity
*/
public Activity startActivitySync(Intent intent) {
validateNotAppThread();

synchronized (mSync) {
intent = new Intent(intent);

ActivityInfo ai = intent.resolveActivityInfo(
getTargetContext().getPackageManager(), 0);
if (ai == null) {
throw new RuntimeException("Unable to resolve activity for: " + intent);
}
String myProc = mThread.getProcessName();
if (!ai.processName.equals(myProc)) {
// todo: if this intent is ambiguous, look here to see if
// there is a single match that is in our package.
throw new RuntimeException("Intent in process "
+ myProc + " resolved to different process "
+ ai.processName + ": " + intent);
}

intent.setComponent(new ComponentName(
ai.applicationInfo.packageName, ai.name));
final ActivityWaiter aw = new ActivityWaiter(intent);

if (mWaitingActivities == null) {
mWaitingActivities = new ArrayList();
}
mWaitingActivities.add(aw);

getTargetContext().startActivity(intent);

do {
try {
mSync.wait();
} catch (InterruptedException e) {
}
} while (mWaitingActivities.contains(aw));

return aw.activity;
}
}

/**
* Information about a particular kind of Intent that is being monitored.
* An instance of this class is added to the
* current instrumentation through {@link #addMonitor}; after being added,
* when a new activity is being started the monitor will be checked and, if
* matching, its hit count updated and (optionally) the call stopped and a
* canned result returned.
*
* <p>An ActivityMonitor can also be used to look for the creation of an
* activity, through the {@link #waitForActivity} method. This will return
* after a matching activity has been created with that activity object.
*/
public static class ActivityMonitor {
private final IntentFilter mWhich;
private final String mClass;
private final ActivityResult mResult;
private final boolean mBlock;


// This is protected by 'Instrumentation.this.mSync'.
/*package*/ int mHits = 0;

// This is protected by 'this'.
/*package*/ Activity mLastActivity = null;

/**
* Create a new ActivityMonitor that looks for a particular kind of
* intent to be started.
*
* @param which The set of intents this monitor is responsible for.
* @param result A canned result to return if the monitor is hit; can
* be null.
* @param block Controls whether the monitor should block the activity
* start (returning its canned result) or let the call
* proceed.
*
* @see Instrumentation#addMonitor
*/
public ActivityMonitor(
IntentFilter which, ActivityResult result, boolean block) {
mWhich = which;
mClass = null;
mResult = result;
mBlock = block;
}

/**
* Create a new ActivityMonitor that looks for a specific activity
* class to be started.
*
* @param cls The activity class this monitor is responsible for.
* @param result A canned result to return if the monitor is hit; can
* be null.
* @param block Controls whether the monitor should block the activity
* start (returning its canned result) or let the call
* proceed.
*
* @see Instrumentation#addMonitor
*/
public ActivityMonitor(
String cls, ActivityResult result, boolean block) {
mWhich = null;
mClass = cls;
mResult = result;
mBlock = block;
}

/**
* Retrieve the filter associated with this ActivityMonitor.
*/
public final IntentFilter getFilter() {
return mWhich;
}

/**
* Retrieve the result associated with this ActivityMonitor, or null if
* none.
*/
public final ActivityResult getResult() {
return mResult;
}

/**
* Check whether this monitor blocks activity starts (not allowing the
* actual activity to run) or allows them to execute normally.
*/
public final boolean isBlocking() {
return mBlock;
}

/**
* Retrieve the number of times the monitor has been hit so far.
*/
public final int getHits() {
return mHits;
}

/**
* Retrieve the most recent activity class that was seen by this
* monitor.
*/
public final Activity getLastActivity() {
return mLastActivity;
}

/**
* Block until an Activity is created that matches this monitor,
* returning the resulting activity.
*
* @return Activity
*/
public final Activity waitForActivity() {
synchronized (this) {
while (mLastActivity == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
Activity res = mLastActivity;
mLastActivity = null;
return res;
}
}

/**
* Block until an Activity is created that matches this monitor,
* returning the resulting activity or till the timeOut period expires.
* If the timeOut expires before the activity is started, return null.
*
* @param timeOut Time to wait before the activity is created.
*
* @return Activity
*/
public final Activity waitForActivityWithTimeout(long timeOut) {
synchronized (this) {
try {
wait(timeOut);
} catch (InterruptedException e) {
}
if (mLastActivity == null) {
return null;
} else {
Activity res = mLastActivity;
mLastActivity = null;
return res;
}
}
}

final boolean match(Context who,
Activity activity,
Intent intent) {
synchronized (this) {
if (mWhich != null
&& mWhich.match(who.getContentResolver(), intent,
true, "Instrumentation") < 0) {
return false;
}
if (mClass != null) {
String cls = null;
if (activity != null) {
cls = activity.getClass().getName();
} else if (intent.getComponent() != null) {
cls = intent.getComponent().getClassName();
}
if (cls == null || !mClass.equals(cls)) {
return false;
}
}
if (activity != null) {
mLastActivity = activity;
notifyAll();
}
return true;
}
}
}

/**
* Add a new {@link ActivityMonitor} that will be checked whenever an
* activity is started. The monitor is added
* after any existing ones; the monitor will be hit only if none of the
* existing monitors can themselves handle the Intent.
*
* @param monitor The new ActivityMonitor to see.
*
* @see #addMonitor(IntentFilter, ActivityResult, boolean)
* @see #checkMonitorHit
*/
public void addMonitor(ActivityMonitor monitor) {
synchronized (mSync) {
if (mActivityMonitors == null) {
mActivityMonitors = new ArrayList();
}
mActivityMonitors.add(monitor);
}
}

/**
* A convenience wrapper for {@link #addMonitor(ActivityMonitor)} that
* creates an intent filter matching {@link ActivityMonitor} for you and
* returns it.
*
* @param filter The set of intents this monitor is responsible for.
* @param result A canned result to return if the monitor is hit; can
* be null.
* @param block Controls whether the monitor should block the activity
* start (returning its canned result) or let the call
* proceed.
*
* @return The newly created and added activity monitor.
*
* @see #addMonitor(ActivityMonitor)
* @see #checkMonitorHit
*/
public ActivityMonitor addMonitor(
IntentFilter filter, ActivityResult result, boolean block) {
ActivityMonitor am = new ActivityMonitor(filter, result, block);
addMonitor(am);
return am;
}

/**
* A convenience wrapper for {@link #addMonitor(ActivityMonitor)} that
* creates a class matching {@link ActivityMonitor} for you and returns it.
*
* @param cls The activity class this monitor is responsible for.
* @param result A canned result to return if the monitor is hit; can
* be null.
* @param block Controls whether the monitor should block the activity
* start (returning its canned result) or let the call
* proceed.
*
* @return The newly created and added activity monitor.
*
* @see #addMonitor(ActivityMonitor)
* @see #checkMonitorHit
*/
public ActivityMonitor addMonitor(
String cls, ActivityResult result, boolean block) {
ActivityMonitor am = new ActivityMonitor(cls, result, block);
addMonitor(am);
return am;
}

/**
* Test whether an existing {@link ActivityMonitor} has been hit. If the
* monitor has been hit at least <var>minHits</var> times, then it will be
* removed from the activity monitor list and true returned. Otherwise it
* is left as-is and false is returned.
*
* @param monitor The ActivityMonitor to check.
* @param minHits The minimum number of hits required.
*
* @return True if the hit count has been reached, else false.
*
* @see #addMonitor
*/
public boolean checkMonitorHit(ActivityMonitor monitor, int minHits) {
waitForIdleSync();
synchronized (mSync) {
if (monitor.getHits() < minHits) {
return false;
}
mActivityMonitors.remove(monitor);
}
return true;
}

/**
* Wait for an existing {@link ActivityMonitor} to be hit. Once the
* monitor has been hit, it is removed from the activity monitor list and
* the first created Activity object that matched it is returned.
*
* @param monitor The ActivityMonitor to wait for.
*
* @return The Activity object that matched the monitor.
*/
public Activity waitForMonitor(ActivityMonitor monitor) {
Activity activity = monitor.waitForActivity();
synchronized (mSync) {
mActivityMonitors.remove(monitor);
}
return activity;
}

/**
* Wait for an existing {@link ActivityMonitor} to be hit till the timeout
* expires. Once the monitor has been hit, it is removed from the activity
* monitor list and the first created Activity object that matched it is
* returned. If the timeout expires, a null object is returned.
*
* @param monitor The ActivityMonitor to wait for.
* @param timeOut The timeout value in secs.
*
* @return The Activity object that matched the monitor.
*/
public Activity waitForMonitorWithTimeout(ActivityMonitor monitor, long timeOut) {
Activity activity = monitor.waitForActivityWithTimeout(timeOut);
synchronized (mSync) {
mActivityMonitors.remove(monitor);
}
return activity;
}

/**
* Remove an {@link ActivityMonitor} that was previously added with
* {@link #addMonitor}.
*
* @param monitor The monitor to remove.
*
* @see #addMonitor
*/
public void removeMonitor(ActivityMonitor monitor) {
synchronized (mSync) {
mActivityMonitors.remove(monitor);
}
}

/**
* Execute a particular menu item.
*
* @param targetActivity The activity in question.
* @param id The identifier associated with the menu item.
* @param flag Additional flags, if any.
* @return Whether the invocation was successful (for example, it could be
* false if item is disabled).
*/
public boolean invokeMenuActionSync(Activity targetActivity,
int id, int flag) {
class MenuRunnable implements Runnable {
private final Activity activity;
private final int identifier;
private final int flags;
boolean returnValue;

public MenuRunnable(Activity _activity, int _identifier,
int _flags) {
activity = _activity;
identifier = _identifier;
flags = _flags;
}

public void run() {
Window win = activity.getWindow();

returnValue = win.performPanelIdentifierAction(
Window.FEATURE_OPTIONS_PANEL,
identifier,
flags);
}

}
MenuRunnable mr = new MenuRunnable(targetActivity, id, flag);
runOnMainSync(mr);
return mr.returnValue;
}

/**
* Show the context menu for the currently focused view and executes a
* particular context menu item.
*
* @param targetActivity The activity in question.
* @param id The identifier associated with the context menu item.
* @param flag Additional flags, if any.
* @return Whether the invocation was successful (for example, it could be
* false if item is disabled).
*/
public boolean invokeContextMenuAction(Activity targetActivity, int id, int flag) {
validateNotAppThread();

// Bring up context menu for current focus.
// It'd be nice to do this through code, but currently ListView depends on
// long press to set metadata for its selected child

final KeyEvent downEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_CENTER);
sendKeySync(downEvent);

// Need to wait for long press
waitForIdleSync();
try {
Thread.sleep(ViewConfiguration.getLongPressTimeout ());
} catch (InterruptedException e) {
Log.e(TAG, "Could not sleep for long press timeout", e);
return false;
}

final KeyEvent upEvent = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DPAD_CENTER);
sendKeySync(upEvent);

// Wait for context menu to appear
waitForIdleSync();

class ContextMenuRunnable implements Runnable {
private final Activity activity;
private final int identifier;
private final int flags;
boolean returnValue;

public ContextMenuRunnable(Activity _activity, int _identifier,
int _flags) {
activity = _activity;
identifier = _identifier;
flags = _flags;
}

public void run() {
Window win = activity.getWindow();
returnValue = win.performContextMenuIdentifierAction(
identifier,
flags);
}

}

ContextMenuRunnable cmr = new ContextMenuRunnable(targetActivity, id, flag);
runOnMainSync(cmr);
return cmr.returnValue;
}

/**
* Sends the key events corresponding to the text to the app being
* instrumented.
*
* @param text The text to be sent.
*/
public void sendStringSync(String text) {
if (text == null) {
return;
}
KeyCharacterMap keyCharacterMap =
KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYB OARD);

KeyEvent[] events = keyCharacterMap.getEvents(text.toCharArray());

if (events != null) {
for (int i = 0; i < events.length; i++) {
sendKeySync(events[i]);
}
}
}

/**
* Send a key event to the currently focused window/view and wait for it to
* be processed. Finished at some point after the recipient has returned
* from its event processing, though it may <em>not</em> have completely
* finished reacting from the event -- for example, if it needs to update
* its display as a result, it may still be in the process of doing that.
*
* @param event The event to send to the current focus.
*/
public void sendKeySync(KeyEvent event) {
validateNotAppThread();
try {
(IWindowManager.Stub.asInterface(ServiceManager.ge tService("window")))
.injectKeyEvent(event, true);
} catch (RemoteException e) {
}
}

/**
* Sends an up and down key event sync to the currently focused window.
*
* @param key The integer keycode for the event.
*/
public void sendKeyDownUpSync(int key) {
sendKeySync(new KeyEvent(KeyEvent.ACTION_DOWN, key));
sendKeySync(new KeyEvent(KeyEvent.ACTION_UP, key));
}

/**
* Higher-level method for sending both the down and up key events for a
* particular character key code. Equivalent to creating both KeyEvent
* objects by hand and calling {@link #sendKeySync}. The event appears
* as if it came from keyboard 0, the built in one.
*
* @param keyCode The key code of the character to send.
*/
public void sendCharacterSync(int keyCode) {
sendKeySync(new KeyEvent(KeyEvent.ACTION_DOWN, keyCode));
sendKeySync(new KeyEvent(KeyEvent.ACTION_UP, keyCode));
}

/**
* Dispatch a pointer event. Finished at some point after the recipient has
* returned from its event processing, though it may <em>not</em> have
* completely finished reacting from the event -- for example, if it needs
* to update its display as a result, it may still be in the process of
* doing that.
*
* @param event A motion event describing the pointer action. (As noted in
* {@link MotionEvent#obtain(long, long, int, float, float, int)}, be sure to use
* {@link SystemClock#uptimeMillis()} as the timebase.
*/
public void sendPointerSync(MotionEvent event) {
validateNotAppThread();
try {
(IWindowManager.Stub.asInterface(ServiceManager.ge tService("window")))
.injectPointerEvent(event, true);
} catch (RemoteException e) {
}
}

/**
* Dispatch a trackball event. Finished at some point after the recipient has
* returned from its event processing, though it may <em>not</em> have
* completely finished reacting from the event -- for example, if it needs
* to update its display as a result, it may still be in the process of
* doing that.
*
* @param event 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.
*/
public void sendTrackballEventSync(MotionEvent event) {
validateNotAppThread();
try {
(IWindowManager.Stub.asInterface(ServiceManager.ge tService("window")))
.injectTrackballEvent(event, true);
} catch (RemoteException e) {
}
}

/**
* Perform instantiation of the process's {@link Application} object. The
* default implementation provides the normal system behavior.
*
* @param cl The ClassLoader with which to instantiate the object.
* @param className The name of the class implementing the Application
* object.
* @param context The context to initialize the application with
*
* @return The newly instantiated Application object.
*/
public Application newApplication(ClassLoader cl, String className, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return newApplication(cl.loadClass(className), context);
}

/**
* Perform instantiation of the process's {@link Application} object. The
* default implementation provides the normal system behavior.
*
* @param clazz The class used to create an Application object from.
* @param context The context to initialize the application with
*
* @return The newly instantiated Application object.
*/
static public Application newApplication(Class<?> clazz, Context context)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
Application app = (Application)clazz.newInstance();
app.attach(context);
return app;
}

/**
* Perform calling of the application's {@link Application#onCreate}
* method. The default implementation simply calls through to that method.
*
* @param app The application being created.
*/
public void callApplicationOnCreate(Application app) {
app.onCreate();
}

/**
* Perform instantiation of an {@link Activity} object. This method is intended for use with
* unit tests, such as android.test.ActivityUnitTestCase. The activity will be useable
* locally but will be missing some of the linkages necessary for use within the sytem.
*
* @param clazz The Class of the desired Activity
* @param context The base context for the activity to use
* @param token The token for this activity to communicate with
* @param application The application object (if any)
* @param intent The intent that started this Activity
* @param info ActivityInfo from the manifest
* @param title The title, typically retrieved from the ActivityInfo record
* @param parent The parent Activity (if any)
* @param id The embedded Id (if any)
* @param lastNonConfigurationInstance Arbitrary object that will be
* available via {@link Activity#getLastNonConfigurationInstance()
* Activity.getLastNonConfigurationInstance()}.
* @return Returns the instantiated activity
* @throws InstantiationException
* @throws IllegalAccessException
*/
public Activity newActivity(Class<?> clazz, Context context,
IBinder token, Application application, Intent intent, ActivityInfo info,
CharSequence title, Activity parent, String id,
Object lastNonConfigurationInstance) throws InstantiationException,
IllegalAccessException {
Activity activity = (Activity)clazz.newInstance();
ActivityThread aThread = null;
activity.attach(context, aThread, this, token, application, intent, info, title,
parent, id, lastNonConfigurationInstance, new Configuration());
return activity;
}

/**
* Perform instantiation of the process's {@link Activity} object. The
* default implementation provides the normal system behavior.
*
* @param cl The ClassLoader with which to instantiate the object.
* @param className The name of the class implementing the Activity
* object.
* @param intent The Intent object that specified the activity class being
* instantiated.
*
* @return The newly instantiated Activity object.
*/
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
return (Activity)cl.loadClass(className).newInstance();
}

/**
* Perform calling of an activity's {@link Activity#onCreate}
* method. The default implementation simply calls through to that method.
*
* @param activity The activity being created.
* @param icicle The previously frozen state (or null) to pass through to
* onCreate().
*/
public void callActivityOnCreate(Activity activity, Bundle icicle) {
if (mWaitingActivities != null) {
synchronized (mSync) {
final int N = mWaitingActivities.size();
for (int i=0; i<N; i++) {
final ActivityWaiter aw = mWaitingActivities.get(i);
final Intent intent = aw.intent;
if (intent.filterEquals(activity.getIntent())) {
aw.activity = activity;
mMessageQueue.addIdleHandler(new ActivityGoing(aw));
}
}
}
}

activity.onCreate(icicle);

if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
am.match(activity, activity, activity.getIntent());
}
}
}
}

public void callActivityOnDestroy(Activity activity) {
if (mWaitingActivities != null) {
synchronized (mSync) {
final int N = mWaitingActivities.size();
for (int i=0; i<N; i++) {
final ActivityWaiter aw = mWaitingActivities.get(i);
final Intent intent = aw.intent;
if (intent.filterEquals(activity.getIntent())) {
aw.activity = activity;
mMessageQueue.addIdleHandler(new ActivityGoing(aw));
}
}
}
}

activity.onDestroy();

if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
am.match(activity, activity, activity.getIntent());
}
}
}
}

/**
* Perform calling of an activity's {@link Activity#onRestoreInstanceState}
* method. The default implementation simply calls through to that method.
*
* @param activity The activity being restored.
* @param savedInstanceState The previously saved state being restored.
*/
public void callActivityOnRestoreInstanceState(Activity activity, Bundle savedInstanceState) {
activity.performRestoreInstanceState(savedInstance State);
}

/**
* Perform calling of an activity's {@link Activity#onPostCreate} method.
* The default implementation simply calls through to that method.
*
* @param activity The activity being created.
* @param icicle The previously frozen state (or null) to pass through to
* onPostCreate().
*/
public void callActivityOnPostCreate(Activity activity, Bundle icicle) {
activity.onPostCreate(icicle);
}

/**
* Perform calling of an activity's {@link Activity#onNewIntent}
* method. The default implementation simply calls through to that method.
*
* @param activity The activity receiving a new Intent.
* @param intent The new intent being received.
*/
public void callActivityOnNewIntent(Activity activity, Intent intent) {
activity.onNewIntent(intent);
}

/**
* Perform calling of an activity's {@link Activity#onStart}
* method. The default implementation simply calls through to that method.
*
* @param activity The activity being started.
*/
public void callActivityOnStart(Activity activity) {
activity.onStart();
}

/**
* Perform calling of an activity's {@link Activity#onRestart}
* method. The default implementation simply calls through to that method.
*
* @param activity The activity being restarted.
*/
public void callActivityOnRestart(Activity activity) {
activity.onRestart();
}

/**
* Perform calling of an activity's {@link Activity#onResume} method. The
* default implementation simply calls through to that method.
*
* @param activity The activity being resumed.
*/
public void callActivityOnResume(Activity activity) {
activity.onResume();

if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
am.match(activity, activity, activity.getIntent());
}
}
}
}

/**
* Perform calling of an activity's {@link Activity#onStop}
* method. The default implementation simply calls through to that method.
*
* @param activity The activity being stopped.
*/
public void callActivityOnStop(Activity activity) {
activity.onStop();
}

/**
* Perform calling of an activity's {@link Activity#onPause} method. The
* default implementation simply calls through to that method.
*
* @param activity The activity being saved.
* @param outState The bundle to pass to the call.
*/
public void callActivityOnSaveInstanceState(Activity activity, Bundle outState) {
activity.performSaveInstanceState(outState);
}

/**
* Perform calling of an activity's {@link Activity#onPause} method. The
* default implementation simply calls through to that method.
*
* @param activity The activity being paused.
*/
public void callActivityOnPause(Activity activity) {
activity.performPause();
}

/**
* Perform calling of an activity's {@link Activity#onUserLeaveHint} method.
* The default implementation simply calls through to that method.
*
* @param activity The activity being notified that the user has navigated away
*/
public void callActivityOnUserLeaving(Activity activity) {
activity.performUserLeaving();
}

/*
* Starts allocation counting. This triggers a gc and resets the counts.
*/
public void startAllocCounting() {
// Before we start trigger a GC and reset the debug counts. Run the
// finalizers and another GC before starting and stopping the alloc
// counts. This will free up any objects that were just sitting around
// waiting for their finalizers to be run.
Runtime.getRuntime().gc();
Runtime.getRuntime().runFinalization();
Runtime.getRuntime().gc();

Debug.resetAllCounts();

// start the counts
Debug.startAllocCounting();
}

/*
* Stops allocation counting.
*/
public void stopAllocCounting() {
Runtime.getRuntime().gc();
Runtime.getRuntime().runFinalization();
Runtime.getRuntime().gc();
Debug.stopAllocCounting();
}

/**
* If Results already contains Key, it appends Value to the key's ArrayList
* associated with the key. If the key doesn't already exist in results, it
* adds the key/value pair to results.
*/
private void addValue(String key, int value, Bundle results) {
if (results.containsKey(key)) {
List<Integer> list = results.getIntegerArrayList(key);
if (list != null) {
list.add(value);
}
} else {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(value);
results.putIntegerArrayList(key, list);
}
}

/**
* Returns a bundle with the current results from the allocation counting.
*/
public Bundle getAllocCounts() {
Bundle results = new Bundle();
results.putLong("global_alloc_count", Debug.getGlobalAllocCount());
results.putLong("global_alloc_size", Debug.getGlobalAllocSize());
results.putLong("global_freed_count", Debug.getGlobalFreedCount());
results.putLong("global_freed_size", Debug.getGlobalFreedSize());
results.putLong("gc_invocation_count", Debug.getGlobalGcInvocationCount());
return results;
}

/**
* Returns a bundle with the counts for various binder counts for this process. Currently the only two that are
* reported are the number of send and the number of received transactions.
*/
public Bundle getBinderCounts() {
Bundle results = new Bundle();
results.putLong("sent_transactions", Debug.getBinderSentTransactions());
results.putLong("received_transactions", Debug.getBinderReceivedTransactions());
return results;
}

/**
* Description of a Activity execution result to return to the original
* activity.
*/
public static final class ActivityResult {
/**
* Create a new activity result. See {@link Activity#setResult} for
* more information.
*
* @param resultCode The result code to propagate back to the
* originating activity, often RESULT_CANCELED or RESULT_OK
* @param resultData The data to propagate back to the originating
* activity.
*/
public ActivityResult(int resultCode, Intent resultData) {
mResultCode = resultCode;
mResultData = resultData;
}

/**
* Retrieve the result code contained in this result.
*/
public int getResultCode() {
return mResultCode;
}

/**
* Retrieve the data contained in this result.
*/
public Intent getResultData() {
return mResultData;
}

private final int mResultCode;
private final Intent mResultData;
}

/**
* Execute a startActivity call made by the application. The default
* implementation takes care of updating any active {@link ActivityMonitor}
* objects and dispatches this call to the system activity manager; you can
* override this to watch for the application to start an activity, and
* modify what happens when it does.
*
* <p>This method returns an {@link ActivityResult} object, which you can
* use when intercepting application calls to avoid performing the start
* activity action but still return the result the application is
* expecting. To do this, override this method to catch the call to start
* activity so that it returns a new ActivityResult containing the results
* you would like the application to see, and don't call up to the super
* class. Note that an application is only expecting a result if
* <var>requestCode</var> is &gt;= 0.
*
* <p>This method throws {@link android.content.ActivityNotFoundException}
* if there was no Activity found to run the given Intent.
*
* @param who The Context from which the activity is being started.
* @param contextThread The main thread of the Context from which the activity
* is being started.
* @param token Internal token identifying to the system who is starting
* the activity; may be null.
* @param target Which activity is perform the start (and thus receiving
* any result); may be null if this call is not being made
* from an activity.
* @param intent The actual Intent to start.
* @param requestCode Identifier for this request's result; less than zero
* if the caller is not expecting a result.
*
* @return To force the return of a particular result, return an
* ActivityResult object containing the desired data; otherwise
* return null. The default implementation always returns null.
*
* @throws android.content.ActivityNotFoundException
*
* @see Activity#startActivity(Intent)
* @see Activity#startActivityForResult(Intent, int)
* @see Activity#startActivityFromChild
*
* {@hide}
*/
public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Activity target,
Intent intent, int requestCode) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
if (am.match(who, null, intent)) {
am.mHits++;
if (am.isBlocking()) {
return requestCode >= 0 ? am.getResult() : null;
}
break;
}
}
}
}
try {
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, intent,
intent.resolveTypeIfNeeded(who.getContentResolver( )),
null, 0, token, target != null ? target.mEmbeddedID : null,
requestCode, false, false);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
}
return null;
}

/*package*/ final void init(ActivityThread thread,
Context instrContext, Context appContext, ComponentName component,
IInstrumentationWatcher watcher) {
mThread = thread;
mMessageQueue = mThread.getLooper().myQueue();
mInstrContext = instrContext;
mAppContext = appContext;
mComponent = component;
mWatcher = watcher;
}

/*package*/ static void checkStartActivityResult(int res, Object intent) {
if (res >= IActivityManager.START_SUCCESS) {
return;
}

switch (res) {
case IActivityManager.START_INTENT_NOT_RESOLVED:
case IActivityManager.START_CLASS_NOT_FOUND:
if (intent instanceof Intent && ((Intent)intent).getComponent() != null)
throw new ActivityNotFoundException(
"Unable to find explicit activity class "
+ ((Intent)intent).getComponent().toShortString()
+ "; have you declared this activity in your AndroidManifest.xml?");
throw new ActivityNotFoundException(
"No Activity found to handle " + intent);
case IActivityManager.START_PERMISSION_DENIED:
throw new SecurityException("Not allowed to start activity "
+ intent);
case IActivityManager.START_FORWARD_AND_REQUEST_CONFLIC T:
throw new AndroidRuntimeException(
"FORWARD_RESULT_FLAG used while also requesting a result");
case IActivityManager.START_NOT_ACTIVITY:
throw new IllegalArgumentException(
"PendingIntent is not an activity");
default:
throw new AndroidRuntimeException("Unknown error code "
+ res + " when starting " + intent);
}
}

private final void validateNotAppThread() {
if (ActivityThread.currentActivityThread() != null) {
throw new RuntimeException(
"This method can not be called from the main application thread");
}
}

private final class InstrumentationThread extends Thread {
public InstrumentationThread(String name) {
super(name);
}
public void run() {
IActivityManager am = ActivityManagerNative.getDefault();
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_ URGENT_DISPLAY);
} catch (RuntimeException e) {
Log.w(TAG, "Exception setting priority of instrumentation thread "
+ Process.myTid(), e);
}
if (mAutomaticPerformanceSnapshots) {
startPerformanceSnapshot();
}
onStart();
}
}

private static final class EmptyRunnable implements Runnable {
public void run() {
}
}

private static final class SyncRunnable implements Runnable {
private final Runnable mTarget;
private boolean mComplete;

public SyncRunnable(Runnable target) {
mTarget = target;
}

public void run() {
mTarget.run();
synchronized (this) {
mComplete = true;
notifyAll();
}
}

public void waitForComplete() {
synchronized (this) {
while (!mComplete) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
}
}

private static final class ActivityWaiter {
public final Intent intent;
public Activity activity;

public ActivityWaiter(Intent _intent) {
intent = _intent;
}
}

private final class ActivityGoing implements MessageQueue.IdleHandler {
private final ActivityWaiter mWaiter;

public ActivityGoing(ActivityWaiter waiter) {
mWaiter = waiter;
}

public final boolean queueIdle() {
synchronized (mSync) {
mWaitingActivities.remove(mWaiter);
mSync.notifyAll();
}
return false;
}
}

private static final class Idler implements MessageQueue.IdleHandler {
private final Runnable mCallback;
private boolean mIdle;

public Idler(Runnable callback) {
mCallback = callback;
mIdle = false;
}

public final boolean queueIdle() {
if (mCallback != null) {
mCallback.run();
}
synchronized (this) {
mIdle = true;
notifyAll();
}
return false;
}

public void waitForIdle() {
synchronized (this) {
while (!mIdle) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
}
}
}

11-16 22:16:40.979: I/DEBUG(31): debuggerd: Jun 30 2010 13:59:20
11-16 22:16:41.079: D/qemud(38): entering main loop
11-16 22:16:41.079: I/Netd(30): Netd 1.0 starting
11-16 22:16:41.090: I/Vold(29): Vold 2.1 (the revenge) firing up
11-16 22:16:41.090: D/Vold(29): Volume sdcard state changing -1 (Initializing) -> 0 (No-Media)
11-16 22:16:41.489: D/Vold(29): Volume sdcard state changing 0 (No-Media) -> 1 (Idle-Unmounted)
11-16 22:16:41.489: W/Vold(29): No UMS switch available
11-16 22:16:41.630: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:16:41.630: D/qemud(38): created client 0xe078 listening on fd 8
11-16 22:16:41.649: D/qemud(38): client_fd_receive: attempting registration for service 'boot-properties'
11-16 22:16:41.649: D/qemud(38): client_fd_receive: -> received channel id 1
11-16 22:16:41.659: D/qemud(38): client_registration: registration succeeded for client 1
11-16 22:16:41.659: I/qemu-props(51): connected to 'boot-properties' qemud service.
11-16 22:16:41.669: I/qemu-props(51): received: dalvik.vm.heapsize=24m
11-16 22:16:41.669: I/qemu-props(51): received: qemu.sf.lcd_density=240
11-16 22:16:41.669: I/qemu-props(51): received: qemu.hw.mainkeys=1
11-16 22:16:41.669: I/qemu-props(51): received: qemu.sf.fake_camera=back
11-16 22:16:41.669: I/qemu-props(51): received:
11-16 22:16:41.669: I/qemu-props(51): invalid format, ignored.
11-16 22:16:42.229: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:16:42.229: D/qemud(38): created client 0x12f38 listening on fd 11
11-16 22:16:42.229: D/qemud(38): fdhandler_event: disconnect on fd 11
11-16 22:16:42.260: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:16:42.260: D/qemud(38): created client 0x12f38 listening on fd 11
11-16 22:16:42.260: D/qemud(38): client_fd_receive: attempting registration for service 'gsm'
11-16 22:16:42.260: D/qemud(38): client_fd_receive: -> received channel id 2
11-16 22:16:42.269: D/qemud(38): client_registration: registration succeeded for client 2
11-16 22:16:42.319: D/AndroidRuntime(33): >>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<
11-16 22:16:42.319: D/AndroidRuntime(33): CheckJNI is ON
11-16 22:16:42.959: I/(34): ServiceManager: 0xacd0
11-16 22:16:42.979: D/AudioHardwareInterface(34): setMode(NORMAL)
11-16 22:16:42.990: I/CameraService(34): CameraService started: pid=34
11-16 22:16:43.011: I/AudioFlinger(34): AudioFlinger's thread 0xb3d8 ready to run
11-16 22:16:43.061: D/AndroidRuntime(33): --- registering native functions ---
11-16 22:16:43.660: I/SamplingProfilerIntegration(33): Profiler is disabled.
11-16 22:16:43.749: I/Zygote(33): Preloading classes...
11-16 22:16:43.749: E/Zygote(33): setreuid() failed. errno: 2
11-16 22:16:43.769: D/dalvikvm(33): GC_EXPLICIT freed 821 objects / 47496 bytes in 14ms
11-16 22:16:44.170: D/dalvikvm(33): GC_EXPLICIT freed 219 objects / 13600 bytes in 8ms
11-16 22:16:44.289: D/dalvikvm(33): GC_EXPLICIT freed 253 objects / 14360 bytes in 11ms
11-16 22:16:44.409: D/dalvikvm(33): GC_EXPLICIT freed 468 objects / 28984 bytes in 8ms
11-16 22:16:44.881: D/dalvikvm(33): GC_EXPLICIT freed 2088 objects / 108280 bytes in 12ms
11-16 22:16:45.189: W/MediaProfiles(33): could not find media config xml file
11-16 22:16:45.239: D/dalvikvm(33): GC_EXPLICIT freed 279 objects / 15984 bytes in 15ms
11-16 22:16:45.711: D/dalvikvm(33): GC_FOR_MALLOC freed 5052 objects / 223992 bytes in 23ms
11-16 22:16:47.010: D/dalvikvm(33): GC_FOR_MALLOC freed 11253 objects / 381344 bytes in 33ms
11-16 22:16:47.470: D/dalvikvm(33): GC_FOR_MALLOC freed 9798 objects / 461152 bytes in 35ms
11-16 22:16:47.889: D/dalvikvm(33): GC_FOR_MALLOC freed 8690 objects / 422872 bytes in 37ms
11-16 22:16:48.440: D/dalvikvm(33): GC_FOR_MALLOC freed 7835 objects / 458864 bytes in 38ms
11-16 22:16:48.939: D/dalvikvm(33): GC_FOR_MALLOC freed 7626 objects / 457776 bytes in 40ms
11-16 22:16:49.519: D/dalvikvm(33): GC_FOR_MALLOC freed 8231 objects / 513296 bytes in 39ms
11-16 22:16:50.090: D/dalvikvm(33): GC_FOR_MALLOC freed 7558 objects / 487104 bytes in 42ms
11-16 22:16:50.130: D/dalvikvm(33): GC_EXPLICIT freed 175 objects / 9248 bytes in 32ms
11-16 22:16:50.369: D/dalvikvm(33): GC_EXPLICIT freed 594 objects / 29024 bytes in 32ms
11-16 22:16:50.469: D/dalvikvm(33): GC_EXPLICIT freed 449 objects / 25280 bytes in 35ms
11-16 22:16:50.790: D/dalvikvm(33): GC_EXPLICIT freed 308 objects / 35136 bytes in 46ms
11-16 22:16:50.961: D/dalvikvm(33): GC_EXPLICIT freed 279 objects / 18896 bytes in 47ms
11-16 22:16:51.340: D/dalvikvm(33): GC_EXPLICIT freed 341 objects / 18472 bytes in 47ms
11-16 22:16:51.609: D/dalvikvm(33): GC_EXPLICIT freed 449 objects / 28352 bytes in 46ms
11-16 22:16:53.809: D/dalvikvm(33): GC_EXPLICIT freed 529 objects / 53248 bytes in 54ms
11-16 22:16:53.950: D/dalvikvm(33): GC_EXPLICIT freed 623 objects / 34016 bytes in 54ms
11-16 22:16:54.099: D/dalvikvm(33): GC_EXPLICIT freed 861 objects / 46872 bytes in 56ms
11-16 22:16:54.330: D/dalvikvm(33): GC_EXPLICIT freed 1747 objects / 85512 bytes in 60ms
11-16 22:16:54.469: D/dalvikvm(33): GC_EXPLICIT freed 447 objects / 29416 bytes in 63ms
11-16 22:16:54.609: D/dalvikvm(33): GC_EXPLICIT freed 315 objects / 20184 bytes in 65ms
11-16 22:16:54.620: I/Zygote(33): ...preloaded 1265 classes in 10869ms.
11-16 22:16:54.620: E/Zygote(33): setreuid() failed. errno: 17
11-16 22:16:54.680: D/dalvikvm(33): GC_EXPLICIT freed 104 objects / 14200 bytes in 56ms
11-16 22:16:54.849: I/Zygote(33): Preloading resources...
11-16 22:16:54.870: W/Zygote(33): Preloaded drawable resource #0x1080093 (res/drawable-hdpi/sym_def_app_icon.png) that varies with configuration!!
11-16 22:16:54.880: W/Zygote(33): Preloaded drawable resource #0x1080002 (res/drawable-hdpi/arrow_down_float.png) that varies with configuration!!
11-16 22:16:54.949: W/Zygote(33): Preloaded drawable resource #0x10800b3 (res/drawable/btn_check.xml) that varies with configuration!!
11-16 22:16:54.989: W/Zygote(33): Preloaded drawable resource #0x10800b6 (res/drawable-hdpi/btn_check_label_background.9.png) that varies with configuration!!
11-16 22:16:54.989: W/Zygote(33): Preloaded drawable resource #0x10800b7 (res/drawable-hdpi/btn_check_off.png) that varies with configuration!!
11-16 22:16:54.989: W/Zygote(33): Preloaded drawable resource #0x10800bc (res/drawable-hdpi/btn_check_on.png) that varies with configuration!!
11-16 22:16:55.051: W/Zygote(33): Preloaded drawable resource #0x1080004 (res/drawable/btn_default.xml) that varies with configuration!!
11-16 22:16:55.130: W/Zygote(33): Preloaded drawable resource #0x1080005 (res/drawable/btn_default_small.xml) that varies with configuration!!
11-16 22:16:55.179: W/Zygote(33): Preloaded drawable resource #0x1080006 (res/drawable/btn_dropdown.xml) that varies with configuration!!
11-16 22:16:55.229: W/Zygote(33): Preloaded drawable resource #0x1080008 (res/drawable/btn_plus.xml) that varies with configuration!!
11-16 22:16:55.269: W/Zygote(33): Preloaded drawable resource #0x1080007 (res/drawable/btn_minus.xml) that varies with configuration!!
11-16 22:16:55.330: W/Zygote(33): Preloaded drawable resource #0x1080009 (res/drawable/btn_radio.xml) that varies with configuration!!
11-16 22:16:55.380: W/Zygote(33): Preloaded drawable resource #0x108000a (res/drawable/btn_star.xml) that varies with configuration!!
11-16 22:16:55.439: D/dalvikvm(33): GC_EXPLICIT freed 421 objects / 25848 bytes in 58ms
11-16 22:16:55.462: W/Zygote(33): Preloaded drawable resource #0x1080131 (res/drawable/btn_toggle.xml) that varies with configuration!!
11-16 22:16:55.462: W/Zygote(33): Preloaded drawable resource #0x1080194 (res/drawable-hdpi/ic_emergency.png) that varies with configuration!!
11-16 22:16:55.469: W/Zygote(33): Preloaded drawable resource #0x1080012 (res/drawable-hdpi/divider_horizontal_bright.9.png) that varies with configuration!!
11-16 22:16:55.469: W/Zygote(33): Preloaded drawable resource #0x1080014 (res/drawable-hdpi/divider_horizontal_dark.9.png) that varies with configuration!!
11-16 22:16:55.500: W/Zygote(33): Preloaded drawable resource #0x1080016 (res/drawable/edit_text.xml) that varies with configuration!!
11-16 22:16:55.509: W/Zygote(33): Preloaded drawable resource #0x108016d (res/drawable/expander_group.xml) that varies with configuration!!
11-16 22:16:55.540: W/Zygote(33): Preloaded drawable resource #0x1080062 (res/drawable/list_selector_background.xml) that varies with configuration!!
11-16 22:16:55.549: W/Zygote(33): Preloaded drawable resource #0x1080227 (res/drawable-hdpi/menu_background.9.png) that varies with configuration!!
11-16 22:16:55.549: W/Zygote(33): Preloaded drawable resource #0x1080228 (res/drawable-hdpi/menu_background_fill_parent_width.9.png) that varies with configuration!!
11-16 22:16:55.570: W/Zygote(33): Preloaded drawable resource #0x1080229 (res/drawable/menu_selector.xml) that varies with configuration!!
11-16 22:16:55.570: W/Zygote(33): Preloaded drawable resource #0x1080234 (res/drawable-hdpi/panel_background.9.png) that varies with configuration!!
11-16 22:16:55.580: W/Zygote(33): Preloaded drawable resource #0x108023b (res/drawable-hdpi/popup_bottom_bright.9.png) that varies with configuration!!
11-16 22:16:55.589: W/Zygote(33): Preloaded drawable resource #0x108023c (res/drawable-hdpi/popup_bottom_dark.9.png) that varies with configuration!!
11-16 22:16:55.589: W/Zygote(33): Preloaded drawable resource #0x108023d (res/drawable-hdpi/popup_bottom_medium.9.png) that varies with configuration!!
11-16 22:16:55.599: W/Zygote(33): Preloaded drawable resource #0x108023e (res/drawable-hdpi/popup_center_bright.9.png) that varies with configuration!!
11-16 22:16:55.599: W/Zygote(33): Preloaded drawable resource #0x108023f (res/drawable-hdpi/popup_center_dark.9.png) that varies with configuration!!
11-16 22:16:55.609: W/Zygote(33): Preloaded drawable resource #0x1080242 (res/drawable-hdpi/popup_full_dark.9.png) that varies with configuration!!
11-16 22:16:55.609: W/Zygote(33): Preloaded drawable resource #0x1080245 (res/drawable-hdpi/popup_top_bright.9.png) that varies with configuration!!
11-16 22:16:55.620: W/Zygote(33): Preloaded drawable resource #0x1080246 (res/drawable-hdpi/popup_top_dark.9.png) that varies with configuration!!
11-16 22:16:55.641: W/Zygote(33): Preloaded drawable resource #0x108006d (res/drawable/progress_indeterminate_horizontal.xml) that varies with configuration!!
11-16 22:16:55.649: W/Zygote(33): Preloaded drawable resource #0x108024c (res/drawable/progress_small.xml) that varies with configuration!!
11-16 22:16:55.659: W/Zygote(33): Preloaded drawable resource #0x108024d (res/drawable/progress_small_titlebar.xml) that varies with configuration!!
11-16 22:16:55.659: W/Zygote(33): Preloaded drawable resource #0x1080270 (res/drawable-hdpi/scrollbar_handle_horizontal.9.png) that varies with configuration!!
11-16 22:16:55.670: W/Zygote(33): Preloaded drawable resource #0x1080271 (res/drawable-hdpi/scrollbar_handle_vertical.9.png) that varies with configuration!!
11-16 22:16:55.730: D/dalvikvm(33): GC_EXPLICIT freed 477 objects / 32608 bytes in 59ms
11-16 22:16:55.751: W/Zygote(33): Preloaded drawable resource #0x1080071 (res/drawable/spinner_dropdown_background.xml) that varies with configuration!!
11-16 22:16:55.759: W/Zygote(33): Preloaded drawable resource #0x1080354 (res/drawable-hdpi/title_bar_shadow.9.png) that varies with configuration!!
11-16 22:16:55.769: W/Zygote(33): Preloaded drawable resource #0x10801d6 (res/drawable-hdpi/indicator_code_lock_drag_direction_green_up.png) that varies with configuration!!
11-16 22:16:55.769: W/Zygote(33): Preloaded drawable resource #0x10801d7 (res/drawable-hdpi/indicator_code_lock_drag_direction_red_up.png) that varies with configuration!!
11-16 22:16:55.769: W/Zygote(33): Preloaded drawable resource #0x10801d8 (res/drawable-hdpi/indicator_code_lock_point_area_default.png) that varies with configuration!!
11-16 22:16:55.779: W/Zygote(33): Preloaded drawable resource #0x10801d9 (res/drawable-hdpi/indicator_code_lock_point_area_green.png) that varies with configuration!!
11-16 22:16:55.790: W/Zygote(33): Preloaded drawable resource #0x10801da (res/drawable-hdpi/indicator_code_lock_point_area_red.png) that varies with configuration!!
11-16 22:16:55.790: W/Zygote(33): Preloaded drawable resource #0x10801e8 (res/drawable-hdpi/jog_tab_bar_left_end_confirm_gray.9.png) that varies with configuration!!
11-16 22:16:55.799: W/Zygote(33): Preloaded drawable resource #0x10801ec (res/drawable-hdpi/jog_tab_bar_left_end_normal.9.png) that varies with configuration!!
11-16 22:16:55.799: W/Zygote(33): Preloaded drawable resource #0x10801ed (res/drawable-hdpi/jog_tab_bar_left_end_pressed.9.png) that varies with configuration!!
11-16 22:16:55.809: W/Zygote(33): Preloaded drawable resource #0x10801f1 (res/drawable-hdpi/jog_tab_bar_right_end_confirm_gray.9.png) that varies with configuration!!
11-16 22:16:55.809: W/Zygote(33): Preloaded drawable resource #0x10801f5 (res/drawable-hdpi/jog_tab_bar_right_end_normal.9.png) that varies with configuration!!
11-16 22:16:55.821: W/Zygote(33): Preloaded drawable resource #0x10801f6 (res/drawable-hdpi/jog_tab_bar_right_end_pressed.9.png) that varies with configuration!!
11-16 22:16:55.821: W/Zygote(33): Preloaded drawable resource #0x10801fb (res/drawable-hdpi/jog_tab_left_confirm_gray.png) that varies with configuration!!
11-16 22:16:55.830: W/Zygote(33): Preloaded drawable resource #0x1080200 (res/drawable-hdpi/jog_tab_left_normal.png) that varies with configuration!!
11-16 22:16:55.839: W/Zygote(33): Preloaded drawable resource #0x1080201 (res/drawable-hdpi/jog_tab_left_pressed.png) that varies with configuration!!
11-16 22:16:55.839: W/Zygote(33): Preloaded drawable resource #0x1080203 (res/drawable-hdpi/jog_tab_right_confirm_gray.png) that varies with configuration!!
11-16 22:16:55.849: W/Zygote(33): Preloaded drawable resource #0x1080209 (res/drawable-hdpi/jog_tab_right_normal.png) that varies with configuration!!
11-16 22:16:55.849: W/Zygote(33): Preloaded drawable resource #0x108020a (res/drawable-hdpi/jog_tab_right_pressed.png) that varies with configuration!!
11-16 22:16:55.859: W/Zygote(33): Preloaded drawable resource #0x108020d (res/drawable-hdpi/jog_tab_target_gray.png) that varies with configuration!!
11-16 22:16:55.859: I/Zygote(33): ...preloaded 61 resources in 1008ms.
11-16 22:16:55.891: I/Zygote(33): ...preloaded 15 resources in 31ms.
11-16 22:16:55.969: D/dalvikvm(33): GC_EXPLICIT freed 503 objects / 37880 bytes in 77ms
11-16 22:16:56.122: D/dalvikvm(33): GC_EXPLICIT freed 150 objects / 5808 bytes in 148ms
11-16 22:16:56.290: D/dalvikvm(33): GC_EXPLICIT freed 2 objects / 48 bytes in 165ms
11-16 22:16:56.309: I/dalvikvm(33): System server process 68 has been created
11-16 22:16:56.309: I/Zygote(33): Accepting command socket connections
11-16 22:16:56.769: E/BatteryService(68): usbOnlinePath not found
11-16 22:16:56.769: E/BatteryService(68): batteryVoltagePath not found
11-16 22:16:56.769: E/BatteryService(68): batteryTemperaturePath not found
11-16 22:16:56.799: I/sysproc(68): Entered system_init()
11-16 22:16:56.799: I/sysproc(68): ServiceManager: 0x1267e0
11-16 22:16:56.799: I/SurfaceFlinger(68): SurfaceFlinger is starting
11-16 22:16:56.811: I/SurfaceFlinger(68): SurfaceFlinger's main thread ready to run. Initializing graphics H/W...
11-16 22:16:56.819: E/SurfaceFlinger(68): Couldn't open /sys/power/wait_for_fb_sleep or /sys/power/wait_for_fb_wake
11-16 22:16:56.859: I/gralloc(68): using (fd=25)
11-16 22:16:56.859: I/gralloc(68): id =
11-16 22:16:56.859: I/gralloc(68): xres = 480 px
11-16 22:16:56.859: I/gralloc(68): yres = 800 px
11-16 22:16:56.859: I/gralloc(68): xres_virtual = 480 px
11-16 22:16:56.859: I/gralloc(68): yres_virtual = 1600 px
11-16 22:16:56.859: I/gralloc(68): bpp = 16
11-16 22:16:56.859: I/gralloc(68): r = 11:5
11-16 22:16:56.859: I/gralloc(68): g = 5:6
11-16 22:16:56.859: I/gralloc(68): b = 0:5
11-16 22:16:56.859: I/gralloc(68): width = 74 mm (164.756760 dpi)
11-16 22:16:56.859: I/gralloc(68): height = 123 mm (165.203247 dpi)
11-16 22:16:56.859: I/gralloc(68): refresh rate = 60.00 Hz
11-16 22:16:56.879: D/libEGL(68): egl.cfg not found, using default config
11-16 22:16:56.889: D/libEGL(68): loaded /system/lib/egl/libGLES_android.so
11-16 22:16:56.921: I/SurfaceFlinger(68): EGL informations:
11-16 22:16:56.921: I/SurfaceFlinger(68): # of configs : 8
11-16 22:16:56.921: I/SurfaceFlinger(68): vendor : Android
11-16 22:16:56.921: I/SurfaceFlinger(68): version : 1.4 Android META-EGL
11-16 22:16:56.921: I/SurfaceFlinger(68): extensions: EGL_KHR_image EGL_KHR_image_base EGL_KHR_image_pixmap EGL_ANDROID_image_native_buffer EGL_ANDROID_swap_rectangle EGL_ANDROID_get_render_buffer
11-16 22:16:56.921: I/SurfaceFlinger(68): Client API: OpenGL ES
11-16 22:16:56.921: I/SurfaceFlinger(68): EGLSurface: 5-6-5-0, config=0x1000000
11-16 22:16:56.929: I/SurfaceFlinger(68): flags : 001c0000
11-16 22:16:56.939: I/SurfaceFlinger(68): OpenGL informations:
11-16 22:16:56.939: I/SurfaceFlinger(68): vendor : Android
11-16 22:16:56.939: I/SurfaceFlinger(68): renderer : Android PixelFlinger 1.3
11-16 22:16:56.949: I/SurfaceFlinger(68): version : OpenGL ES-CM 1.0
11-16 22:16:56.949: I/SurfaceFlinger(68): extensions: GL_OES_byte_coordinates GL_OES_fixed_point GL_OES_single_precision GL_OES_read_format GL_OES_compressed_paletted_texture GL_OES_draw_texture GL_OES_matrix_get GL_OES_query_matrix GL_OES_EGL_image GL_OES_compressed_ETC1_RGB8_texture GL_ARB_texture_compression GL_ARB_texture_non_power_of_two GL_ANDROID_user_clip_plane GL_ANDROID_vertex_buffer_object GL_ANDROID_generate_mipmap
11-16 22:16:56.949: I/SurfaceFlinger(68): GL_MAX_TEXTURE_SIZE = 4096
11-16 22:16:56.949: I/SurfaceFlinger(68): GL_MAX_VIEWPORT_DIMS = 4096
11-16 22:16:57.029: I/sysproc(68): System server: starting Android runtime.
11-16 22:16:57.029: I/sysproc(68): System server: starting Android services.
11-16 22:16:57.040: I/SystemServer(68): Entered the Android system server!
11-16 22:16:57.049: I/sysproc(68): System server: entering thread pool.
11-16 22:16:57.080: I/SystemServer(68): Entropy Service
11-16 22:16:57.179: I/SystemServer(68): Power Manager
11-16 22:16:57.229: I/SystemServer(68): Activity Manager
11-16 22:16:57.299: I/ActivityManager(68): Memory class: 24
11-16 22:16:57.479: D/libEGL(78): egl.cfg not found, using default config
11-16 22:16:57.500: D/libEGL(78): loaded /system/lib/egl/libGLES_android.so
11-16 22:16:57.540: W/zipro(78): Unable to open zip '/data/local/bootanimation.zip': No such file or directory
11-16 22:16:57.540: W/zipro(78): Unable to open zip '/system/media/bootanimation.zip': No such file or directory
11-16 22:16:57.589: W/UsageStats(68): Usage stats version changed; dropping
11-16 22:16:57.769: I/ARMAssembler(68): generated scanline__00000077:03010104_00000004_00000000 [ 22 ipp] (41 ins) at [0x2362d8:0x23637c] in 6431177 ns
11-16 22:16:57.879: I/ARMAssembler(78): generated scanline__00000077:03545404_00000A01_00000000 [ 30 ipp] (51 ins) at [0x1c020:0x1c0ec] in 4051207 ns
11-16 22:16:58.219: I/SystemServer(68): Telephony Registry
11-16 22:16:58.239: I/SystemServer(68): Package Manager
11-16 22:16:58.269: I/Installer(68): connecting...
11-16 22:16:58.279: I/installd(35): new connection
11-16 22:16:58.450: I/PackageManager(68): Libs: android.test.runner:/system/framework/android.test.runner.jar javax.obex:/system/framework/javax.obex.jar
11-16 22:16:58.450: I/PackageManager(68): Features: android.hardware.camera android.hardware.camera.autofocus
11-16 22:16:58.799: D/dalvikvm(68): GC_FOR_MALLOC freed 5267 objects / 231064 bytes in 122ms
11-16 22:16:59.429: W/PackageManager(68): Running ENG build: no pre-dexopt!
11-16 22:16:59.521: D/PackageManager(68): Scanning app dir /system/framework
11-16 22:16:59.819: D/PackageManager(68): Scanning app dir /system/app
11-16 22:17:00.269: D/dalvikvm(68): GC_FOR_MALLOC freed 7408 objects / 364856 bytes in 114ms
11-16 22:17:01.760: D/dalvikvm(68): GC_FOR_MALLOC freed 5412 objects / 297296 bytes in 110ms
11-16 22:17:02.679: D/PackageManager(68): Scanning app dir /data/app
11-16 22:17:03.292: D/dalvikvm(68): GC_FOR_MALLOC freed 7342 objects / 387320 bytes in 127ms
11-16 22:17:03.620: W/PackageParser(68): No actions in intent filter at /data/app/ApiDemos.apk Binary XML file line #1841
11-16 22:17:03.620: W/PackageParser(68): No actions in intent filter at /data/app/ApiDemos.apk Binary XML file line #1847
11-16 22:17:03.662: W/PackageManager(68): Package com.example.android.apis desires unavailable shared library com.example.will.never.exist; ignoring!
11-16 22:17:03.710: D/PackageManager(68): Scanning app dir /data/app-private
11-16 22:17:03.710: I/PackageManager(68): Time to scan packages: 4.28 seconds
11-16 22:17:03.740: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.mail in package com.android.contacts
11-16 22:17:03.740: W/PackageManager(68): Unknown permission android.permission.ADD_SYSTEM_SERVICE in package com.android.phone
11-16 22:17:03.750: W/PackageManager(68): Not granting permission android.permission.SEND_DOWNLOAD_COMPLETED_INTENTS to package com.android.browser (protectionLevel=2 flags=0x1be45)
11-16 22:17:03.759: W/PackageManager(68): Unknown permission com.google.android.gm.permission.WRITE_GMAIL in package com.android.settings
11-16 22:17:03.759: W/PackageManager(68): Unknown permission com.google.android.gm.permission.READ_GMAIL in package com.android.settings
11-16 22:17:03.769: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH in package com.android.settings
11-16 22:17:03.779: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH in package com.android.providers.contacts
11-16 22:17:03.779: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.cp in package com.android.providers.contacts
11-16 22:17:03.790: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.ACCESS_GO OGLE_PASSWORD in package com.android.development
11-16 22:17:03.790: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH in package com.android.development
11-16 22:17:03.790: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.ALL_SERVICES in package com.android.development
11-16 22:17:03.790: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.YouTubeUser in package com.android.development
11-16 22:17:04.160: D/dalvikvm(68): GC_EXPLICIT freed 5483 objects / 333464 bytes in 126ms
11-16 22:17:04.189: I/SystemServer(68): Account Manager
11-16 22:17:04.380: I/SystemServer(68): Content Manager
11-16 22:17:04.510: I/SystemServer(68): System Content Providers
11-16 22:17:04.519: I/ActivityThread(68): Publishing provider settings: com.android.providers.settings.SettingsProvider
11-16 22:17:04.620: I/SystemServer(68): Battery Service
11-16 22:17:04.649: I/SystemServer(68): Lights Service
11-16 22:17:04.649: I/SystemServer(68): ******************************** Service
11-16 22:17:04.660: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:17:04.660: D/qemud(38): created client 0x12f88 listening on fd 12
11-16 22:17:04.670: D/qemud(38): client_fd_receive: attempting registration for service 'hw-control'
11-16 22:17:04.670: D/qemud(38): client_fd_receive: -> received channel id 3
11-16 22:17:04.679: D/qemud(38): client_registration: registration succeeded for client 3
11-16 22:17:04.780: I/SystemServer(68): Alarm Manager
11-16 22:17:04.799: I/SystemServer(68): Init Watchdog
11-16 22:17:04.799: I/SystemServer(68): Sensor Service
11-16 22:17:04.809: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:17:04.819: D/qemud(38): created client 0xc038 listening on fd 13
11-16 22:17:04.819: D/qemud(38): client_fd_receive: attempting registration for service 'sensors'
11-16 22:17:04.819: D/qemud(38): client_fd_receive: -> received channel id 4
11-16 22:17:04.830: D/qemud(38): client_registration: registration succeeded for client 4
11-16 22:17:04.910: D/qemud(38): fdhandler_event: disconnect on fd 13
11-16 22:17:04.910: I/SystemServer(68): Window Manager
11-16 22:17:04.969: I/EventHub(68): New keyboard: device->id=0x10000 devname='qwerty2' propName='hw.keyboards.65536.devname' keylayout='/system/usr/keylayout/qwerty.kl'
11-16 22:17:04.969: I/EventHub(68): New device: path=/dev/input/event0 name=qwerty2 id=0x10000 (of 0x1) index=1 fd=51 classes=0x2f
11-16 22:17:04.979: E/EventHub(68): could not get driver version for /dev/input/mouse0, Not a typewriter
11-16 22:17:04.979: E/EventHub(68): could not get driver version for /dev/input/mice, Not a typewriter
11-16 22:17:04.979: I/KeyInputQueue(68): Device added: id=0x0, name=qwerty2, classes=2f
11-16 22:17:04.999: I/KeyInputQueue(68): X: min=0 max=479 flat=0 fuzz=0
11-16 22:17:04.999: I/KeyInputQueue(68): Y: min=0 max=799 flat=0 fuzz=0
11-16 22:17:05.009: I/KeyInputQueue(68): Pressure: unknown values
11-16 22:17:05.009: I/KeyInputQueue(68): Size: unknown values
11-16 22:17:05.019: I/KeyInputQueue(68): No virtual keys found
11-16 22:17:05.060: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:17:05.060: D/qemud(38): created client 0xc038 listening on fd 13
11-16 22:17:05.060: D/qemud(38): client_fd_receive: attempting registration for service 'sensors'
11-16 22:17:05.060: D/qemud(38): client_fd_receive: -> received channel id 5
11-16 22:17:05.139: D/qemud(38): client_registration: registration succeeded for client 5
11-16 22:17:05.219: D/qemud(38): fdhandler_event: disconnect on fd 13
11-16 22:17:05.299: I/SystemServer(68): Registering null Bluetooth Service (emulator)
11-16 22:17:05.320: E/System(68): Failure starting core service
11-16 22:17:05.320: E/System(68): java.lang.SecurityException
11-16 22:17:05.320: E/System(68): at android.os.BinderProxy.transact(Native Method)
11-16 22:17:05.320: E/System(68): at android.os.ServiceManagerProxy.addService(ServiceM anagerNative.java:146)
11-16 22:17:05.320: E/System(68): at android.os.ServiceManager.addService(ServiceManage r.java:72)
11-16 22:17:05.320: E/System(68): at com.android.server.ServerThread.run(SystemServer.j ava:184)
11-16 22:17:05.320: I/SystemServer(68): Device Policy
11-16 22:17:05.340: I/SystemServer(68): Status Bar
11-16 22:17:05.559: I/SystemServer(68): Clipboard Service
11-16 22:17:05.559: I/SystemServer(68): Input Method Service
11-16 22:17:05.639: I/InputManagerService(68): Enabled input methods: com.android.inputmethod.latin/.LatinIME:com.android.inputmethod.pinyin/.PinyinIME:jp.co.omronsoft.openwnn/.OpenWnnJAJP
11-16 22:17:05.649: I/SystemServer(68): NetStat Service
11-16 22:17:05.669: I/SystemServer(68): NetworkManagement Service
11-16 22:17:05.679: I/SystemServer(68): Connectivity Service
11-16 22:17:05.690: V/ConnectivityService(68): ConnectivityService starting up
11-16 22:17:05.729: D/ConnectivityService(68): getMobileDataEnabled returning true
11-16 22:17:05.761: V/ConnectivityService(68): Starting Wifi Service.
11-16 22:17:05.830: I/WifiService(68): WifiService starting up with Wi-Fi disabled
11-16 22:17:05.851: D/Tethering(68): Tethering starting
11-16 22:17:05.851: D/NetworkManagmentService(68): Registering observer
11-16 22:17:05.889: I/SystemServer(68): Throttle Service
11-16 22:17:05.889: I/SystemServer(68): Accessibility Manager
11-16 22:17:05.910: I/SystemServer(68): Mount Service
11-16 22:17:05.929: I/SystemServer(68): Notification Manager
11-16 22:17:05.960: D/VoldCmdListener(29): volume list
11-16 22:17:05.979: I/PackageManager(68): Updating external media status from unmounted to unmounted
11-16 22:17:05.990: I/SystemServer(68): Device Storage Monitor
11-16 22:17:06.019: D/VoldCmdListener(29): share status ums
11-16 22:17:06.039: I/SystemServer(68): Location Manager
11-16 22:17:06.049: I/SystemServer(68): Search Service
11-16 22:17:06.059: I/SystemServer(68): DropBox Service
11-16 22:17:06.059: I/SystemServer(68): Wallpaper Service
11-16 22:17:06.099: I/SystemServer(68): Audio Service
11-16 22:17:06.280: D/dalvikvm(68): GC_FOR_MALLOC freed 4119 objects / 246440 bytes in 138ms
11-16 22:17:06.519: D/AudioHardwareInterface(34): setMode(NORMAL)
11-16 22:17:06.519: W/AudioPolicyManagerBase(34): setPhoneState() setting same state 0
11-16 22:17:06.559: E/SoundPool(68): error loading /system/media/audio/ui/Effect_Tick.ogg
11-16 22:17:06.559: W/AudioService(68): Soundpool could not load file: /system/media/audio/ui/Effect_Tick.ogg
11-16 22:17:06.570: E/SoundPool(68): error loading /system/media/audio/ui/KeypressStandard.ogg
11-16 22:17:06.570: W/AudioService(68): Soundpool could not load file: /system/media/audio/ui/KeypressStandard.ogg
11-16 22:17:06.580: E/SoundPool(68): error loading /system/media/audio/ui/KeypressSpacebar.ogg
11-16 22:17:06.580: W/AudioService(68): Soundpool could not load file: /system/media/audio/ui/KeypressSpacebar.ogg
11-16 22:17:06.599: E/SoundPool(68): error loading /system/media/audio/ui/KeypressDelete.ogg
11-16 22:17:06.599: W/AudioService(68): Soundpool could not load file: /system/media/audio/ui/KeypressDelete.ogg
11-16 22:17:06.599: E/SoundPool(68): error loading /system/media/audio/ui/KeypressReturn.ogg
11-16 22:17:06.612: W/AudioService(68): Soundpool could not load file: /system/media/audio/ui/KeypressReturn.ogg
11-16 22:17:06.630: I/SystemServer(68): Headset Observer
11-16 22:17:06.639: W/HeadsetObserver(68): This kernel does not have wired headset support
11-16 22:17:06.639: I/SystemServer(68): Dock Observer
11-16 22:17:06.649: W/DockObserver(68): This kernel does not have dock station support
11-16 22:17:06.649: I/SystemServer(68): UI Mode Manager Service
11-16 22:17:06.689: I/SystemServer(68): Backup Service
11-16 22:17:06.720: V/BackupManagerService(68): No ancestral data
11-16 22:17:06.789: I/BackupManagerService(68): Found stale backup journal, scheduling:
11-16 22:17:06.789: I/BackupManagerService(68): + com.android.inputmethod.latin
11-16 22:17:06.789: I/BackupManagerService(68): + com.android.browser
11-16 22:17:06.799: I/BackupManagerService(68): + com.android.providers.userdictionary
11-16 22:17:06.809: I/BackupManagerService(68): + android
11-16 22:17:06.809: I/BackupManagerService(68): + com.android.providers.settings
11-16 22:17:06.809: I/BackupManagerService(68): Backup enabled => false
11-16 22:17:06.820: I/SystemServer(68): AppWidget Service
11-16 22:17:06.830: I/SystemServer(68): Recognition Service
11-16 22:17:06.871: D/VoldCmdListener(29): share status ums
11-16 22:17:06.879: D/StorageNotification(68): Startup with UMS connection false (media state unmounted)
11-16 22:17:06.899: I/SystemServer(68): DiskStats Service
11-16 22:17:06.929: I/WindowManager(68): SAFE MODE not enabled
11-16 22:17:06.929: W/DevicePolicyManagerService(68): failed parsing /data/system/device_policies.xml java.io.FileNotFoundException: /data/system/device_policies.xml (No such file or directory)
11-16 22:17:06.981: I/ActivityManager(68): Config changed: { scale=1.0 imsi=0/0 loc=en_US touch=3 keys=2/1/2 nav=3/1 orien=1 layout=34 uiMode=0 seq=1}
11-16 22:17:07.039: D/PowerManagerService(68): system ready!
11-16 22:17:07.049: I/ActivityManager(68): Sending system update to: ComponentInfo{com.android.providers.contacts/com.android.providers.contacts.ContactsUpgradeRece iver}
11-16 22:17:07.070: I/Zygote(68): Process: zygote socket opened
11-16 22:17:07.110: W/StatusBar(68): No icon ID for slot ime
11-16 22:17:07.120: I/ActivityManager(68): Start proc android.process.acore for broadcast com.android.providers.contacts/.ContactsUpgradeReceiver: pid=108 uid=10000 gids={3003, 1015}
11-16 22:17:07.729: I/ActivityManager(68): Launching preboot mode app: ProcessRecord{44fbc860 108:android.process.acore/10000}
11-16 22:17:08.169: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:17:08.169: D/qemud(38): created client 0xc038 listening on fd 13
11-16 22:17:08.169: D/qemud(38): client_fd_receive: attempting registration for service 'sensors'
11-16 22:17:08.169: D/qemud(38): client_fd_receive: -> received channel id 6
11-16 22:17:08.190: D/qemud(38): client_registration: registration succeeded for client 6
11-16 22:17:08.339: I/ActivityManager(68): Starting activity: Intent { act=android.intent.action.MAIN cat=[android.intent.category.HOME] flg=0x10000000 cmp=com.android.launcher/com.android.launcher2.Launcher }
11-16 22:17:08.429: I/ActivityManager(68): Removing system update proc: ProcessRecord{44fbc860 108:android.process.acore/10000}
11-16 22:17:08.429: I/Process(68): Sending signal. PID: 108 SIG: 9
11-16 22:17:08.450: I/ActivityManager(68): System now ready
11-16 22:17:08.491: D/StatusBar(68): DISABLE_EXPAND: yes
11-16 22:17:08.530: I/SystemServer(68): Making services ready
11-16 22:17:08.570: I/ActivityManager(68): Config changed: { scale=1.0 imsi=0/0 loc=en_US touch=3 keys=2/1/2 nav=3/1 orien=1 layout=34 uiMode=17 seq=2}
11-16 22:17:08.589: W/RecognitionManagerService(68): no available voice recognition services found
11-16 22:17:09.120: I/ActivityManager(68): Start proc com.android.inputmethod.latin for service com.android.inputmethod.latin/.LatinIME: pid=120 uid=10003 gids={}
11-16 22:17:09.150: D/libhardware_legacy(68): using QEMU GPS Hardware emulation
11-16 22:17:09.169: D/NetworkManagmentService(68): Registering observer
11-16 22:17:09.210: E/ThrottleService(68): Could not open GPS configuration file /etc/gps.conf
11-16 22:17:09.259: I/ActivityManager(68): Start proc com.android.phone for added application com.android.phone: pid=125 uid=1001 gids={3002, 3001, 3003, 1015}
11-16 22:17:09.339: I/ActivityManager(68): Start proc com.android.launcher for activity com.android.launcher/com.android.launcher2.Launcher: pid=127 uid=10025 gids={}
11-16 22:17:09.540: I/ActivityManager(68): Start proc com.android.settings for broadcast com.android.settings/.widget.SettingsAppWidgetProvider: pid=131 uid=1000 gids={3002, 3001, 3003}
11-16 22:17:09.559: W/GpsLocationProvider(68): Could not open GPS configuration file /etc/gps.conf
11-16 22:17:10.299: D/dalvikvm(68): GC_FOR_MALLOC freed 5575 objects / 319200 bytes in 719ms
11-16 22:17:10.979: E/logwrapper(148): executing /system/bin/tc failed: No such file or directory
11-16 22:17:11.079: I/logwrapper(30): /system/bin/tc terminated by exit(255)
11-16 22:17:11.110: E/logwrapper(149): executing /system/bin/tc failed: No such file or directory
11-16 22:17:11.150: I/logwrapper(30): /system/bin/tc terminated by exit(255)
11-16 22:17:11.229: E/logwrapper(150): executing /system/bin/tc failed: No such file or directory
11-16 22:17:11.229: I/logwrapper(30): /system/bin/tc terminated by exit(255)
11-16 22:17:11.490: D/AndroidRuntime(116): >>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<
11-16 22:17:11.490: D/AndroidRuntime(116): CheckJNI is ON
11-16 22:17:11.710: W/ActivityManager(68): Unable to start service Intent { act=@0 }: not found
11-16 22:17:11.829: W/ActivityManager(68): Unable to start service Intent { act=@0 }: not found
11-16 22:17:12.809: I/ActivityThread(127): Publishing provider com.android.launcher2.settings: com.android.launcher2.LauncherProvider
11-16 22:17:12.860: I/ActivityThread(125): Publishing provider icc: com.android.phone.IccProvider
11-16 22:17:12.929: I/ActivityThread(125): Publishing provider mms-sms: com.android.providers.telephony.MmsSmsProvider
11-16 22:17:13.190: D/AndroidRuntime(116): --- registering native functions ---
11-16 22:17:13.400: D/qemud(38): fdhandler_accept_event: accepting on fd 10
11-16 22:17:13.400: D/qemud(38): created client 0xc088 listening on fd 14
11-16 22:17:13.400: D/qemud(38): client_fd_receive: attempting registration for service 'gps'
11-16 22:17:13.400: D/qemud(38): client_fd_receive: -> received channel id 7
11-16 22:17:13.429: D/qemud(38): client_registration: registration succeeded for client 7
11-16 22:17:13.429: D/dalvikvm(68): GC_EXTERNAL_ALLOC freed 3199 objects / 211736 bytes in 485ms
11-16 22:17:13.869: I/ActivityThread(125): Publishing provider mms: com.android.providers.telephony.MmsProvider
11-16 22:17:14.039: I/ActivityThread(125): Publishing provider sms: com.android.providers.telephony.SmsProvider
11-16 22:17:14.150: I/ActivityThread(125): Publishing provider telephony: com.android.providers.telephony.TelephonyProvider
11-16 22:17:14.299: D/dalvikvm(127): GC_EXTERNAL_ALLOC freed 968 objects / 72584 bytes in 681ms
11-16 22:17:15.150: I/ActivityManager(68): Start proc android.process.acore for content provider com.android.providers.userdictionary/.UserDictionaryProvider: pid=162 uid=10000 gids={3003, 1015}
11-16 22:17:16.020: D/ConnectivityService(68): getMobileDataEnabled returning true
11-16 22:17:16.589: I/ActivityThread(162): Publishing provider com.android.social: com.android.providers.contacts.SocialProvider
11-16 22:17:16.820: D/PhoneApp(125): onCreate: mProximityWakeLock: null
11-16 22:17:16.999: I/ActivityThread(162): Publishing provider applications: com.android.providers.applications.ApplicationsPro vider
11-16 22:17:17.030: W/ActivityManager(68): Unable to start service Intent { act=com.android.ussd.IExtendedNetworkService }: not found
11-16 22:17:17.270: D/PhoneApp(125): Resetting audio state/mode: IDLE
11-16 22:17:17.929: D/AlarmManagerService(68): Kernel timezone updated to 480 minutes west of GMT
11-16 22:17:17.969: D/SystemClock(125): Setting time of day to sec=1321510637
11-16 22:17:17.295: W/SystemClock(125): Unable to set rtc to 1321510637: Invalid argument
11-16 22:17:17.325: I/ActivityManager(68): Start proc com.android.alarmclock for broadcast com.android.alarmclock/.AlarmInitReceiver: pid=174 uid=10009 gids={}
11-16 22:17:17.735: I/ActivityThread(162): Publishing provider contacts;com.android.contacts: com.android.providers.contacts.ContactsProvider2
11-16 22:17:18.624: D/dalvikvm(68): GREF has increased to 201
11-16 22:17:18.714: D/MobileDataStateTracker(68): default Received state= DISCONNECTED, old= DISCONNECTED, reason= gprsDetached, apnTypeList= default
11-16 22:17:19.075: I/ActivityThread(174): Publishing provider com.android.alarmclock: com.android.alarmclock.AlarmProvider
11-16 22:17:20.254: D/dalvikvm(125): GC_FOR_MALLOC freed 3562 objects / 220488 bytes in 546ms
11-16 22:17:20.466: I/ActivityManager(68): Start proc com.android.defcontainer for service com.android.defcontainer/.DefaultContainerService: pid=189 uid=10010 gids={1015, 2001}
11-16 22:17:20.644: W/ActivityManager(68): Activity idle timeout for HistoryRecord{45020b58 com.android.launcher/com.android.launcher2.Launcher}
11-16 22:17:20.674: D/PowerManagerService(68): bootCompleted
11-16 22:17:20.906: D/VoldCmdListener(29): volume mount /mnt/sdcard
11-16 22:17:20.906: I/Vold(29): /dev/block/vold/179:0 being considered for volume sdcard
11-16 22:17:20.914: D/Vold(29): Volume sdcard state changing 1 (Idle-Unmounted) -> 3 (Checking)
11-16 22:17:21.174: D/MobileDataStateTracker(68): default Received state= DISCONNECTED, old= DISCONNECTED, reason= (unspecified), apnTypeList= default
11-16 22:17:21.204: I/StorageNotification(68): Media {/mnt/sdcard} state changed from {unmounted} -> {checking}
11-16 22:17:21.334: D/OtaStartupReceiver(125): Not a CDMA phone, no need to process OTA
11-16 22:17:21.615: D/MccTable(125): updateMccMncConfiguration: mcc=310, mnc=260
11-16 22:17:21.635: D/MccTable(125): locale set to en_us
11-16 22:17:21.635: D/MccTable(125): WIFI_NUM_ALLOWED_CHANNELS set to 11
11-16 22:17:21.674: I/WifiService(68): WifiService trying to setNumAllowed to 11 with persist set to true
11-16 22:17:21.695: I/ActivityManager(68): Config changed: { scale=1.0 imsi=310/260 loc=en_US touch=3 keys=2/1/2 nav=3/1 orien=1 layout=34 uiMode=17 seq=3}
11-16 22:17:21.744: I/UsageStats(68): Unexpected resume of com.android.launcher while already resumed in com.android.launcher
11-16 22:17:22.504: D/TelephonyProvider(125): Setting numeric '310260' to be the current operator
11-16 22:17:22.764: I/ActivityThread(162): Publishing provider call_log: com.android.providers.contacts.CallLogProvider
11-16 22:17:22.764: I/ActivityThread(162): Publishing provider user_dictionary: com.android.providers.userdictionary.UserDictionar yProvider
11-16 22:17:22.825: D/dalvikvm(68): GC_FOR_MALLOC freed 7449 objects / 333352 bytes in 314ms
11-16 22:17:23.315: I/ActivityManager(68): Start proc android.process.media for broadcast com.android.providers.downloads/.DownloadReceiver: pid=202 uid=10002 gids={1015, 1006, 2001, 3003}
11-16 22:17:23.405: I/RecoverySystem(68): No recovery log file
11-16 22:17:23.744: D/dalvikvm(33): GC_EXPLICIT freed 268 objects / 10144 bytes in 448ms
11-16 22:17:24.334: D/dalvikvm(33): GC_EXPLICIT freed 40 objects / 1768 bytes in 498ms
11-16 22:17:24.494: D/MobileDataStateTracker(68): default Received state= CONNECTING, old= DISCONNECTED, reason= simLoaded, apnTypeList= *
11-16 22:17:24.544: D/NetworkStateTracker(68): setDetailed state, old =IDLE and new state=CONNECTING
11-16 22:17:24.544: D/ConnectivityService(68): ConnectivityChange for mobile: CONNECTING/CONNECTING
11-16 22:17:24.575: D/MobileDataStateTracker(68): replacing old mInterfaceName (null) with /dev/omap_csmi_tty1 for hipri
11-16 22:17:24.605: D/MobileDataStateTracker(68): replacing old mInterfaceName (null) with /dev/omap_csmi_tty1 for supl
11-16 22:17:24.624: D/MobileDataStateTracker(68): replacing old mInterfaceName (null) with /dev/omap_csmi_tty1 for mms
11-16 22:17:24.624: D/MobileDataStateTracker(68): default Received state= CONNECTED, old= CONNECTING, reason= simLoaded, apnTypeList= *
11-16 22:17:24.655: D/NetworkStateTracker(68): setDetailed state, old =CONNECTING and new state=CONNECTED
11-16 22:17:24.655: D/ConnectivityService(68): ConnectivityChange for mobile: CONNECTED/CONNECTED
11-16 22:17:24.664: V/NetworkStateTracker(68): Setting TCP values: [4094,87380,110208,4096,16384,110208] which comes from [net.tcp.buffersize.umts]
11-16 22:17:24.764: I/ActivityThread(202): Publishing provider drm: com.android.providers.drm.DrmProvider
11-16 22:17:24.894: D/dalvikvm(33): GC_EXPLICIT freed 2 objects / 48 bytes in 566ms
11-16 22:17:25.004: D/ConnectivityService(68): adding dns 10.0.2.3 for mobile
11-16 22:17:25.065: I/ActivityThread(202): Publishing provider media: com.android.providers.media.MediaProvider
11-16 22:17:25.075: D/Tethering(68): Tethering got CONNECTIVITY_ACTION
11-16 22:17:25.084: D/Tethering(68): MasterInitialState.processMessage what=3
11-16 22:17:25.084: E/HierarchicalStateMachine(68): TetherMaster - unhandledMessage: msg.what=3
11-16 22:17:25.326: V/MediaProvider(202): Attached volume: internal
11-16 22:17:25.374: I/ActivityThread(202): Publishing provider downloads: com.android.providers.downloads.DownloadProvider
11-16 22:17:26.196: I/ActivityManager(68): Start proc com.android.mms for broadcast com.android.mms/.transaction.MmsSystemEventReceiver: pid=214 uid=10015 gids={3003, 1015}
11-16 22:17:26.424: I/SurfaceFlinger(68): Boot is finished (30448 ms)
11-16 22:17:26.504: I/ARMAssembler(68): generated scanline__00000177:03515104_00000001_00000000 [ 73 ipp] (95 ins) at [0x31e0e8:0x31e264] in 1822438 ns
11-16 22:17:26.716: D/SntpClient(68): request time failed: java.net.SocketException: Address family not supported by protocol
11-16 22:17:26.794: I/SearchManagerService(68): Building list of searchable activities
11-16 22:17:27.044: I/ActivityThread(214): Publishing provider com.android.mms.SuggestionsProvider: com.android.mms.SuggestionsProvider
11-16 22:17:27.334: I//system/bin/fsck_msdos(29): ** /dev/block/vold/179:0
11-16 22:17:27.624: I/ActivityManager(68): Start proc com.android.email for broadcast com.android.email/com.android.exchange.BootReceiver: pid=230 uid=10030 gids={3003, 1015}
11-16 22:17:28.094: I/ActivityThread(230): Publishing provider com.android.email.provider: com.android.email.provider.EmailProvider
11-16 22:17:28.145: I/ActivityThread(230): Publishing provider com.android.exchange.provider: com.android.exchange.provider.ExchangeProvider
11-16 22:17:28.155: I/ActivityThread(230): Publishing provider com.android.email.attachmentprovider: com.android.email.provider.AttachmentProvider
11-16 22:17:28.324: D/Exchange(230): BootReceiver onReceive
11-16 22:17:28.365: I/ActivityManager(68): Start proc com.android.protips for broadcast com.android.protips/.ProtipWidget: pid=238 uid=10007 gids={}
11-16 22:17:28.454: D/EAS SyncManager(230): !!! EAS SyncManager, onCreate
11-16 22:17:28.674: D/dalvikvm(68): GC_EXPLICIT freed 7770 objects / 439784 bytes in 289ms
11-16 22:17:28.905: I//system/bin/fsck_msdos(29): ** Phase 1 - Read and Compare FATs
11-16 22:17:29.044: D/EAS SyncManager(230): !!! EAS SyncManager, onStartCommand
11-16 22:17:29.126: D/EAS SyncManager(230): !!! EAS SyncManager, stopping self
11-16 22:17:29.294: I//system/bin/fsck_msdos(29): Attempting to allocate 1022 KB for FAT
11-16 22:17:29.315: D/MediaScannerService(202): start scanning volume internal
11-16 22:17:29.365: D/Eas Debug(230): Logging:
11-16 22:17:29.385: D/EAS SyncManager(230): !!! EAS SyncManager, onDestroy
11-16 22:17:29.824: D/dalvikvm(189): GC_EXPLICIT freed 785 objects / 56072 bytes in 139ms
11-16 22:17:30.124: D/KeyguardViewMediator(68): pokeWakelock(5000)
11-16 22:17:30.529: D/KeyguardViewMediator(68): pokeWakelock(5000)
11-16 22:17:31.084: I/ARMAssembler(68): generated scanline__00000177:03515104_00001001_00000000 [ 91 ipp] (114 ins) at [0x321328:0x3214f0] in 1461607 ns
11-16 22:17:31.105: I/ActivityManager(68): Displayed activity com.android.launcher/com.android.launcher2.Launcher: 23501 ms (total 23501 ms)
11-16 22:17:31.705: I/ActivityManager(68): Start proc com.android.quicksearchbox for broadcast com.android.quicksearchbox/.SearchWidgetProvider: pid=249 uid=10012 gids={3003}
11-16 22:17:32.464: I/ActivityThread(249): Publishing provider com.android.quicksearchbox.google: com.android.quicksearchbox.google.GoogleSuggestion Provider
11-16 22:17:32.645: I/ActivityManager(68): Start proc com.android.music for broadcast com.android.music/.MediaAppWidgetProvider: pid=256 uid=10022 gids={3003, 1015}
11-16 22:17:33.994: I//system/bin/fsck_msdos(29): Attempting to allocate 1022 KB for FAT
11-16 22:17:34.694: D/PackageParser(68): Scanning package: /data/app/vmdl15652.tmp
11-16 22:17:35.454: I//system/bin/fsck_msdos(29): ** Phase 2 - Check Cluster Chains
11-16 22:17:35.484: D/MediaScanner(202): prescan time: 2157ms
11-16 22:17:35.525: I//system/bin/fsck_msdos(29): ** Phase 3 - Checking Directories
11-16 22:17:35.525: I//system/bin/fsck_msdos(29): ** Phase 4 - Checking for Lost Files
11-16 22:17:35.544: I//system/bin/fsck_msdos(29): 3 files, 522222 free (261111 clusters)
11-16 22:17:35.565: I/logwrapper(29): /system/bin/fsck_msdos terminated by exit(0)
11-16 22:17:35.576: I/Vold(29): Filesystem check completed OK
11-16 22:17:35.594: I/Vold(29): Device /dev/block/vold/179:0, target /mnt/sdcard mounted @ /mnt/secure/staging
11-16 22:17:35.594: D/MediaScanner(202): scan time: 161ms
11-16 22:17:35.605: D/Vold(29): Volume sdcard state changing 3 (Checking) -> 4 (Mounted)
11-16 22:17:35.614: D/MediaScanner(202): postscan time: 2ms
11-16 22:17:35.614: D/MediaScanner(202): total time: 2320ms
11-16 22:17:35.635: I/PackageManager(68): Updating external media status from unmounted to mounted
11-16 22:17:35.635: I/StorageNotification(68): Media {/mnt/sdcard} state changed from {checking} -> {mounted}
11-16 22:17:36.036: I/PackageManager(68): Removing non-system package:com.alteum.intents
11-16 22:17:36.254: D/dalvikvm(162): GC_FOR_MALLOC freed 3920 objects / 237760 bytes in 139ms
11-16 22:17:36.704: D/PackageManager(68): Scanning package com.alteum.intents
11-16 22:17:36.725: I/PackageManager(68): Package com.alteum.intents codePath changed from /data/app/com.alteum.intents-1.apk to /data/app/com.alteum.intents-2.apk; Retaining data and using new
11-16 22:17:36.735: I/PackageManager(68): /data/app/com.alteum.intents-2.apk changed; unpacking
11-16 22:17:36.775: D/installd(35): DexInv: --- BEGIN '/data/app/com.alteum.intents-2.apk' ---
11-16 22:17:37.166: D/dalvikvm(262): DexOpt: load 64ms, verify 126ms, opt 16ms
11-16 22:17:37.185: D/installd(35): DexInv: --- END '/data/app/com.alteum.intents-2.apk' (success) ---
11-16 22:17:37.185: W/PackageManager(68): Code path for pkg : com.alteum.intents changing from /data/app/com.alteum.intents-1.apk to /data/app/com.alteum.intents-2.apk
11-16 22:17:37.225: W/PackageManager(68): Resource path for pkg : com.alteum.intents changing from /data/app/com.alteum.intents-1.apk to /data/app/com.alteum.intents-2.apk
11-16 22:17:37.275: D/dalvikvm(127): GC_EXTERNAL_ALLOC freed 3686 objects / 202944 bytes in 224ms
11-16 22:17:37.334: D/PackageManager(68): Activities: com.alteum.intents.MainActivity
11-16 22:17:37.765: I/installd(35): move /data/dalvik-cache/data@[email protected]@classes.dex -> /data/dalvik-cache/data@[email protected]@classes.dex
11-16 22:17:37.765: D/PackageManager(68): New package installed in /data/app/com.alteum.intents-2.apk
11-16 22:17:37.994: I/Launcher.Model(127): not binding apps: no Launcher activity
11-16 22:17:38.124: D/dalvikvm(127): GC_EXPLICIT freed 1692 objects / 84824 bytes in 120ms
11-16 22:17:38.486: D/VoldCmdListener(29): asec list
11-16 22:17:38.595: I/PackageManager(68): No secure containers on sdcard
11-16 22:17:38.605: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.mail in package com.android.contacts
11-16 22:17:38.645: W/PackageManager(68): Unknown permission android.permission.ADD_SYSTEM_SERVICE in package com.android.phone
11-16 22:17:38.645: W/PackageManager(68): Not granting permission android.permission.SEND_DOWNLOAD_COMPLETED_INTENTS to package com.android.browser (protectionLevel=2 flags=0x1be45)
11-16 22:17:38.735: W/PackageManager(68): Unknown permission com.google.android.gm.permission.WRITE_GMAIL in package com.android.settings
11-16 22:17:38.735: W/PackageManager(68): Unknown permission com.google.android.gm.permission.READ_GMAIL in package com.android.settings
11-16 22:17:38.735: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH in package com.android.settings
11-16 22:17:38.745: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH in package com.android.providers.contacts
11-16 22:17:38.754: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.cp in package com.android.providers.contacts
11-16 22:17:38.765: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.ACCESS_GO OGLE_PASSWORD in package com.android.development
11-16 22:17:38.775: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH in package com.android.development
11-16 22:17:38.794: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.ALL_SERVICES in package com.android.development
11-16 22:17:38.794: W/PackageManager(68): Unknown permission com.google.android.googleapps.permission.GOOGLE_AU TH.YouTubeUser in package com.android.development
11-16 22:17:39.055: I/ActivityManager(68): Force stopping package com.alteum.intents uid=10042
11-16 22:17:39.055: I/ActivityManager(68): Force stopping package com.alteum.intents uid=10042
11-16 22:17:39.155: D/MediaScannerService(202): done scanning volume internal
11-16 22:17:39.204: D/MediaScannerService(202): start scanning volume external
11-16 22:17:39.395: V/MediaProvider(202): /mnt/sdcard volume ID: 267132942
11-16 22:17:39.655: D/dalvikvm(127): GC_FOR_MALLOC freed 8502 objects / 415080 bytes in 96ms
11-16 22:17:40.664: D/dalvikvm(127): GC_EXPLICIT freed 1870 objects / 91064 bytes in 169ms
11-16 22:17:40.675: I/ActivityManager(68): Force stopping package com.alteum.intents uid=10042
11-16 22:17:40.964: I/ActivityManager(68): Start proc com.svox.pico for broadcast com.svox.pico/.VoiceDataInstallerReceiver: pid=264 uid=10028 gids={}
11-16 22:17:41.114: W/RecognitionManagerService(68): no available voice recognition services found
11-16 22:17:41.584: D/dalvikvm(68): GC_EXPLICIT freed 13597 objects / 802400 bytes in 200ms
11-16 22:17:41.725: I/ActivityThread(264): Publishing provider com.svox.pico.providers.SettingsProvider: com.svox.pico.providers.SettingsProvider
11-16 22:17:41.826: I/installd(35): unlink /data/dalvik-cache/data@[email protected]@classes.dex
11-16 22:17:41.864: D/AndroidRuntime(116): Shutting down VM
11-16 22:17:41.864: D/jdwp(116): adbd disconnected
11-16 22:17:41.885: I/AndroidRuntime(116): NOTE: attach of thread 'Binder Thread #3' failed
11-16 22:17:42.725: D/AndroidRuntime(274): >>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<
11-16 22:17:42.725: D/AndroidRuntime(274): CheckJNI is ON
11-16 22:17:42.984: D/AndroidRuntime(274): --- registering native functions ---
11-16 22:17:43.705: V/MediaProvider(202): Attached volume: external
11-16 22:17:44.034: I/ActivityManager(68): Force stopping package com.alteum.intents uid=10042
11-16 22:17:44.034: I/ActivityManager(68): Starting activity: Intent { act=android.intent.action.MAIN cat=[android.intent.category.LAUNCHER] flg=0x10000000 cmp=com.alteum.intents/.MainActivity }
11-16 22:17:44.145: I/ActivityManager(68): Start proc com.alteum.intents for activity com.alteum.intents/.MainActivity: pid=280 uid=10042 gids={}
11-16 22:17:44.154: D/AndroidRuntime(274): Shutting down VM
11-16 22:17:44.164: D/jdwp(274): adbd disconnected
11-16 22:17:44.234: I/AndroidRuntime(274): NOTE: attach of thread 'Binder Thread #3' failed
11-16 22:17:45.274: W/ActivityThread(280): Application com.alteum.intents is waiting for the debugger on port 8100...
11-16 22:17:45.364: I/System.out(280): Sending WAIT chunk
11-16 22:17:45.378: I/dalvikvm(280): Debugger is active
11-16 22:17:45.404: I/System.out(280): Debugger has connected
11-16 22:17:45.494: I/System.out(280): waiting for debugger to settle...
11-16 22:17:45.704: I/System.out(280): waiting for debugger to settle...
11-16 22:17:45.904: I/System.out(280): waiting for debugger to settle...
11-16 22:17:46.106: I/System.out(280): waiting for debugger to settle...
11-16 22:17:46.306: I/System.out(280): waiting for debugger to settle...
11-16 22:17:46.345: I/ARMAssembler(68): generated scanline__00000077:03515104_00000000_00000000 [ 33 ipp] (47 ins) at [0x3a5a58:0x3a5b14] in 997389 ns
11-16 22:17:46.505: I/System.out(280): waiting for debugger to settle...
11-16 22:17:46.714: I/System.out(280): waiting for debugger to settle...
11-16 22:17:46.914: I/System.out(280): waiting for debugger to settle...
11-16 22:17:47.114: I/System.out(280): waiting for debugger to settle...
11-16 22:17:47.314: I/System.out(280): waiting for debugger to settle...
11-16 22:17:47.516: I/System.out(280): waiting for debugger to settle...
11-16 22:17:47.725: I/System.out(280): debugger has settled (1480)
11-16 22:17:49.255: I/ActivityManager(68): Displayed activity com.alteum.intents/.MainActivity: 5130 ms (total 5130 ms)
11-16 22:17:49.394: I/ARMAssembler(68): generated scanline__00000077:03545404_00000004_00000000 [ 47 ipp] (67 ins) at [0x3a5b18:0x3a5c24] in 882333 ns
11-16 22:17:49.954: V/MediaScanner(202): pruneDeadThumbnailFiles... android.database.sqlite.SQLiteCursor@44ec2db8
11-16 22:17:49.954: V/MediaScanner(202): /pruneDeadThumbnailFiles... android.database.sqlite.SQLiteCursor@44ec2db8
11-16 22:17:49.965: D/MediaScanner(202): prescan time: 5347ms
11-16 22:17:49.965: D/MediaScanner(202): scan time: 2ms
11-16 22:17:49.974: D/MediaScanner(202): postscan time: 37ms
11-16 22:17:49.974: D/MediaScanner(202): total time: 5386ms
11-16 22:17:50.016: D/MediaScannerService(202): done scanning volume external
11-16 22:17:53.864: I/ActivityManager(68): Starting activity: Intent { act=android.intent.action.VIEW dat=geo:37.827500,-122.481670 }
11-16 22:22:28.047: D/SntpClient(68): request time failed: java.net.SocketException: Address family not supported by protocol