Struct Session 

pub struct Session<T: ConnectionTransport> {
    pub handled_network_requests: Arc<Mutex<HashMap<String, NetworkRequestHandledState>>>,
    /* private fields */
}

Fields

handled_network_requests: Arc<Mutex<HashMap<String, NetworkRequestHandledState>>>

Tracks network requests that have been handled, keyed by request ID

Implementations

impl<T: ConnectionTransport> Session<T>

pub async fn ws_new( connection_config: &ConnectionTransportConfig, ) -> Session<WebsocketConnectionTransport>

pub async fn create_new_bidi_session( &mut self, connection_type: SessionConnectionType, capabilities: Option<CapabilitiesRequest>, )

pub async fn send_and_get_receiver( &mut self, command_data: CommandData, ) -> Receiver<CommandResponseState>

Send a command and return the receiver to wait for response This allows the caller to release locks before waiting for the response

pub async fn send( &mut self, command_data: CommandData, ) -> Result<ResultData, SessionSendError>

pub async fn end_session(&mut self) -> Result<ResultData, SessionSendError>

Trait Implementations

impl<T: ConnectionTransport> EventManagement for Session<T>

async fn send_event( &mut self, command_data: CommandData, ) -> Result<ResultData, SessionSendError>

fn get_bidi_events(&mut self) -> &mut Arc<Mutex<Vec<BidiEvent>>>

fn push_event(&mut self, event: BidiEvent)

fn subscribe_events<F, R>( &mut self, events: HashSet<&str>, handler: F, browsing_contexts: Option<Vec<String>>, _user_contexts: Option<Vec<&str>>, ) -> impl Future<Output = Result<Option<SubscribeResult>, CommandResultError>>

where F: FnMut(Event) -> R + Send + Sync + 'static, R: Future<Output = ()> + Send + 'static,

fn add_event_handler<F, R>( &mut self, events: HashSet<&str>, handler: F, handler_id: Option<String>, ) -> String

where F: FnMut(Event) -> R + Send + Sync + 'static, R: Future<Output = ()> + Send + 'static,

Add an event handler without sending a subscription command Returns the handler ID (either provided or generated)

fn unsubscribe_events_by_names( &mut self, events: HashSet<&str>, ) -> impl Future<Output = Result<Option<UnsubscribeResult>, CommandResultError>>

Unsubscribe from events by event names

fn unsubscribe_events_by_ids( &mut self, subscription_ids: Vec<Subscription>, ) -> impl Future<Output = Result<Option<UnsubscribeResult>, CommandResultError>>

Unsubscribe from events by subscription IDs

fn event_dispatch( &mut self, ) -> impl Future<Output = (JoinHandle<()>, UnboundedSender<Event>)>