/*
* Copyright (c) 2006-2007 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:  Thumbnail server client-side session
 *
*/


// INCLUDE FILES
#include "thumbnailsession.h"
#include "thumbnailmanagerconstants.h"

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

// ---------------------------------------------------------------------------
// RThumbnailSession::RThumbnailSession()
// C++ default constructor can NOT contain any code, that might leave.
// ---------------------------------------------------------------------------
//
RThumbnailSession::RThumbnailSession(): RSessionBase()
    {
    // No implementation required
    }


// ---------------------------------------------------------------------------
// RThumbnailSession::Connect()
// ---------------------------------------------------------------------------
//
TInt RThumbnailSession::Connect()
    { 
    StartServer();
    
    // special case
    // wait possibly needed here to give an old server process
    // time to enter shutdown state
    User::After(1000);
    
    TInt err = CreateSession( KThumbnailServerName, Version(), KMessageSlots );
    TInt retry = 1;
 
    // special case
    // old server still alive, wait and try again
    while (retry <= 10 && err != KErrNone)
        {
        User::After(retry * 50000);
        StartServer();
        err = CreateSession( KThumbnailServerName, Version(), KMessageSlots );
        retry++;
        }
    
    return err;
    }


// ---------------------------------------------------------------------------
// RThumbnailSession::Close()
// Closes session
// ---------------------------------------------------------------------------
//
void RThumbnailSession::Close()
    {
    RSessionBase::Close();
    }


// ---------------------------------------------------------------------------
// RThumbnailSession::Version()
// Closes session
// ---------------------------------------------------------------------------
//
TVersion RThumbnailSession::Version()
    {
    return TVersion( KThumbnailServerMajorVersionNumber,
        KThumbnailServerMinorVersionNumber, KThumbnailServerBuildVersionNumber )
        ;
    }


// ---------------------------------------------------------------------------
// RThumbnailSession::StartServer()
// ---------------------------------------------------------------------------
//
TInt RThumbnailSession::StartServer()
    {
    TInt res( KErrNone );
    // create server - if one of this name does not already exist

    TFindServer findServer( KThumbnailServerName );
    TFullName name;
    if ( findServer.Next( name ) != KErrNone )
    // we don't exist already
        {
        RProcess server;
        // Create the server process
        // KNullDesC param causes server's E32Main() to be run
        res = server.Create( KThumbnailServerExe, KNullDesC );
        if ( res != KErrNone )
        // thread created ok - now start it going
            {
            return res;
            }

        // Process created successfully
        TRequestStatus status;
        server.Rendezvous( status );
        server.Resume(); // start it going

        // Wait until the completion of the server creation
        User::WaitForRequest( status );

        if ( status != KErrNone )
            {
            server.Close();
            return status.Int();
            }
        // Server created successfully
        server.Close(); // we're no longer interested in the other process

        }
    return res;
    }


// ---------------------------------------------------------------------------
// Request a thumbnail for an object file using file handle
// ---------------------------------------------------------------------------
//
void RThumbnailSession::RequestThumbnailL( const RFile64& aFile, const TDesC& aTargetUri,
    TThumbnailRequestParamsPckg& aParams, TRequestStatus& aStatus )
    {
    TIpcArgs args( &aParams, KCheckValue ); // 1st and 2nd argument
    User::LeaveIfError( aFile.TransferToServer( args, 2, 3 )); // 3th and 4th argument
    aParams().iTargetUri = aTargetUri;
    SendReceive( ERequestThumbByFileHandleAsync, args, aStatus );
    }


// ---------------------------------------------------------------------------
// Request a thumbnail for an object file using file path
// ---------------------------------------------------------------------------
//
void RThumbnailSession::RequestThumbnailL( const TDesC& aPath, const TDesC& aTargetUri, const TThumbnailId /*aThumbnailId*/,
    TThumbnailRequestParamsPckg& aParams, TRequestStatus& aStatus )
    {
    TIpcArgs args( &aParams, KCheckValue);
    aParams().iFileName = aPath;
    aParams().iTargetUri = aTargetUri;
    
    if(aPath.Length()== 0)
        {
        SendReceive( ERequestThumbByIdAsync, args, aStatus );
        }
    else
        {        
        SendReceive( ERequestThumbByPathAsync, args, aStatus );
        }
    }

// ---------------------------------------------------------------------------
// Request a thumbnail for an object file using file path
// ---------------------------------------------------------------------------
//
void RThumbnailSession::RequestThumbnailL( const TThumbnailId aThumbnailId,
        const TDesC& /*aTargetUri*/,
        TThumbnailRequestParamsPckg& aParams, 
        TRequestStatus& aStatus )
    {
    TIpcArgs args( &aParams, KCheckValue );
    aParams().iThumbnailId = aThumbnailId;
    SendReceive( ERequestThumbByIdAsync, args, aStatus );
    }

#if 0
// ---------------------------------------------------------------------------
// Request a thumbnail for an object file using file path
// ---------------------------------------------------------------------------
//
void RThumbnailSession::RequestThumbnailL( const TDesC& aPath, const TDesC& aTargetUri,
    TThumbnailRequestParamsPckg& aParams, TRequestStatus& aStatus )
    {
    TIpcArgs args( &aParams );
    aParams().iFileName = aPath;
    aParams().iTargetUri = aTargetUri;
    SendReceive( ERequestThumbByPathAsync, args, aStatus );
    }
#endif

void RThumbnailSession::RequestSetThumbnailL( 
        TDesC8* aBuffer, const TDesC& aTargetUri,         
        TThumbnailRequestParamsPckg& aParams, 
        TRequestStatus& aStatus  )
    {
    if( !aBuffer )
        {
        User::Leave( KErrArgument );
        }
    
    TIpcArgs args( &aParams, aBuffer, aBuffer->Length(), KCheckValue );
    aParams().iTargetUri = aTargetUri;
    SendReceive( ERequestSetThumbnailByBuffer, args, aStatus );   
    }

void RThumbnailSession::RequestSetThumbnailL( 
        TInt aBitmapHandle, const TDesC& aTargetUri,         
        TThumbnailRequestParamsPckg& aParams, 
        TRequestStatus& aStatus  )
    {
    if( !aBitmapHandle )
        {
        User::Leave( KErrArgument );
        }
    
    TIpcArgs args( &aParams, aBitmapHandle, KCheckValue );
    aParams().iTargetUri = aTargetUri;
    SendReceive( ERequestSetThumbnailByBitmap, args, aStatus );   
    }

// ---------------------------------------------------------------------------
// Release bitmap instance kept by server process
// ---------------------------------------------------------------------------
//
void RThumbnailSession::ReleaseBitmap( TInt aBitmapHandle )
    {
    TInt err = Send( EReleaseBitmap, TIpcArgs( aBitmapHandle ));
    while ( err == KErrServerBusy )
        {
        err = Send( EReleaseBitmap, TIpcArgs( aBitmapHandle ));
        }
    }


// ---------------------------------------------------------------------------
// Cancel pending thumbnail request
// ---------------------------------------------------------------------------
//
TInt RThumbnailSession::CancelRequest( TThumbnailRequestId aRequestId )
    {
    TInt err = SendReceive( ECancelRequest, TIpcArgs( aRequestId ));
    while ( err == KErrServerBusy )
        {
        err = SendReceive( ECancelRequest, TIpcArgs( aRequestId ));
        }
    return err;
    }


// ---------------------------------------------------------------------------
// Change priority of pending thumbnail request
// ---------------------------------------------------------------------------
//
TInt RThumbnailSession::ChangePriority( TThumbnailRequestId aRequestId, TInt
    aNewPriority )
    {
    TInt err = SendReceive( EChangePriority, TIpcArgs( aRequestId, aNewPriority ));
    while ( err == KErrServerBusy )
        {
        err = SendReceive( EChangePriority, TIpcArgs( aRequestId, aNewPriority ));
        }
    return err;
    }

// ---------------------------------------------------------------------------
// Delete thumbnails for given object file
// ---------------------------------------------------------------------------
//
TInt RThumbnailSession::CreateThumbnails( const RFile64& aFile, TDisplayMode aDisplayMode )
    {
    TIpcArgs args( aDisplayMode ); // 1st argument
    TInt err = aFile.TransferToServer( args, 1, 2 ); // 2.&3. argument
    err = Send( ECreateThumbnails, args );
    while ( err == KErrServerBusy )
        {
        err = Send( ECreateThumbnails, args );
        }
    return err;
    }


// ---------------------------------------------------------------------------
// Delete thumbnails for given object file
// ---------------------------------------------------------------------------
//
void RThumbnailSession::DeleteThumbnails( const TDesC& aPath,
        TThumbnailRequestParamsPckg& aParams, TRequestStatus& aStatus )
    {
    TIpcArgs args( &aParams, &aPath, KCheckValue);
            
    SendReceive( EDeleteThumbnails, args, aStatus ); 
    }


// ---------------------------------------------------------------------------
// Delete thumbnails by TThumbnailId.
// ---------------------------------------------------------------------------
//
void RThumbnailSession::DeleteThumbnails( const TThumbnailId aItemId,
        TThumbnailRequestParamsPckg& aParams, TRequestStatus& aStatus )
    {   
    TIpcArgs args( &aParams, aItemId, KCheckValue);
            
    SendReceive( EDeleteThumbnailsById, args, aStatus );  
    }


// ---------------------------------------------------------------------------
//  Get a list of supported MIME types in a HBufC
// ---------------------------------------------------------------------------
//
HBufC* RThumbnailSession::GetMimeTypeListL()
    {
    TInt size = 0;
    TPckg < TInt > pckg( size );
    User::LeaveIfError( SendReceive( EGetMimeTypeBufferSize, TIpcArgs( &pckg )));
    HBufC* res = HBufC::NewLC( size );
    TPtr ptr = res->Des();
    User::LeaveIfError( SendReceive( EGetMimeTypeList, TIpcArgs( &ptr )));
    CleanupStack::Pop( res );
    return res;
    }


// ---------------------------------------------------------------------------
// Update thumbnails.
// ---------------------------------------------------------------------------
//
void RThumbnailSession::UpdateThumbnails( const TDesC& aPath, const TInt aOrientation,
        const TInt64 aModified, TThumbnailRequestParamsPckg& aParams, TRequestStatus& aStatus )
    {
    aParams().iFileName = aPath;
    aParams().iTargetUri = KNullDesC;
    aParams().iOrientation = aOrientation;
    aParams().iModified = aModified;
        
    TIpcArgs args( &aParams, KCheckValue);
            
    SendReceive( EUpdateThumbnails, args, aStatus );  
    }
    

// End of file