/*

* Copyright (c) 2003 - 2005 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:  SIP Settings model.

*

*/

#ifndef GS_SIP_MODEL_H

#define GS_SIP_MODEL_H

// INCLUDES

#include <e32base.h>

#include "tsipsettingsdata.h"

#include "mgssipprofilehandler.h"

#include <sipprofileregistryobserver.h>

#include <sipmanagedprofile.h>

#include <sipmanagedprofileregistry.h>

// FORWARD DECLARATIONS

class CGSPluginInterface;

class CSIPManagedProfileRegistry;

class MSIPProfileRegistryObserver;

class CGSSIPAppShutter; 

// CLASS DECLARATION

/**

*  CGSSIPModel model class

*  @since 3.0

*  model class for all SIP Settings

*/

class CGSSIPModel 

    : public CBase,

      public MSIPProfileRegistryObserver,

      public MGSSIPProfileHandler

    {

    public:  // Constructors and destructor

        /**

        * Two-phased constructor.

        * @return Pointer to created instance

        */

        static CGSSIPModel* NewL();

        /**

        * Destructor.

        */

        virtual ~CGSSIPModel();

    public: // New functions

        /**

        * Creates the SIP profile engine       

        * @param aAppUi for CGSSIPPSettingsPlugin UI

        */

        void CreateEngineL( CGSPluginInterface* aAppUi );                        

        /**

        * Sets flag to quit the application after save has occured

        */

        void QuitAfterSave();

        /**

        * Returns pointer to the profile based on id

        * @param aId Profile id

        * @return Pointer to returned profile

        */

        CSIPManagedProfile* Profile( TUint aId );

        /**

        * Checks if profile can be deleted.

        * @param aIndex Index to the deleted profile

        * @param aIsUse ETrue if profile is in use

        * @param aDefault ETrue if profile is default profile 

        * @param aLocked ETrue if profile is locked 

        */

        void CheckProfileForDeleteL( 

            TInt aIndex, TBool& aIsUse, TBool& aDefault, TBool& aLocked );

        /**

        * Checks is profile in use.

        * @param aProfileId for SIP profile id

        * @return ETrue if profile is in use 

        */

        TBool CheckIsProfileInUseL( TUint32 aProfileId );

    public: // Functions from base classes

        /** 

        * from MSIPProfileRegistryObserver 

        * SIP profile information event

        * @param aProfileId is id for profile

        * @param aEvent type of information event

		*/

		void ProfileRegistryEventOccurred(

		    TUint32 aSIPProfileId, TEvent aEvent );

        /** 

        * SIP profile creation event

        * @param aSIPProfileId id of new SIP Profile

		*/

		void ProfileCreatedL( TUint32 aSIPProfileId );

		/** 

		* SIP profile information update event

		* @param aSIPProfileId id of updated SIP Profile

		*/

		void ProfileUpdatedL( TUint32 aSIPProfileId );

		/**

		* SIP profile registration status changed event

		* @param aSIPProfileId id of profile which registration 

		*        status has been changed.

		*/

		void ProfileRegistrationStatusChanged( TUint32 aSIPProfileId );

		/**		

        * SIP profile destruction event.

        * @param aSIPProfileId id of profile which was destroyed

		*/

		void ProfileDestroyed( TUint32 aSIPProfileId );

        /**

        * Added profile index in the profiles list

        * @return profile index

        */

        TInt AddedProfileIndex();

		/**

        * from MSIPProfileRegistryObserver

		* An asynchronous error has occurred related to SIP profile		

        * @param aSIPProfileId the id of failed profile 

		* @param aError a error code

		*/

		void ProfileRegistryErrorOccurred(				    

		    TUint32 aSIPProfileId,

		    TInt aError);

        /**

        * from MGSSIPProfileHandler

        * Sets the default profile        

        * @param aIndex Index on the array table of the profile that is going

        *               to be a new default profile        

        */

        void SetDefaultProfileL( TInt aIndex );

        /**

        * from MGSSIPProfileHandler

        * Gets the index of the default profile

        * @return KErrNotFound, if one does not exist, otherwise index to profile

        */

        TInt DefaultProfileIndex();

        /**

        * from MGSSIPProfileHandler

        * Returns pointer to the profile array, does not change ownership

        * @return Pointer to the profile array

        */

        CArrayPtr<CSIPManagedProfile>* ProfileArray();

        /**

        * from MGSSIPProfileHandler

        * Starts modifying a profile, copies profile's data to iProfileData

        * @param aIndex index on the array table        

        * @return Ok to move to the next view?

        */

        TBool EditProfileL( TInt aIndex );

        /**

        * from MGSSIPProfileHandler

        * Starts editing a profile that is based on existing one. 

        * @param aCopiedIndex index on the array table of the copied profile       

        */

        void CreateAndEditProfileL( TInt aCopiedIndex );

        /**

        * from MGSSIPProfileHandler

        * Deletes a profile from permanent storage

        */

        void DeleteProfileL( TInt aIndex );

        /**

        * from MGSSIPProfileHandler

        * Checks if there has been an error in registration

        * @param aIndex Index to the table

        * @return Error has happened in registration or then not

        */

        TBool ErrorInRegistration( TInt aIndex );

        /**

        * from MGSSIPProfileHandler

        * Returns pointer to profile data structure for modifying it directly

        * @return Pointer to iProfileData

        */

        TSIPSettingsData* ProfileData();

        /**

        * from MGSSIPProfileHandler

        * Saves profile's changes or returns EFalse if no changes are present.        

        * @return EFalse if no changes (not saved then), otherwise engine

        *         starts saving the modifications

        */

        TBool SaveProfileL();

        /**

        * from MGSSIPProfileHandler

        * Returns list of different profile service types

        * @return list of types

        */

        RArray<TSIPProfileTypeInfo>* TypeListL();

        /**

        * Checks that there are no duplicate profile names.

        * @param aProfileId for current profile to be checked.

        * @param aName for profile name to be checked.

        * @param aCreatedFromExistingProfile to inform if the profile

        * was created from existing profile and language specific

        * number conversions must be done.

        */

        void CheckDuplicateNameL( TInt32 aProfileId, TDes& aName,  

                           TBool aCreatedFromExistingProfile = EFalse);  

    protected:  // New functions

        /**

        * Reads the profile array from SIP Profile Client

        */        

        void ReadArrayFromEngineL();

        /**

        * Copies profile from CSIPManagedProfile to iProfileData for modifications

        * @param aIndex The index to the array to be copied

        */

        void CopyToProfileDataStructL( TInt aIndex );    

        /**

        * Fills the data structure with default values

        */

        void FillDataStructWithDefaultValsL();

        /**

        * Checks if user has made any modfications to the existing profile

        * @return ETrue if user has modified the profile

        */

        TBool CheckForModificationsL();

        /**

        * Copies data from iProfileData to the actual CSIPManagedProfile

        * @return Profile where the stuff was copied to..

        */

        CSIPManagedProfile* CopyDataToProfileL();

        /**        

        * Replaces one profile with another on the array; only cloned profiles

        * should be replaced

        * @param aIndex   Index on the table of the array that is replaced

        * @param aProfile The profile that replaces existing profile

        */

        void ReplaceProfileL( TInt aId, CSIPManagedProfile* aProfile );

        /**

        * Reads profile list from the engine; if reading fails,

        * keeps the old list safe and returns it

        */

        void ReadProfileListFromEngineSafeL();

        /**

        * Calls app ui to udpate the lists; might also trigger exit

        * @param aCmd Command that is passed to view

        */

        void UpdateListCmd( TInt aCmd = EGSCmdUpdateList );

    private:

        /**

        * C++ default constructor.

        */

        CGSSIPModel();

        /**

        * By default Symbian 2nd phase constructor is private.

        */

        void ConstructL();            

        /**

        * For deleting RPointerArray in case of leave

        */

        static void ResetAndDestroy( TAny* aPointerArray );   

        /**

        * For deleting allocated RArray in case of leave

        * @param aArray An array to be destroyed.

        */

        static void CloseAndDestroy( TAny* aArray );     

    private:    // Data

        // The profile's data, which is manipulated

        TSIPSettingsData iProfileData;

        // Instance to the engine

        CSIPManagedProfileRegistry* iEngine;

        // Array of all the profiles

        CArrayPtrFlat<CSIPManagedProfile>* iProfiles;

        // Temporary pointer storage for a new profile before

        // placing it to the permanent storage

        CSIPManagedProfile* iNewProfile;

        // Flag indicating if one should quit after save

        TBool iQuitAfterSave;

        // For quitting app asynchronously after save

        CGSSIPAppShutter* iAppShutter;

        // Instance to plugin UI

        CGSPluginInterface* iAppUi;

        //Index of new profile in the list

        TInt iAddedProfileIndex;

    };

#endif      // GS_SIP_MODEL_H   

// End of File