一个简单的封装类：

//h

class CCallHandler : public CActive
{
public:
 static CCallHandler* NewL();
 ~CCallHandler();

private:
 CCallHandler();
 void ConstructL();

 // inherited from CActive
 void RunL();
 void DoCancel();

 void StartL();
 void Stop();

 enum TState { EWaiting, EAnswering, EWatching };
private:
 RTelServer iServer;
 RPhone  iPhone;
 RLine  iLine;
 RAdvGsmCall iCall;
 RTelServer::TPhoneInfo iPhoneInfo;
 RPhone::TLineInfo  iLineInfo;
 TName   iCallName;
 RCall::TStatus iCallStatus;
 TInt   iNumberPhones;
 TState   iState;
 
 RFileLogger  iLog;
};

//cpp

      void CCallHandler::ConstructL()
{
 iLog.Connect();
 iLog.CreateLog(_L("Logs"),_L("calltest.txt"),EFileLoggingModeOverwrite);
 

 CActiveScheduler::Add(this);

// TInt numLines;
 
 _LIT (KTsyName,"phonetsy.tsy");
 
 iServer.Connect();
 iServer.LoadPhoneModule(KTsyName);

 iServer.GetPhoneInfo(0, iPhoneInfo);
 iPhone.Open(iServer, iPhoneInfo.iName);
 iPhone.Initialise();

 TInt numberPhones = 0;
 iServer.EnumeratePhones(numberPhones);
 
 TBool foundLine = EFalse;
 for(TInt a = 0; a < numberPhones; a++)
 {
  User::LeaveIfError(iPhone.GetLineInfo(a, iLineInfo));
  if(iLineInfo.iLineCapsFlags & RLine::KCapsVoice)
  {
   foundLine = ETrue;
   break;
  }
 }

 if(!foundLine)
  User::Leave(KErrNotFound);
 
 User::LeaveIfError(iLine.Open(iPhone, iLineInfo.iName));

 RDebug::Print(iPhoneInfo.iName);
 
 StartL();
}

void CCallHandler::RunL()
{
 if(iStatus.Int() != KErrNone)
  return;
 
 switch(iState)
 {
 case EWaiting:
  {
   // answer the call
   iState = EAnswering;
   StartL();
   break;
  }
 case EAnswering:
  {
   iState = EWatching;
   StartL();
  // iObserver.HandleCallInChangeL(RCall::EStatusConnected);
   break;
  }
 case EWatching:
  {
   User::LeaveIfError(iCall.GetStatus(iCallStatus));
   if (iCallStatus == RCall::EStatusHangingUp)
   {
  //  iObserver.HandleCallInChangeL(iCallStatus);
    iCall.Close();
    iState = EWaiting;
   }
   StartL();
   break;
  }
 }
}

void CCallHandler::StartL()
{
 switch(iState)
 {
 case EWaiting:
  iLog.Write(_L("EWaiting"));
  // sets iCallName when it receives an incoming call
  iLine.NotifyIncomingCall(iStatus, iCallName);
  break;
 case EAnswering:
  {
   iLog.Write(_L("EAnswering"));
   iLog.Write(iCallName);
   
   User::LeaveIfError(iCall.OpenExistingCall(iLine, iCallName));

   RAdvGsmCall::TDialledNumberInfo dialInfo;
   iCall.GetDialledNumberInfo(dialInfo);
   
   iLog.Write(dialInfo.iName);
   iLog.Write(dialInfo.iNumber.iTelNumber);
   iLog.WriteFormat(_L("type = %d"), dialInfo.iNumber.iTypeOfNumber);

   RAdvGsmCall::TRemotePartyInfo remotepartyinfo;
   iCall.GetRemotePartyInfo(remotepartyinfo);
   iLog.WriteFormat(_L("len = %d"), remotepartyinfo.iNumber.iTelNumber.Length());
   iLog.Write(remotepartyinfo.iNumber.iTelNumber);
  
  // iCall.AnswerIncomingCall(iStatus);
  }
  break;
 case EWatching:
  iLog.Write(_L("EWatching"));
  iCall.NotifyStatusChange(iStatus, iCallStatus);
  break;
 }
 SetActive();
}

void CCallHandler::Stop()
{
 switch(iState)
 {
 case EWaiting:
  iLine.NotifyIncomingCallCancel();
  break;
 case EAnswering:
  iCall.Close();
  break;
 case EWatching:
  iCall.NotifyStatusChangeCancel();
  iCall.Close();
  break;
 }
}