service、aidl

转载请注明本文出自Cym的博客（http://blog.youkuaiyun.com/cym492224103），谢谢支持！

服务（service）

服务没有可视化的用户界面，而是在一段时间内在后台运行。比如说，一个服务可以在用户做其它事情的时候在后台播放背景音乐、从网络上获取一些数据或者计算一些东西并提供给需要这个运算结果的activity使用。每个服务都继承自Service基类。

服务的启动方式和生命周期

[java] view plain copy print ?

1. //第一种启动方式  
2. startService();  

生命周期:onCreate()-->onStart()-->onDestory()

访问者和服务是没有任何关系的

[java] view plain copy print ?

1. //第二种启动方式  
2. bindService();  

生命周期:onCreate()-->onBind()-->onUnbind()-->onDestory()

访问者和服务是绑定在一起的。如果访问者退出。服务一定要停止。同生共死。

访问者可以调用服务里面的方法

服务只会启动一个。

如果启动的服务再次启动也不会在启动

一个调用者只能和服务绑定一次。

如果绑定的服务再次绑定也不会在绑定

startService()启动的服务，只有stopService()才能停止。

bindService()启动的服务，只有unBindService()才能停止

使用服务

当activity要使用到服务里面的方法的时候。我们就应该使用bingService

不需要使用服务里面的方法发时候，我们就使用startService

startService

[java] view plain copy print ?

1. //新建类继承Service  
2. public class MyService extends Service{}  
3. //在AndroidManifes.xml文件中注册Service  
4. <service android:name=".MyService">  
5.            <intent-filter >  
6.                  <action android:name="com.huaao.service.MyService"/>  
7.            </intent-filter>  
8. </service>  
9. //启动服务,参数是一个指向服务的意图  
10. startService(Intent service);  
11. //关闭服务,参数是一个指向服务的意图  
12. stopService(Intent name);  

bindService

IBinder:这是一个能进行远程操作对象的基接口

[java] view plain copy print ?

1. //服务连接实例  
2. ServiceConnection conn = newServiceConnection() {  
3.        //服务断开连接时调用  
4. @Override  
5. public voidonServiceDisconnected(ComponentName name) {  
6. }  
7. //服务连接时调用  
8. //第二个参数是Ibinder，是负责和服务通信的  
9. @Override  
10. public void onServiceConnected(ComponentNamename, IBinder service) {  
11. }  
12. }；  
13. //绑定服务  
14. bindService(Intent service,ServiceConnection conn, int flags);  
15. //解绑服务  
16. unbindService(ServiceConnection conn);  

本地的音乐播放器

activity和serivce是在同一个应用

播放功能和暂停功能：

此时我们不需要用到服务里面的方法所以我们用startService

Activity:

[java] view plain copy print ?

1. public class MainActivity extends Activity {  
2.     /** Called when the activity is first created. */  
3.     @Override  
4.     public void onCreate(Bundle savedInstanceState) {  
5.         super.onCreate(savedInstanceState);  
6.         setContentView(R.layout.main);  
7.     }  
8.     public void start(View v) {  
9.         startService(new Intent(this, MyService.class));  
10.     }  
11.     public void stop(View v) {  
12.         stopService(new Intent(this, MyService.class));  
13.     }  
14. }  

让音乐onCreate的时候就开启,onDestroy就关闭

MyService:

[java] view plain copy print ?

1. public class MyService extends Service {  
2.     private MediaPlayer mp;  
3.     @Override  
4.     public void onCreate() {  
5.         // TODO Auto-generated method stub  
6.         super.onCreate();  
7.         try {  
8.             // 媒体播放器  
9.             mp = new MediaPlayer();  
10.             // 重置  
11.             mp.reset();  
12.     File file = new File(Environment.getExternalStorageDirectory(),  
13.                     "xqx.mp3");  
14.             // 设置播放文件  
15.             mp.setDataSource(file.getAbsolutePath());  
16.             // 准备  
17.             mp.prepare();  
18.             // 播放  
19.             mp.start();  
20.         } catch (Exception e) {  
21.             // TODO Auto-generated catchblock  
22.             e.printStackTrace();  
23.         }  
24.     }  
25.     @Override  
26.     public IBinder onBind(Intentintent) {  
27.         // TODO Auto-generated method stub  
28.         return null;  
29.     }  
30.     @Override  
31.     public void onDestroy() {  
32.         // TODO Auto-generated method stub  
33.         super.onDestroy();  
34.         // 停止播放  
35.         mp.stop();  
36.     }  

如果我们需要添加几个功能：比如暂停，继续功能。这个时候我们就应该用到bindService

Activity:

[java] view plain copy print ?

1. public class MainActivity extends Activity{  
2.    private ServiceConnection conn;  
3.        /**Called when the activity is first created. */  
4.         
5.    private MusicI musici; // 接口  
6.         
7.    @Override  
8.    public void onCreate(Bundle savedInstanceState) {  
9.        super.onCreate(savedInstanceState);  
10.        setContentView(R.layout.main);  
11.     }  
12.      
13.    //使用服务来播放音乐  
14.      
15.    //播放  
16.    public void play(View v){  
17.            Intent service  = new Intent(this,MyService.class);  
18.            conn = new MyServiceConnection();  
19.            bindService(service, conn,Context.BIND_AUTO_CREATE);  
20.     }  
21.      
22.    //暂停  
23.    public void pause(View v){  
24.            musici.pause();  
25.     }  
26.    //继续播放  
27.    public void continue_play(View v){  
28.            musici.continue_play();  
29.     }  
30.      
31.    //停止  
32.    public void stop(View v){  
33.            Intent service  = new Intent(this,MyService.class);  
34.        unbindService(conn);  
35.     }  
36.      
37.    private class MyServiceConnection implements ServiceConnection{  
38.               @Override  
39.               public voidonServiceConnected(ComponentName name, IBinder service) {  
40.                      //TODO Auto-generated method stub  
41.                      musici = (MusicI) service;  
42.               }  
43.               @Override  
44.               public voidonServiceDisconnected(ComponentName name) {  
45.                      //TODO Auto-generated method stub  
46.                        
47.               }  
48.              
49.     }  
50. }  

Interface:

[java] view plain copy print ?

1. public interface MusicI {  
2.     // 暂停  
3.     public void pause();  
4.     // 继续播放  
5.     public void continue_mp();  
6. }  

MyService:

[java] view plain copy print ?

1. public class MyService extends Service {  
2.     private MediaPlayer mp;  
3.     @Override  
4.     public void onCreate() {  
5.         // TODO Auto-generated method stub  
6.         super.onCreate();  
7.         try {  
8.             // 媒体播放器  
9.             mp = new MediaPlayer();  
10.             // 重置  
11.             mp.reset();  
12.     File file = new File(Environment.getExternalStorageDirectory(),  
13.                     "xqx.mp3");  
14.             // 设置播放文件  
15.             mp.setDataSource(file.getAbsolutePath());  
16.             // 准备  
17.             mp.prepare();  
18.             // 播放  
19.             mp.start();  
20.         } catch (Exception e) {  
21.             // TODO Auto-generated catchblock  
22.             e.printStackTrace();  
23.         }  
24.     }  
25.     @Override  
26.     public IBinder onBind(Intentintent) {  
27.         // TODO Auto-generated method stub  
28.         return new MyIBinder();  
29.     }  
30.     @Override  
31.     public void onDestroy() {  
32.         // TODO Auto-generated method stub  
33.         super.onDestroy();  
34.         // 停止播放  
35.         mp.stop();  
36.     }  

[java] view plain copy print ?

1.     class MyIBinder extends Binder implements MusicI {  
2.         @Override  
3.         public void pause() {  
4.             // TODO Auto-generatedmethod stub  
5.             service_pause();  
6.         }  
7.         @Override  
8.         public voidcontinue_mp() {  
9.             // TODO Auto-generatedmethod stub  
10.             service_continue();  
11.         }  
12.     }  
13.     public void service_pause() {  
14.         mp.pause();  
15.     }  
16.     public void service_continue() {  
17.         mp.start();  
18.     }  
19. }  

远程的音乐播放器

activity和serivce是不在同一个应用:

Service：

为了让跨进程访问服务。我们使用了aidl

项目菜单的视图（Package Explorer）切换成 Navigator 视图

将接口后缀改成 .aidl 语言会被编译器自动编译生成java代码

在切换到Package Explorer 在gen文件夹下面就可以看到，

接口类会自定义一个抽象的Stub然后继承Binder实现当前接口

public static abstract class Stub extends android.os.Binder implements com.cym.inter.MusicI

所以服务里面的MyIBinder 只要继承Stub 即可;

class MyIBinder extends Stub

Xml:

[html] view plain copy print ?

1. <service android:name=".MyService">  
2.             <intent-filter >  
3.                要配置名字让其他应用访问  
4.                <action android:name="com.cym.myservice"/>  
5.                  
6.             </intent-filter>  
7.               
8.         </service>  
9.           

Client：

需要相同的文件aidl 就像是一份合同。调用者和访问都需要。并且他们所有都必须是一样的。包名都需要一样。             

[java] view plain copy print ?

1. bindService(newIntent("com.cym.myservice"), mc, Context.BIND_AUTO_CREATE);  
2.     public class MyServiceConnection implements ServiceConnection{  
3.         @Override  
4.         public voidonServiceConnected(ComponentName name, IBinder service) {  
5.             //  Stub提供了asInterface方法 加载服务端返回的Binder对象  
6.              m = Stub.asInterface(service);  
7.         }  
8.         @Override  
9.         public voidonServiceDisconnected(ComponentName name) {  
10.             // TODO Auto-generated methodstub  
11.               
12.         }  
13.           
14.     }  

不仅可以使用无参的方法还可以使用有参的方法

void seekTo(in MusicInfo info);

传入实体， 但是实体要是 implements Parcelable  

[java] view plain copy print ?

1. public class MusicInfo implements Parcelable {  
2.     public int position;  
3.     @Override  
4.     public int describeContents() {  
5.         // TODO Auto-generated method stub  
6.         return 0;  
7.     }  
8.     @Override  
9.     public void writeToParcel(Parcel dest, int flags) {  
10.         // TODO Auto-generated method stub  
11.           dest.writeInt(position);  
12.     }  
13.     public static finalParcelable.Creator<MusicInfo> CREATOR = new Parcelable.Creator<MusicInfo>() {  
14.         public MusicInfo createFromParcel(Parcel in) {  
15.             return new MusicInfo(in);  
16.         }  
17.         public MusicInfo[] newArray(int size) {  
18.             return new MusicInfo[size];  
19.         }  
20.     };  
21.      
22.     public MusicInfo() {  
23.         super();  
24.     }  
25.     public MusicInfo(int position) {  
26.         super();  
27.         this.position = position;  
28.     }  
29.     private MusicInfo(Parcel in) {  
30.         this.position = in.readInt();  
31.     }  
32. }  

Dial文件里面应用的对象也要是dial格式的；

[java] view plain copy print ?

1. MusicInfo.aidl：  
2. packagecom.cym.domain;  
3. parcelableMusicInfo;  
4. MusicI.aidl：  
5. import com.cym.domain.MusicInfo;  
6. interface MusicI {  
7.        
8.       void pause();  
9.        
10.       void continue_mp();  
11.         
12.       void seekTo(in MusicInfo info);    
13. }  

aidl

进程间通信需要用到aidl(AndroidInterface ition Language)语言

aidl的作用:跨进程访问服务

如果在android里面要实现进程间通信，

aidl语言是一种新的语言。该语言会被编译器自动编译生成java代码。

Xxx.aidl

aidl 就像是一份合同。调用者和访问都需要。并且他们所有都必须是一样的。包名都需要一样。

特点：

1 很多关键字不认识 public        

2 对于基本类型都支持

3 但不支持定义javabean

    如果要支持就必须实现Parcelable接口

4 如果有参数必须做明确的说明。in out inout

framework开发

曾经做过framework层开发，一般都是对aidl文件进行一些修改。因为原生的接口有的功能是无法实现一些效果的。比如双卡双待机。有2张sim，

挂断电话的时候，一般就是对方法进行扩展，也就是添加几个参数。

服务里面也不能做耗时的操作。

要耗时。开子线程。

Service进程的重要级别

Android系统试图尽可能长地保持一个应用程序进程，但是当内存低时它最终还是需要移除旧的进程。为了决定保持那个进程及杀死那个进程，android将每个进程放入了一个基于运行于其中的组件的重要性等级和这些组件的状态。重要性最低的进程首先被杀死，然后是其次，以此类推。总共有5个层次级别。

1 前台进程：用户当前工作所需要的。一个进程如果满足下列任何条件被认为是前台进程：

  1.1它正运行这个一个正在与用户交互的活动(Activity对象的onResume()方法已经被调用)

  1.2它寄宿了一个服务，该服务与一个与用户交互的活动绑定

  1.3它有一个Service对象执行它的生命周期回调(onCreate()、onStart()、onDestory())

  1.4它有一个BroadcastReceiver对象执行他的onReceive()方法

2 可视进程：他没有任何前台组件，但是仍然能影响用户在屏幕上看到东西。一个进程满足下面任何一个条件都被认为是可视进程

  2.1 它寄宿着一个不是前台的活动，但是它对用户仍可见(onPause()方法已经被调用)

  2.2 它寄宿着一个服务，该服务绑定到了一个可视的活动

3 服务进程：它是一个运行着一个用startService()方法启动的服务，并且该服务没有落入上面2种分类。虽然服务进程没有直接关系到任何用户可见的，它们通常做用户关心的事(例如：在后台播放mp3或者从网络上下载数据)

4 后台进程：一个保持着一个当前对用户不可视的活动(已经调用Activity对象的onStop()方法)。这些进程没有直接影响用户体验，并且可以在任何时候被杀以收回内存用于一个前台、可视、服务进程。一般地有很多后台进程运行着，因此它们保持在一个LRU(least recently used,即最近最少使用，如果你对操作系统很熟悉，跟内存的页面置换算法LRU一样。)列表以确定最近使用过最多的活动的进程最后被杀。如果一个活动执行正确生命周期方法，且捕获它当前的状态，杀掉它对用户的体验没有伤害的影响。

5 空进程：是一个没有保持活跃的应用程序组件的进程。保持这个进程可用的唯一原因是作为一个cache以提高下次启动组件的速度。系统进程杀死这些进程，以在进程cache和潜在的内核cache之间平衡整个系统资源。

显示电话归属地及设置黑名单

工程结构：

所需权限：

[html] view plain copy print ?

1. <uses-permission android:name="android.permission.READ_PHONE_STATE"/>  
2.    <uses-permission android:name="android.permission.READ_CONTACTS"/>  
3.    <uses-permission android:name="android.permission.CALL_PHONE"/>  
4.    <uses-permission android:name="android.permission.WRITE_CONTACTS"/>  

启动一个服务，

服务里面首先得到电话管理器，窗体管理器，布局管理器。

给电话管理器监听电话状态，如果是来电的话，我们就去查

询数据库什么号码相应的地区，以及是否是联系人，然后显示相应信息。

如果是黑名单的话，那我们就要调用电话服务的一个方法，想要拿到电话服务

返回的IBinder我们就必须在源码里面找到ServiceManager管理所有服务的

类，但是由于ServiceManager没有对外公开，所以我们只能用放射技术使用它的

ｇｅｔＳｅｒｖｉｃｅ方法，得到电话的服务的IBinder对象，然后转化成ITelephony（这个接口要在源码里面找到他的ａｉｄｌ文件因为是调用它的服务，以及要找到他接口里面使用的实体类ｄｉａｌ）

接口就可以使用他的挂断电话方法了，挂掉电话之后删除黑名单号码通话记录，由于通话记录是在删除之后系统在添加所以我们要使用监听

[java] view plain copy print ?

1. // 删除通话记录（通话记录的存储是异步的,可以使用ContentObserver）  
2.                 Uri uri = Calls.CONTENT_URI;  
3.                 getContentResolver().registerContentObserver(uri,false, new MyContentObserver(newHandler(), incomingNumber) );  
4. private class MyContentObserver extendsContentObserver{  
5.             private String number;  
6.             publicMyContentObserver(Handler handler, String number) {  
7.                 super(handler);  
8.                 this.number = number;  
9.                 // TODO Auto-generated constructor stub  
10.             }  
11.             @Override  
12.             public void onChange(boolean selfChange) {  
13.                 // TODO Auto-generated method stub  
14.                 super.onChange(selfChange);  
15.                 Uri uri = Calls.CONTENT_URI;  
16.                 String where = Calls.NUMBER + "= ?";  
17.                 String[] selectionArgs =new String[]{number};  
18.                 getContentResolver().delete(uri,where, selectionArgs);  
19.                 // 取消监听  
20.                 getContentResolver().unregisterContentObserver(this);  
21.             }  
22.               
23.         }  

电话内容提供者删除方法里面有通知监听事件，所以能启动我们自己写的监听。

我们想已开机就使用该功能我们还可以设置一个广播接受者：开机启动广播，广

播在调用服务        

[html] view plain copy print ?

1. <receiver android:name=".MyBroadcastReceiver">  
2.             <intent-filter >  
3.                  <!-- 订阅开机广播-->  
4.                 <action android:name="android.intent.action.BOOT_COMPLETED"/>  
5.             </intent-filter>  
6.               
7.         </receiver>  

[java] view plain copy print ?

1. public class MainActivity extends Activity {  
2.     /** Called when the activity is first created. */  
3.     @Override  
4.     public void onCreate(Bundle savedInstanceState) {  
5.         super.onCreate(savedInstanceState);  
6.         setContentView(R.layout.main);  
7.           
8.         startService(new Intent(this, MyService.class));  
9.     }  
10. }  
11. public class MyService extends Service {  
12.     /* 
13.      * 服务放回过来的IBinder那是不是就可以挂断电话（通过Ibinder调用服务内的方法） 
14.      * 如果要调用该方法我们就应该找到一个aidl文件文件与之对应‘ frameworks\base\telephony\ 
15.      * java\com\android\internal\telephony\ITelephony.aidl 
16.      * 
17.      * 那么我们怎么拿到电话服务呢？ android 里面所有的服务都是被一个类来进行管理 
18.      *frameworks\base\core\java\android\os\ServiceManager 
19.      * public static IBindergetService(String name) { 
20.         try { 
21.             IBinder service = sCache.get(name); 
22.             if (service != null) { 
23.                 return service; 
24.             } else { 
25.                 returngetIServiceManager().getService(name); 
26.             } 
27.         } catch (RemoteException e) { 
28.             Log.e(TAG, "error ingetService", e); 
29.         } 
30.         return null; 
31.     } 
32.      */  
33.     private WindowManager wm;  
34.     private LayoutInflater mInflater;  
35.     private View view;  
36.     // 判断是否显示了来电提醒  
37.     boolean flag = false;  
38.     @Override  
39.     public void onCreate() {  
40.         // TODO Auto-generated method stub  
41.         super.onCreate();  
42.         // 得到电话管理器  
43.         TelephonyManager tm =(TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);  
44.         // 窗体管理器  
45.         wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);  
46.         // 布局加载器  
47.         mInflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
48.         // 监听电话的呼叫状态  
49.         tm.listen(new MyPhoneStateListener(),  
50.                 PhoneStateListener.LISTEN_CALL_STATE);  
51.     }  
52.     private class MyPhoneStateListener extends PhoneStateListener {  
53.         @Override  
54.         public void onCallStateChanged(int state, String incomingNumber) {  
55.             super.onCallStateChanged(state,incomingNumber);  
56.             switch (state) {  
57.             case TelephonyManager.CALL_STATE_IDLE: // 闲置  
58.                 if (flag) {  
59.                     wm.removeView(view);  
60.                     flag = false;  
61.                 }  
62.                 break;  
63.             case TelephonyManager.CALL_STATE_OFFHOOK: // 通话  
64.                 break;  
65.             case TelephonyManager.CALL_STATE_RINGING: // 响铃  
66.                 // 黑名单  
67.                 if (incomingNumber.equals("110")) {  
68.                     endCall(incomingNumber);  
69.                     return;  
70.                 }  
71.                 // 拿Toast显示的源代码  
72.                 // 布局参数  
73.                 WindowManager.LayoutParams params = new WindowManager.LayoutParams();  
74.                 // 高  
75.                 params.height = WindowManager.LayoutParams.WRAP_CONTENT;  
76.                 // 宽  
77.                 params.width = WindowManager.LayoutParams.WRAP_CONTENT;  
78.                 // 标识  
79.                 params.flags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE  
80.                         | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE  
81.                         | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;  
82.                 // 格式  
83.                 params.format = PixelFormat.TRANSLUCENT;  
84.                 // 类型和Toast一样  
85.                 params.type = WindowManager.LayoutParams.TYPE_TOAST;  
86.                 // 加载布局  
87.                 view = mInflater.inflate(R.layout.address, null);  
88.                 // 得到布局里面的控件  
89.                 TextView tv_number =(TextView) view  
90.                         .findViewById(R.id.tv_number);  
91.                 TextView tv_address =(TextView) view  
92.                         .findViewById(R.id.tv_address);  
93.                 // 先查询是否是联系人  
94.                 String name = null;  
95.                 // 得到查询联系人的Uri  
96.     Uri uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI,  
97.                         Uri.encode(incomingNumber));  
98.                 // 查询结果  
99.                 String[] projection = new String[] { PhoneLookup.DISPLAY_NAME };  
100.                 // 去数据库查询得到查询结构  
101.                 Cursor c =getContentResolver().query(uri, projection, null,  
102.                         null, null);  
103.                 if (c.moveToFirst()) {  
104.                     name = c.getString(0);  
105.                 }  
106.                 // 关闭  
107.                 c.close();  
108.                 // 如果查询到了就显示名字，如果查询到那么就显示号码  
109.                 if (name == null) {  
110.                     tv_number.setText(incomingNumber);  
111.                 } else {  
112.                     tv_number.setText(name);  
113.                 }  
114.                 // 查询号码归属地  
115.                 String address =AddressService.getAddress(incomingNumber);  
116.                 tv_address.setText(address);  
117.                 // 显示加载到窗体里面  
118.                 wm.addView(view, params);  
119.                 flag = true;  
120.                 break;  
121.             }  
122.         }  
123.         private void endCall(StringincomingNumber) {  
124.             // 由于ServiceManager没有对外公开  
125.             // 但是我们知道它的类名，所以我们使用放射技术  
126.             try {  
127.                 // 得到该类  
128.                 Class clazz =Class.forName("android.os.ServiceManager");  
129.                 // 拿到该方法  
130.                 Method method =clazz.getMethod("getService", String.class);  
131.                 // 使用该方法(拿到电话的服务返回的IBinder)  
132.                 IBinder ibinder =(IBinder)method.invoke(null, Context.TELEPHONY_SERVICE);  
133.                 // 通过ITelephony接口的Stub.asInterface 我们就可以直接使用该接口的方法了，也就是调用电话的服务内方法  
134.                 ITelephony itelephony =ITelephony.Stub.asInterface(ibinder);  
135.                 // 挂断电话  
136.                 itelephony.endCall();  
137.                 // 删除通话记录（通话记录的存储是异步的,可以使用ContentObserver）  
138.                 Uri uri = Calls.CONTENT_URI;  
139.                 getContentResolver().registerContentObserver(uri,false, new MyContentObserver(new Handler(), incomingNumber));  
140.             } catch (Exception e) {  
141.                 // TODO Auto-generated catch block  
142.                 e.printStackTrace();  
143.             }  
144.         }  
145.     }  
146.         private class MyContentObserver extends ContentObserver{  
147.             private String number;  
148.             public MyContentObserver(Handlerhandler, String number) {  
149.                 super(handler);  
150.                 this.number = number;  
151.                 // TODO Auto-generated constructor stub  
152.             }  
153.             @Override  
154.             public void onChange(boolean selfChange) {  
155.                 // TODO Auto-generated method stub  
156.                 super.onChange(selfChange);  
157.                 Uri uri = Calls.CONTENT_URI;  
158.                 String where = Calls.NUMBER + "= ?";  
159.                 String[] selectionArgs =new String[]{number};  
160.                 getContentResolver().delete(uri,where, selectionArgs);  
161.                 // 取消监听  
162.                 getContentResolver().unregisterContentObserver(this);  
163.             }  
164.               
165.         }  
166.     @Override  
167.     public IBinder onBind(Intentintent) {  
168.         // TODO Auto-generated method stub  
169.         return null;  
170.     }  
171. }  

应用到了Service：

[java] view plain copy print ?

1. public class AddressService {  
2.     public static String getAddress(String number) {  
3.         String address = null;  
4.         // 得到数据库  
5.         File file = new File(Environment.getExternalStorageDirectory(),  
6.                 "address.db");  
7.         SQLiteDatabase db =SQLiteDatabase.openDatabase(file.getAbsolutePath(),  
8.                 null, SQLiteDatabase.OPEN_READONLY);  
9.         if (db.isOpen()) {  
10.             // 判断号码是手机还是电话  
11.             String regularExpression = "^1[358]\\d{9}$";  
12.             // 如果是手机号码  
13.             if(number.matches(regularExpression)) {  
14.                 // 那么就查询根据手机号码前7位  
15.                 String prefix_num =number.substring(0, 7);  
16.                 String selection = "mobileprefix =?";  
17.                 String[] selectionArgs =new String[] { prefix_num };  
18.                 Cursor c = db.query("info", new String[] { "city" }, selection,  
19.                         selectionArgs, null, null, null);  
20.                 if (c.moveToFirst()) {  
21.                     address = c.getString(0);  
22.                 }  
23.                 c.close();  
24.             } else {  
25.                 // 不是 手机号码就是 电话号码  
26.                 // 10位 3区号 + 7位的号码  
27.                 if (number.length() == 10) {  
28.                     String prefix_num = number.substring(0, 3);  
29.                     String selection = "area = ?";  
30.                     String[] selectionArgs = new String[] { prefix_num };  
31.                     Cursor c = db.query("info", new String[] { "city" }, selection,  
32.                             selectionArgs, null, null, null);  
33.                     if(c.moveToFirst())  
34.                     {  
35.                         address =c.getString(0);  
36.                     }  
37.                     c.close();  
38.                 } else if (number.length() == 11) {  
39.                     String prefix_num = number.substring(0, 3);  
40.                     String selection = "area = ?";  
41.                     String[] selectionArgs = new String[] { prefix_num };  
42.                     Cursor c = db.query("info", new String[] { "city" }, selection,  
43.                             selectionArgs, null, null, null);  
44.                     if(c.moveToFirst())  
45.                     {  
46.                         address =c.getString(0);  
47.                     }  
48.                     c.close();  
49.                     String prefix_num1 = number.substring(0, 4);  
50.                     String selection1 = "area = ?";  
51.                     String[] selectionArgs1 = new String[] { prefix_num1 };  
52.                     Cursor c1 = db.query("info", new String[] { "city" }, selection1,  
53.                             selectionArgs1, null, null, null);  
54.                     if(c1.moveToFirst())  
55.                     {  
56.                         address =c1.getString(0);  
57.                     }  
58.                     c1.close();  
59.                 }else if(number.length() == 12) // 12位  4区号 + 8位的号码  
60.                 {  
61.                     String prefix_num1 = number.substring(0, 4);  
62.                     String selection1 = "area = ?";  
63.                     String[] selectionArgs1 = new String[] { prefix_num1 };  
64.                     Cursor c1 = db.query("info", new String[] { "city" }, selection1,  
65.                             selectionArgs1, null, null, null);  
66.                     if(c1.moveToFirst())  
67.                     {  
68.                         address =c1.getString(0);  
69.                     }  
70.                     c1.close();  
71.                 }else if(number.length() == 7 ||number.length() == 8){  
72.                     address = "本地号码";  
73.                 }else if(number.length() == 3){  
74.                     address = "紧急号码";  
75.                 }else if(number.length() == 4){  
76.                     address = "模拟器";  
77.                 }  
78.             }  
79.             // 关闭数据库连接  
80.             db.close();  
81.         }  
82.         if(address == null){  
83.             address = "未知号码";  
84.         }  
85.         return address;  
86.     }  
87. }  

课后问题

服务有什么特点？

服务没有可视化的用户界面，而是在一段时间内在后台运行。

服务只会启动一个。

如果启动的服务再次启动也不会在启动

一个调用者只能和服务绑定一次。

如果绑定的服务再次绑定也不会在绑定

startService()启动的服务，只有stopService()才能停止。

bindService()启动的服务，只有unBindService()才能停止

服务启动方式有几种，区别是什么？

startService

Bindservice

远程服务需要使用什么语言？

aidl