Jak wysłać wiele SMS-ów z Kotlina

Najprostszym sposobem wysyłania SMS-ów z Kotlina jest użycie wbudowanego interfejsu HTTP/Rest SMS API Ozeki SMS Gateway. Korzystając z tego API, będziesz wysyłać wiadomości SMS, wysyłając żądanie 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ć wiele sms-ów z kotlina
Rysunek 1 - Jak wysłać wiele SMS-ów z Kotlina

Poniższy przykładowy kod SMS w Kotlinie demonstruje, jak można wysłać wiele SMS-ów za pomocą interfejsu API REST SMS bramki SMS Ozeki przy użyciu biblioteki Kotlin Ozeki.Libs.Rest. Ta biblioteka jest dostarczana bezpłatnie i można ją używać oraz modyfikować w dowolnym projekcie.

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

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\nMusisz wypełnić wszystkie pola!", 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="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/textMsg"
        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" />

    <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="Wyślij"
        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="Dodaj"
        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="Logi:"
        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>
	

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

Możesz użyć klasy Message do tworzenia SMS-ów, a klasy MessageApi do wysyłania wiadomości SMS 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: SendMultipleSms.kt.zip (150Kb)

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

Plik SendMultipleSms.kt.zip zawiera przykładowy projekt, który posiada 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 wielu SMS-ów przy użyciu Kotlina
Rysunek 2 - Katalog SendMultipleSms.kt

Jak wysłać wiele SMS-ów z Kotlina (Szybkie kroki)

Aby wysłać wiele SMS-ów 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. Zainstaluj Android Studio
  6. Pobierz powyższy przykładowy projekt
  7. Utwórz SMS, tworząc nowy obiekt Message
  8. Utwórz API do wysyłania wiadomości
  9. Użyj metody Send, aby wysłać wiadomości
  10. Odczytaj odpowiedź 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 następnym 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ć wiele SMS-ów z Kotlina, Twój kod Kotlina 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 wielu 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 wysłać SMS, Twoja aplikacja Kotlina 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: 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
		}
	]
}
	

Odpowiedź HTTP otrzymana przez przykład SMS w Kotlinie

Gdy brama SMS otrzyma 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, dostarczając przydatne informacje 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: 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"
	    }
	  ]
	}
}
	

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

Ten film pokazuje, jak pobrać i użyć projektu SendMultipleSms.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 wysyłać wiele SMS-ów przy użyciu Kotlina.

Wideo 2 - Jak wysłać wiele wiadomości 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 bramie SMS, co zostało odebrane. Możesz sprawdzić log, otwierając szczegóły użytkownika HTTP w konsoli zarządzania bramą SMS Ozeki. 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 wielu wiadomości SMS
Rysunek 3 - Projekt SendMultipleSms.kt w Android Studio

Jak wygląda korzystanie z aplikacji na wirtualnym telefonie

Jak widać na Rysunku 4, możesz wysłać wiele wiadomości SMS jednocześnie, korzystając z aplikacji. Po wysłaniu wiadomości możesz zobaczyć log po tekście wiadomości. Tam możesz uzyskać więcej informacji o wysłanych wiadomościach. Aplikacja powiadomi Cię, ile wiadomości zostało wysłanych pomyślnie, a ile nie. (Rysunek 4)

przykładowa aplikacja w Kotlinie do wysyłania wielu wiadomości SMS

Rysunek 4 - Przykładowa aplikacja SendMultipleSms 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, kilka rzeczy należy 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 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 należy uwzględnić.

Dodawanie zależności (Samouczek wideo)

W poniższym filmie dowiesz się, jak dodać wcześniej wspomniane zależności do swojego projektu. Zaczniemy od skopiowania kodu i przejdziemy przez wszystkie kroki aż do działających zależności. Film trwa tylko 53 sekundy, ale zawiera wszystkie niezbędne kroki do wykonania procesu. Możesz bez wysiłku śledzić ten samouczek.

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

Dostęp do internetu

Aby umożliwić Twojej aplikacji wysyłanie żądań HTTP, musisz zezwolić aplikacji 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

Dodawanie połączenia internetowego do 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. Film zacznie się od skopiowania kodu i przeprowadzi Cię przez wszystkie kroki aż do działającego połączenia internetowego. Ten film jest bardzo łatwy do śledzenia, ale zawiera wszystkie niezbędne kroki w szczegółowy sposób.

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

Podsumowanie

Ten artykuł pomaga Ci skonfigurować HTTP SMS API w Ozeki SMS Gateway oraz użyć podanego kodu Kotlin do wysyłania wielu wiadomości SMS. To rozwiązanie jest idealne, jeśli musisz szybko przesłać ważną wiadomość do wielu klientów. Korzystanie z tego rozwiązania w Twojej aplikacji Kotlin pozwoli Ci na stworzenie wydajnego systemu wymiany informacji.

Więcej informacji na ten temat można znaleźć na stronie Ozeki. Kontynuuj czytanie artykułu pt. Jak zaplanować SMS w Kotlin.

Pobierz teraz Ozeki SMS Gateway i zacznij rozwijać swój biznes!

More information