/*
* Copyright (c) 2009 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:
*
*/

#include <e32def.h> // Define before audiopolicy defs
#include <e32std.h> // Define before audiopolicy defs
#include <eikdef.h>

#ifndef __WINS__

#include <audiopolicypubsubdata.h>
#include <audiosw_pubsubkeys.h>

#endif //__WINS__

#include <ctsydomainpskeys.h>
#include <publicruntimeids.hrh>
#include <sacls.h>

#ifdef COMPILE_IN_IVALO
#   include <voiceuidomainpskeys.h>
#endif //COMPILE_IN_IVALO
#include <featmgr.h>

// User includes
#include "cradioenginelogger.h"
#include "cradiosystemeventdetector.h"
#include "mradiosystemeventdetectorobserver.h"

/** Granularity for audio category arrays. */
const TInt KVRAudioCategoryArrayGranularity = 3;

// This has to be the last include. 
#ifdef STUB_CONSTELLATION
#   include "RadioStubManager.h"
#   define KUidSystemCategory KStub_KUidSystemCategory
#   define KPSUidCtsyCallInformation KStub_KPSUidCtsyCallInformation
#   define KPSUidVoiceUiAccMonitor KStub_KPSUidVoiceUiAccMonitor
#   define KPSUidMMFAudioServer KStub_KPSUidMMFAudioServer
#endif //STUB_CONSTELLATION

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

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CRadioSystemEventDetector::CRadioSystemEventDetector( MRadioSystemEventDetectorObserver&  aObserver )
    : iObserver( aObserver )
    , iIsMobileNetworkCoverage( EFalse )
    , iIsWlanCoverage( EFalse )
    , iIsCallActive( EFalse )
    , iIsAudioResourcesAvailable( ETrue )
    , iIsVoiceUiActive( EFalse )
    {
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CRadioSystemEventDetector::ConstructL()
    {
//    FeatureManager::InitializeLibL();
//    TBool wlanSupported = FeatureManager::FeatureSupported( KFeatureIdProtocolWlan );
//    FeatureManager::UnInitializeLib();
    TBool wlanSupported = EFalse; //TODO: Check if we have any need for this

    iNetworkStatusObserver = CRadioPropertyObserver::NewL( *this,
                                                           KUidSystemCategory,
                                                           KUidNetworkStatusValue,
                                                           CRadioPropertyObserver::ERadioPropertyInt );
    iNetworkStatusObserver->ActivateL();

    iIsMobileNetworkCoverage = iNetworkStatusObserver->ValueInt() == ESANetworkAvailable;

    // On S60 platform, there is no guaranteed way of seeing whether WLAN is explicitly turned off
    // in the settings, or whether the network is available. For now, we only check the existence of
    // the WLAN support in the feature manager. We might also want to check whether WLAN access points
    // have been configured.
    iIsWlanCoverage = wlanSupported;

    // Initialize call state observer.
    iCallStatusObserver = CRadioPropertyObserver::NewL( *this,
                                                        KPSUidCtsyCallInformation,
                                                        KCTsyCallState,
                                                        CRadioPropertyObserver::ERadioPropertyInt );
    iCallStatusObserver->ActivateL();
    iIsCallActive = iCallStatusObserver->ValueInt() != EPSCTsyCallStateNone;

#ifdef COMPILE_IN_IVALO
    // Initialize voice ui observer.
    iVoiceUiObserver = CRadioPropertyObserver::NewL( *this,
                                                     KPSUidVoiceUiAccMonitor,
                                                     KVoiceUiOpenKey,
                                                     CRadioPropertyObserver::ERadioPropertyInt );
    iVoiceUiObserver->ActivateL();
#endif //COMPILE_IN_IVALO

#ifndef __WINS__
    // Define audio types for not resuming.
    iNoAutoResumeAudioCategories = RArray<TInt>( KVRAudioCategoryArrayGranularity );
    iNoAutoResumeAudioCategories.AppendL( ECatMediaPlayer );
    iNoAutoResumeAudioCategories.AppendL( ECatMobileTv );
    iNoAutoResumeAudioCategories.AppendL( ECatUnknownPlayer );
    iNoAutoResumeAudioCategories.Compress();
    // Start listening audio client events.
    iAudioPolicyObserver = CRadioPropertyObserver::NewL( *this, KPSUidMMFAudioServer, KAudioPolicyAudioClients, CRadioPropertyObserver::ERadioPropertyByteArray );
    iAudioPolicyObserver->ActivateL();
#endif
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CRadioSystemEventDetector::~CRadioSystemEventDetector()
    {
    FeatureManager::UnInitializeLib();
    delete iCallStatusObserver;
    delete iNetworkStatusObserver;
    delete iVoiceUiObserver;
    delete iAudioPolicyObserver;

    iNoAutoResumeAudioCategories.Close();
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CRadioSystemEventDetector* CRadioSystemEventDetector::NewL( MRadioSystemEventDetectorObserver&  aObserver )
    {
    CRadioSystemEventDetector* self = new ( ELeave ) CRadioSystemEventDetector( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// Handling of the int property changes is done here.
// Observer components are getting notifications in correspondence with what
// has changed
// ---------------------------------------------------------------------------
//
void CRadioSystemEventDetector::HandlePropertyChangeL( const TUid& aCategory,
                                                       const TUint aKey,
                                                       const TInt aValue )
    {
    //TODO: Refactor
    if ( aCategory == KUidSystemCategory && aKey == KUidNetworkStatusValue )
        {
        switch ( aValue )
            {
            case ESANetworkAvailable:
                {
                SetNetworkCoverageL( ETrue, iIsWlanCoverage );
                break;
                }
            case ESANetworkUnAvailable:
                {
                SetNetworkCoverageL( EFalse, iIsWlanCoverage );
                break;
                }
            default:
                {
                break;
                }
            }
        }
    else if ( aCategory == KPSUidCtsyCallInformation && aKey == KCTsyCallState )
        {
        if ( (!iIsCallActive ) && ( aValue > EPSCTsyCallStateNone ))
            {
            iIsCallActive = ETrue;
            iObserver.CallActivatedCallbackL();
            }
        else if ( ( iIsCallActive ) && ( aValue <= EPSCTsyCallStateNone ))
            {
            iIsCallActive = EFalse;
            iObserver.CallDeactivatedCallbackL();
            }
        else
            {
            // No change
            }
        }
#ifdef COMPILE_IN_IVALO
    else if ( aCategory == KPSUidVoiceUiAccMonitor && aKey == KVoiceUiOpenKey )
        {
        switch ( aValue )
            {
            case KVoiceUiIsClose:
                {
                if ( iIsVoiceUiActive )
                    {
                    iIsVoiceUiActive = EFalse;
                    LOG( "Voice UI not active." );
                    if ( iIsAudioResourcesAvailable )
                        {
                        LOG( "Audio resources available. Change informed." );
                        iObserver.AudioResourcesAvailableL();
                        }
                    }
                break;
                }
            case KVoiceUiIsOpen:
                {
                if ( !iIsVoiceUiActive )
                    {
                    iIsVoiceUiActive = ETrue;
                    LOG( "Voice UI active." );
                    }
                break;
                }
            default:
                {
                break;
                }
            }
        }
#endif //COMPILE_IN_IVALO
    else // NOP
        {
        }
    }

#ifndef __WINS__
// ---------------------------------------------------------------------------
// Handling of the byte array property changes is done here.
// Observer components are getting notifications in correspondence with what
// has changed
// ---------------------------------------------------------------------------
//
void CRadioSystemEventDetector::HandlePropertyChangeL( const TUid& aCategory,
                                                       const TUint aKey,
                                                       const TDesC8& aValue )
    {
#if 0
    LOG_METHOD_AUTO;
    LOG_FORMAT( "Category: %d, Key: %d", aCategory, aKey );
    if ( aCategory == KPSUidMMFAudioServer )
        {
        if ( aKey == KAudioPolicyAudioClients )
            {
            TBool atLeastOneAutoResumeAudioPlaying( EFalse );
            TBool atLeastOneNoAutoResumeAudioPlaying( EFalse );
            TBool radioPlaying( EFalse );
            TAudioClientList audioClients;
            audioClients.Copy( aValue );
            // Check all playing audios!
            for ( TInt i = 0; i < audioClients().iNumOfProcesses ; i++ )
                {
                TInt cat = audioClients().iClientCategoryList[i];
                LOG_FORMAT( "Check audio cat %x", cat );
                if ( cat == ECatFmRadio )
                    {
                    radioPlaying = ETrue;
                    }
                else if ( iNoAutoResumeAudioCategories.Find( cat ) != KErrNotFound )
                    {
                    atLeastOneNoAutoResumeAudioPlaying = ETrue;
                    }
                else
                    {
                    atLeastOneAutoResumeAudioPlaying = ETrue;
                    }
                }

            if ( !radioPlaying )
                {
                // Decide audio resource availability from audio category info.
                if ( atLeastOneNoAutoResumeAudioPlaying )
                    {
                    LOG( "Audio resources not available. Change informed." );
                    iIsAudioResourcesAvailable = EFalse;
                    iObserver.AudioAutoResumeForbiddenL();
                    }
                else if ( !atLeastOneAutoResumeAudioPlaying )
                    {
                    if ( !iIsVoiceUiActive )
                        {
                        LOG( "Audio resources available. Change informed." );
                        iIsAudioResourcesAvailable = ETrue;
                        iObserver.AudioResourcesAvailableL();
                        }
                    else
                        {
                        LOG( "Audio resources available. Change not informed." );
                        iIsAudioResourcesAvailable = ETrue;
                        }
                    }
                else
                    {
                    LOG( "Audio resources not available. Change not informed." );
                    iIsAudioResourcesAvailable = EFalse;
                    }
                }
            else // audio resources are considered to be available when radio is playing
                {
                iIsAudioResourcesAvailable = ETrue;
                }
            }
        }
#endif
    }

#else //__WINS__
// ---------------------------------------------------------------------------
// Dummy version for WINS in order to avoid compiler warnings.
// The real implementation of function is above.
// ---------------------------------------------------------------------------
//
void CRadioSystemEventDetector::HandlePropertyChangeL( const TUid& /*aCategory*/,
                                                       const TUint /*aKey*/,
                                                        const TDesC8& /*aValue*/)
    {
    }
#endif

// ---------------------------------------------------------------------------
// Handling of the text property changes is done here.
// Observer components are getting notifications in correspondence with what
// has changed
// ---------------------------------------------------------------------------
//
void CRadioSystemEventDetector::HandlePropertyChangeL( const TUid& /*aCategory*/,
                                                       const TUint /*aKey*/,
                                                       const TDesC& /*aValue*/)
    {
    }

// ---------------------------------------------------------------------------
// This is a callback function which is called when a P&S components returns
// an error
// ---------------------------------------------------------------------------
//
void CRadioSystemEventDetector::HandlePropertyChangeErrorL( const TUid& aCategory,
                                                            const TUint aKey,
                                                            TInt aError )
    {
#ifdef COMPILE_IN_IVALO
    if ( aCategory == KPSUidVoiceUiAccMonitor && aKey == KVoiceUiOpenKey && aError == KErrNotFound )
        {
        HandlePropertyChangeL( KPSUidVoiceUiAccMonitor, KVoiceUiOpenKey, KVoiceUiIsClose );
        }
    else
        {
        iObserver.ErrorCallbackL( aError );
        }
#else
    (void)aCategory;
    (void)aKey;
    (void)aError;
#endif //COMPILE_IN_IVALO
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioSystemEventDetector::IsMobileNetworkCoverage() const
    {
    return iIsMobileNetworkCoverage;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioSystemEventDetector::IsNetworkCoverage() const
    {
    return iIsWlanCoverage || iIsMobileNetworkCoverage;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioSystemEventDetector::IsCallActive() const
    {
    return iIsCallActive;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioSystemEventDetector::IsAudioResourcesAvailable() const
    {
    return iIsAudioResourcesAvailable;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CRadioSystemEventDetector::IsVoiceUiActive() const
    {
    return iIsVoiceUiActive;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CRadioSystemEventDetector::SetNetworkCoverageL( const TBool aIsMobileNetworkCoverage,
                                                     const TBool aIsWlanCoverage )
    {
    LOG_FORMAT( "CRadioSystemEventDetector::SetNetworkCoverageL ( mobile = %d wlan = %d )", aIsMobileNetworkCoverage, aIsWlanCoverage );

    TBool wasCoverage = IsNetworkCoverage();
    iIsMobileNetworkCoverage = aIsMobileNetworkCoverage;
    iIsWlanCoverage = aIsWlanCoverage;
    TBool isCoverage = IsNetworkCoverage();

    if ( isCoverage != wasCoverage )
        {
        if ( isCoverage )
            {
            iObserver.NetworkUpCallbackL();
            }
        else
            {
            iObserver.NetworkDownCallbackL();
            }
        }
    }