如何在Android系统下以编程方式从设备上读取短信?

从API 19开始，你可以使用Telephony类;因为硬核值不会在每个设备中检索消息，因为内容提供程序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();
}
}

如何在Android系统下以编程方式从设备上读取短信?

在android中，短信表是这样的

现在您可以从数据库中选择您想要的任何内容。在我们的例子中，我们只需要

身份，地址和正文

阅读短信时:

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);

读取短信的Kotlin代码:

1-将此权限添加到AndroidManifest.xml:

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

创建BroadCastreceiver类:

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及以上:

   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-将此请求代码添加到Activity或fragment:

 companion object {
const val PERMISSIONS_REQUEST_READ_SMS = 100
}

5- Override检查权限请求结果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  ")
}
}
}
}

最简单的函数

为了读取短信，我写了一个返回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}")
}
}

谷歌Play服务有两个api，可用于简化基于短信的验证过程

< a href = " https://goo。gle/2Y3rMhi" rel="noreferrer">SMS retrierver API

提供完全自动化的用户体验，不需要用户手动输入验证码，也不需要任何额外的应用权限，应该在可能的情况下使用。然而，它确实需要你在消息体中放置一个自定义哈希代码，所以你必须控制服务器端以及.;

• 信息需求 -唯一标识应用程序的11位哈希码
• 发送方要求 -无
• 用户交互 -无

Android应用中请求短信验证

在服务器上校验短信 . bb0在服务器上校验短信

< a href = " https://goo。gle/2LsbLiP" rel="noreferrer">短信用户同意API . gle/2LsbLiP" rel="noreferrer">短信用户同意API . ul

不需要自定义哈希码，但需要用户批准你的应用程序的请求，以访问包含验证码的消息。为了尽量减少向用户显示错误消息的机会，SMS User Consent将从用户的联系人列表中过滤出发件人的消息。

• 信息需求 - 4-10位至少包含一个数字的字母数字代码
• 发送方要求 -发件人不能在用户的联系人列表中
• 用户交互 -一个点击批准

The SMS User Consent API是谷歌播放服务的一部分。要使用它，你至少需要这些库的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"

第一步:开始监听短信

SMS用户同意将监听包含一次性代码的传入SMS消息长达五分钟。它不会查看在启动之前发送的任何消息。如果你知道发送一次性代码的电话号码，你可以指定senderPhoneNumber，或者如果你不知道null将匹配任何数字。

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

步骤2:请求同意阅读消息

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

第三步:解析一次性代码，完成短信验证

当用户单击“Allow”时——是时候真正读取消息了!在onActivityResult中，你可以从数据中获得SMS消息的全文:

val message = data.getStringExtra(SmsRetriever.EXTRA_SMS_MESSAGE)

然后解析SMS消息并将一次性代码传递到后端!

Hier是一个很棒的视频教程!!!!效果非常好!!

这是一个组合从谷歌表列表与数字和一个Android应用程序。(非常容易遵循教程也没有编码员!!

点击链接进入教程:

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

下面是谷歌应用程序脚本的代码:

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 APP Inventer中构建Android应用程序。我做了一个截图来看看这个项目

用1个Python函数获取所有短信:

我写了一个python函数来安装SMS从f-droid导入/导出，然后通过USB使用adb从手机中获取短信文件到pc中。

"""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消息。