/*
* Copyright (c) 2008 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:  Client API, private implementation
 *
*/


#include "tsfswclientimpl.h"
#include "tsfswclientobserver.h"
#include "tsfswcommon.h"
#include <s32mem.h>

#include "clientlogging.h"

// --------------------------------------------------------------------------
// StartServer
// --------------------------------------------------------------------------
//   
static TInt StartServer()
    {
    RProcess server;
    const TUidType uid( KNullUid, KNullUid, KTsFswServerUid );
    TInt err = server.Create( KTsFswServerImg, 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;
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::RTsFswClient::Connect
// --------------------------------------------------------------------------
//
TInt CTsFswClientImpl::RTsFswClient::Connect()
    {
    const TInt KAsyncMessageSlots = 4;
    const TInt KMaxRetry = 4;
    
    TInt retry = KMaxRetry;
    for ( ; ; )
        {
        TInt err = CreateSession( KTsFswServerName, 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;
            }
        }
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::RTsFswClient::Subscribe
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::RTsFswClient::Subscribe( TRequestStatus& aStatus )
    {
    SendReceive( ETsFswSubscribe, aStatus );
    }
    
// --------------------------------------------------------------------------
// CTsFswClientImpl::RTsFswClient::CancelSubscribe
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::RTsFswClient::CancelSubscribe()
    {
    SendReceive( ETsFswCancel );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::RTsFswClient::GetContentL
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::RTsFswClient::GetContentL( RTsFswArray& aDst )
    {
    TSLOG_CONTEXT( GetContentL, TSLOG_LOCAL );
    TSLOG_IN();

    for ( ; ; )
        {
        TPckgBuf<TInt> bufSize;
        User::LeaveIfError( SendReceive( ETsFswGetBufferSize,
            TIpcArgs( &bufSize ) ) );
        HBufC8* buf = HBufC8::NewLC( bufSize() );
        TPtr8 p( buf->Des() );
        TInt err = SendReceive( ETsFswGetBuffer,
            TIpcArgs( &p, bufSize() ) );
        if ( err == KErrNone )
            {
            RDesReadStream strm( p );
            CleanupClosePushL( strm );
            CTsFswEntry::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.
        }

    TSLOG_OUT();
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::RTsFswClient::CloseApp
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::RTsFswClient::CloseApp( TInt aWgId )
    {
    SendReceive( ETsFswCloseApp, TIpcArgs( aWgId ) );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::RTsFswClient::SwitchToApp
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::RTsFswClient::SwitchToApp( TInt aWgId )
    {
    SendReceive( ETsFswSwitchToApp, TIpcArgs( aWgId ) );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::RTsFswClient::ForegroundAppUid
// --------------------------------------------------------------------------
//   
TUid CTsFswClientImpl::RTsFswClient::ForegroundAppUid( TInt aType )
    {
    TUid result = KNullUid;
    TPckgBuf<TInt> uidBuf;
    if ( SendReceive( ETsFswForegroundAppUid,
            TIpcArgs( &uidBuf, &aType ) ) == KErrNone )
        {
        result = TUid::Uid( uidBuf() );
        }
    return result;
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::NewL
// --------------------------------------------------------------------------
//   
CTsFswClientImpl* CTsFswClientImpl::NewL()
    {
    CTsFswClientImpl* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }

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

// --------------------------------------------------------------------------
// CTsFswClientImpl::CTsFswClientImpl()
// --------------------------------------------------------------------------
//   
CTsFswClientImpl::CTsFswClientImpl()
        : CActive( CActive::EPriorityStandard )
    {
    CActiveScheduler::Add( this );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::~CTsFswClientImpl()
// --------------------------------------------------------------------------
//   
CTsFswClientImpl::~CTsFswClientImpl()
    {
    Cancel();
    iClient.Close();
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::ConstructL()
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::ConstructL()
    {
    User::LeaveIfError( iClient.Connect() );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::GetContentL
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::GetContentL( RTsFswArray& aDst )
    {
    iClient.GetContentL( aDst );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::Subscribe
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::Subscribe( MTsFswObserver& aObserver )
    {
    Cancel();
    iObserver = &aObserver;
    iClient.Subscribe( iStatus );
    SetActive();
    }
    
// --------------------------------------------------------------------------
// CTsFswClientImpl::CancelSubscribe
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::CancelSubscribe()
    {
    Cancel();
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::CloseApp
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::CloseApp( TInt aWgId )
    {
    iClient.CloseApp( aWgId );
    }
    
// --------------------------------------------------------------------------
// CTsFswClientImpl::SwitchToApp
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::SwitchToApp( TInt aWgId )
    {
    iClient.SwitchToApp( aWgId );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::ForegroundAppUid
// --------------------------------------------------------------------------
//   
TUid CTsFswClientImpl::ForegroundAppUid( TInt aType )
    {
    return iClient.ForegroundAppUid( aType );
    }

// --------------------------------------------------------------------------
// CTsFswClientImpl::RunL
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::RunL()
    {
    TSLOG_CONTEXT( RunL, TSLOG_LOCAL );
    TSLOG1_IN( "%d", iStatus.Int() );

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

    TSLOG_OUT();
    }
    
// --------------------------------------------------------------------------
// CTsFswClientImpl::DoCancel
// --------------------------------------------------------------------------
//   
void CTsFswClientImpl::DoCancel()
    {
    iClient.CancelSubscribe();
    }


// end of file