/** @file

 * Copyright (c) 2009 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 : UpnpAuthorizationNote implementation

 *

 */

// INCLUDES

#include <AknGlobalNote.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <avkon.mbg>

#include <barsread.h>

#include <barsc.h>

#include <upnpnotifier.rsg>

#include <data_caging_path_literals.hrh>

#include <bautils.h>

#include "upnpauthorizationnote.h"

_LIT( KComponentLogfile, "upnpsecurity.txt" );

#include "upnplog.h"

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

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

// CUpnpAuthorizationNote::CUpnpAuthorizationNote

// C++ default constructor.

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

//

CUpnpAuthorizationNote::CUpnpAuthorizationNote() :

    CActive(EPriorityStandard) // Standard priority

    {

    // Add to scheduler

    CActiveScheduler::Add( this );

    }

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

// CUpnpAuthorizationNote::NewLC

// Two-phased constructor.

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

//

CUpnpAuthorizationNote* CUpnpAuthorizationNote::NewLC()

    {

    CUpnpAuthorizationNote* self = new ( ELeave ) CUpnpAuthorizationNote();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpAuthorizationNote::NewL

// Two-phased constructor.

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

//

CUpnpAuthorizationNote* CUpnpAuthorizationNote::NewL()

    {

    CUpnpAuthorizationNote* self = CUpnpAuthorizationNote::NewLC( );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpAuthorizationNote::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpAuthorizationNote::ConstructL()

    {

    iTimer = CUpnpNotifyTimer::NewL( this );

    RBuf filename;

    GetResourceFilePathLC( filename );

    ReadAuthorisationStringL(filename);

    CleanupStack::PopAndDestroy( &filename );

    }

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

// CUpnpAuthorizationNote::ResourceFilePathLC

// Construct path of resource file

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

//

void CUpnpAuthorizationNote::GetResourceFilePathLC( RBuf& aResultFilePath )

    {

    const TInt KDrivePrefixLength(2);

    const TInt KPathLength( 

        KDrivePrefixLength + KResourcePath().Length() + KResourceFileName().Length() );

    aResultFilePath.CreateL( KPathLength );

    CleanupClosePushL( aResultFilePath );

    aResultFilePath.Append( RProcess().FileName().Left(KDrivePrefixLength) );

    aResultFilePath.Append( KResourcePath );

    aResultFilePath.Append( KResourceFileName );

    }

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

// CUpnpAuthorizationNote::ReadAuthorisationStringL

// Read authorisation string from given resource file

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

//

void CUpnpAuthorizationNote::ReadAuthorisationStringL( const TDesC& aFilename )

    {

    ASSERT( NULL == iAuthorizationString );

    // open file server session

    RFs fs;

    User::LeaveIfError( fs.Connect() );

    CleanupClosePushL( fs );

    // Get the exact filename of the resource file

    TFileName rscFileName;

    rscFileName.Copy( aFilename );

    BaflUtils::NearestLanguageFile( fs, rscFileName );

    // open resource file

    RResourceFile resourceFile;

    resourceFile.OpenL( fs, rscFileName );

    CleanupClosePushL( resourceFile );

    resourceFile.ConfirmSignatureL();

    // read authorization string

    HBufC8* resourceBuffer =

            resourceFile.AllocReadLC( R_UPNPNOTIFIER_INCOMING_DEVICE_TEXT );

    TResourceReader resourceReader;

    resourceReader.SetBuffer( resourceBuffer );

    TPtrC textdata = resourceReader.ReadTPtrC();

    iAuthorizationString = textdata.AllocL();

    // cleanup

    CleanupStack::PopAndDestroy( resourceBuffer );

    CleanupStack::PopAndDestroy( &resourceFile );

    CleanupStack::PopAndDestroy( &fs );

    }

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

// CUpnpAuthorizationNote::~CUpnpAuthorizationNote

// Destructor.

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

//

CUpnpAuthorizationNote::~CUpnpAuthorizationNote()

    {

    Cancel(); // Cancel any request, if outstanding

    delete iTimer;

    delete iAuthorizationString;

    }

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

// CUpnpAuthorizationNote::DoCancel

// How to cancel me.

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

//

void CUpnpAuthorizationNote::DoCancel()

    {

    iTimer->Cancel( );

    TRAP_IGNORE( CancelNoteL( ));

    }

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

// CUpnpAuthorizationNote::CancelNoteL

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

//

void CUpnpAuthorizationNote::CancelNoteL()

    {

    if ( iNote )

        {

        iNote->CancelNoteL( iNoteId );

        delete iNote;

        iNote = NULL;

        }

    }

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

// CUpnpAuthorizationNote::ShowNoteL

// Function for making the request.

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

//

void CUpnpAuthorizationNote::ShowNoteL(

    MUpnpAuthorizationNoteObserver* aObserver )

    {

    ASSERT( !iNote && aObserver );

    iObserver = aObserver;

    iNote = CAknGlobalNote::NewL();

    iNote->SetSoftkeys( R_AVKON_SOFTKEYS_YES_NO );

    iNote->SetGraphic( EMbmAvkonQgn_note_query, EMbmAvkonQgn_note_query_mask );

    iNoteId = iNote->ShowNoteL( iStatus, EAknGlobalInformationNote,

        *iAuthorizationString );

    Cancel(); // Cancel any request, just to be sure

    iTimer->AfterSeconds( KAuthorizationNoteTimeout ); // Set for later

    SetActive(); // Tell scheduler a request is active

    }

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

// CUpnpAuthorizationNote::TimerEventL

// From MUpnpNotifyTimerObserver.

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

//

void CUpnpAuthorizationNote::TimerEventL( CUpnpNotifyTimer* /*aTimer*/)

    {

    if ( IsActive() )

        {

        // cancelling note will complete outstanding request with EEikBidCancel

        CancelNoteL();

        }

    }

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

// CUpnpAuthorizationNote::RunL

// From CActive - handle completion.

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

//

void CUpnpAuthorizationNote::RunL()

    {

    iTimer->Cancel();

    // always delete the note

    CancelNoteL();

    // handle the result

    if ( iStatus == EAknSoftkeyYes )

        {

        __LOG( "[UpnpSecurity]\t CUpnpAuthorisationNotifier, \

        used authorized the access." );

        iObserver->NoteResponseL( ETrue );

        }

    else

        {

        __LOG( "[UpnpSecurity]\t CUpnpAuthorisationNotifier, \

        used denied the access." );

        iObserver->NoteResponseL( EFalse );

        }

    }

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

// CUpnpAuthorizationNote::RunError

// Override to handle leaves from RunL().

// Default implementation causes the active scheduler to panic.

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

//

TInt CUpnpAuthorizationNote::RunError( TInt aError )

    {

    __LOG1( "[UpnpSecurity]\t CUpnpAuthorizationNote::RunError %d", aError );

    TRAP_IGNORE( iObserver->NoteResponseL( EFalse ) );

    return KErrNone;

    }

//  End of File