examples/ForumNokia/ThreadAndActiveObjectsEx/src/bluetoothrefreshtimer.cpp

/*
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
 *    
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *    
 *  * Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *  * Neither the name of Nokia Corporation nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *    
 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 *    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 *    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 *    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 *    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *    
 *    Description:  
 */


// INCLUDES
#include <e32base.h> 
#include "aknnotewrappers.h"
#include "../inc/BluetoothRefreshTimer.h"
#include "btdiscoverer.h"
#include "DeviceListContainer.h"

// a second
const TInt KThreadSecond = 1000 * 1000;

_LIT( refreshDevices, "refreshing devices..." );

// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::CBluetoothRefreshTimer()
//
// Constructor.
// ----------------------------------------------------------------------------
CBluetoothRefreshTimer::CBluetoothRefreshTimer(
         CSharedIntermediator* aSMediator,
         CActiveSchedulerWait* aWait)
             : CTimer(CActive::EPriorityStandard),
               iWait(aWait), iSMediator(aSMediator), 
           iBTDiscoverer(NULL), iRefreshTime(0), iTime(0)  
        {
        iSMediator->SetBTRefreshTimerPtr(this);
        }

// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::~CBluetoothRefreshTimer()
//
// Destructor.
// ----------------------------------------------------------------------------
CBluetoothRefreshTimer::~CBluetoothRefreshTimer()
        {
        Cancel();
        delete iBTDiscoverer;
        }


CBluetoothRefreshTimer* CBluetoothRefreshTimer::NewL(
     CSharedIntermediator* aSMediator, CActiveSchedulerWait* aWait)
        {
        CBluetoothRefreshTimer* self = CBluetoothRefreshTimer::NewLC(
                                                            aSMediator, aWait );
        CleanupStack::Pop(self);
        return self;
        }

CBluetoothRefreshTimer* CBluetoothRefreshTimer::NewLC(
    CSharedIntermediator* aSMediator, CActiveSchedulerWait* aWait)
        {
        CBluetoothRefreshTimer* self = new (ELeave) CBluetoothRefreshTimer(
                                                             aSMediator, aWait );
        CleanupStack::PushL(self);
        self->ConstructL();
        return self;
        }

// Standard Symbian OS 2nd phase constructor
void CBluetoothRefreshTimer::ConstructL()
        {
        CTimer::ConstructL();
   
        iBTDiscoverer = CBTDiscoverer::NewL(iSMediator);
        }

// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::StartL()
//
// Start discovering.
// ----------------------------------------------------------------------------
void CBluetoothRefreshTimer::StartL()
        {
        iRefreshTime = KThreadSecond*iSMediator->RefreshTimerInitlVal();

        iBTDiscoverer->StartDiscoveringDevicesL();
        After( KThreadSecond );
        }

// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::StopWaitLoop()
//
// Cancel active scheduler wait loop and cancel bluetooth discoverer.
// ----------------------------------------------------------------------------
void CBluetoothRefreshTimer::StopWaitLoop()
        {
        iBTDiscoverer->DoCancel();
        Cancel();
        iWait->AsyncStop();     
        }       

// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::RunL()
//
// ----------------------------------------------------------------------------
void CBluetoothRefreshTimer::RunL()
        {
        // Is it time to refresh yet
        if ( iTime >= iRefreshTime ) 
                {
                CDeviceListContainer* container = iSMediator->DeviceListContainer();
        
                container->ClearListBox();
                container->AddItemL( refreshDevices );

                // Clear also shared intermediator
                iSMediator->ResetArray();

                // Find bluetooth devices again
                iBTDiscoverer->RefreshDevices();
                
                iTime = 0;
                }

        // Stop seaching for bt devices
        if (iSMediator->StopSearching())
                {
                // Stop Active Scheduler wait loop
                StopWaitLoop();
                }

        // Wait for a while and run the same function again 
        iTime+=KThreadSecond;
        After( KThreadSecond );
        }

// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::DoCancel()
//
// Cancel and stop the timer. 
// ----------------------------------------------------------------------------
void CBluetoothRefreshTimer::DoCancel() 
        {
        CTimer::DoCancel();
        }

// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::SetRefreshTime(TInt aRefreshTime)
//
// Set a new refresh time. Convert time to microseconds.
// ----------------------------------------------------------------------------
void CBluetoothRefreshTimer::SetRefreshTime(TInt aRefreshTime)
        {
        
        if ( aRefreshTime < KRefreshTimeMin )
                {
                aRefreshTime = KRefreshTimeDefault;
                }

        // Convert to microseconds
        iRefreshTime = aRefreshTime * KThreadSecond;
        }
// ----------------------------------------------------------------------------
// CBluetoothRefreshTimer::RunError(TInt)
//
// Handles a leave occurring in the request completion event handler RunL().
// ----------------------------------------------------------------------------
TInt CBluetoothRefreshTimer::RunError(TInt)
        {
        return KErrNone;
        }

---