Jak zaplanować SMS w Kotlinie

Najprostszym sposobem wysyłania SMS-ów z Kotlina jest użycie wbudowanego interfejsu HTTP/Rest SMS API Ozeki SMS Gateway. Kiedy używasz 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 zaplanować sms w kotlinie
Rysunek 1 - Jak zaplanować SMS w Kotlinie

Poniższy przykładowy kod SMS w Kotlinie demonstruje, jak można wysłać zaplanowaną wiadomość SMS za pomocą interfejsu API REST SMS bramki Ozeki SMS Gateway, korzystając z biblioteki Kotlin Ozeki.Libs.Rest. Ta biblioteka jest dostarczana bezpłatnie i można ją używać oraz modyfikować w dowolnych projektach.

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

MainActivity.kt 
package send.scheduledsms

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import Ozeki.Libs.Rest.Configuration
import Ozeki.Libs.Rest.MessageApi
import Ozeki.Libs.Rest.Message
import android.text.method.ScrollingMovementMethod
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 date:android.widget.EditText = findViewById(R.id.inputTimeToSendDate)
        val time:android.widget.EditText = findViewById(R.id.inputTimeToSendTime)
        val btnSendRequest:android.widget.Button = findViewById(R.id.btnSendRequest)
        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() != ""
                && date.text.toString() != "" && time.text.toString() != "") {
                val datetime = String.format("%s %s", date.text.toString(), time.text.toString())
                val msg = Message()
                msg.ToAddress = inputToAddress.text.toString()
                msg.Text = inputMessage.text.toString()
                msg.TimeToSend = datetime
                GlobalScope.launch(Dispatchers.IO) {
                    val response = api.Send(msg)
                    logBox.text = String.format("%s\n%s", logBox.text, response.toString())
                }
                inputToAddress.text.clear()
                inputMessage.text.clear()
                date.text.clear()
                time.text.clear()
            }
        }

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

    <Button
        android:id="@+id/btnSendRequest"
        android:layout_width="320dp"
        android:layout_height="50dp"
        android:layout_marginTop="36dp"
        android:text="Wyślij"
        android:backgroundTint="#FF3F3F"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.494"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/logBox" />

    <TextView
        android:id="@+id/textToAddress"
        android:layout_width="320dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="36dp"
        android:text="Adres odbiorcy:"
        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/textMessage"
        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/textWhen"
        android:layout_width="320dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:text="Czas wysłania:"
        android:textSize="20sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.494"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/inputMessage" />

    <EditText
        android:id="@+id/inputToAddress"
        android:layout_width="320dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:ems="10"
        android:hint="+36201111111"
        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="100dp"
        android:layout_marginTop="20dp"
        android:ems="10"
        android:gravity="start|top"
        android:hint="Witaj świecie!"
        android:inputType="textMultiLine"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.505"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textMessage" />

    <EditText
        android:id="@+id/inputTimeToSendTime"
        android:layout_width="120dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:layout_marginEnd="44dp"
        android:ems="10"
        android:hint="15:30:00"
        android:inputType="time"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textWhen" />

    <TextView
        android:id="@+id/logBox"
        android:layout_width="320dp"
        android:layout_height="80dp"
        android:layout_marginTop="20dp"
        android:scrollbars="vertical"
        android:text="Logi:"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.505"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/inputTimeToSendTime" />

    <EditText
        android:id="@+id/inputTimeToSendDate"
        android:layout_width="180dp"
        android:layout_height="wrap_content"
        android:layout_marginTop="20dp"
        android:layout_marginEnd="24dp"
        android:ems="10"
        android:hint="2021-06-16"
        android:inputType="date"
        app:layout_constraintEnd_toStartOf="@+id/inputTimeToSendTime"
        app:layout_constraintHorizontal_bias="1.0"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textWhen" />
</androidx.constraintlayout.widget.ConstraintLayout>

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

Możesz użyć klasy Message do utworzenia SMS-a, a klasy MessageApi do wysłania zaplanowanej wiadomości SMS do bramki SMS. Bramka SMS przekaże Twoją wiadomość do sieci komórkowej albo przez połączenie bezprzewodowe, albo przez Internet.

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

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

Plik SendScheduledSms.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 zaplanowanych SMS-ów przy użyciu Kotlina
Rysunek 2 - Katalog SendScheduledSms.kt

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

Aby wysłać zaplanowanego SMS-a z Kotlina:

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

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

Aby móc wysyłać SMS-y 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 Kotlina w Android Studio. Po instalacji kolejnym krokiem jest podłączenie Ozeki SMS Gateway do sieci komórkowej. Możesz utworzenie użytkownika HTTP SMS API. 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 Kotlina.

URL API HTTP do wysyłania SMS-ów z Kotlina

Aby wysłać zaplanowanego SMS-a z Kotlina, Twój Kotlin będzie musiał wysłać żądanie HTTP do bramki SMS. URL API jest pokazany poniżej. Pamiętaj, ż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 zaplanowanych SMS-ów 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 do wykonania tego kodowania: 

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-ów z Kotlina

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

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

Żądanie HTTP do wysyłania SMS-ów z Kotlina

Aby przesłać SMS, Twoja aplikacja Kotlin wyśle żądanie HTTP podobne do poniższego. Pamiętaj, ż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: 320
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":	"e68f8e11-dce2-48e2-a2c5-1d2efa98272a",
			"to_address":	"+36201111111",
			"text":	"Hello world!",
			"create_date":	"2021-06-17T15:04:03",
			"valid_until":	"2021-06-24T15:04:03",
			"time_to_send":	"2021-06-17 15:10:00",
			"submit_report_requested":	true,
			"delivery_report_requested":	true,
			"view_report_requested":	true
		}
	]
}

Odpowiedź HTTP otrzymana przez przykład SMS w Kotlinie

Po otrzymaniu tego żądania, brama SMS 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, dostarczając przydatne informacje dotyczące wysłania wiadomości. 

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 14:56:26 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": "e68f8e11-dce2-48e2-a2c5-1d2efa98272a",
	      "from_station": "%",
	      "to_address": "+36201111111",
	      "to_station": "%",
	      "text": "Hello world!",
	      "create_date": "2021-06-17 15:04:03",
	      "valid_until": "2021-06-24 15:04:03",
	      "time_to_send": "2021-06-17 15:10:00",
	      "submit_report_requested": true,
	      "delivery_report_requested": true,
	      "view_report_requested": false,
	      "tags": [
	        {
	          "name": "Type",
	          "value": "SMS:TEXT"
	        }
	      ],
	      "status": "SUCCESS"
	    }
	  ]
	}
}

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

Ten film pokazuje, jak pobrać i użyć projektu SendScheduledSms.kt. Po otwarciu przykładowego projektu możesz zauważyć, że istnieje pakiet o nazwie Ozeki.Libs.Rest. To pakiet zawierający MessageApi i wszystko, czego potrzebujesz, aby wysłać zaplanowanego SMS-a przy użyciu Kotlina.

Wideo 2 - Jak wysłać zaplanowanego SMS-a przy użyciu kodu Kotlina powyżej (Samouczek wideo)

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

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

projekt kotlin do wysyłania zaplanowanych wiadomości sms
Rysunek 3 - Projekt SendScheduledSms.kt w Android Studio

Jak wygląda korzystanie z aplikacji na telefonie (Samouczek wideo)

Na Rysunku 4 możesz zobaczyć interfejs użytkownika aplikacji na telefonie. Jak widać na zdjęciach przed i po, wysyłanie zaplanowanych SMS-ów jest bardzo proste z tą aplikacją. Po wysłaniu wiadomości log procesu wysyłania będzie widoczny pod polem tekstowym 'Time to send'. Możesz tutaj uzyskać wszystkie informacje dotyczące wysłanej wiadomości.

przykładowa aplikacja kotlin do wysyłania zaplanowanych sms-ów

Rysunek 4 - Przykładowa aplikacja SendScheduledSms przed i po wysłaniu wiadomości

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 swojej 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 3 - 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 musisz uwzględnić.

Dodawanie zależności do projektu (Samouczek wideo)

W poniższym filmie dowiesz się, jak dodać wcześniej wspomniane zależności. Zaczniemy od skopiowania kodu i przejdziemy przez proces do pomyślnie dołączonych zależności. Film trwa tylko 53 sekundy, ale zawiera wszystkie niezbędne kroki do ukończenia procesu. Możesz śledzić ten samouczek bez żadnego wysiłku.

Wideo 4 - Jak dodać potrzebne zależności (Samouczek wideo)

Dostęp do internetu

Aby umożliwić Twojej aplikacji wysyłanie żądań HTTP, musisz zapewnić jej możliwość łączenia 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

Włączanie połączenia internetowego dla Twojego projektu (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. 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 i wklejenia kodu, a następnie przeprowadzi Cię przez proces pomyślnie dodanego połączenia internetowego. Ten film jest szczegółowy i ułatwia jego śledzenie.

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

Podsumowanie

Ten przewodnik pokazuje kroki planowania SMS w Kotlinie z wykorzystaniem HTTP w Ozeki SMS Gateway. Planowanie SMS-ów w celu dostarczania wiadomości, gdy Twoi klienci mają czas na ich przeczytanie, pomaga utrzymać z nimi dobre relacje. Dbanie o drobiazgi, takie jak znalezienie idealnego momentu na przekazanie myśli i informacji, jest kluczowe, jeśli chcesz pokazać, jak profesjonalna jest Twoja firma.

Kontynuuj czytanie podobnych samouczków na stronie Ozeki. Znajdziesz tam więcej informacji na temat używania Kotlina do obsługi wiadomości SMS. Następnie naucz się Jak odbierać SMS w Kotlinie.

Pobierz Ozeki SMS Gateway już teraz i wykorzystaj to, czego się nauczyłeś!

More information