/*
* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
*
*/




#include <mpxlog.h>

#include "vcxconnutilcommon.h"
#include "vcxconnectionutility.hrh"
#include "vcxconnutilpubsub.h"
#include "vcxconnutilsubscriber.h"
#include "vcxconnutilpubsubobserver.h"

// CONSTANTS
_LIT( KConnUtilCounterSema, "__VcxConnUtillCounterSema__ ");
const TInt KSemaStartupValue = 1;

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

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

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::CVcxNsConnUtilEngine()
// -----------------------------------------------------------------------------
//
CVcxConnUtilPubSub::CVcxConnUtilPubSub( )
    {
    // NOP
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::ConstructL()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilPubSub::ConstructL( MConnUtilPubsubObserver *aObserver )
    {
    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilPubSub::ConstructL() in");

    TInt status( KErrNone );
    // semafore for protecting P&S -counter value writing
    status = iSemaCounter.CreateGlobal( KConnUtilCounterSema, KSemaStartupValue );
    if( status == KErrAlreadyExists )
        {
        // if semafore exists already, just open handle to existing
        status = iSemaCounter.OpenGlobal( KConnUtilCounterSema );
        }
    User::LeaveIfError( status );

    User::LeaveIfError( 
            iPropertyCurrentIAPId.Attach( KVcxConnUtilPScategory, 
                                          EVCxPSIapId ) );
    
    User::LeaveIfError( 
            iPropertyCurrentSNAPId.Attach( KVcxConnUtilPScategory, 
                                           EVCxPSSnapId ) );
    
    User::LeaveIfError( 
            iPropertyNbrOfInst.Attach( KVcxConnUtilPScategory, 
                                       EVCxPSNbrConnInstances ) );
    
    User::LeaveIfError(
            iPropertyAccepted.Attach( KVcxConnUtilPScategory, 
                                      EVCxPSNbRoamAccepted ) );
 
    iConnectionStatePS = 
        CVcxConnUtilSubscriber::NewL( KVcxConnUtilPScategory, 
                                      EVCxPSConnectionStatus, 
                                      RProperty::EInt, aObserver );
    
    iMasterExistPS =     
        CVcxConnUtilSubscriber::NewL( KVcxConnUtilPScategory, 
                                      EVCxPSMasterExists, 
                                      RProperty::EInt, aObserver ); 
    
    iRoamingReqStatusPS = 
        CVcxConnUtilSubscriber::NewL( KVcxConnUtilPScategory, 
                                      EVCxPSRoamingRequestStatus, 
                                      RProperty::EInt, aObserver );  
    
    iNbrInstanceResp = 
        CVcxConnUtilSubscriber::NewL( KVcxConnUtilPScategory, 
                                      EVCxPSNbrRoamResp, 
                                      RProperty::EInt, aObserver );
        
    if( GetValue( EVCxPSIapId, status ) == KErrNotFound )
        {
        MPX_DEBUG1("vcxconnutil ## CVcxConnUtilPubSub::ConstructL() no properties");
        
        // define properties
        DefinePropertiesL();           
        }
    
    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilPubSub::ConstructL() out");
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::~CVcxConnUtilPubSub()
// -----------------------------------------------------------------------------
//   
CVcxConnUtilPubSub::~CVcxConnUtilPubSub()
    {
    iSemaCounter.Close();	
    	
    iPropertyCurrentIAPId.Close();
    iPropertyCurrentSNAPId.Close();
    iPropertyNbrOfInst.Close();
    iPropertyAccepted.Close();
    
    delete iConnectionStatePS;
    delete iMasterExistPS;
    delete iRoamingReqStatusPS;
    delete iNbrInstanceResp;
    
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::DefinePropertiesL()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilPubSub::DefinePropertiesL()
    {
    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilPubSub::DefinePropertiesL() in");
    TInt result( KErrNone );
    RSemaphore semaphore;
    result = semaphore.CreateGlobal( KVcxConnUtilPSSema, 0 );
    if( result != KErrNone && result != KErrAlreadyExists )
        {
        // kernel cannot create semaphore, or there is no existing
        User::LeaveIfError( result );
        }
    if( result == KErrAlreadyExists )
        {
        // semaphore exist. Some other process is already defining PS
        // open semaphore and wait for it to finish
        User::LeaveIfError( semaphore.OpenGlobal( KVcxConnUtilPSSema ) );
        semaphore.Wait();
        // check if PS keys do exists
        TInt value( 0 );
        if( GetValue( EVCxPSIapId, value ) == KErrNotFound )
            {
            // other proces has failed to define PS, 
            // this process will try it
            result = KErrNone;
            }                
        }
    if( result == KErrNone )
        {
        const TUidType createPSUid( KNullUid, KNullUid, KVcxConnUtilPScategory );
       
        RProcess createPS;
        result = createPS.Create( KVcxConnUtilPSWorkerName(), KNullDesC(), createPSUid );
        if( result == KErrNone )
            {
            createPS.Resume();
            createPS.Close();
            semaphore.Wait();
            // init default values for keys, whose default differs from 0
            SetValue( EVCxPSRoamingRequestStatus, EVCxRoamingNotInit );
            SetValue( EVCxPSConnectionStatus, EVCxNotConnected );         
            }
        }
    // need to signal here for other possible
    // processes to proceed
    semaphore.Signal();
    semaphore.Close();  
    if( result != KErrNone && result != KErrAlreadyExists )
        {
        // all other erros cause leave: worker process creation fails, or
        // kernel refuses to open existing semphore (== platform problem)
        User::LeaveIfError( result );
        }
    MPX_DEBUG1("vcxconnutil ## CVcxConnUtilPubSub::DefinePropertiesL() out");
    }


RProperty* CVcxConnUtilPubSub::GetProperty( TUint32 aKey )
    {
    switch( aKey )
        {
        case EVCxPSConnectionStatus:
            return &( iConnectionStatePS->Property() );
            
        case EVCxPSIapId:
            return &iPropertyCurrentIAPId;
            
        case EVCxPSSnapId:
            return &iPropertyCurrentSNAPId;
            
        case EVCxPSMasterExists:
            return &( iMasterExistPS->Property() );
            
        case EVCxPSNbrConnInstances:
            return &iPropertyNbrOfInst;
            
        case EVCxPSRoamingRequestStatus:
            return &( iRoamingReqStatusPS->Property() );
            
        case EVCxPSNbrRoamResp:    
            return &( iNbrInstanceResp->Property() );
            
        case EVCxPSNbRoamAccepted:    
            return &iPropertyAccepted;
            
        default:
            break;
        }
    return 0;
    }

CVcxConnUtilSubscriber* CVcxConnUtilPubSub::GetSubscriber( TUint32 aKey )
    {
    switch( aKey )
        {  
        case EVCxPSConnectionStatus:
            return iConnectionStatePS;
            
        case EVCxPSMasterExists:
            return iMasterExistPS;
            
        case EVCxPSRoamingRequestStatus:
            return iRoamingReqStatusPS;
            
        case EVCxPSNbrRoamResp:    
            return iNbrInstanceResp;   
            
        default:
            break;
        }
        return 0;
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::IncCounterPubSubL()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilPubSub::IncCounterPubSubL( TUint32 aKey )
    {
    const TInt KIncValue( 1 );
    DoPSCounterIncrementL( aKey, KIncValue );   
    }
  
// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::DecNbrOfConnUsersPubSub()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilPubSub::DecCounterPubSubL( TUint32 aKey )
    {
    const TInt KDecValue( -1 );
    DoPSCounterIncrementL( aKey, KDecValue );      
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::DoPSCounterIncrementL()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilPubSub::DoPSCounterIncrementL( TUint32 aKey, TInt aCalcFactor )
    {
    if( aKey == EVCxPSNbrConnInstances || 
        aKey == EVCxPSNbrRoamResp      ||
        aKey == EVCxPSNbRoamAccepted )
        {
        RProperty* property = GetProperty( aKey );
        if( property )
            {
             TInt value( 0 );
             TInt err( KErrNone );
             // entering critical section
             iSemaCounter.Wait();
             err = property->Get( value );
             if( err == KErrNone )
                 {
                 value += aCalcFactor;
                 err = property->Set( value ); 
                 }
             // leaving critical section 
             iSemaCounter.Signal();
             User::LeaveIfError( err );  
             }
         }	    	
    }
    
// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::SetValue()
// -----------------------------------------------------------------------------
//
TInt CVcxConnUtilPubSub::SetValue( TUint32 aKey, TInt aValue )
    {
    TInt err( KErrNone );
    RProperty* property = GetProperty( aKey );
    if( property )
        {
        err = property->Set( aValue );
        }
    return err;
    }
 
// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::GetValue()
// -----------------------------------------------------------------------------
//
TInt CVcxConnUtilPubSub::GetValue( TUint32 aKey, TInt& aValue )
    {
    TInt err( KErrNone );
    RProperty* property = GetProperty( aKey );
    if( property )
        {
        err = property->Get( aValue );
        }
    return err;
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::CancelValueSubscribers()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilPubSub::StartSubscibers( TUint32 aKey )
    {
    if( !aKey )
        {
        iConnectionStatePS->Start();
        iMasterExistPS->Start();
        iRoamingReqStatusPS->Start();
        iNbrInstanceResp->Start();
        }
    else
        {
        CVcxConnUtilSubscriber* subscriber = GetSubscriber( aKey );
        if( subscriber )
            {
            subscriber->Start();
            }
        }
    }

// -----------------------------------------------------------------------------
// CVcxConnUtilPubSub::CancelValueSubscribers()
// -----------------------------------------------------------------------------
//
void CVcxConnUtilPubSub::CancelValueSubscribers( TUint32 aKey )
    {
    if( !aKey )
        {
        iConnectionStatePS->Cancel();
        iMasterExistPS->Cancel();
        iRoamingReqStatusPS->Cancel();
        iNbrInstanceResp->Cancel();
        }
    else
        {
        CVcxConnUtilSubscriber* subscriber = GetSubscriber( aKey );
        if( subscriber )
            {
            subscriber->Cancel();
            }
        }
    }
// end of file