/*

* 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: 

*     Logs Application view superclass

*

*/

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logengevents.h>

#endif

#include <eikmenub.h>

#include <Pbk2UID.h>

#include <bldvariant.hrh>

#include <featmgr.h>

#include <baclipb.h>

#include <AknQueryDialog.h>

#include <aknnotewrappers.h> 

#include <StringLoader.h> 

#include <AiwCommon.hrh>                //kaiwcmdcall

#include <AiwContactSelectionDataTypes.h>

#include <AiwContactAssignDataTypes.h>

#ifdef __OMA_POC

#include <pocuiintegrationservices.h>   //cpocuiintegrationservices 

#endif

#include <commonphoneparser.h>

#include <CMessageData.h>

#include <sendui.h> 

#include <SendUiConsts.h>

#include <TSendingCapabilities.h>

#include <aknbutton.h>

#include <AknsUtils.h>

#include <logs.mbg>     // logs own icons

#include <LogsApiConsts.h>      //additional event uids

#include <CPhCltEmergencyCall.h>

#include <Logs.rsg>

#include "LogsIcons.hrh"

#include "LogsConsts.h"

#include "LogsConstants.hrh"

#include "LogsUID.h"

#include "CLogsBaseView.h"

#include "CLogsAppUi.h"

#include "CLogsEngine.h"

#include "CLogsCntLinkChecker.h"

#include "CLogsReaderConfigFactory.h"

#include "MLogsReader.h"

#include "MLogsEventGetter.h"

#include "MLogsSharedData.h"

#include "MLogsSystemAgent.h"   

#include "CLogsTimer.h"

#include "aiwdialdataext.h"

#include "CPhoneNumberFormat.h"

#include "LogsDebug.h"

#include "LogsTraces.h"

#include "CLogsPrependQuery.h"    

// service table

#include <spsettings.h>

#include <spentry.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================

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

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

// CLogsBaseView::LogsAppUi

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

//

CLogsAppUi* CLogsBaseView::LogsAppUi()

    {

    return static_cast<CLogsAppUi*>( CAknView::AppUi() );

    }

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

// CLogsBaseView::~CLogsBaseView

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

//

CLogsBaseView::~CLogsBaseView()

    {

    delete iSendUiText;

    delete iAddress;    

    delete iConstructDelayed;

    delete iNumberInPbkProcessing;

    delete iUriInPbkProcessing;    

    delete iLogsTimer;    

    delete iEmergencyCallAPI;

    RemoveInputBlocker();

    }

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

// CLogsBaseView::CLogsBaseView

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

//

CLogsBaseView::CLogsBaseView() : 

    iConstructDelayedOk( EFalse ),

    iSendUiText( NULL ),

    iFocusChangeControl( ELogsOkToChange ),     

    iEventListCurrent( 0 ),

    iEventListTop( 0 ),

    iRefreshMenuOnUpdate( EFalse ),

    iMenuType(CEikMenuBar::EMenuOptions),

    iInputBlocker(NULL),

    iIsCheckedCntLinkInvaild( EFalse),  

	iResetAndRefreshOnHandleNotify(MLogsModel::ERefresh),

	iIgnoreViewDeactivatedHandling(EFalse),

	iSemiFinishViewDeactivatedOperation(EFalse)

    {

    //Construct CIdle object call back to finalise time consuming construction

    iConstructDelayed = CIdle::New( CActive::EPriorityIdle );

    if( iConstructDelayed )

        {

        //The below seems to slow down reading of Logs entries from db so we're

        //not calling it from here

        //iConstructDelayed->Start( TCallBack( ConstructDelayedCallbackL, this) );            

        }

    }

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

// CLogsBaseView::BaseConstructL

//

// This is just a hook to catch BaseConstructL calls from derived classes before/

// after call to super class's BaseConstructL if needed.

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

//

void CLogsBaseView::BaseConstructL(TInt aResId )

    {

    CAknView::BaseConstructL( aResId );

    if( AknLayoutUtils::PenEnabled() && Toolbar() ) 

        {

        //By default keep toolbar invisible        

        ShowToolbarOnViewActivation( EFalse ); 

        Toolbar()->SetToolbarObserver( this );

        } 

    }

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

// CLogsBaseView::Engine

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

//

CLogsEngine* CLogsBaseView::Engine()

    {

    return LogsAppUi()->Engine();

    }

// Safwish VoIP changes  >>>

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

// CLogsBaseView::SendUiTextL

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

//

const TDesC& CLogsBaseView::SendUiTextL()

    {

    if ( !iSendUiText )

        {

        iSendUiText =  iCoeEnv->AllocReadResourceL( R_STM_WRITE_MSG );

        }    

    return *iSendUiText;

    }

// <<< Safwish VoIP changes  

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

// CLogsBaseView::ConstructDelayedL

//

// Perform time consuming construction operations once. Calling this is needed 

// before e.g. pressing Send key or launching a command from ui's menu.

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

//

void CLogsBaseView::ConstructDelayedL( TBool aIdle )  //EFalse: immediately

    {                                                 //ETrue:  using idle time

    if( iConstructDelayed && aIdle && !iConstructDelayed->IsActive() )     

        {

        iConstructDelayed->Start( TCallBack( ConstructDelayedCallbackL, this) );            

        }

    else

        {

        DoConstructDelayedL();            

        }        

    }

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

// CLogsBaseView::ConstructDelayedCallbackL

//

// Called from CIdle once to finish time consuming construction operations

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

//

TInt CLogsBaseView::ConstructDelayedCallbackL( TAny* aContainer )

    {

    CLogsBaseView* container = static_cast<CLogsBaseView*>( aContainer );

    container->DoConstructDelayedL();    

    return 0;

    }

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

// CLogsBaseView::DoConstructDelayedL

//

// Perform time consuming construction operations once. 

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

//

void CLogsBaseView::DoConstructDelayedL()

    {

    TRACE_ENTRY_POINT;

    if( iConstructDelayed ) 

        {

        iConstructDelayed->Cancel();

        delete iConstructDelayed;

        iConstructDelayed = NULL;

        }

    if( iConstructDelayedOk ) 

        {

        return;    

        }

    iConstructDelayedOk = ETrue;

    iServHandlerRef = LogsAppUi()->CallUiL();  //ownership remains in LogsAppUi,

                                               //this takes a lot of time.

    if ( !iSendUiText )

        {

        iSendUiText = iCoeEnv->AllocReadResourceL( R_STM_WRITE_MSG );

        }

    iAddress = iCoeEnv->AllocReadResourceL(R_LOGS_ADDR_PROMPT);    

    iLogsTimer = CLogsTimer::NewL( CActive::EPriorityUserInput ); //EPriorityStandard  EPriorityHigh

    iEmergencyCallAPI = CPhCltEmergencyCall::NewL( this );

    TRACE_EXIT_POINT

    }

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

// CLogsBaseView::HandleLogsTimerL

//

// Callback function for iLogsTimer 

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

//

void CLogsBaseView::HandleLogsTimerL( TAny* /* aPtr */ )

    {

    HandleCommandL( ELogsCmdLongSendKeyCall );

    }

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

// CLogsBaseView::LaunchPopupMenuL

//

// Launch a popup menu when ok-button has been pressed

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

//

void CLogsBaseView::LaunchPopupMenuL( TInt aResourceId )

    {

    SetCurrentMenuType(CEikMenuBar::EMenuContext);

    TRAPD( err, DoLaunchPopupL( aResourceId ) );

    if( err )

        {

        SetCurrentMenuType(CEikMenuBar::EMenuOptions);

        User::Leave( err );

        }

    SetCurrentMenuType(CEikMenuBar::EMenuOptions);

    }

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

// CLogsBaseView::DoLaunchPopupL

//

// Performs the popup menu launching

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

//

void CLogsBaseView::DoLaunchPopupL( TInt aResourceId )

    {

    MenuBar()->SetContextMenuTitleResourceId( aResourceId );    

    MenuBar()->TryDisplayContextMenuBarL(); //TryDisplayContextMenuBarL() does not provide "Act 

                                            //apps" selection as TryDisplayMenuBarL() would.

    }

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

// CLogsBaseView::FindXSPServiceSettingsLC

// Checks for stored settings for the logged service id. Returns a pointer to the 

// found service table entry or NULL. If a NULL pointer is returned, the object is 

// not pushed to the CleanupStack.

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

//

CSPEntry* CLogsBaseView::FindXSPServiceSettingsLC(const MLogsEventGetter* aEvent)

    {

    CSPEntry* entry = NULL;

    // check only if the service id and sip uri stored.

    if (aEvent->LogsEventData()->ServiceId() && SipUriAvailable( aEvent ) )

        {

        TInt err = KErrNotFound;

        entry = CSPEntry::NewLC();      

        CSPSettings* settings = CSPSettings::NewL();

        CleanupStack::PushL(settings);

        err = settings->FindEntryL( aEvent->LogsEventData()->ServiceId(), *entry );  

        CleanupStack::PopAndDestroy( settings ); 

        if (err != KErrNone)

            {

            CleanupStack::PopAndDestroy( entry ); 

            entry = NULL;

            }   

        }

    return entry;

    }

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

// CLogsBaseView::CmdSaveToVirtualPhonebookL

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

//

void CLogsBaseView::CmdSaveToVirtualPhonebookL( 

    TInt aCommandId, 

    TBool aCalledForMenu,

    const MLogsEventGetter* aEvent )    

    {

    TRACE_ENTRY_POINT;

    using namespace AiwContactAssign;        

    CAiwGenericParamList& inParamList = iServHandlerRef->InParamListL();    

    TUint assignFlags = NULL;

    if( !aCalledForMenu )

        {

        assignFlags = AiwContactAssign::ECreateNewContact;

        }

    inParamList.AppendL(

        TAiwGenericParam(

            EGenericParamContactAssignData,     //AiwGenericParam.hrh

            TAiwVariant(TAiwSingleContactAssignDataV1Pckg( 

                TAiwSingleContactAssignDataV1().SetFlags(assignFlags)))));                    

//           TAiwVariant(TAiwContactAttributeAssignDataV1Pckg( 

//               TAiwContactAttributeAssignDataV1().SetFlags(assignFlags)))));

// the above commented code also provides just one field to add to phonenbook so we must 

// select between msisdn and uri in code below.

    // Check first if there is a service id logged and there are settigs configured.

    // If valid settings found for the logged service id, store to contacts as an xsp id

    //   

    CSPEntry* entry = FindXSPServiceSettingsLC(aEvent);

    if (entry)

        {    

        TBuf<KLogsSipUriMaxLen> xspuserid;

        if ( Engine()->ConvertToUnicode( aEvent->LogsEventData()->Url(), xspuserid ))

            {

            return; //Converting uri to unicode failed

            }

        else 

            {     

            _LIT(KLogsColon, ":");

            HBufC* xspid = HBufC::NewLC(

                    xspuserid.Length() + 

                    entry->GetServiceName().Length() + 

                    KLogsColon().Length() );

            xspid->Des().Append( entry->GetServiceName() );        

            xspid->Des().Append( KLogsColon );

            xspid->Des().Append( xspuserid );                                   

            inParamList.AppendL( 

                TAiwGenericParam(

                        EGenericParamXSpId,

                        TAiwVariant(  xspid->Des() )

                ));         

            CleanupStack::PopAndDestroy( xspid ); 

            CleanupStack::PopAndDestroy( entry );

            }

        }

    //

    // If service id not found or no valid settings, store as a sip uir or phonenumber

    //

    else if( SipUriAvailable( aEvent ) )

        {

        //inParamList allocates it's own buffer, so it's safe to hand over buf 

        TBuf<KLogsSipUriMaxLen> buf; 

        if ( Engine()->ConvertToUnicode( aEvent->LogsEventData()->Url(), buf ) )

            {

            return; //Converting uri to unicode failed

            }

        else

            {

            inParamList.AppendL(

                TAiwGenericParam(

                    EGenericParamSIPAddress,

                    TAiwVariant( buf )

                    ));        

            }

        }    

    else if( PhoneNumberAvailable( aEvent ) )

        {

        inParamList.AppendL(

            TAiwGenericParam(

                EGenericParamPhoneNumber,

                TAiwVariant( aEvent->Number() )

                ));

        }

    else

        {

        return; //Nothing to store

        }

    delete iNumberInPbkProcessing;

    delete iUriInPbkProcessing;    

    iNumberInPbkProcessing = NULL;

    iUriInPbkProcessing = NULL;    

    //2. If sip uri available, we prefer it over phone number (PoC or VoIP)

    if( SipUriAvailable( aEvent ))    

        {

        TBuf<KLogsSipUriMaxLen> buf; 

        // Returns KErrNone if everythin ok

        if ( !(Engine()->ConvertToUnicode( aEvent->LogsEventData()->Url(), buf )) ) 

            {

            iUriInPbkProcessing = buf.AllocL();

            }

        }

    else if( PhoneNumberAvailable( aEvent ))    

        {

        iNumberInPbkProcessing = aEvent->Number()->AllocL();        

        }

    //Add to Phonebook    will call CPbk2AiwAssignProvider::HandleServiceCmdL    

    if ( !aCalledForMenu )    

        {

        iServHandlerRef->ExecuteServiceCmdL(

            aCommandId,

            inParamList,

            iServHandlerRef->OutParamListL(),

            0,

            this );//HandleNotifyL

        }

    else

        {

        iServHandlerRef->ExecuteMenuCmdL(

            aCommandId,

            inParamList,

            iServHandlerRef->OutParamListL(),

            0,

            this );//HandleNotifyL

        }

    // Store AiW call parameters so that we can cancel the call later if needed. 

    SaveAiwCallParamsL(aCommandId, aCalledForMenu, &inParamList);

    // Set input blocker cause we don't want to have the user open menus etc

    // while opening phonebook

    SetInputBlockerL();

    TRACE_EXIT_POINT;    

    }

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

// CLogsBaseView::SaveAiwCallParamsL

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

//

void CLogsBaseView::SaveAiwCallParamsL( TInt aCommandId,

                                        TBool  aCalledForMenu,

                                        CAiwGenericParamList*  aInParamList ) 

    { 

    iAiwCommandId = aCommandId;

    iAiwCalledFromMenu = aCalledForMenu;

    iAiwInParamList = aInParamList;

    // To detect and cancel the aiw call early enough, we will need to observe view activation

    LogsAppUi()->AddViewActivationObserverL(this);

    }

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

// CLogsBaseView::ClearAiwCallParams

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

//

void CLogsBaseView::ClearAiwCallParams()

    {

    iAiwCommandId = KErrNotFound;

    iAiwCalledFromMenu = EFalse;

    iAiwInParamList = NULL;

    // No need to observe view activation anymore. 

    LogsAppUi()->RemoveViewActivationObserver(this);

    }

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

// CLogsBaseView::CancelSaveToPbkL

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

//

void CLogsBaseView::CancelSaveToPbkL()

    {