/*

* 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:  Interface for service request

*

*/

// INCLUDE FILES

#include    "CServiceRequest.h"

#include    "MServiceRequestObserver.h"

#include    <ServiceRequest.rsg>

#include    <AknWaitDialog.h>

#include    <AknGlobalNote.h>

#include    <aknnotewrappers.h>

#include    <avkon.hrh>

#include    <StringLoader.h>

#include    <gsmerror.h>

#include    <exterror.h>

#include    <ConeResLoader.h> 

#include    <textresolver.h>

// CONSTANTS

_LIT( KSerqResourcesWithFullPath,"z:\\resource\\ServiceRequest.rsc" );

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

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

// CServiceRequest::CServiceRequest

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

// might leave.

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

//

CServiceRequest::CServiceRequest( MServiceRequestObserver& aObserver )

: CActive(EPriorityStandard) , iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CServiceRequest::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CServiceRequest::ConstructL()

    {

    iResourceLoader = new(ELeave) RConeResourceLoader( *CCoeEnv::Static() ); 

    TFileName fileName( KSerqResourcesWithFullPath ); 

    iResourceLoader->OpenL(fileName);

    }

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

// CServiceRequest::NewL

// Two-phased constructor.

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

//

EXPORT_C CServiceRequest* CServiceRequest::NewL( MServiceRequestObserver& aObserver )

    {

    CServiceRequest* self = new( ELeave ) CServiceRequest( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

EXPORT_C CServiceRequest::~CServiceRequest()

    {

    Reset();

    if ( iResourceLoader )

        {

        iResourceLoader->Close();

        }

    delete iResourceLoader;

    iResourceLoader = NULL;

    // If instance is deleted in call back - inform the function.

    if ( iDestroyed )

        {

        *iDestroyed = ETrue;

        }

    }

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

// CServiceRequest::Reset

// Deletes used member data

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

//

void CServiceRequest::Reset()

    {

    Cancel();

    delete iRequestingNote;

    iRequestingNote = NULL;

    delete iNoteText;

    iNoteText = NULL;

    }

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

// CServiceRequest::StartL

// Launches the request note.

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

//

EXPORT_C void CServiceRequest::StartL( const TDesC& aText )

    {

    // delete possible old data:

    Reset();

    // Choose alternative "requesting" text if given

    if ( aText.Length() )

        {

        iNoteText = aText.AllocL();

        }

    // Create note and launch it.

    CAknWaitDialog* requestingNote = new(ELeave) CAknWaitDialog(

        (REINTERPRET_CAST(CEikDialog**,&iRequestingNote)) , ETrue );

    iRequestingNote = requestingNote;

    requestingNote->PrepareLC( R_SERQ_REQUESTING_WAIT_NOTE );

    if ( iNoteText )

        {

        requestingNote->SetTextL( iNoteText->Des() );

        }

    requestingNote->SetCallback( this );

    requestingNote->RunLD();

    }

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

// CServiceRequest::DialogDismissedL

// Called when the note is cancelled. Observer call made asyncronously.

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

//

void CServiceRequest::DialogDismissedL( TInt aButtonId )

    {

    Cancel();

    if ( aButtonId == EAknSoftkeyQuit || aButtonId == EEikBidCancel )

        { 

        // Activate new request

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, aButtonId );

        SetActive();

        }

    }

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

// CServiceRequest::ShowCompletionNoteL

// Removes the wait note and shows another note if needed.

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

//

EXPORT_C void CServiceRequest::ShowCompletionNoteL( 

    TBool aShowNote,

    TInt aError,

    TSerqNoteType aNoteType,

    const TDesC& aText )

    {

    // delete old instances

    Reset();

    // if new notes are not required

    if ( !aShowNote )

        {

        return;

        }

    // Check default note appearance

    TInt defaultTextId;

    TSerqNoteType defaultNoteType;

    GetDefaultNote( aError , defaultNoteType , defaultTextId );

    // Choose text

    if ( aText.Length() )

        {

        iNoteText = aText.AllocL();

        }

    else

        {

        // read from resources

        iNoteText = StringLoader::LoadL( defaultTextId, CCoeEnv::Static() );

        }

    // Choose note type

    TSerqNoteType noteType;

    if ( aNoteType != ESerqDefault )

        {

        noteType = aNoteType;

        }

    else

        {

        noteType = defaultNoteType;

        }

    // Start note

    LaunchNoteL( noteType );

    }

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

// CServiceRequest::GetDefaultNote

// Decides note type based on the given error value.

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

//

void CServiceRequest::GetDefaultNote( 

    const TInt aError,

    TSerqNoteType& aNoteType,

    TInt& aResourceId )

    {

    switch ( aError  )

        {

        case KErrNone:

            aResourceId = R_TEXT_DONE;

            aNoteType = ESerqGlobalConfirmationNote;

            break;

        case KErrCancel:

            aResourceId = R_TEXT_UNCONFIRMED;

            aNoteType = ESerqLocalInformationNote;

            break;

        case KErrInUse:

        case KErrAccessDenied:

        case KErrGsmSSUnknownSubscriber:

        case KErrGsmSSAbsentSubscriber:        

        case KErrGsmSSIllegalOperation:

        case KErrGsmSSIllegalSubscriber:

        case KErrGsmSSSubscriptionViolation:

        case KErrGsmSSIllegalEquipment:

            aResourceId = R_TEXT_NOT_ALLOWED;

            aNoteType = ESerqGlobalInformationNote;

            break;

        case KErrGsmSSCallBarred:       

        case KErrGsmSSIncompatibility:

            aResourceId = R_QTN_SRVRQ_INFO_CONFL;

            aNoteType = ESerqGlobalInformationNote;

            break;

        case KErrGsmSSSystemFailure:

            aResourceId = R_TEXT_RESULT_UNKNOWN;

            aNoteType = ESerqGlobalInformationNote;

            break;        

        case KErrGsmSSErrorStatus:

        case KErrGsmSSUnexpectedDataValue:

        case KErrGsmSSResourcesUnavailable:

            aResourceId = R_TEXT_REQUEST_REJECTED;

            aNoteType = ESerqGlobalInformationNote;

            break;

        case KErrGsmSSPasswordAttemptsViolation:

        case KErrGsmSSNegativePasswordCheck:

        case KErrGsmSSPasswordRegistrationFailure:

            aResourceId = R_PASSWORD_ERROR_NOTE;

            aNoteType = ESerqGlobalErrorNote;

            break;

        case KErrGsmNoService:

            aResourceId = R_TEXT_NO_SERVICE;

            aNoteType = ESerqGlobalInformationNote;

            break;

        default:

            aResourceId = R_TEXT_NOT_DONE;

            aNoteType = ESerqGlobalInformationNote;

            break; 

        }

    }

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

// CServiceRequest::LaunchNoteL

// Launches given note type. Text is got from iNoteText member variable.

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

//

void CServiceRequest::LaunchNoteL( const TSerqNoteType aNoteType)

    {

    switch ( aNoteType )

        {

        case ESerqLocalInformationNote:

        case ESerqLocalConfirmationNote:

            {

            CAknResourceNoteDialog* dlg = NULL;

            if ( aNoteType == ESerqLocalInformationNote )

                {

                dlg = new ( ELeave ) CAknInformationNote( ETrue );

                }

            else

                {

                dlg = new ( ELeave ) CAknConfirmationNote( ETrue );

                }

            dlg->ExecuteLD(  iNoteText->Des() );

            delete iNoteText;

            iNoteText = NULL;

            break;

            }

        case ESerqGlobalInformationNote:

        case ESerqGlobalErrorNote:

        case ESerqGlobalConfirmationNote:

            {

            CAknGlobalNote* dlg = CAknGlobalNote::NewLC();

            if ( aNoteType == ESerqGlobalInformationNote )

                {

                dlg->ShowNoteL( EAknGlobalInformationNote , iNoteText->Des() );

                }

            else if ( aNoteType == ESerqGlobalErrorNote )

                {

                dlg->ShowNoteL( EAknGlobalErrorNote , iNoteText->Des() );

                }

            else

                {

                dlg->ShowNoteL( EAknGlobalConfirmationNote , iNoteText->Des() );

                }

            CleanupStack::PopAndDestroy( dlg );

            delete iNoteText;

            iNoteText = NULL;

            break;

            }

        default:

            User::Invariant();

            break;

        }

    }

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

// CServiceRequest::RunL

// Calls observer interface to tell that the notes has been dismissed.

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

//

void CServiceRequest::RunL()

    {

    __ASSERT_ALWAYS( !iDestroyed, User::Invariant() );

    TBool destr = EFalse; // Destructor changes to ETrue if deleted.

    iDestroyed = &destr;

    // Object still exists and the note is cancelled:

    TRAPD( error , 

        iObserver.MServiceRequestNoteCancelledL( iStatus.Int() == EEikBidCancel ) );

    // All OK

    if ( error == KErrNone )

        {

        if ( !destr )

            {

            iDestroyed = NULL;

            }

        return;

        }

    // We got an error value.

    if ( !destr )

        {

        iDestroyed = NULL;

        User::Leave( error );

        }

    else

        {

        CTextResolver* textResolver = CTextResolver::NewLC();

        HBufC* buffer = textResolver->ResolveErrorString( error ).AllocLC();

        CAknGlobalNote* note = CAknGlobalNote::NewLC();

        note->ShowNoteL( EAknGlobalErrorNote, *buffer );

        CleanupStack::PopAndDestroy( note );

        CleanupStack::PopAndDestroy( buffer ); 

        CleanupStack::PopAndDestroy( textResolver );

        }

    }

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

// CServiceRequest::RunError

// Called when RunL leaves

// (other items were commented in a header). 

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

// 

TInt CServiceRequest::RunError( TInt /*aError*/ )

    {

    return KErrNone;

    }

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

// CServiceRequest::DoCancel

// Does nothing. Must be implemented due inheritance.

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

//

void CServiceRequest::DoCancel()

    {

    }

//  End of File