我的Android进阶之旅------>android中service的onStartCommand()方法中intent为null的问题

       今天在维护公司的一个APP的时候，突然爆了空指针异常，

Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'boolean android.content.Intent.getBooleanExtra(java.lang.String, boolean)' on a null object reference

       下面是报错的log。

D/AndroidRuntime( 4721): Shutting down VM
E/AndroidRuntime( 4721): FATAL EXCEPTION: main
E/AndroidRuntime( 4721): Process: com.tintele.sos, PID: 4721
E/AndroidRuntime( 4721): java.lang.RuntimeException: Unable to start service com.tintele.sos.SosService@36087165 with null: java.lang.NullPointerException: Attempt to invoke virtual method 'boolean android.content.Intent.getBooleanExtra(java.lang.String, boolean)' on a null object reference
E/AndroidRuntime( 4721):        at android.app.ActivityThread.handleServiceArgs(ActivityThread.java:3152)
E/AndroidRuntime( 4721):        at android.app.ActivityThread.access$2100(ActivityThread.java:178)
E/AndroidRuntime( 4721):        at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1568)
E/AndroidRuntime( 4721):        at android.os.Handler.dispatchMessage(Handler.java:111)
E/AndroidRuntime( 4721):        at android.os.Looper.loop(Looper.java:194)
E/AndroidRuntime( 4721):        at android.app.ActivityThread.main(ActivityThread.java:5637)
E/AndroidRuntime( 4721):        at java.lang.reflect.Method.invoke(Native Method)
E/AndroidRuntime( 4721):        at java.lang.reflect.Method.invoke(Method.java:372)
E/AndroidRuntime( 4721):        at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:959)
E/AndroidRuntime( 4721):        at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:754)
E/AndroidRuntime( 4721): Caused by: java.lang.NullPointerException: Attempt to invoke virtual method 'boolean android.content.Intent.getBooleanExtra(java.lang.String, boolean)' on a null object reference
E/AndroidRuntime( 4721):        at com.tintele.sos.SosService.onStartCommand(SosService.java:309)
E/AndroidRuntime( 4721):        at android.app.ActivityThread.handleServiceArgs(ActivityThread.java:3135)
E/AndroidRuntime( 4721):        ... 9 more

     打印log后发现原来是在onStartCommand(Intent intent, int flags, int startId)方法中intent为null。这个错误是对onStartCommand()方法的flags参数没有深入理解造成的，报错的代码：

boolean groundAlarmFlag=intent.getBooleanExtra("flag", false);

      而这个flag参数是通过别处传过来的，代码如下：

Intent intent = new Intent(getBaseContext(), SosService.class);
intent.putExtra("flag", true);
startService(intent);

【报错原因】

       因此报错 intent的参数是null的原因是这个intent参数是通过startService(Intent)方法所传递过来的，但是如果Service在你的进程退出后有可能被系统自动重启，这个时候intent就会是null.
【解决方法】
        【方法一】在使用intent前需要判断一下是否为空。即：

boolean groundAlarmFlag = false;  
if (intent!=null) {
    groundAlarmFlag=intent.getBooleanExtra("flag", false);
}

        【方法二】

      将onStartCommand()方法的返回值从

return super.onStartCommand(intent, flags, startId);

      改成

return super.onStartCommand(intent, Service.START_REDELIVER_INTENT, startId);

因为onStartCommand方法的默认值START_STICKY_COMPATIBILITY或者START_STICKY不能保证intent不为null.

/**
     * 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;
    }

==================================================================

下面具体讲解一下这几个flags的参数，首先参数有START_STICKY_COMPATIBILITY、

START_STICKY、START_NOT_STICKY、START_REDELIVER_INTENT四个。下面分别介绍一下，如下面表格所示：

   源代码如下：

/**
     * 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;

 官方文档上的解释如下：

public static final int START_STICKY_COMPATIBILITY

public static final int START_STICKY

public static final int START_REDELIVER_INTENT

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

// 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;
}

  作者：欧阳鹏  欢迎转载，与人分享是进步的源泉！

  转载请保留原文地址：http://blog.csdn.net/ouyang_peng

====================================================================================