Como Receber um SMS em Kotlin
A maneira mais simples de enviar SMS a partir de Kotlin é usar a API HTTP/Rest de SMS integrada do Ozeki SMS Gateway. Ao usar esta API, você enviará mensagens SMS fazendo uma requisição HTTP Post para o gateway de SMS. A requisição HTTP Post conterá uma mensagem formatada em JSON. O gateway de SMS enviará este SMS para o telefone do destinatário e retornará uma resposta HTTP 200 OK para a sua requisição. (Figura 1)
O exemplo de código SMS em Kotlin abaixo demonstra como você pode receber mensagens SMS usando a API HTTP Rest de SMS do Ozeki SMS Gateway com a biblioteca Kotlin Ozeki.Libs.Rest. Esta biblioteca é fornecida gratuitamente, e você pode usá-la e modificá-la em qualquer um dos seus projetos.
MainActivity.kt
package receive.sms
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import Ozeki.Libs.Rest.*
import android.widget.ArrayAdapter
import kotlinx.coroutines.*
class MainActivity : AppCompatActivity() {
@DelicateCoroutinesApi
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val listMessages:android.widget.ListView = findViewById(R.id.listMessages)
val btnSendRequest:android.widget.Button = findViewById(R.id.btnSendRequest)
val configuration = Configuration(
username = "http_user",
password = "qwe123",
apiurl = "http://10.0.2.2:9509/api"
)
val messages_label : ArrayList<Message> = arrayListOf()
val arrayAdapter = ArrayAdapter<Message>(this, android.R.layout.simple_list_item_1, messages_label)
listMessages.adapter = arrayAdapter
val api = MessageApi(configuration)
btnSendRequest.setOnClickListener {
GlobalScope.launch(Dispatchers.IO) {
val result = api.DownloadIncomming()
val messages = result.Messages
for (index in 0 until messages.size) {
messages_label.add(messages.get(index))
}
}
arrayAdapter.notifyDataSetChanged()
}
}
}
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Button
android:id="@+id/btnSendRequest"
android:layout_width="320dp"
android:layout_height="wrap_content"
android:layout_marginTop="24dp"
android:backgroundTint="#FF3F3F"
android:text="Baixar mensagens recebidas"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.505"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/listMessages" />
<TextView
android:id="@+id/textMessages"
android:layout_width="320dp"
android:layout_height="wrap_content"
android:layout_marginTop="24dp"
android:text="Mensagens"
android:textAlignment="center"
android:textSize="22sp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.505"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<ListView
android:id="@+id/listMessages"
android:layout_width="320dp"
android:layout_height="500dp"
android:layout_marginTop="24dp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/textMessages" />
</androidx.constraintlayout.widget.ConstraintLayout>
Como usar o exemplo de SMS em Kotlin:
Você pode usar a classe MessageApi para receber mensagens SMS do gateway de SMS. Sua requisição do seu dispositivo será encaminhada para o gateway de SMS através da internet.
Baixar ReceiveSms.kt
O código-fonte explicado neste artigo pode ser baixado, usado e modificado gratuitamente.
Download: ReceiveSms.kt.zip (148Kb)
O arquivo ReceiveSms.kt.zip contém um projeto de exemplo, que inclui a biblioteca Ozeki.Libs.Rest. Com esta biblioteca, você pode enviar, excluir, marcar e receber mensagens SMS criando um MessageApi e usando os métodos Send(), Delete(), Mark() e Receive(). (Figura 2)
Para receber um SMS com Kotlin:
- Instale o Ozeki SMS Gateway
- Conecte o Ozeki SMS Gateway à rede móvel
- Envie um SMS teste a partir da interface gráfica do Ozeki
- Crie um usuário de API HTTP de SMS
- Android Studio
- Baixe o projeto de exemplo acima
- Crie uma API para baixar suas mensagens recebidas
- Use o método DownloadIncoming() para receber suas mensagens
- Leia a mensagem de resposta no console
- Verifique os logs no gateway de SMS
Instale o Ozeki SMS Gateway e crie um usuário de API HTTP
Para poder receber SMS com Kotlin, primeiro você precisa instalar o Ozeki SMS Gateway. O gateway SMS pode ser instalado no mesmo computador onde você desenvolve seu código Kotlin no Android Studio. Após a instalação, o próximo passo é conectar o Ozeki SMS Gateway à rede móvel. Você pode enviar um SMS de teste a partir da interface gráfica do Ozeki para verificar se sua conexão com a rede móvel está funcionando. O passo final para preparar seu ambiente é criar um usuário de API HTTP para SMS. Crie um usuário com o nome de usuário "http_user" e senha "qwe123" para que o exemplo funcione sem modificações.
Após a configuração do ambiente, você pode executar seu código Kotlin.
URL da API HTTP para enviar SMS a partir de Kotlin
Para receber SMS com Kotlin, seu código Kotlin precisará fazer uma requisição HTTP para o gateway SMS. A URL da API é mostrada abaixo. Observe que o endereço IP (127.0.0.1) deve ser substituído pelo endereço IP do seu gateway SMS. Se o Ozeki SMS Gateway estiver instalado no mesmo computador onde o aplicativo JavaScript de SMS está sendo executado, pode ser 127.0.0.1. Se estiver instalado em um computador diferente, deve ser o endereço IP desse computador.
http://127.0.0.1:9509/api?action=rest
Autenticação HTTP para receber SMS com Kotlin
Para autenticar o cliente de SMS em Kotlin, você precisa enviar o nome de usuário e senha em uma string codificada em base64 para o servidor em uma requisição HTTP. O formato usado é: base64(nome de usuário+":"+senha). Em Kotlin, você pode usar o seguinte código para fazer essa codificação:
var usernamePassword = "%s:%s".format(username, password) return "Basic %s".format(Base64.getEncoder().encodeToString(usernamePassword.toByteArray()))
Por exemplo, se você codificar o nome de usuário 'http_user' e a senha 'qwe123', você obterá a seguinte string codificada em base64: aHR0cF91c2VyOnF3ZTEyMw==. Para enviar
Cabeçalho da requisição HTTP para enviar SMS a partir de Kotlin
Para receber a(s) mensagem(ns) SMS, você precisa incluir as seguintes linhas como cabeçalhos na requisição HTTP. Observe que incluímos um cabeçalho de tipo de conteúdo e um cabeçalho de Autorização.
Content-Type: application/json Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
Requisição HTTP para receber SMS com Kotlin
Para receber a(s) mensagem(ns) SMS recebida(s), seu aplicativo Kotlin enviará uma requisição HTTP semelhante à mostrada abaixo. Observe que esta requisição contém uma parte de cabeçalho HTTP e uma parte de corpo HTTP. O corpo HTTP é uma string de dados codificada em JSON. Ela contém o número do destinatário e o texto da mensagem.
GET /api?action=receivemsg&folder=inbox HTTP/1.1 Connection: Keep-Alive Accept-Encoding: gzip Authorization: Basic aHR0cF91c2VyOnF3ZTEyMw== Host: 10.0.2.2:9509 User-Agent: okhttp/4.2.2
Resposta HTTP recebida pelo exemplo de SMS em Kotlin
Assim que o gateway SMS receber esta requisição, ele gerará uma resposta HTTP. A resposta HTTP conterá um código de status, para indicar se a requisição de envio de SMS foi bem-sucedida ou não. Ela também retornará uma estrutura codificada em JSON para fornecer detalhes úteis sobre o envio da mensagem.
HTTP/1.1 200 OK
User-Agent: OZEKI 10.3.120 (www.myozeki.com)
Content-Type: application/json; charset=utf8
Last-Modified: Thu, 17 Jun 2021 16:10:48 GMT
Server: 10/10.3.120
Transfer-Encoding: chunked
{
"http_code": 200,
"response_code": "SUCCESS",
"response_msg": "",
"data": {
"folder": "inbox",
"limit": "1000",
"data": [
{
"message_id": "ada7ee44-aefc-e746-9376-b76e3674442a",
"from_connection": "http_user@localhost",
"from_address": "+36203333333",
"from_station": "%",
"to_connection": "http_user@localhost",
"to_address": "http_user",
"to_station": "%",
"text": "Hello world 3",
"create_date": "2021-06-17 16:09:11",
"valid_until": "2021-06-24 16:09:11",
"time_to_send": "2021-06-17 16:09:11",
"submit_report_requested": true,
"delivery_report_requested": true,
"view_report_requested": true,
"tags": [
{
"name": "Type",
"value": "SMS:TEXT"
}
]
},
{
"message_id": "fccc6211-c710-c80e-a28f-664ff8b0e964",
"from_connection": "http_user@localhost",
"from_address": "+36201111111",
"from_station": "%",
"to_connection": "http_user@localhost",
"to_address": "http_user",
"to_station": "%",
"text": "Hello world 1",
"create_date": "2021-06-17 16:09:11",
"valid_until": "2021-06-24 16:09:11",
"time_to_send": "2021-06-17 16:09:11",
"submit_report_requested": true,
"delivery_report_requested": true,
"view_report_requested": true,
"tags": [
{
"name": "Type",
"value": "SMS:TEXT"
}
]
},
{
"message_id": "ba782a64-05cd-8ba8-9f4c-e8597ca30b59",
"from_connection": "http_user@localhost",
"from_address": "+36202222222",
"from_station": "%",
"to_connection": "http_user@localhost",
"to_address": "http_user",
"to_station": "%",
"text": "Hello world 2",
"create_date": "2021-06-17 16:09:11",
"valid_until": "2021-06-24 16:09:11",
"time_to_send": "2021-06-17 16:09:11",
"submit_report_requested": true,
"delivery_report_requested": true,
"view_report_requested": true,
"tags": [
{
"name": "Type",
"value": "SMS:TEXT"
}
]
}
]
}
}
Como receber mensagens SMS com Kotlin usando a API de SMS e o projeto de exemplo acima (Tutorial em vídeo)
Este vídeo mostra como baixar e usar o projeto ReceiveSms.kt. Uma vez que você abriu o projeto de exemplo, pode notar que há um pacote chamado Ozeki.Libs.Rest. Este é o pacote que contém o MessageApi e tudo o que você precisa para receber mensagens SMS usando Kotlin.
Como verificar se a solicitação foi aceita pelo usuário HTTP
Após o envio do SMS, é uma boa ideia verificar seu gateway SMS, para ver o que foi recebido. Você pode verificar o log abrindo os detalhes do usuário HTTP no console de gerenciamento do Ozeki SMS Gateway. No final do vídeo acima, você pode ver como verificar se a solicitação foi recebida pelo http_user. (Figura 3)
Na Figura 4, você pode ver como é usar o aplicativo em um telefone. Como você pode ver na imagem Antes, por padrão não há mensagens recebidas. Pressione o botão 'Baixar Entradas' para obter as mensagens enviadas para você. Na foto Depois, você pode ver que todas as informações sobre uma mensagem são visíveis quando você a baixa.
A biblioteca Ozeki.Libs.Rest pode ser baixada, usada e modificada gratuitamente.
Download: Ozeki.Libs.Rest.kt.zip (7.66Kb)
Se você decidir criar seu aplicativo por conta própria apenas com a biblioteca Ozeki.Libs.Rest,
há algumas coisas que você deve alterar em seu aplicativo base.
Para usar a biblioteca Ozeki.Libs.Rest, você deve colocá-la na pasta java
do diretório principal.
No vídeo a seguir, mostrarei como baixar e adicionar a biblioteca Ozeki.Libs.Rest
ao seu próprio projeto.
Dependências
É importante mencionar que a biblioteca Ozeki.Libs.Rest tem algumas dependências. Para usá-la, você deve adicionar essas dependências nos Gradle Scripts.
implementation "com.squareup.okhttp3:okhttp:4.2.2" implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0' implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.0'
No vídeo a seguir, você verá como anexar as dependências mencionadas anteriormente. Ele começará com a cópia do código e o levará até as dependências adicionadas com sucesso. O vídeo tem apenas 53 segundos, mas contém todas as etapas necessárias para concluir o método. Você pode seguir este tutorial sem esforço.
Acesso à internet
Para que seu aplicativo possa enviar
uma solicitação HTTP, você precisa permitir que seu aplicativo
se conecte à internet.
No vídeo a seguir, mostrarei como habilitar o acesso à internet
para seu aplicativo Kotlin.
<uses-permission android:name="android.permission.INTERNET" />
android:usesCleartextTraffic="true"
Você precisa adicionar ambas as linhas ao arquivo AndroidManifest.xml.
No próximo vídeo, mostrarei onde você deve inserir os códigos acima.
O vídeo começará com a cópia do código e o levará até a conexão à internet adicionada com sucesso.
Este vídeo é preciso e fácil de seguir.
Conclusão
Este guia foi escrito para mostrar os passos de recebimento de SMS em Kotlin usando o usuário HTTP do Ozeki SMS Gateway. Esta solução ajuda você a coletar as mensagens recebidas na pasta Inbox e movê-las para o seu programa em Kotlin. Usar esta solução dá a você a capacidade de manter seu sistema de mensagens organizado como planejado.
Este é apenas o começo, saiba mais sobre como gerenciar suas mensagens no site da Ozeki. Para se manter eficiente e atualizado, organize as mensagens, leia o próximo artigo sobre Como excluir um SMS em Kotlin.
Vamos trabalhar, configure o Ozeki SMS Gateway agora!
More information
- Kotlin enviar SMS com a API REST HTTP (exemplo de código)
- Kotlin enviar múltiplos SMS com a API REST HTTP (exemplo de código)
- Kotlin agendar SMS com a API REST HTTP (exemplo de código)
- Kotlin receber SMS com a API REST HTTP (exemplo de código)
- Kotlin excluir SMS com a API REST HTTP (exemplo de código)
- Github: API de SMS em Kotlin