void TestQGeoSatelliteInfoSource::removeSlotForRequestTimeout()
{
CHECK_SOURCE_VALID;
bool i = connect(m_source, SIGNAL(requestTimeout()), this, SLOT(test_slot1()));
QVERIFY(i==true);
i = connect(m_source, SIGNAL(requestTimeout()), this, SLOT(test_slot2()));
QVERIFY(i==true);
i = disconnect(m_source, SIGNAL(requestTimeout()), this, SLOT(test_slot1()));
QVERIFY(i==true);
m_source->requestUpdate(-1);
QTRY_VERIFY_WITH_TIMEOUT((m_testSlot2Called == true), 1000);
}
void QGeoSatelliteInfoSourceAndroid::requestUpdate(int timeout)
{
if (requestTimer.isActive())
return;
if (timeout != 0 && timeout < minimumUpdateInterval()) {
emit requestTimeout();
return;
}
if (timeout == 0)
timeout = UPDATE_FROM_COLD_START;
requestTimer.start(timeout);
// if updates already running with interval equal or less then timeout
// then we wait for next update coming through
// assume that a single update will not be quicker than regular updates anyway
if (updatesRunning && updateInterval() <= timeout)
return;
QGeoSatelliteInfoSource::Error error = AndroidPositioning::startSatelliteUpdates(
androidClassKeyForSingleRequest, true, timeout);
if (error != QGeoSatelliteInfoSource::NoError) {
requestTimer.stop();
m_error = error;
emit QGeoSatelliteInfoSource::error(m_error);
}
}
void XMLHttpRequestClass::requestFinished() {
disconnect(&_timer, SIGNAL(timeout()), this, SLOT(requestTimeout()));
_errorCode = _reply->error();
if (_errorCode == QNetworkReply::NoError) {
_rawResponseData.append(_reply->readAll());
if (_responseType == "json") {
_responseData = _engine->evaluate("(" + QString(_rawResponseData.data()) + ")");
if (_responseData.isError()) {
_engine->clearExceptions();
_responseData = QScriptValue::NullValue;
}
} else if (_responseType == "arraybuffer") {
QScriptValue data = _engine->newVariant(QVariant::fromValue(_rawResponseData));
_responseData = _engine->newObject(reinterpret_cast<ScriptEngine*>(_engine)->getArrayBufferClass(), data);
} else {
_responseData = QScriptValue(QString(_rawResponseData.data()));
}
}
setReadyState(DONE);
emit requestComplete();
}
void QGeoSatelliteInfoSourceMaemo::requestUpdate(int timeout)
{
int timeoutForRequest = 0;
if (!timeout) {
if (LiblocationWrapper::instance()->isActive())
// If GPS is active, assume quick fix.
timeoutForRequest = DEFAULT_UPDATE_INTERVAL;
else
// Otherwise reserve longer time to get a fix.
timeoutForRequest = POWERSAVE_POWERON_PERIOD;
} else if (timeout < MINIMUM_UPDATE_INTERVAL) {
if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::RequestActive)
return;
emit requestTimeout();
return;
} else {
timeoutForRequest = timeout;
}
satelliteInfoState |= QGeoSatelliteInfoSourceMaemo::RequestActive;
if (!(LiblocationWrapper::instance()->isActive()))
LiblocationWrapper::instance()->start();
activateTimer();
requestTimer->start(timeoutForRequest);
}
void QGeoSatelliteInfoSourceWinCE::requestUpdate(int timeout)
{
if (timeout < 0)
emit requestTimeout();
else
infoThread->requestUpdate(timeout);
}
void TestQGeoSatelliteInfoSource::requestUpdateAfterStartUpdates_ZeroInterval()
{
CHECK_SOURCE_VALID;
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyUse(m_source,
SIGNAL(satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyTimeout(m_source, SIGNAL(requestTimeout()));
m_source->setUpdateInterval(0);
m_source->startUpdates();
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 1) && (spyUse.count() == 1), MAX_WAITING_TIME);
spyView.clear();
spyUse.clear();
m_source->requestUpdate(7000);
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 1) && (spyUse.count() == 1)
&& (spyTimeout.count() == 0), 7000);
spyView.clear();
spyUse.clear();
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 1) && (spyUse.count() == 1), 12000);
m_source->stopUpdates();
}
void TestQGeoSatelliteInfoSource::requestUpdate_timeoutLessThanMinimumInterval()
{
CHECK_SOURCE_VALID;
QSignalSpy spyTimeout(m_source, SIGNAL(requestTimeout()));
m_source->requestUpdate(1);
QTRY_COMPARE_WITH_TIMEOUT(spyTimeout.count(), 1, 1000);
}
void XMLHttpRequestClass::doSend() {
_reply = NetworkAccessManager::getInstance().sendCustomRequest(_request, _method.toLatin1(), _sendData);
connectToReply(_reply);
if (_timeout > 0) {
_timer.start(_timeout);
connect(&_timer, SIGNAL(timeout()), this, SLOT(requestTimeout()));
}
}
void XMLHttpRequestClass::abortRequest() {
// Disconnect from signals we don't want to receive any longer.
disconnect(&_timer, SIGNAL(timeout()), this, SLOT(requestTimeout()));
if (_reply) {
disconnectFromReply(_reply);
_reply->abort();
_reply->deleteLater();
_reply = NULL;
}
}
void QGeoSatelliteInfoSourceSimulator::requestUpdate(int timeout)
{
if (!requestTimer->isActive()) {
// Get a single update within timeframe
if (timeout < 0)
emit requestTimeout();
else {
requestTimer->start(timeout * qreal(0.75));
}
}
}
void QGeoSatelliteInfoSourceAndroid::requestTimeoutElapsed()
{
m_satelliteInfoState &=~QGeoSatelliteInfoSourceAndroid::RequestActive;
if (m_satelliteInfoState & QGeoSatelliteInfoSourceAndroid::Stopped)
{
QtLocationJni::satelliteDisableupdates(this);
}
emit requestTimeout();
}
void TestQGeoSatelliteInfoSource::requestUpdate()
{
CHECK_SOURCE_VALID;
QFETCH(int, timeout);
QSignalSpy spy(m_source, SIGNAL(requestTimeout()));
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
m_source->requestUpdate(timeout);
// Geoclue may deliver update instantly if there is a satellite fix
QTRY_VERIFY_WITH_TIMEOUT(!spy.isEmpty() || !spyView.isEmpty(), 10);
}
QGeoSatelliteInfoSourceAndroid::QGeoSatelliteInfoSourceAndroid(QObject *parent) :
QGeoSatelliteInfoSource(parent), m_error(NoError), updatesRunning(false)
{
qRegisterMetaType< QGeoSatelliteInfo >();
qRegisterMetaType< QList<QGeoSatelliteInfo> >();
androidClassKeyForUpdate = AndroidPositioning::registerPositionInfoSource(this);
androidClassKeyForSingleRequest = AndroidPositioning::registerPositionInfoSource(this);
requestTimer.setSingleShot(true);
QObject::connect(&requestTimer, SIGNAL(timeout()),
this, SLOT(requestTimeout()));
}
void QGeoSatelliteInfoSourceMaemo::requestTimeoutElapsed()
{
updateTimer->stop();
emit requestTimeout();
satelliteInfoState &= ~QGeoSatelliteInfoSourceMaemo::RequestActive;
if (satelliteInfoState & QGeoSatelliteInfoSourceMaemo::Stopped)
if (LiblocationWrapper::instance()->isActive())
LiblocationWrapper::instance()->stop();
activateTimer();
}
QGeoSatelliteInfoSourceWinCE::QGeoSatelliteInfoSourceWinCE(QObject *parent) : QGeoSatelliteInfoSource(parent)
{
QGeoSatelliteInfoValidator *validator = new QGeoSatelliteInfoValidator();
// The QGeoInfoThreadWinCE instance takes ownership of the validator.
infoThread = new QGeoInfoThreadWinCE(validator, false, this);
infoThread->setUpdateInterval(DefaultUpdateInterval);
infoThread->start();
// QGeoInfoThreadWinCE takes care of registering GPS_POSITION as a metatype.
connect(infoThread, SIGNAL(dataUpdated(GPS_POSITION)), this, SLOT(dataUpdated(GPS_POSITION)));
connect(infoThread, SIGNAL(updateTimeout()), this, SIGNAL(requestTimeout()));
}
void QGeoSatelliteInfoSourceSimulator::requestUpdate(int timeout)
{
if (!requestTimer->isActive()) {
// Get a single update within timeframe
if (timeout == 0)
timeout = minimumUpdateInterval();
if (timeout < minimumUpdateInterval())
emit requestTimeout();
else
requestTimer->start(timeout);
}
}
void QGeoSatelliteInfoSourceGypsy::requestUpdateTimeout()
{
#ifdef Q_LOCATION_GYPSY_DEBUG
qDebug("QGeoSatelliteInfoSourceGypsy request update timeout occurred.");
#endif
// If we end up here, there has not been valid satellite update.
// Emit timeout and disconnect from signal if regular updates are not
// ongoing (as we were listening just for one single requestUpdate).
if (!m_updatesOngoing) {
m_engine->eng_g_signal_handlers_disconnect_by_func(G_OBJECT(m_satellite), (void*)satellites_changed, this);
}
m_requestOngoing = false;
emit requestTimeout();
}
QGeoPositionInfoSourceAndroid::QGeoPositionInfoSourceAndroid(QObject *parent) :
QGeoPositionInfoSource(parent), updatesRunning(false), m_error(NoError)
{
qRegisterMetaType< QGeoPositionInfo >();
androidClassKeyForUpdate = AndroidPositioning::registerPositionInfoSource(this);
androidClassKeyForSingleRequest = AndroidPositioning::registerPositionInfoSource(this);
//qDebug() << "androidClassKey: " << androidClassKeyForUpdate << androidClassKeyForSingleRequest;
//by default use all methods
setPreferredPositioningMethods(AllPositioningMethods);
m_requestTimer.setSingleShot(true);
QObject::connect(&m_requestTimer, SIGNAL(timeout()), this, SLOT(requestTimeout()));
}
void TestQGeoSatelliteInfoSource::requestUpdate_validTimeout()
{
CHECK_SOURCE_VALID;
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyUse(m_source,
SIGNAL(satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyTimeout(m_source, SIGNAL(requestTimeout()));
m_source->requestUpdate(7000);
QTRY_VERIFY_WITH_TIMEOUT(
(spyView.count() == 1) && (spyUse.count() == 1 && (spyTimeout.count()) == 0), 7000);
}
UserAgent::UserAgent(QObject* parent) :
QObject(parent),
m_req_data(NULL),
m_manager(NetworkManagerFactory::createInstance()),
requestType(TYPE_DEFAULT),
agentPath(QString())
{
QString agentpath = QLatin1String("/ConnectivityUserAgent");
setAgentPath(agentpath);
connect(m_manager, SIGNAL(availabilityChanged(bool)),
this, SLOT(updateMgrAvailability(bool)));
requestTimer = new QTimer(this);
requestTimer->setSingleShot(true);
connect(requestTimer,SIGNAL(timeout()),this,SLOT(requestTimeout()));
}
void QGeoSatelliteInfoSourceAndroid::requestTimeout()
{
AndroidPositioning::stopUpdates(androidClassKeyForSingleRequest);
const int count = m_satsInView.count();
if (!count) {
emit requestTimeout();
return;
}
emit QGeoSatelliteInfoSource::satellitesInViewUpdated(m_satsInView);
emit QGeoSatelliteInfoSource::satellitesInUseUpdated(m_satsInUse);
m_satsInUse.clear();
m_satsInView.clear();
}
void TestQGeoSatelliteInfoSource::startUpdates_testDefaultInterval()
{
CHECK_SOURCE_VALID;
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyUse(m_source,
SIGNAL(satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy timeout(m_source, SIGNAL(requestTimeout()));
m_source->startUpdates();
for (int i = 0; i < 3; i++) {
QTRY_VERIFY_WITH_TIMEOUT( (spyView.count() > 0 ) && (spyUse.count() > 0) && (timeout.count() == 0), 7000);
spyView.clear();
spyUse.clear();
}
m_source->stopUpdates();
}
void QGeoSatelliteInfoSourceGeoclueMaster::requestUpdateTimeout()
{
// If we end up here, there has not been a valid satellite info update.
if (m_running) {
m_inView.clear();
m_inUse.clear();
emit satellitesInViewUpdated(m_inView);
emit satellitesInUseUpdated(m_inUse);
} else {
emit requestTimeout();
// Only stop satellite info if regular updates not active.
cleanupSatelliteSource();
m_master->releaseMasterClient();
}
}
void TestQGeoSatelliteInfoSource::requestUpdate_overlappingCallsWithTimeout()
{
CHECK_SOURCE_VALID;
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyUse(m_source,
SIGNAL(satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyTimeout(m_source,
SIGNAL(requestTimeout()));
m_source->requestUpdate(0);
m_source->requestUpdate(1);
QTRY_COMPARE_WITH_TIMEOUT(spyTimeout.count(), 0, 7000);
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 1) && (spyUse.count() == 1), 7000);
}
void QGeoSatelliteInfoSourceGypsy::requestUpdate(int timeout)
{
if (m_requestOngoing)
return;
if (timeout < 0) {
emit requestTimeout();
return;
}
m_requestOngoing = true;
GError *error = 0;
// If GPS has a fix a already, request current data.
GypsyDeviceFixStatus fixStatus = m_engine->eng_gypsy_device_get_fix_status(m_device, &error);
if (!error && (fixStatus != GYPSY_DEVICE_FIX_STATUS_INVALID &&
fixStatus != GYPSY_DEVICE_FIX_STATUS_NONE)) {
#ifdef Q_LOCATION_GYPSY_DEBUG
qDebug() << "QGeoSatelliteInfoSourceGypsy fix available, requesting current satellite data";
#endif
GPtrArray* satelliteData = m_engine->eng_gypsy_satellite_get_satellites(m_satellite, &error);
if (!error) {
// The fix was available and we have satellite data to deliver right away.
satellitesChanged(m_satellite, satelliteData);
m_engine->eng_gypsy_satellite_free_satellite_array(satelliteData);
return;
}
}
// No fix is available. If updates are not ongoing already, start them.
m_requestTimer.setInterval(timeout == 0? UPDATE_TIMEOUT_COLD_START: timeout);
if (!m_updatesOngoing) {
m_engine->eng_g_signal_connect (m_satellite, "satellites-changed",
G_CALLBACK (satellites_changed), this);
}
m_requestTimer.start();
if (error) {
#ifdef Q_LOCATION_GYPSY_DEBUG
qDebug() << "QGeoSatelliteInfoSourceGypsy error asking fix status or satellite data: " << error->message;
#endif
g_error_free(error);
}
}
void TestQGeoSatelliteInfoSource::requestUpdateBeforeStartUpdates_SmallInterval()
{
CHECK_SOURCE_VALID;
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyUse(m_source,
SIGNAL(satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy timeout(m_source, SIGNAL(requestTimeout()));
m_source->requestUpdate(7000);
m_source->setUpdateInterval(10000);
m_source->startUpdates();
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() > 0) && (spyUse.count() > 0) && (timeout.count() == 0), 7000);
spyView.clear();
spyUse.clear();
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() > 0) && (spyUse.count() > 0) && (timeout.count() == 0), 20000);
m_source->stopUpdates();
}
void QGeoSatelliteInfoSourceNpeBackend::requestUpdate(int timeout)
{
// ignore if another requestUpdate is still pending
if (!requestTimer->isActive()) {
int minimumInterval = minimumUpdateInterval();
if (timeout == 0)
timeout = 5*minimumInterval; // set reasonable timeout if provided timeout is 0
// do not start request if timeout can not be fulfilled by the source
if (timeout < minimumInterval) {
emit requestTimeout();
return;
}
// get satellite update as fast as possible in case of ongoing tracking session
if ( satOngoing ) {
if ( QGeoSatelliteInfoSource::updateInterval() != minimumInterval)
m_locationdConn->setUpdateInterval(minimumInterval);
} else { // request the update only if no tracking session is active
m_locationdConn->requestSatelliteUpdate();
}
requestTimer->start(timeout);
}
}
void QGeoSatelliteInfoSourceGeoclueMaster::requestUpdate(int timeout)
{
if (timeout < minimumUpdateInterval() && timeout != 0) {
emit requestTimeout();
return;
}
if (m_requestTimer.isActive())
return;
if (!m_master->hasMasterClient())
configureSatelliteSource();
m_requestTimer.start(qMax(timeout, minimumUpdateInterval()));
if (m_sat) {
QDBusPendingReply<qint32, qint32, qint32, QList<qint32>, QList<QGeoSatelliteInfo> > reply =
m_sat->GetSatellite();
QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this);
connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
this, SLOT(getSatelliteFinished(QDBusPendingCallWatcher*)));
}
}
void QGeoSatelliteInfoSourceNpeBackend::requestTimerExpired()
{
emit requestTimeout();
shutdownRequestSession();
}
void TestQGeoSatelliteInfoSource::startUpdates_testIntervalChangesWhileRunning()
{
// There are two ways of dealing with an interval change, and we have left it system dependent.
// The interval can be changed will running or after the next update.
// WinCE uses the first method, S60 uses the second method.
// The minimum interval on the symbian emulator is 5000 msecs, which is why the times in
// this test are as high as they are.
CHECK_SOURCE_VALID;
QSignalSpy spyView(m_source,
SIGNAL(satellitesInViewUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy spyUse(m_source,
SIGNAL(satellitesInUseUpdated(const QList<QGeoSatelliteInfo> &)));
QSignalSpy timeout(m_source, SIGNAL(requestTimeout()));
m_source->setUpdateInterval(0);
m_source->startUpdates();
m_source->setUpdateInterval(0);
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() > 0) && (spyUse.count() > 0), 7000);
QCOMPARE(timeout.count(), 0);
spyView.clear();
spyUse.clear();
m_source->setUpdateInterval(5000);
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 2) && (spyUse.count() == 2) && (timeout.count() == 0), 15000);
spyView.clear();
spyUse.clear();
m_source->setUpdateInterval(10000);
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 2) && (spyUse.count() == 2) && (timeout.count() == 0), 30000);
spyView.clear();
spyUse.clear();
m_source->setUpdateInterval(5000);
QTRY_VERIFY_WITH_TIMEOUT((spyView.count() == 2) && (spyUse.count() == 2) && (timeout.count() == 0), 15000);
spyView.clear();
spyUse.clear();
m_source->setUpdateInterval(5000);
QTRY_VERIFY_WITH_TIMEOUT( (spyView.count() == 2) && (spyUse.count() == 2) && (timeout.count() == 0), 15000);
spyView.clear();
spyUse.clear();
m_source->setUpdateInterval(0);
QTRY_VERIFY_WITH_TIMEOUT( (spyView.count() > 0 ) && (spyUse.count() > 0) && (timeout.count() == 0), 7000);
spyView.clear();
spyUse.clear();
m_source->setUpdateInterval(0);
QTRY_VERIFY_WITH_TIMEOUT( (spyView.count() > 0 ) && (spyUse.count() > 0) && (timeout.count() == 0), 7000);
spyView.clear();
spyUse.clear();
m_source->stopUpdates();
}
