Jak wysłać SMS z Kotlina

Najprostszym sposobem na wysłanie SMS-a z Kotlina jest użycie wbudowanego interfejsu HTTP/Rest SMS API Ozeki SMS Gateway. Korzystając z tego API, wysyłasz wiadomości SMS poprzez wysłanie żądania HTTP Post do bramki SMS. Żądanie HTTP Post będzie zawierać wiadomość sformatowaną w formacie JSON. Bramka SMS wyśle tę wiadomość SMS na telefon odbiorcy i zwróci odpowiedź HTTP 200 OK na Twoje żądanie. (Rysunek 1)

jak wysłać sms z kotlina
Rysunek 1 - Jak wysłać SMS z Kotlina

Poniższy przykładowy kod SMS w Kotlinie demonstruje, jak można wysyłać SMS-y za pomocą http rest SMS API bramki SMS Ozeki, używając biblioteki Kotlin Ozeki.Libs.Rest. Ta biblioteka jest dostarczana bezpłatnie i możesz jej używać oraz modyfikować w dowolnych swoich projektach.

Wideo 1 - Jak pobrać przykład SendSms.kt.zip (Samouczek wideo)

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())
                }
            }
        }
    }
}
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="send.sms.MainActivity">

    <Button
        android:id="@+id/btnSendRequest"
        android:layout_width="320dp"
        android:layout_height="50dp"
        android:layout_marginBottom="24dp"
        android:text="Wyślij"
        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="Witaj świecie!"
        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="Wiadomość:"
        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="Adres odbiorcy:"
        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>

Jak używać przykładu SMS w Kotlinie:

Możesz użyć klasy Message do tworzenia SMS-ów, a klasy MessageApi do wysyłania SMS-ów do bramki SMS. Bramka SMS przekaże twoją wiadomość do sieci komórkowej za pośrednictwem połączenia bezprzewodowego lub przez Internet.

Kod źródłowy omówiony w tym artykule można pobrać, używać i modyfikować bezpłatnie.
Pobierz: SendSms.kt.zip (148Kb)

Co znajduje się w pliku SendSms.kt.zip?

Plik SendSms.kt.zip zawiera przykładowy projekt, który zawiera bibliotekę Ozeki.Libs.Rest. Dzięki tej bibliotece możesz wysyłać, usuwać, oznaczać i odbierać wiadomości SMS, tworząc MessageApi i używając metod Send(), Delete(), Mark() oraz Receive(). (Rysunek 2)

przykładowy projekt do wysyłania sms przy użyciu node js
Rysunek 2 - Katalog SendSms.kt

Jak wysłać SMS z Kotlina (Szybkie kroki)

Aby wysłać SMS z Kotlina:

  1. Zainstaluj Ozeki SMS Gateway
  2. Podłącz Ozeki SMS Gateway do sieci komórkowej
  3. Wyślij testową wiadomość SMS z interfejsu Ozeki
  4. Utwórz użytkownika API SMS HTTP
  5. Android Studio
  6. Pobierz powyższy przykładowy projekt
  7. Utwórz wiadomość SMS, tworząc nowy obiekt Message
  8. Utwórz API do wysłania wiadomości
  9. Użyj metody Send, aby wysłać wiadomość
  10. Odczytaj odpowiedź na konsoli
  11. Sprawdź logi w bramce SMS

Zainstaluj Ozeki SMS Gateway i utwórz użytkownika API HTTP

Aby móc wysyłać SMS z Kotlina, najpierw musisz zainstalować Ozeki SMS Gateway. Bramka SMS może być zainstalowana na tym samym komputerze, na którym tworzysz swój kod Kotlin w Android Studio. Po instalacji następnym krokiem jest podłączenie Ozeki SMS Gateway do sieci komórkowej. Możesz utworzenie użytkownika API SMS HTTP. Utwórz użytkownika z nazwą "http_user" i hasłem "qwe123", aby przykład działał bez modyfikacji.

Po skonfigurowaniu środowiska możesz uruchomić swój kod Kotlin.

URL API HTTP do wysyłania SMS z Kotlina

Aby wysłać SMS z Kotlina, Twój Kotlin będzie musiał wysłać żądanie HTTP do bramki SMS. URL API jest pokazany poniżej. Należy zauważyć, że adres IP (127.0.0.1) powinien zostać zastąpiony adresem IP Twojej bramki SMS. Jeśli Ozeki SMS Gateway jest zainstalowany na tym samym komputerze, na którym działa aplikacja SMS w JavaScript, może to być 127.0.0.1. Jeśli jest zainstalowany na innym komputerze, powinien to być adres IP tego komputera. 

http://127.0.0.1:9509/api?action=rest

Uwierzytelnianie HTTP do wysyłania SMS z Kotlina

Aby uwierzytelnić klienta SMS w Kotlinie, musisz wysłać nazwę użytkownika i hasło w zakodowanym ciągu base64 do serwera w żądaniu HTTP. Używany format to: base64(nazwa_użytkownika+":"+hasło). W Kotlinie możesz użyć następującego kodu, aby wykonać to kodowanie: 

var usernamePassword = "%s:%s".format(username, password)
return "Basic %s".format(Base64.getEncoder().encodeToString(usernamePassword.toByteArray()))

Na przykład, jeśli zakodujesz nazwę użytkownika 'http_user' i hasło 'qwe123', otrzymasz następujący zakodowany ciąg base64: aHR0cF91c2VyOnF3ZTEyMw==. Aby wysłać

Nagłówek żądania HTTP do wysyłania SMS z Kotlina

Aby wysłać wiadomości SMS, musisz uwzględnić następujące linie jako nagłówki w żądaniu HTTP. Należy zauważyć, że zawieramy nagłówek Content-Type i Authorization. 

Content-Type: application/json
Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==

Żądanie HTTP do wysyłania SMS z Kotlina

Aby przesłać SMS, Twoja aplikacja Kotlin wyśle żądanie HTTP podobne do poniższego. Należy zauważyć, że to żądanie zawiera część nagłówka HTTP i część ciała HTTP. Ciało HTTP to ciąg danych zakodowany w JSON. Zawiera numer odbiorcy i tekst wiadomości. 

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
		}
	]
}

Odebrana odpowiedź HTTP w przykładzie SMS w Kotlinie

Gdy brama SMS odbierze to żądanie, wygeneruje odpowiedź HTTP. Odpowiedź HTTP będzie zawierać kod statusu, wskazujący, czy żądanie wysłania SMS zakończyło się sukcesem czy nie. Zwróci również strukturę zakodowaną w formacie JSON, aby dostarczyć przydatnych informacji o przesłaniu wiadomości. 

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": "Messages queued for delivery.",
	"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": "Hello world!",
	      "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"
	    }
	  ]
	}
}

Jak wysłać SMS z Kotlina przy użyciu API SMS i powyższego projektu przykładowego (Samouczek wideo)

Ten film pokazuje, jak pobrać i użyć projektu SendSms.kt. Po otwarciu przykładowego projektu możesz zauważyć, że istnieje pakiet o nazwie Ozeki.Libs.Rest. To właśnie ten pakiet zawiera MessageApi i wszystko, czego potrzebujesz, aby wysłać SMS przy użyciu Kotlina.

Wideo 2 - Jak wysłać SMS za pomocą powyższego kodu w Kotlinie (Samouczek wideo)

Jak sprawdzić, czy SMS został zaakceptowany przez użytkownika HTTP

Po przesłaniu SMS-a warto sprawdzić w bramce SMS, co zostało odebrane. Możesz sprawdzić logi, otwierając szczegóły użytkownika HTTP w konsoli zarządzania Ozeki SMS Gateway. Na końcu powyższego filmu możesz zobaczyć, jak sprawdzić, czy żądanie zostało odebrane przez http_user. (Rysunek 3)

projekt w kotlinie do wysyłania wiadomości sms
Rysunek 3 - Projekt SendSms.kt w Android Studio

Jak wygląda korzystanie z aplikacji

Na Rysunku 4 widać, jak wygląda aplikacja po wysłaniu wiadomości. Jak widać, wcześniej wysłane wiadomości będą przechowywane jako log pod polem tekstowym 'Message'. Możesz zobaczyć wszystkie informacje o wiadomości, takie jak nadawca, tekst i wynik procedury wysyłania.

przykładowa aplikacja w kotlinie do wysyłania sms
Rysunek 4 - Przykładowa aplikacja SendSms przed i po wysłaniu wiadomości

Jak sprawdzić, czy SMS został wysłany do sieci komórkowej

Ostatnim krokiem weryfikacji procedury jest sprawdzenie logów połączenia z siecią komórkową. Może być konieczne włączenie logowania w konfiguracji połączenia przed wysłaniem wiadomości, aby zobaczyć logi. Jeśli logowanie jest włączone, zobaczysz numer telefonu i tekst wysłanej wiadomości.

Wideo 3 - Jak sprawdzić, czy klient SMPP odebrał nasze żądanie (Samouczek wideo)

Jak dodać Ozeki.Libs.Rest do własnego projektu

Bibliotekę Ozeki.Libs.Rest można pobrać, używać i modyfikować bezpłatnie.
Pobierz: Ozeki.Libs.Rest.kt.zip (7.66Kb)

Jeśli zdecydujesz się stworzyć swoją aplikację samodzielnie, tylko z biblioteką Ozeki.Libs.Rest, jest kilka rzeczy, które powinieneś zmienić w podstawowej aplikacji. Aby użyć biblioteki Ozeki.Libs.Rest, musisz umieścić ją w folderze java głównego katalogu.
W poniższym filmie pokażę, jak pobrać i dodać bibliotekę Ozeki.Libs.Rest do własnego projektu.

Wideo 4 - Jak dodać bibliotekę Ozeki.Libs.Rest do własnej aplikacji (Samouczek wideo)

Zależności

Warto wspomnieć, że biblioteka Ozeki.Libs.Rest ma pewne zależności. Aby jej użyć, musisz dodać te zależności do 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'

Kod 1 - Lista zależności, które należy uwzględnić.

Dodawanie zależności (samouczek wideo)

W poniższym filmie dowiesz się, jak dodać wcześniej wspomniane zależności. Zaczniemy od skopiowania kodu i przejdziemy przez cały proces aż do pomyślnego dodania zależności. Film trwa tylko 53 sekundy, ale zawiera wszystkie niezbędne kroki do wykonania tej czynności. Możesz bez wysiłku śledzić ten samouczek.

Wideo 5 - Jak dodać wymagane zależności (Samouczek wideo)

Dostęp do internetu

Aby umożliwić Twojej aplikacji wysyłanie żądań HTTP, musisz zezwolić jej na łączenie się z internetem.
W poniższym filmie pokażę Ci, jak włączyć dostęp do internetu dla Twojej aplikacji Kotlin. 

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

Kod 2 - Aby włączyć dostęp do internetu dla Twojej aplikacji Kotlin.

android:usesCleartextTraffic="true"

Kod 3 - Aby umożliwić wysyłanie żądań HTTP

Jak włączyć połączenie internetowe dla Twojej aplikacji (Samouczek wideo)

Musisz dodać obie te linie do pliku AndroidManifest.xml.
W poniższym filmie pokażę Ci, gdzie należy umieścić powyższe kody. Film zacznie się od skopiowania kodu i przeprowadzi Cię przez proces aż do pomyślnego dodania połączenia internetowego. Ten film jest szczegółowy i ułatwia jego śledzenie.

Wideo 6 - Jak zezwolić na dostęp do internetu dla Twojej aplikacji (Samouczek wideo)

Podsumowanie

Celem tego przewodnika było pokazanie, jak wysyłać wiadomości SMS z Kotlina za pomocą HTTP SMS API bramki SMS Ozeki. Zdobyta wiedza umożliwia utrzymywanie kontaktu z klientami za pomocą prostego kodu Kotlin. Międzynarodowe wysyłanie wiadomości również jest możliwe dzięki bramce SMS Ozeki, ponieważ działa ona w każdym kraju i może wysyłać oraz odbierać SMS-y przez różne połączenia mobilne.

Upewnij się, że kontynuujesz naukę tutaj, odwiedzając inne strony z samouczkami na stronie Ozeki, aby uzyskać więcej informacji. Sprawdź więcej przewodników dotyczących używania Kotlina, zacznij od Jak wysyłać wiele SMS-ów z Kotlina.

Teraz pierwszą rzeczą, którą musisz zrobić, jest pobranie bramki SMS Ozeki i rozpoczęcie korzystania z niej!

More information