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();
}
}
오래되었지만, 이 게시물과 관련된 를 얻기 .SMS
Android의 콘텐츠 공급자:
다음 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 표는 다음과 같습니다.
이제 데이터베이스에서 원하는 것을 선택할 수 있습니다.우리의 경우에는 필요한 것만
아이디,주소,본문
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가 있습니다.
사용자가 수동으로 확인 코드를 입력하거나 추가 앱 권한을 요구하지 않고 완전히 자동화된 사용자 환경을 제공하며 가능한 경우 사용해야 합니다.그러나 메시지 본문에 사용자 정의 해시 코드를 배치해야 하므로 서버 측도 제어할 수 있어야 합니다.
- 메시지 요구 사항 - 앱을 고유하게 식별하는 11자리 해시 코드
- 보낸 사람 요구 사항 - 없음
- 사용자 상호 작용 - 없음
사용자 지정 해시 코드가 필요하지 않지만 사용자가 확인 코드가 포함된 메시지에 액세스하려면 앱의 요청을 승인해야 합니다.를 전달할 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)
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 앱을 만드는 비디오의 두 번째 부분만 따라가면 됩니다.프로젝트를 보기 위해 스크린샷을 만들었습니다.
언급URL : https://stackoverflow.com/questions/848728/how-can-i-read-sms-messages-from-the-device-programmatically-in-android
'bestsource' 카테고리의 다른 글
'object' 유형의 다른 지원 개체 '[objectObject]'을(를) 찾을 수 없습니다.NgFor는 어레이와 같은 반복 가능한 파일에 대한 바인딩만 지원합니다. (0) | 2023.08.27 |
---|---|
기존 항목을 폴더로 덮어쓰려면 어떻게 해야 합니까?여기 PowerShell에서 복사하시겠습니까? (0) | 2023.08.27 |
범위를 쉼표로 구분된 문자열로 변환 (0) | 2023.08.22 |
Python에서 빈 개체 만들기 (0) | 2023.08.22 |
매개 변수와 함께 또는 매개 변수 없이 사용할 수 있는 장식기를 만드는 방법은 무엇입니까? (0) | 2023.08.22 |