/*
* Copyright (c) 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:   Server client for alfredserver.exe
*
*/



#include <apgcli.h>
#include <centralrepository.h>
#include <alf/ftokenclient.h>

#include <eikenv.h>
#include "alf/alfenv.h"
#include "alfuids.h"
#include "alf/alfclientbase.h"
#include "alflogger.h"
#include "alf/alfconstants.h"
#include <goommonitor.h>
#include <pslninternalcrkeys.h>

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

#ifndef __WINS__
#define START_GOOM_FROM_ALF_CLIENT	 
#endif

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
EXPORT_C RAlfClientBase::RAlfClientBase(TInt aServiceUid)
    : RAknAppServiceBase(), iServiceUid(aServiceUid), iEnv(0), iCmdLine(0), iApa(0)
    {
    }

// ---------------------------------------------------------------------------
// Opens the connection
// ---------------------------------------------------------------------------
//    
EXPORT_C void RAlfClientBase::OpenL()
    {
    __ALFLOGSTRING( "RAlfClient::OpenL start" )
    TUint differentiator = 
        StartServerL( TUid::Uid(KAlfAppServerInterfaceUid3) );
    TName serverName;
    ConstructServerName( 
        serverName, 
        TUid::Uid(KAlfAppServerInterfaceUid3), 
        differentiator );
    ConnectExistingByNameL( serverName );
    __ALFLOGSTRING( "RAlfClient::OpenL end" )
    }
  
// ---------------------------------------------------------------------------
// Creates server name
// ---------------------------------------------------------------------------
//    
EXPORT_C void RAlfClientBase::ConstructServerName( TName& aServerName, 
                                        TUid aAppServerUid, 
                                        TUint aServerDifferentiator )
    {

    _LIT(KServerNameFormat, "%08x_%08x_AppServer");
    aServerName.Format( 
        KServerNameFormat, 
        aServerDifferentiator, 
        aAppServerUid.iUid );
    }    
    
// ---------------------------------------------------------------------------
// Creates name, launches server and waits it to start.
// ---------------------------------------------------------------------------
// 
EXPORT_C TUint RAlfClientBase::StartServerL( TUid aAppUid )
    {
    // Start the server application
    TName serverName;
    TUint differentiator( 0 );
    
    differentiator = KAlfAppServerInterfaceUid3;
    ConstructServerName( 
        serverName, 
        TUid::Uid(KAlfAppServerInterfaceUid3) , 
        differentiator );
        
    TFindServer find( serverName );
    TFullName fullName;
    if ( find.Next( fullName ) == KErrNone )
        {
        return differentiator;
        }
    
    TThreadId serverThreadId;
    LaunchAppL( aAppUid, differentiator, serverThreadId );

    return differentiator;
    }
    
// ---------------------------------------------------------------------------
// Launches the app server.
// ---------------------------------------------------------------------------
// 
EXPORT_C void RAlfClientBase::LaunchAppL( 
    TUid aAppUid, 
    TUint aServerDifferentiator, 
    TThreadId& aThreadId )
	{
	RApaLsSession apa;
	User::LeaveIfError( apa.Connect() );
	CleanupClosePushL( apa );
	
	TApaAppInfo info;
	User::LeaveIfError( apa.GetAppInfo( info, aAppUid ) );

	CApaCommandLine* cmdLine = CApaCommandLine::NewLC();
	cmdLine->SetExecutableNameL( info.iFullName );
	cmdLine->SetServerRequiredL( aServerDifferentiator );
    // Set the command to start the server in background
    cmdLine->SetCommandL( EApaCommandBackground );        

	TRequestStatus status;	
	TInt err = apa.StartApp( *cmdLine, aThreadId, &status );
    
    User::LeaveIfError( err );
    
    User::WaitForRequest(status);
    
    User::LeaveIfError( status.Int() );
    
	CleanupStack::PopAndDestroy( cmdLine );
	CleanupStack::PopAndDestroy( &apa );
	}

// ---------------------------------------------------------------------------
// From class RAknAppServiceBase.
// Returns the service UID supported.
// ---------------------------------------------------------------------------
//
EXPORT_C TUid RAlfClientBase::ServiceUid() const
    {
    return TUid::Uid(iServiceUid);
    }


// ---------------------------------------------------------------------------
// Grant access
// ---------------------------------------------------------------------------
//
EXPORT_C TInt RAlfClientBase::GrantAccessToPrivateFile( 
                                            const TDesC& aFileName, 
                                            TInt aObjectIdentfier, 
                                            TInt aCommandId )
    {
    if (!iEnv || !iEnv->TokenClient())
        {
        return KErrNotReady;        
        }
    
    TInt64 token = 0;
    TPckg<TInt64> tokenBuf(token);
    TInt err = iEnv->TokenClient()->GenerateToken(aFileName, TUid::Uid(KAlfAppServerInterfaceUid3), tokenBuf);
    if (!err)
        {
        err = SendReceive(EAlfDoSubSessionCmd, TIpcArgs(aCommandId,&tokenBuf,&tokenBuf,aObjectIdentfier));
        }
 
    return err;
    }

// ---------------------------------------------------------------------------
// Grant access
// ---------------------------------------------------------------------------
//
EXPORT_C TInt RAlfClientBase::GrantAccessToPrivateFile( 
                                            const RFile& aFile, 
                                            TInt aObjectIdentfier, 
                                            TInt aCommandId )
   {
    if (!iEnv || !iEnv->TokenClient())
        {
        return KErrNotReady;        
        }
    
    TInt64 token = 0;
    TPckg<TInt64> tokenBuf(token);
    TInt err = iEnv->TokenClient()->GenerateToken(aFile, TUid::Uid(KAlfAppServerInterfaceUid3), tokenBuf);
    if (!err)
        {
        err = SendReceive(EAlfDoSubSessionCmd, TIpcArgs(aCommandId,&tokenBuf,&tokenBuf,aObjectIdentfier));
        }
 
    return err;
    }

// ---------------------------------------------------------------------------
// Sets env
// ---------------------------------------------------------------------------
//
void RAlfClientBase::SetAlfEnv(CAlfEnv& aAlf)
    {
    iEnv = &aAlf;
    }

void RAlfClientBase::StartAsyncL(TRequestStatus* aStatus)
    {
    ASSERT(iApa==0 && iCmdLine == 0);
    // Start the server application
    TName serverName;
    TUint differentiator( 0 );
    
    differentiator = KAlfAppServerInterfaceUid3;
    ConstructServerName( 
        serverName, 
        TUid::Uid(KAlfAppServerInterfaceUid3) , 
        differentiator );
    
    TFindServer serverFinder(serverName);
    TFullName fullName;
    if (serverFinder.Next(fullName) == KErrNone)
        {
        User::Leave(KErrAlreadyExists);
        }
        
    TThreadId threadId;
    // we don't have proper destructor and thus we don't take
    // "normal" ownership on our members...
    
    // assign to member after poping from cleanup stack - codescanner now happy
  RApaLsSession*  apa = new (ELeave) RApaLsSession;
	CleanupStack::PushL(apa);
	User::LeaveIfError( apa->Connect() );
	CleanupClosePushL( *apa );
	
	TApaAppInfo info;
	User::LeaveIfError( apa->GetAppInfo( info, TUid::Uid(KAlfAppServerInterfaceUid3) ) );

	CApaCommandLine* cmdLine = CApaCommandLine::NewLC();
	cmdLine->SetExecutableNameL( info.iFullName );
	cmdLine->SetServerRequiredL( differentiator );
    // Set the command to start the server in background
    cmdLine->SetCommandL( EApaCommandBackground );        

	User::LeaveIfError(apa->StartApp( *cmdLine, threadId, aStatus ));

    CleanupStack::Pop(3);
    iCmdLine=cmdLine;
    iApa = apa;
    }

#if !defined(__WINS__)    
_LIT(KBgAnimExeName, "z:\\sys\\bin\\backgroundanimhost.exe");
#endif

void RAlfClientBase::CompleteAsynchConstructionL()
    {
    if (iApa)
        {    
        delete iCmdLine;
        iCmdLine = 0; 
        iApa->Close();
        delete iApa;
        iApa = 0;

        TName serverName;
            ConstructServerName( 
            serverName, 
            TUid::Uid(KAlfAppServerInterfaceUid3), 
            KAlfAppServerInterfaceUid3 );
        ConnectExistingByNameL( serverName );
        }
    else
        {
    	TInt value = 0;
        CRepository* repo = CRepository::NewLC(KCRUidThemes);
        User::LeaveIfError(repo->Get(KThemesAnimBackgroundSupport, value));
        CleanupStack::PopAndDestroy();
#if !defined(__WINS__)
        if (!value)
            {         
            RProcess image;
            User::LeaveIfError(image.Create(KBgAnimExeName,KNullDesC));
            image.Resume();
            image.Close();
            }
#endif
        }
	       
    }

CAlfAsynchStartup::CAlfAsynchStartup():CActive(CActive::EPriorityHigh), iClient(RAlfClientBase(KAlfAppServerInterfaceUid3))
    {
    CActiveScheduler::Add(this);
    }

EXPORT_C void CAlfAsynchStartup::StartL()
    {
	  TInt err(KErrNone);
	
#ifdef START_GOOM_FROM_ALF_CLIENT	 
	  // do the actual goom startup : starting this first in case something goes wrong and startup needs to stop
    TRAP( err, CreateGOOMWatcherThreadL());
	if(err != KErrNone)
		{
	    RDebug::Print(_L("Creating out of graphics mem thread failed with err %d"), err);
		}
#endif
	
	//everything went ok for goom: moving over for alf now
    CAlfAsynchStartup* me = new (ELeave) CAlfAsynchStartup();
    TRAP(err, me->iClient.StartAsyncL(&(me->iStatus)));
    if ( err )
        {
        if (err == KErrAlreadyExists) // NGA Always
            {
            me->SetActive();    
            TRequestStatus* sptr = &(me->iStatus);
            User::RequestComplete(sptr, err);    
            }    
        else
            {
            // just die gracefully
            delete me;
            }
        return;
        }

    // everything fine, wait for rendezvous
    me->SetActive();    
    }
    
void CAlfAsynchStartup::RunL()
    {

    TRAP_IGNORE(iClient.CompleteAsynchConstructionL());
    iClient.Close();
    
    delete this;
    }

void CAlfAsynchStartup::DoCancel()
    {
    // not possible at the moment
    }

// end of file