Android sms read all

Android: Обработка СМС

0. Вместо вступления

Периодически (когда у меня выпадает свободный вечер, и наш «клуб» организует игру) я играю в регбол. «Клуб» организован таким образом, что в день игры всем участникам приходит СМС такого вида:

Регбол! Сегодня в 19-30. Двор школы №30: ул. Володарского, 20. Открытая площадка с резиновым покрытием. Тел. 8 (951) ***-**-**.

И вот я подумал — почему бы не написать небольшое приложение, которое будет отлавливать эти сообщения, и забивать их в гугл-календарь. Зачем? Да, в основном, just for fun, ибо я не настолько занятой человек, чтобы мне были жизненно необходимы автоматические секретари.

Итак, приложение будет уметь следующее:

• Следить за входящими сообщениями. Если пришло сообщение от адресата RM FIGHT, то нужно сверить текст сообщения с шаблоном, и при совпадении создать мероприятие в гугл-календаре. Если же текст сообщения с шаблоном не совпадает (например, просто какие-то новости пришли), то сохраняем сообщение в базе, чтобы потом можно было его прочитать.
• Показывать сообщения от этого адресата, не попадающие в категорию «Оповещение об игре» (новости, реклама и т.д.).

В рамках статьи я полагаю, что у читателя есть базовые знания — как создать проект, что такое файл Manifest, и с чего вообще начинать разработку под андроид — на этот счет есть куча разных туториалов, и здесь на этом останавливаться не будем. В то же время статья не предназначена для продвинутых андроид-девелоперов, в ней будут рассматриваться достаточно базовые вещи, вроде мониторинга и обработки смс, работы с базой данных, подключения по HTTP.

Итак, приступим. Кстати, используемая версия SDK — 14 (Android 4.0).

1. Перехватываем СМС

Для мониторинга входящих СМС первым делом нам необходимо запросить разрешение на их получение. Для этого в файл AndroidManifest.xml необходимо добавить запись вида:

Следующим шагом будет реализация монитора для прослушивания входящих сообщений. Для этого в манифест-файле регистрируем receiver:

Здесь мы установили приоритет равным 100, чтобы наше приложение получило доступ к входящему СМС раньше стандартного обработчика СМС, которое имеет нулевой приоритет. После того, как наше приложение обработает сообщение, нет смысла отдавать его системе, и помещать в папку Входящие.

Теперь создаем класс, расширяющий BroadcastReceiver :

В этом классе реализуется абстрактный метод onReceive() , который вызывается системой каждый раз при получении сообщения. В методе прописываем:

Здесь мы получаем сообщение с помощью метода intent.getExtras().get(«pdus») , который возвращает массив объектов в формате PDU — эти объекты мы потом приводим к типу SmsMessage с помощью метода createFromPdu() .

Теперь внимание. То, что мы делаем после получения сообщения, должно исполняться быстро. Broadcast receiver получает в системе высокий приоритет, но он работает в фоновом режиме и должен выполняться за короткое время, так что наши возможности ограничены. Например, мы можем сгенерировать уведомление или запустить службу, чтобы продолжить обработку в ней. Поэтому мы проверим отправителя сообщения, и если это уведомление об игре — мы вытащим текст сообщения и запустим службу, в которой уже и будем проводить обработку этого сообщения.

Дописываем в методе onReceive() :

Здесь мы составляем текст сообщения (в случае, когда сообщение было длинным и пришло в нескольких смс-ках, каждая отдельная часть хранится в messages[i] ) и вызываем метод abortBroadcast() , чтобы предотвратить дальнейшую обработку сообщения другими приложениями.

2. Обрабатываем СМС

В предыдущем пункте мы остановились на том, что запускаем службу для обработки смс с помощью метода startService() . Собственно, что такое службы и с чем их едят хорошо описано на официальном сайте, поэтому здесь на этом останавливаться не будем.

Создаем класс SmsService , расширяющий класс Service :

Поскольку у нас локальная служба, метод onBind() возвращает null.

Для вывода уведомлений нам понадобится вспомогательный метод showNotification():

В методе onStartCommand() прописываем:

Осталось, собственно, реализовать метод smsProcess() , который добавит смс в базу и сформирует мероприятие в гугл-календаре. Этим и займемся в следующей части статьи.

UPDATE: выложил код на GitHub. Со второй частью статьи пока не успеваю, слишком уж загружен по работе. Надеюсь в ближайшее время с этим вопросом разберусь.

Источник

Как программно читать СМС-сообщения с устройства в Android?

Я хочу получить SMS-сообщения с устройства и отобразить их?

Используйте Content Resolver ( «content: // sms / inbox» ) для чтения SMS, которые находятся в папке «Входящие».

Пожалуйста, добавьте разрешение READ_SMS .

Я надеюсь, что это помогает 🙂

Установить приложение в качестве приложения SMS по умолчанию

Функция для получения SMS

Не забудьте определить разрешение в вашем AndroidManifest.xml

Это тривиальный процесс. Хороший пример вы можете увидеть в исходном коде SMSPopup.

Изучите следующие методы:

это метод для чтения:

Начиная с API 19 для этого вы можете использовать класс телефонии; Так как жестко заданные значения не будут получать сообщения на всех устройствах, потому что поставщик контента Uri меняется от устройств и производителей.

Этот пост немного устарел, но вот еще одно простое решение для получения данных, связанных с SMS поставщиком контента в Android:

Получить все SMS :

В каждом SMS-сообщении есть все поля, поэтому вы можете получить любую нужную вам информацию:
адрес, тело, receiveDate, тип (INBOX, SENT, DRAFT, ..), threadId, .

Гель все Thread :

Гель все Conversation :

Он работает с List или, Cursor и есть пример приложения, чтобы увидеть, как это выглядит и работает.

На самом деле, есть поддержка всех поставщиков контента Android, таких как: Контакты, Журналы вызовов, Календарь, . Полный документ со всеми опциями: https://github.com/EverythingMe/easy-content-providers/wiki/Android- провайдеры

Надеюсь, это также помогло 🙂

Шаг 1: сначала мы должны добавить разрешения в файл манифеста, как

Шаг 2: затем добавьте сервисный класс получателя смс для получения смс

Шаг 3: Добавить разрешение во время выполнения

Шаг 4. Добавьте эти классы в ваше приложение и протестируйте интерфейсный класс.

SmsReceiver.java

Есть много уже доступных ответов, но я думаю, что все они упускают важную часть этого вопроса. Прежде чем читать данные из внутренней базы данных или ее таблицы, мы должны понять, как в ней хранятся данные, а затем найти решение вышеуказанного вопроса:

Как программно читать СМС-сообщения с устройства в Android?

Итак, в андроид смс таблица выглядит так

Знайте, мы можем выбрать все, что мы хотим из базы данных. В нашем случае нам нужно только

В случае чтения СМС:

1. Спросите разрешения

2. Теперь ваш код выглядит так

Я надеюсь, что это будет полезно. Спасибо.

Сервисы Google Play имеют два API, которые вы можете использовать для упрощения процесса проверки на основе SMS

Предоставляет полностью автоматизированный пользовательский интерфейс, не требуя от пользователя ручного ввода кодов проверки и не требуя каких-либо дополнительных разрешений приложения, и должен использоваться по возможности. Однако он требует, чтобы вы поместили пользовательский хеш-код в тело сообщения, поэтому вы должны также контролировать серверную часть .

• Требования к сообщениям — 11-значный хэш-код, который однозначно идентифицирует ваше приложение
• Требования к отправителю — Нет
• Взаимодействие с пользователем — нет

Не требует настраиваемого хеш-кода, однако требует, чтобы пользователь одобрил запрос вашего приложения на доступ к сообщению, содержащему проверочный код. Чтобы свести к минимуму вероятность появления неправильного сообщения для пользователя, SMS User Consent будет отфильтровываться сообщения от отправителей в списке контактов пользователя.

• Требования к сообщению — 4-10-значный буквенно-цифровой код, содержащий не менее одного номера
• Требования к отправителю — отправитель не может быть в списке контактов пользователя
• Взаимодействие с пользователем — одно нажатие для подтверждения

The SMS User Consent API является частью Сервисов Google Play. Для его использования вам понадобится как минимум версия 17.0.0 этих библиотек:

Шаг 1: Начните слушать SMS-сообщения

SMS User Consent будет прослушивать входящие SMS-сообщения, содержащие одноразовый код, до пяти минут. Он не будет проверять сообщения, отправленные до его запуска. Если вам известен номер телефона, на который будет отправляться одноразовый код, вы можете указать senderPhoneNumber , или, если вы не null соответствуете ни одному номеру.

Шаг 2: Запрос согласия на чтение сообщения

Как только ваше приложение получит сообщение, содержащее одноразовый код, оно будет уведомлено о трансляции. На данный момент у вас нет согласия на чтение сообщения — вместо этого вы получаете Intent что вы можете начать запрашивать согласие пользователя. Внутри вашего BroadcastReceiver , вы показываете подсказку, используя Intent в extras . Когда вы запускаете это намерение, он запрашивает у пользователя разрешение на чтение одного сообщения. Им будет показан весь текст, которым они поделятся с вашим приложением.

Шаг 3: Разбор одноразового кода и полное подтверждение SMS

Когда пользователь нажимает “Allow” — самое время прочитать сообщение! Внутри onActivityResult вы можете получить полный текст SMS-сообщения из данных:

Затем вы анализируете SMS-сообщение и передаете одноразовый код своему бэкэнду!

Источник

How to Receive and Handle SMS on Android

Despite the popularity of social media networks and messengers, texting is still the most common way to communicate via smartphones. According to the 2020 State of Texting report by Zipwhip, 77% of people use their texting app more frequently than other messengers.

But default SMS applications aren’t always comfortable for receiving SMS on Android, so users start looking for third-party apps. Additionally, non-messenger Android applications may still need SMS handling functionality (for example to confirm SMS authentication codes). In this article, we share our experience in developing SMS (and other service) handlers. In particular, we describe how to:

• Make your application the default SMS handler
• Develop an Android SMS receiver
• Encrypt and decrypt SMS messages
• Add texts to the SMS table in a device database

This text will be useful for developers who need to add SMS handling functionality to their app or create a new SMS messaging app.

Device Programming Team

Contents:

Making an app the default SMS handler

It’s important to make your application the default for handling SMS messages because only such app can record data to the SMS database. Your app should request permission to become the default SMS app before requesting any other permissions. This is also a requirement of the Google Play Store: if an app requests SMS, MMS, or CALL LOG permissions and isn’t a default SMS or Contact app, it will be rejected by Google.

In order to become the default messaging app, your app needs to:

• Register a receiver to handle incoming SMS messages
• Register a receiver to handle incoming MMS messages
• Create an activity that allows users to send new SMS or MMS messages in the Android application
• Create a service that sends out quick response messages

In our example, we’ll focus on how to receive SMS and send new SMS and MMS messages on Android. All of this functionality must be implemented in order to make our app the default handler.

We can use this code to ask a user to make our app the default for receiving SMS messages on Android:

In the code above, REQUEST_DEFAULT_APP is the request code to store the user’s choice. If the user allows the app to be the default, implementing this choice looks as follows:

Now we can proceed to the app manifest file and app permissions.

Developing the Android app manifest file

The app manifest file is a very important part of an Android application. It contains information on the app’s:

• Package name
• Components (activities, content providers, services, broadcast receivers)
• Required permissions
• Required software and hardware features

Let’s focus on the permissions for our application.

In Android 6, Google introduced runtime permissions. They protect the privacy of user data, tell users what information will be used by the app, and make sure users understand what an app can do with their data.

The runtime permissions system defines two permission levels:

• Normal — Permissions to access data or resources that pose little to no risk to the user’s personal information (e.g. device time zone). These permissions don’t require the user’s approval.

Dangerous — Permissions to handle a user’s sensitive data (e.g. texts, messages, photos, notes, etc.). These require the user’s approval.

When an application requests permission, a system dialog appears. It contains a list of the permissions the app requires and Allow and Deny buttons.

If the user denies a permission, when the app requests it the next time, the dialog box will contain a Do not ask me again checkbox.

When developing an app, you should take into account the scenario when a user denies permissions. All logic that relies on the denied permissions should not cause the app to fail.

In our example, the app’s manifest file declares permissions to read, send, and get all SMS in Android programmatically, as well as receive MMS messages, and receive push notifications:

After the declaration, the app should get the following permissions:

And handle the result of its requests in this way:

All of these permissions are in the same group, so they’re granted all together. If you request permissions from different permission groups, you’ll need to check the grantedResults array so you don’t miss any denied permissions.

To simplify the process of acquiring permissions, you can use a library like Quick Permissions.

Now it’s time to start a standard activity. In our example, this is part of an application that decrypts an SMS and shows it to the user. But in a real messaging app, there should also be an activity that provides functionality to create and send new SMS and MMS messages.

The part of our Manifest.xml file that describes our main activity looks like this:

Now we need to create an SMS receiver:

We also need to create an MMS receiver:

Finally, we should add a service that allows the user to respond to texts:

By this stage, our app can receive, display, and respond to texts. Let’s take a look at its ViewModel file.

Editing the ViewModel

At this stage, our project contains only one Extensible Markup Language (XML) layout. There’s one button and one list. The button is used for getting SMS messages from the system inbox; the list is used for showing messages.

Here’s the XML layout code:

And here’s a screenshot of our simple user interface:

As you can see, this XML doesn’t contain any listeners. We’ll add them later. Next, we need to introduce encryption and decryption algorithms.

Encrypting and decrypting SMS messages

All texts that our app receives will be encrypted. To handle them, we need to add a class that provides encryption and decryption.

In our application, encryption is done by executing the fun encrypt(data: String): String function. It encrypts a string with a key generated using the Password-Based Key Derivation Function (PBKDF2) algorithm. The returned value is an encrypted Base64 string.

Here’s what happens when we execute this function:

After that, we need to decrypt the SMS. To do that, we use the fun decrypt(encryptedData: String): String function. It decrypts the Base64 string with a PBKDF2 algorithm.

The decryption process looks like this:

To encrypt and decrypt the given ByteArray, we can use the fun cryptoOperation(cipherMode: Int, data: ByteArray): ByteArray function. We can execute it using the following code:

Encryption algorithms such as AES, Rivest–Shamir–Adleman, MD5, etc. require a secret key in the form of a ByteArray. We can generate a secret key that uses salt with the fun generateKey(): ByteArray function. Here’s an example of how to generate a key:

After executing these functions, our app can encrypt and decrypt texts. Now we can add an SMS handler.

Handling received SMS messages

The main class that receives SMS messages is SmsReceiver. It extends the BroadcastReceiver class. Any child class of BroadcastReceiver must contain the onReceive method, which receives Context and Intent parameters.

The BroadcastReceiver class is well-described in the official documentation, which is why we won’t focus on its properties.

When we get an event upon receiving a text, we need to go to the onReceive method. First, let’s confirm that all of the received content is valid:

The next step is to check that we’ve received the SMS data by checking the action value:

Now we’re ready to receive the SMS content with the val smsMessages = Telephony.Sms.Intents.getMessagesFromIntent(intent) method. It will provide us an array of smsMessages. Here’s an example:

When the SMS list gets into Intent, then the SMS should be parsed. For this purpose, we call the getMessagesFromIntent method from the Telephony.Sms.Intents class.

Then SmsReceiver gets the SMS and can do anything with it. In our example, SMS messages are encrypted and recorded in the SMS table of the device database. We need to do this to allow the default Android SMS viewer to view encrypted SMS messages.

When our app receives an SMS, it’s displayed using the Toast class.

Reading and decrypting SMS messages

After we’ve created encryption procedures, it’s time to add functionality for reading and decrypting SMS messages. Let’s list the click listener for the button on the main screen. All texts from the inbox are read, and then the sender information and SMS text are put into the list using this code:

The SMS is obtained from the list, decrypted, and then displayed to the user. The item listener list is as follows:

After that, our application is ready to handle SMS messages!

Conclusion

An application for handling text messages is must on any device. Lots of users aren’t satisfied with their default SMS app and are looking for a more comfortable solution. But there are several tricks to making an SMS app in Android Studio. It has to:

• be the default application for SMS messages
• ask for all necessary permissions (and not crash it a user denies them)
• receive, display, and allow the user to respond to texts
• be secure
• add received texts to the device’s SMS database

In this article, we’ve shown you how to build an Android app with this functionality. Creating such applications is only the tip of the iceberg in terms of our experience in mobile app development. If you have a complex Android-related project, challenge us with it!

Источник