diff -r a0ea99b6fa53 -r 19bd632b5100 bluetoothengine/btmac/src/btmac/btmpagescanparametersmanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bluetoothengine/btmac/src/btmac/btmpagescanparametersmanager.cpp	Fri May 28 17:03:06 2010 +0300
@@ -0,0 +1,295 @@
+// 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
+    }