Android总结篇系列:Android Service

Service通常总是称之为“后台服务”,其中“后台”一词是相对于前台而言的,具体是指其本身的运行并不依赖于用户可视的UI界面,因此,从实际业务需求上来理解,Service的适用场景应该具备以下条件:

1.并不依赖于用户可视的UI界面(当然,这一条其实也不是绝对的,如前台Service就是与Notification界面结合使用的);

2.具有较长时间的运行特性。

1.Service AndroidManifest.xml 声明

一般而言,从Service的启动方式上,可以将Service分为Started Service和Bound Service。无论哪种具体的Service启动类型,都是通过继承Service基类自定义而来。在使用Service时,要想系统能够找到此自定义Service,无论哪种类型,都需要在AndroidManifest.xml中声明,语法格式如下:

 1 <service android:enabled=["true" | "false"]
 2     android:exported=["true" | "false"]
 3     android:icon="drawable resource"
 4     android:isolatedProcess=["true" | "false"]
 5     android:label="string resource"
 6     android:name="string"
 7     android:permission="string"
 8     android:process="string" >
 9     . . .
10 </service>

其中,android:exported属性上一篇博文中对此已进行详尽描述,android:name对应Service类名,android:permission是权限声明,android:process设置具体的进程名称。需要注意的是Service能否单独使用一个进程与其启动方式有关,本后下面会给出具体说明。其他的属性此处与其他组件基本相同,不再过多描述。

注:如果自定义Service没有在AndroidManifest.xml中声明,当具体使用时,不会像Activity那样直接崩溃报错,对于显式Intent启动的Service,此时也会给出waring信息“IllegalArgumentException: Service not registered”,有时候不容易发现忘了声明而一时定位不到问题。

 

2.Started Service

 Started Service相对比较简单,通过context.startService(Intent serviceIntent)启动Service,context.stopService(Intent serviceIntent)停止此Service。当然,在Service内部,也可以通过stopSelf(...)方式停止其本身。

1)Started Service自定义

下面代码片段显示的是一个最基本的Started Service的自定义方式:

 1 public class MyService extends Service {
 2 
 3     public static final String TAG = "MyService";
 4 
 5     @Override
 6     public IBinder onBind(Intent intent) {
 7         return null;
 8     }
 9 
10     @Override
11     public void onCreate() {
12         super.onCreate();
13         Log.w(TAG, "in onCreate");
14     }
15 
16     @Override
17     public int onStartCommand(Intent intent, int flags, int startId) {
18         Log.w(TAG, "in onStartCommand");
19         Log.w(TAG, "MyService:" + this);
20         String name = intent.getStringExtra("name");
21         Log.w(TAG, "name:" + name);
22         return START_STICKY;
23     }
24 
25     @Override
26     public void onDestroy() {
27         super.onDestroy();
28         Log.w(TAG, "in onDestroy");
29     }
30 }

其中,onBind(...)函数是Service基类中的唯一抽象方法,子类都必须重写实现,此函数的返回值是针对Bound Service类型的Service才有用的,在Started Service类型中,此函数直接返回 null 即可。onCreate(...)、onStartCommand(...)和onDestroy()都是Started Service相应生命周期阶段的回调函数。

2) Started Service使用

 1 public class MainActivity extends Activity {
 2 
 3     public static final String TAG = "MainActivity";
 4 
 5     private Button startServiceBtn;
 6     private Button stopServideBtn;
 7     private Button goBtn;
 8 
 9     private Intent serviceIntent;
10 
11     @Override
12     protected void onCreate(Bundle savedInstanceState) {
13         super.onCreate(savedInstanceState);
14         setContentView(R.layout.activity_main);
15 
16         startServiceBtn = (Button) findViewById(R.id.start_service);
17         stopServideBtn = (Button) findViewById(R.id.stop_service);
18         goBtn = (Button) findViewById(R.id.go);
19 
20         startServiceBtn.setOnClickListener(new View.OnClickListener() {
21             @Override
22             public void onClick(View v) {
23                 serviceIntent = new Intent(MainActivity.this, MyService.class);
24                 startService(serviceIntent);
25             }
26         });
27 
28         stopServideBtn.setOnClickListener(new View.OnClickListener() {
29             @Override
30             public void onClick(View v) {
31                 stopService(serviceIntent);
32             }
33         });
34 
35         goBtn.setOnClickListener(new View.OnClickListener() {
36             @Override
37             public void onClick(View v) {
38                 Intent intent = new Intent(MainActivity.this, BActivity.class);
39                 startActivity(intent);
40             }
41         });
42 
43     }
44 
45     @Override
46     protected void onDestroy() {
47         super.onDestroy();
48         Log.w(TAG, "in onDestroy");
49     }
50 }

如上代码片段,

当Client调用startService(Intent serviceIntent)后,如果MyService是第一次启动,首先会执行 onCreate()回调,然后再执行onStartCommand(Intent intent, int flags, int startId),当Client再次调用startService(Intent serviceIntent),将只执行onStartCommand(Intent intent, int flags, int startId),因为此时Service已经创建了,无需执行onCreate()回调。无论多少次的startService,只需要一次stopService()即可将此Service终止,执行onDestroy()函数(其实很好理解,因为onDestroy()与onCreate()回调是相对的)。

下面重点关注下onStartCommand(Intent intent, int flags, int startId)方法。

其中参数flags默认情况下是0,对应的常量名为START_STICKY_COMPATIBILITY。startId是一个唯一的整型,用于表示此次Client执行startService(...)的请求请求标识,在多次startService(...)的情况下,呈现0,1,2....递增。另外,此函数具有一个int型的返回值,具体的可选值及含义如下:

START_NOT_STICKY:当Service因为内存不足而被系统kill后,接下来未来的某个时间内,即使系统内存足够可用,系统也不会尝试重新创建此Service。除非程序中Client明确再次调用startService(...)启动此Service。

START_STICKY:当Service因为内存不足而被系统kill后,接下来未来的某个时间内,当系统内存足够可用的情况下,系统将会尝试重新创建此Service,一旦创建成功后将回调onStartCommand(...)方法,但其中的Intent将是null,pendingintent除外。

START_REDELIVER_INTENT:与START_STICKY唯一不同的是,回调onStartCommand(...)方法时,其中的Intent将是非空,将是最后一次调用startService(...)中的intent。

START_STICKY_COMPATIBILITY:compatibility version of {@link #START_STICKY} that does not guarantee that {@link #onStartCommand} will be called again after being killed。此值一般不会使用,所以注意前面三种情形就好。

以上的描述中,”当Service因为内存不足而被系统kill后“一定要非常注意,因为此函数的返回值设定只是针对此种情况才有意义的,换言之,当认为的kill掉Service进程,此函数返回值无论怎么设定,接下来未来的某个时间内,即使系统内存足够可用,Service也不会重启。

小米手机针对此处做了变更:

另外,需要注意的是,小米手机针对此处做了一定的修改。在“自启动管理”中有一个自启动应用列表,默认情况下,只有少应用(如微信、QQ、YY、360等)默认是可以自启动的,其他应用默认都是禁止的。用户可以手动添加自启动应用,添加后的应用中如果Started Service onStartCommand(...)回调返回值是START_STICKY或START_REDELIVER_INTENT,当用户在小米手机上长按Home键结束App后,接下来未来的某个时间内,当系统内存足够可用时,Service依然可以按照上述规定重启。当然,如果用户在 设置 >> 应用 >> 强制kill掉App进程,此时Service是不会重启的。

注:以上实验结论基于小米2S亲测。

 

3) Started Service生命周期及进程相关

1.onCreate(Client首次startService(..)) >> onStartCommand >> onStartCommand - optional ... >> onDestroy(Client调用stopService(..))

注:onStartCommand(..)可以多次被调用,onDestroy()与onCreate()想匹配,当用户强制kill掉进程时,onDestroy()是不会执行的。

2.对于同一类型的Service,Service实例一次永远只存在一个,而不管Client是否是相同的组件,也不管Client是否处于相同的进程中。

3.Service通过startService(..)启动Service后,此时Service的生命周期与Client本身的什么周期是没有任何关系的,只有Client调用stopService(..)或Service本身调用stopSelf(..)才能停止此Service。当然,当用户强制kill掉Service进程或系统因内存不足也可能kill掉此Service。

4.Client A 通过startService(..)启动Service后,可以在其他Client(如Client B、Client C)通过调用stopService(..)结束此Service。

5.Client调用stopService(..)时,如果当前Service没有启动,也不会出现任何报错或问题,也就是说,stopService(..)无需做当前Service是否有效的判断。

6.startService(Intent serviceIntent),其中的intent既可以是显式Intent,也可以是隐式Intent,当Client与Service同处于一个App时,一般推荐使用显示Intent。当处于不同App时,只能使用隐式Intent。

当Service需要运行在单独的进程中,AndroidManifest.xml声明时需要通过android:process指明此进程名称,当此Service需要对其他App开放时,android:exported属性值需要设置为true(当然,在有intent-filter时默认值就是true)。

1 <service
2     android:name=".MyService"
3     android:exported="true"
4     android:process=":MyCorn" >
5     <intent-filter>
6         <action android:name="com.example.androidtest.myservice" />
7     </intent-filter>
8 </service>

 

4)Started Service Client与Service通信相关

当Client调用startService(Intent serviceIntent)启动Service时,Client可以将参数通过Intent直接传递给Service。Service执行过程中,如果需要将参数传递给Client,一般可以通过借助于发送广播的方式(此时,Client需要注册此广播)。

 

3.Bound Service

相对于Started Service,Bound Service具有更多的知识点。Bound Service的主要特性在于Service的生命周期是依附于Client的生命周期的,当Client不存在时,Bound Service将执行onDestroy,同时通过Service中的Binder对象可以较为方便进行Client-Service通信。Bound Service一般使用过程如下:

1.自定义Service继承基类Service,并重写onBind(Intent intent)方法,此方法中需要返回具体的Binder对象;

2.Client通过实现ServiceConnection接口来自定义ServiceConnection,并通过bindService (Intent service, ServiceConnection sc, int flags)方法将Service绑定到此Client上;

3.自定义的ServiceConnection中实现onServiceConnected(ComponentName name, IBinder binder)方法,获取Service端Binder实例;

4.通过获取的Binder实例进行Service端其他公共方法的调用,以完成Client-Service通信;

5.当Client在恰当的生命周期(如onDestroy等)时,此时需要解绑之前已经绑定的Service,通过调用函数unbindService(ServiceConnection sc)。

 在Bound Service具体使用过程中,根据onBind(Intent intent)方法放回的Binder对象的定义方式不同,又可以将其分为以下三种方式,且每种方式具有不同的特点和适用场景:

1).Extending the Binder class

 这是Bound Service中最常见的一种使用方式,也是Bound Service中最简单的一种。

局限:Clinet与Service必须同属于同一个进程,不能实现进程间通信(IPC)。否则则会出现类似于“android.os.BinderProxy cannot be cast to xxx”错误。

下面通过代码片段看下具体的使用:

 1 public class MyBindService extends Service {
 2 
 3     public static final String TAG = "MyBindService";
 4 
 5     private MyBinder mBinder = new MyBinder();
 6 
 7     public class MyBinder extends Binder {
 8         MyBindService getService() {
 9             return MyBindService.this;
10         }
11     }
12 
13     @Override
14     public void onCreate() {
15         super.onCreate();
16         Log.w(TAG, "in onCreate");
17     }
18 
19     @Override
20     public IBinder onBind(Intent intent) {
21         Log.w(TAG, "in onBind");
22         return mBinder;
23     }
24 
25     @Override
26     public boolean onUnbind(Intent intent) {
27         Log.w(TAG, "in onUnbind");
28         return super.onUnbind(intent);
29     }
30 
31     @Override
32     public void onDestroy() {
33         super.onDestroy();
34         Log.w(TAG, "in onDestroy");
35     }
36 }
 1 public class BActivity extends Activity {
 2 
 3     public static final String TAG = "BActivity";
 4 
 5     private Button bindServiceBtn;
 6     private Button unbindServiceBtn;
 7 
 8     private Button startIntentService;
 9 
10     private Intent serviceIntent;
11 
12     private ServiceConnection sc = new MyServiceConnection();
13     private MyBinder mBinder;
14     private MyBindService mBindService;
15     private boolean mBound;
16 
17     private class MyServiceConnection implements ServiceConnection {
18 
19         @Override
20         public void onServiceConnected(ComponentName name, IBinder binder) {
21             Log.w(TAG, "in MyServiceConnection onServiceConnected");
22             mBinder = (MyBinder) binder;
23             mBindService = mBinder.getService();
24 
25             mBound = true;
26         }
27 
28         @Override
29         public void onServiceDisconnected(ComponentName name) {
30             // This is called when the connection with the service has been
31             // unexpectedly disconnected -- that is, its process crashed.
32             Log.w(TAG, "in MyServiceConnection onServiceDisconnected");
33             mBound = false;
34         }
35 
36     }
37 
38     @Override
39     protected void onCreate(Bundle savedInstanceState) {
40         super.onCreate(savedInstanceState);
41         setContentView(R.layout.b);
42 
43         bindServiceBtn = (Button) findViewById(R.id.bind_service);
44         unbindServiceBtn = (Button) findViewById(R.id.unbind_service);
45         startIntentService = (Button) findViewById(R.id.start_intentservice);
46 
47         bindServiceBtn.setOnClickListener(new View.OnClickListener() {
48             @Override
49             public void onClick(View v) {
50                 Intent intent = new Intent(BActivity.this, MyBindService.class);
51                 bindService(intent, sc, Context.BIND_AUTO_CREATE);
52             }
53         });
54 
55         unbindServiceBtn.setOnClickListener(new View.OnClickListener() {
56             @Override
57             public void onClick(View v) {
58                 excuteUnbindService();
59             }
60         });
61 
62         startIntentService.setOnClickListener(new View.OnClickListener() {
63             @Override
64             public void onClick(View v) {
65                 Intent intent = new Intent(BActivity.this, MyIntentService.class);
66                 startService(intent);
67             }
68         });
69 
70     }
71 
72     private void excuteUnbindService() {
73         if (mBound) {
74             unbindService(sc);
75             mBound = false;
76         }
77     }
78 
79     @Override
80     protected void onDestroy() {
81         super.onDestroy();
82         Log.w(TAG, "in onDestroy");
83         excuteUnbindService();
84     }
85 }

首次点击bindServiceBtn进行bindService(..)时,依次回调顺序如下:

1 MyBindService(13457): in onCreate
2 MyBindService(13457): in onBind
3 BActivity(13457): in MyServiceConnection onServiceConnected

再次点击bindServiceBtn按钮时,发现没有任何输出,说明MyBindService没有进行任何回调。

点击unbindServiceBtn进行unbindService(..)时,回调顺序为:

1 MyBindService(13457): in onUnbind
2 MyBindService(13457): in onDestroy

 注:在四大基本组件中,需要注意的的是BroadcastReceiver不能作为Bound Service的Client,因为BroadcastReceiver的生命周期很短,当执行完onReceive(..)回调时,BroadcastReceiver生命周期完结。而Bound Service又与Client本身的生命周期相关,因此,Android中不允许BroadcastReceiver去bindService(..),当有此类需求时,可以考虑通过startService(..)替代。

 

2)Using a Messenger

Messenger,在此可以理解成”信使“,通过Messenger方式返回Binder对象可以不用考虑Clinet - Service是否属于同一个进程的问题,并且,可以实现Client - Service之间的双向通信。极大方便了此类业务需求的实现。

局限:不支持严格意义上的多线程并发处理,实际上是以队列去处理

下面直接看下具体的使用:

 1 public class MyMessengerService extends Service {
 2 
 3     public static final String TAG = "MyMessengerService";
 4 
 5     public static final int MSG_FROM_CLIENT_TO_SERVER = 1;
 6     public static final int MSG_FROM_SERVER_TO_CLIENT = 2;
 7 
 8     private Messenger mClientMessenger;
 9     private Messenger mServerMessenger = new Messenger(new ServerHandler());
10 
11     @Override
12     public IBinder onBind(Intent intent) {
13         Log.w(TAG, "in onBind");
14         return mServerMessenger.getBinder();
15     }
16 
17     class ServerHandler extends Handler {
18         @Override
19         public void handleMessage(Message msg) {
20             Log.w(TAG, "thread name:" + Thread.currentThread().getName());
21             switch (msg.what) {
22             case MSG_FROM_CLIENT_TO_SERVER:
23                 Log.w(TAG, "receive msg from client");
24                 mClientMessenger = msg.replyTo;
25 
26                 // service发送消息给client
27                 Message toClientMsg = Message.obtain(null, MSG_FROM_SERVER_TO_CLIENT);
28                 try {
29                     Log.w(TAG, "server begin send msg to client");
30                     mClientMessenger.send(toClientMsg);
31                 } catch (RemoteException e) {
32                     e.printStackTrace();
33                 }
34                 break;
35             default:
36                 super.handleMessage(msg);
37             }
38         }
39     }
40 
41     @Override
42     public boolean onUnbind(Intent intent) {
43         Log.w(TAG, "in onUnbind");
44         return super.onUnbind(intent);
45     }
46 
47     @Override
48     public void onDestroy() {
49         Log.w(TAG, "in onDestroy");
50         super.onDestroy();
51     }
52 }
  1 public class CActivity extends Activity {
  2 
  3     public static final String TAG = "CActivity";
  4 
  5     private Button bindServiceBtn;
  6     private Button unbindServiceBtn;
  7     private Button sendMsgToServerBtn;
  8 
  9     private ServiceConnection sc = new MyServiceConnection();
 10     private boolean mBound;
 11 
 12     private Messenger mServerMessenger;
 13 
 14     private Handler mClientHandler = new MyClientHandler();
 15     private Messenger mClientMessenger = new Messenger(mClientHandler);
 16 
 17     private class MyClientHandler extends Handler {
 18         @Override
 19         public void handleMessage(Message msg) {
 20             if (msg.what == MyMessengerService.MSG_FROM_SERVER_TO_CLIENT) {
 21                 Log.w(TAG, "reveive msg from server");
 22             }
 23         }
 24     }
 25 
 26     private class MyServiceConnection implements ServiceConnection {
 27 
 28         @Override
 29         public void onServiceConnected(ComponentName name, IBinder binder) {
 30             Log.w(TAG, "in MyServiceConnection onServiceConnected");
 31             mServerMessenger = new Messenger(binder);
 32 
 33             mBound = true;
 34         }
 35 
 36         @Override
 37         public void onServiceDisconnected(ComponentName name) {
 38             // This is called when the connection with the service has been
 39             // unexpectedly disconnected -- that is, its process crashed.
 40             Log.w(TAG, "in MyServiceConnection onServiceDisconnected");
 41 
 42             mBound = false;
 43         }
 44     }
 45 
 46     @Override
 47     protected void onCreate(Bundle savedInstanceState) {
 48         super.onCreate(savedInstanceState);
 49         setContentView(R.layout.c);
 50 
 51         bindServiceBtn = (Button) findViewById(R.id.bind_service);
 52         unbindServiceBtn = (Button) findViewById(R.id.unbind_service);
 53         sendMsgToServerBtn = (Button) findViewById(R.id.send_msg_to_server);
 54 
 55         bindServiceBtn.setOnClickListener(new View.OnClickListener() {
 56             @Override
 57             public void onClick(View v) {
 58                 Intent intent = new Intent(CActivity.this, MyMessengerService.class);
 59                 bindService(intent, sc, Context.BIND_AUTO_CREATE);
 60             }
 61         });
 62 
 63         unbindServiceBtn.setOnClickListener(new View.OnClickListener() {
 64             @Override
 65             public void onClick(View v) {
 66                 excuteUnbindService();
 67             }
 68         });
 69 
 70         sendMsgToServerBtn.setOnClickListener(new View.OnClickListener() {
 71             @Override
 72             public void onClick(View v) {
 73                 sayHello();
 74             }
 75         });
 76 
 77         new Handler().postDelayed(new Runnable() {
 78             @Override
 79             public void run() {
 80                 Intent intent = new Intent(CActivity.this, MyAlarmBroadcastReceiver.class);
 81                 sendBroadcast(intent);
 82             }
 83         }, 3 * 1000);
 84 
 85     }
 86 
 87     public void sayHello() {
 88         if (!mBound)
 89             return;
 90         // Create and send a message to the service, using a supported 'what' value
 91         Message msg = Message.obtain(null, MyMessengerService.MSG_FROM_CLIENT_TO_SERVER, 0, 0);
 92         // 通过replyTo把client端的Messenger(信使)传递给service
 93         msg.replyTo = mClientMessenger;
 94         try {
 95             mServerMessenger.send(msg);
 96         } catch (RemoteException e) {
 97             e.printStackTrace();
 98         }
 99     }
100 
101     private void excuteUnbindService() {
102         if (mBound) {
103             unbindService(sc);
104             mBound = false;
105         }
106     }
107 
108     @Override
109     protected void onDestroy() {
110         super.onDestroy();
111         Log.w(TAG, "in onDestroy");
112         excuteUnbindService();
113     }
114 }

其中,需要注意的几点是:

1.MyMessengerService自定中,通过new Messenger(new ServerHandler())创建Messenger对象,在onBind(..)回调中,通过调用Messenger对象的getBinder()方法,将Binder返回;

2.Client在ServiceConnection的onServiceConnected(..)的回调中,通过new Messenger(binder)获取到Service传递过来的mServerMessenger;

3.接下来,就可以通过mServerMessenger.send(msg)方法向Service发送message,Service中的Messenger构造器中的Handler即可接收到此信息,在handleMessage(..)回调中处理;

4.至此只是完成了从Client发送消息到Service,同样的道理,想实现Service发送消息到Client,可以在客户端定义一个Handler,并得到相应的Messenger,在Clinet发送消息给Service时,通过msg.replyTo = mClientMessenger方式将Client信使传递给Service;

5.Service接收到Client信使后,获取此信使,并通过mClientMessenger.send(toClientMsg)方式将Service消息发送给Client。

至此,完成了Client - Service之间的双向通信流程。

 

3).AIDL(Android Interface Definition Language)

一般情况下,Messenger这种方式都是可以满足需求的,当然,通过自定义AIDL方式相对更加灵活。

这种方式需要自己在项目中自定义xxx.aidl文件,然后系统会自动在gen目录下生成相应的接口类文件,接下来整个的流程与Messenger方式差别不大,网上也有不少实例,在此不再具体给出。

 

注:无论哪种方式的Bound Service,在进行unbind(..)操作时,都需要注意当前Service是否处于已经绑定状态,否则可能会因为当前Service已经解绑后继续执行unbind(..)会导致崩溃。这点与Started Service区别很大(如前文所述:stopService(..)无需做当前Service是否有效的判断)。

 

4.Local Service  VS Remote Service

Local Service:不少人又称之为”本地服务“,是指Client - Service同处于一个进程;

Remote Service:又称之为”远程服务“,一般是指Service处于单独的一个进程中。

其他使用上上文中基本上都有所述。

 

5.Service特性

1.Service本身都是运行在其所在进程的主线程(如果Service与Clinet同属于一个进程,则是运行于UI线程),但Service一般都是需要进行”长期“操作,所以经常写法是在自定义Service中处理”长期“操作时需要新建线程,以免阻塞UI线程或导致ANR;

2.Service一旦创建,需要停止时都需要显示调用相应的方法(Started Service需要调用stopService(..)或Service本身调用stopSelf(..), Bound Service需要调用unbindService(..)),否则对于Started Service将处于一直运行状态,对于Bound Service,当Client生命周期结束时也将因此问题。也就是说,Service执行完毕后,必须人为的去停止它。

 

6.IntentService

IntentService是系统提供给我们的一个已经继承自Service类的特殊类,IntentService特殊性是相对于Service本身的特性而言的:

1.默认直接实现了onBind(..)方法,直接返回null,并定义了抽象方法onHandlerIntent(..),用户自定义子类时,需要实现此方法;

2.onHandlerIntent(..)主要就是用来处于相应的”长期“任务的,并且已经自动在新的线程中,用户无语自定义新线程;

3.当”长期“任务执行完毕后(也就是onHandlerIntent(..)执行完毕后),此IntentService将自动结束,无需人为调用方法使其结束;

4.IntentService处于任务时,也是按照队列的方式一个个去处理,而非真正意义上的多线程并发方式。

下面是一个基本的继承自IntentService的自定义Service:

 1 public class MyIntentService extends IntentService {
 2 
 3     public static final String TAG = "MyIntentService";
 4 
 5     public MyIntentService() {
 6         super(TAG);
 7     }
 8 
 9     public MyIntentService(String name) {
10         super(name);
11     }
12 
13     @Override
14     protected void onHandleIntent(Intent intent) {
15         Log.w(TAG, "in onHandleIntent");
16         Log.w(TAG, "thread name:" + Thread.currentThread().getName());
17     }
18 
19 }

 

7.前台Service

Android中Service接口中还提供了一个称之为”前台Service“的概念。通过Service.startForeground (int id, Notification notification)方法可以将此Service设置为前台Service。在UI显示上,notification将是一个处于onGoing状态的通知,使得前台Service拥有更高的进程优先级,并且Service可以直接notification通信。

下面是一个简单的前台Service使用实例:

 1 public class MyService extends Service {
 2 
 3     public static final String TAG = "MyService";
 4 
 5     @Override
 6     public IBinder onBind(Intent intent) {
 7         return null;
 8     }
 9 
10     @Override
11     public void onCreate() {
12         super.onCreate();
13         Log.w(TAG, "in onCreate");
14     }
15 
16     @Override
17     public int onStartCommand(Intent intent, int flags, int startId) {
18         Log.w(TAG, "in onStartCommand");
19         Log.w(TAG, "MyService:" + this);
20         String name = intent.getStringExtra("name");
21         Log.w(TAG, "name:" + name);
22 
23         
24         Notification notification = new Notification(R.drawable.ic_launcher, "test", System.currentTimeMillis());
25         Intent notificationIntent = new Intent(this, DActivity.class);
26         PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntesnt, 0);
27         notification.setLatestEventInfo(this, "title", "content", pendingIntent);
28         startForeground(1, notification);
29         
30 
31         return START_REDELIVER_INTENT;
32     }
33 
34     @Override
35     public void onDestroy() {
36         super.onDestroy();
37         Log.w(TAG, "in onDestroy");
38     }
39 }

 

posted @ 2014-12-23 21:51  HappyCorn  阅读(113170)  评论(7编辑  收藏  举报