diff --git a/core/java/com/android/server/SystemService.java b/core/java/com/android/server/SystemService.java
index d69293a..0c89f94 100644
--- a/core/java/com/android/server/SystemService.java
+++ b/core/java/com/android/server/SystemService.java
@@ -23,24 +23,24 @@
 /**
  * The base class for services running in the system process. Override and implement
  * the lifecycle event callback methods as needed.
- *
+ * <p>
  * The lifecycle of a SystemService:
- *
- * {@link #onCreate(android.content.Context)} is called to initialize the
- * service.
- *
- * {@link #onStart()} is called to get the service running. It is common
- * for services to publish their Binder interface at this point. All required
- * dependencies are also assumed to be ready to use.
- *
- * Then {@link #onBootPhase(int)} is called as many times as there are boot phases
+ * </p><ul>
+ * <li>The constructor is called and provided with the system {@link Context}
+ * to initialize the system service.
+ * <li>{@link #onStart()} is called to get the service running.  The service should
+ * publish its binder interface at this point using
+ * {@link #publishBinderService(String, IBinder)}.  It may also publish additional
+ * local interfaces that other services within the system server may use to access
+ * privileged internal functions.
+ * <li>Then {@link #onBootPhase(int)} is called as many times as there are boot phases
  * until {@link #PHASE_BOOT_COMPLETE} is sent, which is the last boot phase. Each phase
  * is an opportunity to do special work, like acquiring optional service dependencies,
  * waiting to see if SafeMode is enabled, or registering with a service that gets
  * started after this one.
- *
- * NOTE: All lifecycle methods are called from the same thread that created the
- * SystemService.
+ * </ul><p>
+ * NOTE: All lifecycle methods are called from the system server's main looper thread.
+ * </p>
  *
  * {@hide}
  */
@@ -54,17 +54,34 @@
     public static final int PHASE_THIRD_PARTY_APPS_CAN_START = 600;
     public static final int PHASE_BOOT_COMPLETE = 1000;
 
-    private SystemServiceManager mManager;
-    private Context mContext;
+    private final Context mContext;
 
-    final void init(Context context, SystemServiceManager manager) {
+    /**
+     * Initializes the system service.
+     * <p>
+     * Subclasses must define a single argument constructor that accepts the context
+     * and passes it to super.
+     * </p>
+     *
+     * @param context The system server context.
+     */
+    public SystemService(Context context) {
         mContext = context;
-        mManager = manager;
-        onCreate(context);
     }
 
+    /**
+     * Gets the system context.
+     */
+    public final Context getContext() {
+        return mContext;
+    }
+
+    /**
+     * Returns true if the system is running in safe mode.
+     * TODO: we should define in which phase this becomes valid
+     */
     public final boolean isSafeMode() {
-        return mManager.isSafeMode();
+        return getManager().isSafeMode();
     }
 
     /**
@@ -126,8 +143,8 @@
         return LocalServices.getService(type);
     }
 
-    public final Context getContext() {
-        return mContext;
+    private SystemServiceManager getManager() {
+        return LocalServices.getService(SystemServiceManager.class);
     }
 
 //    /**
diff --git a/core/java/com/android/server/SystemServiceManager.java b/core/java/com/android/server/SystemServiceManager.java
index 06ad7f4..6c853be 100644
--- a/core/java/com/android/server/SystemServiceManager.java
+++ b/core/java/com/android/server/SystemServiceManager.java
@@ -17,14 +17,15 @@
 package com.android.server;
 
 import android.content.Context;
-import android.util.Log;
 import android.util.Slog;
 
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 
 /**
  * Manages creating, starting, and other lifecycle events of
- * {@link com.android.server.SystemService}s.
+ * {@link com.android.server.SystemService system services}.
  *
  * {@hide}
  */
@@ -68,24 +69,43 @@
      */
     @SuppressWarnings("unchecked")
     public <T extends SystemService> T startService(Class<T> serviceClass) {
-        final T serviceInstance = (T)createInstance(serviceClass);
+        final String name = serviceClass.getName();
+        Slog.i(TAG, "Starting " + name);
+
+        // Create the service.
+        if (!SystemService.class.isAssignableFrom(serviceClass)) {
+            throw new RuntimeException("Failed to create " + name
+                    + ": service must extend " + SystemService.class.getName());
+        }
+        final T service;
         try {
-            Slog.i(TAG, "Creating " + serviceClass.getSimpleName());
-            serviceInstance.init(mContext, this);
-        } catch (Throwable e) {
-            throw new RuntimeException("Failed to create service " + serviceClass.getName(), e);
+            Constructor<T> constructor = serviceClass.getConstructor(Context.class);
+            service = constructor.newInstance(mContext);
+        } catch (InstantiationException ex) {
+            throw new RuntimeException("Failed to create service " + name
+                    + ": service could not be instantiated", ex);
+        } catch (IllegalAccessException ex) {
+            throw new RuntimeException("Failed to create service " + name
+                    + ": service must have a public constructor with a Context argument", ex);
+        } catch (NoSuchMethodException ex) {
+            throw new RuntimeException("Failed to create service " + name
+                    + ": service must have a public constructor with a Context argument", ex);
+        } catch (InvocationTargetException ex) {
+            throw new RuntimeException("Failed to create service " + name
+                    + ": service constructor threw an exception", ex);
         }
 
-        mServices.add(serviceInstance);
+        // Register it.
+        mServices.add(service);
 
+        // Start it.
         try {
-            Slog.i(TAG, "Starting " + serviceClass.getSimpleName());
-            serviceInstance.onStart();
-        } catch (Throwable e) {
-            throw new RuntimeException("Failed to start service " + serviceClass.getName(), e);
+            service.onStart();
+        } catch (RuntimeException ex) {
+            throw new RuntimeException("Failed to start service " + name
+                    + ": onStart threw an exception", ex);
         }
-
-        return serviceInstance;
+        return service;
     }
 
     /**
@@ -107,9 +127,11 @@
             final SystemService service = mServices.get(i);
             try {
                 service.onBootPhase(mCurrentPhase);
-            } catch (Throwable e) {
-                reportWtf("Service " + service.getClass().getName() +
-                        " threw an Exception processing boot phase " + mCurrentPhase, e);
+            } catch (Exception ex) {
+                throw new RuntimeException("Failed to boot service "
+                        + service.getClass().getName()
+                        + ": onBootPhase threw an exception during phase "
+                        + mCurrentPhase, ex);
             }
         }
     }
@@ -144,34 +166,4 @@
 
         Slog.e(TAG, builder.toString());
     }
-
-    private SystemService createInstance(Class<?> clazz) {
-        // Make sure it's a type we expect
-        if (!SystemService.class.isAssignableFrom(clazz)) {
-            reportWtf("Class " + clazz.getName() + " does not extend " +
-                    SystemService.class.getName());
-        }
-
-        try {
-            return (SystemService) clazz.newInstance();
-        } catch (InstantiationException e) {
-            reportWtf("Class " + clazz.getName() + " is abstract", e);
-        } catch (IllegalAccessException e) {
-            reportWtf("Class " + clazz.getName() +
-                    " must have a public no-arg constructor", e);
-        }
-        return null;
-    }
-
-    private static void reportWtf(String message) {
-        reportWtf(message, null);
-    }
-
-    private static void reportWtf(String message, Throwable e) {
-        Slog.i(TAG, "******************************");
-        Log.wtf(TAG, message, e);
-
-        // Make sure we die
-        throw new RuntimeException(message, e);
-    }
 }