Kihagyás

Flash Call

A Flash Call egy olyan telefonellenőrzési módszer, amely SMS helyett nem fogadott hívást használ a telefonszámok ellenőrzésére. Gyorsabb, biztonságosabb és költséghatékonyabb.

Áttekintés

A Flash Call ellenőrzése a következők szerint működik:

  1. A felhasználó ellenőrzést kér
  2. A rendszer hívást kezdeményez a felhasználó telefonjára
  3. A hívás 1-2 csengetés után automatikusan megszakad
  4. A felhasználói alkalmazás rögzíti a hívóazonosítót
  5. A hívóazonosítót a várt minta alapján ellenőrzik
  6. A felhasználó hitelesítése megtörtént

Előnyök

Költséghatékony

  • Akár 10-szer olcsóbb, mint az SMS
  • Nincs üzenetküldési díj
  • Csökkentett költségek nagy volumenű ellenőrzés esetén

Gyorsabb

  • Azonnali ellenőrzés (1-3 másodperc)
  • Nem kell várni az SMS-kézbesítésre
  • Jobb felhasználói élmény

Biztonságosabb

  • Nehezebb lehallgatni, mint az SMS-t
  • Nem látható az OTP az értesítésekben
  • Ellenáll a SIM-csere támadásoknak

Globális elérés

  • Olyan országokban működik, ahol SMS-korlátozások érvényesek
  • Nincs probléma az SMS-szűréssel
  • Univerzális telefon kompatibilitás

Alapvető Flash hívás

Kérelem

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

Paraméterek

Paraméter Típus Kötelező Leírás
"tól" húr Igen Az Ön feladó azonosítója
"hoz" húr Igen Címzett telefonszáma (E.164)
"típus" húr Igen Állítsa be a "flashcall"
"hívóazonosító" húr Igen Telefonszám, amely a felhasználót hívja
"ttl" egész Nem Élettartam másodpercben (alapértelmezett: 60)

Hogyan működik

1. A felhasználó beírja a telefonszámot

A felhasználó megadja telefonszámát az alkalmazásban:

Phone: +380XXXXXXXXX

2. Kérjen gyorshívást

A szerver gyorshívás-ellenőrzést kér:

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-válasz

Az API a várt hívóazonosító mintát adja vissza:

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

4. Hívás kezdeményezése

A rendszer hívást kezdeményez a felhasználó telefonjára és 1-2 csengetés után befejezi.

5. Hívóazonosító rögzítése

A felhasználói alkalmazás rögzíti a bejövő hívás hívóazonosítóját:

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

6. Ellenőrizze a mintát

Hasonlítsa össze a rögzített hívóazonosítót a várt mintával:

// 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);
}

Megvalósítási példák

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

Web (szerveroldali)

// 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' });
  }
});

Válaszformátum

Sikerreakció

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

Válaszmezők

Mező Típus Leírás
messageId húr Egyedi ellenőrzési azonosító
"állapot" húr Állapot: "elfogadva", "elutasítva"
"hívóazonosító" húr Teljes hívóazonosító szám
"minta" húr Egyező minta (számok + csillagok)
"hoz" húr Címzett telefonszáma
"ttl" egész Érvényességi idő másodpercben

Mintaillesztés

Az API egy mintát ad vissza csillagokkal, amelyek néhány számjegyet takarnak:

Full number: +380123456789
Pattern:     ***456789

Az alkalmazásnak:

  1. Rögzítse a bejövő hívóazonosítót
  2. Vegye ki a számjegyeket a hívóazonosítóból
  3. Egyeztetés a mintával (csillag = bármely szám)
  4. Ellenőrizze az egyezést a TTL időszakon belül

Visszatérés SMS-hez

Ha a Flash Call sikertelen, akkor automatikusan térjen vissza az SMS-re:

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

Használati esetek

Fiókregisztráció

Ellenőrizze a telefonszámokat a regisztráció során SMS-költség nélkül.

Bejelentkezés ellenőrzése

Kéttényezős hitelesítés flash hívás segítségével.

Telefonszám frissítése

Ellenőrizze az új telefonszámot, amikor a felhasználó frissíti a profilt.

Tranzakció megerősítése

Erősítse meg a nagy értékű tranzakciókat gyorshívással.

Bevált gyakorlatok

TTL

  • ✅ Állítsa a TTL-t 60-90 másodpercre
  • ✅ Lehetővé teszi a felhasználó számára, hogy újra próbálkozzon a lejárat után
  • ❌ Ne használjon 120 másodpercnél hosszabb TTL-t

Felhasználói élmény

  • A "Várakozás hívásra..." üzenet megjelenítése
  • Kijelző visszaszámláló (60 másodperc)
  • Adja meg az "SMS használata helyett" lehetőséget
  • A hívóazonosító automatikus felismerése és ellenőrzése

Hibakezelés

  • Kezelje a hiányzó telefonos engedélyeket
  • Időtúllépés a TTL lejárta után
  • SMS tartalék opció biztosítása
  • Világos hibaüzenetek megjelenítése

Engedélyek

Telefonos engedélyek kérése villámhívás előtt:

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>

Tesztelés

  • Teszt különböző eszközökön
  • Teszt különböző hordozókkal
  • Tesztelje az engedély megtagadási forgatókönyveket
  • Tesztelje a hálózati időtúllépési forgatókönyveket

Korlátozások

Platformtámogatás

  • Minden mobileszközön működik
  • Telefonálási képesség szükséges
  • READ_PHONE_STATE engedély szükséges
  • Előfordulhat, hogy telefon nélkül nem működik táblagépen

Hálózat

  • Aktív telefonkapcsolat szükséges
  • Rossz hálózati körülmények között meghibásodhat
  • Fuvarozói korlátozások vonatkozhatnak
  • A nemzetközi árak változhatnak

Adatvédelem

  • A felhasználók letilthatják az ismeretlen számokat
  • Egyes eszközök hívásblokkolással rendelkeznek
  • Kifejezett engedélyekre van szükség
  • Vegye figyelembe a felhasználók adatvédelmi aggályait

Hibaelhárítás

A hívás nem érkezett

  • Ellenőrizze a telefon jelét
  • Ellenőrizze a számformátumot (E.164)
  • Ellenőrizze a szolgáltatói korlátozásokat
  • Próbálja ki az SMS-t

A minta nem egyezik

  • Gondoskodjon a helyes hívóazonosító rögzítéséről
  • Törölje le a nem számjegyű karaktereket
  • Ellenőrizze a minta formátumát
  • Ellenőrizze a TTL időszakon belül

Engedély megtagadva

  • Megfelelően kérjen engedélyeket
  • Magyarázza el, miért van szükség engedélyekre
  • Alternatív megoldás (SMS)
  • Kezelje kecsesen

Következő lépések