/* 
 * 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: process monitor.                 
 *
 */

#include "hsprocessmonitor.h"

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

// -----------------------------------------------------------------------------
// CHsProcessMonitor::NewL()
// Two-phased constructor
// -----------------------------------------------------------------------------
CHsProcessMonitor* CHsProcessMonitor::NewL( const TInt iProcessId,
                                            MHsProcessMonitorObserver& aObserver )
    {
    CHsProcessMonitor* self = new ( ELeave ) CHsProcessMonitor( iProcessId,
                                                                aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CHsProcessMonitor::~CHsProcessMonitor()
// Destructor.
// -----------------------------------------------------------------------------
//
CHsProcessMonitor::~CHsProcessMonitor()
    {
    Cancel();
    SecureProcessHandleAsClosed();    	
    iProcessId = KErrNotFound;
    }

// -----------------------------------------------------------------------------
// CHsProcessMonitor::AttachMonitor()
// Attach monitor
// -----------------------------------------------------------------------------
//
TInt CHsProcessMonitor::AttachMonitor()
    {   
    SecureProcessHandleAsClosed();
    
    TInt error = iProcess.Open( iProcessId, EOwnerProcess );
    
    if( error == KErrNone )
        {
        iProcessHandleOpen = ETrue;
        }
    
    return error;
    }   

// -----------------------------------------------------------------------------
// CHsProcessMonitor::StartMonitor()
// Start monitor
// -----------------------------------------------------------------------------
//
TInt CHsProcessMonitor::StartMonitor()
    {
    TInt error = KErrNone;
    
    if( !iProcessHandleOpen )
        {
        error = AttachMonitor();
        }
    
    if( error == KErrNone )
        {
        iProcess.Logon( iStatus );
        SetActive();                
        }
    
    return error;
    }   

// -----------------------------------------------------------------------------
// CHsProcessMonitor::CHsProcessMonitor()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
CHsProcessMonitor::CHsProcessMonitor( const TInt aProcessId,
                                      MHsProcessMonitorObserver& aObserver ) :
        CActive( EPriorityStandard ),
        iProcessId( aProcessId ),
        iObserver( aObserver ),
        iProcessHandleOpen( EFalse )
    {
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CHsProcessMonitor::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHsProcessMonitor::ConstructL()
    {    
    }

// -----------------------------------------------------------------------------
// CHsProcessMonitor::RunL
// -----------------------------------------------------------------------------
//
void CHsProcessMonitor::RunL()
    {
    iProcess.LogonCancel( iStatus );    	
    
    const TInt error = iStatus.Int();        
    
    if( error == KErrCancel )
        {
        }
    else if( error == KErrNoMemory )
        {
        User::Leave( KErrNoMemory );
        }
    else
        {
        const TExitType exitType = iProcess.ExitType();									
        if( exitType == EExitPending )
            {
            User::LeaveIfError( StartMonitor() );
            }
        else
            {
            iObserver.ProcessEnded( exitType,
                                    iProcess.ExitReason(),
                                    iProcess.ExitCategory() );
            }
        }
    }

// -----------------------------------------------------------------------------
// CHsProcessMonitor::DoCancel()
// From CActive.
// -----------------------------------------------------------------------------
//
void CHsProcessMonitor::DoCancel()
    {
    iProcess.LogonCancel( iStatus );
    }      

// -----------------------------------------------------------------------------
// CHsProcessMonitor::RunError()
// From CActive.
// -----------------------------------------------------------------------------
//
TInt CHsProcessMonitor::RunError( TInt aError )
    {    
    iObserver.ProcessMonitoringError( aError );

    // Observer will handle error. Return green light.
    return KErrNone;    
    }  

// -----------------------------------------------------------------------------
// CHsProcessMonitor::SecureProcessHandleAsClosed()
// Close process handle if open
// -----------------------------------------------------------------------------
//
void CHsProcessMonitor::SecureProcessHandleAsClosed()
    {
    if( iProcessHandleOpen )
        {
        iProcess.Close();
        iProcessHandleOpen = EFalse;
        }
    } 

// End of File