/*

* Copyright (c) 2004-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:   base class for mms operations

*

*/

// INCLUDE FILES

#include    <msventry.h>

#include    <logcli.h>

#include    <logview.h>

// socket error when switching to offline mode

#include    <es_sock.h>

// Internet error when switching to offline mode

#include    <inet6err.h>

#include    <CoreApplicationUIsSDKCRKeys.h>

#include    <e32property.h> // PubSub

#include    <connect/sbdefs.h>

#include    <apgcli.h>  // RApaLsSession

#include    <fileprotectionresolver.h>

#include    <mmsvattachmentmanager.h>

#include    "mmsbaseoperation.h"

#include    "mmsservercommon.h"

#include    "mmserrors.h"

#include    "mmssettings.h"

#include    "mmsserverentry.h"

#include    "mmssession.h"

#include    "mmsheaders.h"

#include    "mmsdecode.h"

#include    "mmsencode.h"

#include    "mmsscheduledentry.h"

#include    "mmslog.h"

#include    "mmsconninit.h"

#include    "MmsServerDebugLogging.h"

#include    "MmsPhoneClient.H"

#include    "mmscodecdatasupplier.h"

#include    "mmscodecdatasink.h"

#include 	"mmsregisteredapplications.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TInt KMmsBackupWait = 300000000; // wait for 5min, no more

const TInt KMmsServerReadyWait = 5000000; // wait for 5 sec for server ready after backup end

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CMmsBaseOperation::CMmsBaseOperation

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMmsBaseOperation::CMmsBaseOperation( RFs& aFs ):CMsgActive( KMmsActiveObjectPriority ),

iFs( aFs )

    {

    // As this class is derived from CBase, all uninitialized variables are set to 0.

    }

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

// CMmsBaseOperation::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMmsBaseOperation::ConstructL( CMmsSettings* aMmsSettings )

    {

    // Default critical state

    // If nothing is stored, operations just fall through, and there is no error

    iCriticalState = EMmsOperationEncodingPDU;

    iMmsSettings = aMmsSettings;

    // connect to socket to keep connection open as long as we need it

    TInt error = KErrNone;

    error = iSocketServ.Connect();

#ifndef _NO_MMSS_LOGGING_

    if ( error != KErrNone )

        {

        TMmsLogger::Log( _L("BaseOperation: Connect Socket server returned error %d"), error );

        }

#endif

    User::LeaveIfError( error );

    error = iConnection.Open( iSocketServ );

#ifndef _NO_MMSS_LOGGING_

    if ( error != KErrNone )

        {

        TMmsLogger::Log( _L("BaseOperation: RConnection::Open returned error %d"), error );

        }

#endif

    User::LeaveIfError( error );

    iFailed = new( ELeave ) CMsvEntrySelection;

    iSuccessful = new( ELeave ) CMsvEntrySelection;

    iResponse = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );

    iEncoder = CMmsEncode::NewL( iFs );

    iDecoder = CMmsDecode::NewL( iFs );

    // expand size is arbitrary. It is not used, we

    // always allocate the amount we need

    iEncodeBuffer = CBufFlat::NewL( 0x100 );

	// coverity[size_error][buffer_alloc]

    iMmsSession = CMmsSession::NewL( KMmsActiveObjectPriority, iSocketServ, iConnection );

    iRemoteParties = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

    // observe backup/restore event ends

    iBackupStart = EFalse;

    iBackupEnd = EFalse;

    }

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

// CMmsBaseOperation::NewL

// Two-phased constructor.

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

//

CMmsBaseOperation* CMmsBaseOperation::NewL( RFs& aFs, CMmsSettings* aMmsSettings )

    {

    CMmsBaseOperation* self = new( ELeave ) CMmsBaseOperation( aFs );

    CleanupStack::PushL( self );

    self->ConstructL( aMmsSettings );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CMmsBaseOperation::~CMmsBaseOperation()

    {

    // derived class must cancel.

	Cancel();		// framework requirement

    // iSelection, iServerEntry, and iMmsSettings

    // are not deleted, because they belong to caller

// start of ROAMING CHECK handling

    delete iPhone;

// end ROAMING CHECK handling

    if ( iRemoteParties )

        {

        iRemoteParties->Reset();

        }

    delete iRemoteParties;

    delete iEncodeBuffer;

    delete iFailed;

    delete iSuccessful;

    delete iEntryWrapper;

    delete iUri;

    delete iResponse;

    delete iEncoder;

    delete iDecoder;

    delete iMmsLog;

    delete iLogEvent;

    delete iLogViewEvent;

    delete iLogClient;

    delete iMmsSession;

    // connection initiator should be NULL already...

    delete iConnectionInitiator;

    delete iIAPArray;

    iConnection.Close();

    iSocketServ.Close();

    }

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

// CMmsBaseOperation::NetworkOperationsAllowed()

//

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

//

TBool CMmsBaseOperation::NetworkOperationsAllowed()

    {

    TBool networkAllowed = ETrue; // optimist

    // If there is no such key, we will continue normally.

    // This means that in a system where online/offline mode switching

    // is not supported, we behave as we were always online

    CRepository* repository = NULL;

    TInt error = KErrNone;

    TInt value = ECoreAppUIsNetworkConnectionAllowed;

    TRAP( error, repository = CRepository::NewL( KCRUidCoreApplicationUIs ) );

    if( error == KErrNone )

        {

        repository->Get( KCoreAppUIsNetworkConnectionAllowed, value );

        delete repository;

        repository = NULL;

        if ( value == ECoreAppUIsNetworkConnectionNotAllowed )

            {

            networkAllowed = EFalse;

            }

        }

    return networkAllowed;

    }

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

// CMmsBaseOperation::AllocateTID

//

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

//

TInt64 CMmsBaseOperation::AllocateTID()

    {

    TTime currentTime;

    currentTime.UniversalTime();

    return currentTime.Int64();

    }

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

// CMmsBaseOperation::StartL

//

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

//

void CMmsBaseOperation::StartL(

    CMsvEntrySelection& aSelection,

    CMsvServerEntry& aServerEntry,

    TMsvId aService,

    TRequestStatus& aStatus )

    {

#ifndef _NO_MMSS_LOGGING_

    TMmsLogger::Log( _L("BaseOperation starting"));

#endif

    InitializeL( aSelection, aServerEntry, aService );

    if ( iCurrentMessageNo < 1 )

        {

        // nothing to send. Give up immediately

        aStatus = KRequestPending;

        TRequestStatus* status = &aStatus;

        User::RequestComplete( status, KErrNotFound );

        return;

        }

    // The first thing to do is to encode the first message.

    // We don't start connecting before we have something to send

    // We want to minimize the connection time in order to minimize

    // the probability of the connection being broken.

    // In the connect routine we must check that the connection

    // exists, and open it if it doesn't

    // the last call in derived class StartL before SetActive() must be Queue.

    // This will store the caller's status and set it to "request pending" state

    Queue( aStatus );

    FallThrough();

    }

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

// CMmsBaseOperation::ContainsClosedContent

//

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

//

TInt CMmsBaseOperation::CheckClosedContentL( CMsvServerEntry& aServerEntry, RFs& aFs )

    {

    RApaLsSession apaLsSession;

    TInt err = apaLsSession.Connect();

    if ( err != KErrNone )

        {

        return err;

        }

    CleanupClosePushL( apaLsSession );

    CFileProtectionResolver* fileProt = CFileProtectionResolver::NewLC( aFs );

    TDataRecognitionResult* dataType = new( ELeave )TDataRecognitionResult;

    CleanupStack::PushL( dataType );

    CMsvStore* store = aServerEntry.ReadStoreL();

    CleanupStack::PushL( store );

    MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

    TInt attaCount = attachMan.AttachmentCount();

    TInt i = 0;

    // we check all attachments, but if we find even one forbidden type, we give up.

    for ( i = 0; i < attaCount && err == KErrNone; i++ )

        {

       	CMsvAttachment* attaInfo =  attachMan.GetAttachmentInfoL( i );

        RFile file;

        err = file.Open( aFs, attaInfo->FilePath(), EFileRead|EFileShareReadersOnly );

        delete attaInfo;

        attaInfo = NULL;

        if ( err == KErrNone )

            {

            // We continue only if we managed to open the file successfully    

            CleanupClosePushL( file );

            err = apaLsSession.RecognizeData( file, *dataType );

#ifndef _NO_MMSS_LOGGING_

            if ( err != KErrNone )

                {

                TMmsLogger::Log(_L("- Error in recognization of data type"), err );

                // We assume that the file cannot be closed content, if its type

                // is not recognized

                err = KErrNotSupported;

                }

            else

                {

                HBufC16* buf16 = HBufC16::NewLC( KMaxFileName );

                TPtrC dummy;

                TPtr ptr = buf16->Des();

                file.Name( ptr );

                // we cannot log indefinitely long strings.

                // We get this long strings only if the message is corrupted.

                dummy.Set( ptr.Left( KMmsMaxLogStringLength ) );

                TMmsLogger::Log( _L("- filename: %S"), &dummy );

                CleanupStack::PopAndDestroy( buf16 );

                TBuf<KMaxDataTypeLength> buffer;

                buffer.Copy( dataType->iDataType.Des8() );

                TMmsLogger::Log(_L("- Data type recognizer result: %S"), &buffer );

                if ( dataType->iConfidence == CApaDataRecognizerType::ECertain )

                    {

                    TMmsLogger::Log(_L("- Confidence level: Certain"));

                    }

                else if ( dataType->iConfidence == CApaDataRecognizerType::EProbable )

                    {

                    TMmsLogger::Log(_L("- Confidence level: Probable"));

                    }

                else if ( dataType->iConfidence == CApaDataRecognizerType::EPossible )

                    {

                    TMmsLogger::Log(_L("- Confidence level: Possible"));

                    }

                else if ( dataType->iConfidence == CApaDataRecognizerType::EUnlikely )

                    {

                    TMmsLogger::Log(_L("- Confidence level: Unlikely"));

                    }

                else if ( dataType->iConfidence == CApaDataRecognizerType::ENotRecognized )

                    {

                    TMmsLogger::Log(_L("- Confidence level: Not recognized"));

                    }

                else

                    {

                    TMmsLogger::Log(_L("- Unknown confidence level"));

                    }

                }

#endif

            // We Must set limit to "possible". The recognition is rather uncertain

            if ( err == KErrNone && dataType->iConfidence >= CApaDataRecognizerType::EPossible )

                {

                TInt pos = 0;

                file.Seek( ESeekStart, pos ); // rewind just in case

                TInt prot = fileProt->ProtectionStatusL( file, dataType->iDataType );

                if ( ( prot & ( EFileProtForwardLocked | EFileProtClosedContent ) ) &&

                    !( prot & EFileProtSuperDistributable ) )

                    {

                    err = KMmsErrorProtectedContent;

                    }

                }

            CleanupStack::PopAndDestroy( &file ); //close file    

            }

#ifndef _NO_MMSS_LOGGING_

        else

            {

            TMmsLogger::Log(_L("- Error in opening file for recognization of data type"), err );

            }

#endif

        }

    CleanupStack::PopAndDestroy( store );

    CleanupStack::PopAndDestroy( dataType );

    CleanupStack::PopAndDestroy( fileProt );

    CleanupStack::PopAndDestroy( &apaLsSession ); // close apaSession

    if ( err == KErrNotSupported )

        {

        // the content type was not recognized, we must assume it is not closed content

        err = KErrNone;

        }

    return err;

    }

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

// CMmsBaseOperation::HandleBackupOperationEventL

//

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

//

void CMmsBaseOperation::HandleBackupOperationEventL(

    const TBackupOperationAttributes& aBackupOperationAttributes )

    {

    switch ( aBackupOperationAttributes.iOperation )

        {

        case EStart:

            iBackupStart = ETrue;

            iBackupEnd = EFalse;

#ifndef _NO_MMSS_LOGGING_

            TMmsLogger::Log(_L("Backup/Restore Start"));

#endif

            break;

        case EEnd:

        case EAbort:

            iBackupStart = EFalse;

            if ( iHaveTimer )

                {

                iTimer.Cancel();

                // Set this to true only if we cancel timer because of backup end

                iBackupEnd = ETrue;

                // do not do it twice

                iDoNotWaitForBackupEnd = ETrue;

                iMustWait = ETrue;

                }

#ifndef _NO_MMSS_LOGGING_

            if ( aBackupOperationAttributes.iOperation == EEnd )

                {

                TMmsLogger::Log(_L("Backup/Restore End"));

                }

            else // if not end, then it was abort

                {

                TMmsLogger::Log(_L("Backup/Restore Abort"));

                }

#endif

            break;

        default:

            break;

        }

    }

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

// CMmsBaseOperation::RunL

//

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

//

void CMmsBaseOperation::RunL()

    {

    // DoRunL() takes the AO through the states, queuing another

    // asynch step as required.

    // if DoRunL() detects the end of the cycle it returns

    // without queuing another cycle.

    // If Run() would exit without queuing another cycle it reports

    // completion to the client.

    // In CMsgActive this is true if the asynch step or DoRunL fails,

    // or the state cycle is complete

    // However, we must keep our cycle going in spite of error.

    // If any step reports an error, we must cleanup the current

    // operation, and continue to the next entry in the selection.

    // Only if we lose the connection, we complete the whole loop.

    // If we have completed ourselves, the error is already in iError.

    // However, if an asynchronous operation completed us, the error

    // comes back to us in iStatus.

    // As we always complete ourselves by returning iError as the

    // status, we get back either our original iError, or a new

    // error value set by an asynchronous operation.

#ifndef _NO_MMSS_LOGGING_

    TMmsLogger::Log( _L("BaseOperation RunL status %d, error %d"),

        iStatus.Int(), iError );

#endif

    TInt status=iStatus.Int();

    if ( iBackupEnd && ( status == KErrCancel || status == KErrTimedOut ) )

        {

        // timer cancelled because of backup end - continue as if no error

        status = KErrNone;

        }

    // wait for 5 seconds after backup end

    if ( iMustWait )

        {

        // Timer is never active if iMustWait == ETrue,

        // Actually it is not possible to check if iTimer is active.

        // We must rely on iMustWait.

        // iMustWait is set true only when the timer was just cancelled

        // because of backup end, and we must wait a few seconds before continuing.

        iMustWait = EFalse;

        iTimer.After( iStatus, KMmsServerReadyWait );

        SetActive();

        return;

        }

    // when we come here after wait, the timer can go.

    if ( iHaveTimer )

        {

        iTimer.Cancel();

        iTimer.Close();

        iHaveTimer = EFalse;

        iDoNotWaitForBackupEnd = ETrue;

        iBackupEnd = EFalse;

        }

    if ( status <= (TInt) KMsvMediaUnavailable &&

        status >= (TInt) KMsvIndexRestore &&

        !iDoNotWaitForBackupEnd )

        {

#ifndef _NO_MMSS_LOGGING_

        TMmsLogger::Log( _L("- must wait for backup end ") );

#endif

        iState = EMmsOperationWaitingForBackupEnd;

        // This will take us back to RunL

        WaitForBackupEnd();

        // iError has been set when the media unavailable error has occurred.

        if ( iError == status )

            {

            iError = KErrNone;

            }

        return;

        }