Struct xpcom::interfaces::nsIIdleService

#[repr(C)]
pub struct nsIIdleService { /* fields omitted */ }

interface nsIIdleService : nsISupports

/**
 * This interface lets you monitor how long the user has been 'idle',
 * i.e. not used their mouse or keyboard. You can get the idle time directly,
 * but in most cases you will want to register an observer for a predefined
 * interval. The observer will get an 'idle' notification when the user is idle
 * for that interval (or longer), and receive an 'active' notification when the
 * user starts using their computer again.
 */

Methods

impl nsIIdleService

pub fn coerce<T: nsIIdleServiceCoerce>(&self) -> &T

Cast this nsIIdleService to one of its base interfaces.

impl nsIIdleService

pub unsafe fn GetIdleTime(&self, aIdleTime: *mut uint32_t) -> nsresult

/**
     * The amount of time in milliseconds that has passed
     * since the last user activity.
     *
     * If we do not have a valid idle time to report, 0 is returned
     * (this can happen if the user never interacted with the browser
     * at all, and if we are also unable to poll for idle time manually).
     */

readonly attribute unsigned long idleTime;

pub unsafe fn AddIdleObserver(
    &self,
    observer: *const nsIObserver,
    time: uint32_t
) -> nsresult

/**
     * Add an observer to be notified when the user idles for some period of
     * time, and when they get back from that.
     *
     * @param observer the observer to be notified
     * @param time the amount of time in seconds the user should be idle before
     *             the observer should be notified.
     *
     * @note
     * The subject of the notification the observer will get is always the
     * nsIIdleService itself.
     * When the user goes idle, the observer topic is "idle" and when he gets
     * back, the observer topic is "active".
     * The data param for the notification contains the current user idle time.
     *
     * @note
     * You can add the same observer twice.
     * @note
     * Most implementations need to poll the OS for idle info themselves,
     * meaning your notifications could arrive with a delay up to the length
     * of the polling interval in that implementation.
     * Current implementations use a delay of 5 seconds.
     */

void addIdleObserver (in nsIObserver observer, in unsigned long time);

pub unsafe fn RemoveIdleObserver(
    &self,
    observer: *const nsIObserver,
    time: uint32_t
) -> nsresult

/**
     * Remove an observer registered with addIdleObserver.
     * @param observer the observer that needs to be removed.
     * @param time the amount of time they were listening for.
     * @note
     * Removing an observer will remove it once, for the idle time you specify.
     * If you have added an observer multiple times, you will need to remove it
     * just as many times.
     */

void removeIdleObserver (in nsIObserver observer, in unsigned long time);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsIIdleService

const IID: nsIID

IID: nsIID = nsID(3427987866, 25518, 18972, [156, 195, 231, 158, 172, 224, 180, 113])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsIIdleService

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsIIdleService

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.