Como enviar SMS a partir de Kotlin
A maneira mais simples de enviar SMS a partir de Kotlin é usar a API de SMS HTTP/Rest 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)
Código Kotlin para enviar SMS para celular
O exemplo de código de SMS em Kotlin abaixo demonstra como você pode enviar SMS usando a API 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 de seus projetos.
MainActivity.kt
package send.sms
import android.os.Build
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.text.method.ScrollingMovementMethod
import androidx.annotation.RequiresApi
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import Ozeki.Libs.Rest.Configuration
import Ozeki.Libs.Rest.Message
import Ozeki.Libs.Rest.MessageApi
class MainActivity : AppCompatActivity() {
@RequiresApi(Build.VERSION_CODES.O)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val btnSendRequest:android.widget.Button = findViewById(R.id.btnSendRequest)
val inputToAddress:android.widget.EditText = findViewById(R.id.inputToAddress)
val inputMessage:android.widget.EditText = findViewById(R.id.inputMessage)
val logBox:android.widget.TextView = findViewById(R.id.logBox)
logBox.movementMethod = ScrollingMovementMethod()
val configuration = Configuration(
username = "http_user",
password = "qwe123",
apiurl = "http://10.0.2.2:9509/api"
)
val api = MessageApi(configuration)
btnSendRequest.setOnClickListener {
if (inputToAddress.text.toString() != "" && inputMessage.text.toString() != "") {
GlobalScope.launch(Dispatchers.IO) {
val msg = Message()
msg.ToAddress = inputToAddress.text.toString()
msg.Text = inputMessage.text.toString()
inputToAddress.text.clear()
inputMessage.text.clear()
val response = api.Send(msg)
logBox.text = String.format("%s\n%s", logBox.text, response.toString())
}
}
}
}
}
<?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="send.sms.MainActivity">
<Button
android:id="@+id/btnSendRequest"
android:layout_width="320dp"
android:layout_height="50dp"
android:layout_marginBottom="24dp"
android:text="Enviar"
android:backgroundTint="#FF3F3F"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.505"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/logBox"
app:layout_constraintVertical_bias="0.776" />
<EditText
android:id="@+id/inputMessage"
android:layout_width="320dp"
android:layout_height="150dp"
android:layout_marginTop="32dp"
android:ems="10"
android:gravity="start|top"
android:hint="Olá mundo!"
android:inputType="textMultiLine"
android:textColorHint="#BFBFBF"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.494"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/textView" />
<TextView
android:id="@+id/textView"
android:layout_width="320dp"
android:layout_height="wrap_content"
android:layout_marginTop="20dp"
android:text="Mensagem:"
android:textSize="20sp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.505"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/inputToAddress" />
<TextView
android:id="@+id/textView2"
android:layout_width="320dp"
android:layout_height="wrap_content"
android:layout_marginTop="40dp"
android:text="Para:"
android:textSize="20sp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.505"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<EditText
android:id="@+id/inputToAddress"
android:layout_width="320dp"
android:layout_height="wrap_content"
android:layout_marginTop="16dp"
android:ems="10"
android:hint="+36201111111"
android:inputType="textPersonName"
android:textColorHint="#BFBFBF"
android:textSize="18sp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.505"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/textView2" />
<TextView
android:id="@+id/logBox"
android:layout_width="320dp"
android:layout_height="160dp"
android:layout_marginTop="36dp"
android:scrollbars="vertical"
android:text="Log:"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintHorizontal_bias="0.505"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/inputMessage" />
</androidx.constraintlayout.widget.ConstraintLayout>
Como usar o exemplo de SMS em Kotlin:
Você pode usar a classe Message para criar o SMS e a classe MessageApi para enviar o SMS para o gateway de SMS. O gateway de SMS encaminhará sua mensagem para a rede móvel através de uma conexão sem fio ou pela Internet.
Baixar SendSms.kt
O código-fonte explicado neste artigo pode ser baixado, usado e modificado gratuitamente.
Download: SendSms.kt.zip (148Kb)
O que está no arquivo SendSms.kt.zip?
O arquivo SendSms.kt.zip contém o 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)
Como enviar SMS a partir do Kotlin (Passos rápidos)
Para enviar SMS a partir do Kotlin:
- Instale o Ozeki SMS Gateway
- Conecte o Ozeki SMS Gateway à rede móvel
- Envie um SMS de teste a partir da interface gráfica do Ozeki
- Crie um usuário de API HTTP para SMS
- Android Studio
- Baixe o projeto de exemplo acima
- Crie o SMS criando um novo objeto Message
- Crie uma API para enviar sua mensagem
- Use o método Send para enviar sua mensagem
- 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 enviar SMS a partir do Kotlin, primeiro você precisa 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 do Kotlin
Para enviar SMS a partir do Kotlin, seu código Kotlin terá que fazer uma requisição HTTP para o gateway de 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 de SMS. Se o Ozeki SMS Gateway estiver instalado no mesmo computador onde o aplicativo de SMS em JavaScript 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 enviar SMS a partir do 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', obterá a seguinte string codificada em base64: aHR0cF91c2VyOnF3ZTEyMw==. Para enviar
Cabeçalho da requisição HTTP para enviar SMS a partir do Kotlin
Para enviar as mensagens 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 enviar SMS a partir do Kotlin
Para enviar o SMS, 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. Ele contém o número do destinatário e o texto das mensagens.
POST /api?action=sendmsg HTTP/1.1
Connection: Keep-Alive
Content-Length: 323
Content-Type: application/json; charset=utf-8
Accept-Encoding: gzip
Authorization: Basic aHR0cF91c2VyOnF3ZTEyMw==
Host: 10.0.2.2:9509
User-Agent: okhttp/4.2.2
{
"messages": [
{
"message_id": "b686acf6-7420-4a3d-b444-779dcffc652b",
"to_address": "+36201111111",
"text": "Hello world!",
"create_date": "2021-06-17T09:48:30",
"valid_until": "2021-06-24T09:48:30",
"time_to_send": "-999999999-01-01T00:00",
"submit_report_requested": true,
"delivery_report_requested": true,
"view_report_requested": true
}
]
}
Resposta HTTP recebida pelo exemplo de SMS em Kotlin
Assim que o gateway SMS receber esta solicitação, ele gerará uma resposta HTTP. A resposta HTTP conterá um código de status, para indicar se o envio do SMS foi bem-sucedido ou não. 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: Wed, 16 Jun 2021 09:06:03 GMT
Server: 10/10.3.120
Transfer-Encoding: chunked
{
"http_code": 200,
"response_code": "SUCCESS",
"response_msg": "Mensagens enfileiradas para entrega.",
"data": {
"total_count": 1,
"success_count": 1,
"failed_count": 0,
"messages": [
{
"message_id": "b686acf6-7420-4a3d-b444-779dcffc652b",
"from_station": "%",
"to_address": "+36201111111",
"to_station": "%",
"text": "Olá mundo!",
"create_date": "2021-06-17 09:48:30",
"valid_until": "2021-06-24 09:48:30",
"time_to_send": "2021-06-17 09:48:30",
"submit_report_requested": true,
"delivery_report_requested": true,
"view_report_requested": false,
"tags": [
{
"name": "Type",
"value": "SMS:TEXT"
}
],
"status": "SUCCESS"
}
]
}
}
Como enviar SMS a partir de 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 SendSms.kt. Assim que você abrir o projeto de exemplo, pode notar que há um pacote chamado Ozeki.Libs.Rest. Este é o pacote que contém a MessageApi e tudo o que você precisa para enviar um SMS usando Kotlin.
Como verificar se o SMS foi aceito pelo usuário HTTP
Depois que o SMS for enviado, é uma boa ideia verificar seu gateway SMS, para ver o que ele recebeu. 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)
Como é a aparência do aplicativo em uso
Na Figura 4, você pode ver como o aplicativo se parece depois de enviar uma mensagem com ele. Como você pode ver, suas mensagens enviadas anteriormente serão armazenadas como um log abaixo da caixa de texto 'Mensagem'. Você pode ver todas as informações sobre a mensagem, como o remetente, o texto e o resultado do procedimento de envio.
Como verificar se o SMS foi enviado para a rede móvel
O passo final para verificar o procedimento é dar uma olhada nos logs da conexão com a rede móvel. Você pode precisar ativar o registro na configuração da conexão antes de enviar a mensagem para ver os logs. Se o registro estiver ativado, você verá o número de telefone e o texto da mensagem que você enviou.
Como adicionar Ozeki.Libs.Rest ao seu próprio projeto
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 Scripts Gradle.
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'
Adicionando as dependências (tutorial em vídeo)
No vídeo a seguir, você aprenderá como adicionar as dependências mencionadas anteriormente. Começará copiando o código e o guiará até as dependências serem adicionadas com sucesso. O vídeo tem apenas 53 segundos, mas apresenta todas as etapas necessárias para concluir o processo. Você pode seguir este tutorial sem esforço.
Acesso à internet
Para que sua aplicação possa enviar
uma requisição HTTP, você precisa permitir que ela
se conecte à internet.
No vídeo a seguir, mostrarei como habilitar o acesso à internet
para sua aplicação em Kotlin.
<uses-permission android:name="android.permission.INTERNET" />
android:usesCleartextTraffic="true"
Como habilitar a conexão à internet para seu aplicativo (Tutorial em vídeo)
Você precisa adicionar ambas as linhas ao arquivo AndroidManifest.xml.
No vídeo a seguir, mostrarei onde você deve colocar os códigos acima.
O vídeo começará copiando o código e o guiará até a conexão à internet ser adicionada com sucesso.
Este vídeo é detalhado e oferece uma experiência fácil de acompanhar.
Conclusão
O objetivo deste guia foi mostrar como enviar mensagens SMS a partir de Kotlin com a API HTTP SMS do Ozeki SMS Gateway. O conhecimento que você adquiriu permite manter contato com seus clientes usando um código simples em Kotlin. O envio de mensagens internacionais também é possível com o Ozeki SMS Gateway, pois ele funciona em qualquer país e pode enviar e receber SMS por várias conexões móveis.
Certifique-se de continuar seus estudos aqui, visite outras páginas de tutorial no site da Ozeki para mais informações. Confira mais guias sobre o uso de Kotlin, começando com o Como enviar múltiplos SMS a partir de Kotlin.
Agora, a primeira coisa a fazer é baixar o Ozeki SMS Gateway e começar a usá-lo!
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