bestsource

Android에서 단말기의 SMS 메시지를 프로그래밍 방식으로 읽는 방법은 무엇입니까?

bestsource 2023. 8. 27. 09:42
반응형

Android에서 단말기의 SMS 메시지를 프로그래밍 방식으로 읽는 방법은 무엇입니까?

단말기에서 SMS 메시지를 검색하여 표시하시겠습니까?

받은 편지함에 있는 SMS를 읽으려면 Content Resolver("content://sms/inbox")를 사용합니다.

// public static final String INBOX = "content://sms/inbox";
// public static final String SENT = "content://sms/sent";
// public static final String DRAFT = "content://sms/draft";
Cursor cursor = getContentResolver().query(Uri.parse("content://sms/inbox"), null, null, null, null);

if (cursor.moveToFirst()) { // must check the result to prevent exception
    do {
       String msgData = "";
       for(int idx=0;idx<cursor.getColumnCount();idx++)
       {
           msgData += " " + cursor.getColumnName(idx) + ":" + cursor.getString(idx);
       }
       // use msgData
    } while (cursor.moveToNext());
} else {
   // empty box, no SMS
}

READ_를 추가하십시오.SMS 권한.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        final String myPackageName = getPackageName();
        if (!Telephony.Sms.getDefaultSmsPackage(this).equals(myPackageName)) {

            Intent intent = new Intent(Telephony.Sms.Intents.ACTION_CHANGE_DEFAULT);
            intent.putExtra(Telephony.Sms.Intents.EXTRA_PACKAGE_NAME, myPackageName);
            startActivityForResult(intent, 1);
        }else {
            List<Sms> lst = getAllSms();
        }
    }else {
        List<Sms> lst = getAllSms();
    }

앱을 기본 SMS 앱으로 설정

    @Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == 1) {
    if (resultCode == RESULT_OK) {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            final String myPackageName = getPackageName();
            if (Telephony.Sms.getDefaultSmsPackage(mActivity).equals(myPackageName)) {

                List<Sms> lst = getAllSms();
            }
        }
    }
}
}

SMS를 받는 기능

public List<Sms> getAllSms() {
    List<Sms> lstSms = new ArrayList<Sms>();
    Sms objSms = new Sms();
    Uri message = Uri.parse("content://sms/");
    ContentResolver cr = mActivity.getContentResolver();

    Cursor c = cr.query(message, null, null, null, null);
    mActivity.startManagingCursor(c);
    int totalSMS = c.getCount();

    if (c.moveToFirst()) {
        for (int i = 0; i < totalSMS; i++) {

            objSms = new Sms();
            objSms.setId(c.getString(c.getColumnIndexOrThrow("_id")));
            objSms.setAddress(c.getString(c
                    .getColumnIndexOrThrow("address")));
            objSms.setMsg(c.getString(c.getColumnIndexOrThrow("body")));
            objSms.setReadState(c.getString(c.getColumnIndex("read")));
            objSms.setTime(c.getString(c.getColumnIndexOrThrow("date")));
            if (c.getString(c.getColumnIndexOrThrow("type")).contains("1")) {
                objSms.setFolderName("inbox");
            } else {
                objSms.setFolderName("sent");
            }

            lstSms.add(objSms);
            c.moveToNext();
        }
    }
    // else {
    // throw new RuntimeException("You have no SMS");
    // }
    c.close();

    return lstSms;
}

SMS 클래스는 다음과 같습니다.

public class Sms{
private String _id;
private String _address;
private String _msg;
private String _readState; //"0" for have not read sms and "1" for have read sms
private String _time;
private String _folderName;

public String getId(){
return _id;
}
public String getAddress(){
return _address;
}
public String getMsg(){
return _msg;
}
public String getReadState(){
return _readState;
}
public String getTime(){
return _time;
}
public String getFolderName(){
return _folderName;
}


public void setId(String id){
_id = id;
}
public void setAddress(String address){
_address = address;
}
public void setMsg(String msg){
_msg = msg;
}
public void setReadState(String readState){
_readState = readState;
}
public void setTime(String time){
_time = time;
}
public void setFolderName(String folderName){
_folderName = folderName;
}

}

AndroidManifest.xml에서 권한을 정의하는 것을 잊지 마십시오.

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

이것은 사소한 과정입니다.소스 코드 SMS 팝업에서 좋은 예를 볼 수 있습니다.

다음 방법을 검토합니다.

SmsMmsMessage getSmsDetails(Context context, long ignoreThreadId, boolean unreadOnly)
long findMessageId(Context context, long threadId, long _timestamp, int messageType
void setMessageRead(Context context, long messageId, int messageType)
void deleteMessage(Context context, long messageId, long threadId, int messageType)

판독 방법은 다음과 같습니다.

SmsMmsMessage getSmsDetails(Context context,
                            long ignoreThreadId, boolean unreadOnly)
{
   String SMS_READ_COLUMN = "read";
   String WHERE_CONDITION = unreadOnly ? SMS_READ_COLUMN + " = 0" : null;
   String SORT_ORDER = "date DESC";
   int count = 0;
   // Log.v(WHERE_CONDITION);
   if (ignoreThreadId > 0) {
      // Log.v("Ignoring sms threadId = " + ignoreThreadId);
      WHERE_CONDITION += " AND thread_id != " + ignoreThreadId;
   }
   Cursor cursor = context.getContentResolver().query(
                      SMS_INBOX_CONTENT_URI,
                      new String[] { "_id", "thread_id", "address", "person", "date", "body" },
                      WHERE_CONDITION,
                      null,
                      SORT_ORDER);
   if (cursor != null) {
      try {
         count = cursor.getCount();
         if (count > 0) {
            cursor.moveToFirst();
            // String[] columns = cursor.getColumnNames();
            // for (int i=0; i<columns.length; i++) {
            // Log.v("columns " + i + ": " + columns[i] + ": " + cursor.getString(i));
            // }                                         
            long messageId = cursor.getLong(0);
            long threadId = cursor.getLong(1);
            String address = cursor.getString(2);
            long contactId = cursor.getLong(3);
            String contactId_string = String.valueOf(contactId);
            long timestamp = cursor.getLong(4);

            String body = cursor.getString(5);                             
            if (!unreadOnly) {
                count = 0;
            }

            SmsMmsMessage smsMessage = new SmsMmsMessage(context, address,
                          contactId_string, body, timestamp,
                          threadId, count, messageId, SmsMmsMessage.MESSAGE_TYPE_SMS);
            return smsMessage;
         }
      } finally {
         cursor.close();
      }
   }               
   return null;
}

API 19 이후부터는 전화 통신 클래스를 사용할 수 있습니다. 컨텐츠 공급자 URI가 장치 및 제조업체에서 변경되기 때문에 하드코어 값이 모든 장치에서 메시지를 검색하지는 않습니다.

public void getAllSms(Context context) {

    ContentResolver cr = context.getContentResolver();
    Cursor c = cr.query(Telephony.Sms.CONTENT_URI, null, null, null, null);
    int totalSMS = 0;
    if (c != null) {
        totalSMS = c.getCount();
        if (c.moveToFirst()) {
            for (int j = 0; j < totalSMS; j++) {
                String smsDate = c.getString(c.getColumnIndexOrThrow(Telephony.Sms.DATE));
                String number = c.getString(c.getColumnIndexOrThrow(Telephony.Sms.ADDRESS));
                String body = c.getString(c.getColumnIndexOrThrow(Telephony.Sms.BODY));
                Date dateFormat= new Date(Long.valueOf(smsDate));
                String type;
                switch (Integer.parseInt(c.getString(c.getColumnIndexOrThrow(Telephony.Sms.TYPE)))) {
                    case Telephony.Sms.MESSAGE_TYPE_INBOX:
                        type = "inbox";
                        break;
                    case Telephony.Sms.MESSAGE_TYPE_SENT:
                        type = "sent";
                        break;
                    case Telephony.Sms.MESSAGE_TYPE_OUTBOX:
                        type = "outbox";
                        break;
                    default:
                        break;
                }


                c.moveToNext();
            }
        }

        c.close();

    } else {
        Toast.makeText(this, "No message to show!", Toast.LENGTH_SHORT).show();
    }
}

오래되었지만, 이 게시물과 관련된 를 얻기 .SMSAndroid의 콘텐츠 공급자:

다음 lib 사용: https://github.com/EverythingMe/easy-content-providers

  • 모두 가져오기SMS:

    TelephonyProvider telephonyProvider = new TelephonyProvider(context);
    List<Sms> smses = telephonyProvider.getSms(Filter.ALL).getList();
    

    SMS에는 모든 필드가 있으므로 필요한 정보를 얻을 수 있습니다.
    주소, 본문, receivedDate, 유형등(INBOX, SENT, 안초),), threadId, ...

  • 올 ㅠㅠMMS:

    List<Mms> mmses = telephonyProvider.getMms(Filter.ALL).getList();
    
  • 올 ㅠㅠThread:

    List<Thread> threads = telephonyProvider.getThreads().getList();
    
  • 올 ㅠㅠConversation:

    List<Conversation> conversations = telephonyProvider.getConversations().getList();
    

은 작니다합동에서와 함께 합니다.List또는Cursor그리고 그것이 어떻게 보이고 작동하는지 볼 수 있는 샘플 앱이 있습니다.

실제로 다음과 같은 모든 Android 콘텐츠 공급자를 지원합니다.연락처, 통화 로그, 일정관리...모든 옵션이 포함된 전체 문서: https://github.com/EverythingMe/easy-content-providers/wiki/Android-providers

그것이 또한 도움이 되었기를 바랍니다 :)

여러 개의 답변이 이미 제공되고 있지만 모두 이 질문의 중요한 부분을 누락한 것 같습니다.내부 데이터베이스 또는 테이블에서 데이터를 읽기 전에 데이터가 저장되는 방식을 이해해야 합니다. 그러면 위의 질문에 대한 해결책을 찾을 수 있습니다.

Android에서 단말기의 SMS 메시지를 프로그래밍 방식으로 읽는 방법은 무엇입니까?

Android에서 SMS 표는 다음과 같습니다.

enter image description here

이제 데이터베이스에서 원하는 것을 선택할 수 있습니다.우리의 경우에는 필요한 것만

아이디,주소,본문

SMS를 읽는 경우:

1.권한을 요청

int REQUEST_PHONE_CALL = 1;

   if (ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.READ_SMS) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.READ_SMS}, REQUEST_PHONE_CALL);
        }

또는

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

2.이제 당신의 코드는 이렇게 됩니다.

// Create Inbox box URI
Uri inboxURI = Uri.parse("content://sms/inbox");

// List required columns
String[] reqCols = new String[]{"_id", "address", "body"};

// Get Content Resolver object, which will deal with Content Provider
ContentResolver cr = getContentResolver();

// Fetch Inbox SMS Message from Built-in Content Provider
Cursor c = cr.query(inboxURI, reqCols, null, null, null);

// Attached Cursor with adapter and display in listview
adapter = new SimpleCursorAdapter(this, R.layout.a1_row, c,
        new String[]{"body", "address"}, new int[]{
        R.id.A1_txt_Msg, R.id.A1_txt_Number});
lst.setAdapter(adapter);

이것이 도움이 되기를 바랍니다.감사해요.

1단계: 먼저 매니페스트 파일에 다음과 같은 권한을 추가해야 합니다.

<uses-permission android:name="android.permission.RECEIVE_SMS" android:protectionLevel="signature" />
<uses-permission android:name="android.permission.READ_SMS" />

2단계: 그런 다음 SMS 수신을 위한 서비스 SMS 수신기 클래스를 추가합니다.

<receiver android:name="com.aquadeals.seller.services.SmsReceiver">
    <intent-filter>
        <action android:name="android.provider.Telephony.SMS_RECEIVED"/>
    </intent-filter>
</receiver>

3단계: 실행 시간 권한 추가

private boolean checkAndRequestPermissions()
{
    int sms = ContextCompat.checkSelfPermission(this, Manifest.permission.READ_SMS);

    if (sms != PackageManager.PERMISSION_GRANTED)
    {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_SMS}, REQUEST_ID_MULTIPLE_PERMISSIONS);
        return false;
    }
    return true;
}

4단계: 앱에 이 클래스를 추가하고 인터페이스 클래스를 테스트합니다.

public interface SmsListener {
   public void messageReceived(String messageText);
}

SmsReceiver.java

public class SmsReceiver extends BroadcastReceiver {
    private static SmsListener mListener;
    public Pattern p = Pattern.compile("(|^)\\d{6}");
    @Override
    public void onReceive(Context context, Intent intent) {
        Bundle data  = intent.getExtras();
        Object[] pdus = (Object[]) data.get("pdus");
        for(int i=0;i<pdus.length;i++)
        {
            SmsMessage smsMessage = SmsMessage.createFromPdu((byte[]) pdus[i]);
            String sender = smsMessage.getDisplayOriginatingAddress();
            String phoneNumber = smsMessage.getDisplayOriginatingAddress();
            String senderNum = phoneNumber ;
            String messageBody = smsMessage.getMessageBody();
            try{
                if(messageBody!=null){
                    Matcher m = p.matcher(messageBody);
                    if(m.find()) {
                        mListener.messageReceived(m.group(0));
                    }
                }
            }
            catch(Exception e){}
        }
    }
    public static void bindListener(SmsListener listener) {
        mListener = listener; 
    }
}

Google Play 서비스에는 SMS 기반 검증 프로세스를 간소화하는 데 사용할 수 있는 두 가지 API가 있습니다.

SMS 리트리버 API

사용자가 수동으로 확인 코드를 입력하거나 추가 앱 권한을 요구하지 않고 완전히 자동화된 사용자 환경을 제공하며 가능한 경우 사용해야 합니다.그러나 메시지 본문에 사용자 정의 해시 코드를 배치해야 하므로 서버 측도 제어할 수 있어야 합니다.

  • 메시지 요구 사항 - 앱을 고유하게 식별하는 11자리 해시 코드
  • 보낸 사람 요구 사항 - 없음
  • 사용자 상호 작용 - 없음

Android 앱에서 SMS 확인 요청

서버에서 SMS 확인 수행

SMS 사용자 동의 API

사용자 지정 해시 코드가 필요하지 않지만 사용자가 확인 코드가 포함된 메시지에 액세스하려면 앱의 요청을 승인해야 합니다.를 전달할 SMS User Consent사용자의 연락처 목록에 있는 보낸 사람의 메시지를 필터링합니다.

  • 메시지 요구 사항 - 하나 이상의 숫자를 포함하는 4-10자리 영숫자 코드
  • 발송인 요구사항 - 발송인은 사용자의 연락처 목록에 있을 수 없습니다.
  • 사용자 상호 작용 - 원탭으로 승인

The SMS User Consent API는 Google Play 서비스의 일부입니다. 버전이 할 것입니다.17.0.0다음 라이브러리 중:

implementation "com.google.android.gms:play-services-auth:17.0.0"
implementation "com.google.android.gms:play-services-auth-api-phone:17.1.0"

1단계: SMS 메시지 듣기 시작

SMS 사용자 동의는 일회성 코드가 포함된 수신 SMS 메시지를 최대 5분 동안 수신합니다.시작하기 전에 전송된 메시지를 확인하지 않습니다.코드를 , ▁the▁if▁number▁specify다를 지정할 수 .senderPhoneNumberㅠㅠㅠㅠㅠㅠㅠnull모든 숫자와 일치합니다.

 smsRetriever.startSmsUserConsent(senderPhoneNumber /* or null */)

2단계: 메시지 읽기 동의 요청

앱이 일회성 코드가 포함된 메시지를 수신하면 브로드캐스트를 통해 알림이 표시됩니다.이 시점에서 메시지를 읽을 수 있는 동의가 없습니다. 대신 다음 메시지가 표시됩니다.Intent사용자에게 동의를 요청할 수 있습니다.의 용자내 에.BroadcastReceiver다음을 사용하여 프롬프트를 표시합니다.Intent에서extras이 의도를 시작하면 사용자에게 단일 메시지를 읽을 수 있는 권한을 묻는 메시지가 표시됩니다.앱과 공유할 전체 텍스트가 표시됩니다.

val consentIntent = extras.getParcelable<Intent>(SmsRetriever.EXTRA_CONSENT_INTENT)
startActivityForResult(consentIntent, SMS_CONSENT_REQUEST)

enter image description here

3단계: 일회용 코드 구문 분석 및 SMS 확인 완료

사용자가 클릭할 때“Allow”메시지를 실제로 읽을 시간입니다!내부onActivityResult데이터에서 SMS 메시지의 전체 텍스트를 가져올 수 있습니다.

val message = data.getStringExtra(SmsRetriever.EXTRA_SMS_MESSAGE)

그런 다음 SMS 메시지를 구문 분석하고 일회성 코드를 백엔드로 전달합니다!

가장 쉬운 기능

SMS를 읽기 위해 Conversation 객체를 반환하는 함수를 작성했습니다.

class Conversation(val number: String, val message: List<Message>)
class Message(val number: String, val body: String, val date: Date)

fun getSmsConversation(context: Context, number: String? = null, completion: (conversations: List<Conversation>?) -> Unit) {
        val cursor = context.contentResolver.query(Telephony.Sms.CONTENT_URI, null, null, null, null)

        val numbers = ArrayList<String>()
        val messages = ArrayList<Message>()
        var results = ArrayList<Conversation>()

        while (cursor != null && cursor.moveToNext()) {
            val smsDate = cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Sms.DATE))
            val number = cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Sms.ADDRESS))
            val body = cursor.getString(cursor.getColumnIndexOrThrow(Telephony.Sms.BODY))

            numbers.add(number)
            messages.add(Message(number, body, Date(smsDate.toLong())))
        }

        cursor?.close()

        numbers.forEach { number ->
            if (results.find { it.number == number } == null) {
                val msg = messages.filter { it.number == number }
                results.add(Conversation(number = number, message = msg))
            }
        }

        if (number != null) {
            results = results.filter { it.number == number } as ArrayList<Conversation>
        }

        completion(results)
    }

사용:

getSmsConversation(this){ conversations ->
    conversations.forEach { conversation ->
        println("Number: ${conversation.number}")
        println("Message One: ${conversation.message[0].body}")
        println("Message Two: ${conversation.message[1].body}")
    }
}

또는 특정 번호의 대화만 받습니다.

getSmsConversation(this, "+33666494128"){ conversations ->
    conversations.forEach { conversation ->
        println("Number: ${conversation.number}")
        println("Message One: ${conversation.message[0].body}")
        println("Message Two: ${conversation.message[1].body}")
    }
}

SMS를 읽을 코틀린 코드:

1 - AndroidManifest.xml에 이 권한을 추가합니다.

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

2-브로드캐스트 수신기 클래스 만들기:

package utils.broadcastreceivers

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.telephony.SmsMessage
import android.util.Log

class MySMSBroadCastReceiver : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
    var body = ""
    val bundle = intent?.extras
    val pdusArr = bundle!!.get("pdus") as Array<Any>
    var messages: Array<SmsMessage?>  = arrayOfNulls(pdusArr.size)

 // if SMSis Long and contain more than 1 Message we'll read all of them
    for (i in pdusArr.indices) {
        messages[i] = SmsMessage.createFromPdu(pdusArr[i] as ByteArray)
    }
      var MobileNumber: String? = messages[0]?.originatingAddress
       Log.i(TAG, "MobileNumber =$MobileNumber")         
       val bodyText = StringBuilder()
        for (i in messages.indices) {
            bodyText.append(messages[i]?.messageBody)
        }
        body = bodyText.toString()
        if (body.isNotEmpty()){
       // Do something, save SMS in DB or variable , static object or .... 
                       Log.i("Inside Receiver :" , "body =$body")
        }
    }
 }

3-Android 6 이상인 경우 SMS 권한 획득:

   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && 
    ActivityCompat.checkSelfPermission(context!!,
            Manifest.permission.RECEIVE_SMS
        ) != PackageManager.PERMISSION_GRANTED
    ) { // Needs permission

            requestPermissions(arrayOf(Manifest.permission.RECEIVE_SMS),
            PERMISSIONS_REQUEST_READ_SMS
        )

    } else { // Permission has already been granted

    }

4 - 이 요청 코드를 활동 또는 조각에 추가합니다.

 companion object {
    const val PERMISSIONS_REQUEST_READ_SMS = 100
   }

5 - 확인 권한 재지정 요청 결과 fun:

 override fun onRequestPermissionsResult(
    requestCode: Int, permissions: Array<out String>,
    grantResults: IntArray
) {
    when (requestCode) {

        PERMISSIONS_REQUEST_READ_SMS -> {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Log.i("BroadCastReceiver", "PERMISSIONS_REQUEST_READ_SMS Granted")
            } else {
                //  toast("Permission must be granted  ")
            }
        }
    }
}
String WHERE_CONDITION = unreadOnly ? SMS_READ_COLUMN + " = 0" : null;

변경자:

String WHERE_CONDITION = unreadOnly ? SMS_READ_COLUMN + " = 0 " : SMS_READ_COLUMN + " = 1 ";

1개의 Python 기능이 있는 모든 SMS 메시지 가져오기:

는 f-droid에서 SMS 가져오기/내보내기를 설치한 다음 USB를 사용하여 전화기에서 PC로 SMS 파일을 가져오는 파이썬 기능을 작성했습니다.adb.

"""Ensures sms messages can be read through adb."""
import hashlib
import os
import time
from typing import List

import requests  # type: ignore[import]

from src.helper import create_and_write_file, load_dict_from_file
from src.sender.helper_sms import cmd_res, device_ready


def sms_ie_config_content(int_time: int, output_dir: str) -> List[str]:
    """Creates the sms_ie .xml config file content to schedule an export at the
    time: int time.

    int_time contains the number of minutes after midnight on which an
    sms export is scheduled.

    :param int_time: int:
    :param output_dir: str:
    :param int_time: int:
    :param output_dir: str:

    """

    content = [
        "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>",
        "<map>",
        '    <boolean name="include_binary_data" value="true" />',
        '    <boolean name="mms" value="true" />',
        '    <string name="max_messages"></string>',
        '    <boolean name="schedule_export" value="true" />',
        '    <boolean name="sms" value="true" />',
        '    <boolean name="debugging" value="false" />',
        '    <boolean name="export_call_logs" value="true" />',
        f'    <int name="export_time" value="{int_time}" />',
        '    <boolean name="export_messages" value="true" />',
        '    <string name="export_dir">content://com.android.providers.'
        + "downloads.documents/tree/raw%3A%2Fstorage%2Femulated%2F0%2FDo"
        + f"wnload%2F{output_dir}</string>",
        "</map>",
    ]
    return content


def sha256(fname: str) -> str:
    """Computes the sha256 sum of a file.

    :param fname:
    """
    hash_sha256 = hashlib.sha256()
    with open(fname, "rb") as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_sha256.update(chunk)
    return hash_sha256.hexdigest()


def get_file(url: str, filename: str, expected_hash: str) -> None:
    """Downloads a file and verifies its filecontent is as expected.

    :param url: param filename:
    :param expected_hash:
    :param filename:
    """
    if not sms_ie_apk_file_exists(filename, expected_hash):
        response = requests.get(url)
        with open(filename, "wb") as some_file:
            some_file.write(response.content)
    assert_sms_ie_apk_file_exists(filename, expected_hash)


def assert_sms_ie_apk_file_exists(filename: str, expected_hash: str) -> None:
    """Verifies a file exists and that its content is as expected. Throws error
    if file does not exist or if the content is not expected.

    :param filename: param expected_hash:
    :param expected_hash:
    """
    if not os.path.exists(filename):
        raise Exception(f"Error, filename={filename} did not exist.")
    if expected_hash is not None:
        if sha256(filename) != expected_hash:
            raise Exception(f"Download is corrupted, {sha256(filename)}.")


def sms_ie_apk_file_exists(filename: str, expected_hash: str) -> bool:
    """Returns True a file exists and that its content is as expected. Returns
    False otherwise.

    :param filename: param expected_hash:
    :param expected_hash:
    """
    if not os.path.exists(filename):
        return False
    if sha256(filename) != expected_hash:
        return False
    return True


def app_is_installed(package_name: str) -> bool:
    """Verifies an application is installed on the phone.

    :param package_name:
    """

    installation_response = cmd_res(
        f"adb shell pm list packages {package_name}"
    )
    return installation_response == f"package:{package_name}\n"


def adb_install_apk(filename: str, package_name: str) -> None:
    """Installs an application and verifies it is installed.

    :param filename: param package_name:
    :param package_name:
    """
    if not app_is_installed(package_name):
        installation_response = cmd_res(f"adb install {filename}")
        print(f"installation_response={installation_response}")
    if not app_is_installed(package_name):
        raise Exception(
            f"Error, after installation, package:{package_name} "
            + "was not found."
        )


def ensure_sms_ie_config_file_exists(xml_path: str) -> None:
    """Ensures the configuration for the SMS Import/Export applictation exists.

    :param xml_path:
    """
    # Ensure the app directory exists.
    assert_dir_exists_on_phone("/data/data/com.github.tmo1.sms_ie/")
    ensure_dir_exists_on_phone(
        "/data/data/com.github.tmo1.sms_ie/shared_prefs/"
    )

    ensure_file_exists_on_phone(xml_path)


def create_sms_ie_output_folder(output_path: str) -> None:
    """Creates the output directory on the phone to which the sms messages will
    be exported.

    :param output_path: str:
    :param output_path: str:
    """
    ensure_dir_exists_on_phone(output_path)


def ensure_dir_exists_on_phone(path: str) -> None:
    """Creates a directory if it does not yet exist on the phone.

    :param path:
    """
    command = f"adb shell mkdir -p {path}"
    cmd_res(command)

    assert_dir_exists_on_phone(path)


def assert_dir_exists_on_phone(path: str) -> None:
    """Throws error if a directory does not yet exist on the phone.

    :param path:
    """
    command = f'adb shell [ -d {path} ] && echo "exists."'
    output = cmd_res(command)
    if output != "exists.\n":
        raise Exception(f"Error, app dir:{path} is not found.")


def file_exists_on_phone(filepath: str) -> bool:
    """Returns True if a file exists on the phone. Returns False otherwise.

    :param filepath:
    """
    command = f'adb shell [ -f {filepath} ] && echo "exists."'
    output = cmd_res(command)
    if output != "exists.\n":
        return False
    return True


def remove_file_if_exists_on_phone(filepath: str) -> None:
    """Removes file from phone if it exists.

    :param filepath:
    """
    if file_exists_on_phone(filepath):
        command = f"adb shell rm {filepath}"
        cmd_res(command)
    assert_file_does_not_exists_on_phone(filepath)


def assert_file_does_not_exists_on_phone(filepath: str) -> None:
    """Throws error if file exists on phone.

    :param filepath:
    """
    if file_exists_on_phone(filepath):
        raise Exception("Error file:{filepath} still exists on phone.")


def assert_file_exists_on_phone(filepath: str) -> None:
    """Throws error if a file does not exist on the phone.

    # TODO: verify this is not a duplicate function.

    :param filepath:
    """
    if not file_exists_on_phone(filepath):
        raise Exception("Error file:{filepath} still exists on phone.")


def ensure_file_exists_on_phone(path: str) -> None:
    """Creates a file if it does not yet exist on the phone.

    # TODO: verify this is not a duplicate function.

    :param path:
    """
    command = f"adb shell touch {path}"
    cmd_res(command)
    assert_file_exists_on_phone(path)


def copy_file_from_pc_to_phone(
    local_filepath: str, phone_filepath: str
) -> None:
    """Copies a file from the pc to the phone.

    :param local_filepath: param phone_filepath:
    :param phone_filepath:
    """
    # Overwrite file content

    command = f"adb push {local_filepath} {phone_filepath}"
    print(f"command={command}")
    # TODO: verify mdf5 values are identical
    cmd_res(command)


def copy_file_from_phone_to_pc(
    phone_filepath: str, local_filepath: str
) -> None:
    """Copies a file from the phone to the pc.

    :param phone_filepath: param local_filepath:
    :param local_filepath:
    """
    # Overwrite file content

    command = f"adb pull {phone_filepath} {local_filepath}"
    print(f"command={command}")
    # TODO: verify mdf5 values are identical
    cmd_res(command)


def verify_app_is_in_foreground(package_name: str) -> None:
    """Verify an app is opened and into the foreground.

    :param package_name:
    """

    command = (
        "adb shell dumpsys activity recents | grep 'Recent #0' | cut -d="
        + " -f2 | sed 's| .*||' | cut -d '/' -f1"
    )
    output = cmd_res(command)
    if output != f"{package_name}\n":
        raise Exception(
            "Error, app is not running in the foreground. Please try again."
        )


def restart_application(package_name: str) -> None:
    """Restarts an application.

    :param package_name: str:
    :param package_name: str:
    """

    command = f"adb shell am force-stop {package_name}"
    cmd_res(command)
    # command=f"adb shell monkey -p '{package_name}' 1"
    # Works but does not export according to schedule.
    command = (
        f"adb shell am start -n {package_name}/{package_name}.MainActivity"
    )
    print(f"command={command}")
    cmd_res(command)
    time.sleep(2)


def screen_is_locked() -> bool:
    """Returns True if the screen is locked.

    Returns False if the screen is unlocked.
    """
    command = "adb shell dumpsys power | grep 'mHolding'"
    output = cmd_res(command)
    lines = output.split()
    if (
        lines[0] == "mHoldingWakeLockSuspendBlocker=true"
        and lines[1] == "mHoldingDisplaySuspendBlocker=true"
    ):
        return False
    if (
        lines[0] == "mHoldingWakeLockSuspendBlocker=true"
        and lines[1] == "mHoldingDisplaySuspendBlocker=false"
    ):
        return True
    raise Exception(f"Unexpected output in check if screen is locked:{output}")


def clear_app_data(package_name) -> None:
    """Deletes application data.

    :param package_name:
    """
    command = f"adb shell pm clear {package_name}"
    cmd_res(command)


def send_export_sms_inputs(
    package_name, keystrokes: List[int], pause_time: int
) -> None:
    """Sends keystrokes to phone.

    :param package_name: param keystrokes: List[int]:
    :param pause_time: int:
    :param keystrokes: List[int]:
    :param pause_time: int:
    """
    time.sleep(pause_time)
    for keystroke in keystrokes:
        verify_app_is_in_foreground(package_name)
        command = f"adb shell input keyevent {keystroke}"
        cmd_res(command)
        time.sleep(pause_time)


def get_phone_date():
    """Gets current date from phone in format yyyy-mm-dd."""
    command = "adb shell date +%F"
    date = cmd_res(command)
    return date.strip()  # removes newlines


def get_phone_time(buffer_sec: int) -> tuple[int, int]:
    """Gets the time from the phone, and computes whether the time up to the
    next whole minute is enough or whether the code should wait an additional
    minute.

    :param buffer_sec: int:
    :param buffer_sec: int:
    """
    # TODO: change to: date +%T for HH:MM:SS format without parsing
    command = "adb shell date"
    date_and_time = cmd_res(command)
    time_elements = date_and_time.split(" ")

    # Extract the 18:19:20 time from the date and time string.
    for element in time_elements:
        if ":" in element:
            time_str = element

    # Split 18:19:20 into hrs, mins and seconds
    if time_str is None:
        raise Exception("Phone time not found")
    [hrs, mins, secs] = list(map(int, time_str.split(":")))
    print(f"{hrs}:{mins}:{secs}")
    wait_time = 60 - secs

    # Ensure a buffer in when to export, is taken into account.
    if secs + buffer_sec > 60:
        mins = mins + 1
        wait_time = wait_time + 60

    # Expected time:
    return (
        hrs * 60 + mins + 1,
        wait_time,
    )  # Plus 1 because the export should happen at the next minute.


def get_sms_messages_from_phone(sms_ie_dict) -> dict:
    """Gets sms messages from phone and stores them locally in a .json file.

    :param sms_ie_dict:
    """
    # Get the sms_ie .apk file from the release page.
    url = (
        "https://github.com/tmo1/sms-ie/releases/download/v1.4.1/com.github"
        + ".tmo1.sms_ie-v1.4.1.apk"
    )
    filename = "sms_ie.apk"
    expected_hash = (
        "185afc567ea5fce2df4045925687a79a717bd31185cd944a4c80c51e64ce77ec"
    )

    get_file(url, filename, expected_hash=expected_hash)

    # Connect to phone through adb
    # check if device connected
    if device_ready():

        # Install sms_ie.apk file.
        adb_install_apk(filename, sms_ie_dict["package_name"])

        clear_app_data(sms_ie_dict["package_name"])

        # Verify sms_ie config file is found and exists.
        ensure_sms_ie_config_file_exists(sms_ie_dict["phone_xml_path"])

        # Specify output directory on android device.
        # Verify output directory exists on android device.
        create_sms_ie_output_folder(sms_ie_dict["output_dirpath"])

        # Delete sms_ie output file if it exists on phone.
        output_filepath = (
            f'{sms_ie_dict["output_dirpath"]}messages-{get_phone_date()}.json'
        )
        print(f"output_filepath={output_filepath}")
        remove_file_if_exists_on_phone(output_filepath)

        # Get the time on the phone and add buffer of 10 seconds.
        export_time, wait_time = get_phone_time(5)
        print(f"export_time={export_time}")
        print(f"wait_time={wait_time}")

        # Verify config file contains schedule, and if not overwrite config.
        config_content = sms_ie_config_content(
            export_time, sms_ie_dict["output_dir"]
        )

        # Create local copy of file content:
        create_and_write_file(sms_ie_dict["local_xml_path"], config_content)

        # Push config file to device.
        copy_file_from_pc_to_phone(
            sms_ie_dict["local_xml_path"], sms_ie_dict["phone_xml_path"]
        )

        if not screen_is_locked():
            clear_app_data(sms_ie_dict["package_name"])

            # Restart sms_ie application
            restart_application(sms_ie_dict["package_name"])

            # enter, enter
            time.sleep(2)
            print("pressing enter 4 times, to grant permissions")
            send_export_sms_inputs(
                sms_ie_dict["package_name"], [23, 23, 23, 23], 1
            )

            print("pressing enter,tab, enter to export sms output")
            # enter, tab, enter
            send_export_sms_inputs(
                sms_ie_dict["package_name"], [23, 61, 23], 1
            )
            print("Waiting 15 seconds for the export of data to be completed.")
            time.sleep(15)

            # Wait for wait time+file creation duration buffer
            print(
                f"Waiting for:{wait_time} seconds until sms data export file"
                + " is created."
            )
            time.sleep(wait_time)

            # Verify output file exists
            assert_file_exists_on_phone(output_filepath)

            # Copy file from phone to local storage
            copy_file_from_phone_to_pc(
                output_filepath, sms_ie_dict["local_sms_filepath"]
            )

            # Verify the sms messages file exists locally.
            if not os.path.exists(sms_ie_dict["local_sms_filepath"]):
                raise Exception(
                    f"Error, filename={sms_ie_dict['local_sms_filepath']} did"
                    + " not exist."
                )

        else:
            raise Exception("Error, please unlock screen and try again.")
    else:
        raise Exception("Please connect phone and enable adb, and try again.")

    # Load sms_ie output file content.
    sms_messages = load_dict_from_file(sms_ie_dict["local_sms_filepath"])
    return sms_messages

키 입력을 앱으로 전송하여 수동 내보내기를 수행합니다.

다음과 같이 호출됩니다.

output_dir = "sms_ie_output"
sms_ie_dict = {
    "private_dir": "private_data",
    # ensure_private_data_templates_exist(private_dir)
    "output_dir": output_dir,
    "output_dirpath": f"/sdcard/Download/{output_dir}/",
    "phone_xml_path": "/data/data/com.github.tmo1.sms_ie/shared_prefs/com."
    + "github.tmo1.sms_ie_preferences.xml",
    "local_xml_path": "installation/com.github.tmo1.sms_ie_preferences.xml",
    "package_name": "com.github.tmo1.sms_ie",
    "local_sms_messages_dir": "private_data/",
    "local_sms_filepath": "private_data/messages.json",
}


sms_messages = get_sms_messages_from_phone(sms_ie_dict)

개선의 여지

나는 처음에 구성을 수정하여 다음 분에 내보낼 일정을 설정하고 그 분을 기다렸지만 아무 일도 일어나지 않았습니다.그래서 저는 대신 SMS 메시지를 내보내는 수동 키 입력을 보냅니다.

Hier는 훌륭한 비디오 튜토리얼입니다!!!!정말 잘 작동합니다!!!

이것은 숫자가 있는 구글 시트 리스트와 안드로이드 앱의 조합입니다. (코더가 없는 경우에도 튜토리얼을 따르기 매우 쉽습니다!)

자습서 링크를 따릅니다.

https://www.youtube.com/watch?v=PReU4ITp37I&list=PLuB9drjjGa0QvFzWq_bwO8bOTRaWpdP_d&index=2

Google 앱 스크립트의 코드는 다음과 같습니다.

const SHEET_URL = "https://docs.google.com/spreadsheets/d/16_fp7lQsnaMLaDYMVsE5YxsohQBANllEVcZeMP5ZpiU/edit#gid=0";
const SHEET_NAME = "SMS";

const doGet = () => {
  const sheet = SpreadsheetApp.openByUrl(SHEET_URL).getSheetByName(SHEET_NAME);
  const [header, ...data] = sheet.getDataRange().getDisplayValues();
  

  const PHONE = header.indexOf("Phone");
  const TEXT = header.indexOf("Text");
  const STATUS = header.indexOf("Status");

  const output = [];

 data.forEach((row, index) => {
  if (row[STATUS] === "") {
    output.push([index+1, row[PHONE], row[TEXT]]);
  }
});

const json = JSON.stringify(output);

return ContentService.createTextOutput(json).setMimeType(ContentService.MimeType.TEXT);
}

const doPost = (e) => {
  const sheet = SpreadsheetApp.openByUrl(SHEET_URL).getSheetByName(SHEET_NAME);
  const [header] = sheet.getRange("A1:1").getValues();
  const STATUS = header.indexOf("Status");
  var rowId = Number(e.parameter.row);
  sheet.getRange(rowId + 1, STATUS +1).setValue("SMS Sent");
  return ContentService.createTextOutput("").setMimeType(ContentService.MimeType.TEXT);
}

그리고 그가 MIT 앱 Inventor에서 Android 앱을 만드는 비디오의 두 번째 부분만 따라가면 됩니다.프로젝트를 보기 위해 스크린샷을 만들었습니다.

enter image description here

언급URL : https://stackoverflow.com/questions/848728/how-can-i-read-sms-messages-from-the-device-programmatically-in-android

반응형