Jak odeslat SMS z Kotlinu

Nejjednodušší způsob, jak odeslat SMS z Kotlinu, je použít vestavěné HTTP/Rest SMS API Ozeki SMS Gateway. Když použijete toto API, budete odesílat SMS zprávy vytvořením HTTP Post požadavku na SMS bránu. HTTP Post požadavek bude obsahovat zprávu ve formátu JSON. SMS brána následně odešle tuto SMS na cílové telefonní číslo a vrátí HTTP 200 OK odpověď na váš požadavek. (Obrázek 1)

jak odeslat sms z kotlinu
Obrázek 1 - Jak odeslat SMS z Kotlinu

Následující ukázka kódu Kotlin pro SMS demonstruje, jak můžete odesílat SMS pomocí http rest SMS API Ozeki SMS Gateway s využitím knihovny Kotlin Ozeki.Libs.Rest. Tato knihovna je vám poskytována zdarma a můžete ji používat a upravovat v jakémkoli ze svých projektů.

Video 1 - Jak stáhnout příklad SendSms.kt.zip (Návod ve videu)

MainActivity.kt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
<?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="Odeslat"
        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="Ahoj světe!"
        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="Zpráva:"
        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="Příjemce:"
        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 používat příklad Kotlin pro SMS:

Můžete použít třídu Message k vytvoření SMS a třídu MessageApi k odeslání SMS do SMS brány. SMS brána přepošle vaši zprávu do mobilní sítě buď prostřednictvím bezdrátového připojení nebo přes internet.

Stáhnout SendSms.kt

Zdrojový kód popsaný v tomto článku lze zdarma stáhnout, použít a upravit.
Stáhnout: SendSms.kt.zip (148Kb)

Co obsahuje soubor SendSms.kt.zip?

Soubor SendSms.kt.zip obsahuje ukázkový projekt, který obsahuje knihovnu Ozeki.Libs.Rest. S touto knihovnou můžete odesílat, mazat, označovat a přijímat SMS zprávy vytvořením MessageApi a použitím metod Send(), Delete(), Mark() a Receive(). (Obrázek 2)

ukázkový projekt pro odesílání sms pomocí node js
Obrázek 2 - Adresář SendSms.kt

Jak odeslat SMS z Kotlinu (Rychlé kroky)

Pro odeslání SMS z Kotlinu:

  1. Nainstalujte Ozeki SMS Gateway
  2. Připojte Ozeki SMS Gateway k mobilní síti
  3. Odešlete testovací SMS z Ozeki GUI
  4. Vytvořte HTTP SMS API uživatele
  5. Android Studio
  6. Stáhněte výše uvedený ukázkový projekt
  7. Vytvořte SMS vytvořením nového objektu Message
  8. Vytvořte API pro odeslání zprávy
  9. Použijte metodu Send pro odeslání zprávy
  10. Přečtěte si odpověď na konzoli
  11. Zkontrolujte protokoly v SMS gateway

Instalace Ozeki SMS Gateway a vytvoření HTTP API uživatele

Pro odesílání SMS z Kotlinu je nejprve nutné nainstalovat Ozeki SMS Gateway. SMS gateway lze nainstalovat na stejný počítač, kde vyvíjíte svůj Kotlin kód v Android Studiu. Po instalaci je dalším krokem připojení Ozeki SMS Gateway k mobilní síti. Můžete odeslat testovací SMS z Ozeki GUI pro ověření, že vaše připojení k mobilní síti funguje. Posledním krokem přípravy prostředí je vytvoření HTTP SMS API uživatele. Vytvořte uživatele s uživatelským jménem "http_user" a heslem "qwe123", aby ukázka fungovala bez úprav.

Po nastavení prostředí můžete spustit svůj Kotlin kód.

HTTP API URL pro odesílání SMS z Kotlinu

Pro odesílání SMS z Kotlinu musí váš Kotlin kód odeslat HTTP požadavek na SMS gateway. API URL je uvedeno níže. Poznámka: IP adresa (127.0.0.1) by měla být nahrazena IP adresou vaší SMS gateway. Pokud je Ozeki SMS Gateway nainstalován na stejném počítači, kde běží JavaScriptová SMS aplikace, může to být 127.0.0.1. Pokud je nainstalován na jiném počítači, měla by to být IP adresa tohoto počítače.

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

HTTP autentizace pro odesílání SMS z Kotlinu

Pro autentizaci Kotlin SMS klienta je nutné odeslat uživatelské jméno a heslo v base64 kódovaném řetězci na server v HTTP požadavku. Použitý formát je: base64(username+":"+password). V Kotlinu můžete pro toto kódování použít následující kód:

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

Například pokud zakódujete uživatelské jméno 'http_user' a heslo 'qwe123', získáte následující base64 kódovaný řetězec: aHR0cF91c2VyOnF3ZTEyMw==. Pro odeslání

HTTP hlavička požadavku pro odesílání SMS z Kotlinu

Pro odeslání SMS zpráv je nutné do HTTP požadavku zahrnout následující řádky jako hlavičky. Poznámka: Zahrnujeme hlavičku Content-Type a Authorization.

1
2
3
Content-Type: application/json
Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
     

HTTP požadavek pro odesílání SMS z Kotlinu

Pro odeslání SMS váš Kotlin aplikace odešle HTTP požadavek podobný tomuto níže. Poznámka: Tento požadavek obsahuje část HTTP hlavičky a část HTTP těla. HTTP tělo je JSON kódovaný datový řetězec. Obsahuje číslo příjemce a text zprávy.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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
        }
    ]
}
     

HTTP odpověď přijatá příkladem SMS v Kotlinu

Jakmile SMS brána obdrží tento požadavek, vygeneruje HTTP odpověď. Tato HTTP odpověď bude obsahovat stavový kód, který indikuje, zda byl požadavek na odeslání SMS úspěšný nebo ne. Dále vrátí strukturu zakódovanou v JSONu, která poskytuje užitečné detaily o odeslání zprávy.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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": "Zprávy zařazeny k odeslání.",
    "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 odeslat SMS z Kotlinu pomocí SMS API a výše uvedeného příkladu (Video návod)

Toto video vám ukáže, jak stáhnout a použít projekt SendSms.kt. Jakmile otevřete příklad projektu, můžete si všimnout, že obsahuje balíček nazvaný Ozeki.Libs.Rest. Tento balíček obsahuje MessageApi a vše, co potřebujete k odeslání SMS pomocí Kotlinu.

Video 2 - Jak odeslat SMS pomocí výše uvedeného kódu v Kotlinu (Video návod)

Jak ověřit, že SMS byla přijata HTTP uživatelem

Po odeslání SMS je dobré zkontrolovat vaši SMS bránu, abyste viděli, co přijala. Protokoly můžete zkontrolovat otevřením detailů HTTP uživatele v konzoli pro správu Ozeki SMS brány. Na konci výše uvedeného videa uvidíte, jak ověřit, zda byl požadavek přijat http_user. (Obrázek 3)

kotlin projekt pro odeslání sms zprávy
Obrázek 3 - Projekt SendSms.kt v Android Studiu

Jak vypadá použití aplikace

Na obrázku 4 můžete vidět, jak vypadá aplikace po odeslání zprávy. Jak vidíte, dříve odeslané zprávy jsou uloženy jako log pod textovým polem 'Zpráva'. Můžete vidět všechny informace o zprávě, jako je odesílatel, text a výsledek procesu odeslání.

příklad kotlin aplikace pro odeslání sms
Obrázek 4 - Příklad aplikace SendSms před a po odeslání zprávy

Jak ověřit, že SMS byla odeslána do mobilní sítě

Posledním krokem při ověřování procesu je podívat se na protokoly připojení k mobilní síti. Možná budete muset před odesláním zprávy zapnout protokolování v konfiguraci připojení, abyste viděli protokoly. Pokud je protokolování zapnuto, uvidíte telefonní číslo a text odeslané zprávy.

Video 3 - Jak otestovat, zda SMPP klient přijal náš požadavek (Video návod)

Jak přidat Ozeki.Libs.Rest do vlastního projektu

Knihovnu Ozeki.Libs.Rest lze stáhnout, používat a upravovat zdarma.
Stáhnout: Ozeki.Libs.Rest.kt.zip (7.66Kb)

Pokud se rozhodnete vytvořit svou aplikaci sami pouze s knihovnou Ozeki.Libs.Rest, musíte v základní aplikaci změnit několik věcí. Pro použití knihovny Ozeki.Libs.Rest ji musíte umístit do složky java hlavního adresáře
V následujícím videu vám ukážu, jak stáhnout a přidat knihovnu Ozeki.Libs.Rest do vašeho vlastního projektu.

Video 4 - Jak přidat knihovnu Ozeki.Libs.Rest do vaší vlastní aplikace (Video návod)

Závislosti

Je důležité zmínit, že knihovna Ozeki.Libs.Rest má některé závislosti. Pro její použití musíte tyto závislosti přidat do Gradle Scripts.

1
2
3
4
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'
     

Kód 1 - Seznam závislostí, které je třeba zahrnout.

V následujícím videu se naučíte, jak přidat výše zmíněné závislosti. Začneme kopírováním kódu a provedeme vás celým procesem až k úspěšnému přidání závislostí. Video je dlouhé pouze 53 sekund, ale obsahuje všechny potřebné kroky k dokončení procesu. Tento návod můžete snadno sledovat.

Video 5 - Jak přidat potřebné závislosti (Videonávod)

Přístup k internetu

Aby vaše aplikace mohla odesílat HTTP požadavky, musíte jí umožnit připojení k internetu.
V následujícím videu vám ukážu, jak povolit internetový přístup pro vaši Kotlin aplikaci.

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

Kód 2 - Povolení internetového přístupu pro vaši Kotlin aplikaci.

1
2
android:usesCleartextTraffic="true"
     

Kód 3 - Pro umožnění odesílání HTTP požadavků

Jak povolit internetové připojení pro vaši aplikaci (Videonávod)

Musíte přidat oba tyto řádky do souboru AndroidManifest.xml.
V následujícím videu vám ukážu, kam byste měli výše uvedené kódy umístit. Video začne kopírováním kódu a provede vás až k úspěšnému přidání internetového připojení. Toto video je podrobné a snadno se podle něj postupuje.

Video 6 - Jak povolit internetový přístup pro vaši aplikaci (Videonávod)

Závěr

Cílem tohoto průvodce bylo ukázat vám, jak odesílat SMS zprávy z Kotlinu pomocí HTTP SMS API Ozeki SMS Gateway. Získané znalosti vám umožní zůstat v kontaktu se svými zákazníky pomocí jednoduchého Kotlin kódu. Mezinárodní zasílání zpráv je s Ozeki SMS Gateway také možné, protože funguje v jakékoli zemi a může odesílat a přijímat SMS přes různé mobilní připojení.

Nezapomeňte pokračovat ve studiu zde, navštivte další stránky s návody na webu Ozeki pro více informací. Podívejte se na další průvodce o používání Kotlinu, začněte s Jak odeslat více SMS z Kotlinu.

Nyní je vaším prvním krokem stáhnout Ozeki SMS Gateway a začít jej používat!

More information