Struct matrix_sdk::encryption::verification::QrVerification

source ·

pub struct QrVerification { /* private fields */ }

Available on crate features qrcode and e2e-encryption only.

Expand description

An object controlling QR code style key verification flows.

Implementations§

source §

impl QrVerification

source

pub fn own_user_id(&self) -> &UserId

Get our own user id.

source

pub fn is_self_verification(&self) -> bool

Is this a verification that is verifying one of our own devices.

source

pub fn is_done(&self) -> bool

Has this verification finished.

source

pub fn has_been_scanned(&self) -> bool

Whether the QrCode was scanned by the other device.

source

pub fn we_started(&self) -> bool

Did we initiate the verification flow.

source

pub fn cancel_info(&self) -> Option<CancelInfo>

Get info about the cancellation if the verification flow has been cancelled.

source

pub fn other_user_id(&self) -> &UserId

Get the user id of the other user participating in this verification flow.

source

pub fn other_device(&self) -> &ReadOnlyDevice

Get the other user’s device that we’re verifying.

source

pub fn is_cancelled(&self) -> bool

Has the verification been cancelled.

source

pub fn to_qr_code(&self) -> Result<QrCode, EncodingError>

Generate a QR code object that is representing this verification flow.

The QrCode can then be rendered as an image or as an unicode string.

The to_bytes() method can be used to instead output the raw bytes that should be encoded as a QR code.

source

pub fn to_bytes(&self) -> Result<Vec<u8>, EncodingError>

Generate a the raw bytes that should be encoded as a QR code is representing this verification flow.

The to_qr_code() method can be used to instead output a QrCode object that can be rendered.

source

pub async fn confirm(&self) -> Result<()>

Confirm that the other side has scanned our QR code.

source

pub async fn cancel(&self) -> Result<()>

Abort the verification flow and notify the other side that we did so.

source

pub fn changes(&self) -> impl Stream<Item = QrVerificationState>

Listen for changes in the QR code verification process.

The changes are presented as a stream of QrVerificationState values.

This method can be used to react to changes in the state of the verification process, or rather the method can be used to handle each step of the verification process.

§Flowchart

The flow of the verification process is pictured below. Please note that the process can be cancelled at each step of the process. Either side can cancel the process.

               ┌───────┐
               │Started│
               └───┬───┘
                   │
                   │
            ┌──────⌄─────┐
            │Reciprocated│
            └──────┬─────┘
                   │
               ┌───⌄───┐
               │Scanned│
               └───┬───┘
                   │
         __________⌄_________
        ╱                    ╲       ┌─────────┐
       ╱   Was the QR Code    ╲______│Cancelled│
       ╲ successfully scanned ╱ no   └─────────┘
        ╲____________________╱
                   │yes
                   │
              ┌────⌄────┐
              │Confirmed│
              └────┬────┘
                   │
               ┌───⌄───┐
               │  Done │
               └───────┘

§Examples

use futures_util::{Stream, StreamExt};
use matrix_sdk::encryption::verification::{
    QrVerification, QrVerificationState,
};

let mut stream = qr.changes();

while let Some(state) = stream.next().await {
    match state {
        QrVerificationState::Scanned => {
            println!("Was the QR code successfully scanned?");

            // Ask the user to confirm or cancel here.
            if user_confirmed {
                qr.confirm().await?;
            } else {
                qr.cancel().await?;
            }
        }
        QrVerificationState::Done { .. } => {
            let device = qr.other_device();

            println!(
                "Successfully verified device {} {} {:?}",
                device.user_id(),
                device.device_id(),
                device.local_trust_state()
            );

            break;
        }
        QrVerificationState::Cancelled(cancel_info) => {
            println!(
                "The verification has been cancelled, reason: {}",
                cancel_info.reason()
            );
            break;
        }
        QrVerificationState::Started
        | QrVerificationState::Reciprocated
        | QrVerificationState::Confirmed => (),
    }
}