1 /*

     2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Provides the interface between SUPL Gateway and SUPL Protocol Handler. 

    15 *				 This class provides the functionality of loading and unloading 

    16 *				 the Protocol handler ECom plug-in.

    17 *

    18 */

    19 

    20 

    21 #ifndef C_CSUPLPROTOCOLMANAGERBASE_H

    22 #define C_CSUPLPROTOCOLMANAGERBASE_H

    23 

    24 

    25 #include <e32base.h>

    26 #include "epos_msuplpacketreceiver.h"

    27 #include <epos_suplterminal.h>

    28 

    29 //Forword Declarations

    30 class CSuplSessionBase;

    31 class CSuplCommunicationManager;

    32 

    33 

    34 /**

    35  * Constant:    KProtocolManagerInterfaceDefinitionUid

    36  *

    37  * Description: UID of this ECOM interface. 

    38  *

    39  */

    40 const TUid KProtocolManagerInterfaceDefinitionUid = {0x102073CB};

    41  

    42 

    43 /**

    44  * Class:       CSUPLProtocolManagerBase

    45  *

    46  * Description: Custom ECOM interface definition. This interface is used by

    47  *              clients to find specific instance and implementation of 

    48  *				protocol handler Plugin.

    49  */

    50  

    51  

    52 class CSUPLProtocolManagerBase : public CBase, public MSuplPacketReceiver

    53     {

    54 

    55 public :

    56 

    57 	/**

    58 	 * For diffentiating request between Terminal & NET initiation 

    59 	 *

    60 	 */

    61 	enum TSuplReqType

    62 	    {

    63 	    ETerminal = 0,

    64 	    ENetwork

    65 	    }; 

    66    

    67 public: // Constructors and destructor  

    68 

    69     /**

    70      * Function:     NewL, Two Phase Construction

    71      *

    72      * @Description: Wraps ECom object instantitation. Will search for

    73      *               interface implementation, which matches to given

    74      *               aOperationName.

    75      *

    76      * @Param:       aOperationName, name of requested implementation.

    77      *

    78      * @return 		 instance of implementation		

    79      *

    80      */     

    81  	IMPORT_C static CSUPLProtocolManagerBase* NewL(const TDesC8& aOperationName);

    82 

    83     /**

    84      * Function:     NewL, Two Phase Construction

    85      *

    86      * @Description: Wraps ECom object instantitation. Will search for

    87      *               interface implementation, which matches to given

    88      *               UID.

    89      *

    90      * @Param:       aImplementationUid, UID of requested implementation.

    91      *

    92      * @return 		 instance of implementation		

    93      *

    94      */     

    95  	IMPORT_C static CSUPLProtocolManagerBase* NewL(const TUid &aImplementationUid);

    96  

    97     /**

    98      * Function:     CSUPLProtocolManagerBase 

    99      *

   100      * @Description: Default constructor

   101      *

   102      * @Param:       None

   103      *

   104      * @Returns:     None

   105      *

   106      */

   107    	IMPORT_C CSUPLProtocolManagerBase();

   108    

   109       /**

   110      * Function:     SetImplementationUid

   111      *

   112      * @Description: Sets Uid of implementation 

   113      *

   114      * @Param:       UID of implementation.

   115      *

   116      * @Returns:     None

   117      *

   118      */

   119 	IMPORT_C virtual void ConstructL(const TUid& aUid); 

   120 

   121     /**

   122      * Function:     ~CSUPLProtocolManagerBase  

   123      *

   124      * @Description: Wraps ECom object destruction. Notifies the ECOM

   125      *               framework that specific instance is being destroyed.

   126      */

   127     IMPORT_C  ~CSUPLProtocolManagerBase();

   128 

   129     /**

   130      * Function:     ImplementationUid, 

   131      *

   132      * @Description: Gives implementation UID

   133      *

   134      * @Param:       None.

   135      *

   136      * @return 		 Returns implementation UID 		

   137      *

   138      */     

   139   	IMPORT_C TUid ImplementationUid() const;

   140  

   141     /**

   142      * Function:   	 Version 

   143      *

   144      * @Description: Gives version of implementation

   145      *

   146      * @Param:       None.

   147      *

   148      * @return 		 Returns TInt, containing version of implementation 

   149      *

   150      */     

   151   	IMPORT_C TInt Version() const;

   152 

   153 public:

   154 

   155     /**

   156      * Function:     InitializeL, 

   157      *

   158      * @Description: Does the asynchonous initilization. 

   159      *

   160      * @Param:       aCommManager,Communication Manager

   161      * @Param:       aInitilizationRequestStatus,for asynchronous initilization of protocol manager

   162      *

   163      * @Returns:     None

   164      *

   165      */

   166   	virtual void InitializeL(

   167   					 CSuplCommunicationManager* aCommManager,

   168   					 TRequestStatus& aInitilizationRequestStatus) = 0;

   169 

   170     /**

   171      * Function:     CancelInitialize, 

   172      *

   173      * @Description: Does the cancellation of asynchronous initilization. 

   174      *

   175      * @Param:       None

   176      *

   177      * @Returns:     None

   178      *

   179      */

   180   	virtual void CancelInitialize() = 0;

   181 

   182     /**

   183      * Function:     DeInitialize, 

   184      *

   185      * @Description: Does the de-initilization. 

   186      *

   187      * @Param:       aDeInitRequestStatus,for asynchronous de-initilization of protocol manager

   188      *

   189      * @Returns:     None

   190      *

   191      */

   192   	virtual void DeInitialize(TRequestStatus& aDeInitRequestStatus) = 0;

   193 

   194     /**

   195      * Function:     CancelDeInitialize, 

   196      *

   197      * @Description: Does the cancellation of asynchronous de-initilization. 

   198      *

   199      * @Param:       None

   200      *

   201      * @Returns:     None

   202      *

   203      */

   204   	virtual void CancelDeInitialize() = 0;

   205 

   206     /**

   207      * Function:     HandleSuplMessageL, 

   208      *

   209      * @Description: Handles packet which come from SLP in NET initiated case

   210      *

   211      * @Param:       aSuplSession , session object on which processing will start

   212      * @Param:       aStatus, 			On return, the status of the request

   213      *

   214      * @Returns:     None

   215      *

   216      */ 		

   217   	virtual void HandleSuplMessageL(

   218   					 CSuplSessionBase *const aSuplSession,

   219   					 TRequestStatus& aStatus,

   220   					 HBufC8* aMessage) = 0;

   221   					 

   222 public: 

   223 

   224     /**

   225      * Function:     CreateNewSession

   226      *

   227      * @Description: Creates new SuplSession instance

   228      *

   229      * @Param:       None

   230      *

   231      * @Returns:     Instance of CSuplSessionBase.

   232      *

   233      */

   234    	virtual CSuplSessionBase* CreateNewSessionL(

   235    					 TSuplReqType aRequestType, 

   236    					 TInt aIpcSessionId,

   237    					 RSuplTerminalSubSession::TSuplServiceType aSuplService) = 0;

   238    

   239    	/**

   240      * Function:     DestroySession

   241      *

   242      * @Description: Destoys SuplSession instance

   243      *

   244      * @Param:       None

   245      *

   246      * @Returns:     TInt, if session is invalid, then returns KErrArgument

   247      *

   248      */

   249    	virtual TInt DestroySession(CSuplSessionBase* aSuplSession ) = 0;

   250    

   251     /**

   252      * Function:     RunSessionL, 

   253      *

   254      * @Description: Starts processing on session

   255      *

   256      * @Param:       aSuplSession , session object on which processing will start

   257      * @Param:       aStatus, 			On return, the status of the request

   258      * @Param:       aAllowedCapabilities , Allowed capabilities of SET

   259      * @Param:       aRequestID , Request ID of Session

   260      *

   261      * @Returns:     None

   262      */ 		

   263   	virtual void RunSessionL(

   264   					 CSuplSessionBase *const aSuplSession,

   265   					 TRequestStatus& aStatus,

   266   					 const TDesC& aHslpAddress, 

   267   					 TBool aFallBack, 

   268   					 TBool aFirstReq, 

   269   					 TInt aAllowedCapabilities, 

   270   					 TInt aRequestID = 0) = 0;

   271 

   272     /**

   273      * Function:     RunSessionL, 

   274      *

   275      * @Description: Starts processing on session

   276      *

   277      * @Param:       aSuplSession , session object on which processing will start

   278      * @Param:       aStatus, 			On return, the status of the request

   279      * @Param:       aAllowedCapabilities , Allowed capabilities of SET

   280      * @Param:       aQop , specifies the quality of position

   281      * @Param:       aRequestID , Request ID of Session

   282      *

   283      * @Returns:     None

   284      *

   285      */

   286   	virtual void RunSessionL(

   287   					 CSuplSessionBase *const aSuplSession,

   288   					 TRequestStatus& aStatus,

   289   					 const TDesC& aHslpAddress, 

   290   					 TBool aFallBack, 

   291   					 TBool aFirstReq, 

   292   					 TInt aAllowedCapabilities,

   293   					 TSuplTerminalQop& aQop, 

   294   					 TInt aRequestID = 0) = 0;

   295 

   296    	/**

   297      * Function:     CancelRunSession

   298      *

   299      * @Description: Cancels the Run Session Request

   300      *

   301      * @Param:       Session Object

   302      *

   303      * @Returns:     None

   304      *

   305      */

   306    	virtual void CancelRunSession(CSuplSessionBase* aSuplSession) = 0;

   307     

   308     /**

   309      * Function:     RunSuplTriggerSessionL, 

   310      *

   311      * @Description: Starts processing on session

   312      *

   313      * @Param:       aSuplSession, session object on which processing will start

   314      * @Param:       aStatus, On return, the status of the request

   315      * @Param:       aPTrigger, specifies the periodic trigger session

   316      * @Param:       aHslpAddress, specifies HSLP Server Address to be used 

   317      *				  	to get position from it

   318      * @Param:       aFallBack, enables/diables Multiple-SLP Fallback mechanism

   319      * @Param:       aAllowedCapabilities, Allowed capabilities of SET

   320      * @Param:       aRequestID, Request ID of Session     

   321      *

   322      * @Returns:     None

   323      *

   324      */

   325    	virtual void RunSuplTriggerSessionL(

   326   					 CSuplSessionBase *const aSuplSession,

   327   					 TRequestStatus& aStatus,

   328   					 TSuplTerminalPeriodicTrigger& aPTrigger,

   329   					 const TDesC& aHslpAddress, 

   330   					 TBool aFallBack, 

   331   					 TInt aAllowedCapabilities,

   332   					 TInt aRequestID = 0) = 0;

   333 

   334    	/**

   335      * Function:     CancelSuplTriggerSession

   336      *

   337      * @Description: Cancels an in-progress Terminal Initiated 

   338 	 * 				 Periodic Trigger Session Location Request

   339      *

   340      * @Param:       Session Object

   341      *

   342      * @Returns:     None

   343      *

   344      */

   345    	virtual void CancelSuplTriggerSession(CSuplSessionBase* aSuplSession) = 0;

   346 

   347    	/**

   348      * Function:     NotifyTriggerFired

   349      *

   350      * @Description: Starts listening for the trigger fired event

   351      *

   352      * @Param:       None

   353      *

   354      * @Returns:     None

   355      *

   356      */

   357     virtual void NotifyTriggerFiredL(

   358     				 CSuplSessionBase *const aSuplSession,

   359   					 TRequestStatus& aStatus, 

   360         			 TSuplTriggerFireInfo& aFireInfo) = 0;

   361 

   362     

   363     /**

   364      * Function:     GetSUPLMessageVersionL

   365      *

   366      * @Description: Cancels listening for the trigger fired event

   367      *

   368      * @Param:       aMajorVersion,return parameter which will hold version after decoding of message.

   369      *

   370      * @Param:       aReceivedMessage,message to be used to get version number.

   371      *

   372      * @Returns:     returns KErrNone if recceived message gets decoded successfuly otherwise KErrGeneral.

   373      *

   374      */

   375     virtual TInt GetSUPLMessageVersionL(TInt& aMajorVersion, const TDesC8& aReceivedMessage);

   376     

   377     

   378 

   379 				 

   380 public: // from MSuplPacketReceiver

   381 

   382    	/**

   383      * Function:     HandleSuplPackets

   384      *

   385      * @Description: Process Supl message which are comming from SLP

   386      *

   387      * @Param:       aPacket, message packet

   388      *

   389      * @Returns:     None

   390      *

   391      */

   392    	virtual void HandlePacket(const TDesC8& aPacket, TUint aPortNum) = 0;

   393 

   394    	/**

   395      * Function:     HandlePacketError

   396      *

   397      * @Description: Handles error if any while reading from communication manager

   398      *

   399      * @Param:       aError, error code occured while reading from communication manager

   400      *

   401      * @Returns:     None

   402      *

   403      */

   404    	virtual void HandlePacketError(TInt aError) = 0;

   405     

   406 private:

   407 

   408  	/**

   409      *	By default,  prohibit copy constructor

   410 	 */         

   411     CSUPLProtocolManagerBase( const CSUPLProtocolManagerBase& );

   412     

   413    	/**

   414      *	By default,  Prohibit assigment operator

   415      *

   416 	 */

   417     CSUPLProtocolManagerBase& operator= ( const CSUPLProtocolManagerBase& );

   418 	

   419     /**

   420      * Function:     GetVersionL 

   421      *

   422      * @Description: Gives version of implementation 

   423      *

   424      * @Param:       None

   425      *

   426      * @Returns:     TInt , containing version of implementation 

   427      *

   428      */

   429 	TInt GetVersionL() const;	

   430 	

   431    	/**

   432      * Function:     SetImplementationUid

   433      *

   434      * @Description: Sets Uid of implementation 

   435      *

   436      * @Param:       UID of implementation.

   437      *

   438      * @Returns:     None

   439      *

   440      */

   441 	 //void SetImplementationUid(const TUid& aUid); 

   442 

   443 private:

   444 

   445     /** 

   446      * iDtor_ID_Key  Instance identifier key. When instance of an

   447      *               implementation is created by ECOM framework, the

   448      *               framework will assign UID for it. The UID is used in

   449      *               destructor to notify framework that this instance is

   450      *               being destroyed and resources can be released.

   451      *

   452      */     

   453     TUid iDtor_ID_Key;

   454     

   455     /**

   456      * Uid of Implementation    

   457      *

   458      */

   459     TUid iImplementationUid;

   460     

   461     };

   462 

   463 

   464 #endif // C_CSUPLPROTOCOLMANAGERBASE_H

   465 

   466 // End of File