http://developer.android.com/reference/android/app/Service.html

    /**

     * Constant to return from {@link #onStartCommand}: compatibility

     * version of {@link #START_STICKY} that does not guarantee that

     * {@link #onStartCommand} will be called again after being killed.

     */

    public static final int START_STICKY_COMPATIBILITY = 0;

    /**

     * Constant to return from {@link #onStartCommand}: if this service's

     * process is killed while it is started (after returning from

     * {@link #onStartCommand}), then leave it in the started state but

     * don't retain this delivered intent.  Later the system will try to

     * re-create the service.  Because it is in the started state, it will

     * guarantee to call {@link #onStartCommand} after creating the new

     * service instance; if there are not any pending start commands to be

     * delivered to the service, it will be called with a null intent

     * object, so you must take care to check for this.

     *

     * <p>This mode makes sense for things that will be explicitly started

     * and stopped to run for arbitrary periods of time, such as a service

     * performing background music playback.

     */

    public static final int START_STICKY = 1;

    /**

     * Constant to return from {@link #onStartCommand}: if this service's

     * process is killed while it is started (after returning from

     * {@link #onStartCommand}), and there are no new start intents to

     * deliver to it, then take the service out of the started state and

     * don't recreate until a future explicit call to

     * {@link Context#startService Context.startService(Intent)}.  The

     * service will not receive a {@link #onStartCommand(Intent, int, int)}

     * call with a null Intent because it will not be re-started if there

     * are no pending Intents to deliver.

     *

     * <p>This mode makes sense for things that want to do some work as a

     * result of being started, but can be stopped when under memory pressure

     * and will explicit start themselves again later to do more work.  An

     * example of such a service would be one that polls for data from

     * a server: it could schedule an alarm to poll every N minutes by having

     * the alarm start its service.  When its {@link #onStartCommand} is

     * called from the alarm, it schedules a new alarm for N minutes later,

     * and spawns a thread to do its networking.  If its process is killed

     * while doing that check, the service will not be restarted until the

     * alarm goes off.

     */

    public static final int START_NOT_STICKY = 2;

    /**

     * Constant to return from {@link #onStartCommand}: if this service's

     * process is killed while it is started (after returning from

     * {@link #onStartCommand}), then it will be scheduled for a restart

     * and the last delivered Intent re-delivered to it again via

     * {@link #onStartCommand}.  This Intent will remain scheduled for

     * redelivery until the service calls {@link #stopSelf(int)} with the

     * start ID provided to {@link #onStartCommand}.  The

     * service will not receive a {@link #onStartCommand(Intent, int, int)}

     * call with a null Intent because it will will only be re-started if

     * it is not finished processing all Intents sent to it (and any such

     * pending events will be delivered at the point of restart).

     */

    public static final int START_REDELIVER_INTENT = 3;

参数
onStartCommand()的函数原型，代码如下：

    /**

     * Called by the system every time a client explicitly starts the service by calling

     * {@link android.content.Context#startService}, providing the arguments it supplied and a

     * unique integer token representing the start request.  Do not call this method directly.

     *

     * <p>For backwards compatibility, the default implementation calls

     * {@link #onStart} and returns either {@link #START_STICKY}

     * or {@link #START_STICKY_COMPATIBILITY}.

     *

     * <p>If you need your application to run on platform versions prior to API

     * level 5, you can use the following model to handle the older {@link #onStart}

     * callback in that case.  The <code>handleCommand</code> method is implemented by

     * you as appropriate:

     *

     * {@sample development/samples/ApiDemos/src/com/example/android/apis/app/ForegroundService.java

     *   start_compatibility}

     *

     * <p class="caution">Note that the system calls this on your

     * service's main thread.  A service's main thread is the same

     * thread where UI operations take place for Activities running in the

     * same process.  You should always avoid stalling the main

     * thread's event loop.  When doing long-running operations,

     * network calls, or heavy disk I/O, you should kick off a new

     * thread, or use {@link android.os.AsyncTask}.</p>

     *

     * @param intent The Intent supplied to {@link android.content.Context#startService},

     * as given.  This may be null if the service is being restarted after

     * its process has gone away, and it had previously returned anything

     * except {@link #START_STICKY_COMPATIBILITY}.

     * @param flags Additional data about this start request.  Currently either

     * 0, {@link #START_FLAG_REDELIVERY}, or {@link #START_FLAG_RETRY}.

     * @param startId A unique integer representing this specific request to

     * start.  Use with {@link #stopSelfResult(int)}.

     *

     * @return The return value indicates what semantics the system should

     * use for the service's current started state.  It may be one of the

     * constants associated with the {@link #START_CONTINUATION_MASK} bits.

     *

     * @see #stopSelfResult(int)

     */

    public int onStartCommand(Intent intent, int flags, int startId) {

        onStart(intent, startId);

        return mStartCompatibility ? START_STICKY_COMPATIBILITY : START_STICKY;

    }

官方解释如下：

// This is the old onStart method that will be called on the pre-2.0

// platform.  On 2.0 or later we override onStartCommand() so this

// method will not be called.

@Override

public void onStart(Intent intent, int startId) {

    handleCommand(intent);

}

@Override

public int onStartCommand(Intent intent, int flags, int startId) {

    handleCommand(intent);

    // We want this service to continue running until it is explicitly

    // stopped, so return sticky.

    return START_STICKY;

}