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




// INCLUDE FILES
#include <e32base.h>
#include <e32test.h>
#include <eikenv.h>
#include <eikappui.h>
#include <msvapi.h>
#include <msvuids.h>
#include <mtmuibas.h>
#include <mtuireg.h>
#include <mtudcbas.h>
#include <bautils.h>
#include <mtmuidef.hrh>
#include <eikdialg.h>
#include <featmgr.h>

#include "init.h"

// CONSTANTS
const TInt KUidMsgTypeSMSValue  = 0x1000102C;
const TUid KUidMsgTypeSMSUid   = {KUidMsgTypeSMSValue}; 
const TInt KUidMsgTypeMMSValue  = 0x100058E1;
const TUid KUidMsgTypeMMSUid   = {KUidMsgTypeMMSValue}; 
const TInt KUidMsgTypePocaValue = 0x10207245;
const TUid KUidMsgTypePocaUid   = {KUidMsgTypePocaValue};
const TInt KUidMsgTypeAMSValue  = 0x1020745B;
const TUid KUidMsgTypeAMSUid    = {KUidMsgTypeAMSValue};
const TInt KMailInitPanicStringLength = 15;

_LIT(KInitSpaceBuffer, " ");
_LIT(KInitColon, " ");
_LIT(KThread,   "MTMInit");
_LIT(KPanic,    "MTMInit");
#ifdef __WINS__
_LIT(KDllName,"\\system\\programs\\mailinit.dll");
#endif
#ifdef __EPOC32__
_LIT(KProcess,  "MTMInit");
#endif
#ifdef _DEBUG
const TInt KInitErrorMaxTextLength=80;
#endif

const TInt KMailInitRetryCounter = 10;
const TInt KMailInitRetryTimeout = 2000000; // two seconds

#ifdef __MARM__
//  To stop warnings of missing .def file for a EXEDLL compilation
//  under MARM (as suggested by Alistair Bradley)
//
EXPORT_C void Dummy() {};
#endif



/**
*  CDummyObserver 
*  This is just a temporary MMsvSessionObserver during the mail init
*/
class CDummyObserver : public CBase, public MMsvSessionObserver
    {
    public:
        CDummyObserver() {};
        void HandleSessionEventL(
            TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/) {};
    };

// ----------------------------------------------------
// DeleteStoreInitFlagFileL
// ----------------------------------------------------
void DeleteStoreInitFlagFileL()
    {
    }

// ----------------------------------------------------
// DoInitialiseSingleMtmL
// ----------------------------------------------------
LOCAL_C void DoInitialiseSingleMtmL(CClientMtmRegistry& aBaseReg, CMtmUiRegistry& aUiReg, const TUid& anId)
    {
    INITLOGGER_WRITE_FORMAT2( "DoInitialiseSingleMtmL() - mtm uid: %d 0x%x", anId.iUid, anId.iUid);

    INITLOGGER("DoInitialiseSingleMtmL() - Creating BaseMtm");
    //create base mtm
    CBaseMtm* baseMtm=aBaseReg.NewMtmL(anId);
    CleanupStack::PushL(baseMtm);
    
    INITLOGGER("DoInitialiseSingleMtmL() - Creating Mtm UI");
    CBaseMtmUi* mtmUi=aUiReg.NewMtmUiL(*baseMtm);
    CleanupStack::PushL(mtmUi);

    TInt response;
    TUid isInstalled={KUidMsvMtmUiQueryMessagingInitialisation};
    TInt err=mtmUi->QueryCapability(isInstalled, response);

    if (err==KErrNone)
        {
        INITLOGGER("DoInitialiseSingleMtmL() - Invoking initialisation method");
        // Need to install this type
        CMsvEntrySelection* tempobject = new (ELeave) CMsvEntrySelection;
        CleanupStack::PushL(tempobject);
        TBuf8<1> tempdes;
        TInt installNow={KMtmUiMessagingInitialisation};    
        mtmUi->InvokeSyncFunctionL(installNow,*tempobject,tempdes);
        CleanupStack::PopAndDestroy( tempobject );
        }
    else if (err!=KErrNotSupported)
        {
        User::Leave(err);
        }

    CleanupStack::PopAndDestroy( 2, baseMtm ); // mtmUi,baseMtm
    INITLOGGER("DoInitialiseSingleMtmL() - Complete");
    }

// ----------------------------------------------------------------------------
// GetMtmName()
// ----------------------------------------------------------------------------
//
LOCAL_C void GetMtmName( 
    TBuf<KMaxKernelName>& aMtmName, 
    const TUid& aUid,
    const CMtmUiRegistry& aUiRegistry )
    {    
    aMtmName = aUiRegistry.RegisteredMtmDllInfo(
        aUid ).HumanReadableName().Left( KMailInitPanicStringLength - 1 ); 
    }
    
// ----------------------------------------------------------------------------
// AppendPanicString()
// ----------------------------------------------------------------------------
//
LOCAL_C void AppendPanicString( 
    TBuf<KMaxKernelName>& aPanicString, 
    const TUid& aUid,
    const CMtmUiRegistry& aUiRegistry )
    {    
    // Make sure the new length fits to total name
    if ( aPanicString.Length() < KMaxKernelName - KMailInitPanicStringLength )
        {
        GetMtmName( aPanicString, aUid, aUiRegistry );
        aPanicString.Append( aPanicString );
        aPanicString.Append( KInitSpaceBuffer );
        }
    }
    
// ----------------------------------------------------
// DoInitialiseMtmsL
// ----------------------------------------------------
#ifdef _DEBUG
LOCAL_C void DoInitialiseMtmsL( TDes& aMtmBuffer )
#else
LOCAL_C void DoInitialiseMtmsL( )
#endif
    {
    TBuf<KMaxKernelName> panicString;
    panicString.Copy( KThread );
    panicString.Append( KInitColon );
    
    INITLOGGER("DoInitialiseMtmsL()");
    // connect to the server
    CDummyObserver* ob = new(ELeave)CDummyObserver;
    CleanupStack::PushL(ob);

    INITLOGGER("DoInitialiseMtmsL() : Creating CMsvSession");
    TInt error = KErrNone;
    TInt counter = KMailInitRetryCounter;
    CMsvSession* session = NULL;
    TRAP( error, session = CMsvSession::OpenSyncL(*ob) );
    while ( counter > 0 && error != KErrNone )
        {
        INITLOGGER("DoInitialiseMtmsL() : Creating CMsvSession failed, wait and try again");
        counter--;
        User::After( KMailInitRetryTimeout );
        TRAP( error, session = CMsvSession::OpenSyncL(*ob) );
        }
    if ( error != KErrNone || session == NULL )
        {
        INITLOGGER("DoInitialiseMtmsL() : Creating CMsvSession failed, leave now");
        User::Leave( error != KErrNone ? error : KErrNotFound );
        }
    CleanupStack::PushL(session);
    
    //create ui registry
    INITLOGGER("DoInitialiseMtmsL() : Creating Registries");
    CClientMtmRegistry* basemtmregistry=CClientMtmRegistry::NewL(*session);
    CleanupStack::PushL(basemtmregistry);
    CMtmUiRegistry* uiRegistry=CMtmUiRegistry::NewL(*session);
    CleanupStack::PushL(uiRegistry);

    //check through mtms
    TInt ret = 0;

    // try to initialise SMS first
    INITLOGGER( "-----------------------< Start INIT: SMS >-----------------------" );
    if ( uiRegistry->IsPresent( KUidMsgTypeSMSUid ) )
        {
        TRAP(ret, DoInitialiseSingleMtmL(*basemtmregistry, *uiRegistry, KUidMsgTypeSMSUid));
        }
#ifdef _DEBUG
    else
        {
        INITLOGGER("DoInitialiseMtmsL() - SMS Not present, this might be ok?");
        }
#endif

    if (ret)
        {
        error = ret;
        ret = 0;
        
        // Track SMS, which can't fail of course
        AppendPanicString( panicString, KUidMsgTypeSMSUid, *uiRegistry );
        
#ifdef _DEBUG
        INITLOGGER_WRITE_FORMAT( "***** !!! SMS INIT FAILED (%d) !!! *****", error );  
        aMtmBuffer.Append( KInitSpaceBuffer );
        aMtmBuffer.AppendNum( KUidMsgTypeSMSValue );
#endif
        }
    INITLOGGER( "------------------------< End INIT: SMS >------------------------" );        
        
    INITLOGGER( "-----------------------< Start INIT: MMS >-----------------------" );    
    // then try to initialise MMS 
    if ( uiRegistry->IsPresent( KUidMsgTypeMMSUid ) )
        {
        TRAP(ret, DoInitialiseSingleMtmL(*basemtmregistry, *uiRegistry, KUidMsgTypeMMSUid ));
        }
#ifdef _DEBUG
    else
        {
        INITLOGGER("DoInitialiseMtmsL() - MMS Not present, this might be ok?");
        }
#endif

    if (ret)
        {         
        // Track MMS
        AppendPanicString( panicString, KUidMsgTypeMMSUid, *uiRegistry );

        error = ret;
        ret = 0;       
        
#ifdef _DEBUG
        INITLOGGER_WRITE_FORMAT( "***** !!! MMS INIT FAILED (%d) !!! *****", error );  
        aMtmBuffer.Append( KInitSpaceBuffer );
        aMtmBuffer.AppendNum( KUidMsgTypeMMSValue );
#endif
        }

    INITLOGGER( "------------------------< End INIT: MMS >------------------------" );

    //now check through the other mtms
#ifdef _DEBUG    
    TBuf<KMaxKernelName> debugString;
#endif // _DEBUG    
    TInt count=uiRegistry->NumRegisteredMtmDlls();
    for (TInt cc=0; cc<count; ++cc)
        {
        TUid uid=uiRegistry->MtmTypeUid(cc);
        
        INITLOGGER_WRITE_FORMAT( "-------------------< Start INIT: 0x%x >------------------", uid.iUid );
#ifdef _DEBUG
        debugString.Zero();
        GetMtmName( debugString, uid, *uiRegistry );
        debugString.Append( '\0' );
        INITLOGGER_WRITE_FORMAT2( "0x%x: %s", uid.iUid, debugString.Ptr() );
#endif // _DEBUG
        
        TBool initialise = ETrue;
        // Postcard or Audio messaging MTMs can be variated by runtime, so depending
        // on the flags they might not be initialized at all.
        if( uid == KUidMsgTypePocaUid || uid == KUidMsgTypeAMSUid)
            {
            TInt flag = -1;
            if ( uid == KUidMsgTypePocaUid )
                {
                flag = KFeatureIdMmsPostcard;
                }
            else if ( uid == KUidMsgTypeAMSUid )
                {
                flag = KFeatureIdAudioMessaging;
                }
            FeatureManager::InitializeLibL();
            if ( flag != -1 )
                {
                if ( !FeatureManager::FeatureSupported( flag ) )
                    {
                    INITLOGGER( "* Feature NOT supported *" );
                    initialise = EFalse;
                    }
                }
            FeatureManager::UnInitializeLib();
            }

        if (uid.iUid == KUidMsgTypeSMSValue || uid.iUid == KUidMsgTypeMMSValue )
            {
            INITLOGGER( "* Already Initialized *" );
            initialise = EFalse;
            }


        if ( initialise )        
            {
            // return value is ignored, so as not to prevent other MTMs being initialised
            TRAP(ret, DoInitialiseSingleMtmL(*basemtmregistry, *uiRegistry, uid));
            if (ret)
                {
                     
                // Track Other Uids
                AppendPanicString( panicString, uid, *uiRegistry );

                error=ret;
#ifdef _DEBUG
                INITLOGGER_WRITE_FORMAT( "***** !!! INIT FAILED (%d) !!! *****", error );            
                aMtmBuffer.Append( KInitSpaceBuffer );
                aMtmBuffer.AppendNum( (TInt)uid.iUid );
#endif
                }
                
            INITLOGGER_WRITE_FORMAT( "--------------------< End INIT: 0x%x >-------------------", uid.iUid );    
            }
#ifdef _DEBUG
        else
            {
            INITLOGGER_WRITE_FORMAT( "--------------------< End INIT: NOT done for 0x%x, see reason above >-------------------", uid.iUid );
            }
#endif
        }
    
    if (error)
        {
        INITLOGGER_WRITE_FORMAT( "DoInitialiseMtmsL() - %S", &panicString );
        INITLOGGER_WRITE_FORMAT( "DoInitialiseMtmsL() - Leave error %d", error);

        User::RenameThread( panicString );
        Panic( EMailInitisationFailed );
        }

    CleanupStack::PopAndDestroy(4); // uiRegistry,basemtmregistry,session,ob
    }


// ----------------------------------------------------
// CMailInitAppUi::~CMailInitAppUi
// ----------------------------------------------------
CMailInitAppUi::~CMailInitAppUi()
    {
    }


// ----------------------------------------------------
// CMailInitAppUi::ConstructL
// ----------------------------------------------------
void CMailInitAppUi::ConstructL()
    {
    CEikAppUi::BaseConstructL(ENonStandardResourceFile|ENoScreenFurniture);
    }



// ----------------------------------------------------
// CMailInitServerEnv::DestroyEnvironment
// ----------------------------------------------------
void CMailInitServerEnv::DestroyEnvironment()
    {
    CEikonEnv::DestroyEnvironment();
    }

// ----------------------------------------------------
// CMailInitServerEnv::ConstructL
// ----------------------------------------------------
void CMailInitServerEnv::ConstructL()
    {
    CEikonEnv::ConstructL( EFalse );
    SetAutoForwarding( ETrue );
    }

// ----------------------------------------------------
// DoWork
// ----------------------------------------------------
LOCAL_C void DoWork()
    {
    INITLOGGER("DoWork()");

#ifndef _DEBUG
    TRAPD(leave, DoInitialiseMtmsL());
    if(leave == KErrNone)
        {
        // Delete flag file if present.
        TRAP_IGNORE(DeleteStoreInitFlagFileL());
        }
#else
    TBuf<2*KInitErrorMaxTextLength> errorBuffer;
    TRAPD(leave, DoInitialiseMtmsL( errorBuffer ));
    if(leave == KErrNone)
        {
        // Delete flag file if present.
        TRAP_IGNORE(DeleteStoreInitFlagFileL());
        return;
        }

#endif // _DEBUG
    }


// ----------------------------------------------------
// StartFunction
// ----------------------------------------------------
GLDEF_C TInt StartFunction()
    {
    INITLOGGER("StartFunction()");
#ifdef __EPOC32__
    // Rename our process (on h/w only).
    User::RenameProcess( KProcess );
#endif
    // Rename our thread.
    //User::RenameThread
    User::RenameThread( KThread );

    INITLOGGER("StartFunction(): Constructing Env and AppUi");
    CMailInitServerEnv* dialogEnv = new CMailInitServerEnv;
    __ASSERT_ALWAYS(dialogEnv!=NULL, Panic(EMailInitPanicStartAllocEnv));
    CMailInitAppUi* dialogAppUi = new CMailInitAppUi;
    __ASSERT_ALWAYS(dialogAppUi!=NULL, Panic(EMailInitPanicStartAllocAppUi));

    TRAPD(leave,{dialogEnv->ConstructL(); dialogAppUi->ConstructL();});
    __ASSERT_ALWAYS(leave==KErrNone, Panic(EMailInitPanicStartConstructL));

    dialogEnv->DisableExitChecks(ETrue);

    CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack
    __ASSERT_ALWAYS(cleanup!=NULL, Panic(EMailInitPanicStartAllocCleanupStack));
    DoWork();
    delete cleanup; // destroy clean-up stack
    
    // finished
    dialogAppUi->PrepareToExit();

    dialogEnv->DestroyEnvironment();

    return KErrNone;
    }

// ----------------------------------------------------
// WinsMain
// ----------------------------------------------------
#ifdef __WINS__
EXPORT_C TInt WinsMain(TAny* /*aParam*/)
    {
	  return KErrNone;
    }
#endif

// ----------------------------------------------------
// E32Main
// ----------------------------------------------------
GLDEF_C TInt E32Main()
    {
    return StartFunction();
    }

// ----------------------------------------------------
// Panic
// ----------------------------------------------------
GLDEF_C void Panic(TMailInitPanic aPanic) // called if the server fails to be created
    {
    User::Panic(KPanic, aPanic);
    }


// ----------------------------------------------------
// E32Dll
// ----------------------------------------------------
#ifdef __WINS__
GLDEF_C TInt E32Dll(TInt /*aReason*/)
    {
    return KErrNone;
    }
#endif

// End of file