`
suliuyes
  • 浏览: 93697 次
  • 性别: Icon_minigender_1
  • 来自: 成都
文章分类
社区版块
存档分类
最新评论

Android手机上监听短信的两种方式

AndroidOS应用服务器thread.net 
阅读更多

转载于：http://blog.csdn.net/JavaTiger427/archive/2010/10/11/5932751.aspx

 

1、 接受系统的短信广播，操作短信内容。

 

优点：操作方便，适合简单的短信应用。

缺点：来信会在状态栏显示通知信息。

 

AndroidManifest.xml ：

<uses-permission android:name="android.permission.SEND_SMS"></uses-permission>  
<uses-permission android:name="android.permission.RECEIVE_SMS"></uses-permission>  
   
<!-- Receiver -->  
<receiver android:name=".sms.SMSReceiver">  
<intent-filter>  
    <action android:name="android.provider.Telephony.SMS_RECEIVED" />  
</intent-filter>  
</receiver>

 

code :

 

package org.anymobile.demo.sms;  
   
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
import android.telephony.gsm.SmsMessage;  
import android.util.Log;  
   
public class SMSReceiver extends BroadcastReceiver  
{  
    public static final String TAG = "ImiChatSMSReceiver";  
    //android.provider.Telephony.Sms.Intents  
    public static final String SMS_RECEIVED_ACTION = "android.provider.Telephony.SMS_RECEIVED";  
     
    @Override  
    public void onReceive(Context context, Intent intent)  
    {  
       if (intent.getAction().equals(SMS_RECEIVED_ACTION))  
       {  
           SmsMessage[] messages = getMessagesFromIntent(intent);  
           for (SmsMessage message : messages)  
           {  
              Log.i(TAG, message.getOriginatingAddress() + " : " +  
                  message.getDisplayOriginatingAddress() + " : " +  
                  message.getDisplayMessageBody() + " : " +  
                  message.getTimestampMillis());  
           }  
       }  
    }  
     
    public final SmsMessage[] getMessagesFromIntent(Intent intent)  
    {  
        Object[] messages = (Object[]) intent.getSerializableExtra("pdus");  
        byte[][] pduObjs = new byte[messages.length][];  
   
        for (int i = 0; i < messages.length; i++)  
        {  
            pduObjs[i] = (byte[]) messages[i];  
        }  
        byte[][] pdus = new byte[pduObjs.length][];  
        int pduCount = pdus.length;  
        SmsMessage[] msgs = new SmsMessage[pduCount];  
        for (int i = 0; i < pduCount; i++)  
        {  
            pdus[i] = pduObjs[i];  
            msgs[i] = SmsMessage.createFromPdu(pdus[i]);  
        }  
        return msgs;  
    }  
   
}

 2、 应用观察者模式，监听短信数据库，操作短信内容。

 

优点：可以拦截来信在状态栏的显示通知，适合作短信拦截。

缺点：可以发展成 MU ，在后台悄悄的收 / 发短信。

 

实例如下：

SystemEventReceiver ：收到开机启动 OK 的广播后，启动 BootService 服务；收到应用发送短信的 INTENT 后，调用系统接口发送短信

BootService ：开启服务后，打开短信监听器

SMSObserver ：数据观察者，监听短信数据库

SMSHandler ：短信处理器

 

AndroidManifest.xml ：

 

<uses-permission android:name="android.permission.READ_SMS"></uses-permission>  
<uses-permission android:name="android.permission.WRITE_SMS"></uses-permission>  
<!-- Service -->  
<service android:name=".BootService"  
        android:label="@string/app_name">  
    <intent-filter>  
                <action android:name="org.anymobile.test.service.IMICHAT" />  
    <category android:name="android.intent.category.DEFAULT" />  
</intent-filter>  
</service>  
<!-- Receiver -->  
<receiver android:name=".SystemEventReceiver">  
<intent-filter>  
    <action android:name="android.intent.action.BOOT_COMPLETED" />  
</intent-filter>  
</receiver>

 code ：

 

package org.anymobile.demo.sms;  
   
import android.content.ContentUris;  
import android.content.Context;  
import android.content.Intent;  
import android.net.Uri;  
import android.os.Handler;  
import android.os.Message;  
import android.util.Log;  
   
public class SMSHandler extends Handler  
{  
    public static final String TAG = "SMSHandler";  
   
    private Context mContext;  
     
    public SMSHandler(Context context)  
    {  
       super();  
       this.mContext = context;  
    }  
     
    public void handleMessage(Message message)  
    {  
       Log.i(TAG,  "handleMessage: " + message);  
        
       MessageItem item = (MessageItem) message.obj;  
       //delete the sms  
       Uri uri = ContentUris.withAppendedId(SMS.CONTENT_URI, item.getId());  
       mContext.getContentResolver().delete(uri, null, null);  
       Log.i(TAG,  "delete sms item: " + item);  
    }  
}

 package org.anymobile.demo.sms;

 

   
import android.content.ContentResolver;  
import android.database.ContentObserver;  
import android.database.Cursor;  
import android.os.Handler;  
import android.os.Message;  
import android.util.Log;  
   
public class SMSObserver extends ContentObserver  
{  
    public static final String TAG = "SMSObserver";  
     
    private static final String[] PROJECTION = new String[]  
    {  
    SMS._ID,//0  
        SMS.TYPE,//1  
        SMS.ADDRESS,//2  
        SMS.BODY,//3  
        SMS.DATE,//4  
        SMS.THREAD_ID,//5  
        SMS.READ,//6  
        SMS.PROTOCOL//7  
    };  
    private static final String SELECTION =  
    SMS._ID  + " > %s" +  
//      " and " + SMS.PROTOCOL + " = null" +  
//      " or " + SMS.PROTOCOL + " = " + SMS.PROTOCOL_SMS + ")" +  
    " and (" + SMS.TYPE + " = " + SMS.MESSAGE_TYPE_INBOX +  
    " or " + SMS.TYPE + " = " + SMS.MESSAGE_TYPE_SENT + ")";  
     
    private static final int COLUMN_INDEX_ID    = 0;  
    private static final int COLUMN_INDEX_TYPE  = 1;  
    private static final int COLUMN_INDEX_PHONE = 2;  
    private static final int COLUMN_INDEX_BODY  = 3;  
    private static final int COLUMN_INDEX_PROTOCOL = 7;  
   
    private static final int MAX_NUMS = 10;  
    private static int MAX_ID = 0;  
   
    private ContentResolver mResolver;  
    private Handler mHandler;  
     
    public SMSObserver(ContentResolver contentResolver, Handler handler)  
    {  
       super(handler);  
        
       this.mResolver = contentResolver;  
       this.mHandler = handler;  
    }  
   
    @Override  
    public void onChange(boolean selfChange)  
    {  
       Log.i(TAG, "onChange : " + selfChange + "; " + MAX_ID + "; " + SELECTION);  
       super.onChange(selfChange);  
         
        Cursor cursor = mResolver.query(SMS.CONTENT_URI, PROJECTION,  
        String.format(SELECTION, MAX_ID), null, null);  
         
        int id, type, protocol;  
        String phone, body;  
        Message message;  
        MessageItem item;  
         
        int iter = 0;  
        boolean hasDone = false;  
         
        while (cursor.moveToNext())  
        {  
        id = cursor.getInt(COLUMN_INDEX_ID);  
        type = cursor.getInt(COLUMN_INDEX_TYPE);  
        phone = cursor.getString(COLUMN_INDEX_PHONE);  
        body = cursor.getString(COLUMN_INDEX_BODY);  
        protocol = cursor.getInt(COLUMN_INDEX_PROTOCOL);  
            
        if (hasDone)  
        {  
             MAX_ID = id;  
             break;  
        }  
        if (protocol == SMS.PROTOCOL_SMS && body != null && body.startsWith(SMS.FILTER))  
        {  
             hasDone = true;  
              
            item = new MessageItem();  
            item.setId(id);  
            item.setType(type);  
            item.setPhone(phone);  
            item.setBody(body);  
            item.setProtocol(protocol);  
             
            message = new Message();  
               message.obj = item;  
               mHandler.sendMessage(message);  
        }  
        else  
        {  
              if (id > MAX_ID) MAX_ID = id;  
        }  
        if (iter > MAX_NUMS) break;  
        iter ++;  
        }  
    }  
}

 package org.anymobile.demo.sms; 

   
import android.net.Uri;  
import android.provider.BaseColumns;  
   
public interface SMS extends BaseColumns  
{  
    public static final Uri CONTENT_URI = Uri.parse("content://sms");  
    public static final String FILTER  = "!imichat";  
     
    public static final String TYPE = "type";  
    public static final String THREAD_ID = "thread_id";  
    public static final String ADDRESS = "address";  
    public static final String PERSON_ID = "person";  
    public static final String DATE = "date";  
    public static final String READ = "read";  
    public static final String BODY = "body";  
    public static final String PROTOCOL = "protocol";  
   
    public static final int MESSAGE_TYPE_ALL    = 0;  
    public static final int MESSAGE_TYPE_INBOX  = 1;  
    public static final int MESSAGE_TYPE_SENT   = 2;  
    public static final int MESSAGE_TYPE_DRAFT  = 3;  
    public static final int MESSAGE_TYPE_OUTBOX = 4;  
    public static final int MESSAGE_TYPE_FAILED = 5; // for failed outgoing messages  
    public static final int MESSAGE_TYPE_QUEUED = 6; // for messages to send later  
     
    public static final int PROTOCOL_SMS = 0;//SMS_PROTO  
    public static final int PROTOCOL_MMS = 1;//MMS_PROTO  
}

 package org.anymobile.demo.sms; 

   
public class MessageItem implements java.io.Serializable  
{  
    private static final long serialVersionUID = 1L;  
     
    private int id;  
    private int type;  
    private int protocol;  
    private String phone;  
    private String body;  
     
    public MessageItem()  
    {}  
   
    public int getId()  
    {  
       return id;  
    }  
   
    public void setId(int id)  
    {  
       this.id = id;  
    }  
   
    public int getType()  
    {  
       return type;  
    }  
   
    public void setType(int type)  
    {  
       this.type = type;  
    }  
   
    public int getProtocol()  
    {  
       return protocol;  
    }  
   
    public void setProtocol(int protocol)  
    {  
       this.protocol = protocol;  
    }  
   
    public String getPhone()  
    {  
       return phone;  
    }  
   
    public void setPhone(String phone)  
    {  
       this.phone = phone;  
    }  
   
    public String getBody()  
    {  
       return body;  
    }  
   
    public void setBody(String body)  
    {  
       this.body = body;  
    }  
     
    public String toString()  
    {  
       return  
           "id = " + id + ";" +  
           "type = " + type + ";" +  
           "protocol = " + protocol + ";" +  
           "phone = " + phone + ";" +  
           "body = " + body;  
    }  
}

 package org.anymobile.demo; 

   
import android.app.Service;  
import android.content.ContentResolver;  
import android.content.Intent;  
import android.database.ContentObserver;  
import android.os.Handler;  
import android.os.IBinder;  
import android.os.Process;  
import android.util.Log;  
   
import org.anymobile.demo.sms.SMS;  
import org.anymobile.demo.sms.SMSHandler;  
import org.anymobile.demo.sms.SMSObserver;  
   
public class BootService extends Service  
{  
    public static final String TAG = "BootService";  
     
    private ContentObserver mObserver;  
   
    private Handler mHandler = new Handler();  
     
    @Override  
    public void onCreate()  
    {  
       Log.i(TAG, "onCreate().");  
       super.onCreate();  
        
       addSMSObserver();  
    }  
     
    public void addSMSObserver()  
    {  
       Log.i(TAG, "add a SMS observer. ");  
        
       ContentResolver resolver = getContentResolver();  
        
       Handler handler = new SMSHandler(this);  
       mObserver = new SMSObserver(resolver, handler);  
       resolver.registerContentObserver(SMS.CONTENT_URI, true, mObserver);  
    }  
   
    @Override  
    public IBinder onBind(Intent intent)  
    {  
       return null;  
    }  
   
    @Override  
    public void onDestroy()  
    {  
       Log.i(TAG, "onDestroy().");  
        
        this.getContentResolver().unregisterContentObserver(mObserver);  
        
       super.onDestroy();  
   
        Process.killProcess(Process.myPid());  
       System.exit(0);  
    }  
}

 package org.anymobile.demo; 

   
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
//import android.os.Handler;  
//import android.os.Message;  
import android.telephony.gsm.SmsManager;  
   
import org.anymobile.demo.sms.MessageItem;  
   
public class SystemEventReceiver extends BroadcastReceiver  
{  
    @Override  
    public void onReceive(Context context, Intent intent)  
    {  
       if (intent.getAction().equals(Intent.ACTION_BOOT_COMPLETED))  
       {  
           context.startService(new Intent(Globals.IMICHAT_SERVICE));  
       }  
       else if (intent.getAction().equals(Globals.ACTION_SEND_SMS))  
       {  
           MessageItem mItem =  
              (MessageItem) intent.getSerializableExtra(Globals.EXTRA_SMS_DATA);  
           if (mItem != null && mItem.getPhone() != null && mItem.getBody() != null)  
           {  
              SmsManager.getDefault()  
                  .sendTextMessage(mItem.getPhone(), null,  
                     mItem.getBody(), null, null);  
//            new Thread(mTasks).start();  
           }  
       }  
    }  
}
分享到：
| 获取Android的Java源代码并在Eclipse中关 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Android上监听收到的短信(SMS)

    本文将详细介绍两种主要方法：通过广播监听短信消息和通过短信数据库获取短信内容。 **方式一：通过广播监听短信消息** 在Android系统中，可以通过注册一个BroadcastReceiver来监听系统的Intent，特别是ACTION_SMS...

    Android之发送短信的两种方式

    在Android平台上，发送短信是应用程序与用户交互的重要方式之一，主要分为两种方法：直接调用系统短信接口发送和启动系统短信应用。这两种方法各有特点，适用于不同的场景。 1. 调用系统短信接口直接发送短信 这种...

    Android中监听短信的两种方法

    在Android系统中，监听短信通常有两种方法：通过注册BroadcastReceiver监听SMS_RECEIVED_ACTION广播和使用ContentObserver监控短信数据库。这两种方法各有优缺点，下面将详细解释它们的工作原理和实现方式。 1. ...

    Android广播监听机制的两种实现方法.pdf

    本文将深入探讨Android广播监听的两种实现方法，并通过手机短信监听实例进行对比，为实际开发提供指导。 一、广播监听机制简介 Android广播是操作系统用来通知所有感兴趣的程序某些特定事件发生的一种机制。这些...

    PC通过wifi或者USB管理android手机上的短信

    标题中的“PC通过WiFi或者USB管理Android手机上的短信”揭示了一个技术方案，即利用计算机（PC）远程控制或同步Android设备上的短信功能。这个系统由两大部分构成：Android端的应用和PC端的Swing程序。 在Android端...

    Android高级应用源码-广播监听短信并获取短信内容.zip

    这个"Android高级应用源码-广播监听短信并获取短信内容.zip"的项目，显然涉及到如何通过自定义的BroadcastReceiver来监听并处理短信相关的事件。以下是关于这个主题的详细知识点： 1. **BroadcastReceiver基础**： ...

    Android中监听电话状态.zip

    在Android系统中，监听电话状态是一项重要的功能，它允许开发者获取到电话的实时信息，比如来电、去电、通话结束等事件。这项功能通常应用于电话录音、来电管理、短信拦截等场景。本教程将深入探讨如何在Android应用...

    Android短信验证码监听解决onChange多次调用的方法

    在Android开发中，短信验证码是身份验证的一种常见方式，特别是在移动应用中。为了实现这个功能，开发者需要监听手机接收到的短信，并从中提取出验证码。然而，在实际操作中，可能会遇到一些挑战，如onChange方法的...

    基于Android,后台监听机制的程序实现.docx

    这种监听机制可以通过两种主要的方式实现：BroadcastReceiver和Service。 - **BroadcastReceiver**：这是一种专门用于接收系统或应用广播的组件。它可以监听并响应特定的系统事件，例如接收到新短信、拨打电话等。 ...

    Android最基本的发短信打电话

    本文将深入探讨如何在Android应用中实现这两种通信方式。 首先，我们要了解Android的权限管理。在AndroidManifest.xml文件中，必须添加相应的权限声明，才能允许应用程序进行短信发送和电话拨打。对于发送短信，...

    简易的android短信管理器代码

    在Android平台上，开发一个简易的短信管理器是常见的任务，涉及到的主要知识点包括Android系统的权限管理、BroadcastReceiver（广播接收者）、SMSManager类以及UI设计。下面将详细解释这些概念及其在实现短信管理器...

    android BroadcastReceiver实验，短信接收

    我们需要添加ACTION_SMS_RECEIVED的权限到AndroidManifest.xml，因为监听短信需要这个特殊的权限。 ```xml &lt;uses-permission android:name="android.permission.RECEIVE_SMS" /&gt; ``` 在onReceive()方法中，我们...

    android读取短信验证码自动填入

    接下来，我们要监听短信的接收。在Android中，我们可以通过注册BroadcastReceiver来实现。创建一个名为SmsReceiver的BroadcastReceiver类，并重写onReceive方法： ```java public class SmsReceiver extends ...

    Android拦截陌生人号码短信

    总结来说，Android拦截陌生人号码短信主要依赖于BroadcastReceiver组件，通过监听`android.provider.Telephony.SMS_RECEIVED`广播事件来实现。当接收到短信时，BroadcastReceiver的onReceive()方法会被调用，我们...

    Android短信发送源码

    这个"Android短信发送源码"示例为你提供了一种简单易懂的方法来实现这一功能。下面将详细讲解相关知识点，包括Android SMS API的使用、权限管理以及实际的代码实现。 首先，Android系统为发送短信提供了`SmsManager...

    android中可以通过两种方式调用接口发送短信

    在Android系统中，有两种主要的方法来发送短信。第一种是通过直接调用系统短信接口，而第二种则是启动系统的短信发送界面。...以上就是Android中调用接口发送短信的两种方式，开发者可以根据实际需求选择合适的方法。

    Android中采用广播接收者实现短信监控器、拦截外拨电话功能案例

    在这个“Android中采用广播接收者实现短信监控器、拦截外拨电话功能案例”中，我们将探讨如何利用BroadcastReceiver来监控手机中的短信和电话事件。 首先，我们需要创建一个BroadcastReceiver的子类，比如`...

    Android短信过滤

    有两种主要方式实现后台运行： 1. **Service**：创建一个Service，启动后持续运行。在Service中注册BroadcastReceiver，这样即使应用主界面关闭，BroadcastReceiver也能接收到短信广播。 2. **IntentService**：...

    Android手机号码归属地查询demo

    在Android开发中，有时我们需要实现一个功能，即查询手机号码的归属地，这对于垃圾短信过滤、用户信息验证等场景非常有用。本项目就是一个基于Volley框架实现的Android手机号码归属地查询的示例（demo）。Volley是...

    Android开发中通过手机号+短信验证码登录的实例代码

    Android开发中，手机号+短信验证码登录是非常常见的一种登录方式。下面，我们将通过实例代码来实现手机号+短信验证码登录的功能。 首先，我们需要在activity_login.xml文件中添加相应的控件，包括 手机号EditText、...

Magicbox
Global site tag (gtag.js) - Google Analytics