Välkkõne

Välkkõne on telefoni kinnitamise meetod, mis kasutab telefoninumbrite kinnitamiseks SMS-i asemel vastamata kõnet. See on kiirem, turvalisem ja kulutõhusam.

Ülevaade

Välkkõne kinnitamine töötab:

Kasutaja taotleb kinnitust
Süsteem algatab kõne kasutaja telefonile
Kõne lõpetatakse automaatselt pärast 1-2 helinat
Kasutaja rakendus jäädvustab helistaja ID
Helistaja ID kontrollitakse eeldatava mustriga
Kasutaja on autentitud

Kasu

Kulusäästlik

Kuni 10x odavam kui SMS
Sõnumi saatmise tasu pole
Vähendatud kulud suuremahulise kontrollimise korral

Kiiremini

Kiire kinnitus (1-3 sekundit)
SMS-i kohaletoimetamist ei pea ootama
Parem kasutajakogemus

Turvalisem

Raskem pealt kuulata kui SMS-e
Märguannetes pole OTP-d näha
Vastupidav SIM-i vahetamise rünnakutele

Globaalne ulatus

Töötab riikides, kus on SMS-i piirangud
SMS-i filtreerimisega probleeme pole
Universaalne telefoni ühilduvus

Põhiline välkkõne

Taotlus

{
  "from": "YourApp",
  "to": "+380XXXXXXXXX",
  "type": "flashcall",
  "messageData": {
    "callerId": "+380123456789"
  }
}

Parameetrid

Parameeter	Tüüp	Nõutav	Kirjeldus
"alates"	string	Jah	Teie saatja identifikaator
`kuni`	string	Jah	Saaja telefoninumber (E.164)
"tüüp"	string	Jah	Määrake "flashcall"
"helistaja ID"	string	Jah	Telefoninumber, mis helistab kasutajale
`ttl`	täisarv	Ei	Eluaeg sekundites (vaikimisi: 60)

Kuidas see töötab

1. Kasutaja sisestab telefoninumbri

Kasutaja esitab teie rakenduses oma telefoninumbri:

Phone: +380XXXXXXXXX

2. Taotlege välkkõnet

Teie server taotleb välkkõne kinnitamist:

curl -X POST https://restapi.smsbat.com/bat/messagelist \
  -H "X-Authorization-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{
      "from": "YourApp",
      "to": "+380XXXXXXXXX",
      "type": "flashcall",
      "messageData": {
        "callerId": "+380123456789"
      },
      "ttl": 60
    }]
  }'

3. API vastus

API tagastab oodatud helistaja ID mustri:

{
  "messagelistId": 123456,
  "messages": [
    {
      "messageId": "abc123def456",
      "status": "accepted",
      "callerId": "+380123456789",
      "pattern": "***456789",
      "to": "+380XXXXXXXXX"
    }
  ]
}

4. Alustage kõnet

Süsteem algatab kõne kasutaja telefonile ja lõpetab pärast 1-2 helinat.

5. Jäädvustage helistaja ID

Kasutaja rakendus jäädvustab sissetuleva kõne helistaja ID:

// Android example
val cursor = contentResolver.query(
    CallLog.Calls.CONTENT_URI,
    arrayOf(CallLog.Calls.NUMBER),
    null, null,
    CallLog.Calls.DATE + " DESC"
)

6. Kinnitage muster

Võrrelge jäädvustatud helistaja ID-d eeldatava mustriga:

// JavaScript example
function verifyFlashCall(callerId, pattern) {
  // Remove non-digits
  const callerDigits = callerId.replace(/\D/g, '');
  const patternDigits = pattern.replace(/\*/g, '.');

  // Check if matches pattern
  const regex = new RegExp(patternDigits);
  return regex.test(callerDigits);
}

Rakendusnäited

Android

class FlashCallVerification {
    fun requestFlashCall(phoneNumber: String) {
        // 1. Request flash call from API
        val response = api.requestFlashCall(phoneNumber)
        val pattern = response.pattern

        // 2. Wait for incoming call
        val callReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context, intent: Intent) {
                if (intent.action == TelephonyManager.ACTION_PHONE_STATE_CHANGED) {
                    val state = intent.getStringExtra(TelephonyManager.EXTRA_STATE)

                    if (state == TelephonyManager.EXTRA_STATE_RINGING) {
                        val callerId = intent.getStringExtra(
                            TelephonyManager.EXTRA_INCOMING_NUMBER
                        )

                        // 3. Verify caller ID against pattern
                        if (verifyPattern(callerId, pattern)) {
                            onVerificationSuccess()
                        }
                    }
                }
            }
        }

        // Register receiver
        context.registerReceiver(
            callReceiver,
            IntentFilter(TelephonyManager.ACTION_PHONE_STATE_CHANGED)
        )
    }

    private fun verifyPattern(callerId: String?, pattern: String): Boolean {
        if (callerId == null) return false

        val regex = pattern.replace("*", "\\d").toRegex()
        return regex.matches(callerId)
    }
}

iOS

class FlashCallVerification {
    func requestFlashCall(phoneNumber: String) {
        // 1. Request flash call from API
        api.requestFlashCall(phoneNumber) { response in
            let pattern = response.pattern

            // 2. Use CallKit to detect incoming call
            let provider = CXProvider(configuration: providerConfiguration)
            provider.setDelegate(self, queue: nil)

            // Store pattern for verification
            self.expectedPattern = pattern
        }
    }

    // CallKit delegate
    func provider(_ provider: CXProvider, perform action: CXAnswerCallAction) {
        // Capture caller ID
        let callerId = action.callUUID.uuidString

        // Verify against pattern
        if verifyPattern(callerId: callerId, pattern: expectedPattern) {
            onVerificationSuccess()
        }

        action.fulfill()
    }

    private func verifyPattern(callerId: String, pattern: String) -> Bool {
        let regex = try! NSRegularExpression(
            pattern: pattern.replacingOccurrences(of: "*", with: "\\d")
        )
        let range = NSRange(location: 0, length: callerId.count)
        return regex.firstMatch(in: callerId, range: range) != nil
    }
}

Veeb (serveripoolne)

// Node.js example
const express = require('express');
const app = express();

app.post('/request-verification', async (req, res) => {
  const { phoneNumber } = req.body;

  // 1. Request flash call
  const response = await fetch('https://restapi.smsbat.com/bat/messagelist', {
    method: 'POST',
    headers: {
      'X-Authorization-Key': process.env.SMSBAT_API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      messages: [{
        from: 'YourApp',
        to: phoneNumber,
        type: 'flashcall',
        messageData: {
          callerId: process.env.FLASH_CALL_NUMBER
        },
        ttl: 60
      }]
    })
  });

  const data = await response.json();
  const { messageId, pattern } = data.messages[0];

  // 2. Store pattern for verification
  await redis.setex(`flashcall:${messageId}`, 60, pattern);

  // 3. Return pattern to client
  res.json({ messageId, pattern });
});

app.post('/verify-flashcall', async (req, res) => {
  const { messageId, callerId } = req.body;

  // 1. Get expected pattern
  const pattern = await redis.get(`flashcall:${messageId}`);

  if (!pattern) {
    return res.status(400).json({ error: 'Verification expired' });
  }

  // 2. Verify caller ID
  const regex = new RegExp(pattern.replace(/\*/g, '\\d'));
  const isValid = regex.test(callerId);

  if (isValid) {
    // Mark phone as verified
    await markPhoneVerified(callerId);
    res.json({ verified: true });
  } else {
    res.status(400).json({ error: 'Invalid caller ID' });
  }
});

Vastusevorming

Edukas vastus

{
  "messagelistId": 123456,
  "messages": [
    {
      "messageId": "abc123def456",
      "status": "accepted",
      "callerId": "+380123456789",
      "pattern": "***456789",
      "to": "+380XXXXXXXXX",
      "ttl": 60
    }
  ]
}

Vastuseväljad

Väli	Tüüp	Kirjeldus
`messageId`	string	Unikaalne kinnitus ID
`olek`	string	Olek: "vastu võetud", "tagasi lükatud"
"helistaja ID"	string	Helistaja täielik ID number
`muster`	string	Vastav muster (numbrid + tärnid)
`kuni`	string	Saaja telefoninumber
`ttl`	täisarv	Kehtivusaeg sekundites

Mustri sobitamine

API tagastab mustri tärnidega, mis varjavad mõnda numbrit:

Full number: +380123456789
Pattern:     ***456789

Teie rakendus peaks:

Jäädvustage sissetuleva helistaja ID
Võtke helistaja ID-st numbrid välja
Sobitage mustriga (tärnid = mis tahes number)
Kontrollige vastavust TTL perioodi jooksul

Tagasi SMS-i juurde

Kui välkkõne ebaõnnestub, pöörduge automaatselt tagasi SMS-i:

{
  "from": "YourApp",
  "to": "+380XXXXXXXXX",
  "type": "flashcall",
  "messageData": {
    "callerId": "+380123456789"
  },
  "fallback": {
    "type": "sms",
    "text": "Your verification code is: 123456"
  },
  "ttl": 60
}

Kasutusjuhtumid

Konto registreerimine

Kinnitage telefoninumbrid registreerumisel ilma SMS-i tasudeta.

Sisselogimise kinnitamine

Kahefaktoriline autentimine välkkõne abil.

Telefoninumbri värskendus

Kui kasutaja profiili värskendab, kinnitage uus telefoninumber.

Tehingu kinnitus

Kinnitage suure väärtusega tehingud välkkõnega.

Parimad tavad

TTL

✅ Seadke TTL 60-90 sekundile
✅ Luba kasutajal pärast aegumist uuesti proovida
❌ Ärge kasutage TTL-i kauem kui 120 sekundit

Kasutuskogemus

Kuva teade "Ootab kõnet...".
Kuva taimer (60 sekundit)
andke valik "Kasuta selle asemel SMS-i"
Helistaja ID automaatne tuvastamine ja kinnitamine

Vigade käsitlemine

Käsitlege puuduvaid telefonilubasid
Aegumine pärast TTL aegumist
Pakkuge SMS-i varuvalikut
Näita selgeid veateateid

Load

Küsige telefoni lubasid enne välkkõnet:

Android:

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

iOS:

<key>NSPhoneCallUsageDescription</key>
<string>We need phone access to verify your number</string>

Testimine

Testige erinevatel seadmetel
Testige erinevate kandjatega
Testige loa keelamise stsenaariume
Testige võrgu ajalõpu stsenaariume

Piirangud

Platvormi tugi

Töötab kõigis mobiilseadmetes
Nõuab telefonikõne võimalust
Vajab READ_PHONE_STATE luba
Ilma telefonita ei pruugi tahvelarvutites töötada

Võrk

Nõuab aktiivset telefoniühendust
Kehvades võrgutingimustes võib ebaõnnestuda
Kehtida võivad operaatori piirangud
Rahvusvahelised hinnad võivad erineda

Privaatsus

Kasutajad võivad blokeerida tundmatud numbrid
Mõnel seadmel on kõnede blokeerimine
Nõuab selgesõnalisi õigusi
Kaaluge kasutaja privaatsusprobleeme

Veaotsing

Kõnet ei võetud vastu

Kontrollige, kas telefonil on signaal
Kontrollige numbrivormingut (E.164)
Kontrollige operaatori piiranguid
Proovige SMS-i varundust

Muster ei sobi

Tagada õige helistaja ID jäädvustamine
Eemaldage mittekohalised märgid
Kontrollige mustri vormingut
Kontrollige TTL perioodi jooksul

Luba keelatud

Taotlege õigusi õigesti
Selgitage, miks lube on vaja
pakkuda alternatiivi (SMS)
Käsitsege graatsiliselt

Järgmised sammud

Viber OTP - alternatiivne OTP-edastus
SMS-sõnumid - SMS-varusõnumid
Kontrolli olekut - Jälgige välkkõne olekut