Maemo::IcdPrivate Class Reference

Public Functions
uint	addrinfo (QString &service_type, uint service_attrs, QString &service_id, QString &network_type, uint network_attrs, QByteArray &network_id, IcdAddressInfoResult &addr_result)
uint	addrinfo (QList< IcdAddressInfoResult > &addr_results)
void	callReply (const QString &method, const QList< QVariant > &args, const QString &error)
void	clearState ()
bool	doState ()
	IcdPrivate (Icd *myfriend)
	IcdPrivate (unsigned int timeout, Icd *myfriend)
	IcdPrivate (unsigned int timeout, IcdDbusInterfaceVer ver, Icd *myfriend)
void	init (unsigned int dbus_timeout, IcdDbusInterfaceVer ver, Icd *myfriend)
QStringList	scan (icd_scan_request_flags flags, QStringList &network_types, QList< IcdScanResult > &scan_results, QString &error)
void	signalReceived (const QString &interface, const QString &signal, const QList< QVariant > &args)
uint	state (QString &service_type, uint service_attrs, QString &service_id, QString &network_type, uint network_attrs, QByteArray &network_id, IcdStateResult &state_result)
uint	state (QList< IcdStateResult > &state_results)
uint	statistics (QList< IcdStatisticsResult > &stats_results)
	~IcdPrivate ()

Public Variables
Icd *	icd
IcdDbusInterfaceVer	icd_dbus_version
QList< QVariant >	mArgs
DBusDispatcher *	mDBus
QString	mError
QString	mInterface
QString	mMethod
QString	mSignal
QList< QVariant >	receivedSignals
unsigned int	timeout

Detailed Description

Definition at line 79 of file maemo_icd.cpp.

Constructors and Destructors

IcdPrivate() [1/3]

Maemo::IcdPrivate::IcdPrivate ( Icd *  myfriend )

inline

Definition at line 82 of file maemo_icd.cpp.

    {
        init(10000, IcdNewDbusInterface, myfriend);
    }

IcdPrivate() [2/3]

Maemo::IcdPrivate::IcdPrivate ( unsigned int  timeout, Icd *  myfriend  )

inline

Definition at line 87 of file maemo_icd.cpp.

    {
        init(timeout, IcdNewDbusInterface, myfriend);
    }

IcdPrivate() [3/3]

Maemo::IcdPrivate::IcdPrivate ( unsigned int  timeout, IcdDbusInterfaceVer  ver, Icd *  myfriend  )

inline

Definition at line 92 of file maemo_icd.cpp.

    {
        Q_UNUSED(ver);

        /* Note that the old Icd interface is currently disabled and
     * the new one is always used.
     */
        init(timeout, IcdNewDbusInterface, myfriend);
    }

~IcdPrivate()

Maemo::IcdPrivate::~IcdPrivate ( )

inline

Definition at line 102 of file maemo_icd.cpp.

    {
      QObject::disconnect(mDBus, 
              SIGNAL(signalReceived(const QString&, 
                        const QString&,
                        const QList<QVariant>&)),
              icd,
              SLOT(icdSignalReceived(const QString&, 
                         const QString&,
                         const QList<QVariant>&)));

      QObject::disconnect(mDBus,
              SIGNAL(callReply(const QString&,
                       const QList<QVariant>&,
                       const QString&)),
              icd,
              SLOT(icdCallReply(const QString&,
                        const QList<QVariant>&,
                        const QString&)));

        delete mDBus;
        mDBus = 0;
    }

Functions

addrinfo() [1/2]

uint Maemo::IcdPrivate::addrinfo	(	QString &	service_type,
		uint	service_attrs,
		QString &	service_id,
		QString &	network_type,
		uint	network_attrs,
		QByteArray &	network_id,
		IcdAddressInfoResult &	addr_result
	)

Definition at line 716 of file maemo_icd.cpp.

Referenced by Maemo::Icd::addrinfo(), and ~IcdPrivate().

{
    QTimer timer;
    QVariant reply;
    uint total_signals;
    QVariantList vl;

    clearState();

    reply = mDBus->call(ICD_DBUS_API_ADDRINFO_REQ,
            service_type, service_attrs, service_id,
            network_type, network_attrs, network_id);
    if (reply.type() != QVariant::List)
        return 0;
    vl = reply.toList();
    if (vl.isEmpty())
        return 0;
    reply = vl.first();
    total_signals = reply.toUInt();

    if (!total_signals)
        return 0;

    timer.setSingleShot(true);
    timer.start(timeout);

    mInterface.clear();
    while (timer.isActive() && mInterface.isEmpty()) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);

    if (mSignal != ICD_DBUS_API_ADDRINFO_SIG) {
            mInterface.clear();
        continue;
    }
    }

    timer.stop();

    if (mError.isEmpty()) {
        get_addrinfo_all_result(mArgs, addr_result);
    } else {
        qWarning() << "Error:" << mError;
    }

    // The returned value should be one because we asked for one addrinfo
    return total_signals;
}

addrinfo() [2/2]

uint Maemo::IcdPrivate::addrinfo

(

QList< IcdAddressInfoResult > &

addr_results

)

Definition at line 658 of file maemo_icd.cpp.

{
    QVariant reply;
    QVariantList vl;
    uint signals_left, total_signals;
    IcdAddressInfoResult result;
    time_t started;
    int timeout_secs = timeout / 1000;

    PDEBUG("%s\n", "addr_results");

    clearState();
    reply = mDBus->call(ICD_DBUS_API_ADDRINFO_REQ);
    if (reply.type() != QVariant::List)
        return 0;
    vl = reply.toList();
    if (vl.isEmpty())
        return 0;
    reply = vl.first();
    if (reply.type() != QVariant::UInt)
        return 0;
    signals_left = total_signals = reply.toUInt();
    if (!signals_left)
        return 0;

    started = time(0);
    addr_results.clear();
    while (signals_left) {
        mInterface.clear();
    while ((time(0)<=(started+timeout_secs)) && mInterface.isEmpty()) {
        mDBus->synchronousDispatch(1000);
        QCoreApplication::sendPostedEvents(icd, QEvent::MetaCall);
    }

        if (time(0)>(started+timeout_secs)) {
        total_signals = 0;
        break;
    }

    if (mSignal != ICD_DBUS_API_ADDRINFO_SIG) {
        continue;
    }

    if (mError.isEmpty()) {
        get_addrinfo_all_result(mArgs, result);
        addr_results << result;
        signals_left--;
    } else {
        qWarning() << "Error:" << mError;
        break;
    }
    }

    PDEBUG("total_signals=%d\n", total_signals);
    return total_signals;
}

callReply()

void Maemo::IcdPrivate::callReply	(	const QString &	method,
		const QList< QVariant > &	args,
		const QString &	error
	)

Definition at line 239 of file maemo_icd.cpp.

Referenced by Maemo::Icd::icdCallReply(), init(), and ~IcdPrivate().

{
    mMethod = method;
    mError = error;
}

clearState()

void Maemo::IcdPrivate::clearState ( )

inline

Definition at line 211 of file maemo_icd.cpp.

Referenced by addrinfo(), scan(), state(), and statistics().

    {
      mMethod.clear();
      mInterface.clear();
      mSignal.clear();
      mError.clear();
      mArgs.clear();
      receivedSignals.clear();
    }

doState()

bool Maemo::IcdPrivate::doState

(

)

Referenced by clearState().

init()

void Maemo::IcdPrivate::init ( unsigned int  dbus_timeout, IcdDbusInterfaceVer  ver, Icd *  myfriend  )

inline

Definition at line 165 of file maemo_icd.cpp.

Referenced by IcdPrivate().

    {
      if (ver == IcdNewDbusInterface) {
    mDBus = new DBusDispatcher(ICD_DBUS_API_INTERFACE,
                   ICD_DBUS_API_PATH,
                   ICD_DBUS_API_INTERFACE);
      } else {
    mDBus = new DBusDispatcher(ICD_DBUS_SERVICE,
                   ICD_DBUS_PATH,
                   ICD_DBUS_INTERFACE);
      }
      icd_dbus_version = ver;

      /* This connect has a side effect as it means that only one
       * Icd object can exists in one time. This should be fixed!
       */
      QObject::connect(mDBus, 
               SIGNAL(signalReceived(const QString&, 
                         const QString&,
                         const QList<QVariant>&)),
               myfriend,
               SLOT(icdSignalReceived(const QString&, 
                          const QString&,
                          const QList<QVariant>&)));

      QObject::connect(mDBus,
               SIGNAL(callReply(const QString&,
                    const QList<QVariant>&,
                    const QString&)),
               myfriend,
               SLOT(icdCallReply(const QString&,
                     const QList<QVariant>&,
                     const QString&)));

      icd = myfriend;
      timeout = dbus_timeout;

#ifdef PRINT_DEBUGINFO
      if (!fdebug) {
    fdebug = fopen("/tmp/maemoicd.log", "a+");
      }
      PDEBUG("created %s\n", "IcdPrivate");
#endif
    }

scan()

QStringList Maemo::IcdPrivate::scan	(	icd_scan_request_flags	flags,
		QStringList &	network_types,
		QList< IcdScanResult > &	scan_results,
		QString &	error
	)

Definition at line 274 of file maemo_icd.cpp.

Referenced by Maemo::Icd::scan(), and ~IcdPrivate().

{
    Q_UNUSED(network_types);

    QStringList scanned_types;
    QTimer timer;
    QVariant reply;
    QVariantList vl;
    bool last_result = false;
    IcdScanResult result;
    int all_waited;
    
    clearState();
    reply = mDBus->call(ICD_DBUS_API_SCAN_REQ, (uint)flags);
    if (reply.type() != QVariant::List)
        return scanned_types;
    vl = reply.toList();
    if (vl.isEmpty()) {
        error = "Scan did not return anything.";
    return scanned_types;
    }
    reply = vl.first();
    scanned_types = reply.toStringList();
    //qDebug() << "Scanning:" << scanned_types;
    all_waited = scanned_types.size();

    timer.setSingleShot(true);
    timer.start(timeout);

    scan_results.clear();
    while (!last_result) {
    while (timer.isActive() && mInterface.isEmpty() && mError.isEmpty()) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
    }

    if (!timer.isActive()) {
        //qDebug() << "Timeout happened";
        break;
    }

    if (mSignal != ICD_DBUS_API_SCAN_SIG) {
        //qDebug() << "Received" << mSignal << "while waiting" << ICD_DBUS_API_SCAN_SIG << ", ignoring";
        mInterface.clear();
        continue;
    }

    if (mError.isEmpty()) {
        QString msgInterface = receivedSignals.takeFirst().toString();
        QString msgSignal = receivedSignals.takeFirst().toString();
        QList<QVariant> msgArgs = receivedSignals.takeFirst().toList();
        //qDebug() << "Signal" << msgSignal << "received.";
        //qDebug() << "Params:" << msgArgs;

        while (!msgSignal.isEmpty()) {
        get_scan_result(msgArgs, result);

#if 0
        qDebug() << "Received: " <<
            "status =" << result.status <<
            ", timestamp =" << result.timestamp <<
            ", service_type =" << result.scan.service_type <<
            ", service_name =" << result.service_name <<
            ", service_attrs =" << result.scan.service_attrs <<
            ", service_id =" << result.scan.service_id <<
            ", service_priority =" << result.service_priority <<
            ", network_type =" << result.scan.network_type <<
            ", network_name =" << result.network_name <<
            ", network_attrs =" << result.scan.network_attrs <<
            ", network_id =" << "-" <<
            ", network_priority =" << result.network_priority <<
            ", signal_strength =" << result.signal_strength <<
            ", station_id =" << result.station_id <<
            ", signal_dB =" << result.signal_dB;
#endif

        if (result.status == ICD_SCAN_COMPLETE) {
            //qDebug() << "waited =" << all_waited;
            if (--all_waited == 0) {
                last_result = true;
            break;
            }
        } else
            scan_results << result;

        if (receivedSignals.isEmpty())
            break;

        msgInterface = receivedSignals.takeFirst().toString();
        msgSignal = receivedSignals.takeFirst().toString();
        msgArgs = receivedSignals.takeFirst().toList();
        }
        mInterface.clear();

    } else {
        qWarning() << "Error while scanning:" << mError;
        break;
    }
    }
    timer.stop();

    error = mError;
    return scanned_types;
}

signalReceived()

void Maemo::IcdPrivate::signalReceived	(	const QString &	interface,
		const QString &	signal,
		const QList< QVariant > &	args
	)

Definition at line 225 of file maemo_icd.cpp.

Referenced by Maemo::Icd::icdSignalReceived(), init(), and ~IcdPrivate().

{
    // Signal handler, which simply records what has been signalled
    mInterface = interface;
    mSignal = signal;
    mArgs = args;

    //qDebug() << "signal" << signal << "received:" << args;
    receivedSignals << QVariant(interface) << QVariant(signal) << QVariant(args);
}

state() [1/2]

uint Maemo::IcdPrivate::state	(	QString &	service_type,
		uint	service_attrs,
		QString &	service_id,
		QString &	network_type,
		uint	network_attrs,
		QByteArray &	network_id,
		IcdStateResult &	state_result
	)

Definition at line 417 of file maemo_icd.cpp.

Referenced by Maemo::Icd::state(), and ~IcdPrivate().

{
    QTimer timer;
    QVariant reply;
    uint total_signals;
    QVariantList vl;

    clearState();

    reply = mDBus->call(ICD_DBUS_API_STATE_REQ,
            service_type, service_attrs, service_id,
            network_type, network_attrs, network_id);
    if (reply.type() != QVariant::List)
        return 0;
    vl = reply.toList();
    if (vl.isEmpty())
        return 0;
    reply = vl.first();
    total_signals = reply.toUInt();
    if (!total_signals)
        return 0;

    timer.setSingleShot(true);
    timer.start(timeout);

    mInterface.clear();
    while (timer.isActive() && mInterface.isEmpty()) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);

    if (mSignal != ICD_DBUS_API_STATE_SIG) {
            mInterface.clear();
        continue;
    }
    }

    timer.stop();

    if (mError.isEmpty()) {
        if (!mArgs.isEmpty()) {
        if (mArgs.size()>2)
            get_state_all_result(mArgs, state_result);
        else {
            // We are not connected as we did not get the status we asked
            return 0;
        }
    }
    } else {
        qWarning() << "Error:" << mError;
    }

    // The returned value should be one because we asked for one state
    return total_signals;
}

state() [2/2]

uint Maemo::IcdPrivate::state

(

QList< IcdStateResult > &

state_results

)

Definition at line 481 of file maemo_icd.cpp.

{
    QVariant reply;
    QVariantList vl;
    uint signals_left, total_signals;
    IcdStateResult result;
    time_t started;
    int timeout_secs = timeout / 1000;

    PDEBUG("%s\n", "state_results");

    clearState();
    reply = mDBus->call(ICD_DBUS_API_STATE_REQ);
    if (reply.type() != QVariant::List)
        return 0;
    vl = reply.toList();
    if (vl.isEmpty())
        return 0;
    reply = vl.first();
    signals_left = total_signals = reply.toUInt();
    if (!signals_left)
        return 0;

    started = time(0);
    state_results.clear();
    mError.clear();
    while (signals_left) {
        mInterface.clear();
    while ((time(0)<=(started+timeout_secs)) && mInterface.isEmpty()) {
        mDBus->synchronousDispatch(1000);
        QCoreApplication::sendPostedEvents(icd, QEvent::MetaCall);
    }

        if (time(0)>(started+timeout_secs)) {
        total_signals = 0;
        break;
    }

    if (mSignal != ICD_DBUS_API_STATE_SIG) {
        continue;
    }

    if (mError.isEmpty()) {
        if (!mArgs.isEmpty()) {
            if (mArgs.size()==2)
                get_state_all_result2(mArgs, result);
        else
                get_state_all_result(mArgs, result);
        state_results << result;
        }
        signals_left--;
    } else {
        qWarning() << "Error:" << mError;
        break;
    }
    }

    PDEBUG("total_signals=%d\n", total_signals);
    return total_signals;
}

statistics()

uint Maemo::IcdPrivate::statistics

(

QList< IcdStatisticsResult > &

stats_results

)

Definition at line 564 of file maemo_icd.cpp.

Referenced by Maemo::Icd::statistics(), and ~IcdPrivate().

{
    QTimer timer;
    QVariant reply;
    QVariantList vl;
    uint signals_left, total_signals;
    IcdStatisticsResult result;

    clearState();
    reply = mDBus->call(ICD_DBUS_API_STATISTICS_REQ);
    if (reply.type() != QVariant::List)
        return 0;
    vl = reply.toList();
    if (vl.isEmpty())
        return 0;
    reply = vl.first();
    if (reply.type() != QVariant::UInt)
        return 0;
    signals_left = total_signals = reply.toUInt();

    if (!signals_left)
        return 0;

    timer.setSingleShot(true);
    timer.start(timeout);
    stats_results.clear();
    while (signals_left) {
    mInterface.clear();
    while (timer.isActive() && mInterface.isEmpty()) {
        QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
    }

    if (!timer.isActive()) {
        total_signals = 0;
        break;
    }

    if (mSignal != ICD_DBUS_API_STATISTICS_SIG) {
        continue;
    }

    if (mError.isEmpty()) {
        get_statistics_all_result(mArgs, result);
        stats_results << result;
        signals_left--;
    } else {
        qWarning() << "Error:" << mError;
        break;
    }
    }
    timer.stop();

    return total_signals;
}

Properties

icd

Icd* Maemo::IcdPrivate::icd

Definition at line 163 of file maemo_icd.cpp.

Referenced by addrinfo(), state(), and ~IcdPrivate().

icd_dbus_version

IcdDbusInterfaceVer Maemo::IcdPrivate::icd_dbus_version

Definition at line 162 of file maemo_icd.cpp.

mArgs

QList<QVariant> Maemo::IcdPrivate::mArgs

Definition at line 159 of file maemo_icd.cpp.

Referenced by addrinfo(), signalReceived(), state(), and statistics().

mDBus

DBusDispatcher* Maemo::IcdPrivate::mDBus

Definition at line 154 of file maemo_icd.cpp.

Referenced by addrinfo(), scan(), state(), statistics(), and ~IcdPrivate().

mError

QString Maemo::IcdPrivate::mError

Definition at line 158 of file maemo_icd.cpp.

Referenced by addrinfo(), callReply(), scan(), state(), and statistics().

mInterface

QString Maemo::IcdPrivate::mInterface

Definition at line 156 of file maemo_icd.cpp.

Referenced by addrinfo(), scan(), signalReceived(), state(), and statistics().

mMethod

QString Maemo::IcdPrivate::mMethod

Definition at line 155 of file maemo_icd.cpp.

Referenced by callReply().

mSignal

QString Maemo::IcdPrivate::mSignal

Definition at line 157 of file maemo_icd.cpp.

Referenced by addrinfo(), scan(), signalReceived(), state(), and statistics().

receivedSignals

QList<QVariant> Maemo::IcdPrivate::receivedSignals

Definition at line 160 of file maemo_icd.cpp.

Referenced by scan(), and signalReceived().

timeout

unsigned int Maemo::IcdPrivate::timeout

Definition at line 161 of file maemo_icd.cpp.

Referenced by addrinfo(), scan(), state(), and statistics().

---

The documentation for this class was generated from the following file:

• /src/plugins/bearer/icd/maemo_icd.cpp