CTelephony error -8071 E65 DialNewCall Access denied

[plemanach]

Hi,

I Get a -8071 error when i use DialNewCall code on E65 :

The DialNewCall follow a Hangup.

Despite the error code 8071 the call keep going but i cant't monitor : i use RegisterForAsyncNotification and i get Access denied error.

Can you Help me ?

void CIsvTelCallAppTelephony::TelApiWrapperMakeNewCallL( 
    CTelephony::TCallId aCallId,
    TBuf<CTelephony::KMaxTelNumberSize> aTelNumber)
    {
    if ( IsActive() )
    	{
    	return;
    	}
    
    iTelApiCmd = EMakeNewCall;
    CTelephony::TCallParamsV1 callParams;
    CTelephony::TCallParamsV1Pckg callParamPckg( callParams );
    iCallId = aCallId;
    iTelNum = aTelNumber;
    
        
#ifdef __WINS__
    CAknErrorNote* errorNoteMsg = new (ELeave) CAknErrorNote;
    errorNoteMsg->ExecuteLD(iEmuApiNotSupported);
#else
    iTel->DialNewCall( iStatus, callParamPckg, iTelNum, 
        iCallId, CTelephony::EVoiceLine );
    
    SetActive();
    StartWait();
#endif
    }

void CIsvTelCallAppTelephony::HangUpOnGoingCall()
	{
		RWsSession ws; 
		ws.Connect(); 
		TRawEvent ev1;  
		ev1.Set(TRawEvent::EKeyDown, EStdKeyNo); 
		ws.SimulateRawEvent(ev1); // CAPABILITY Req. SwEvent
		User::After(1000000); 
		TRawEvent ev2;  
		ev2.Set(TRawEvent::EKeyUp, EStdKeyNo); 
		ws.SimulateRawEvent(ev2); // CAPABILITY Req. SwEvent
		ws.Close();
	}

void CIsvTelCallAppTelephony::RegisterForAsyncNotification( TInt aAsyncEvent )
    {
    if (IsActive())
    	{
    	return;
    	}
	iTelApiCmd = EAsyncEvent;    
	switch(aAsyncEvent)
	    {
		case CTelephony::EOwnedCall1StatusChange :
		    {
			iEvent = CTelephony::EOwnedCall1StatusChange;
            iCallStatus.iStatus = CTelephony::EStatusUnknown;
		    }
		    break;
		case CTelephony::EOwnedCall2StatusChange :
		    {
			iEvent = CTelephony::EOwnedCall2StatusChange;					
            iCallStatus.iStatus = CTelephony::EStatusUnknown;
		    }
		    break;
		case CTelephony::EVoiceLineStatusChange :
		    {
			iEvent = CTelephony::EVoiceLineStatusChange;
		    }
		    break;
		default :
		    break;	
	    }
		iTel->NotifyChange(iStatus, iEvent, iCallStatusPckg);
    	SetActive();
    }

Best regards

[symbianyucca]

This has been discussed quite many times. the problem is actually network related, and it appears that some networks are doing the fixes for the problem already.

anyway, meanwhile turn your device to use GSM only (from the default dual mode).

[plemanach]

Yes i read these posts and i contourned the first by wait 2 secondes between hangup and call again and i turn to gsm only but my real problem is i can't monitor the second call : I get a access denied after the NotifyChange I can't get status to the second call and i didn't read about it in threads.

[elviin]

Hello,

I would like to catch events like CTelephony::EStatusConnecting, or CTelephony::EStatusDisconnecting but I always get the status -8071. Despite suggestion and clues like "red button" or "gsm" this api seems to be quite unreliable doesn't it? I can catch these events using RCall api, but I need to use CTelephony anyway.

[symbianyucca]

just debug your code, and make sure you are using it correctly. At least I have found the API rather reliable.

[elviin]

Where could be the bug? I have checked also this wiki post how to make a call and this post how to monitor a call event. Is it necessary to have 2 AO's one for making calls and the second for monitoring? The example in c:\S60\devices\S60_5th_Edition_SDK_v1.0\S60CppExamples\IsvTelCallApp is using just one AO. I do not see any difference between my and this project in the sense of making calls.

void CDialService::DialNumber(const Vp::CContact& aContact, const TInt aNumberIndex, MDialServiceObserver* aObserver)
{
    iObserver = aObserver;
        
    if (IsActive())
    {
        Cancel();
    }
    
    CTelephony::TTelNumber telNumber( aContact.PhoneList()[aNumberIndex]->ToString());
 
    CTelephony::TCallParamsV1 callParams;
    callParams.iIdRestrict = CTelephony::ESendMyId;
    CTelephony::TCallParamsV1Pckg callParamsPckg(callParams);
 
    iTelephony->DialNewCall(iStatus, callParamsPckg, telNumber, iCallId, CTelephony::EVoiceLine);
 
    User::After(1000);
    
    SetActive();
}

void CDialService::ConstructL()
{
     CActiveScheduler::Add(this); // Add to scheduler  
     iTelephony = CTelephony::NewL();
}
 
CDialService::~CDialService()
{
     if(IsActive())
      {
      Cancel(); 
      }
     
     if (iTelephony)
     {
     delete iTelephony;
     iTelephony = NULL;
     }
}
 
 
CDialService::CDialService()
    : CActive(CActive::EPriorityStandard), 
      isDialedNumber(false),
      iLineStatusPckg( iLineStatus )
{      
    //default constructor
}

CDialService* CDialService::NewLC()
{
    CDialService* self = new (ELeave) CDialService();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
}

CDialService* CDialService::NewL()
{
    CDialService* self = CDialService::NewLC();
    CleanupStack::Pop(); // self;
    return self;
}
 
void CDialService::ListenForCallStatus()
{ 
    VPLOGFUNTAG();
    
     if (!IsActive()) 
     {
         iTelephony->NotifyChange(iStatus,CTelephony::EVoiceLineStatusChange,iLineStatusPckg);
         SetActive();
     }
}
 
void CDialService::RunL()
{
    VPLOGFUNTAG();
    
    if(!iObserver) return;
    
    VPLOG( _L("iStatus = %d"), iStatus.Int() ); //always getting -8071
    
    if(iStatus == KErrNone)
    {
        iTelephony->GetCallStatus( iCallId, iLineStatusPckg );
        
        CTelephony::TCallStatus callStatus = iLineStatus.iStatus;
        
        switch(callStatus)
        {
        case CTelephony::EStatusUnknown:
        {
            VPLOG( _L("callStatus -> EStatusUnknown"));
            
            break;
        }
        case CTelephony::EStatusIdle:
        {
            VPLOG( _L("callStatus -> EStatusIdle"));
            
            break;
        }
        case CTelephony::EStatusDialling:
        {
            VPLOG( _L("callStatus -> EStatusDialling"));
            break;
        }
        case CTelephony::EStatusRinging:
        {
            VPLOG( _L("callStatus -> EStatusRinging"));
            
            break;
        }
        case CTelephony::EStatusAnswering:
        {
            VPLOG( _L("callStatus -> EStatusAnswering"));
            
            break;
        }
        case CTelephony::EStatusConnecting:
        {
            VPLOG( _L("callStatus -> EStatusConnecting"));
            
            break;
        }
        case CTelephony::EStatusConnected:
        {
            VPLOG( _L("callStatus -> EStatusConnected"));
            iObserver->DialServiceMessageState(CTelephony::EStatusConnected);
            iObserver = NULL;

            break;
        }
        case CTelephony::EStatusReconnectPending:
        {
            VPLOG( _L("callStatus -> EStatusReconnectPending"));
            
            break;
        }
        case CTelephony::EStatusDisconnecting:
        {
            VPLOG( _L("callStatus -> EStatusDisconnecting"));
            
            break;
        }
        case CTelephony::EStatusHold:
        {
            VPLOG( _L("callStatus -> EStatusHold"));
            
            break;
        }
        case CTelephony::EStatusTransferring:
        {
            VPLOG( _L("callStatus -> EStatusTransferring"));
            
            break;
        }
        case CTelephony::EStatusTransferAlerting:
        {
            VPLOG( _L("callStatus -> EStatusTransferAlerting"));
            
            break;
        }
        default:
        {
            __ASSERT_DEBUG(
                    0, 
                    User::Panic(
                        Vp::Panics::Gui::DialService::KGlDialNotHandled, 
                        Vp::Panics::Gui::DialService::KGlDialNotHandledCode
                    )
            );
        
            Cancel();
            break;
        }
        }
    }
    else
    {
        __ASSERT_DEBUG(
                0, 
                User::Panic(
                    Vp::Panics::Gui::DialService::KGlDialNotHandled, 
                    Vp::Panics::Gui::DialService::KGlDialNotHandledCode
                )
        );
    }
    
    
}
 
void CDialService::DoCancel()
{
    iTelephony->CancelAsync(CTelephony::EDialNewCallCancel);
}

TInt CDialService::RunError( TInt aError )
{
    return aError;
}

[symbianyucca]

you must have two AO's, otherwise you end up missing the event's while you are doing somehting different, so please try it out with two separate AO's each doing their own tasks only.

[elviin]

Ok. Thank you Yucca. But as in the below mentioned example (c:\S60\devices\S60_5th_Edition_SDK_v1.0\S60CppExamples\IsvTelCallApp) there is only one AO and all events are properly propagated to AO's RunL().

[symbianyucca]

I have not checked that example, anyway, if you have an reguest such as dialing, while your reguests for line-state-monitoring are no active, you definetely will lose events, so, upto you, do it with one, if you think it is ok for you, and if you really need to see all states as they come, then you might want to consider the advise given.

[elviin]

That decoupling into two AO's works. Thank you Yucca.