×

Discussion Board

Results 1 to 9 of 9
  1. #1
    Registered User
    Join Date
    Jul 2009
    Posts
    27

    Unhappy Qt CTelephony problems

    Hi everyone !
    I need some help to solve CTelephony problems in my Qt project testCall.

    it could detect the call status when have a incoming call, the change of status as follows:
    Ringing
    Dialer Error = -46 (just can not retrieve the incoming call number?)
    Disconnecting (hang up)
    Idle

    when dial a number, status:
    Dial
    the number
    Dial end
    Dialer Error = -46

    and the auto answer doesn't work either

    the files about my project as follows

    testCall.h
    Code:
    #ifndef TESTCALL_H
    #define TESTCALL_H
    
    #include <QtGui/QWidget>
    #include "ui_testCall.h"
    
    #include "Call_Observer.h"
    #include "Call_Dialer.h"
    #include "Send_DTMF.h"
    
    _LIT(KTxStatusError					,"Status Error = ");
    _LIT(KTxDialerError					,"Dialer Error = ");
    _LIT(KTxDialerDone					,"Dialer Done");
    
    _LIT(KTxDTMFError					,"DTMF Error = ");
    _LIT(KTxDTMFDone					,"DTMF Done");
    _LIT(KTxDTMFToneString				,"1234567890#*");
    
    _LIT(KTxStatusDialling				,"Dialling");
    _LIT(KTxStatusRinging				,"Ringing");
    _LIT(KTxStatusAnswering				,"Answering");
    _LIT(KTxStatusConnecting			,"Connecting");
    _LIT(KTxStatusConnected				,"Connected");
    _LIT(KTxStatusUnknown				,"Unknown");
    _LIT(KTxStatusIdle					,"Idle");
    _LIT(KTxStatusReconnectPending		,"ReconnectPending");
    _LIT(KTxStatusDisconnecting			,"Disconnecting");
    _LIT(KTxStatusHold					,"Hold");
    _LIT(KTxStatusTransferring			,"Transferring");
    _LIT(KTxStatusTransferAlerting		,"TransferAlerting");
    
    
    _LIT(KTxAutoAnswerOn				,"Autoanswer is On");
    _LIT(KTxAutoAnswerOff				,"Autoanswer is Off");
    
    class testCall : public QWidget,MCallObsCallBack,MCallDialerCallBack
    ,MDTMFCallBack
    {
        Q_OBJECT
    
    public:
    	testCall(QWidget *parent = 0);
        ~testCall();
        void AddText(const TDesC& aTones);
        void AddText(QString content);
    
    private:
        Ui::testCall ui;
        
    protected: // from MCallObsCallBack, MCallDialerCallBack & CMyDTMFSender
    	void CallNumberL(const TDesC& aNumber);
    	void NotifyChangeInCallStatusL(CTelephony::TCallStatus& aStatus, TInt aError);
    	void DialerDone(TInt aError);
    	void DTMFDoneL(TInt aError);
    private: // Member variables
    	CMyCallObserver*	iMyCallObserver;
    	TBool				iCanDial,iCanHangup,iAutoAnswer;
    	CMyCallDialer*		iMyCallDialer;
    	CMyDTMFSender*		iMyDTMFSender;
    
    public slots:
    	void Call();
    	void AutoAnswer();
    	
    };
    
    #endif // TESTCALL_H
    testCall.cpp
    Code:
    #include "testCall.h"
    
    testCall::testCall(QWidget *parent)
        : QWidget(parent)
    {
    	ui.setupUi(this);
    	QObject::connect(ui.callButton, SIGNAL(clicked()), this, SLOT(Call()));
    	QObject::connect(ui.autoAnswerButton, SIGNAL(clicked()), this, SLOT(AutoAnswer()));
    	
    	iCanDial = ETrue;
    	iMyCallObserver = CMyCallObserver::NewL(*this);
    	iMyCallObserver->SetParent(this);
    	iMyCallDialer = CMyCallDialer::NewL(*this);
    	iMyCallDialer->SetParent(this);
    	iMyDTMFSender = CMyDTMFSender::NewL(*this);
    	AddText("Statr...");
    }
    
    testCall::~testCall()
    {
    
    }
    
    void testCall::AddText(const TDesC& aTones)
    {
       
    	TBuf<200> buf(aTones);    
    	QString qString((QChar*)buf.Ptr(),buf.Length());     
    	ui.listWidget->addItem(qString);
    }
    
    void testCall::AddText(QString content)
    {
    	ui.listWidget->addItem(content);
    }
    
    /*
    -----------------------------------------------------------------------------
    CMyCallObserver uses this callback to inform about the incoming/outgoing
    caller's phone number
    -----------------------------------------------------------------------------
    */ 
    void testCall::CallNumberL(const TDesC& aNumber)
    	{
    		AddText(aNumber);
    	}
    
    /*
    -----------------------------------------------------------------------------
    CMyCallObserver uses this callback to inform about changes 
    in the phone line status
    -----------------------------------------------------------------------------
    */ 
    void testCall::NotifyChangeInCallStatusL(CTelephony::TCallStatus& aStatus, TInt aError)
    	{
    	TBuf<100> addbuffer;
    	
    	if(aError != KErrNone)
    		{
    		addbuffer.Copy(KTxStatusError);
    		addbuffer.AppendNum(aError);
    		AddText(addbuffer);
    		}
    
    		iCanDial = EFalse;// by default we can not dial...
    	
    	switch(aStatus)
    	{
    	case CTelephony::EStatusDialling:
    	    addbuffer.Copy(KTxStatusDialling);
    	    break;	
    	case CTelephony::EStatusRinging:
    		addbuffer.Copy(KTxStatusRinging);
    		break;
    	case CTelephony::EStatusAnswering:
    		addbuffer.Copy(KTxStatusAnswering);
    		break;
    	case CTelephony::EStatusConnecting:
    		addbuffer.Copy(KTxStatusConnecting);
    		break;
    	case CTelephony::EStatusConnected:
    	    iCanHangup 	= ETrue;
    	    // we have phonecall active, thus can hangup now
    		addbuffer.Copy(KTxStatusConnected);
    		break;
    	case CTelephony::EStatusIdle://call has ended
    	    iCanDial 	= ETrue; // can dial
    	    iCanHangup 	= EFalse;// and can not hangup
    		addbuffer.Copy(KTxStatusIdle);
    	    break;
    	case CTelephony::EStatusReconnectPending:
    	    addbuffer.Copy(KTxStatusReconnectPending);
    	    break;
    	case CTelephony::EStatusDisconnecting:
    		addbuffer.Copy(KTxStatusDisconnecting);
    		break;
    	case CTelephony::EStatusHold:
    	    addbuffer.Copy(KTxStatusHold);
    		break;
    	case CTelephony::EStatusTransferring:
    	    addbuffer.Copy(KTxStatusTransferring);
    	    break;
    	case CTelephony::EStatusTransferAlerting:
    	    addbuffer.Copy(KTxStatusTransferAlerting);
    		break;
    	case CTelephony::EStatusUnknown:
    	default:
    		addbuffer.Copy(KTxStatusUnknown);
    		break;
    	};
    	AddText(addbuffer);
    	
    	if(iMyCallDialer && iMyCallObserver && iAutoAnswer)
    		{
    		// if we are ringing, and previously we were not dialing
    		// then we can answer this call since its ringing for incoming call
    		if(aStatus == CTelephony::EStatusRinging
    		&& iMyCallObserver->PreviousStatus() != CTelephony::EStatusDialling)
    			{
    			iMyCallDialer->AnswerIncomingCall();
    			}
    		}
    	}
    
    /*
    -----------------------------------------------------------------------------
    CMyCallDialer uses this callback to inform that it has done something,
    which is either: Dial, Hangup or automatic answering
    -----------------------------------------------------------------------------
    */ 
    void testCall::DialerDone(TInt aError)
    	{
    	if(aError != KErrNone)
    		{
    		TBuf<100> addbuffer(KTxDialerError);
    		addbuffer.AppendNum(aError);
    		AddText(addbuffer);
    		}
    	else
    		{
    		AddText(KTxDialerDone);
    		}
    	}
    
    /*
    -----------------------------------------------------------------------------
    CMyDTMFSender uses this callback to inform that it has finished sending
    DTMF tones
    -----------------------------------------------------------------------------
    */ 
    void testCall::DTMFDoneL(TInt aError)
    	{
    	if(aError != KErrNone)
    		{
    		TBuf<100> addbuffer(KTxDTMFError);
    		addbuffer.AppendNum(aError);
    		AddText(addbuffer);
    		}
    	else
    		{
    		AddText(KTxDTMFDone);
    		}	
    }
    
    void testCall::Call()
    {
    	_LIT(Number	,"+919464763259");
    	TBuf<25> dialNumber(Number);
    		
    	if(dialNumber.Length())
    		{
    		iMyCallDialer->Dial(dialNumber);
    		}
    	//iMyCallDialer->Dial();
    }
    
    void testCall::AutoAnswer()
    {
    	iAutoAnswer = ETrue;
    	AddText(KTxAutoAnswerOn);
    }
    Has anyone encountered similar cases. Please help me solve it.
    Thanks a lot !

  2. #2
    Registered User
    Join Date
    Jul 2009
    Posts
    27

    Re: Qt CTelephony problems

    and the other files Call_Observer and Call_Dialer as follows:

    Call_Dialer .h
    Code:
    #ifndef __PHONEEXAMPLE_CALLDIALER_H__
    #define __PHONEEXAMPLE_CALLDIALER_H__
    
    #include <e32base.h>
    #include <ETel3rdParty.h>
    
    class testCall;
    
    class MCallDialerCallBack
    {
    public:
    	virtual void DialerDone(TInt aError)=0;
    };
    
    class CMyCallDialer : public CActive
    {
      enum TMyCallStates
      	{
      	EMyCallIdle,
      	EMyCallDialing,
      	EMyCallHangingup,
      	EMyCallAnswering
      	};
    public:// public constructors & destructor
      	static CMyCallDialer* NewLC(MCallDialerCallBack& aCallBack);
      	static CMyCallDialer* NewL(MCallDialerCallBack& aCallBack);
      	~CMyCallDialer();
      	// public functions
      	void Dial(const TDesC& aPhoneNumber,CTelephony::TCallerIdentityRestrict aRestinction = CTelephony::EIdRestrictDefault);
      	void Dial();
      	void Hangup();
      	void AnswerIncomingCall();
      	void SetParent(testCall *p);
    protected: // from CActive
      	void RunL();
      	void DoCancel();
    private:
      	CMyCallDialer(MCallDialerCallBack& aCallBack);
      	void ConstructL();		
    private:
    	MCallDialerCallBack& 		iCallBack;
      	CTelephony* 				iTelephony;
      	CTelephony::TCallId 		iCallId;
      	CTelephony::TCallParamsV1 	iCallParams;
      	CTelephony::TCallParamsV1Pckg iCallParamsPckg;
      	TMyCallStates 				iState;
      	testCall* parent;
    };
    #endif //__PHONEEXAMPLE_CALLDIALER_H__
    Call_Dialer .cpp
    Code:
    #include "Call_Dialer.h"
    #include "testCall.h"
    
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    CMyCallDialer* CMyCallDialer::NewLC(MCallDialerCallBack& aCallBack)
    	{
      	CMyCallDialer* self = new (ELeave) CMyCallDialer(aCallBack);
      	CleanupStack::PushL(self);
      	self->ConstructL();
      	return self;
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    CMyCallDialer* CMyCallDialer::NewL(MCallDialerCallBack& aCallBack)
    	{
      	CMyCallDialer* self = CMyCallDialer::NewLC(aCallBack);
      	CleanupStack::Pop();
      	return self;
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */  
    CMyCallDialer::CMyCallDialer(MCallDialerCallBack& aCallBack)
    :CActive(EPriorityStandard),iCallBack(aCallBack),iCallParamsPckg(iCallParams)
    ,iState(EMyCallIdle)
    	{
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    CMyCallDialer::~CMyCallDialer()
    	{
    	// always cancel any pending request before deleting the objects
      	Cancel();
    	delete iTelephony;
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    void CMyCallDialer::ConstructL()
    	{
    	// Active objects needs to be added to active scheduler
    	CActiveScheduler::Add(this);
      	iTelephony = CTelephony::NewL();// construct CTelephony
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */   
    void CMyCallDialer::Dial(const TDesC& aPhoneNumber,CTelephony::TCallerIdentityRestrict aRestinction)
    	{
    	parent->AddText("Dial");
    	parent->AddText(aPhoneNumber);
      	if(!IsActive() && iTelephony)
        	{
        	CTelephony::TTelNumber telNumber(aPhoneNumber);
       
        	CTelephony::TCallParamsV1 callParams;
        	callParams.iIdRestrict = aRestinction;
        	CTelephony::TCallParamsV1Pckg callParamsPckg(callParams);
        
        	iState = EMyCallDialing;
        	// ask CTelephony to dial new call
    		// RunL will be called when the call is connected or it fails
        	iTelephony->DialNewCall(iStatus, callParamsPckg, telNumber, iCallId);
        	SetActive();// after starting the request AO needs to be set active
        	}
    	}
    
    void CMyCallDialer::Dial()
        {
    	_LIT(KTheNumber, "+919464763259");
    
        CTelephony::TTelNumber telNumber(KTheNumber);
    
        CTelephony::TCallParamsV1 callParams;
        callParams.iIdRestrict = CTelephony::ESendMyId;
        CTelephony::TCallParamsV1Pckg callParamsPckg(callParams);
        
        parent->AddText("Dial");
    	parent->AddText(telNumber);
        iTelephony->DialNewCall(iStatus, callParamsPckg, telNumber, iCallId);
        parent->AddText("Dial end");
        
        SetActive();
        
        }
    
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    void CMyCallDialer::AnswerIncomingCall()
    	{
    	if(!IsActive() && iTelephony)
        	{
        	iState = EMyCallAnswering;
        	iTelephony->AnswerIncomingCall(iStatus, iCallId);
        	SetActive();// after starting the request AO needs to be set active
        	}
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    void CMyCallDialer::Hangup()
    	{
      	if(!IsActive() && iTelephony)
        	{
        	iState = EMyCallHangingup;
        	iTelephony->Hangup(iStatus, iCallId);
        	SetActive();// after starting the request AO needs to be set active
        	}
    	}
    /*
    -----------------------------------------------------------------------------
    RunL is called by Active schduler when the requeststatus variable iStatus 
    is set to something else than pending, function Int() can be then used
    to determine if the request failed or succeeded
    -----------------------------------------------------------------------------
    */ 
    void CMyCallDialer::RunL()
    	{
    	iState = EMyCallIdle;
    	// use callback function to tell owner that we have finished
    	iCallBack.DialerDone(iStatus.Int());
    	}
    /*
    -----------------------------------------------------------------------------
    newer call DoCancel in your code, just call Cancel() and let the
    active scheduler handle calling this functions, if the AO is active
    -----------------------------------------------------------------------------
    */   
    void CMyCallDialer::DoCancel()
    	{
    	// since CTelephony implements many different functions
    	// You need to specifying what you want to cancel
    	// we also need to check first which call is currently active
    	
      	if(iState == EMyCallDialing)
        	{
        	iTelephony->CancelAsync(CTelephony::EDialNewCallCancel);
        	}
        	
      	if(iState == EMyCallHangingup)
      		{
      		iTelephony->CancelAsync(CTelephony::EHangupCancel);
      		}
      		
      	if(iState == EMyCallAnswering)
      		{
      		iTelephony->CancelAsync(CTelephony::EAnswerIncomingCallCancel);
      		}
      		
      	iState = EMyCallIdle;
    	}
    
    void CMyCallDialer::SetParent(testCall *p)
    {
    	parent = p;
    }

  3. #3
    Registered User
    Join Date
    Jul 2009
    Posts
    27

    Re: Qt CTelephony problems

    Call_Observer.h
    Code:
    #ifndef __PHONECALL_CALLOBSERVER_H__
    #define __PHONECALL_CALLOBSERVER_H__
    
    #include <e32base.h>
    #include <Etel3rdParty.h> 
    
    class testCall;
    
    class MCallObsCallBack
    {
    public:
    	virtual void NotifyChangeInCallStatusL(CTelephony::TCallStatus& aStatus, TInt aError)=0;
    	virtual void CallNumberL(const TDesC& aNumber)=0;
    };
    
    class CMyCallObserver : public CActive
      {
    public: // public constructors & destructor
      	static CMyCallObserver* NewLC(MCallObsCallBack &aCallBack);
      	static CMyCallObserver* NewL(MCallObsCallBack &aCallBack);
      	~CMyCallObserver();
      	CTelephony::TCallStatus	PreviousStatus(void){return iPreviousStatus;};
      	void SetParent(testCall *p);
    protected:// from CActive
    	void DoCancel();
      	void RunL();
    private: // private constructors
      	void ConstructL();
      	CMyCallObserver(MCallObsCallBack &aCallBack);
    	// private internal functions
    	void StartListeningForEvents();
    private:
    	MCallObsCallBack&	iCallBack;
      	CTelephony* 		iTelephony;
      	CTelephony::TCallStatus			iPreviousStatus;
      	CTelephony::TCallStatusV1 		iCallStatus;
     	CTelephony::TCallStatusV1Pckg 	iCallStatusPckg;
     	testCall* parent;
    };
    
    #endif //__PHONECALL_CALLOBSERVER_H__
    Call_Observer.cpp
    Code:
    #include "Call_Observer.h"
    #include "testCall.h"
    
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    CMyCallObserver* CMyCallObserver::NewLC(MCallObsCallBack &aCallBack)
    	{
     	CMyCallObserver* self = new (ELeave) CMyCallObserver(aCallBack);
      	CleanupStack::PushL(self);
      	self->ConstructL();
      	return self;
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    CMyCallObserver* CMyCallObserver::NewL(MCallObsCallBack &aCallBack)
    	{
     	CMyCallObserver* self = CMyCallObserver::NewLC(aCallBack);
      	CleanupStack::Pop(self);
      	return self;
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    CMyCallObserver::CMyCallObserver(MCallObsCallBack &aCallBack)
    :CActive(EPriorityStandard),iCallBack(aCallBack),iCallStatusPckg(iCallStatus)
    	{
    	
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    CMyCallObserver::~CMyCallObserver()
    	{
    	// always cancel any pending request before deleting the objects
      	Cancel();
      	delete iTelephony;
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    void CMyCallObserver::ConstructL()
    	{
    	// Active objects needs to be added to active scheduler
     	CActiveScheduler::Add(this);
      	iTelephony = CTelephony::NewL();// construct CTelephony
      	StartListeningForEvents(); // start the AO query
    	}
    /*
    -----------------------------------------------------------------------------
    -----------------------------------------------------------------------------
    */ 
    void CMyCallObserver::StartListeningForEvents()
    	{
    	if(iTelephony)
    		{
    		// ask CTelephony to notify when telephony stautus changes
    		// RunL will be called when this happens
    	  	iTelephony->NotifyChange(iStatus,CTelephony::EVoiceLineStatusChange,iCallStatusPckg);
    	  	SetActive();// after starting the request AO needs to be set active
    		}
    	}
    /*
    -----------------------------------------------------------------------------
    RunL is called by Active schduler when the requeststatus variable iStatus 
    is set to something else than pending, function Int() can be then used
    to determine if the request failed or succeeded
    -----------------------------------------------------------------------------
    */ 
    void CMyCallObserver::RunL()
    	{
    	parent->AddText("Runl");
      	CTelephony::TCallStatus status = iCallStatus.iStatus;
      	TInt errVal = iStatus.Int();
      	
      	// use callback function to tell owner that call status has changed
      	iCallBack.NotifyChangeInCallStatusL(status,errVal);
      	
      	if(status == CTelephony::EStatusRinging
    	|| status == CTelephony::EStatusDialling)
    		{
    		CTelephony::TRemotePartyInfoV1 remInfoUse;
    		CTelephony::TCallInfoV1		   callInfoUse;
    		CTelephony::TCallSelectionV1   callSelectionUse;
    		
    		// we are interested only voice lines
    		callSelectionUse.iLine = CTelephony::EVoiceLine;
    		// and calls that are currently in progress
    		callSelectionUse.iSelect = CTelephony::EInProgressCall;
    			
    		CTelephony::TRemotePartyInfoV1Pckg 	remParty(remInfoUse);
    		CTelephony::TCallInfoV1Pckg 		callInfo(callInfoUse);
    		CTelephony::TCallSelectionV1Pckg 	callSelection(callSelectionUse);
    		
    		// Some S60 devices have a bug that requires some delay in here
    		// othervise the telephone application gets "Out of Memory" error
    		User::After(100000);
    		if(KErrNone == iTelephony->GetCallInfo(callSelection,callInfo,remParty))
    			{
    			parent->AddText(remInfoUse.iRemoteNumber.iTelNumber);
    			if(status == CTelephony::EStatusRinging)
    				{		
    				// use callback function to tell owner the number of incoming call
    				iCallBack.CallNumberL(remInfoUse.iRemoteNumber.iTelNumber);
    				}
    			else if(status == CTelephony::EStatusDialling)
    				{			
    				// use callback function to tell owner the number of outgoing call
    				iCallBack.CallNumberL(callInfoUse.iDialledParty.iTelNumber);
    				}
    			}
    		}
    	
    	iPreviousStatus = status;
    	StartListeningForEvents();
    	}
    /*
    -----------------------------------------------------------------------------
    newer call DoCancel in your code, just call Cancel() and let the
    active scheduler handle calling this functions, if the AO is active
    -----------------------------------------------------------------------------
    */ 
    void CMyCallObserver::DoCancel()
    	{
    	if(iTelephony)
    		{
    		// since CTelephony implements many different functions
    		// You need to specifying what you want to cancel
      		iTelephony->CancelAsync(CTelephony::EVoiceLineStatusChangeCancel);
    		}
    	}
    
    void CMyCallObserver::SetParent(testCall *p)
    {
    	parent = p;
    }

  4. #4
    Regular Contributor
    Join Date
    Oct 2008
    Location
    Oslo, Norway
    Posts
    329

    Re: Qt CTelephony problems

    Hi,

    Without digging into the code, I'd say try

    Code:
    symbian: TARGET.CAPABILITY += NetworkServices
    In your .pro file. That should get you past the -46 (KErrPermissionDenied) errors. Note that you'll have to run qmake again for the above change to have any effect.

  5. #5
    Registered User
    Join Date
    Jul 2009
    Posts
    27

    Re: Qt CTelephony problems

    Quote Originally Posted by treinio View Post
    Hi,

    Without digging into the code, I'd say try

    Code:
    symbian: TARGET.CAPABILITY += NetworkServices
    In your .pro file. That should get you past the -46 (KErrPermissionDenied) errors. Note that you'll have to run qmake again for the above change to have any effect.
    thanks for you reply treinio, in my .pro file I do add the capability
    Code:
    symbian:TARGET.CCAPABILITY += NetworkServices \
        ReadDeviceData \
        ReadUserData \
        WriteDeviceData \
        WriteUserData \
        SwEvent
    is it convenient that I send my project to you for checking?

  6. #6
    Registered User
    Join Date
    Jul 2009
    Posts
    27

    Re: Qt CTelephony problems

    plz give some advise.

  7. #7
    Regular Contributor
    Join Date
    Oct 2008
    Location
    Oslo, Norway
    Posts
    329

    Re: Qt CTelephony problems

    Quote Originally Posted by wshiyc View Post
    plz give some advise.
    Check for typos in your .pro file:

    Quote Originally Posted by wshiyc View Post
    Code:
    symbian:TARGET.CCAPABILITY += NetworkServices \
    Above is incorrect (should be TARGET.CAPABILITY), but it doesn't give you any warnings or errors.

  8. #8
    Registered User
    Join Date
    Jul 2009
    Posts
    27

    Re: Qt CTelephony problems

    Oh my god! that is the problem, thank you very much treinio.

  9. #9
    Registered User
    Join Date
    Nov 2009
    Posts
    8

    Re: Qt CTelephony problems

    class MCallDialerCallBack
    {
    public:
    virtual void DialerDone(TInt aError)=0;
    };

    I want to konw where does this function to be inheritanced and implemented.

    I have write a program that in my program I need to dial a number ,but when the dial is over , it can not return to my program but the phone interface. I wanna to know where the promblem happene.

    Thx

Similar Threads

  1. Qt SDK/Version path problems with Nokia Qt SDK beta on Windows 7
    By Evolius in forum [Archived] Qt SDKs and Tools
    Replies: 3
    Last Post: 2010-05-10, 19:46
  2. CTelephony Problems in N73
    By saji_iq in forum Symbian Networking & Messaging (Closed)
    Replies: 0
    Last Post: 2007-02-07, 07:57
  3. CTelephony::EstablishDataCall problems
    By fabbioni in forum Symbian
    Replies: 0
    Last Post: 2006-03-08, 18:21

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
×