phonecmdhandler/phonecmdhnlr/inc/PhoneHandlerControl.h
branchRCL_3
changeset 19 7d48bed6ce0c
parent 9 71e7b994dff4
child 20 987c9837762f
equal deleted inserted replaced
18:594d59766373 19:7d48bed6ce0c
    18 
    18 
    19 #ifndef CPHONEHANDLERCONTROL_H
    19 #ifndef CPHONEHANDLERCONTROL_H
    20 #define CPHONEHANDLERCONTROL_H
    20 #define CPHONEHANDLERCONTROL_H
    21 
    21 
    22 //  INCLUDES
    22 //  INCLUDES
    23 #include "PhoneHandlerService.h"
    23 #include "phonehandlerservice.h" 
    24 #include <RemConExtensionApi.h>
    24 #include <RemConExtensionApi.h> 
    25 #include <RemConCallHandlingTargetObserver.h>
    25 #include <RemConCallHandlingTargetObserver.h> 
    26 #include <e32base.h>
    26 #include <e32base.h>
    27 #include <PhCltTypes.h>	
    27 #include <phclttypes.h> 
    28 #include <e32property.h> 
    28 #include <e32property.h> 
    29 #include <ccpdefs.h>
       
    30 
    29 
    31 // CONSTANTS
    30 // CONSTANTS
    32 
    31 
    33 // MACROS
    32 // MACROS
    34 
    33 
    41 // CLASS DECLARATION
    40 // CLASS DECLARATION
    42 class CRemConInterfaceSelector;
    41 class CRemConInterfaceSelector;
    43 class CRemConCallHandlingTarget;
    42 class CRemConCallHandlingTarget;
    44 class CPhoneHandlerResponse;
    43 class CPhoneHandlerResponse;
    45 class CPhoneHandlerCallState;
    44 class CPhoneHandlerCallState;
    46 class CPhoneHandlerCallArray;
       
    47 class MCall;
       
    48 
    45 
    49 /**
    46 /**
    50 * Receives call handling related key presses from accessories and executes 
    47 * Receives call handling related key presses from accessories and executes 
    51 * them.
    48 * them.
    52 *
    49 *
    53 *  @lib PhoneCmdHandler
    50 *  @lib PhoneCmdHandler
    54 *  @since S60 3.1
    51 *  @since S60 3.1
    55 */
    52 */
    56 NONSHARABLE_CLASS( CPhoneHandlerControl ) : public CBase,
    53 NONSHARABLE_CLASS( CPhoneHandlerControl ) : public CBase,
    57 											public MRemConCallHandlingTargetObserver
    54                                             public MRemConCallHandlingTargetObserver
    58 	{
    55     {
    59     public:  // Constructors and destructor
    56     public:  // Constructors and destructor
    60     
    57     
    61         /**
    58         /**
    62         * Two-phased constructor.
    59         * Two-phased constructor.
    63         */
    60         */
    64         static CPhoneHandlerControl* NewL( 
    61         static CPhoneHandlerControl* NewL( 
    65         	CRemConInterfaceSelector* aIfSelector = NULL );
    62             CRemConInterfaceSelector* aIfSelector = NULL );
    66 
    63 
    67         /**
    64         /**
    68         * Destructor.
    65         * Destructor.
    69         */
    66         */
    70         virtual ~CPhoneHandlerControl();
    67         virtual ~CPhoneHandlerControl();
    71 
    68 
    72     public: // New functions
    69     public: // New functions
    73     
    70     
    74     	/**
    71         /**
    75         * Returns phone number for dial or speed dial.
    72         * Returns phone number for dial or speed dial.
    76         * @since S60 3.1
    73         * @since S60 3.1
    77         * @param void
    74         * @param void
    78         * @return TPhCltTelephoneNumber phone number
    75         * @return TPhCltTelephoneNumber phone number
    79         */
    76         */
   108         * @since S60 3.1
   105         * @since S60 3.1
   109         * @param void
   106         * @param void
   110         * @return TChar DTMF tone
   107         * @return TChar DTMF tone
   111         */
   108         */
   112         const TChar& Tone() const;
   109         const TChar& Tone() const;
   113     	
   110         
   114     	/**
   111         /**
   115         * Returns reference to API used to communicate with accessory who 
   112         * Returns reference to API used to communicate with accessory who 
   116         * initiated key press.
   113         * initiated key press.
   117         * @since S60 3.1
   114         * @since S60 3.1
   118         * @param void
   115         * @param void
   119         * @return CRemConCallHandlingTarget& reference to API
   116         * @return CRemConCallHandlingTarget& reference to API
   120         */	
   117         */  
   121 		CRemConCallHandlingTarget& CommandInitiator() const;
   118         CRemConCallHandlingTarget& CommandInitiator() const;
   122 		
   119         
   123 		/**
   120         /**
   124         * Informs the latest call state.
   121         * Informs the latest call state.
   125         * @since S60 9.2
   122         * @since S60 3.1
   126         * @param aCall Call from MCallInformationObserver
   123         * @param aState Call state from KTelephonyCallState P&S key
   127           * @return void
   124         * @return void
   128         */
   125         */
   129 		void NotifyCallStateL( const MCall* aCall );
   126         void NotifyCallState( const TInt aState );
   130 
   127 
   131 		/**
   128         /**
   132         * Get iSwitchCall flag, if this flag is ETrue, it means
   129         * Get iSwitchCall flag, if this flag is ETrue, it means
   133         * "Send" key in remote target is pressed in multiparty call,
   130         * "Send" key in remote target is pressed in multiparty call,
   134         * otherwise EFalse
   131         * otherwise EFalse
   135         * @since S60 3.1
   132         * @since S60 3.1
   136         * @return TBool
   133         * @return TBool
   137         */
   134         */
   138 		TBool SwitchCall();
   135         TBool SwitchCall();
   139 
   136 
   140 	    	        
   137                     
   141     public: // Functions from base classes
   138     public: // Functions from base classes
   142     	        
   139                 
   143     protected:  // New functions
   140     protected:  // New functions
   144         
   141         
   145     protected:  // Functions from base classes
   142     protected:  // Functions from base classes
   146     
   143     
   147     private:
   144     private:
   153 
   150 
   154         /**
   151         /**
   155         * By default Symbian 2nd phase constructor is private.
   152         * By default Symbian 2nd phase constructor is private.
   156         */
   153         */
   157         void ConstructL( CRemConInterfaceSelector* aIfSelector = NULL );
   154         void ConstructL( CRemConInterfaceSelector* aIfSelector = NULL );
   158 				
   155                 
   159 		/**
   156         /**
   160 		* From MRemConCallHandlingTargetObserver. Answer an incoming phone call.
   157         * From MRemConCallHandlingTargetObserver. Answer an incoming phone call.
   161 		*/
   158         */
   162 		virtual void AnswerCall();
   159         virtual void AnswerCall();
   163 
   160 
   164 		/**
   161         /**
   165 		* From MRemConCallHandlingTargetObserver. End an incoming/ongoing 
   162         * From MRemConCallHandlingTargetObserver. End an incoming/ongoing 
   166 		* phone call.
   163         * phone call.
   167 		*/
   164         */
   168 		virtual void EndCall();
   165         virtual void EndCall();
   169 	
   166     
   170 		/**
   167         /**
   171 		* From MRemConCallHandlingTargetObserver. Answer an incoming phone call, 
   168         * From MRemConCallHandlingTargetObserver. Answer an incoming phone call, 
   172 		* or end an ongoing call according to call status. 
   169         * or end an ongoing call according to call status. 
   173 		*/
   170         */
   174 		virtual void AnswerEndCall();
   171         virtual void AnswerEndCall();
   175 		
   172         
   176 		/**
   173         /**
   177 		* From MRemConCallHandlingTargetObserver. Make a voice call.
   174         * From MRemConCallHandlingTargetObserver. Make a voice call.
   178 		*/
   175         */
   179 		virtual void VoiceDial( const TBool aActivate );
   176         virtual void VoiceDial( const TBool aActivate );
   180 	
   177     
   181 		/**
   178         /**
   182 		* From MRemConCallHandlingTargetObserver. Redial last phone call.
   179         * From MRemConCallHandlingTargetObserver. Redial last phone call.
   183 		*/
   180         */
   184 		virtual void LastNumberRedial();
   181         virtual void LastNumberRedial();
   185 	
   182     
   186 		/**
   183         /**
   187 		* From MRemConCallHandlingTargetObserver. Dial a phone call.
   184         * From MRemConCallHandlingTargetObserver. Dial a phone call.
   188 		*/
   185         */
   189 		virtual void DialCall( const TDesC8& aTelNumber );
   186         virtual void DialCall( const TDesC8& aTelNumber );
   190 	
   187     
   191 		/**
   188         /**
   192 		* From MRemConCallHandlingTargetObserver. Make multiparty call.
   189         * From MRemConCallHandlingTargetObserver. Make multiparty call.
   193 		*/
   190         */
   194 		virtual void MultipartyCalling( const TDesC8& aData );
   191         virtual void MultipartyCalling( const TDesC8& aData );
   195 	
   192     
   196 		/**
   193         /**
   197 		* Generates DTMF signal.
   194         * Generates DTMF signal.
   198 		*/
   195         */
   199 		virtual void GenerateDTMF( const TChar aChar );
   196         virtual void GenerateDTMF( const TChar aChar );
   200 	
   197     
   201 		/**
   198         /**
   202 		* From MRemConCallHandlingTargetObserver. Make a speed dial call.
   199         * From MRemConCallHandlingTargetObserver. Make a speed dial call.
   203 		*/
   200         */
   204 		virtual void SpeedDial( const TInt aIndex );
   201         virtual void SpeedDial( const TInt aIndex );
   205 		
   202         
   206 		/**
   203         /**
   207 		* Starts processing service corresponding to key press.
   204         * Starts processing service corresponding to key press.
   208 		*/
   205         */
   209 		void StartProcessing( 
   206         void StartProcessing( 
   210 			const TRemConExtCallHandlingApiOperationId aOperation );
   207             const TRemConExtCallHandlingApiOperationId aOperation );
   211 		
   208         
   212 		/**
   209         /**
   213 		* Creates service.
   210         * Creates service.
   214 		*/
   211         */
   215 		MPhoneHandlerService* CreateServiceL( 
   212         MPhoneHandlerService* CreateServiceL( 
   216 			const TRemConExtCallHandlingApiOperationId aOperation );
   213             const TRemConExtCallHandlingApiOperationId aOperation );
   217 		
   214         
   218 		/**
   215         /**
   219 		* Initializes speed dial.
   216         * Returns call status.
   220 		*/
   217         */
   221 		void InitializeSpeedDialL();
   218         void CallStatusL( RPhone::TLineInfo& aLineInfo );
   222 		
   219         
   223 		/**
   220                 
   224 		* Returns call status.
       
   225 		*/
       
   226 		void CallStatusL( RPhone::TLineInfo& aLineInfo );
       
   227 		
       
   228 		/**
       
   229         * Returns autolock status
       
   230         */
       
   231 		TBool IsAutoLockOn() const;
       
   232 		
       
   233 		/**
       
   234         * Returns BT accessory command status
       
   235         */
       
   236 		TBool IsBTAccessoryCmd() const;
       
   237 		
       
   238     private:    // Data
   221     private:    // Data
   239         
   222         
   240         // Provides e.g. service to listen accessory key presses.
   223         // Provides e.g. service to listen accessory key presses.
   241         CRemConInterfaceSelector* iInterfaceSelector;	// owned
   224         CRemConInterfaceSelector* iInterfaceSelector;   // owned
   242         
   225         
   243         //  API notifying PhoneCmdHandler about call handling key presses.
   226         //  API notifying PhoneCmdHandler about call handling key presses.
   244         CRemConCallHandlingTarget* iTarget;	// owned
   227         CRemConCallHandlingTarget* iTarget; // owned
   245                 
   228                 
   246         // Phone number for dial call/speed dial.
   229         // Phone number for dial call/speed dial.
   247         TPhCltTelephoneNumber iTelNumber;
   230         TPhCltTelephoneNumber iTelNumber;
   248         
   231         
   249         // Voice recognition status
   232         // Voice recognition status
   268         RProperty iProperty;
   251         RProperty iProperty;
   269         
   252         
   270         // Previous call state
   253         // Previous call state
   271         TInt iPrevState;
   254         TInt iPrevState;
   272         
   255         
       
   256         // Number of active calls
       
   257         // Used to determine whether there's a multicall case when call state
       
   258         TInt iActiveCalls;
       
   259         
   273         // switch phonecall by press "Send" key
   260         // switch phonecall by press "Send" key
   274         TBool iSwitchCall;
   261         TBool iSwitchCall;
   275         
   262         
   276         // Listens to phone call state changes.
   263         // Listens to phone call state changes.
   277         CPhoneHandlerCallState* iCallStateObserver;
   264         CPhoneHandlerCallState* iCallStateObserver;
   278         
   265         
   279         CPhoneHandlerCallArray* iCallArray;
       
   280                     
   266                     
   281     public:     // Friend classes
   267     public:     // Friend classes
   282     
   268     
   283     protected:  // Friend classes
   269     protected:  // Friend classes
   284     
   270