免费注册 查看新帖 |

Chinaunix

  平台 论坛 博客 文库
› 论坛 › 操作系统 › 移动操作系统 › Android开发--Service入门用法与教程
最近访问板块 发新帖
查看: 822 | 回复: 0
打印 上一主题 下一主题

Android开发--Service入门用法与教程 [复制链接]

aliounian

论坛徽章:
0
跳转到指定楼层
1楼 [收藏(0)] [报告]
发表于 2011-02-14 16:28 |只看该作者 |倒序浏览
android SDK提供了Service，用于类似*nix守护进程或者windows的服务。
Service有两种类型：
1. 本地服务（Local Service）：用于应用程序内部
2. 远程服务（Remote Sercie）：用于android系统内部的应用程序之间
前者用于实现应用程序自己的一些耗时任务，比如查询升级信息，并不占用应用程序比如Activity所属线程，而是单开线程后台执行，这样用户体验比较好。
后者可被其他应用程序复用，比如天气预报服务，其他应用程序不需要再写这样的服务，调用已有的即可。
编写不需和Activity交互的本地服务示例
本地服务编写比较简单。首先，要创建一个Service类，该类继承android的Service类。这里写了一个计数服务的类，每秒钟为计数器加一。在服务类的内部，还创建了一个线程，用于实现后台执行上述业务逻辑。
  1. package com.easymorse;
  2. import android.app.Service;
  3. import android.content.Intent;
  4. import android.os.IBinder;
  5. import android.util.Log;
  6. public class CountService extends Service {
  7.     private boolean threadDisable;
  8.     private int count;
  9.     @Override
  10.     public IBinder onBind(Intent intent) {
  11.         return null;
  12.     }
  13.     @Override
  14.     public void onCreate() {
  15.         super.onCreate();
  16.         new Thread(new Runnable() {
  17.             @Override
  18.             public void run() {
  19.                 while (!threadDisable) {
  20.                     try {
  21.                         Thread.sleep(1000);
  22.                     } catch (InterruptedException e) {
  23.                     }
  24.                     count++;
  25.                     Log.v("CountService", "Count is " + count);
  26.                 }
  27.             }
  28.         }).start();
  29.     }
  30.     @Override
  31.     public void onDestroy() {
  32.         super.onDestroy();
  33.         this.threadDisable = true;
  34.         Log.v("CountService", "on destroy");
  35.     }
  36.     public int getCount() {
  37.         return count;
  38.     }
  39. }
 
需要将该服务注册到配置文件AndroidManifest.xml中，否则无法找到：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="com.easymorse" android:versionCode="1" android:versionName="1.0">
  4.     <application android:icon="@drawable/icon" android:label="@string/app_name">
  5.         <activity android:name=".LocalServiceDemoActivity"
  6.             android:label="@string/app_name">
  7.             <intent-filter>
  8.                 <action android:name="android.intent.action.MAIN" />
  9.                 <category android:name="android.intent.category.LAUNCHER" />
  10.             </intent-filter>
  11.         </activity>
  12.         <service android:name="CountService" />
  13.     </application>
  14.     <uses-sdk android:minSdkVersion="3" />
  15. </manifest>
 
在Activity中启动和关闭本地服务。
  1. package com.easymorse;
  2. import android.app.Activity;
  3. import android.content.Intent;
  4. import android.os.Bundle;
  5. public class LocalServiceDemoActivity extends Activity {
  6.     /** Called when the activity is first created. */
  7.     @Override
  8.     public void onCreate(Bundle savedInstanceState) {
  9.         super.onCreate(savedInstanceState);
  10.         setContentView(R.layout.main);
  11.         this.startService(new Intent(this, CountService.class));
  12.     }
  13.     @Override
  14.     protected void onDestroy() {
  15.         super.onDestroy();
  16.         this.stopService(new Intent(this, CountService.class));
  17.     }
  18. }
 
可通过日志查看到后台线程打印的计数内容。
编写本地服务和Activity交互的示例
上面的示例是通过startService和stopService启动关闭服务的。适用于服务和activity之间没有调用交互的情况。如果之间需要传递参数或者方法调用。需要使用bind和unbind方法。
具体做法是，服务类需要增加接口，比如ICountService，另外，服务类需要有一个内部类，这样可以方便访问外部类的封装数据，这个内部类需要继承Binder类并实现ICountService接口。还有，就是要实现Service的onBind方法，不能只传回一个null了。
这是新建立的接口代码：
 

  1. package com.easymorse;
  2. public interface ICountService {
  3.     public abstract int getCount();
  4. }

修改后的CountService代码：

  1. package com.easymorse;
  2. import android.app.Service;
  3. import android.content.Intent;
  4. import android.os.Binder;
  5. import android.os.IBinder;
  6. import android.util.Log;
  7. public class CountService extends Service implements ICountService {
  8.     private boolean threadDisable;
  9.     private int count;
  10.     private ServiceBinder serviceBinder=new ServiceBinder();
  11.     public class ServiceBinder extends Binder implements ICountService{
  12.         @Override
  13.         public int getCount() {
  14.             return count;
  15.         }
  16.     }
  17.     @Override
  18.     public IBinder onBind(Intent intent) {
  19.         return serviceBinder;
  20.     }
  21.     @Override
  22.     public void onCreate() {
  23.         super.onCreate();
  24.         new Thread(new Runnable() {
  25.             @Override
  26.             public void run() {
  27.                 while (!threadDisable) {
  28.                     try {
  29.                         Thread.sleep(1000);
  30.                     } catch (InterruptedException e) {
  31.                     }
  32.                     count++;
  33.                     Log.v("CountService", "Count is " + count);
  34.                 }
  35.             }
  36.         }).start();
  37.     }
  38.     @Override
  39.     public void onDestroy() {
  40.         super.onDestroy();
  41.         this.threadDisable = true;
  42.         Log.v("CountService", "on destroy");
  43.     }
  44.     /* (non-Javadoc)
  45.      * @see com.easymorse.ICountService#getCount()
  46.      */
  47.     public int getCount() {
  48.         return count;
  49.     }
  50. }
服务的注册也要做改动，AndroidManifest.xml文件：
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="com.easymorse" android:versionCode="1" android:versionName="1.0">
  4.     <application android:icon="@drawable/icon" android:label="@string/app_name">
  5.         <activity android:name=".LocalServiceDemoActivity"
  6.             android:label="@string/app_name">
  7.             <intent-filter>
  8.                 <action android:name="android.intent.action.MAIN" />
  9.                 <category android:name="android.intent.category.LAUNCHER" />
  10.             </intent-filter>
  11.         </activity>
  12.         <service android:name="CountService">
  13.             <intent-filter>
  14.                 <action android:name="com.easymorse.CountService"/>
  15.             </intent-filter>
  16.         </service>
  17.     </application>
  18.     <uses-sdk android:minSdkVersion="3" />
  19. </manifest>
Acitity代码不再通过startSerivce和stopService启动关闭服务，另外，需要通过ServiceConnection的内部类实现来连接Service和Activity。
  1. package com.easymorse;
  2. import android.app.Activity;
  3. import android.content.ComponentName;
  4. import android.content.Intent;
  5. import android.content.ServiceConnection;
  6. import android.os.Bundle;
  7. import android.os.IBinder;
  8. import android.util.Log;
  9. public class LocalServiceDemoActivity extends Activity {
  10.     private ServiceConnection serviceConnection = new ServiceConnection() {
  11.         @Override
  12.         public void onServiceConnected(ComponentName name, IBinder service) {
  13.             countService = (ICountService) service;
  14.             Log.v("CountService", "on serivce connected, count is "
  15.                     + countService.getCount());
  16.         }
  17.         @Override
  18.         public void onServiceDisconnected(ComponentName name) {
  19.             countService = null;
  20.         }
  21.     };
  22.     private ICountService countService;
  23.     /** Called when the activity is first created. */
  24.     @Override
  25.     public void onCreate(Bundle savedInstanceState) {
  26.         super.onCreate(savedInstanceState);
  27.         setContentView(R.layout.main);
  28.         this.bindService(new Intent("com.easymorse.CountService"),
  29.                 this.serviceConnection, BIND_AUTO_CREATE);
  30.     }
  31.     @Override
  32.     protected void onDestroy() {
  33.         super.onDestroy();
  34.         this.unbindService(serviceConnection);
  35.     }
  36. }
编写传递基本型数据的远程服务

上面的示例，可以扩展为，让其他应用程序复用该服务。这样的服务叫远程（remote）服务，实际上是进程间通信（RPC）。
这时需要使用android接口描述语言（AIDL）来定义远程服务的接口，而不是上述那样简单的java接口。扩展名为aidl而不是java。可用上面的ICountService改动而成ICountSerivde.aidl，eclipse会自动生成相关的java文件。
  1. package com.easymorse;
  2. interface ICountService {
  3.     int getCount();
  4. }
 
编写服务（Service）类，稍有差别，主要在binder是通过远程获得的，需要通过桩（Stub）来获取。桩对象是远程对象的本地代理。
  1. package com.easymorse;
  2. import android.app.Service;
  3. import android.content.Intent;
  4. import android.os.IBinder;
  5. import android.os.RemoteException;
  6. import android.util.Log;
  7. public class CountService extends Service {
  8.     private boolean threadDisable;
  9.     private int count;
  10.     private ICountService.Stub serviceBinder = new ICountService.Stub() {
  11.         @Override
  12.         public int getCount() throws RemoteException {
  13.             return count;
  14.         }
  15.     };
  16.     @Override
  17.     public IBinder onBind(Intent intent) {
  18.         return serviceBinder;
  19.     }
  20.     @Override
  21.     public void onCreate() {
  22.         super.onCreate();
  23.         new Thread(new Runnable() {
  24.             @Override
  25.             public void run() {
  26.                 while (!threadDisable) {
  27.                     try {
  28.                         Thread.sleep(1000);
  29.                     } catch (InterruptedException e) {
  30.                     }
  31.                     count++;
  32.                     Log.v("CountService", "Count is " + count);
  33.                 }
  34.             }
  35.         }).start();
  36.     }
  37.     @Override
  38.     public void onDestroy() {
  39.         super.onDestroy();
  40.         this.threadDisable = true;
  41.         Log.v("CountService", "on destroy");
  42.     }
  43. }
配置文件AndroidManifest.xml和上面的类似，没有区别。
在Activity中使用服务的差别不大，只需要对ServiceConnection中的调用远程服务的方法时，要捕获异常。
  1. private ServiceConnection serviceConnection = new ServiceConnection() {
  2.     @Override
  3.     public void onServiceConnected(ComponentName name, IBinder service) {
  4.         countService = (ICountService) service;
  5.         try {
  6.             Log.v("CountService", "on serivce connected, count is "
  7.                     + countService.getCount());
  8.         } catch (RemoteException e) {
  9.             throw new RuntimeException(e);
  10.         }
  11.     }
  12.     @Override
  13.     public void onServiceDisconnected(ComponentName name) {
  14.         countService = null;
  15.     }
  16. };
这样就可以在同一个应用程序中使用远程服务的方式和自己定义的服务交互了。
如果是另外的应用程序使用远程服务，需要做的是复制上面的aidl文件和相应的包构到应用程序中，其他调用等都一样。
编写传递复杂数据类型的远程服务
远程服务往往不只是传递java基本数据类型。这时需要注意android的一些限制和规定：
   1. android支持String和CharSequence
   2. 如果需要在aidl中使用其他aidl接口类型，需要import，即使是在相同包结构下；
   3. android允许传递实现Parcelable接口的类，需要import；
   4. android支持集合接口类型List和Map，但是有一些限制，元素必须是基本型或者上述三种情况，不需要import集合接口类，但是需要对元素涉及到的类型import；
   5. 非基本数据类型，也不是String和CharSequence类型的，需要有方向指示，包括in、out和inout，in表示由客户端设置，out表示由服务端设置，inout是两者均可设置。
这里将前面的例子中返回的int数据改为复杂数据类型：
  1. package com.easymorse;
  2. import android.os.Parcel;
  3. import android.os.Parcelable;
  4. public class CountBean implements Parcelable {
  5.     public static final Parcelable.Creator<CountBean> CREATOR = new Creator<CountBean>() {
  6.         @Override
  7.         public CountBean createFromParcel(Parcel source) {
  8.             CountBean bean = new CountBean();
  9.             bean.count = source.readInt();
  10.             return bean;
  11.         }
  12.         @Override
  13.         public CountBean[] newArray(int size) {
  14.             return new CountBean[size];
  15.         }
  16.     };
  17.     public int count;
  18.     @Override
  19.     public void writeToParcel(Parcel dest, int flags) {
  20.         dest.writeInt(this.count);
  21.     }
  22.     @Override
  23.     public int describeContents() {
  24.         return 0;
  25.     }
  26. }

然后，需要在相同包下建一个同名的aidl文件，用于android生成相应的辅助文件：

package com.easymorse;
parcelable CountBean;
 
这一步是android 1.5后的变化，无法通过adt生成aidl，也不能用一个比如全局的project.aidl文件，具体见：http://www.anddev.org/viewtopic.php?p=20991
然后，需要在服务的aidl文件中修改如下：
  1. package com.easymorse;
  2. import com.easymorse.CountBean;
  3. interface ICountService {
  4.     CountBean getCount();
  5. }
 
其他的改动很小，只需将CountService和调用CountService的部分修改为使用CountBean即可。
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则 发表回复

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号-6 北京市公安局海淀分局网监中心备案编号：11010802020122 niuxiaotong@pcpop.com 17352615567
未成年举报专区
中国互联网协会会员  联系我们：huangweiwei@itpub.net
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP