/*
* Copyright (c) 2010 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:   Implements class
*
*/



// INCLUDE FILES

#include "coutboxsendoperation.h"   // header

#include <SendUiConsts.h>           // MTM Uids
#include <msvids.h>                  // Entry Ids
#include <gsmerror.h>                // SMS sending failure error codes
#include <smutset.h>
#include "debugtraces.h"

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

// Two-phased constructor.
COutboxSendOperation* COutboxSendOperation::NewL(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus )
    {
    // Create the instance of sending operation
    COutboxSendOperation* self =
        new (ELeave) COutboxSendOperation(
            aMsvSession, aObserverRequestStatus );

    // Push self into cleanup stack during construction
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop();

    // Return the object
    return self;
    }

// C++ default constructor can NOT contain any code that
// might leave.
//
COutboxSendOperation::COutboxSendOperation(
    CMsvSession& aMsvSession,
    TRequestStatus& aObserverRequestStatus )
    :
    CMsvOperation( aMsvSession, CActive::EPriorityStandard, aObserverRequestStatus ),
    iSelections( 4 ),
    iServices(),
    iSupportedMsgs( COutboxSendOperation::ESupportsSmsSending )
    {
    // Start scheduler
    CActiveScheduler::Add(this);
    }

//destructor
COutboxSendOperation::~COutboxSendOperation()
    {
    // Cancel sending
    Cancel();

    // Delete sending operation
    delete iOperation;
    iOperation = NULL;

    // Delete entry
    delete iEntry;
    iEntry = NULL;

    // Remove services from queue and destroy message selections
    iServices.Reset();
    iSelections.ResetAndDestroy();
    }

// ----------------------------------------------------
// COutboxSendOperation::ConstructL
// ----------------------------------------------------
//
void COutboxSendOperation::ConstructL()
    {
    // Get rootindex entry
    iEntry = iMsvSession.GetEntryL( KMsvRootIndexEntryId );
    iEntry->SetSortTypeL(
        TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByNone, ETrue ) );

    // Set sending flags
    iSupportedMsgs |= ESendSms;

    // Start sending
    StartSendingL();
    }

// ----------------------------------------------------
// COutboxSendOperation::RunL
// ----------------------------------------------------
//
void COutboxSendOperation::RunL()
    {
    QDEBUG_WRITE("COutboxSendOperation::RunL");
    User::LeaveIfError( iStatus.Int() );

    // Check and start sending, if needed
    TUid sendMtm;

    // Check if messages needs to be sent
    if( IsSendingNeeded( sendMtm ) )
        {
        StartSendingL();
        }
    // Nothing to send, complete operation
    else
        {
        CompleteObserver( iStatus.Int() );
        }
    }

// ----------------------------------------------------
// COutboxSendOperation::RunError
// ----------------------------------------------------
//
TInt COutboxSendOperation::RunError( TInt aError )
    {   
    CompleteObserver( aError );
    return aError;
    }

// ----------------------------------------------------
// COutboxSendOperation::DoCancel
// ----------------------------------------------------
//
void COutboxSendOperation::DoCancel()
    {
    // Check if sending operation is running
    if( iOperation )
        {
        // Cancel it
        iOperation->Cancel();
        }

    // Complete operation with current status
    CompleteObserver( iStatus.Int() );
    }

// ----------------------------------------------------
// COutboxSendOperation::ProgressL
// ----------------------------------------------------
//
const TDesC8& COutboxSendOperation::ProgressL()
    {
    // Check if operation exists
    if( iOperation )
        {
        // Return the operation
        return iOperation->ProgressL();
        }

    // If no operation, return blank information
    return KNullDesC8();
    }

// ---------------------------------------------------------
// COutboxSendOperation::CompleteOperation
// ---------------------------------------------------------
//
void COutboxSendOperation::CompleteObserver( TInt aStatus )
    {
    // Get the observer status
    TRequestStatus* status = &iObserverRequestStatus;
    User::RequestComplete( status, aStatus );
    }

// ----------------------------------------------------
// COutboxSendOperation::StartSendingL
// ----------------------------------------------------
//
void COutboxSendOperation::StartSendingL()
    {
    // Remove any sending operation that currently may be running
    delete iOperation;
    iOperation = NULL;


    // Check if there was errors with creating selection
    if  ( CheckAndCreateSelectionL() )
        {
        // Create new operation and trap any errors
        SendWaitingSMSMessages();
        RemoveSelection();
        }
    else
        {
        CompleteSelf( KErrNone );
        }
    }

    // if error, then complete this pass with the error code
void COutboxSendOperation::SendWaitingSMSMessages()
    {
    TRAPD( err, SendWaitingSMSMessagesL() );
    if  ( err != KErrNone )
        {
        ASSERT( !IsActive() );
        CompleteSelf( err );
        }
    }

// ----------------------------------------------------
// COutboxSendOperation::SendWaitingSMSMessagesL
// ----------------------------------------------------
//
void COutboxSendOperation::SendWaitingSMSMessagesL()
    {
    // Get first selection from queue
    CMsvEntrySelection& selection = ( *iSelections[0] );

    // Get count of messages in queue
    TInt count = selection.Count();

    // Go through all messages
    while( count-- )
        {
        // Select message
        iEntry->SetEntryL( selection[count] );
        TMsvEntry entry( iEntry->Entry() );

        // Check if the message is tried to send when in offline
        if( ( entry.SendingState() == KMsvSendStateSuspended ||
              entry.SendingState() == KMsvSendStateFailed) &&
            ( entry.iError == KErrGsmOfflineOpNotAllowed ||
              entry.iError == KErrGsmOfflineSimOpNotAllowed) )
            {
            // Set message to wait sending
            entry.SetSendingState( KMsvSendStateWaiting );
            iEntry->ChangeL( entry );
            }
		else
			{
			selection.Delete( count );
			}
        }
    selection.Compress();

    // Set entry to outbox
    iMtm = iEntry->Entry().iMtm;
    iEntry->SetEntryL( KMsvGlobalOutBoxIndexEntryId );
	if ( selection.Count() )
		{
		iOperation = iEntry->CopyL( selection, iServices[0], iStatus );
        SetActive();
		}
    else
        {
        // Nothing to send, but we must complete the observer via our RunL callback
        CompleteSelf( KErrNone );
        }
    }


// ----------------------------------------------------
// COutboxSendOperation::RemoveSelection
// ----------------------------------------------------
//
void COutboxSendOperation::RemoveSelection()
    {
    // Clear the the current selection.
    iServices.Delete(0);

    // Delete selection object and index
    delete iSelections[0];
    iSelections.Delete(0);
    }

// ----------------------------------------------------
// COutboxSendOperation::CreateSelectionL
// ----------------------------------------------------
//
void COutboxSendOperation::CreateSelectionL(
    const TUid &aUidForSel,
    const TMsvId& aServiceId,
    CMsvEntrySelection*& aSelection )
    {
    // Set entry to outbox and get messages from outbox
    iEntry->SetEntryL( KMsvGlobalOutBoxIndexEntryId );
    aSelection = iEntry->ChildrenWithMtmL( *&aUidForSel );

    // Check if there is anything to put into array
    if( aSelection->Count() )
        {
        // Put selection to queue
        CleanupStack::PushL( aSelection );
        iSelections.AppendL( aSelection );
        CleanupStack::Pop( aSelection );

        // Put service to queue
        iServices.AppendL( aServiceId );
        }
    else
        {
        // Remove selection
        delete aSelection;
        aSelection = NULL;
        }
    }

// ----------------------------------------------------
// COutboxSendOperation::CheckAndCreateSelectionL
// ----------------------------------------------------
//
TBool COutboxSendOperation::CheckAndCreateSelectionL()
    {
    // Get root index
    iEntry->SetEntryL( KMsvRootIndexEntryId );

    // MTM, for which the selection is collected
    TUid sendMtm;

    // Selection of messages for sending
    CMsvEntrySelection* smsSelection = NULL;

    // While MTM's available for sending
    while( smsSelection == NULL && IsSendingNeeded( sendMtm ) )
        {
        // Find default SMS service
        TMsvId serviceId =0;
        TSmsUtilities::ServiceIdL(*iEntry, serviceId);
        QDEBUG_WRITE_FORMAT("COutboxSendOperation::CheckAndCreateSelectionL ",serviceId );
        // Check if the service ID is found
        if( serviceId != KMsvNullIndexEntryId )
            {
            // Create selection of messages of specified MTM
            CreateSelectionL( sendMtm, serviceId, smsSelection );
            }
        // Selection has been created, remove the flag
        RemoveSendingFlag( *&sendMtm );
        }

    const TBool selectionAvailable = ( smsSelection != NULL );
    return selectionAvailable;
    }

// ----------------------------------------------------
// COutboxSendOperation::RemoveSendingFlag
// ----------------------------------------------------
//
void COutboxSendOperation::RemoveSendingFlag( const TUid& aMtm )
    {
    // Decide actions by mtm
    switch( aMtm.iUid )
        {
        // SMS-messages
        case KSenduiMtmSmsUidValue:
            iSupportedMsgs &= ~ESendSms;
            break;        
        default:
            break;
        }
    }

// ----------------------------------------------------
// COutboxSendOperation::IsSendingNeeded
// ----------------------------------------------------
//
TBool COutboxSendOperation::IsSendingNeeded(
    TUid& aMtm ) const
    {
    // Set starting condition
    TBool needSending = EFalse;

    // Check if sms-sending is supported and messages need to be sent
    if( iSupportedMsgs & ESupportsSmsSending &&
        iSupportedMsgs & ESendSms )
        {
        aMtm = KSenduiMtmSmsUid;
        needSending = ETrue;
        }
    // Otherwise nothing needs to be done
    else
        {
        aMtm.iUid = 0;
        needSending = EFalse;
        }

    // Return the result
    return needSending;
    }

// ----------------------------------------------------
// COutboxSendOperation::CompleteSelf
// ----------------------------------------------------
//
void COutboxSendOperation::CompleteSelf( TInt aValue )
    {
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, aValue );
    SetActive();
    }
    
// End of file