/*

* Copyright (c) 2003-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:

* Name        : sipprofileregistrybase.h

* Part of     : SIP Profile Client

* Interface   : SDK API, SIP Profile API

* The class for retrieving SIP profiles from permanent storage.

* Version     : 1.0

*

*/

#ifndef CSIPPROFILEREGISTRYBASE_H

#define CSIPPROFILEREGISTRYBASE_H

//  INCLUDES

#include <e32base.h>

#include <badesca.h>

#include "sipconcreteprofileobserver.h"

// FORWARD DECLARATIONS

class CSIPProfile;

class CSIPConcreteProfile;

class TSIPProfileTypeInfo;

class CSIPProfileCleanupItem;

class CSIPProfileItem;

class CSIPProfileITCReceiver;

class CSIPProfileITC;

class CSIPProfilePlugins;

class MSIPProfileRegistryObserver;

class RSIPProfile;

class CSIPConcreteProfileHolder;

// CLASS DECLARATION

/**

* @publishedAll

* @released

*

* The class functions for retrieving SIP profiles from permanent storage.

* It enables retrieval of single or more profiles from permanent

* storage located in profile server.

*  

* The class enables also the query of supported profile types.

*

* This class is an abstract class and cannot be instantiated.

*

* @lib sipprofilecli.lib

*/

class CSIPProfileRegistryBase: public CBase, public MSIPConcreteProfileObserver

    {

    public:  // Constructors and destructor

        IMPORT_C ~CSIPProfileRegistryBase();

    public: //new functions

        /**

        * Gets all SIP profiles

        * @pre aProfiles.Count() == 0

        * @param aProfiles a reference to a client-owned array, which

        *        on return is filled with all existing SIP profiles

        * @leave KErrNoMemory if out of memory

        * @capability ReadUserData

        */

        IMPORT_C void ProfilesL(RPointerArray<CSIPProfile>& aProfiles);

        /**

        * Gets all SIP profiles of particular type

        * The owneship of profiles are transferred.

        * @pre aProfiles.Count() == 0

        * @param aType a SIP profile type that is used for a query

        * @param aProfiles a reference to a client-owned array, which

        *        on return is filled with profiles of the given type.

        * @leave KErrNoMemory if out of memory

        * @capability ReadUserData

        */        

        IMPORT_C void ProfilesL(

                     const TSIPProfileTypeInfo& aType,

                     RPointerArray<CSIPProfile>& aProfiles);

        /**

        * Gets SIP profile for a particular SIP AOR

        * The owneship of profiles are transferred.

        * @pre aProfiles.Count() == 0

        * @param aAOR a SIP AOR e.g. user@domain.com

        * @param aProfiles a reference to a client-owned array, which

        *        on return is filled with profiles of the given type.

        * @leave KErrNoMemory if out memory

        * @capability ReadUserData

        */

        IMPORT_C void ProfilesL(

                     const TDesC8& aAOR,

                     RPointerArray<CSIPProfile>& aProfiles);

        /**

        * Gets SIP profile identified by the Id

        * The owneship of profile is transferred.

        * @param aId a SIP profile Id

        * @return SIP profile 

        * @leave KErrNotFound if profile is not found

        * @capability ReadUserData

        */

        IMPORT_C CSIPProfile* ProfileL(TUint32 aId);

        /**

        * Gets the default profile

        * @return default profile; the owneship is transfered

        * @leave KErrNotFound if profile not found

        * @leave KErrNoMemory if out of memory

        * @capability ReadUserData

        */

        IMPORT_C CSIPProfile* DefaultProfileL();

        /**

        * Gets supported profile types

        * The owneship of returned objects are transferred.

        * @pre aSupportedProfileTypes.Count() == 0

        * @param aSupportedProfileTypes a reference to  client-owned array,

        *        which on return is filled with supported profile types.

        *         Any existing data in the array is destroyed.

        * @leave KErrNoMemory if out of memory

        */

        IMPORT_C void SupportedProfileTypesL(

                    RArray<TSIPProfileTypeInfo>& aSupportedProfileTypes);

        /**

        * Gets the last occurred error during registration

        * @param aProfile 

        * @return last occurred registration error, KErrNone if no error

        */

        IMPORT_C TInt LastRegistrationError(const CSIPProfile& aProfile) const;

    public:

        /**

        * Enable profile

        * @param aProfile to be enabled

        * @internalComponent        

        */

        void EnableProfileL(CSIPProfile& aProfile);

        /**

        * Gets count of clients that have a profile enabled

        * @param aProfile profile to be checked

        * @return number of clients that have the profile enabled

        * @internalComponent

        */

        TInt UsageL(const CSIPProfile& aProfile) const;

        /**

        * Disable profile

        * @param aProfile to be disabled

        * @internalComponent

        */

        void DisableProfileL(CSIPProfile& aProfile);

        /**

        * Force disable profile

    	* All Profile related activities will be stopped ungracefully

        * @param aProfile to be disabled

        * @internalComponent

        */

        void ForceDisableProfileL(CSIPProfile& aProfile);

        /**

        * Add profile

        * @param aProfile to be added

        * @internalComponent

        */

        void AddProfileL(CSIPProfile& aProfile);

        /**

        * Update profile

        * @param aProfile to be updated

        * @internalComponent

        */

        void UpdateProfileL(CSIPProfile& aProfile);

        /**

        * Remove profile

        * @pre UsageL(aProfile) == 0

        * @param aProfile to be removed

        * @internalComponent

        */

        void RemoveProfileL(CSIPProfile& aProfile);

        /**

        * Informs destruction of local profile object instance

        * @param aProfile instance of deleted profile

        * @internalComponent

        */

        void ProfileDeleted(CSIPProfile& aProfile);

        /**

        * Checks whether profile is default or not

        * @param aProfile checked profile

        * @return ETrue if is default, otherwise EFalse

        * @internalComponent

        */

        TBool IsDefaultProfileL(const CSIPProfile& aProfile);

        /**

        * Updates SIP profile value for negotiated security mechanism; leaves on failure

        * @param aProfile a SIP profile

        * @internalComponent

        */

        void NegotiatedSecurityMechanismL(CSIPConcreteProfile& aProfile);

        /**

        * Updates SIP profile value for registered AORs; leaves on failure

        * @param aProfile a SIP profile

        * @internalComponent

        */

        void RegisteredAORsL(CSIPConcreteProfile& aProfile);

        /**

        * Gets new instance of either type CSIPProfile or CSIPManagedProfile

        * @return new instance

        * @internalComponent

        */        

        virtual CSIPProfile* NewInstanceL() = 0;

        /**

        * Roll back in case of failure

        * @param aItem object to be cleaned

        * @internalComponent

        */

        static void CrashRevert (TAny* aItem);

        /**

        * Roll back in case of failure

        * @param aItem object to be cleaned

        * @internalComponent

        */

        static void LocalCrashRevert (TAny* aItem);

        /**

        * Gets the ITC member variable.

        * The owneship of ITC is not transferred.

        * @return Reference to ITC member variable.

        * @internalComponent 

        */

        CSIPProfileITC& Itc(); 

        /**

        * Gets the ITC receiver member variable.

        * The owneship of ITC receiver is not transferred.

        * @return Reference to ITC receiver member variable.

        * @internalComponent 

        */

        CSIPProfileITCReceiver& ItcReceiver(); 

    public: // From MSIPConcreteProfileObserver

        /**

        * SIP profile registration status changed event

        * @param aProfileId id of profile which registration 

        *        status has been changed.

        * @param aStatus new status of the profile

        * @param aStatusId id related to registration

        * @internalComponent

        */

        void RegistrationStatusChangedL(TUint32 aProfileId, 

                                       TInt aStatus,

                                       TUint32 aStatusId);

        /** 

        * SIP profile creation event.

        * @param aProfileId id of new SIP Profile

        * @internalComponent

        */

        void AddedL(TUint32 aProfileId);

        /**

        * SIP profile destruction event.

        * @param aProfileId id of profile which was destroyed

        * @internalComponent

        */    

        void RemovedL(TUint32 aProfileId);

        /** 

        * SIP profile information update event

        * @param aProfileId id of updated SIP Profile

        * @param aSize size of updated SIP Profile

        * @internalComponent

        */

        void UpdatedL(TUint32 aProfileId, TUint aSize);

        /**

        * An asynchronous error has occurred related to SIP profile

        * @param aProfileId the id of failed profile 

        * @param aStatus

        * @param aError a error code

        * @internalComponent

        */

        void ErrorOccurredL(TUint32 aProfileId,

                            TInt aStatus,

                            TInt aError);

    protected: 

        /**

        * Constructor

        * @param aObserver observer to send events to

        * @internalComponent 

        */

        CSIPProfileRegistryBase(MSIPProfileRegistryObserver& aObserver); 

        /**

        * Symbian 2nd phase base class constructor

        * @internalComponent

        */

        void BaseConstructL();

        /**

        * Store profile into client cache

        * @param aItem a cleanup item for roll back in case of failure

        * @internalComponent

        */

        void StoreProfileL(CSIPProfileCleanupItem* aItem);

        /**

        * Store array of profiles into client cache

        * @param aProfiles a array containing the profiles

        * @param aRetProfiles returned array containing profiles

        * @internalComponent

        */

        void StoreArrayL(

            RPointerArray<CSIPConcreteProfile>& aProfiles,

            RPointerArray<CSIPProfile>& aRetProfiles);

        /**

        * Gets profile cache item

        * @param aProfileId a profile id to be found

        * @return local cache item of the profile

        * @internalComponent

        */        

        CSIPProfileItem* ProfileItemL(TUint aProfileId);

        /**

        * Gets profile cache item index

        * @param aProfileId a profile id to be found

        * @return local cache item index of the profile

        * @internalComponent

        */        

        TInt ProfileIndex (TUint aProfileId);

        /**

        * Gets profile cache item by index

        * @param aIndex a index of the profile to be found

        * @return local cache item of the profile

        * @internalComponent

        */        

        CSIPProfileItem* ProfileItemByIndex(TUint aIndex);

        /**

        * Gets SIP profile identified by the Id; leaves on failure

        * The owneship of profile is transferred.

        * @param aId a SIP profile Id

        * @param aSize of profile if known

        * @return SIP profile or 0 pointer if there's no such SIP profile

        * @internalComponent

        */

        CSIPProfile* SIPProfileL(TUint32 aId, TInt aSize = 0);

    protected: // Data

        /**

        * @internalComponent

        */

        RSIPProfile* iSipClient;

        /**

        * @internalComponent

        */        

        CSIPProfileITCReceiver* iITCReceiver;

        /**

        * @internalComponent

        */        

        CSIPProfileITC* iITC;

        /**

        * @internalComponent

        */        

        MSIPProfileRegistryObserver& iObserver;

        /**

        * @internalComponent

        */        

        RPointerArray<CSIPProfileItem> iProfiles;

        /**

        * @internalComponent

        */        

        CSIPProfilePlugins* iProfilePlugins;

        /**

        * @internalComponent

        */        

        CSIPProfileItem* iFindEntry;

    private:

        void ProfilesCommonL(RPointerArray<CSIPProfile>& aProfiles, 

                             CSIPConcreteProfileHolder* aHolder);

    };

#endif // CSIPPROFILEREGISTRYBASE_H