拦截，阅读和取消短信

Question

我正在寻找一种方法来挂钩SMSManager或更低级别的机制，这样我就可以拦截，阅读并取消发送之前的任何传出的SMS消息。

Answer 1

很明显，这不是你想听到的，但是Android的设计根本不是允许第三方应用程序互相干扰或者超越用户的自由选择。

它没有提供一个“hook”类型的机制来强制拦截基本功能，而不是修改安装在设备上的Android本身的内部版本。

设备管理员界面不包含管理短信的任何内容。

是的，有时候人们会使用各种“黑客”方法在某种程度上完成这些事情，但它们与平台的设计相悖，因此或者在不同的“错误修复”类型改进时不可靠或可能中断是由android制作的。或者他们的范围受到限制，例如更换主屏幕，从而限制轻松启动的内容 - 但只有在主屏幕应用程序保持选定状态，并且无法规范其他意图源的情况下。

您可能会发现在头脑的思想足够的吸引力，你决定要运行它，但记住，除非它是一个未来的介绍打算做这种事情的API 你最有可能被利用的监督，很可能会很快纠正平台的设计。

Answer 2

妥协怎么样？为什么不创建一个应用程序来写短信？用户可以选择它作为写短信的默认应用程序，所以它不会一直困扰他们。我相信，只有这样，才能实现接近您的目标而无需生根/提供您自己的Android版本。

Answer 3

犹未晚之后再也没有:)

我把时间用在这2个天... ...而且不希望其他任何浪费自己的时间:)

1. 拨打服务，以及注册内容观察者在服务类

UPDATE：加入SMS模型类

 public class SMS { 
     public Date date; 
     public String from; 
     public String message; 
     public String to; 

     public SMS(String paramString1, String paramString2, String paramString3,Date paramDate) { 
      this.from = paramString1; 
      this.to = paramString2; 
      this.message = paramString3; 
      this.date = paramDate; 
     } 
    } 

---

public class ServiceClass extends Service implements SMSListener { 
    public static boolean sendSms = true; 
    private final IBinder mBinder = new LocalBinder(); 
    public static MyContentObserver mSMSObserver; 
    private Context ctx; 
    public static SMS param_SMS; 
    int myID = -1; 

    @Override 
    public int onStartCommand(Intent intent, int flags, int startId) { 
      // TODO Auto-generated method stub 

      myID = startId; 
      sendSms = true; 
      Context localContext = getApplicationContext(); 
      ctx = localContext; 

      mSMSObserver = new MyContentObserver(null); 
      mSMSObserver.setSMSListener(this); 
      mSMSObserver.start(localContext); 

      return Service.START_STICKY; 
    } 

     @Override 
     public void onDestroy() { 
      // TODO Auto-generated method stub 
      SharedPreferences prefs = getApplicationContext().getSharedPreferences(
        "appData", 0); 

      if (prefs.getBoolean(CommonStrings.KEY_PREFS_TOGGLE, false)) { 

       super.onDestroy(); 
       Log.e("OnDestroy", "Stopping Service"); 
       Context localContext = getApplicationContext(); 
       mSMSObserver.stop(localContext); 

       try { 
        stopSelf(myID); 
        Log.e("Stopping self", "Stopping Service"); 
       } catch (Exception e) { 
        e.printStackTrace(); 
       } 
      } 
     } 

     @Override 
     public IBinder onBind(Intent intent) { 
      // TODO Auto-generated method stub 
      Log.e("OnBinder", "OnBinder"); 
      return null; 
     } 

     @Override 
     public void reportIncomingSms(SMS paramSMS) { 
      // TODO Auto-generated method stub 

     } 

     public void reportOutgoingSms(SMS paramSMS) { 
      if (!MainActivity.stopped) { 
       Log.e("OUT GOING SMS DETECTED", "OUT GOING SMS DETECTED"); 
       sendSms = true; 
       param_SMS = paramSMS; 

       // DO ANY THING, Out going Msg detected... 

      } 
     } 

     public class LocalBinder extends Binder { 
      public LocalBinder() { 
      } 

      public ServiceClass getService() { 
       return ServiceClass.this; 
      } 
     } 
    } 

扩展内容观察员

public class MyContentObserver extends ContentObserver { 

public static final int MESSAGE_TYPE_ALL = 0; 
public static final int MESSAGE_TYPE_DRAFT = 3; 
public static final int MESSAGE_TYPE_FAILED = 5; 
public static final int MESSAGE_TYPE_INBOX = 1; 
public static final int MESSAGE_TYPE_OUTBOX = 4; 
public static final int MESSAGE_TYPE_QUEUED = 6; 
public static final int MESSAGE_TYPE_SENT = 2; 
public static final String TYPE = "type"; 
private SMSListener mSMSListener; 
public static long _id; 
private ContentObserver observer; 
    public MyContentObserver(Handler handler) { 
    super(handler); 
    // TODO Auto-generated constructor stub 
    } 
    private void readFromOutgoingSMS(Context paramContext) { 
    if (!MainActivity.stopped) { 
     Cursor localCursor = paramContext.getContentResolver().query(
     Uri.parse("content://sms"), null, null, null, null); 
     long l = 0; 
     int i; 
     if (localCursor.moveToNext()) { 
      l = localCursor.getLong(localCursor.getColumnIndex("_id")); 
      String str1 = localCursor.getString(localCursor 
        .getColumnIndex("protocol")); 
      i = localCursor.getInt(localCursor.getColumnIndex("type")); 
      if ((str1 != null) || (i != 6)) 
       localCursor.close(); 
       if (i == 6) { 
       int j = localCursor.getColumnIndex("body"); 
       int k = localCursor.getColumnIndex("address"); 
       Date localDate = new Date(localCursor.getLong(localCursor 
         .getColumnIndex("date"))); 
       String str2 = localCursor.getString(k); 
       String str3 = localCursor.getString(j); 
       localCursor.close(); 
        _id = l; 
        // Delete SMS and Save the sms content to custom type variable 
       if (deleteSms(paramContext, l)) { 
        SMS localSMS = new SMS("", str2, str3, localDate); 
        this.mSMSListener.reportOutgoingSms(localSMS); 
       } else { 
        localCursor.close(); 
       } 
      } 
     } 
    } 
} 

public static boolean deleteSms(Context paramContext, long paramLong) { 
    Uri localUri = ContentUris.withAppendedId(Uri.parse("content://sms"), 
      paramLong); 
    boolean bool = false; 
    if (localUri != null) { 
     try { 
      int j = paramContext.getContentResolver().delete(localUri, 
        null, null); 
      if (j == 1) 
       bool = true; 
      else 
       bool = false; 
     } catch (Exception localException) { 
      localException.printStackTrace(); 
      bool = false; 
     } 
    } 
    return bool; 
} 

private void registerContentObserver(final Context paramContext) { 
     this.observer = new ContentObserver(null) { 
       public void onChange(boolean paramAnonymousBoolean) { 
        readFromOutgoingSMS(paramContext); 
       } 
      }; 
      paramContext.getContentResolver().registerContentObserver(
       Uri.parse("content://sms"), true, this.observer); 
     } 
      public void setSMSListener(SMSListener paramSMSListener) { 
      this.mSMSListener = paramSMSListener; 
     } 
     public void start(Context paramContext) { 
      registerContentObserver(paramContext); 
      listenForIncomingSms(paramContext); 
     } 

     public void stop(Context paramContext) { 
      paramContext.getContentResolver().unregisterContentObserver(
        this.observer); 
     } 
     private void listenForIncomingSms(Context paramContext) { 
     //..... 
     } 

} 

SMS听者

public abstract interface SMSListener { 
public abstract void reportIncomingSms(SMS paramSMS); 

public abstract void reportOutgoingSms(SMS paramSMS); 
    } 

所需权限：

<uses-permission android:name="android.permission.READ_SMS" /> 
    <uses-permission android:name="android.permission.READ_CONTACTS" />