/*
* Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 CWiFiProtDlgsPlugin.
*
*/
// INCLUDE FILES
#include <e32property.h> // For RProperty
#include <wifiprotuiddefs.h>
#include <bautils.h>
#include <eikenv.h>
#include <data_caging_path_literals.hrh>
#include "wifiprotdlgsplugin.h"
#include "wifiprotplugin.h"
#include "wifiprotlogger.h"
#include "wifiprotactiverunner.h"
using namespace WiFiProt;
// CONSTS
_LIT( KDriveZ, "z:" );
// ============================ MEMBER FUNCTIONS ============================
// --------------------------------------------------------------------------
// CWiFiProtDlgsPlugin* CWiFiProtDlgsPlugin::NewL()
// --------------------------------------------------------------------------
//
CWiFiProtDlgsPlugin* CWiFiProtDlgsPlugin::NewL(
const TBool aResourceFileResponsible,
RCmManagerExt* aCmManagerExt )
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::NewL" );
CWiFiProtDlgsPlugin* self = new ( ELeave ) CWiFiProtDlgsPlugin();
CleanupStack::PushL( self );
self->ConstructL( KResourceFileName,
aResourceFileResponsible, aCmManagerExt );
CleanupStack::Pop( self );
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::NewL" );
return self;
}
// --------------------------------------------------------------------------
// CWiFiProtDlgsPlugin* CWiFiProtDlgsPlugin::NewL()
// --------------------------------------------------------------------------
//
CWiFiProtDlgsPlugin* CWiFiProtDlgsPlugin::NewL(
const TBool aResourceFileResponsible )
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::NewL (without passed CmManager)" );
CWiFiProtDlgsPlugin* ret = NewL( aResourceFileResponsible, NULL );
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::NewL (without passed CmManager)" );
return ret;
}
// --------------------------------------------------------------------------
// CWiFiProtDlgsPlugin::~CWiFiProtDlgsPlugin
// --------------------------------------------------------------------------
//
CWiFiProtDlgsPlugin::~CWiFiProtDlgsPlugin( )
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::~CWiFiProtDlgsPlugin" );
delete iRunner;
//we didn't get a cmManager from the client, so use our own
if (iPassedCmManagerExt == NULL)
{
iCmManagerExt.Close();
}
iUids.Close();
if ( iResource )
{
CCoeEnv::Static()->DeleteResourceFile( iResource );
}
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::~CWiFiProtDlgsPlugin" );
}
// --------------------------------------------------------------------------
// CWiFiProtDlgsPlugin::TNotifierInfo
// CWiFiProtDlgsPlugin::Info() const
// --------------------------------------------------------------------------
//
CWiFiProtDlgsPlugin::TNotifierInfo CWiFiProtDlgsPlugin::Info() const
{
return iInfo;
}
// --------------------------------------------------------------------------
// TPtrC8 CWiFiProtDlgsPlugin::StartL()
// --------------------------------------------------------------------------
//
TPtrC8 CWiFiProtDlgsPlugin::StartL( const TDesC8& /*aBuffer*/ )
{
CLOG_WRITE( "CWiFiProtDlgsPlugin::StartL" );
return KNullDesC8().Ptr();
}
// --------------------------------------------------------------------------
// void CWiFiProtDlgsPlugin::Cancel()
// --------------------------------------------------------------------------
//
void CWiFiProtDlgsPlugin::Cancel()
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::Cancel" );
if ( !iCancelled )
{
if ( iRunner && !iCancelledFromInside )
{
iClientCancelled = ETrue;
iRunner->CancelByClient();
}
iCancelled = ETrue;
if ( !iMessage.IsNull() )
{
if ( iConnMode )
{
TRAP_IGNORE( iMessage.WriteL( iReplySlot,
TPckg<WiFiProt::TWiFiConnOutputParams>(
TWlanProtectedSetupCredentialAttribute() )
));
}
else
{
TRAP_IGNORE( iMessage.WriteL( iReplySlot,
TPckg<WiFiProt::TWiFiOutputParams>( KNullDesC8() )
));
}
iMessage.Complete( KErrCancel );
}
}
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::Cancel" );
}
// --------------------------------------------------------------------------
// void CWiFiProtDlgsPlugin::Release()
// --------------------------------------------------------------------------
//
void CWiFiProtDlgsPlugin::Release()
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::Release" );
delete this;
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::Release" );
}
// --------------------------------------------------------------------------
// TPtrC8 CWiFiProtDlgsPlugin::UpdateL()
// --------------------------------------------------------------------------
//
TPtrC8 CWiFiProtDlgsPlugin::UpdateL(const TDesC8& /*aBuffer*/)
{
return KNullDesC8().Ptr();
}
// --------------------------------------------------------------------------
// void CWiFiProtDlgsPlugin::CompleteL()
// --------------------------------------------------------------------------
//
void CWiFiProtDlgsPlugin::CompleteL( TInt aStatus )
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::CompleteL" );
CLOG_WRITEF( _L( "aStatus:" ), aStatus );
iCancelled = ETrue;
if ( !iMessage.IsNull() )
{
if ( iConnMode )
{
// return a different kind of message
// for connection creation
WiFiProt::TWiFiConnOutputParams connOutputParams =
WiFiProt::TWiFiConnOutputParams( iNetworkSettings );
connOutputParams.iReturn = iReturn;
iMessage.WriteL( iReplySlot,
TPckg<WiFiProt::TWiFiConnOutputParams>( connOutputParams ) );
}
else
{
// ... or iap(s) creation
const TInt elementSize = sizeof(TUint32);
TBuf8<(KMaxNumberOfUids * elementSize)> buf;
TInt uidsCount = iUids.Count();
if ( uidsCount > KMaxNumberOfUids )
{
uidsCount = KMaxNumberOfUids;
}
// copy data from the array to iIapIds in TWiFiOutputParams
buf.Append((const TUint8 *)(&iUids[0]), uidsCount *elementSize);
//append return value
WiFiProt::TWiFiOutputParams outputParams =
WiFiProt::TWiFiOutputParams(buf);
outputParams.iReturn = iReturn;
iMessage.WriteL( iReplySlot,
TPckg<WiFiProt::TWiFiOutputParams>( outputParams ) );
}
iMessage.Complete( aStatus );
}
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::CompleteL" );
}
// --------------------------------------------------------------------------
// CWiFiProtDlgsPlugin::SetCancelledFlag
// --------------------------------------------------------------------------
//
void CWiFiProtDlgsPlugin::SetCancelledFlag( TBool aCancelled )
{
iCancelled = aCancelled;
}
// --------------------------------------------------------------------------
// CWiFiProtDlgsPlugin::TNotifierInfo CWiFiProtDlgsPlugin::RegisterL()
// --------------------------------------------------------------------------
//
CWiFiProtDlgsPlugin::TNotifierInfo CWiFiProtDlgsPlugin::RegisterL()
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::RegisterL" );
iInfo.iUid = KUidWiFiProtSetup;
iInfo.iPriority = ENotifierPriorityHigh;
iInfo.iChannel = KUidWiFiProtSetup;
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::RegisterL" );
return iInfo;
}
// --------------------------------------------------------------------------
// void CWiFiProtDlgsPlugin::StartL
// --------------------------------------------------------------------------
//
void CWiFiProtDlgsPlugin::StartL( const TDesC8& aBuffer,
TInt aReplySlot,
const RMessagePtr2& aMessage )
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::StartL" );
TPckgBuf<TWiFiInputParams> pckgParams(
TPckgBuf<TWiFiInputParams>(TWiFiInputParams(KNullDesC8(),
EFalse)));
pckgParams.Copy( *((TPckgBuf<TWiFiInputParams>*) (&aBuffer)));
TWiFiInputParams params((pckgParams)());
iConnMode = params.iConnectionNeeded;
TWlanSsid ssid;
ssid.Copy( params.iSSid );
iCancelled = EFalse;
iReplySlot = aReplySlot;
iMessage = aMessage;
if ( iConnMode )
{
// no need for uid array to return, but we need a single network
// settings struct
iRunner->StartProtectedSetupConnL( ssid, iNetworkSettings,
CmManagerToUse());
}
else
{
iRunner->StartProtectedSetupAsyncL( ssid, iUids, CmManagerToUse() );
}
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::StartL" );
}
// --------------------------------------------------------------------------
// WiFiProt::TWiFiReturn CWiFiProtDlgsPlugin::CompleteProcessL
// --------------------------------------------------------------------------
//
void CWiFiProtDlgsPlugin::CompleteProcessL( WiFiProt::TWiFiReturn aReturnValue )
{
CLOG_ENTERFN( "WiFiProtDlgsPlugin::CompleteProcessL" );
iReturn = aReturnValue;
switch ( aReturnValue )
{
case EWiFiOK:
{
CLOG_WRITE("StartProtectedSetupL returned EWiFiOK");
CompleteL( KErrNone );
break;
}
case EWifiNoAuto:
{
CLOG_WRITE("StartProtectedSetupL returned EWifiNoAuto");
CompleteL( KErrNone );
break;
}
case EWiFiCancel:
{
CLOG_WRITE("StartProtectedSetupL returned EWiFiCancel");
iCancelledFromInside = ETrue;
Cancel();
break;
}
default:
{
//should never happen
CLOG_WRITE("Unhandled exit value, leaving...");
User::Leave( KErrGeneral );
break;
}
}
CLOG_WRITEF( _L( "Uids returned:" ), iUids.Count() );
for ( TInt i = 0;i<iUids.Count();i++ )
{
CLOG_WRITEF( _L( "Uid:" ), iUids[i] );
}
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::CompleteProcessL" );
}
// --------------------------------------------------------------------------
// WiFiProt::TWiFiReturn CWiFiProtDlgsPlugin::StartFromUiL
// --------------------------------------------------------------------------
//
WiFiProt::TWiFiReturn CWiFiProtDlgsPlugin::StartFromUiL(
const TWlanSsid& aSSid,
TBool aConnectionNeeded,
RArray<TUint32>& aUidsReturned)
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::StartFromUiL" );
CLOG_WRITE("Input params:");
CLOG_WRITE("SSid:");
TBuf<KWlanMaxSsidLength> buf;
buf.Copy(aSSid);
CLOG_WRITEF( buf );
CLOG_WRITE("Connection needed:");
if ( aConnectionNeeded )
{
CLOG_WRITE("ETrue");
}
else
{
CLOG_WRITE("EFalse");
}
//use passed CmManager if present
WiFiProt::TWiFiReturn ret = iRunner->StartProtectedSetupL(
aSSid, aUidsReturned, CmManagerToUse());
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::StartFromUiL" );
return ret;
}
// --------------------------------------------------------------------------
// void CWiFiProtDlgsPlugin::CmManagerToUse()
// --------------------------------------------------------------------------
//
RCmManagerExt& CWiFiProtDlgsPlugin::CmManagerToUse()
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::CmManagerToUse" );
if (iPassedCmManagerExt == NULL )
{
CLOG_WRITE("Own CmManagerExt used");
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::CmManagerToUse" );
return iCmManagerExt;
}
else
{
CLOG_WRITE("Passed CmManagerExt used");
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::CmManagerToUse" );
return *iPassedCmManagerExt;
}
}
// --------------------------------------------------------------------------
// CWiFiProtDlgsPlugin::CWiFiProtDlgsPlugin()
// --------------------------------------------------------------------------
//
CWiFiProtDlgsPlugin::CWiFiProtDlgsPlugin()
: iCancelled( EFalse ),
iResource( 0 ),
iCancelledFromInside( EFalse )
{
CLOG_WRITE("CWiFiProtDlgsPlugin::CWiFiProtDlgsPlugin");
}
// --------------------------------------------------------------------------
// void CWiFiProtDlgsPlugin::ConstructL( )
// --------------------------------------------------------------------------
//
void CWiFiProtDlgsPlugin::ConstructL(const TDesC& aResourceFileName,
const TBool aResourceFileResponsible,
RCmManagerExt* aCmManagerExt )
{
CLOG_ENTERFN( "CWiFiProtDlgsPlugin::ConstructL" );
if ( aResourceFileResponsible )
{
// Since this is a .DLL, resource files that are to be used by the
// notifier aren't added automatically so we do that here.
TFileName fileName;
fileName.Append( KDriveZ );
fileName.Append( KDC_RESOURCE_FILES_DIR );
fileName.Append( aResourceFileName );
BaflUtils::NearestLanguageFile( CCoeEnv::Static()->FsSession(),
fileName );
iResource = CCoeEnv::Static()->AddResourceFileL( fileName );
}
iPassedCmManagerExt = aCmManagerExt;
//we didn't get a cmManager from the client, so use our own
if (iPassedCmManagerExt == NULL)
{
iCmManagerExt.OpenL();
}
iRunner = CWiFiProtActiveRunner::NewL( this );
CLOG_LEAVEFN( "CWiFiProtDlgsPlugin::ConstructL" );
}
// End of File