Como enviar múltiplos SMS a partir de 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 realizando 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 múltiplos SMS para celular

O exemplo de código de SMS em Kotlin abaixo demonstra como você pode enviar múltiplos 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 dos seus projetos.

Vídeo 1 - Como baixar o exemplo SendMultipleSms.kt.zip (Tutorial em vídeo)

MainActivity.kt

package send.multiple.sms

import Ozeki.Libs.Rest.Configuration
import Ozeki.Libs.Rest.Message
import Ozeki.Libs.Rest.MessageApi
import android.os.Bundle
import android.text.method.ScrollingMovementMethod
import android.widget.ArrayAdapter
import androidx.appcompat.app.AppCompatActivity
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch


class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val inputToAddress:android.widget.EditText = findViewById(R.id.inputToAddress)
        val inputMessage:android.widget.EditText = findViewById(R.id.inputMessage)
        val btnAddMessage:android.widget.Button = findViewById(R.id.btnAddMessage)
        val btnSendRequest:android.widget.Button = findViewById(R.id.btnSendRequest)
        val listOfMessages:android.widget.ListView = findViewById(R.id.listView)
        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)

        val messages : ArrayList<Message> = arrayListOf()
        val messages_label : ArrayList<String> = arrayListOf()

        val arrayAdapter = ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, messages_label)

        listOfMessages.adapter = arrayAdapter

        btnAddMessage.setOnClickListener {
            if (inputToAddress.text.toString() != "" && inputMessage.text.toString() != "" ) {
                val msg = Message()
                msg.ToAddress = inputToAddress.text.toString()
                msg.Text = inputMessage.text.toString()
                inputToAddress.text.clear()
                inputMessage.text.clear()
                messages_label.add(msg.toString())
                arrayAdapter.notifyDataSetChanged()
                messages.add(msg)
            } else {
                logBox.text = String.format("%s\nVocê precisa preencher todos os campos!", logBox.text)
            }
        }

        btnSendRequest.setOnClickListener {
            messages_label.clear()
            arrayAdapter.notifyDataSetChanged()
            GlobalScope.launch(Dispatchers.IO) {
                val response = api.Send(messages)
                messages.clear()
                logBox.text = String.format("%s\n%s", logBox.text, response.toString())
            }
        }

    }
}

main_activity.xml

<?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">

    <TextView
        android:id="@+id/textToAddress"
        android:layout_width="320dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="40dp"
        android:text="Destinatário:"
        android:textSize="20sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.498"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/textMsg"
        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" />

    <EditText
        android:id="@+id/inputToAddress"
        android:layout_width="320dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:ems="10"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.505"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textToAddress" />

    <EditText
        android:id="@+id/inputMessage"
        android:layout_width="320dp"
        android:layout_height="80dp"
        android:layout_marginTop="20dp"
        android:ems="10"
        android:gravity="start|top"
        android:inputType="textMultiLine"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.494"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textMsg" />

    <Button
        android:id="@+id/btnSendRequest"
        android:layout_width="320dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text="Enviar"
        android:backgroundTint="#FF3F3F"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/listView" />

    <Button
        android:id="@+id/btnAddMessage"
        android:layout_width="320dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:backgroundTint="#FF3F3F"
        android:text="Adicionar"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.505"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/inputMessage" />

    <ListView
        android:id="@+id/listView"
        android:layout_width="320dp"
        android:layout_height="120dp"
        android:layout_marginTop="20dp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.494"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/btnAddMessage" />

    <TextView
        android:id="@+id/logBox"
        android:layout_width="320dp"
        android:layout_height="80dp"
        android:layout_marginTop="20dp"
        android:nestedScrollingEnabled="false"
        android:scrollbars="vertical"
        android:text="Logs:"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.494"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/btnSendRequest" />

</androidx.constraintlayout.widget.ConstraintLayout>

Como usar o exemplo de SMS em Kotlin:

Você pode usar a classe Message para criar os SMS e a classe MessageApi para enviar as mensagens 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 SendMultipleSms.kt

O código-fonte explicado neste artigo pode ser baixado, usado e modificado gratuitamente.
Download: SendMultipleSms.kt.zip (150Kb)

O que está no arquivo SendMultipleSms.kt.zip?

O arquivo SendMultipleSms.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)

projeto de exemplo para enviar múltiplos SMS usando Kotlin — Figura 2 - Diretório SendMultipleSms.kt

Como enviar múltiplos SMS a partir de Kotlin (Passos rápidos)

Para enviar múltiplos SMS a partir de 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 suas mensagens
Use o método Send para enviar 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 enviar SMS a partir de Kotlin, primeiro você precisa instalar o Ozeki SMS Gateway. O gateway de 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 "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 enviar múltiplos SMS a partir de 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 múltiplos SMS a partir de 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 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 de 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. Ela contém o número do destinatário e o texto da mensagem.

POST /api?action=sendmsg HTTP/1.1
Connection: Keep-Alive
Content-Length: 944
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":	"50fae4db-be52-4a79-905b-d51d1c83351b",
			"to_address":	"+36201111111",
			"text":	"Hello world 3",
			"create_date":	"2021-06-17T13:59:40",
			"valid_until":	"2021-06-24T13:59:40",
			"time_to_send":	"-999999999-01-01T00:00",
			"submit_report_requested":	true,
			"delivery_report_requested":	true,
			"view_report_requested":	true
		},
		{
			"message_id":	"6be6e16f-783e-4a88-ba7c-5f37553ee430",
			"to_address":	"+36202222222",
			"text":	"Hello world 2",
			"create_date":	"2021-06-17T13:59:58",
			"valid_until":	"2021-06-24T13:59:58",
			"time_to_send":	"-999999999-01-01T00:00",
			"submit_report_requested":	true,
			"delivery_report_requested":	true,
			"view_report_requested":	true
		},
		{
			"message_id":	"128495ae-7175-4219-bed5-5da3161e7c1a",
			"to_address":	"+36203333333",
			"text":	"Hello world 1",
			"create_date":	"2021-06-17T14:00:15",
			"valid_until":	"2021-06-24T14:00:15",
			"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: Thu, 17 Jun 2021 13:48:15 GMT
Server: 10/10.3.120
Transfer-Encoding: chunked
{
	"http_code": 200,
	"response_code": "SUCCESS",
	"response_msg": "Messages queued for delivery.",
	"data": {
	  "total_count": 3,
	  "success_count": 3,
	  "failed_count": 0,
	  "messages": [
	    {
	      "message_id": "50fae4db-be52-4a79-905b-d51d1c83351b",
	      "from_station": "%",
	      "to_address": "+36201111111",
	      "to_station": "%",
	      "text": "Hello world 3",
	      "create_date": "2021-06-17 13:59:40",
	      "valid_until": "2021-06-24 13:59:40",
	      "time_to_send": "2021-06-17 13:59:40",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    },
	    {
	      "message_id": "6be6e16f-783e-4a88-ba7c-5f37553ee430",
	      "from_station": "%",
	      "to_address": "+36202222222",
	      "to_station": "%",
	      "text": "Hello world 2",
	      "create_date": "2021-06-17 13:59:58",
	      "valid_until": "2021-06-24 13:59:58",
	      "time_to_send": "2021-06-17 13:59:58",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    },
	    {
	      "message_id": "128495ae-7175-4219-bed5-5da3161e7c1a",
	      "from_station": "%",
	      "to_address": "+36203333333",
	      "to_station": "%",
	      "text": "Hello world 1",
	      "create_date": "2021-06-17 14:00:15",
	      "valid_until": "2021-06-24 14:00:15",
	      "time_to_send": "2021-06-17 14:00:15",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    }
	  ]
	}
}

Como enviar vários 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 SendMultipleSms.kt. Ao abrir o projeto de exemplo, você 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 vários SMS usando Kotlin.

Vídeo 2 - Como enviar várias mensagens SMS com o código em Kotlin acima (Tutorial em vídeo)

Como verificar se o SMS foi aceito 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)

projeto em Kotlin para enviar várias mensagens SMS — Figura 3 - Projeto SendMultipleSms.kt no Android Studio

Como o aplicativo se parece em um telefone virtual

Como você pode ver na Figura 4, é possível enviar várias mensagens SMS ao mesmo tempo usando o aplicativo. Após o envio das mensagens, você pode ver um log abaixo do texto da mensagem. Lá, você pode obter mais informações sobre as mensagens enviadas. Ele notificará quantas mensagens foram enviadas com sucesso e quantas falharam. (Figura 4)

aplicativo de exemplo em Kotlin para enviar vários SMS — Figura 4 - Aplicativo de exemplo SendMultipleSms antes e depois do envio das mensagens

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 alterações que devem ser feitas 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.

Vídeo 3 - Como adicionar a biblioteca Ozeki.Libs.Rest ao seu próprio aplicativo (Tutorial em vídeo)

Dependências

É importante mencionar que a biblioteca Ozeki.Libs.Rest possui 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'

Código 1 - A lista de dependências que você precisa incluir.

Adicionando dependências (Tutorial em vídeo)

No vídeo a seguir, você aprenderá como adicionar as dependências mencionadas anteriormente ao seu projeto. Ele começará com a cópia do código e o guiará até as dependências funcionais. O vídeo tem apenas 53 segundos, mas apresenta todos os passos necessários para completar o processo. Você pode seguir este tutorial sem esforço.

Vídeo 4 - Como adicionar as dependências necessárias (Tutorial em vídeo)

Acesso à internet

Para que sua aplicação possa enviar uma requisição HTTP, você precisa permitir que sua aplicação se conecte à internet.
No vídeo a seguir, mostrarei como habilitar o acesso à internet para sua aplicação Kotlin.

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

Código 2 - Para habilitar o acesso à internet para sua aplicação Kotlin.

android:usesCleartextTraffic="true"

Código 3 - Para permitir o envio de requisições HTTP

Adicionando conexão à internet ao projeto (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. Você precisa adicionar ambas as linhas ao arquivo AndroidManifest.xml. O vídeo começará com a cópia do código e o guiará até uma conexão à internet funcional. Este vídeo é muito fácil de seguir, mas apresenta todos os passos que você precisa tomar de forma detalhada.

Vídeo 5 - Como permitir acesso à internet para sua aplicação (Tutorial em vídeo)

Para resumir

Este artigo ajuda você a configurar uma API HTTP de SMS no Ozeki SMS Gateway e a usar o código Kotlin fornecido para enviar múltiplas mensagens SMS. Esta solução é perfeita se você precisa encaminhar uma mensagem importante para vários clientes o mais rápido possível. É benéfico usar esta solução em seu aplicativo Kotlin para ter um sistema de compartilhamento de informações de alto desempenho.

Mais informações sobre este tópico podem ser encontradas na página da web da Ozeki. Continue lendo com o artigo intitulado Como agendar um SMS em Kotlin.

Agora baixe o Ozeki SMS Gateway e comece a desenvolver seu negócio!