Struct matrix_sdk::encryption::verification::QrVerification

pub struct QrVerification { /* private fields */ }

Available on crate features qrcode and e2e-encryption only.

An object controlling QR code style key verification flows.

Implementations

impl QrVerification

pub fn own_user_id(&self) -> &UserId

Get our own user id.

pub fn is_self_verification(&self) -> bool

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

pub fn is_done(&self) -> bool

Has this verification finished.

pub fn has_been_scanned(&self) -> bool

Whether the QrCode was scanned by the other device.

pub fn we_started(&self) -> bool

Did we initiate the verification flow.

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

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

pub fn other_user_id(&self) -> &UserId

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

pub fn other_device(&self) -> &DeviceData

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

pub fn is_cancelled(&self) -> bool

Has the verification been cancelled.

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.

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.

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

Confirm that the other side has scanned our QR code.

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

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

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 => (),
    }
}

pub fn state(&self) -> QrVerificationState

Get the current state the verification process is in.

To listen to changes to the QrVerificationState use the QrVerification::changes method.

pub fn room_id(&self) -> Option<&RoomId>

Get the room ID, if the verification is happening inside a room.

Trait Implementations

impl Clone for QrVerification

fn clone(&self) -> QrVerification

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QrVerification

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<QrVerification> for Verification

fn from(qr: QrVerification) -> Self

Converts to this type from the input type.