/*
* Copyright (c) 2007-2007 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: Implementation of CWsfWlanInfoArray
*
*/
// EXTERNAL INCLUDES
#include <s32mem.h>
// CLASS HEADER
#include "wsfwlaninfoarray.h"
// INTERNAL INCLUDES
#include "wsfwlaninfoarraysortkey.h"
#include "wsfwlaninfoarrayfiltervisitor.h"
using namespace CMManager;
// LOCAL DEFINITIONS
static const TUint KInfoArrayGranuality = 10;
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::NewL
// ---------------------------------------------------------------------------
//
EXPORT_C CWsfWlanInfoArray* CWsfWlanInfoArray::NewL()
{
CWsfWlanInfoArray* thisPtr = NewLC();
CleanupStack::Pop( thisPtr );
return thisPtr;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::NewLC
// ---------------------------------------------------------------------------
//
EXPORT_C CWsfWlanInfoArray* CWsfWlanInfoArray::NewLC()
{
CWsfWlanInfoArray* thisPtr = new ( ELeave ) CWsfWlanInfoArray();
CleanupStack::PushL( thisPtr );
thisPtr->ConstructL();
return thisPtr;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::~CWsfWlanInfoArray
// ---------------------------------------------------------------------------
//
CWsfWlanInfoArray::~CWsfWlanInfoArray()
{
if ( iInfoArray )
{
iInfoArray->ResetAndDestroy();
delete iInfoArray;
}
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::CWsfWlanInfoArray
// ---------------------------------------------------------------------------
//
CWsfWlanInfoArray::CWsfWlanInfoArray() :
iUIPrioritySort( EFalse )
{
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::ConstructL
// ---------------------------------------------------------------------------
//
void CWsfWlanInfoArray::ConstructL()
{
iInfoArray = new (ELeave) CArrayPtrFlat<TWsfWlanInfo>(
KInfoArrayGranuality );
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::Reset
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::Reset()
{
iInfoArray->ResetAndDestroy();
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::Count
// ---------------------------------------------------------------------------
//
EXPORT_C TUint CWsfWlanInfoArray::Count()
{
return iInfoArray->Count();
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::AppendL
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::AppendL( TWsfWlanInfo* aWlanInfo )
{
iInfoArray->AppendL( aWlanInfo );
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::At
// ---------------------------------------------------------------------------
//
EXPORT_C TWsfWlanInfo* CWsfWlanInfoArray::At( TInt aIndex ) const
{
TWsfWlanInfo* temp( NULL );
TInt count = iInfoArray->Count();
if ( count && ( aIndex < count ) )
{
temp = ( *iInfoArray )[aIndex];
}
return temp;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::Delete
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::Delete( TWsfWlanInfo* aWlanInfo )
{
TInt count = iInfoArray->Count();
for( TInt i = 0; i < count; ++i )
{
if ( ( *iInfoArray )[i] == aWlanInfo )
{
delete ( *iInfoArray )[i];
iInfoArray->Delete( i );
iInfoArray->Compress();
break;
}
}
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::GetArrayIndex
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CWsfWlanInfoArray::GetArrayIndex( TWsfWlanInfo* aWlanInfo ) const
{
TBool found( EFalse );
TInt index( 0 );
TWsfWlanInfo* temp;
TInt count = iInfoArray->Count();
while( ( index < count ) && !found )
{
temp = ( *iInfoArray )[index];
if ( !temp->iSsid.Compare( aWlanInfo->iSsid ) )
{
found = ETrue;
}
else
{
++index;
}
}
return ( found ? index : KErrNotFound );
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::operator[]
// ---------------------------------------------------------------------------
//
EXPORT_C TWsfWlanInfo* CWsfWlanInfoArray::operator[]( TUint aIndex ) const
{
return ( *iInfoArray )[aIndex];
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::Match
// ---------------------------------------------------------------------------
//
EXPORT_C TWsfWlanInfo* CWsfWlanInfoArray::Match( const TDesC8& aSsid,
const TInt aPriorThis )
{
TInt count = iInfoArray->Count();
TWsfWlanInfo* ret( NULL );
count = count < aPriorThis ? count: aPriorThis;
for( TInt i = 0; i < count; i++ )
{
TWsfWlanInfo* temp = ( *iInfoArray )[i];
if ( !temp->iSsid.Compare( aSsid ) )
{
ret = temp;
break;
}
}
return ret;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::Match
// ---------------------------------------------------------------------------
//
EXPORT_C TWsfWlanInfo* CWsfWlanInfoArray::Match( const TUint32 aIapID,
const TInt aPriorThis )
{
TInt count = iInfoArray->Count();
TWsfWlanInfo* ret( NULL );
count = count < aPriorThis ? count: aPriorThis;
for( TInt i = 0; i < count; i++ )
{
TWsfWlanInfo* temp = ( *iInfoArray )[i];
if ( temp->iIapId == aIapID )
{
ret = temp;
break;
}
}
return ret;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::MatchWithIapIDL
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::MatchWithIapIDL( const TUint aIapID,
const TInt aPriorThis,
RPointerArray<TWsfWlanInfo>& aMatchArray )
{
aMatchArray.Reset();
TInt count = iInfoArray->Count();
TWsfWlanInfo* temp(NULL);
count = count < aPriorThis ? count: aPriorThis;
for( TInt i = 0; i < count ; i++ )
{
temp = ( *iInfoArray )[i];
if( temp->iIapId == aIapID )
{
aMatchArray.AppendL(temp);
}
}
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::MatchL
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::MatchL( const TDesC8& aSsid,
CMManager::TWlanSecMode aSecMode,
CMManager::TWlanNetMode aNetMode,
TBool aUsesPreSharedKey,
const TInt aPriorThis,
RPointerArray<TWsfWlanInfo>& aMatchArray )
{
aMatchArray.Reset();
TInt count = iInfoArray->Count();
TWsfWlanInfo* temp(NULL);
count = count < aPriorThis ? count: aPriorThis;
for( TInt i = 0; i < count ; i++ )
{
temp = ( *iInfoArray )[i];
if( !temp->iSsid.Compare( aSsid ) && temp->iSecurityMode == aSecMode
&& temp->iNetMode == aNetMode )
{
aMatchArray.AppendL(temp);
}
else if ( temp->iIapId && !temp->iSsid.Compare( aSsid )
&& temp->SecurityMode() == CMManager::EWlanSecMode802_1x
&& temp->iNetMode == aNetMode )
{
if ( aSecMode == CMManager::EWlanSecModeOpen )
{
aMatchArray.AppendL(temp);
}
else if ( aSecMode == CMManager::EWlanSecModeWep )
{
aMatchArray.AppendL(temp);
}
else if ( aSecMode == CMManager::EWlanSecModeWpa
&& !aUsesPreSharedKey )
{
aMatchArray.AppendL(temp);
}
else if ( aSecMode == CMManager::EWlanSecMode802_1x )
{
aMatchArray.AppendL(temp);
}
}
}
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::SerializeContentLC
// ---------------------------------------------------------------------------
//
EXPORT_C HBufC8* CWsfWlanInfoArray::SerializeContentLC()
{
HBufC8* buffer( NULL );
if ( !iInfoArray->Count() )
{
buffer = KNullDesC8().AllocLC();
}
else
{
TInt32 requiredBufferSize = sizeof( TUint32 ) +
iInfoArray->Count() * sizeof( TWsfWlanInfo );
buffer = HBufC8::NewLC( requiredBufferSize );
// create a stream..
TPtr8 bufferPtr = buffer->Des();
RDesWriteStream writeStream( bufferPtr );
writeStream.Open( bufferPtr);
CleanupClosePushL( writeStream );
writeStream.WriteInt16L( iInfoArray->Count() );
TWsfWlanInfo* infoPtr = NULL;
for ( TInt i( 0 ); i < iInfoArray->Count(); i++)
{
infoPtr = ( *iInfoArray )[i];
writeStream << *infoPtr;
}
writeStream.CommitL();
// try to realloc - save space realloc to required level..
TStreamPos position = writeStream.Sink()->TellL( MStreamBuf::EWrite );
CleanupStack::PopAndDestroy( &writeStream ); // closes the stream
CleanupStack::Pop( buffer );
HBufC8* newBuffer = buffer->ReAlloc( position.Offset() );
if ( newBuffer ) // the realloc succeeded - swap the buffer
{
buffer = newBuffer;
}
CleanupStack::PushL( buffer);
}
return buffer;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::AppendFromStreamBufferL
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CWsfWlanInfoArray::AppendFromStreamBufferL(
const TDesC8& aStreamBuffer )
{
RDesReadStream reader( aStreamBuffer );
reader.Open( aStreamBuffer ); // codescanner false alarm
// ignoring Open() return value.. Open returns void
CleanupClosePushL( reader );
TInt infoCount = reader.ReadInt16L();
TWsfWlanInfo *infoPtr = NULL;
for ( TInt i(0); i < infoCount; i++ )
{
infoPtr = new (ELeave)TWsfWlanInfo;
CleanupStack::PushL( infoPtr );
reader >> *infoPtr;
AppendL( infoPtr );
CleanupStack::Pop( infoPtr );
}
CleanupStack::PopAndDestroy( &reader );
return Count();
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::FindHiddenEntry
// ---------------------------------------------------------------------------
//
EXPORT_C TWsfWlanInfo* CWsfWlanInfoArray::FindHiddenEntry(
const TInt aPriorThis )
{
TInt count = iInfoArray->Count();
TWsfWlanInfo* ret( NULL );
count = count < aPriorThis ? count : aPriorThis;
for ( TInt i = 0; i < count; ++i )
{
TWsfWlanInfo* temp = ( *iInfoArray )[i];
if ( !temp->iVisibility )
{
ret = temp;
break;
}
}
return ret;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::DeleteFromTail
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CWsfWlanInfoArray::DeleteFromTail( const TInt aCount )
{
TInt arrayItemCount = iInfoArray->Count();
if ( aCount >= arrayItemCount )
{
iInfoArray->ResetAndDestroy();
}
else
{
--arrayItemCount;
for ( TInt i( 1 ) ; i <= aCount; ++i, --arrayItemCount )
{
delete ( *iInfoArray )[arrayItemCount];
iInfoArray->Delete( arrayItemCount );
}
iInfoArray->Compress();
}
return iInfoArray->Count();
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::SortArrayL
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::SortArrayL()
{
if ( iInfoArray->Count() > 1 )
{
CWsfWlanInfoArraySortKey* sortKey = CWsfWlanInfoArraySortKey::NewLC(
*this );
// Sort returns KErrGeneral if stack overflow, otherwise, returns
// KErrNone. So we will Leave only if stack overflow,
// but than that really does not matter...
User::LeaveIfError( iInfoArray->Sort( *sortKey ) );
CleanupStack::PopAndDestroy( sortKey );
}
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::SortArrayL
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::SortArrayL(
MWsfWlanInfoArrayFilterVisitor& aSortKey )
{
// the visitor sortkey may do some other stuff too
// so don't make any asumptions...
// just go for the sorting...
aSortKey.FilterPreSortL( this );
User::LeaveIfError( iInfoArray->Sort( aSortKey.SortingKey() ) );
aSortKey.FilterPostSortL( this );
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::SetUIPrioritySort
// ---------------------------------------------------------------------------
//
EXPORT_C void CWsfWlanInfoArray::SetUIPrioritySort( const TBool aUIPrioritySort )
{
iUIPrioritySort = aUIPrioritySort;
}
// ---------------------------------------------------------------------------
// CWsfWlanInfoArray::GetUIPrioritySort
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CWsfWlanInfoArray::GetUIPrioritySort( )
{
return iUIPrioritySort;
}