/*

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

*     Static class to help mtm service queries.

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <bldvariant.hrh>               // For feature flags  

#include <msvuids.h>                    // KUidMsvServiceEntry

#include <data_caging_path_literals.hrh> // KDC_RESOURCE_FILES_DIR

#include <msvapi.h>

#include <msvstd.hrh>

#include <msvids.h>

#include <mtclreg.h>                    // CClientMtmRegistry

#include <muiu_internal.rsg>

#include <bautils.h>

#include <AknPhoneNumberGrouping.h>     // CAknPhoneNumberGrouping

#include "MsgOperationWait.h"           // CMsgOperationWait 

#include <muiumsvuiserviceutilitiesinternal.h>

#include "MuiuCallCmd.h"

#include "MuiuSendKeyAcceptingQueryDialog.h"

#include "MuiuListQueryDialog.h"        // CMuiuListQueryDialog

#include "MuiuEmailTools.h"

#include <centralrepository.h>          // link against centralrepository.lib

#include <messaginginternalcrkeys.h>    // for Central Repository keys

#include <CoreApplicationUIsSDKCRKeys.h>

#include <telconfigcrkeys.h>            // KCRUidTelConfiguration,KTelMatchDigits

#include <mmsgenutils.h>

#include <msgvoipextension.h>

#include <MuiuMsvUiServiceUtilities.h>  // MsvUiServiceUtilities

#include <featmgr.h>

#include <MessagingDomainCRKeys.h>

#include <SendUiConsts.h>

#include <mtudreg.h>

#include <miutset.h>

#include <SendUiConsts.h>

// CONSTANTS

const TInt KDefaultParamValueLength  = -1;   // Default aCompareLength parameter value

                                             // in ComparePhoneNumberL method

const TInt KDefaultCompareLength     = 7;    // Used in ComparePhoneNumberL method

                                             // if aCompareLength parameter has default value

const TInt KEqualCompareValue        = 0;    // CompareF returns 0 if phone numbers are equal

const TInt KFirstItemInList          = 0;

const TInt KHotswapWaitInterval      = 1000000;   // 1 second

const TInt KHotswapWaitMax           = 7;         // 7 number of turns(cycle time KHotswapWaitInterval)

_LIT( KDirAndMuiuResFileName,"muiu_internal.rsc" );

// ---------------------------------------------------------

// MsvUiServiceUtilitiesInternal::CallToSenderQueryL

//

// Used when asking from user if calling to sender of the message and dial

// if user select "Yes".  Check immediately if phone number is valid. If phone number

// is not valid then return EFalse and doesn't do nothing.

// If parameter "aDialWithoutQueries" is true then call immediately to sender of the message 

// and doesn't ask nothing from user before it.

// Returns:  Returns ETrue if the phone number was valid.

// 

// ---------------------------------------------------------

//

EXPORT_C TBool MsvUiServiceUtilitiesInternal::CallToSenderQueryL( const TDesC& aNumber, 

                                                          const TDesC& aName, 

                                                          TBool aDialWithoutQueries )

    {

    TBool validNumber( EFalse );	//Is phone number valid or not

    HBufC* buf = HBufC::NewLC( aNumber.Length() );

    TPtr   bufNumberPtr = buf->Des();

    bufNumberPtr = aNumber;

    validNumber = CommonPhoneParser::ParsePhoneNumber( bufNumberPtr, 

                                                       CommonPhoneParser::EPhoneClientNumber );

    if( validNumber )

        {

        if( aDialWithoutQueries )

            {

            //Start dialing and open Calling dialog

            CMuiuCallCmd* cMuiuCallCmdPtr = CMuiuCallCmd::NewL();

            cMuiuCallCmdPtr->ExecuteLD( bufNumberPtr, aName );

            }

        else

            {

            CMuiuSendKeyAcceptingQueryDialog* dlg = 

                                              CMuiuSendKeyAcceptingQueryDialog::NewL( aNumber, 

                                                                                      aName );

            if( dlg->ExecuteLD( R_MUIU_CALLBACK_QUERY ) )

                {

                //Start dialing and open Calling dialog

                CMuiuCallCmd* cMuiuCallCmdPtr = CMuiuCallCmd::NewL();

                cMuiuCallCmdPtr->ExecuteLD( bufNumberPtr, aName );

                }

            }

        }

    CleanupStack::PopAndDestroy( buf );

    return validNumber;

    }

// ---------------------------------------------------------

// MsvUiServiceUtilitiesInternal::CallServiceL

//

// ---------------------------------------------------------

//

EXPORT_C TBool MsvUiServiceUtilitiesInternal::CallServiceL( 

            const TDesC& aSenderNumber,

            const TDesC& aSenderName,

            const TDesC& aNumberInFocus,

            CEikonEnv* aEnv )

    {

    TBool validNumber( EFalse );

    // Is list query needed

    if ( aNumberInFocus.Length() && aSenderNumber.Length() )

        { 

        // Two numbers, list query is needed

        HBufC* buf = HBufC::NewLC( aNumberInFocus.Length() );

        TPtr   bufNumberPtr = buf->Des();

        bufNumberPtr = aNumberInFocus;

        CommonPhoneParser::ParsePhoneNumber( bufNumberPtr, 

                                             CommonPhoneParser::EPhoneClientNumber );

        HBufC* groupedNumber = CAknPhoneNumberGrouping::CreateGroupedPhoneNumberL( bufNumberPtr );

        CleanupStack::PushL( groupedNumber );

        TPtr groupedNumberPtr = groupedNumber->Des();

        // Adding MUIU's resource-file

        TParse parse;

        parse.Set(KDirAndMuiuResFileName, &KDC_RESOURCE_FILES_DIR, NULL); 

        TFileName resourceFile(parse.FullName());

        if ( !aEnv )

            {

            aEnv  = CEikonEnv::Static();

            }

        BaflUtils::NearestLanguageFile( aEnv->FsSession(), resourceFile );

        TInt offset = aEnv->AddResourceFileL( resourceFile );

        // TRAPD to be sure that resource-file gets also deleted

        TInt index = 0;

        TInt commandId( 0 );

        TRAPD( err,commandId = LaunchDialogL( groupedNumberPtr, &index ) );

        // Removing MUIU's resource-file

        aEnv->DeleteResourceFile( offset );

        CleanupStack::PopAndDestroy( 2, buf ); //groupedNumber, buf

        User::LeaveIfError( err );

        if ( ( commandId == EAknSoftkeyCall ) || ( commandId == EEikBidOk ) )

            { 

            if ( index == 0 )

                {// number in focus

                validNumber = CallToSenderQueryL( aNumberInFocus, KNullDesC );

                }

            else

                {// back to sender

                validNumber = CallToSenderQueryL( aSenderNumber, aSenderName );

                }

            }

        }

    else if ( aSenderNumber.Length() )

        {

        // Sender only, list query is not needed

        // Launch the normal call query

        validNumber = CallToSenderQueryL( aSenderNumber, aSenderName, EFalse );

        }

    else if ( aNumberInFocus.Length() )

        {

        // Focused number only, list query is not needed

        // Launch the normal call query

        validNumber = CallToSenderQueryL( aNumberInFocus, KNullDesC(), EFalse );

        }

    else

        {

        // No numbers

        validNumber = EFalse;

        }

    return validNumber;

    }

// ---------------------------------------------------------

// MsvUiServiceUtilitiesInternal::InternetCallToSenderQueryL

//

// Used when asking from user if calling to sender of the message and dial

// if user select "Yes". Assumes allways that Internet call number is valid and 

// ETrue returned.

// If parameter "aDialWithoutQueries" is true then call immediately to sender of 

// the message and doesn't ask nothing from user before it.

// Returns:  Returns ETrue.

// 

// ---------------------------------------------------------

//

EXPORT_C TBool MsvUiServiceUtilitiesInternal::InternetCallToSenderQueryL( const TDesC& aNumber, 

                                                                  const TDesC& aName, 

                                                                  TBool aDialWithoutQueries )

    {

    //If the SIP URI is not valid then check is the selected number valid CS number.

    if( aDialWithoutQueries )

        {

        //Start dialing and open Calling dialog

        CMuiuCallCmd* cMuiuCallCmdPtr = CMuiuCallCmd::NewL();

        cMuiuCallCmdPtr->ExecuteLD( aNumber, aName, ETrue );

        }

    else

        {

        CMuiuSendKeyAcceptingQueryDialog* dlg = CMuiuSendKeyAcceptingQueryDialog::NewL( aNumber, 

                                                                                        aName );

        if( dlg->ExecuteLD( R_MUIU_CALLBACK_QUERY ) )

            {

            //Start dialing and open Calling dialog

            CMuiuCallCmd* cMuiuCallCmdPtr = CMuiuCallCmd::NewL();

            cMuiuCallCmdPtr->ExecuteLD( aNumber, aName, ETrue );

            }

        }

    return ETrue;

    }

// ---------------------------------------------------------

// MsvUiServiceUtilitiesInternal::InternetCallServiceL

//

// ---------------------------------------------------------

//

EXPORT_C TBool MsvUiServiceUtilitiesInternal::InternetCallServiceL( 

            const TDesC& aSenderNumber,

            const TDesC& aSenderName,

            const TDesC& aNumberInFocus,

            CEikonEnv* aEnv )

    {

        TBool validNumber( EFalse );

    // Is list query needed

    if ( aNumberInFocus.Length() && aSenderNumber.Length() )

        { 

        // Two numbers, list query is needed

        HBufC* buf = HBufC::NewLC( aNumberInFocus.Length() );

        TPtr   bufNumberPtr = buf->Des();

        bufNumberPtr = aNumberInFocus;

        CommonPhoneParser::ParsePhoneNumber( bufNumberPtr, 

                                             CommonPhoneParser::EPhoneClientNumber );

        HBufC* groupedNumber = CAknPhoneNumberGrouping::CreateGroupedPhoneNumberL( bufNumberPtr );

        CleanupStack::PushL( groupedNumber );

        TPtr groupedNumberPtr = groupedNumber->Des();

        // Adding MUIU's resource-file

        TParse parse;

        parse.Set(KDirAndMuiuResFileName, &KDC_RESOURCE_FILES_DIR, NULL); 

        TFileName resourceFile(parse.FullName());

        if ( !aEnv )

            {

            aEnv  = CEikonEnv::Static();

            }

        BaflUtils::NearestLanguageFile( aEnv->FsSession(), resourceFile );

        TInt offset = aEnv->AddResourceFileL( resourceFile );

        // TRAPD to be sure that resource-file gets also deleted

        TInt index = 0;

        TInt commandId( 0 );

        TRAPD( err,commandId = LaunchDialogL( groupedNumberPtr, &index ) );

        // Removing MUIU's resource-file

        aEnv->DeleteResourceFile( offset );

        CleanupStack::PopAndDestroy( 2, buf ); //groupedNumber, buf

        User::LeaveIfError( err );

        if ( ( commandId == EAknSoftkeyCall ) || ( commandId == EEikBidOk ) )

            { 

            if ( index == 0 )

                {// number in focus

                validNumber = InternetCallToSenderQueryL( aNumberInFocus, KNullDesC );

                }

            else

                {               

                // call CS call to sender              

                validNumber = CallToSenderQueryL( aSenderNumber, aSenderName );  

                }

            }

        }

    else if ( aSenderNumber.Length() )

        {

        // Sender only, list query is not needed

        // Launch the normal call query

        validNumber = InternetCallToSenderQueryL( aSenderNumber, aSenderName, EFalse );

        }

    else if ( aNumberInFocus.Length() )

        {

        // Focused number only, list query is not needed

        // Launch the normal call query

        validNumber = InternetCallToSenderQueryL( aNumberInFocus, KNullDesC(), EFalse );

        }

    else

        {

        // No numbers

        validNumber = EFalse;

        }

    return validNumber;

    }

// ----------------------------------------------------

// MsvUiServiceUtilitiesInternal::ChangeMessageStoreToPhoneL

// ----------------------------------------------------

EXPORT_C void MsvUiServiceUtilitiesInternal::ChangeMessageStoreToPhoneL( CMsvSession& aSession )

    {

    //check if message server is busy

    TInt outstanding = 1;

    for ( TInt jj = 0;  jj < KHotswapWaitMax  && outstanding; jj++ )

        {

        outstanding = aSession.OutstandingOperationsL();

        if ( outstanding == 0 )

            {

            // check to see if any mailboxes are open - 

            // otherwise we could miss client side operations

            CMsvEntry* root=CMsvEntry::NewL( aSession, KMsvRootIndexEntryIdValue, 

                TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) );

            CleanupStack::PushL( root );

            CMsvEntrySelection* sel=root->ChildrenWithTypeL( KUidMsvServiceEntry );

            CleanupStack::PushL( sel );

            const TMsvEntry* tentry=NULL;

            for ( TInt cc=sel->Count(); --cc>=0 && !outstanding; )

                {

                tentry=&( root->ChildDataL( ( *sel )[cc]) );

                if ( tentry->Connected() )

                    {

                    outstanding++;

                    }

                }

            CleanupStack::PopAndDestroy( 2, root ); //sel, root                

            }

        if ( outstanding > 0 )

            {

            User::After( KHotswapWaitInterval ); //wait one second

            }

        }

    CMsgOperationWait* waiter = CMsgOperationWait::NewLC();

    CMsvOperation* op = aSession.ChangeDriveL( EDriveC, waiter->iStatus );

    CleanupStack::PushL( op );

    waiter->Start();        

    CleanupStack::PopAndDestroy( 2, waiter ); //waiter, op

    }

// ----------------------------------------------------

// MsvUiServiceUtilitiesInternal::MmcDriveInfoL

// ----------------------------------------------------

EXPORT_C TBool MsvUiServiceUtilitiesInternal::MmcDriveInfoL( CMsvSession& aSession )

    {

    return aSession.MessageStoreDrivePresentL();

    }

// ---------------------------------------------------------

// MsvUiServiceUtilitiesInternal::DefaultServiceForMTML

// ---------------------------------------------------------

//

EXPORT_C TMsvId MsvUiServiceUtilitiesInternal::DefaultServiceForMTML( 

    CMsvSession& aSession, 

    TUid aMtm, 

    TBool aFindFirstServiceIfNoDefault )

    {

    FeatureManager::InitializeLibL();

    TBool selectableEmail =

        FeatureManager::FeatureSupported( KFeatureIdSelectableEmail );

    TBool emailFramework =

        FeatureManager::FeatureSupported( KFeatureIdFfEmailFramework );

    FeatureManager::UnInitializeLib();

    TMsvId serviceId = KMsvUnknownServiceIndexEntryId;

    // Default mailbox is fetched seperately by using the API provided by symbian

    // If selectableEmail feature is on, get the default email 

    // account from the central repository  

    if ( selectableEmail && !emailFramework && MuiuEmailTools::IsMailMtm( aMtm ) )

    	{

    	serviceId = MuiuEmailTools::DefaultSendingMailboxL( aSession, aMtm );

    	if ( serviceId == KMsvUnknownServiceIndexEntryId )

    		{

    		CRepository* repository = NULL;

    		TRAPD( ret, repository = CRepository::NewL(

    				                KCRUidSelectableDefaultEmailSettings ) );

    		CleanupStack::PushL( repository );

    		if ( ret == KErrNone )

    			{

    			TInt entryId;

    				if ( repository->Get( KSelectableDefaultMailAccount ,

    						              entryId ) != KErrNone )

    				{

    				serviceId = KMsvUnknownServiceIndexEntryId;    		        

    				}

    			else

    				{

    				serviceId = entryId;    

    				}    		        

    			}

    		CleanupStack::PopAndDestroy();            

    		}

    	// Bug workaround, validate that the mailbox exist

    	TMsvEntry mailbox;

    	TMsvId dummyId;

    	if ( aSession.GetEntry( serviceId, dummyId, mailbox ) != KErrNone )

    		{

    		serviceId = KMsvUnknownServiceIndexEntryId;

    		aFindFirstServiceIfNoDefault = ETrue;

    		}

    	}

    // if selectable email feature is off, Default mailbox is fetched 

    // seperately by using the API provided by symbian

    else if ( !selectableEmail && MuiuEmailTools::IsMailMtm( aMtm, ETrue ) )

    	{                

    	// Get service id, which will always be validated

    	serviceId = MuiuEmailTools::DefaultSendingMailboxL( aSession, aMtm );

    	aFindFirstServiceIfNoDefault &=             

    	( serviceId == KMsvUnknownServiceIndexEntryId );

    	}	

    // Other mtm's use this path

    else

    	{

    	CClientMtmRegistry* registry = CClientMtmRegistry::NewL( aSession );

    	CleanupStack::PushL( registry );

    	CBaseMtm* mtm = registry->NewMtmL( aMtm );

    	CleanupStack::PushL( mtm );

    	TRAPD( error, serviceId = mtm->DefaultServiceL() );

    	if( error != KErrNone )

    		{

    		serviceId = KMsvUnknownServiceIndexEntryId;

    		}

        CleanupStack::PopAndDestroy( 2 ); // registry, mtm

        registry = NULL;

        mtm = NULL;

        }    

    if ( aFindFirstServiceIfNoDefault && 

    	 serviceId == KMsvUnknownServiceIndexEntryId ) 

    	{

    	CMsvEntry* entry = aSession.GetEntryL( KMsvRootIndexEntryIdValue );

    	CleanupStack::PushL( entry );

    	CMsvEntrySelection* sel = entry->ChildrenWithMtmL( aMtm );

    	CleanupStack::PopAndDestroy( entry );

    	CleanupStack::PushL( sel );

    	entry = NULL;

    	// Check if mail mtm

    		if ( MuiuEmailTools::IsMailMtm( aMtm, ETrue ) )

    			{

    			// Mail services needs to be validated, provide the array 

    			// of services for validation

    			serviceId = MuiuEmailTools::FindFirstValidMailboxL(

    					    aSession, *sel, aMtm );

    			}

    		else

    			{

    			// Just take the first available service from the list

    			if ( sel->Count() > 0 )

    				{

    				serviceId = sel->At( 0 );

    				}            

    			}            

    		CleanupStack::PopAndDestroy( sel );

    		sel = NULL;

    		}

	return serviceId;    

    }

// ---------------------------------------------------------

// MsvUiServiceUtilitiesInternal::SetDefaultServiceForMTML

// ---------------------------------------------------------

//

EXPORT_C void MsvUiServiceUtilitiesInternal::SetDefaultServiceForMTML( 

    CMsvSession& aSession, 

    TUid aMtm, 

    TMsvId aServiceId )

    {

    FeatureManager::InitializeLibL();

    if ( MuiuEmailTools::IsMailMtm( aMtm ) )

        {

        TMsvEntry mailbox;

        TInt error = MuiuEmailTools::GetMailboxServiceId(

            aSession, mailbox, aServiceId, ETrue );

        if ( error == KErrNone )

            {            

            MuiuEmailTools::SetDefaultSendingMailboxL( 

                mailbox.Id() );

            }

        }

    else if ( FeatureManager::FeatureSupported( KFeatureIdSelectableEmail )

            && aMtm != KSenduiMtmSyncMLEmailUid )

    	{

    	TMsvEntry entry;

    	TMsvId serviceId;

    	User::LeaveIfError( aSession.GetEntry(

    			                            aServiceId, serviceId, entry ) );

    	TBool appendEmail = EFalse;						            

    	if( entry.Visible() )

    		{

    		appendEmail = ETrue;

    		}

    	else

    		{

    		CMtmUiDataRegistry* uiRegistry =