Como receber SMS do Scala

A maneira mais simples de receber SMS do Scala é usar a API HTTP/Rest de SMS integrada do Ozeki SMS Gateway. Quando você usa essa API, receberá mensagens SMS enviando uma solicitação HTTP Get para o gateway de SMS. O HTTP Get conterá um nome de pasta de onde você deseja receber as mensagens. O gateway de SMS enviará todas as mensagens da pasta para sua aplicação cliente em Scala e retornará uma resposta HTTP 200 OK para sua solicitação.

O exemplo de código Scala para SMS abaixo demonstra como você pode enviar um SMS agendado usando a API HTTP Rest de SMS do Ozeki SMS Gateway com a biblioteca Ozeki.Libs.Rest em Scala. Esta biblioteca é fornecida gratuitamente, e você pode usá-la e modificá-la em qualquer um de seus projetos.

import Ozeki.Libs.Rest.{ Configuration, MessageApi }


object main  {
  def main(args: Array[String]): Unit = {
      
    val configuration = Configuration(
      Username = "http_user",
      Password = "qwe123",
      ApiUrl = "http://127.0.0.1:9509/api"
    )

    val api : MessageApi = MessageApi(configuration)

    val result = api.DownloadIncoming()

    println(result)

    for (message <- result.Messages) {
      println(message)
    }
  }
}
	

Como usar o exemplo de SMS em Scala:

Este exemplo de SMS em Scala pode ser usado em qualquer aplicação Scala. Para usá-lo, você deve baixar a biblioteca Ozeki.Libs.Rest. Após o download da biblioteca, você precisa adicionar uma referência a ela no seu código-fonte Scala. Isso permitirá que você use as classes fornecidas pela biblioteca Ozeki.Libs.Rest. Você pode usar a classe Message para criar o SMS. Você pode usar a classe MessageApi para receber o SMS no 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.

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

No ReceiveSms.scala.zip você encontrará o arquivo ReceiveSms.scala, que contém o código de exemplo para mostrar como enviar um SMS. Este código de exemplo está listado abaixo.

Para receber SMS do Scala:

1. Instale um usuário de API HTTP
2. Ative "Log communication events" na aba Advanced
3. Configure o Visual Studio
4. Baixe e extraia o arquivo ReceiveSms.scala.zip
5. Abra o projeto ReceiveSms.scala no IDE IntelliJ
6. Inicie o aplicativo Ozeki SMS Gateway
7. Execute o código Scala ReceiveSms.scala no IDE IntelliJ
8. Verifique os logs para ver se o SMS foi enviado

Para poder receber SMS do Scala, primeiro você precisa instalar o Ozeki SMS Gateway. O gateway de SMS pode ser instalado no mesmo computador onde você desenvolve seu código Scala em qualquer editor de texto, como o Bloco de Notas do Windows. Após a instalação, o próximo passo é conectar o Ozeki SMS Gateway à rede móvel. Você pode enviar um SMS de teste 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 fazer o exemplo funcionar sem modificações.

Após configurar o ambiente, você pode executar seu código Scala.

Para enviar SMS do Scala, seu código Scala terá que fazer uma solicitaçã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 a aplicação de SMS em Scala está sendo executada, 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
	

Para autenticar o cliente de SMS em Scala, você precisa enviar o nome de usuário e senha em uma string codificada em base64 para o servidor em uma solicitação HTTP. O formato usado é: base64(nome de usuário+":"+senha). Em Scala, você pode usar o seguinte código para fazer essa codificação:

val usernamePassword = "%s:%s".format(Username, Password).getBytes()
val usernamePasswordEncoded = Base64.getEncoder.encodeToString(usernamePassword)
"Basic %s".format(usernamePasswordEncoded)
	

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

Para receber as mensagens SMS, você precisa incluir as seguintes linhas como cabeçalhos na solicitaçã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==
	

Solicitação HTTP para receber SMS do Scala

Para enviar o SMS, sua aplicação Scala enviará uma solicitação HTTP semelhante à mostrada abaixo. Observe que esta solicitaçã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 os números dos destinatários e os textos das mensagens que enviamos.

GET /api?action=receivemsg&folder=inbox HTTP/1.1
HTTP2-Settings: AAEAAEAAAAIAAAABAAMAAABkAAQBAAAAAAUAAEAA
Connection: Upgrade, HTTP2-Settings
Upgrade: h2c
Content-Length: 0
Authorization: Basic aHR0cF91c2VyOnF3ZTEyMw==
Host: 127.0.0.1:9509
User-Agent: Java-http-client/16.0.1
	

Resposta HTTP recebida pelo exemplo de SMS em Scala

Assim que o gateway de 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. 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.123 (www.myozeki.com)
Content-Type: application/json; charset=utf8
Last-Modified: Thu, 15 Jul 2021 11:23:02 GMT
Server: 10/10.3.123
Transfer-Encoding: chunked

{
	"http_code": 200,
	"response_code": "SUCCESS",
	"response_msg": "",
	"data": {
	  "folder": "inbox",
	  "limit": "1000",
	  "data": [
	    {
	      "message_id": "bf1960cf-1474-40ac-85aa-5487a6edeb7f",
	      "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-07-13 11:51:57",
	      "valid_until": "2021-07-20 11:51:57",
	      "time_to_send": "2021-07-13 11:51:57",
	      "submit_report_requested": true,
	      "delivery_report_requested": false,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ]
	    },
	    {
	      "message_id": "df87cdf8-6e8b-4c99-a648-d2f24231bf04",
	      "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-07-13 11:51:57",
	      "valid_until": "2021-07-20 11:51:57",
	      "time_to_send": "2021-07-13 11:51:57",
	      "submit_report_requested": true,
	      "delivery_report_requested": false,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ]
	    },
	    {
	      "message_id": "7308e035-f92d-4515-9d21-9bb80ef26e74",
	      "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-07-13 11:51:57",
	      "valid_until": "2021-07-20 11:51:57",
	      "time_to_send": "2021-07-13 11:51:57",
	      "submit_report_requested": true,
	      "delivery_report_requested": false,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ]
	    }
	  ]
	}
}
	

Como receber SMS do Scala usando a API de SMS do Scala (Tutorial em vídeo)

Este vídeo mostra como baixar o arquivo ReceiveSms.scala.zip desta página. Se você assistir ao vídeo, notará que o conteúdo do ReceiveSms.scala.zip é colocado na área de trabalho do Windows. Você também verá que executamos o prompt de comando para enviar o SMS.

Exemplo de SMS em Scala: ReceiveSms.scala

O código de exemplo abaixo faz parte do ReceiveSms.scala.

Como verificar se o SMS foi aceito pelo usuário HTTP

Após o envio do SMS, é uma boa ideia verificar seu gateway de 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. O vídeo a seguir mostra o que procurar.

Resumo

Este guia mostrou os passos básicos para receber SMS em Scala com a ajuda do Ozeki SMS Gateway. Se todos os passos forem seguidos cuidadosamente, encaminhar as mensagens recebidas para um programa Scala deve ser muito simples. Com esta solução, você pode garantir que essas mensagens sejam coletadas onde elas devem estar. É importante notar que o Ozeki SMS Gateway é executado em um ambiente que você controla, então sua lista de contatos e dados estão em boas mãos.

Continue lendo na página de tutoriais da Ozeki, onde você pode encontrar mais informações sobre tópicos como agendamento de SMS em Scala.

A única coisa a fazer agora é baixar o Ozeki SMS Gateway e começar a trabalhar!