Service中onStartCommand方法intent报空的问题

本文转自：http://www.mobile-open.com/2015/86156.html

本文主要讲述了service的onStartCommand()方法中intent为null这个空指针异常产生的原因及解决方法，现在整理出来分享给Android程序员兄弟们，希望给他们的开发工作带来帮助。

今天在维护公司的一个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.
     * 
     * 

For backwards compatibility, the default implementation calls * {@link #onStart} and returns either {@link #START_STICKY} * or {@link #START_STICKY_COMPATIBILITY}. * *

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. ThehandleCommandmethod is implemented by * you as appropriate: * * {@sampledevelopment/samples/ApiDemos/src/com/example/android/apis/app/ForegroundService.java * start_compatibility} * *

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}.

* * @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四个。下面分别介绍一下，如下面表格所示：

START_STICKY	如果service进程被kill掉，保留service的状态为开始状态，但不保留递送的intent对象。随后系统会尝试重新创建service，由于服务状态为开始状态，所以创建服务后一定会调用onStartCommand(Intent,int,int)方法。如果在此期间没有任何启动命令被传递到service，那么参数Intent将为null。
START_NOT_STICKY	“非粘性的”。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统不会自动重启该服务。
START_REDELIVER_INTENT	重传Intent。使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务，并将Intent的值传入。
START_STICKY_COMPATIBILITY	START_STICKY的兼容版本，但不保证服务被kill后一定能重启。

源代码如下：

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

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. * *

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

Added in API level 5

Constant to return fromonStartCommand(Intent, int, int): compatibility version ofSTART_STICKYthat does not guarantee thatonStartCommand(Intent, int, int)will be called again after being killed.

Constant Value: 0 (0x00000000)

public static final int START_STICKY

Added in API level 5

Constant to return fromonStartCommand(Intent, int, int): if this service's process is killed while it is started (after returning fromonStartCommand(Intent, int, int)), 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 callonStartCommand(Intent, int, int)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.

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.

Constant Value: 1 (0x00000001)

public static final int START_NOT_STICKY

Added in API level 5

Constant to return fromonStartCommand(Intent, int, int): if this service's process is killed while it is started (after returning fromonStartCommand(Intent, int, int)), 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 toContext.startService(Intent). The service will not receive aonStartCommand(Intent, int, int)call with a null Intent because it will not be re-started if there are no pending Intents to deliver.

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 itsonStartCommand(Intent, int, int)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.

Constant Value: 2 (0x00000002)

public static final int START_REDELIVER_INTENT

Added in API level 5

Constant to return fromonStartCommand(Intent, int, int): if this service's process is killed while it is started (after returning fromonStartCommand(Intent, int, int)), then it will be scheduled for a restart and the last delivered Intent re-delivered to it again viaonStartCommand(Intent, int, int). This Intent will remain scheduled for redelivery until the service callsstopSelf(int)with the start ID provided toonStartCommand(Intent, int, int). The service will not receive aonStartCommand(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).

Constant Value: 3 (0x00000003)

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

Added in API level 5

Called by the system every time a client explicitly starts the service by callingstartService(Intent), providing the arguments it supplied and a unique integer token representing the start request. Do not call this method directly.

For backwards compatibility, the default implementation callsonStart(Intent, int)and returns eitherSTART_STICKYorSTART_STICKY_COMPATIBILITY.

If you need your application to run on platform versions prior to API level 5, you can use the following model to handle the olderonStart(Intent, int)callback in that case. ThehandleCommandmethod is implemented by you as appropriate:

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

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 useAsyncTask.

Parameters

intent	The Intent supplied tostartService(Intent), as given. This may be null if the service is being restarted after its process has gone away, and it had previously returned anything exceptSTART_STICKY_COMPATIBILITY.
flags	Additional data about this start request. Currently either 0,START_FLAG_REDELIVERY, orSTART_FLAG_RETRY.
startId	A unique integer representing this specific request to start. Use withstopSelfResult(int).

Returns

• 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 theSTART_CONTINUATION_MASKbits.
  

  See Also

  • stopSelfResult(int)

本文到此结束，需要的朋友可以参考下。