Struct Client 

pub struct Client {
    pub group_cache: Arc<DashMap<Jid, GroupInfo>>,
    pub device_cache: Arc<DashMap<Jid, (Vec<Jid>, Instant)>>,
    pub enable_auto_reconnect: Arc<AtomicBool>,
    pub auto_reconnect_errors: Arc<AtomicU32>,
    pub last_successful_connect: Arc<Mutex<Option<DateTime<Utc>>>>,
    pub custom_enc_handlers: Arc<DashMap<String, Arc<dyn EncHandler>>>,
    /* private fields */
}

Fields

group_cache: Arc<DashMap<Jid, GroupInfo>>

device_cache: Arc<DashMap<Jid, (Vec<Jid>, Instant)>>

enable_auto_reconnect: Arc<AtomicBool>

auto_reconnect_errors: Arc<AtomicU32>

last_successful_connect: Arc<Mutex<Option<DateTime<Utc>>>>

custom_enc_handlers: Arc<DashMap<String, Arc<dyn EncHandler>>>

Custom handlers for encrypted message types

Implementations

impl Client

pub async fn new( persistence_manager: Arc<PersistenceManager>, ) -> (Arc<Self>, Receiver<MajorSyncTask>)

pub async fn run(self: &Arc<Self>)

pub async fn connect(self: &Arc<Self>) -> Result<(), Error>

pub async fn disconnect(&self)

pub async fn set_passive(&self, passive: bool) -> Result<(), IqError>

pub fn is_connected(&self) -> bool

pub fn is_logged_in(&self) -> bool

pub fn persistence_manager(&self) -> Arc<PersistenceManager>

Get access to the PersistenceManager for this client. This is useful for multi-account scenarios to get the device ID.

pub async fn edit_message( &self, to: Jid, original_id: String, new_content: Message, ) -> Result<String, Error>

pub async fn send_node(&self, node: Node) -> Result<(), ClientError>

pub async fn get_push_name(&self) -> String

pub async fn get_pn(&self) -> Option<Jid>

pub async fn get_lid(&self) -> Option<Jid>

impl Client

pub async fn download(&self, downloadable: &dyn Downloadable) -> Result<Vec<u8>>

pub async fn download_to_file<W: Write + Seek + Send + Unpin>( &self, downloadable: &dyn Downloadable, writer: W, ) -> Result<()>

impl Client

pub async fn generate_message_id(&self) -> String

Generates a unique message ID that conforms to the WhatsApp protocol format.

This is an advanced function that allows library users to generate message IDs that are compatible with the WhatsApp protocol. The generated ID includes timestamp, user JID, and random components to ensure uniqueness.

Advanced Use Case

This function is intended for advanced users who need to build custom protocol interactions or manage message IDs manually. Most users should use higher-level methods like send_message which handle ID generation automatically.

Returns

A string containing the generated message ID in the format expected by WhatsApp.

pub async fn send_iq(&self, query: InfoQuery<'_>) -> Result<Node, IqError>

Sends a custom IQ (Info/Query) stanza to the WhatsApp server.

This is an advanced function that allows library users to send custom IQ stanzas for protocol interactions that are not covered by higher-level methods. Common use cases include live location updates, custom presence management, or other advanced WhatsApp features.

Advanced Use Case

This function bypasses some of the higher-level abstractions and safety checks provided by other client methods. Users should be familiar with the WhatsApp protocol and IQ stanza format before using this function.

Arguments

• query - The IQ query to send, containing the stanza type, namespace, content, and optional timeout

Returns

• Ok(Node) - The response node from the server
• Err(IqError) - Various error conditions including timeout, connection issues, or server errors

Example

use wacore::request::{InfoQuery, InfoQueryType};
use wacore_binary::builder::NodeBuilder;
use wacore_binary::node::NodeContent;
use wacore_binary::jid::Jid;

// This is a simplified example - real usage requires proper setup
let query_node = NodeBuilder::new("presence")
    .attr("type", "available")
    .build();

let server_jid = Jid::new("", "s.whatsapp.net");

let query = InfoQuery {
    query_type: InfoQueryType::Set,
    namespace: "presence",
    to: server_jid,
    target: None,
    content: Some(NodeContent::Nodes(vec![query_node])),
    id: None,
    timeout: None,
};

let response = client.send_iq(query).await?;

impl Client

pub async fn send_message( &self, to: Jid, message: Message, ) -> Result<String, Error>

impl Client

pub async fn upload( &self, data: Vec<u8>, media_type: MediaType, ) -> Result<UploadResponse>

impl Client

pub async fn query_group_info(&self, jid: &Jid) -> Result<GroupInfo, Error>

impl Client

pub async fn send_presence(&self, presence: Presence) -> Result<(), Error>

Trait Implementations

impl SendContextResolver for Client

fn resolve_devices<'life0, 'life1, 'async_trait>( &'life0 self, jids: &'life1 [Jid], ) -> Pin<Box<dyn Future<Output = Result<Vec<Jid>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn fetch_prekeys<'life0, 'life1, 'async_trait>( &'life0 self, jids: &'life1 [Jid], ) -> Pin<Box<dyn Future<Output = Result<HashMap<Jid, PreKeyBundle>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn fetch_prekeys_for_identity_check<'life0, 'life1, 'async_trait>( &'life0 self, jids: &'life1 [Jid], ) -> Pin<Box<dyn Future<Output = Result<HashMap<Jid, PreKeyBundle>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn resolve_group_info<'life0, 'life1, 'async_trait>( &'life0 self, jid: &'life1 Jid, ) -> Pin<Box<dyn Future<Output = Result<GroupInfo, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,