/*!
Update the registration \a state, \a locationAreaCode, and \a cellId,
and notify all interested clients if they are different than the
previous values.
\sa QGprsNetworkRegistration::registrationState()
\sa QGprsNetworkRegistration::locationAreaCode()
\sa QGprsNetworkRegistration::cellId()
\sa QGprsNetworkRegistration::registrationStateChanged()
\sa QGprsNetworkRegistration::locationChanged()
*/
void QGprsNetworkRegistrationServer::updateRegistrationState
( QTelephony::RegistrationState state,
int locationAreaCode, int cellId )
{
if ( locationAreaCode != this->locationAreaCode() ||
cellId != this->cellId() ) {
if ( state != registrationState() ) {
// Update everything.
setValue( "state", (int)state, Delayed );
setValue( "locationAreaCode", locationAreaCode, Delayed );
setValue( "cellId", cellId );
emit registrationStateChanged();
emit locationChanged();
} else {
// Update only the location.
setValue( "locationAreaCode", locationAreaCode, Delayed );
setValue( "cellId", cellId );
emit locationChanged();
}
} else if ( state != registrationState() ) {
// Update only registration.
setValue( "state", (int)state );
emit registrationStateChanged();
}
}
void Solid::Control::ModemCdmaInterface::makeConnections(QObject * source)
{
if (source) {
QObject::connect(source, SIGNAL(signalQualityChanged(uint)),
this, SIGNAL(signalQualityChanged(uint)));
QObject::connect(source, SIGNAL(registrationStateChanged(Solid::Control::ModemCdmaInterface::RegistrationState,Solid::Control::ModemCdmaInterface::RegistrationState)),
this, SIGNAL(registrationStateChanged(Solid::Control::ModemCdmaInterface::RegistrationState,Solid::Control::ModemCdmaInterface::RegistrationState)));
}
}
void AsteriskManager::serviceStarted()
{
// The "asterisk" handler has started up, so attach to the service.
d->netReg = new QNetworkRegistration( "asterisk", this ); // No tr
if ( !d->netReg->available() ) {
delete d->netReg;
d->netReg = 0;
} else {
connect( d->netReg, SIGNAL(registrationStateChanged()),
this, SLOT(registrationStateChanged()) );
registrationStateChanged();
}
}
void AsteriskManager::serviceStopped()
{
// The "asterisk" handler has shut down, so detach from the service.
delete d->netReg;
d->netReg = 0;
registrationStateChanged();
}
/*!
This function handles registration queries and notifications
*/
void DialupImpl::registrationStateChanged()
{
if ( commManager->supports<QNetworkRegistration>().contains( "modem" ) ) {
if ( !netReg ) {
netReg = new QNetworkRegistration( "modem", this );
connect( netReg, SIGNAL(registrationStateChanged()),
this, SLOT(registrationStateChanged()) );
}
} else if ( netReg ){
qLog(Network) << "lost modem network registration";
delete netReg;
netReg = 0;
regState = QTelephony::RegistrationUnknown;
status();
return;
} else {
qLog(Network) << "No modem network registration available yet";
return;
}
QTelephony::RegistrationState oldState = regState;
const QtopiaNetwork::Type t = this->type();
if ( t & QtopiaNetwork::PhoneModem && netReg ) {
regState = netReg->registrationState();
switch ( regState ) {
case QTelephony::RegistrationHome:
case QTelephony::RegistrationRoaming:
// we have network registration and can start dialup
if ( regState != oldState ) {
qLog(Network) << "Network registered - Dialup can be started";
status();
}
break;
case QTelephony::RegistrationDenied:
default:
case QTelephony::RegistrationNone:
case QTelephony::RegistrationUnknown:
case QTelephony::RegistrationSearching:
if ( regState != oldState ) {
status();
qLog(Network) << "Missing network registration for Dialup";
}
break;
}
}
}
void ESURegistration::setRegistrationState(ESURegistration::RegistrationState regState)
{
if( d->registrationState != regState ) {
d->registrationState = regState;
Q_EMIT registrationStateChanged();
Q_EMIT isRegisteredChanged();
}
}
ModemManager::ModemCdmaInterface::ModemCdmaInterface(const QString & path, QObject * parent)
: ModemInterface(*new ModemCdmaInterfacePrivate(path, this), parent)
{
Q_D(ModemCdmaInterface);
connect(&d->modemCdmaIface, SIGNAL(RegistrationStateChanged(uint,uint)),
this, SIGNAL(registrationStateChanged(ModemManager::ModemCdmaInterface::RegistrationState,
ModemManager::ModemCdmaInterface::RegistrationState)));
connect(&d->modemCdmaIface, SIGNAL(SignalQuality(uint)),
this, SIGNAL(signalQualityChanged(uint)));
}
void CellModemManager::setNotReadyStatus()
{
stopAutoRegisterTimer();
if(d->m_regState != QTelephony::RegistrationNone)
emit registrationStateChanged(QTelephony::RegistrationNone);
if(!d->m_operator.isEmpty())
emit networkOperatorChanged(QString());
if(d->m_callForwardingEnabled)
emit callForwardingEnabledChanged(false);
updateStatus();
}
void CellModemManager::setReadyStatus()
{
if(d->m_regState != QTelephony::RegistrationNone)
emit registrationStateChanged(d->m_regState);
if(!d->m_operator.isEmpty())
emit networkOperatorChanged(d->m_operator);
if(d->m_callForwardingEnabled)
emit callForwardingEnabledChanged(d->m_callForwardingEnabled);
updateStatus();
}
AtPhoneIndicators::AtPhoneIndicators( QObject *parent )
: AtIndicators( parent )
{
d = new AtPhoneIndicatorsPrivate();
d->signalQuality = new QValueSpaceItem
( "/Hardware/Accessories/QSignalSource/modem/SignalStrength", this );
connect( d->signalQuality, SIGNAL(contentsChanged()),
this, SLOT(updateSignalQuality()) );
d->batteryCharge = new QValueSpaceItem( "/Hardware/Accessories/QPowerSource/modem", this );
connect( d->batteryCharge, SIGNAL(contentsChanged()),
this, SLOT(updateBatteryCharge()) );
#ifdef QTOPIA_CELL
d->smsMemoryFull = new QValueSpaceItem
( "/Telephony/Status/SMSMemoryFull", this );
connect( d->smsMemoryFull, SIGNAL(contentsChanged()),
this, SLOT(updateSmsMemoryFull()) );
#endif
d->battchg = addIndicator( "battchg", 5, 0 );
d->signal = addIndicator( "signal", 5, 0 );
d->service = addIndicator( "service", 1, 0 );
d->message = addIndicator( "message", 1, 0 );
d->call = addIndicator( "call", 1, 0 );
d->roam = addIndicator( "roam", 1, 0 );
d->smsfull = addIndicator( "smsfull", 1, 0 );
d->callsetup = addIndicator( "callsetup", 3, 0 );
d->callhold = addIndicator( "callheld", 2, 0 );
d->netReg = new QNetworkRegistration( "modem", this );
if ( !d->netReg->available() ) {
// May be a VoIP-only phone, so use the default network reg object.
delete d->netReg;
d->netReg = new QNetworkRegistration( QString(), this );
}
connect( d->netReg, SIGNAL(registrationStateChanged()),
this, SLOT(updateRegistrationState()) );
#ifdef QTOPIA_CELL
d->smsReader = new QSMSReader( QString(), this );
connect( d->smsReader, SIGNAL(unreadCountChanged()),
this, SLOT(unreadCountChanged()) );
#endif
updateRegistrationState();
updateSignalQuality();
updateBatteryCharge();
}
/*!
Update the registration \a state and notify all interested clients
if it is different than the previous value. The locationAreaCode()
and cellId() will be set to -1.
\sa registrationState(), registrationStateChanged()
\sa locationAreaCode(), cellId()
*/
void QNetworkRegistrationServer::updateRegistrationState
( QTelephony::RegistrationState state )
{
if ( locationAreaCode() != -1 || cellId() != -1 ) {
if ( state != registrationState() ) {
// Update everything.
setValue( "state", (int)state, Delayed );
setValue( "locationAreaCode", -1, Delayed );
setValue( "cellId", -1 );
emit registrationStateChanged();
emit locationChanged();
} else {
// Update only the location.
setValue( "locationAreaCode", -1, Delayed );
setValue( "cellId", -1 );
emit locationChanged();
}
} else if ( state != registrationState() ) {
// Update only registration.
setValue( "state", (int)state );
emit registrationStateChanged();
}
}
void DialupImpl::initialize()
{
if ( !netSpace ) {
const uint ident = qHash( configIface->configFile() );
QString path = QString("/Network/Interfaces/%1").arg(ident);
netSpace = new QValueSpaceObject( path, this );
netSpace->setAttribute( "Config", configIface->configFile() );
netSpace->setAttribute( "State", QtopiaNetworkInterface::Unknown );
netSpace->setAttribute( "Error", QtopiaNetworkInterface::NotInitialized );
netSpace->setAttribute( "ErrorString", tr("Interface hasn't been initialized yet.") );
netSpace->setAttribute( "NetDevice", QVariant() );
netSpace->setAttribute( "UpdateTrigger", 0 );
}
if ( isAvailable() ) {
ifaceStatus = QtopiaNetworkInterface::Down;
qLog(Network) << "DialupImpl: Using serial device: " << device();
} else {
ifaceStatus = QtopiaNetworkInterface::Unavailable;
qLog(Network) << "DialupImpl: interface not available";
}
netSpace->setAttribute( "State", ifaceStatus );
updateTrigger();
#ifdef QTOPIA_CELL
QtopiaNetwork::Type t = type();
if ( t & QtopiaNetwork::PhoneModem ) {
//we cannot start an internal GPRS connection if we don't have a registered network
//initiate monitoring of registration changes
commManager = new QCommServiceManager( this );
connect( commManager, SIGNAL(servicesChanged()), this, SLOT(registrationStateChanged()) );
registrationStateChanged(); //ask for first update
}
#endif
}
void CellModemManager::registrationStateChanged()
{
if(d->m_regState == d->m_netReg->registrationState())
return;
d->m_regState = d->m_netReg->registrationState();
if(Ready == state()) {
emit registrationStateChanged(d->m_regState);
updateStatus();
} else {
tryDoReady();
}
doAutoRegister();
}
/*!
Sets the desired plane mode state to \a enabled. If \a enabled is true, the
CellModemManager will attempt to disable the modem aerial and put it into
the AerialOff state. If false, the aerial will be enabled and the manager
will transition into the Ready state.
If the modem does not support plane mode, this method will have no effect.
Support for plane mode can be determined through the planeModeSupported()
method.
*/
void CellModemManager::setPlaneModeEnabled(bool enabled)
{
bool aerialEnabled = !enabled;
if(d->m_aerialOn == aerialEnabled)
return; // Already in progress
if(!aerialEnabled && !planeModeSupported())
return; // Plane mode is not supported
d->m_aerialOn = aerialEnabled;
if(Ready == state() || AerialOff == state()) {
setAerialEnabled(aerialEnabled);
}
emit planeModeEnabledChanged(d->m_aerialOn);
emit registrationStateChanged(d->m_regState);
}
/*!
Constructs a new CellBroadcastControl instance with the specified \a parent.
*/
CellBroadcastControl::CellBroadcastControl(QObject *parent)
: QObject(parent), infoMsgId(-1)
{
cb = new QCellBroadcast(QString(), this);
QObject::connect(cb, SIGNAL(broadcast(QCBSMessage)),
this, SLOT(cellBroadcast(QCBSMessage)));
QObject::connect(cb, SIGNAL(setChannelsResult(QTelephony::Result)),
this, SLOT(cellBroadcastResult(QTelephony::Result)));
firstSubscribe = false;
QAbstractCallPolicyManager *cellModem = QAbstractCallPolicyManager::managerForCallType("Voice");
if (cellModem)
connect(cellModem,
SIGNAL(registrationStateChanged(QTelephony::RegistrationState)),
this,
SLOT(registrationChanged(QTelephony::RegistrationState)));
else
qLog(Component) << "CellBroadcastControl: No Cellmodem manager component available";
}
void Modem3gppPropertiesTest::testModem3gppProperties()
{
ModemManager::ModemDevice::Ptr modemDevice = ModemManager::modemDevices().first();
QVERIFY(modemDevice);
QVERIFY(modemDevice->hasInterface(ModemManager::ModemDevice::GsmInterface));
ModemManager::Modem3gpp::Ptr modem3gppInterface = modemDevice->interface(ModemManager::ModemDevice::GsmInterface).objectCast<ModemManager::Modem3gpp>();
QVERIFY(modem3gppInterface);
modem3gpp->setEnabledFacilityLocks(MM_MODEM_3GPP_FACILITY_SIM);
QSignalSpy enabledFacilityLocksChangedSpy(modem3gppInterface.data(), SIGNAL(enabledFacilityLocksChanged(QFlags<MMModem3gppFacility>)));
QVERIFY(enabledFacilityLocksChangedSpy.wait());
QCOMPARE(modem3gppInterface->enabledFacilityLocks(), enabledFacilityLocksChangedSpy.at(0).at(0).value<QFlags<MMModem3gppFacility> >());
modem3gpp->setImei(QLatin1String("IMEI2"));
QSignalSpy imeiChangedSpy(modem3gppInterface.data(), SIGNAL(imeiChanged(QString)));
QVERIFY(imeiChangedSpy.wait());
QCOMPARE(modem3gppInterface->imei(), imeiChangedSpy.at(0).at(0).toString());
modem3gpp->setOperatorCode(QLatin1String("21025"));
QSignalSpy operatorCodeChangedSpy(modem3gppInterface.data(), SIGNAL(operatorCodeChanged(QString)));
QVERIFY(operatorCodeChangedSpy.wait());
QCOMPARE(modem3gppInterface->operatorCode(), operatorCodeChangedSpy.at(0).at(0).toString());
modem3gpp->setOperatorName(QLatin1String("op-name2"));
QSignalSpy operatorNameChangedSpy(modem3gppInterface.data(), SIGNAL(operatorNameChanged(QString)));
QVERIFY(operatorNameChangedSpy.wait());
QCOMPARE(modem3gppInterface->operatorName(), operatorNameChangedSpy.at(0).at(0).toString());
modem3gpp->setRegistrationState(MM_MODEM_3GPP_REGISTRATION_STATE_IDLE);
QSignalSpy registrationStateChangedSpy(modem3gppInterface.data(), SIGNAL(registrationStateChanged(MMModem3gppRegistrationState)));
QVERIFY(registrationStateChangedSpy.wait());
QCOMPARE(modem3gppInterface->registrationState(), registrationStateChangedSpy.at(0).at(0).value<MMModem3gppRegistrationState>());
#if MM_CHECK_VERSION(1, 2, 0)
modem3gpp->setSubscriptionState(MM_MODEM_3GPP_SUBSCRIPTION_STATE_PROVISIONED);
QSignalSpy subscriptionStateChangedSpy(modem3gppInterface.data(), SIGNAL(subscriptionStateChanged(MMModem3gppSubscriptionState)));
QVERIFY(subscriptionStateChangedSpy.wait());
QCOMPARE(modem3gppInterface->subscriptionState(), subscriptionStateChangedSpy.at(0).at(0).value<MMModem3gppSubscriptionState>());
#endif
}
void QLinphoneCore::onRegistrationStateChanged(LinphoneProxyConfig *cfg, LinphoneRegistrationState state) {
emit registrationStateChanged(QLProxy(cfg),state);
}
void SipClient::registrationStateChangedCb(LinphoneRegistrationState cstate)
{
emit registrationStateChanged(static_cast<SipClient::RegistrationState>(cstate));
}
bool DialupImpl::start( const QVariant /*options*/ )
{
if ( ifaceStatus != QtopiaNetworkInterface::Down ) {
switch ( ifaceStatus )
{
case QtopiaNetworkInterface::Unknown:
updateTrigger( QtopiaNetworkInterface::NotInitialized,
tr("Interface hasn't been initialized yet.") );
break;
case QtopiaNetworkInterface::Unavailable:
updateTrigger( QtopiaNetworkInterface::NotAvailable,
tr("Interface is not available.") );
break;
case QtopiaNetworkInterface::Up:
case QtopiaNetworkInterface::Pending:
case QtopiaNetworkInterface::Demand:
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Interface already started/active.") );
break;
default:
break;
}
qLog(Network) << "ppp interface cannot be started "
<<configIface->configFile();
return false;
}
QtopiaNetworkProperties prop = configIface->getProperties();
QStringList args;
const bool demand = prop.value("Properties/Autostart").toString() == "y";
const QtopiaNetwork::Type t = type();
#ifdef QTOPIA_CELL
if ( t & QtopiaNetwork::PhoneModem ) {
if ( regState != QTelephony::RegistrationHome &&
regState != QTelephony::RegistrationRoaming ) {
//we want to start the network but we don't have a network
//registration yet. wait till registration is done then go ahead
//and start iface
qLog(Network) << "Cannot start dialup yet due to missing"
<< "network registration. try again later";
registrationStateChanged(); //ask for first update
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Missing network registration. Try again later.") );
return false;
}
}
#endif
if ( t & QtopiaNetwork::NamedModem || t & QtopiaNetwork::PCMCIA ) {
QString dev = device();
if ( dev.isEmpty() || dev == "internal") {
qLog(Network) << "No external device";
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Missing external serial device.") );
return false;
}
if ( dev.startsWith("/dev/") )
dev = dev.mid(5);
args << dev;
args << "updetach";
}
#ifdef QTOPIA_CELL
else {
args << "nodetach";
}
#endif
args << "debug";
args << "call";
const QString peerID = prop.value("Serial/PeerID").toString();
if ( peerID.isEmpty() ) {
qLog(Network) << "Missing peer ID";
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Missing peer ID. Please reconfigure device.") );
return false;
}
args << peerID;
QString password = prop.value("Properties/Password").toString();
if (!password.isEmpty()) {
args << "password";
args << password;
}
const QString logfile = Qtopia::tempDir() + "qpe-pppd-log-"+peerID;
args << "logfile";
args << logfile;
QFile::remove( logfile ) ;
if ( t & QtopiaNetwork::NamedModem || t & QtopiaNetwork::PCMCIA ) {
qLog(Network) << "###################################";
qLog(Network) << "Starting ppp using external modem: " <<
args.join(" ");
args.prepend("start"); //cmd for network script
thread.addScriptToRun( pppScript, args );
} else { //QtopiaNetwork::PhoneModem
#ifdef QTOPIA_CELL
const QString path = Qtopia::applicationFileName("Network", "chat");
const QString connectF = path+"/connect-"+peerID;
const QString disconnectF = path+"/disconnect-"+peerID;
//Create a data call
qLog(Network) << "###################################";
qLog(Network) << "Starting ppp using internal modem: " <<
args.join(" ");
qLog(Network) << "connect: " << connectF;
qLog(Network) << "disconnect: " << disconnectF;
qLog(Network) << "demand dialing: " << (demand ? "yes" : "no");
QDialOptions pppd;
pppd.setUseIpModule( true );
pppd.setIpProgramName( PPPD_BINARY );
pppd.setIpConnectScript( connectF );
pppd.setIpDisconnectScript( disconnectF );
pppd.setIpDemandDialing( demand );
pppd.setIpArgs( args );
//Make sure that an existing call is stopped.
if ( !dataCall.isNull() ) {
dataCall.hangup();
}
if ( !callManager )
callManager = new QPhoneCallManager( this );
//Dial the new call.
if ( callManager ) {
dataCall = callManager->create( "IP" );
dataCall.connectNotification( this,
SLOT(connectNotification(QPhoneCall,QPhoneCall::Notification,QString)));
dataCall.connectStateChanged( this, SLOT(phoneCallStateChanged(QPhoneCall)) );
dataCall.dial( pppd );
} else {
qLog(Network) << "No call manager created";
}
#endif
}
state = Initialize;
logIndex = 0;
tidStateUpdate = startTimer( 1000 );
if ( demand )
ifaceStatus = QtopiaNetworkInterface::Demand;
else
ifaceStatus = QtopiaNetworkInterface::Pending;
netSpace->setAttribute( "State", ifaceStatus );
updateTrigger();
delayedGatewayInstall = true;
return true;
}
/*!
\internal
Construct a new CellModemManager with the appropriate \a parent. Only one
instance of CellModemManager may be constructed.
*/
CellModemManager::CellModemManager(QObject *parent)
: QAbstractCallPolicyManager(parent), d(new CellModemManagerPrivate)
{
Q_ASSERT(!cellModemManagerInstance);
cellModemManagerInstance = true;
d->m_status = new QValueSpaceObject("/Telephony/Status", this);
d->m_status->setAttribute("ModemStatus", "Initializing");
QValueSpaceItem *simToolkitAvailable;
simToolkitAvailable = new QValueSpaceItem
("/Telephony/Status/SimToolkit/Available", this);
connect(simToolkitAvailable, SIGNAL(contentsChanged()),
this, SLOT(simToolkitAvailableChange()));
// Check for modem
QServiceChecker checker("modem");
if(!checker.isValid()) {
d->m_aerialOn = false;
d->m_state = NoCellModem;
updateStatus();
return;
}
d->m_netReg = new QNetworkRegistration("modem", this);
d->m_regState = d->m_netReg->registrationState();
d->m_operator = d->m_netReg->currentOperatorName();
QObject::connect(d->m_netReg, SIGNAL(registrationStateChanged()),
this, SLOT(registrationStateChanged()));
QObject::connect(d->m_netReg, SIGNAL(currentOperatorChanged()),
this, SLOT(currentOperatorChanged()));
// Rename signal for QAbstractCallPolicyManager.
QObject::connect(this, SIGNAL(registrationStateChanged(QTelephony::RegistrationState)),
this, SIGNAL(registrationChanged(QTelephony::RegistrationState)));
d->m_pinManager = new QPinManager("modem", this);
QObject::connect(d->m_pinManager,
SIGNAL(pinStatus(QString,QPinManager::Status,QPinOptions)),
this,
SLOT(pinStatus(QString,QPinManager::Status,QPinOptions)) );
d->m_rfFunc = new QPhoneRfFunctionality("modem", this);
QObject::connect(d->m_rfFunc,
SIGNAL(levelChanged()), this, SLOT(rfLevelChanged()));
d->m_callForwarding = new QCallForwarding("modem", this);
QObject::connect(d->m_callForwarding,
SIGNAL(forwardingStatus(QCallForwarding::Reason,QList<QCallForwarding::Status>)),
this,
SLOT(forwardingStatus(QCallForwarding::Reason,QList<QCallForwarding::Status>)));
QSimInfo *simInfo = new QSimInfo( "modem", this );
connect( simInfo, SIGNAL(removed()), this, SLOT(simRemoved()) );
connect( simInfo, SIGNAL(inserted()), this, SLOT(simInserted()) );
if(::profilesControlModem) {
d->m_profiles = new QPhoneProfileManager(this);
d->m_aerialOn = !d->m_profiles->planeMode();
QObject::connect(d->m_profiles, SIGNAL(planeModeChanged(bool)),
this, SLOT(planeModeChanged(bool)));
}
// If plane mode isn't an option, then we have to fully initialize the modem
// each time
if(!planeModeSupported())
d->m_aerialOn = true;
setAerialEnabled(d->m_aerialOn);
updateStatus();
doInitialize();
}
void QLinPhoneCore::setRegistrationState(RegistrationState state)
{
m_rstate = state;
emit registrationStateChanged(state);
}
