wlan_bearer/wlanengine/wlan_symbian/wlanengine_symbian_3.1/inc/wlanmgmtimpl.h
branchRCL_3
changeset 14 13838cf40350
parent 3 6524e815f76f
child 17 a828660c511c
equal deleted inserted replaced
12:af3fb27c7511 14:13838cf40350
    14 * Description:  ECom interface implementation definition
    14 * Description:  ECom interface implementation definition
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 /*
    18 /*
    19 * %version: 21 %
    19 * %version: 21.1.1 %
    20 */
    20 */
    21 
    21 
    22 #ifndef WLANMGMTIMPL_H
    22 #ifndef WLANMGMTIMPL_H
    23 #define WLANMGMTIMPL_H
    23 #define WLANMGMTIMPL_H
    24 
    24 
   373          */
   373          */
   374         virtual TInt GetExtendedConnectionSecurityMode(
   374         virtual TInt GetExtendedConnectionSecurityMode(
   375             TWlanConnectionExtentedSecurityMode& aMode );        
   375             TWlanConnectionExtentedSecurityMode& aMode );        
   376 
   376 
   377         /**
   377         /**
       
   378          * (From MWlanMgmtInterface)
   378          * Activate the extended notification service.
   379          * Activate the extended notification service.
   379          * 
   380          * 
   380          * After the client has enabled the notification service, it can
   381          * After the client has enabled the notification service, it can
   381          * receive asynchronous notifications from the server.
   382          * receive asynchronous notifications from the server.
   382          *
   383          *
   387         virtual void ActivateExtendedNotificationsL(
   388         virtual void ActivateExtendedNotificationsL(
   388             MWlanMgmtNotifications& aCallback,
   389             MWlanMgmtNotifications& aCallback,
   389             TUint aCallbackInterfaceVersion );
   390             TUint aCallbackInterfaceVersion );
   390 
   391 
   391         /**
   392         /**
       
   393          * (From MWlanMgmtInterface)
   392          * Create a virtual traffic stream.
   394          * Create a virtual traffic stream.
   393          *
   395          *
   394          * @param aStatus Status of the calling active object. On successful
   396          * @param aStatus Status of the calling active object. On successful
   395          *                completion contains KErrNone, otherwise one of the
   397          *                completion contains KErrNone, otherwise one of the
   396          *                system-wide error codes.
   398          *                system-wide error codes.
   405             const TWlanTrafficStreamParameters& aStreamParameters,
   407             const TWlanTrafficStreamParameters& aStreamParameters,
   406             TUint& aStreamId,
   408             TUint& aStreamId,
   407             TWlanTrafficStreamStatus& aStreamStatus );
   409             TWlanTrafficStreamStatus& aStreamStatus );
   408 
   410 
   409         /**
   411         /**
       
   412          * (From MWlanMgmtInterface)
   410          * Cancel an outstanding traffic stream creation request.
   413          * Cancel an outstanding traffic stream creation request.
   411          */
   414          */
   412         virtual void CancelCreateTrafficStream();
   415         virtual void CancelCreateTrafficStream();
   413 
   416 
   414         /**
   417         /**
       
   418          * (From MWlanMgmtInterface)
   415          * Delete a virtual traffic stream.
   419          * Delete a virtual traffic stream.
   416          *
   420          *
   417          * @param aStatus Status of the calling active object. On successful
   421          * @param aStatus Status of the calling active object. On successful
   418          *                completion contains KErrNone, otherwise one of the
   422          *                completion contains KErrNone, otherwise one of the
   419          *                system-wide error codes.
   423          *                system-wide error codes.
   422         virtual void DeleteTrafficStream(
   426         virtual void DeleteTrafficStream(
   423             TRequestStatus& aStatus,
   427             TRequestStatus& aStatus,
   424             TUint aStreamId );
   428             TUint aStreamId );
   425 
   429 
   426         /**
   430         /**
       
   431          * (From MWlanMgmtInterface)
   427          * Cancel an outstanding traffic stream deletion request.
   432          * Cancel an outstanding traffic stream deletion request.
   428          */
   433          */
   429         virtual void CancelDeleteTrafficStream();
   434         virtual void CancelDeleteTrafficStream();
   430 
   435 
   431         /**
   436         /**
       
   437          * (From MWlanMgmtInterface)
   432          * Initiate a roam to the given BSSID.
   438          * Initiate a roam to the given BSSID.
   433          *
   439          *
   434          * @param aStatus Status of the calling active object. On successful
   440          * @param aStatus Status of the calling active object. On successful
   435          *                completion contains KErrNone, otherwise one of the
   441          *                completion contains KErrNone, otherwise one of the
   436          *                system-wide error codes.
   442          *                system-wide error codes.
   440         virtual void DirectedRoam(
   446         virtual void DirectedRoam(
   441             TRequestStatus& aStatus,
   447             TRequestStatus& aStatus,
   442             const TWlanBssid& aBssid );
   448             const TWlanBssid& aBssid );
   443 
   449 
   444         /**
   450         /**
       
   451          * (From MWlanMgmtInterface)
   445          * Cancel an outstanding directed roam request.
   452          * Cancel an outstanding directed roam request.
   446          */
   453          */
   447         virtual void CancelDirectedRoam();
   454         virtual void CancelDirectedRoam();
   448 
   455 
   449         /**
   456         /**
   452          */
   459          */
   453         void ProtectedSetupComplete(
   460         void ProtectedSetupComplete(
   454             TInt aStatus );
   461             TInt aStatus );
   455 
   462 
   456         /**
   463         /**
       
   464          * (From MWlanMgmtInterface)
   457          * Start aggressive background scanning.
   465          * Start aggressive background scanning.
   458          * @param aInterval Scan interval for aggressive mode (in seconds).
   466          * @param aInterval Scan interval for aggressive mode (in seconds).
   459          *                  Valid range: 1-120 seconds.
   467          *                  Valid range: 1-120 seconds.
   460          */
   468          */
   461         virtual TInt StartAggressiveBgScan(
   469         virtual TInt StartAggressiveBgScan(
   462             TUint aInterval );
   470             TUint aInterval );
       
   471 
       
   472         /**
       
   473          * (From MWlanMgmtInterface)
       
   474          * Get the available WLAN IAPs.
       
   475          *
       
   476          * @param aCacheLifetime Defines how many seconds old cached results the client
       
   477          *                       is willing to accept. The valid is range is from 0 to
       
   478          *                       60 seconds. The value of -1 means the system default will
       
   479          *                       be used. The aCacheLifetime parameter has a meaning only
       
   480          *                       when the aMaxDelay parameter is zero.
       
   481          *                       Value will be changed to the actual value used by the
       
   482          *                       system.
       
   483          * @param aMaxDelay Maximum amount of seconds the client is willing to wait for
       
   484          *                  the availability results. The valid range is from 0 to 1200
       
   485          *                  seconds or KWlanInfiniteScanDelay. KWlanInfiniteScanDelay
       
   486          *                  will never cause a scan, but the request will be
       
   487          *                  completed when any other broadcast scan request is completed.
       
   488          *                  Value will be changed to the actual value used by the system.
       
   489          * @param aFilteredResults Whether availability is filtered based on signal strength.
       
   490                                    ETrue if filtering is allowed, EFalse if not.
       
   491          * @param aStatus Status of the calling active object. On successful
       
   492          *                completion contains KErrNone, otherwise one of the
       
   493          *                system-wide error codes.
       
   494          * @param aAvailableIaps Array of IAPs available.
       
   495          */
       
   496         virtual void GetAvailableIaps(
       
   497             TInt& aCacheLifetime,
       
   498             TUint& aMaxDelay,
       
   499             TBool aFilteredResults,
       
   500             TRequestStatus& aStatus,
       
   501             RArray<TWlanIapAvailabilityData>& aAvailableIaps );
   463 
   502 
   464 	protected: // Methods
   503 	protected: // Methods
   465 
   504 
   466         /**
   505         /**
   467          * (From MWLMNotify) Connection status has changed.
   506          * (From MWLMNotify) Connection status has changed.
   684             RArray<TUint>& aAvailableIaps,
   723             RArray<TUint>& aAvailableIaps,
   685             TInt& aCacheLifetime,
   724             TInt& aCacheLifetime,
   686             TUint& aMaxDelay );
   725             TUint& aMaxDelay );
   687 
   726 
   688         /**
   727         /**
       
   728          * C++ default constructor.
       
   729          * @param aCallback Callback interface to CWlanMgmtImpl.
       
   730          * @param aServer Interface to RWLMServer. 
       
   731          * @param aAvailableIaps Available IAPs are stored here.
       
   732          * @param aCacheLifetime how old cached results (in seconds) the client is willing to accept.
       
   733          * @param aMaxDelay maximum time the client is willing to wait for the scan results.
       
   734          * @param aFilteredResults Whether availability is filtered based on signal strength.
       
   735          */
       
   736         CWlanAvailableIapsRequest(
       
   737             CWlanMgmtImpl& aCallback,
       
   738             RWLMServer& aServer,
       
   739             RArray<TWlanIapAvailabilityData>& aAvailableIaps,
       
   740             TInt& aCacheLifetime,
       
   741             TUint& aMaxDelay,
       
   742             TBool aFilteredResults );
       
   743 
       
   744         /**
   689          * Destructor.
   745          * Destructor.
   690          */
   746          */
   691         virtual ~CWlanAvailableIapsRequest();
   747         virtual ~CWlanAvailableIapsRequest();
   692         
   748         
   693        // New methods
   749        // New methods
   726         CWlanMgmtImpl& iCallback;
   782         CWlanMgmtImpl& iCallback;
   727 
   783 
   728         // Interface to RWLMServer
   784         // Interface to RWLMServer
   729         RWLMServer& iServer;
   785         RWLMServer& iServer;
   730 
   786 
   731         // Handle to client storage for available IAPs
   787         // Handle to client storage for available IAP IDs for legacy methods.
   732 		RArray<TUint>& iPendingAvailableIaps;
   788         // Not owned by this pointer.
   733 		
   789         RArray<TUint>* iPendingAvailableIapIds;
       
   790 
       
   791         // Handle to client storage for available IAPs.
       
   792         // Not owned by this pointer.
       
   793         RArray<TWlanIapAvailabilityData>* iPendingAvailableIaps;
       
   794 
   734 		// Storage for available IAPs
   795 		// Storage for available IAPs
   735 		TWlmAvailableIaps iAvailableIaps;
   796 		TWlmAvailableIaps iAvailableIaps;
   736 		
   797 
   737 		// The package buffer needed for the asynchronous request
   798 		// The package buffer needed for the asynchronous request
   738 		TPckg<TWlmAvailableIaps> iAvailableIapsBuf;
   799 		TPckg<TWlmAvailableIaps> iAvailableIapsBuf;
   739 		
   800 		
   740 		// The package buffer needed for the asynchronous request
   801 		// The package buffer needed for the asynchronous request
   741 		TPckg<TInt> iCacheLifetimeBuf;
   802 		TPckg<TInt> iCacheLifetimeBuf;
   742 		
   803 		
   743 		// The package buffer needed for the asynchronous request
   804 		// The package buffer needed for the asynchronous request
   744 		TPckg<TUint> iMaxDelayBuf;
   805 		TPckg<TUint> iMaxDelayBuf;
   745 		
   806 		
       
   807 		// Whether availability is filtered based on signal strength.
       
   808 		TBool iFilteredResults;
   746     };
   809     };
   747 
   810 
   748 
   811 
   749 /**
   812 /**
   750 * Class for handling asynchronous Protected Setup requests.
   813 * Class for handling asynchronous Protected Setup requests.