examples/SFExamples/RecipeEx/src/MobilityEngine.cpp

// Symbian Foundation Example Code
// 
// This software is in the public domain. No copyright is claimed, and you 
// may use it for any purpose without license from the Symbian Foundation.
// No warranty for any purpose is expressed or implied by the authors or
// the Symbian Foundation. 


#include <nifman.h>  // KConnDisableTimers
#include <eikenv.h>
#include <aknglobalnote.h> 
#include <es_enum.h>
#include <TextResolver.h>
#include <aknquerydialog.h> 
#include <txtetext.h>  // CEditableText
#include <cmapplicationsettingsui.h>

#include "MobilityEngine.h"
#include "LogContainer.h"

// Constants
_LIT(KInitialText, "Select Options->Connect to start");
_LIT(KStarting, "Starting connection...");
_LIT(KSuccessful, "Successful connection.");
_LIT(KRegisteredWithMobilityExt, "Registered with Mobility Ext");
_LIT(KResolvingUrlFmt,"Resolving URL: %S");
_LIT(KSocketConnecting,"Socket connecting...");
_LIT(KSocketConnected,"Socket connected.");
_LIT(KDisconnected,"Disconnected.");
_LIT(KPreferredCarrierAvailableFmt,"PreferredCarrierAvailable: #%u->#%u, upgrade: %S, seamless: %S");
_LIT(KMigrating, "Migrating...");
_LIT(KNewCarrierActive, "New Carrier Active");
_LIT(KErrorFmt,"Error: %S");
_LIT(KAddressFmt,"Address: %S:%u");
_LIT(KFallBackToPreviousCarrier,"Falling back to previous carrier.");
_LIT(KTrueStr,"true");
_LIT(KFalseStr,"false");

_LIT(KPanicCategory,"MobilityEngine");
enum TPanicCodes
        {
        EPanicUnreachable = 0,
        EPanicBadAddressFamily = 1
        };

_LIT(KDefaultHost,"www.google.com");


// ================= MEMBER FUNCTIONS =======================

CMobilityEngine::CMobilityEngine(CLogContainer* aLogView) :
        CActive(EPriorityStandard),  // Standard priority
        iLogView(aLogView)
        {
        }

CMobilityEngine* CMobilityEngine::NewLC(CLogContainer* aLogView)
        {
        CMobilityEngine* self = new (ELeave) CMobilityEngine(aLogView);
        CleanupStack::PushL(self);
        self->ConstructL();
        return self;
        }

CMobilityEngine* CMobilityEngine::NewL(CLogContainer* aLogView)
        {
        CMobilityEngine* self = CMobilityEngine::NewLC(aLogView);
        CleanupStack::Pop(self);
        return self;
        }

void CMobilityEngine::ConstructL()
        {
        User::LeaveIfError(iSocketServ.Connect());
        User::LeaveIfError(iConnection.Open(iSocketServ));
        
        iTextResolver = CTextResolver::NewL();
        
        CActiveScheduler::Add(this); // Add to scheduler
        
        iHostAndPort = KDefaultHost().AllocL();

        iLogView->LogEntryL(KInitialText);
        }

CMobilityEngine::~CMobilityEngine()
        {
        Disconnect();
        delete iTextResolver;
        iConnection.Close();
        iSocketServ.Close();
        delete iHostAndPort;
        }

void CMobilityEngine::DoCancel()
        {
        switch(iState)
                {
                case EStartingConnection:
                        iConnection.Stop();
                        break;
                case EResolvingAddress:
                        iResolver.Cancel();
                        break;
                case ESocketConnecting:
                        iRoamingSocket.CancelConnect();
                        break;
                case EAsyncDisconnect:
                        break;
                default:
                        User::Panic(KPanicCategory,EPanicUnreachable);
                        break;
                }
        }

void CMobilityEngine::RunL()
        {
        if(iStatus!=KErrNone)
                {
                iLogView->LogEntryL(KErrorFmt,&iTextResolver->ResolveErrorString(iStatus.Int()));
                if(iAcceptOnConnect)
                        {
                        iAcceptOnConnect = EFalse;
                        // failed to connect or resolve - close both socket and resolver
                        iRoamingSocket.Close();
                        iResolver.Close();
                        iMobility->NewCarrierRejected();
                        iLogView->LogEntryL(KFallBackToPreviousCarrier);
                        ConnectSocketL();
                        return;
                        }
                Disconnect();
                return;
                }
    switch(iState)
        {
        case EStartingConnection: // Connection started
                        {
                        iLogView->LogEntryL(KSuccessful);
                        // Register for mobility API
                        iMobility = CActiveCommsMobilityApiExt::NewL(iConnection, *this);
                        iLogView->LogEntryL(KRegisteredWithMobilityExt);
                        ConnectSocketL();
                        break;
                        }
        case EResolvingAddress:
                {
                TNameRecord& record = iNameEntry();
                if(record.iFlags&TNameRecord::EAlias)
                        {
                        iResolver.Next(iNameEntry,iStatus);
                        SetActive();
                        break;
                        }
                iResolver.Close();
                        record.iAddr.SetPort(GetPort()); // HTTP
                        LogAddressL(record.iAddr);
                iAddrResolved = ETrue;
                ConnectSocketL();
                break;
                }
        case ESocketConnecting:
                {
                iState = ESocketConnected;
                if(iAcceptOnConnect)
                        {
                        iAcceptOnConnect = EFalse;
                        iMobility->NewCarrierAccepted();
                        }
                // the socket is now connected and available for use
                iLogView->LogEntryL(KSocketConnected);
                break;
                }
        case EAsyncDisconnect:
                Disconnect();
                break;
                default:
                        {
                        User::Panic(KPanicCategory,EPanicUnreachable);
                        break;
                        }
                }
        }


TInt CMobilityEngine::RunError(TInt aError)
        {
        TRAP_IGNORE(iLogView->LogEntryL(KErrorFmt,&iTextResolver->ResolveErrorString(aError)));
        Disconnect();
        return KErrNone;
        }

void CMobilityEngine::ConnectL()
        {
        if(iState!=EIdle)
                {
                User::Leave(KErrInUse);
                }
    
    TCmSettingSelection userSelection;
    
    CCmApplicationSettingsUi* settings = CCmApplicationSettingsUi::NewL();
    CleanupStack::PushL(settings);
    
    TUint listedItems = CMManager::EShowAlwaysAsk |
                        CMManager::EShowDefaultConnection |
                        CMManager::EShowDestinations |
                        CMManager::EShowConnectionMethods;
    
    TBearerFilterArray filter;
    
    TBool selected = settings->RunApplicationSettingsL(userSelection,
                                                       listedItems,
                                                       filter);

    CleanupStack::PopAndDestroy(settings);

    if (selected) {
        switch (userSelection.iResult)
            {
            case CMManager::EDestination:
                {
                TConnSnapPref prefs;
                prefs.SetSnap(userSelection.iId);
        
                iConnection.Start(prefs, iStatus);
                break;
                }
            case CMManager::EConnectionMethod:
                {
                TCommDbConnPref prefs;
                prefs.SetIapId(userSelection.iId);
                prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
        
                iConnection.Start(prefs, iStatus);
                break;
                }
            case CMManager::EDefaultConnection:
                {
                iConnection.Start(iStatus);
                break;
                }
            default: // EAlwaysAsk
                {
                TCommDbConnPref prefs;
                prefs.SetDialogPreference(ECommDbDialogPrefPrompt);
        
                iConnection.Start(prefs, iStatus);
                }
            }

        iState = EStartingConnection;
        SetActive();
        iLogView->LogEntryL(KStarting);
        }
        }

void CMobilityEngine::Disconnect()
        {
        Cancel();
        // see comments about RSocket::Close() in PreferredCarrierAvailable(...)
        iRoamingSocket.Close();
        iAddrResolved = EFalse;
        iResolver.Close();
        delete iMobility;
        iMobility = NULL;
        iConnection.Stop();
        iState = EIdle;
        TRAP_IGNORE(iLogView->LogEntryL(KDisconnected));
        }

TBool CMobilityEngine::IsIdle()
        {
        return iState==EIdle;
        }

void CMobilityEngine::PreferredCarrierAvailable(TAccessPointInfo aOldAPInfo,
                               TAccessPointInfo aNewAPInfo,
                               TBool aIsUpgrade,
                               TBool aIsSeamless)
        {
    TRAP_IGNORE(iLogView->LogEntryL(KPreferredCarrierAvailableFmt,
                aOldAPInfo.AccessPoint(),aNewAPInfo.AccessPoint(),
                &(aIsUpgrade ? KTrueStr() : KFalseStr()),&(aIsSeamless ? KTrueStr() : KFalseStr())));

        if (aIsSeamless)
        {
        // ...
        }
    else
        {
        Cancel();

        // RSocket::Close() will Shutdown(ENormal,.) and, under some conditions,
        // that may take a long time and make the UI non-responsive. It may be
        // a good idea to Shutdown(EImmediate,.) and resend the data after
        // reconnecting if the higher-level protocol allows, say, by requiring
        // message acknowledgement and allowing duplicates.
        iRoamingSocket.Close();
        iResolver.Close();
        iMobility->MigrateToPreferredCarrier();
        iState = EChangingCarrier;
        TRAP_IGNORE(iLogView->LogEntryL(KMigrating));
        }       
        }

void CMobilityEngine::NewCarrierActive(TAccessPointInfo /*aNewAPInfo*/, TBool /*aIsSeamless*/)
        {
        TRAPD(err,HandleNewCarrierActiveL());
        if(err!=KErrNone)
                {
                iMobility->NewCarrierRejected();
                TRAP_IGNORE(iLogView->LogEntryL(KErrorFmt,&iTextResolver->ResolveErrorString(err)));
                // we can't disconnect immediatelly in a callback from *iMobility 
                AsyncDisconnect();
                }
        }

void CMobilityEngine::Error(TInt aError)        
        {
        // KErrCancel is received from "delete iMobility;" i.e. from Disconnect()
        if(aError!=KErrCancel)
                {
                TRAP_IGNORE(iLogView->LogEntryL(KErrorFmt,&iTextResolver->ResolveErrorString(aError)));
                // we can't disconnect immediatelly in a callback from *iMobility 
                AsyncDisconnect();
                }
        }

void CMobilityEngine::HandleNewCarrierActiveL()
        {
    iLogView->LogEntryL(KNewCarrierActive);
    ConnectSocketL();
    iAcceptOnConnect = ETrue;
    }

void CMobilityEngine::ConnectSocketL()
        {
        if(!iAddrResolved)
                {
                User::LeaveIfError(iResolver.Open(iSocketServ,KAfInet,KProtocolInetTcp,iConnection));
                iResolver.GetByName(GetHost(),iNameEntry,iStatus);
                iState = EResolvingAddress;
                SetActive();
                iLogView->LogEntryL(KResolvingUrlFmt,iHostAndPort);
                return;
                }
        User::LeaveIfError(iRoamingSocket.Open(iSocketServ,KAfInet,KSockStream,KProtocolInetTcp,iConnection));
        iRoamingSocket.Connect(iNameEntry().iAddr,iStatus);
        iState = ESocketConnecting;
        SetActive();
        iLogView->LogEntryL(KSocketConnecting);
        }

void CMobilityEngine::AsyncDisconnect()
        {
        iState = EAsyncDisconnect;
        iStatus = KRequestPending;
        SetActive();
        TRequestStatus* status = &iStatus;
        User::RequestComplete(status,KErrNone);
        }

void CMobilityEngine::LogAddressL(const TSockAddr& aAddr)
        {
        __ASSERT_DEBUG(aAddr.Family()==KAfInet,User::Panic(KPanicCategory,EPanicBadAddressFamily));
        TBuf<16> buf;
        static_cast<const TInetAddr&>(aAddr).Output(buf);
        iLogView->LogEntryL(KAddressFmt,&buf,aAddr.Port());
        }

TPtrC CMobilityEngine::GetHost() const
        {
        TInt pos = iHostAndPort->Locate(':');
        if(pos==KErrNotFound)
                {
                return *iHostAndPort;
                }
        return (pos==KErrNotFound) ? *iHostAndPort : iHostAndPort->Left(pos);
        }

TUint CMobilityEngine::GetPort() const
        {
        TInt pos = iHostAndPort->Locate(':');
        if(pos==KErrNotFound)
                {
                return 80u; // default to HTTP
                }
        TPtrC portStr = iHostAndPort->Right(pos+1);
        TLex lex(portStr);
        TUint port;
        if(lex.Val(port)!=KErrNone || port==0u)
                {
                port = 80u;
                }
        return port;
        }

// End of file

---