/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Provides cached information on IAPs and SNAPs in CommsDat.

*

*/

#ifndef CONNMONCOMMSDATCACHE_H

#define CONNMONCOMMSDATCACHE_H

#include <e32base.h>

#include <commsdattypesv1_1.h>

#include <rconnmon.h>

class CConnMonServer;

class CConnMonIAP;

class TConnMonBearer;

NONSHARABLE_CLASS( TLanBearerEntry )

    {

public:

    TInt iId;

    TBool iWlanBearer;

    };

NONSHARABLE_CLASS( TConnMonSnapEntry )

    {

public:

    TConnMonSnapEntry();

    TConnMonSnapEntry(

            TUint aId,

            TUint aIapId,

            TUint aSnapId );

    static TInt Compare(

            const TConnMonSnapEntry& aFirst,

            const TConnMonSnapEntry& aSecond );

    static TInt FindCompare(

            const TInt* aKey,

            const TConnMonSnapEntry& aEntry );

    static TBool Match(

            const TConnMonSnapEntry& aFirst,

            const TConnMonSnapEntry& aSecond );

public:

    TUint iId;              // SNAP ID

    TUint iNextLayerIapId;  // Real or virtual IAP ID

    TUint iNextLayerSnapId; // Embeded SNAP ID

    TInt iAvailability;     // TConnMonAvailability

    // Index of linked object. SNAP or IAP depending if iNextLayerIapId or

    // iNextLayerSnapId is set.

    TInt iNextLayerIndex;

    };

NONSHARABLE_CLASS( TConnMonIapEntry )

    {

public:

    TConnMonIapEntry();

    TConnMonIapEntry(

            TUint aId,

            TUint aBearerType,

            TUint aServiceType );

    static TInt Compare(

            const TConnMonIapEntry& aFirst,

            const TConnMonIapEntry& aSecond );

    static TInt FindCompare(

            const TInt* aKey,

            const TConnMonIapEntry& aEntry );

    static TBool Match(

            const TConnMonIapEntry& aFirst,

            const TConnMonIapEntry& aSecond );

public:

    TUint iId;              // IAP ID (unique among IAPs)

    TUint iBearerType;      // Bearer type from IAP table

    TUint iServiceType;     // Service type from IAP table

    TInt iAvailability;     // TConnMonAvailability

    TUint iNextLayerIapId;  // Real or virtual IAP ID

    TUint iNextLayerSnapId; // SNAP ID

    TInt iNextLayerIndex;   // Index of linked object

    };

NONSHARABLE_CLASS( TConnMonVirtualIapEntry )

    {

public:

    TConnMonVirtualIapEntry();

    TConnMonVirtualIapEntry(

            TUint aId,

            TUint aNextLayerIapId,

            TUint aNextLayerSnapId );

    static TInt Compare(

            const TConnMonVirtualIapEntry& aFirst,

            const TConnMonVirtualIapEntry& aSecond );

    static TInt FindCompare(

            const TInt* aKey,

            const TConnMonVirtualIapEntry& aEntry );

    static TBool Match(

            const TConnMonVirtualIapEntry& aFirst,

            const TConnMonVirtualIapEntry& aSecond );

public:

    TUint iId;              // IAP ID (unique among IAPs) ID

    TUint iNextLayerIapId;  // Real or virtual IAP ID

    TUint iNextLayerSnapId; // SNAP ID

    };

/**

 * ConnMon CommsDat cache

 */

NONSHARABLE_CLASS( CConnMonCommsDatCache ) : public CBase

    {

private:

    // Availability status for cache tables

    enum TConnMonAvailability

        {

        EConnMonAvailabilityUnknown = 0,    // Not solved yet

        EConnMonAvailabilityProcessing,     // Availability is beeing solved (loop detection)

        EConnMonAvailabilityUnavailable,    // Not available

        EConnMonAvailabilityAvailable       // Available

        };

    enum TConnMonCacheInitState

        {

        EConnMonCacheInitNotStarted = 0,

        EConnMonCacheInitInProgress,

        EConnMonCacheInitCompleted

        };

    enum TConnMonCacheBearerType

        {

        EConnMonCacheBearerTypeUnknown = 0,

        EConnMonCacheBearerTypeAny,

        EConnMonCacheBearerTypeVirtual

        };

    enum TConnMonCacheServiceType

        {

        EConnMonCacheServiceTypeUnknown = 0,

        EConnMonCacheServiceTypeAny,

        EConnMonCacheServiceTypeCsd,

        EConnMonCacheServiceTypeGprs,

        EConnMonCacheServiceTypeLan,

        EConnMonCacheServiceTypeWlan

        };

public:

    /**

     * Two-phased constructor.

     */

    static CConnMonCommsDatCache* NewL();

    /**

     * Two-phased constructor.

     */

    static CConnMonCommsDatCache* NewLC();

    /**

    * Destructor.

    */

    virtual ~CConnMonCommsDatCache();

    /**

     * Initializes the SNAP and IAP cache. Reads all relevant IAP and SNAP

     * information from CommsDat and writes it to cache. This should be called

     * before the first client has connected to ConnMon.

     *

     * @return error code.

     */

    void Init(

            CConnMonServer* aServer,

            CConnMonIAP* aConnMonIap,

            RPointerArray<TConnMonBearer>* aBearers );

    inline TUint32 GetIapRecordTableId() { return iIapRecordTableId; }

    inline TUint32 GetSnapRecordTableId() { return iSnapRecordTableId; }

    inline TUint32 GetVirtualRecordTableId() { return iVirtualRecordTableId; }

    /**

     * Reads a changed CommsDat table and if changes are detected, updates the

     * internal cache.

     *

     * @param aTableId Table ID of the changed CommsDat table

     */

    void RefreshCommsDatCacheL( const TUint32 aTableId );

    /**

     * Updates the internal structures of the cache and recalculates all SNAP

     * and IAP availability information.

     * If aCanSendEvents is true, will send IAP and/or SNAP availability

     * changed events if changes detected.

     */

    void RefreshAvailabilityInfo( const TBool aCanSendEvents );

    /**

     * Sets the availability status to available for all IAPs with matching

     * bearer ID / service type.

     */

    void SetAvailableIapsWithBearerId( const TUint aServiceType );

    /**

     * Sets the availability status to available for the IAP with given ID.

     */

    void SetAvailableIapWithId( const TUint aId );

    /**

     * Get available IAP IDs related to given bearer ID.

     *

     * @param aBearerId Bearer ID to identify between all bearers and a

     * specific one.

     * @param aIapInfo A TConnMonIapInfo object to contain the IDs.

     * @return error code.

     */

    TInt GetAvailableIaps( const TUint aBearerId, TConnMonIapInfo& aIapInfo );

    /**

     * Get available SNAP IDs.

     *

     * @param aSnapInfo A TConnMonSNAPInfo object to contain the IDs.

     */

    void GetAvailableSnaps( TConnMonSNAPInfo& aSnapInfo );

    /**

     * Get available SNAP IDs.

     *

     * @param aSnapIds Array to contain the IDs.

     * @return KErrNoMemory if the RArray fails to allocate memory for itself,

     * KErrNone otherwise.

     */

    TInt GetAvailableSnaps( RArray<TConnMonId>& aSnapIds );

private:

    /**

     * Constructor.

     */

    CConnMonCommsDatCache();

    /**

     * 2nd level constructor.

     */

    void ConstructL();

    /**

     * Reads all relevant CommsDat information to cache and initializes the

     * SNAP and virtual IAP table IDs.

     */

    void InitCommsDatCacheL();

    /**

     * Reads all IAPinformation from CommsDat and updates the cache if

     * necessary.

     *

     * @return ETrue if cache information was changed, EFalse otherwise.

     */

    TBool RefreshCommsDatIapCacheL( CommsDat::CMDBSession& aDb );

    /**

     * Reads all IAP table information from CommsDat into an array.

     */

    void ReadCommsDatIapTableL(

            CommsDat::CMDBSession& aDb,

            RArray<TConnMonIapEntry>& aCurrentIapData,

            RArray<TUint>& aCurrentWlanIapIds );

    /**

     * Reads one record from IAP table and finds out the service and bearer

     * types.

     */

    void ReadCommsDatIapEntryL(

            CommsDat::CCDIAPRecord* aIapEntry,

            RArray<TLanBearerEntry>& aLanBearerTableCache,

            TUint& aBearerType,

            TUint& aServiceType );

    /**

     * Reads all records from the LAN bearer table and checks if they are WLAN

     * bearer type. Results are stored in an array.

     */

    void ReadCommsDatLanBearerTableL(

            CommsDat::CMDBSession& aDb,

            RArray<TLanBearerEntry>& aLanBearerTableCache );

    /**

     * Reads all SNAP information from CommsDat and updates the cache if

     * necessary.

     *

     * @return ETrue if cache information was changed, EFalse otherwise.

     */

    TBool RefreshCommsDatSnapCacheL( CommsDat::CMDBSession& aDb );

    /**

     * Reads all SNAP information from CommsDat to an array.

     */

    void ReadCommsDatSnapTableL(

            CommsDat::CMDBSession& aDb,

            RArray<TConnMonSnapEntry>& aCurrentSnapData );

    /**

     * Reads all virtual IAP link information from CommsDat and updates the

     * cache if necessary. CommsDat is not read if IAP table did not contain

     * any virtual IAPs.

     *

     * @return ETrue if cache information was changed, EFalse otherwise.

     */

    TBool RefreshCommsDatVirtualIapCacheL( CommsDat::CMDBSession& aDb );

    /**

     * Reads all virtual IAP link information from CommsDat to an array.

     */

    void ReadCommsDatVirtualIapTableL(

            CommsDat::CMDBSession& aDb,

            RArray<TConnMonVirtualIapEntry>& aCurrentVirtualIapData );

    /**

     * Compares to sorted RArray<TUint> arrays. Returns ETrue if the arrays are not identical.

     */

    TBool CompareSortedArrays(

            const RArray<TUint>& aFirstArray,

            const RArray<TUint>& aSecondArray );

    /**

     * Compares to sorted RArray<TConnMonIapEntry> arrays. Returns ETrue if the arrays are not identical.

     */

    TBool CompareSortedArrays(

            const RArray<TConnMonIapEntry>& aFirstArray,

            const RArray<TConnMonIapEntry>& aSecondArray );

    /**

     * Compares to sorted RArray<TConnMonSnapEntry> arrays. Returns ETrue if

     * the arrays are not identical.

     */

    TBool CompareSortedArrays(

            const RArray<TConnMonSnapEntry>& aFirstArray,

            const RArray<TConnMonSnapEntry>& aSecondArray );

    /**

     * Compares to sorted RArray<TConnMonVirtualIapEntry> arrays. Returns ETrue

     * if the arrays are not identical.

     */

    TBool CompareSortedArrays(

            const RArray<TConnMonVirtualIapEntry>& aFirstArray,

            const RArray<TConnMonVirtualIapEntry>& aSecondArray );

    /**

     * Copy new data into a RArray<TUint> array.

     */

    void DeepCopy(

            const RArray<TUint>& aSourceArray,

            RArray<TUint>& aTargetArray );

    /**

     * Updates the index links for SNAPs and virtual IAPs.

     */

    void UpdateSnapAndVirtualIapLinks();

    /**

     * Sets the availability flag to false for all IAPs and SNAPs contained in

     * cache.

     */

    void ResetAllAvailabilityInfo();

    /**

     * Solve SNAP and virtual IAP availability. The results depend on real IAP

     * availability, so those need to be set when this method is called.

     */

    void SolveSnapAndVirtualIapAvailability();

    /**

     * Create a EConnMonIapAvailabilityChange event and add it to the event

     * queue to be sent to clients.

     */

    TInt SendIapAvailabilityEvent();

    /**

     * Create a EConnMonSNAPsAvailabilityChange event and add it to the event

     * queue to be sent to clients.

     */

    TInt SendSnapAvailabilityEvent();

    /**

     * Finds the index in cache for IAP with id aId. Returns KErrNotFound (-1)

     * if no match is found.

     */

    TInt FindIapIndex( const TUint aId );

    /**

     * Finds the first index in cache for SNAP with ID aId. Returns

     * KErrNotFound (-1) if no match is found.

     */

    TInt FindSnapIndex( const TUint aId );

    /**

     * Takes a SNAP cache index and reads the ID from that entry. Then adjusts

     * the availability for each cache entry related to that ID.

     */

    void SetSnapAvailabilityAtIndex( TUint aIndex, TInt aAvailability );

    /**

     * Check IAP availability by index

     */

    TInt CheckIapAvailability( TUint aIndex );

    /**

     * Check SNAP availability by index

     */

    TInt CheckSnapAvailability( TUint aIndex );

    /**

     * Updates the internal list of available IAP IDs and returns ETrue if it

     * has changed.

     */

    TBool UpdateAvailableIaps();

    /**

     * Updates the internal list of available SNAP IDs and returns ETrue if it

     * has changed.

     */

    TBool UpdateAvailableSnaps();

    /**

     * Checks from LAN bearer table array if given ID has a WLAN bearer.

     */

    TBool HasWlanBearer(

            TUint32 aId,

            RArray<TLanBearerEntry>& aLanBearerTableCache );

    /**

     * Convert a bearer ID to (cache internal) service type

     */

    TInt ConvertBearerIdToServiceType(

            const TUint aBearerId,

            TUint& aServiceType );

    /**

     * Checks from CommsDat if WLAN background scanning is enabled.

     *

     * @return ETrue if WLAN background scanning is enabled, EFalse otherwise.

     */

    TBool IsWlanBackgroundScanningEnabledL();

private: // Data

    // To keep track of Init()-method call.

    TInt iInitStatus;

    // Flags set when changes in CommsDat (compared to cache) detected.

    TBool iIapsChanged;

    TBool iSnapsChanged;

    TBool iVirtualIapsChanged;

    // Set in init phase, is WLAN bearer available or not.

    TBool iWlanSupportEnabled;

    // Table IDs for CommsDat record types, will be set during init phase.

    TUint32 iIapRecordTableId;

    TUint32 iSnapRecordTableId;

    TUint32 iVirtualRecordTableId;

    // Counter for virtual IAPs. Whwn zero, virtual IAP link table is not read.

    TInt iVirtualIapCount;

    // Cache for WLAN IAP IDs, to efficiently detect any changes. WLAN scan

    // enabled when changes occur.

    RArray<TUint> iWlanIapIdCache;

    // Cache for available IAP IDs, to efficiently detect availability changes.

    RArray<TUint> iIapIdCache;

    // Cache for available SNAP IDs, to efficiently detect availability changes.

    RArray<TUint> iSnapIdCache;

    // Cache tables, own

    RArray<TConnMonIapEntry>* iIapCache;

    RArray<TConnMonSnapEntry>* iSnapCache;

    RArray<TConnMonVirtualIapEntry>* iVirtualIapCache;

    // Pointer to server module, not own

    CConnMonServer* iServer;

    // Pointer to IAP module, not own

    CConnMonIAP* iIap;

    // Bearers, not own

    RPointerArray<TConnMonBearer>* iBearers;

    };

#endif // CONNMONCOMMSDATCACHE_H

// End-of-file