// Copyright (c) 2010 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 "btmpagescanparametersmanager.h"

#include <ctsydomainpskeys.h>

#include <bt_subscribe.h>

#include <bt_subscribe_partner.h>

#include <bttypespartner.h>

#include "debug.h"

// in the current configuration an incoming call ringing limit is 30 seconds

// if for some reason we don't receive the call state change

// we disable fast connection page scan settings in 35 seconds

const TInt KFastConnectionTime              = 35000000;

// a timeout for resetting page scan settings

// if we don't receive a confirmation we try to reset again

const TInt KRestoreStandardParametersTime   = 1000000;

const TInt KCallStateListenerService            = 8;

const TInt KPageScanParametersListenerService   = 9;

const TInt KFastConnectionService               = 10;

const TInt KRestoreStandardParametersService    = 11;

CBtmPageScanParametersManager::CBtmPageScanParametersManager()

    :  iIsBeingDeactivated(EFalse)

    {

    }

CBtmPageScanParametersManager::~CBtmPageScanParametersManager()

    {

    TRACE_FUNC_ENTRY

    delete iTimerActive;

    iTimer.Close();

    if (iCallStateKey.Handle())

        {

        iCallStateKey.Cancel();

        }

    delete iPageScanParametersListener;

    iCallStateKey.Close();

    if (iPageScanParametersKey.Handle())

        {

        iPageScanParametersKey.Cancel();

        }

    delete iCallStateListener;

    iPageScanParametersKey.Close();

    TRACE_FUNC_EXIT

    }

void CBtmPageScanParametersManager::ConstructL()

    {

    TRACE_FUNC_ENTRY

    LEAVE_IF_ERROR(iCallStateKey.Attach(KPSUidCtsyCallInformation, KCTsyCallState));

    iCallStateListener = CBtmActive::NewL(*this, CActive::EPriorityStandard,

                                          KCallStateListenerService);

    LEAVE_IF_ERROR(iPageScanParametersKey.Attach(KPropertyUidBluetoothCategory,

                                                 KPropertyKeyBluetoothGetPageScanParameters));

    iPageScanParametersListener = CBtmActive::NewL(*this, CActive::EPriorityStandard,

                                                   KPageScanParametersListenerService);

    iTimerActive = CBtmActive::NewL(*this, CActive::EPriorityStandard, KFastConnectionService);

    TRACE_FUNC_EXIT

    }

CBtmPageScanParametersManager* CBtmPageScanParametersManager::NewL()

    {

    TRACE_STATIC_FUNC_ENTRY

    CBtmPageScanParametersManager* self = new( ELeave ) CBtmPageScanParametersManager();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CBtmPageScanParametersManager::StartTimer(TInt aService, TInt aTimeout)

    {

    if (!iTimerActive->IsActive())

        {

        TRACE_FUNC_ENTRY

        iTimer.CreateLocal();

        iTimer.After(iTimerActive->iStatus, aTimeout);

        iTimerActive->SetRequestId(aService);

        iTimerActive->GoActive();

        TRACE_FUNC_EXIT

        }

    else

        {

        TRACE_WARNING(_L("WARNING, page scan manager timer is already active"))

        }

    }

void CBtmPageScanParametersManager::StopTimer()

    {

    if (iTimerActive->IsActive())

        {

        TRACE_FUNC_ENTRY

        iTimerActive->Cancel();

        iTimer.Close();

        TRACE_FUNC_EXIT

        }

    }

void CBtmPageScanParametersManager::RequestCompletedL(CBtmActive& aActive)

    {

    TRACE_FUNC_ENTRY

    TRACE_INFO((_L("request id %d status %d"), aActive.RequestId(), aActive.iStatus.Int()))

    if (aActive.iStatus.Int() == KErrNone)

        {

        switch (aActive.RequestId())

            {

            case KCallStateListenerService:

                {

                iCallStateKey.Subscribe(aActive.iStatus);

                aActive.GoActive();

                TInt callState;

                TInt ret = iCallStateKey.Get(callState);

                if (ret == KErrNone)

                    {

                    TRACE_INFO((_L("call state received %d"), callState))

                    if (callState == EPSCTsyCallStateRinging)

                        {

                        // an incoming call ringing => switch to fast page scanning

                        TRACE_INFO((_L("switching to fast page scanning")))

                        (void) RProperty::Set(KPropertyUidBluetoothCategory,

                                              KPropertyKeyBluetoothSetPageScanParameters,

                                              EFastConnectionPageScanParameters);

                        // we will disable fast page scanning when the timer gets expired

                        StartTimer(KFastConnectionService, KFastConnectionTime);

                        }

                    else if (iTimerActive->IsActive() && iTimerActive->RequestId() == KFastConnectionService)

                        {

                        // the incoming call is not ringing anymore => switch to standard page scanning

                        TRACE_INFO((_L("switching to standard page scanning")))

                        DisableFastConnection();

                        }

                    }

                break;

                }

            case KPageScanParametersListenerService:

                {

                iPageScanParametersKey.Subscribe(aActive.iStatus);

                aActive.GoActive();

                TInt pageScanParameters;

                TInt ret = iPageScanParametersKey.Get(pageScanParameters);

                if (ret == KErrNone)

                    {

                    TRACE_INFO((_L("page scan parameters received %d"), pageScanParameters))

                    if (iTimerActive->IsActive() && iTimerActive->RequestId() == KRestoreStandardParametersService

                        && pageScanParameters == EStandardPageScanParameters)

                        {

                        TRACE_INFO((_L("standard page scan parameters enabled")))

                        StopTimer();

                        if (iIsBeingDeactivated)

                            {

                            TRACE_INFO((_L("page scan parameters service is stopped")))

                            iPageScanParametersKey.Cancel();

                            }

                        }

                    }

                break;

                }

            case KFastConnectionService:

            case KRestoreStandardParametersService:

                {

                // try to reset the page scan setting because it hasn't been confirmed yet

                TRACE_INFO((_L("timer expired, switching to standard page scanning")))

                DisableFastConnection();

                break;

                }

            default:

                {

                TRACE_WARNING(_L("WARNING, unknown service"))

                break;

                }

            }

        }

    TRACE_FUNC_EXIT

    }

void CBtmPageScanParametersManager::CancelRequest(CBtmActive& aActive)

    {

    TRACE_FUNC_ENTRY

    switch (aActive.RequestId())

        {

        case KFastConnectionService:

        case KRestoreStandardParametersService:

            {

            iTimer.Cancel();

            break;

            }

        default:

            break;

        }

    TRACE_FUNC_EXIT

    }

void CBtmPageScanParametersManager::DisableFastConnection()

    {

    TRACE_FUNC_ENTRY

    StopTimer();

    // switch to standard page scanning

    (void) RProperty::Set(KPropertyUidBluetoothCategory,

                          KPropertyKeyBluetoothSetPageScanParameters,

                          EStandardPageScanParameters);

    // we will disable fast page scanning when the timer gets expired

    StartTimer(KRestoreStandardParametersService, KRestoreStandardParametersTime);

    TRACE_FUNC_EXIT

    }

void CBtmPageScanParametersManager::Activate()

    {

    TRACE_FUNC_ENTRY

    iIsBeingDeactivated = EFalse;

    if (!iCallStateListener->IsActive())

        {

        iCallStateKey.Subscribe(iCallStateListener->iStatus);

        iCallStateListener->GoActive();

        }

    else

        {

        TRACE_WARNING(_L("WARNING, call state is already being listened"))

        }

    if (!iPageScanParametersListener->IsActive())

        {

        iPageScanParametersKey.Subscribe(iPageScanParametersListener->iStatus);

        iPageScanParametersListener->GoActive();

        }

    else

        {

        TRACE_WARNING(_L("WARNING, call state is already being listened"))

        }

    TInt callState;

    TInt err = RProperty::Get(KPSUidCtsyCallInformation, KCTsyCallState, callState);

    if(err == KErrNone && callState == EPSCTsyCallStateRinging)

        {

        // an incoming call already ringing => switch to fast page scanning

        TRACE_INFO((_L("call is already ringing, switching to fast page scanning")))

        (void) RProperty::Set(KPropertyUidBluetoothCategory,

                              KPropertyKeyBluetoothSetPageScanParameters,

                              EFastConnectionPageScanParameters);

        // we will disable fast page scanning when the timer gets expired

        StartTimer(KFastConnectionService, KFastConnectionTime);

        }

    TRACE_FUNC_EXIT

    }

void CBtmPageScanParametersManager::Deactivate()

    {

    TRACE_FUNC_ENTRY

    iIsBeingDeactivated = ETrue;

    // stop call state listening

    iCallStateKey.Cancel();

    if (iTimerActive->IsActive())

        {

        // if fast page scanning is active, disable it

        // if we're already switching to standard page scanning, do nothing

        if (iTimerActive->RequestId() == KFastConnectionService)

            {

            TRACE_INFO((_L("deactivation started, switching to standard page scanning")))

            DisableFastConnection();

            }

        }

    else

        {

        // if no timer is active we just stop page scan parameters listening

        iPageScanParametersKey.Cancel();

        }

    TRACE_FUNC_EXIT

    }