/*
 * ===========================================================================
 *  Name        : hgfswclientimpl.cpp
 *  Part of     : Huriganes / Fast Swap Server
 *  Description : Client API, private implementation
 *  Version     : %version: sa1spcx1#10 %
 *
 *  Copyright © 2008 Nokia Corporation.
 *  This material, including documentation and any related 
 *  computer programs, is protected by copyright controlled by 
 *  Nokia Corporation. All rights are reserved. Copying, 
 *  including reproducing, storing, adapting or translating, any 
 *  or all of this material requires the prior written consent of 
 *  Nokia Corporation. This material also contains confidential 
 *  information which may not be disclosed to others without the 
 *  prior written consent of Nokia Corporation.
 * ===========================================================================
 */

#include "hgfswclientimpl.h"
#include "hgfswclientobserver.h"
#include "hgfswcommon.h"
#include <s32mem.h>

#include "clientlogging.h"

static TInt StartServer()
    {
    RProcess server;
    const TUidType uid( KNullUid, KNullUid, KHgFswServerUid );
    TInt err = server.Create( KHgFswServerImg, KNullDesC, uid );
    if ( err != KErrNone )
        {
        return err;
        }
    TRequestStatus stat;
    server.Rendezvous( stat );
    if ( stat != KRequestPending )
        {
        server.Kill( 0 );
        }
    else
        {
        server.Resume();
        }
    User::WaitForRequest( stat );
    err = server.ExitType() == EExitPanic ? KErrGeneral : stat.Int();
    server.Close();
    return err;
    }

TInt CHgFswClientImpl::RHgFswClient::Connect()
    {
    const TInt KAsyncMessageSlots = 4;
    const TInt KMaxRetry = 4;
    
    TInt retry = KMaxRetry;
    for ( ; ; )
        {
        TInt err = CreateSession( KHgFswServerName, TVersion( 0, 0, 0 ), KAsyncMessageSlots );
        if ( err != KErrNotFound && err != KErrServerTerminated )
            {
            return err;
            }
        if ( !--retry )
            {
            return err;
            }
        err = StartServer();
        if ( err != KErrNone && err != KErrAlreadyExists )
            {
            return err;
            }
        }
    }

void CHgFswClientImpl::RHgFswClient::Subscribe( TRequestStatus& aStatus )
    {
    SendReceive( EHgFswSubscribe, aStatus );
    }
    
void CHgFswClientImpl::RHgFswClient::CancelSubscribe()
    {
    SendReceive( EHgFswCancel );
    }

void CHgFswClientImpl::RHgFswClient::GetContentL( RHgFswArray& aDst )
    {
    HGLOG_CONTEXT( GetContentL, HGLOG_LOCAL );
    HGLOG_IN();

    for ( ; ; )
        {
        TPckgBuf<TInt> bufSize;
        User::LeaveIfError( SendReceive( EHgFswGetBufferSize,
            TIpcArgs( &bufSize ) ) );
        HBufC8* buf = HBufC8::NewLC( bufSize() );
        TPtr8 p( buf->Des() );
        TInt err = SendReceive( EHgFswGetBuffer,
            TIpcArgs( &p, bufSize() ) );
        if ( err == KErrNone )
            {
            RDesReadStream strm( p );
            CleanupClosePushL( strm );
            CHgFswEntry::InternalizeArrayL( strm, aDst );
            CleanupStack::PopAndDestroy( &strm );
            }
        else if ( err != KErrArgument )
            {
            User::Leave( err );
            }
        CleanupStack::PopAndDestroy( buf );
        if ( err == KErrNone )
            {
            break;
            }
        // If result was KErrArgument then the size received from GetBufferSize is
        // not valid anymore so restart the whole procedure.
        }

    HGLOG_OUT();
    }

void CHgFswClientImpl::RHgFswClient::CloseApp( TInt aWgId )
    {
    SendReceive( EHgFswCloseApp, TIpcArgs( aWgId ) );
    }

void CHgFswClientImpl::RHgFswClient::SwitchToApp( TInt aWgId )
    {
    SendReceive( EHgFswSwitchToApp, TIpcArgs( aWgId ) );
    }

TUid CHgFswClientImpl::RHgFswClient::ForegroundAppUid( TInt aType )
    {
    TUid result = KNullUid;
    TPckgBuf<TInt> uidBuf;
    if ( SendReceive( EHgFswForegroundAppUid,
            TIpcArgs( &uidBuf, &aType ) ) == KErrNone )
        {
        result = TUid::Uid( uidBuf() );
        }
    return result;
    }

CHgFswClientImpl* CHgFswClientImpl::NewL()
    {
    CHgFswClientImpl* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

CHgFswClientImpl* CHgFswClientImpl::NewLC()
    {
    CHgFswClientImpl* self = new ( ELeave ) CHgFswClientImpl;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

CHgFswClientImpl::CHgFswClientImpl()
        : CActive( CActive::EPriorityStandard )
    {
    CActiveScheduler::Add( this );
    }

CHgFswClientImpl::~CHgFswClientImpl()
    {
    Cancel();
    iClient.Close();
    }

void CHgFswClientImpl::ConstructL()
    {
    User::LeaveIfError( iClient.Connect() );
    }

void CHgFswClientImpl::GetContentL( RHgFswArray& aDst )
    {
    iClient.GetContentL( aDst );
    }

void CHgFswClientImpl::Subscribe( MHgFswObserver& aObserver )
    {
    Cancel();
    iObserver = &aObserver;
    iClient.Subscribe( iStatus );
    SetActive();
    }
    
void CHgFswClientImpl::CancelSubscribe()
    {
    Cancel();
    }

void CHgFswClientImpl::CloseApp( TInt aWgId )
    {
    iClient.CloseApp( aWgId );
    }
    
void CHgFswClientImpl::SwitchToApp( TInt aWgId )
    {
    iClient.SwitchToApp( aWgId );
    }

TUid CHgFswClientImpl::ForegroundAppUid( TInt aType )
    {
    return iClient.ForegroundAppUid( aType );
    }

void CHgFswClientImpl::RunL()
    {
    HGLOG_CONTEXT( RunL, HGLOG_LOCAL );
    HGLOG1_IN( "%d", iStatus.Int() );

    if ( iStatus == KErrNone && iObserver )
        {
        iClient.Subscribe( iStatus );
        SetActive();
        iObserver->HandleFswContentChanged();
        }

    HGLOG_OUT();
    }
    
void CHgFswClientImpl::DoCancel()
    {
    iClient.CancelSubscribe();
    }


// end of file