/*
* Copyright (c) 2006-2007 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:  Model for managing SIP profiles.
*  Version     : %version: 19 % << Don't touch! Updated by Synergy at check-out.
*
*/


#include <sipmanagedprofileregistry.h>
#include <sipmanagedprofile.h>

#include "mussipprofilemodel.h"
#include "muslogger.h"
#include "mussettings.inl"
#include "mussettingsmodel.h"


const TInt KUnknownProfileId = 0;


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


// ----------------------------------------------------------------------------
// 
// ----------------------------------------------------------------------------
//
CMusSIPProfileModel::CMusSIPProfileModel()
    {
    }

// ----------------------------------------------------------------------------
// 
// ----------------------------------------------------------------------------
//
void CMusSIPProfileModel::ConstructL()
    {
    MUS_LOG( "[MUSSET] <- CMusSIPProfileModel::ConstructL()" )
            
    MUS_LOG( "[MUSSET]  Creating CSIPManagedProfileRegistry " )
    iEngine = CSIPManagedProfileRegistry::NewL( *this );
    MUS_LOG( "[MUSSET]  Done " )
    MUS_LOG( "[MUSSET]  Getting profiles " )
    iEngine->ProfilesL( iProfiles );
    MUS_LOG( "[MUSSET]  Done " )
    SortProfilesL();
    MUS_LOG( "[MUSSET] -> CMusSIPProfileModel::ConstructL()" )
    }

// ----------------------------------------------------------------------------
// 
// ----------------------------------------------------------------------------
//
CMusSIPProfileModel* CMusSIPProfileModel::NewL()
    {
    MUS_LOG( "[MUSSET] -> CMusSIPProfileModel::NewL()" )
    CMusSIPProfileModel* self = new( ELeave ) CMusSIPProfileModel();

    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    MUS_LOG( "[MUSSET] <- CMusSIPProfileModel::NewL()" )
    return self;
    }

// ----------------------------------------------------------------------------
// 
// ----------------------------------------------------------------------------
//
CMusSIPProfileModel::~CMusSIPProfileModel()
    {
    MUS_LOG( "[MUSSET] -> CMusSIPProfileModel::~CMusSIPProfileModel()" )
    iProfiles.ResetAndDestroy();
    delete iEngine;
    MUS_LOG( "[MUSSET] <- CMusSIPProfileModel::~CMusSIPProfileModel()" )
    }

// ----------------------------------------------------------------------------
// Returns reference to the locally cached SIP profile array.
// ----------------------------------------------------------------------------
//
RPointerArray<CSIPProfile>& CMusSIPProfileModel::ProfileArrayL()
    {
    MUS_LOG( "[MUSSET] <-> CMusSIPProfileModel::ProfileArrayL()" )
    return iProfiles;
    }

// ----------------------------------------------------------------------------
// Returns index to the default SIP profile in locally cached array.
// ----------------------------------------------------------------------------
//
TInt CMusSIPProfileModel::DefaultProfileIndex()
    {
    MUS_LOG( "[MUSSET] -> CMusSIPProfileModel::DefaultProfileIndex()" )
    TInt index( KErrNotFound );

    for ( TInt i = 0; i < iProfiles.Count(); i++ )
        {
        TBool defProfile( EFalse );
        if (
    	    KErrNone ==
    	    iProfiles[i]->GetParameter( KSIPDefaultProfile, defProfile )
    	    && defProfile )
            {
            index = i;
            break;
            }
        }

    MUS_LOG1( "[MUSSET] <- CMusSIPProfileModel::DefaultProfileIndex()( %d )",
              index )
    return index;
    }

// ----------------------------------------------------------------------------
// Returns id of the default SIP profile. If default SIP profile is not found
// KUnknownProfileId is returned.
// ----------------------------------------------------------------------------
//
TUint32 CMusSIPProfileModel::DefaultProfileId()
    {
    MUS_LOG( "[MUSSET] -> CMusSIPProfileModel::DefaultProfileId()" )
    TUint32 id( KUnknownProfileId );

    for ( TInt i = 0; i < iProfiles.Count(); i++ )
        {
        TBool defProfile( EFalse );
        TInt error = iProfiles[i]->GetParameter( KSIPDefaultProfile, defProfile );
        if ( error == KErrNone && defProfile )
            {
            iProfiles[i]->GetParameter( KSIPProfileId, id );
            break;
            }
        }

    MUS_LOG1( "[MUSSET] <- CMusSIPProfileModel::DefaultProfileId()( %d )",
              id )
    return id;
    }

// -----------------------------------------------------------------------------
// Disable SIP Registration.
// -----------------------------------------------------------------------------
//
void CMusSIPProfileModel::DisableProfileL()
    {
    MUS_LOG( "[MUSSET]  -> CMusSIPProfileModel::DisableProfileL " )        
    CSIPManagedProfile* managedProfile = static_cast<CSIPManagedProfile*>(
            iEngine->ProfileL( DefaultProfileId()) );
    CleanupStack::PushL( managedProfile );
    MUS_LOG( "[MUSSET]  Add registration parameter to profile.dat file " )
    //set autoregistration off (i.e. when needed) => disable profile
    User::LeaveIfError( managedProfile->SetParameter( KSIPAutoRegistration, EFalse ) );
    MUS_LOG( "[MUSSET]  Saving profile " )
    iEngine->SaveL( *managedProfile );
    MUS_LOG( "[MUSSET]  Saved" )
    CleanupStack::PopAndDestroy( managedProfile );
    MUS_LOG( "[MUSSET]  <- CMusSIPProfileModel::DisableProfileL " )        
    }

// -----------------------------------------------------------------------------
// Enable SIP Registration.
// -----------------------------------------------------------------------------
//
void CMusSIPProfileModel::EnableProfileL()
    {
    MUS_LOG( "[MUSSET]  -> CMusSIPProfileModel::EnableProfileL " )        
    CSIPManagedProfile* managedProfile = static_cast<CSIPManagedProfile*>(
            iEngine->ProfileL( DefaultProfileId() ) );
    CleanupStack::PushL( managedProfile );
    MUS_LOG( "[MUSSET] Add registration parameters to profile.dat file " )
    //set autoregistration on (i.e. always on) => enable profile
    User::LeaveIfError( managedProfile->SetParameter( KSIPAutoRegistration, ETrue ) );
    MUS_LOG( "[MUSSET]  Saving profile " )
    iEngine->SaveL( *managedProfile );
    MUS_LOG( "[MUSSET]  Saved" )
    CleanupStack::PopAndDestroy( managedProfile );
    MUS_LOG( "[MUSSET]  <- CMusSIPProfileModel::EnableRegisterL " )        
    }

// -----------------------------------------------------------------------------
// if SIP Registration enabled.
// -----------------------------------------------------------------------------
//
TBool CMusSIPProfileModel::ProfileEnabledL()
    {
    MUS_LOG( "[MUSSET]  -> CMusSIPProfileModel::ProfileEnabledL " ) 
    CSIPManagedProfile* managedProfile = static_cast<CSIPManagedProfile*>(
            iEngine->ProfileL( DefaultProfileId() ) );
    CleanupStack::PushL( managedProfile );
    TBool enabled;
    MUS_LOG( "[MUSSET]  Getting KSIPAutoRegistration" ) 
    User::LeaveIfError( 
            managedProfile->GetParameter( KSIPAutoRegistration, enabled ) );
    MUS_LOG( "[MUSSET]  Done" ) 
    MUS_LOG1( "[MUSSET]  KSIPAutoRegistration=%d", enabled ) 
    CleanupStack::PopAndDestroy( managedProfile );
    MUS_LOG( "[MUSSET]  <- CMusSIPProfileModel::ProfileEnabledL " )
    return enabled;
    }

// ----------------------------------------------------------------------------
// Returns index of the default SIP profile on locally cached array. If default
// SIP profile is not found, KErrNotFound is returned.
// ----------------------------------------------------------------------------
//
TInt CMusSIPProfileModel::ProfileIndexByIdL( TUint32 aId )
    {
    MUS_LOG( "[MUSSET] -> CMusSIPProfileModel::ProfileIndexByIdL()" )
    TInt index( KErrNotFound );
    
    for ( TInt i = 0; i < iProfiles.Count(); i++ )
        {
        TUint32 id( KUnknownProfileId );
        TInt error = iProfiles[i]->GetParameter( KSIPProfileId, id );
        if ( error == KErrNone && id == aId )
            {
            index = i;
            break;
            }
        }

    MUS_LOG1( "[MUSSET] <- CMusSIPProfileModel::ProfileIndexByIdL()( %d )",
              index )
    return index;
    }


// ----------------------------------------------------------------------------
// Returns profile ID by index.
// ----------------------------------------------------------------------------
//
TUint32 CMusSIPProfileModel::ProfileIdByIndex( TUint aIndex )
    {
    MUS_LOG1( "[MUSSET] -> CMusSIPProfileModel::ProfileIdByIndex()( %d )",
              aIndex )
	TUint32 profileId( KUnknownProfileId );
    if ( aIndex < iProfiles.Count() )
        {
        if ( iProfiles[aIndex]->GetParameter( KSIPProfileId, profileId ) )
            {
            profileId = KUnknownProfileId;
            }
        }

    MUS_LOG( "[MUSSET] <- CMusSIPProfileModel::ProfileIdByIndex()" )
    return profileId;
    }

// ----------------------------------------------------------------------------
// Sorts internal array of SIP profiles by id. Used algorithm is generally
// slower than quicksort and selectionsort but very feasible for expected
// amount of items to be sorted and complexity vise.
// ----------------------------------------------------------------------------
//
void CMusSIPProfileModel::SortProfilesL()
    {
	TUint32 profileIdFirst( 0 );
	TUint32 profileIdSecond( 0 );
    for ( TInt a = 0; a < iProfiles.Count() - 1; a++ )
        {
        for ( TInt b = a + 1; b < iProfiles.Count(); b++ )
            {
            User::LeaveIfError( iProfiles[a]->GetParameter(
            	KSIPProfileId, profileIdFirst ) );
    		User::LeaveIfError( iProfiles[b]->GetParameter(
    			KSIPProfileId, profileIdSecond ) );
            if ( profileIdFirst > profileIdSecond )
                {
                CSIPProfile* tmp = iProfiles[b];
                iProfiles[b] = iProfiles[a];
                iProfiles[a]  = tmp;
                }
            }
        }
    }

// ----------------------------------------------------------------------------
// From class MSIPProfileRegistryObserver.
// Notifies of an event in SIP profile registry.
// ----------------------------------------------------------------------------
//
void CMusSIPProfileModel::ProfileRegistryEventOccurred(
    TUint32 aSIPProfileId, TEvent aEvent )
	{  
    MUS_LOG("[MUSSET] -> CMusSIPProfileModel::ProfileRegistryEventOccurred()" )
    MUS_LOG2("            SIPProfileId is %d,Event is %d",aSIPProfileId,aEvent)
    
    // We revert back to default settings if the profile used by MuS is deleted
    if ( aEvent == EProfileDestroyed )
    	{
    	TRAP_IGNORE( 
            //if the profile is the profile used by mush
            if ( MultimediaSharingSettings::SipProfileSettingL() ==
                 aSIPProfileId )
                {
                //set the profile to default	
                MultimediaSharingSettings::SetSipProfileSettingL( 
                                    CMusSettingsModel::KVsSipProfileDefault );
                //set mush off
                MultimediaSharingSettings::SetActivationSettingL(
                                    MusSettingsKeys::EActiveInHomeNetworks );
                }
            );
		 }
    
    if ( aEvent == EProfileCreated ||
         aEvent == EProfileUpdated ||
         aEvent == EProfileDestroyed )
        {
        // Profiles have been manipulated in SIP side, we must delete client
        // side profile objects and retrieve them again. If fetching fails,
        // we have empty array which is better than showing wrong values to
        // user.
        iProfiles.ResetAndDestroy();
        TRAP_IGNORE( iEngine->ProfilesL( iProfiles ) );
        TRAP_IGNORE( SortProfilesL() );
        }
    
    MUS_LOG( "[MUSSET] <- CMusSIPProfileModel::ProfileRegistryEventOccurred()" )
	}

// ----------------------------------------------------------------------------
// From class MSIPProfileRegistryObserver.
// An asynchronous error has occurred related to SIP profile
// ----------------------------------------------------------------------------
//
void CMusSIPProfileModel::ProfileRegistryErrorOccurred(
	TUint32 /*aSIPProfileId*/,
	TInt /*aError*/ )
    {
    MUS_LOG( "[MUSSET] <- CMusSIPProfileModel::ProfileRegistryErrorOccurred()" )
    }

// ----------------------------------------------------------------------------
//Set CMusSettingsModel to handle ProfileRegistry Event.
// ----------------------------------------------------------------------------
//
void CMusSIPProfileModel::SetCMusSettingsModel(CMusSettingsModel* aCMusSettingsModel)
	{
	iCMusSettingsModel = aCMusSettingsModel;
	}