/*

 * 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