ut_telephony_epoc.cpp

Go to the documentation of this file.

// generated code -- do not edit

#include "ut_telephony_epoc.h"

void ClosureFunc_SignalStrength(bb_Blackboard *, enum bb_DataType, gpointer, int, gpointer arg);

void ClosureFunc_NetworkInfo(bb_Blackboard *, enum bb_DataType, gpointer, int, gpointer arg);

void ClosureFunc_NetworkRegistration(bb_Blackboard *, enum bb_DataType, gpointer, int, gpointer arg);

CGetterAo_FlightMode::CGetterAo_FlightMode(CTelephony &aTelephony, MGetterObs_FlightMode &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CGetterAo_FlightMode::~CGetterAo_FlightMode()
{
  Cancel();
}

void CGetterAo_FlightMode::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.GetFlightMode(iStatus, iDataDes);
    SetActive();
  }
}

void CGetterAo_FlightMode::RunL()
{
  iInterface.GotData_FlightMode(iStatus.Int());
}

void CGetterAo_FlightMode::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EGetFlightModeCancel);
}

CNotifyAo_FlightMode::CNotifyAo_FlightMode(CTelephony &aTelephony, MNotifyObs_FlightMode &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CNotifyAo_FlightMode::~CNotifyAo_FlightMode()
{
  Cancel();
}

void CNotifyAo_FlightMode::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.NotifyChange(iStatus, CTelephony::EFlightModeChange, iDataDes);
    SetActive();
  }
}

void CNotifyAo_FlightMode::RunL()
{
  iInterface.ChangedData_FlightMode(iStatus.Int());
}

void CNotifyAo_FlightMode::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EFlightModeChangeCancel);
}

CNotifyAo_CallStatus::CNotifyAo_CallStatus(CTelephony &aTelephony, MNotifyObs_CallStatus &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CNotifyAo_CallStatus::~CNotifyAo_CallStatus()
{
  Cancel();
}

void CNotifyAo_CallStatus::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.NotifyChange(iStatus, CTelephony::EVoiceLineStatusChange, iDataDes);
    SetActive();
  }
}

void CNotifyAo_CallStatus::RunL()
{
  iInterface.ChangedData_CallStatus(iStatus.Int());
}

void CNotifyAo_CallStatus::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EVoiceLineStatusChangeCancel);
}

CGetterAo_BatteryInfo::CGetterAo_BatteryInfo(CTelephony &aTelephony, MGetterObs_BatteryInfo &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CGetterAo_BatteryInfo::~CGetterAo_BatteryInfo()
{
  Cancel();
}

void CGetterAo_BatteryInfo::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.GetBatteryInfo(iStatus, iDataDes);
    SetActive();
  }
}

void CGetterAo_BatteryInfo::RunL()
{
  iInterface.GotData_BatteryInfo(iStatus.Int());
}

void CGetterAo_BatteryInfo::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EGetBatteryInfoCancel);
}

CNotifyAo_BatteryInfo::CNotifyAo_BatteryInfo(CTelephony &aTelephony, MNotifyObs_BatteryInfo &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CNotifyAo_BatteryInfo::~CNotifyAo_BatteryInfo()
{
  Cancel();
}

void CNotifyAo_BatteryInfo::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.NotifyChange(iStatus, CTelephony::EBatteryInfoChange, iDataDes);
    SetActive();
  }
}

void CNotifyAo_BatteryInfo::RunL()
{
  iInterface.ChangedData_BatteryInfo(iStatus.Int());
}

void CNotifyAo_BatteryInfo::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EBatteryInfoChangeCancel);
}

CGetterAo_SignalStrength::CGetterAo_SignalStrength(CTelephony &aTelephony, MGetterObs_SignalStrength &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CGetterAo_SignalStrength::~CGetterAo_SignalStrength()
{
  Cancel();
}

void CGetterAo_SignalStrength::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.GetSignalStrength(iStatus, iDataDes);
    SetActive();
  }
}

void CGetterAo_SignalStrength::RunL()
{
  iInterface.GotData_SignalStrength(iStatus.Int());
}

void CGetterAo_SignalStrength::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EGetSignalStrengthCancel);
}

CNotifyAo_SignalStrength::CNotifyAo_SignalStrength(CTelephony &aTelephony, MNotifyObs_SignalStrength &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CNotifyAo_SignalStrength::~CNotifyAo_SignalStrength()
{
  Cancel();
}

void CNotifyAo_SignalStrength::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.NotifyChange(iStatus, CTelephony::ESignalStrengthChange, iDataDes);
    SetActive();
  }
}

void CNotifyAo_SignalStrength::RunL()
{
  iInterface.ChangedData_SignalStrength(iStatus.Int());
}

void CNotifyAo_SignalStrength::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::ESignalStrengthChangeCancel);
}

CGetterAo_NetworkRegistration::CGetterAo_NetworkRegistration(CTelephony &aTelephony, MGetterObs_NetworkRegistration &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CGetterAo_NetworkRegistration::~CGetterAo_NetworkRegistration()
{
  Cancel();
}

void CGetterAo_NetworkRegistration::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.GetNetworkRegistrationStatus(iStatus, iDataDes);
    SetActive();
  }
}

void CGetterAo_NetworkRegistration::RunL()
{
  iInterface.GotData_NetworkRegistration(iStatus.Int());
}

void CGetterAo_NetworkRegistration::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EGetNetworkRegistrationStatusCancel);
}

CNotifyAo_NetworkRegistration::CNotifyAo_NetworkRegistration(CTelephony &aTelephony, MNotifyObs_NetworkRegistration &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CNotifyAo_NetworkRegistration::~CNotifyAo_NetworkRegistration()
{
  Cancel();
}

void CNotifyAo_NetworkRegistration::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.NotifyChange(iStatus, CTelephony::ENetworkRegistrationStatusChange, iDataDes);
    SetActive();
  }
}

void CNotifyAo_NetworkRegistration::RunL()
{
  iInterface.ChangedData_NetworkRegistration(iStatus.Int());
}

void CNotifyAo_NetworkRegistration::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::ENetworkRegistrationStatusChangeCancel);
}

CGetterAo_NetworkInfo::CGetterAo_NetworkInfo(CTelephony &aTelephony, MGetterObs_NetworkInfo &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CGetterAo_NetworkInfo::~CGetterAo_NetworkInfo()
{
  Cancel();
}

void CGetterAo_NetworkInfo::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.GetCurrentNetworkInfo(iStatus, iDataDes);
    SetActive();
  }
}

void CGetterAo_NetworkInfo::RunL()
{
  iInterface.GotData_NetworkInfo(iStatus.Int());
}

void CGetterAo_NetworkInfo::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::EGetCurrentNetworkInfoCancel);
}

CNotifyAo_NetworkInfo::CNotifyAo_NetworkInfo(CTelephony &aTelephony, MNotifyObs_NetworkInfo &aInterface) : CActive(EPriorityStandard), iDataDes(iData), iTelephony(aTelephony), iInterface(aInterface)
{
  CActiveScheduler::Add(this);
}

CNotifyAo_NetworkInfo::~CNotifyAo_NetworkInfo()
{
  Cancel();
}

void CNotifyAo_NetworkInfo::MakeRequest()
{
  if ((!IsActive())) {
    iTelephony.NotifyChange(iStatus, CTelephony::ECurrentNetworkInfoChange, iDataDes);
    SetActive();
  }
}

void CNotifyAo_NetworkInfo::RunL()
{
  iInterface.ChangedData_NetworkInfo(iStatus.Int());
}

void CNotifyAo_NetworkInfo::DoCancel()
{
  iTelephony.CancelAsync(CTelephony::ECurrentNetworkInfoChangeCancel);
}

CObserverAo_SignalStrength *CObserverAo_SignalStrength::NewLC(ac_AppContext *aAppContext, MObserverObs_SignalStrength &aInterface)
{
  CObserverAo_SignalStrength *object = new (ELeave) CObserverAo_SignalStrength(aAppContext, aInterface);
  CleanupStack::PushL(object);
  object->ConstructL();
  return object;
}

CObserverAo_SignalStrength *CObserverAo_SignalStrength::NewL(ac_AppContext *aAppContext, MObserverObs_SignalStrength &aInterface)
{
  CObserverAo_SignalStrength *object = NewLC(aAppContext, aInterface);
  CleanupStack::Pop();
  return object;
}

CObserverAo_SignalStrength::CObserverAo_SignalStrength(ac_AppContext *aAppContext, MObserverObs_SignalStrength &aInterface) : iAppContext(aAppContext), iInterface(aInterface)
{
}

CObserverAo_SignalStrength::~CObserverAo_SignalStrength()
{
  BbUnregister();
  (delete iRetryAo);
  (delete iNotifier);
  (delete iGetter);
}

void CObserverAo_SignalStrength::ConstructL()
{
  BbRegisterL();
  (iRetryAo = CRetryAo::NewL((*this), 20, 60));
  (iGetter = new (ELeave) CGetterAo_SignalStrength(ac_Telephony(iAppContext), (*this)));
  (iNotifier = new (ELeave) CNotifyAo_SignalStrength(ac_Telephony(iAppContext), (*this)));
  if ((!GetFlightMode())) {
    iGetter->MakeRequest();
  }
}

void CObserverAo_SignalStrength::BbRegisterL()
{
  (iClosure.changed = ClosureFunc_SignalStrength);
  (iClosure.arg = this);
  if ((!bb_Blackboard_register(ac_get_Blackboard(iAppContext), bb_dt_flightmode, iClosure, NULL))) {
    User::LeaveNoMemory();
  }
}

void CObserverAo_SignalStrength::BbUnregister()
{
  bb_Blackboard_unregister(ac_get_Blackboard(iAppContext), iClosure);
}

void CObserverAo_SignalStrength::MakeRequest()
{
  if (iGetterDone) {
    iNotifier->MakeRequest();
  } else {
    iGetter->MakeRequest();
  }
}

void CObserverAo_SignalStrength::Cancel()
{
  iNotifier->Cancel();
  iGetter->Cancel();
  iRetryAo->Cancel();
  iRetryAo->ResetFailures();
  (iGetterDone = EFalse);
}

TBool CObserverAo_SignalStrength::GetFlightMode() const
{
  return bb_Blackboard_board(ac_global_Blackboard)->flightmode;
}

void CObserverAo_SignalStrength::HandleFlightModeChange()
{
  if (GetFlightMode()) {
    Cancel();
    iInterface.InFlightMode_SignalStrength();
  } else {
    MakeRequest();
  }
}

void CObserverAo_SignalStrength::RetryTimerExpired(CRetryAo *, TInt aError)
{
  if (aError) {
    er_log_symbian(er_FATAL, aError, "retry timer error in CObserverAo_SignalStrength");
  } else {
    MakeRequest();
  }
}

void CObserverAo_SignalStrength::GotData_SignalStrength(TInt aError)
{
  HandleData(aError, iGetter->Data());
  if ((!aError)) {
    (iGetterDone = ETrue);
  }
}

void CObserverAo_SignalStrength::ChangedData_SignalStrength(TInt aError)
{
  HandleData(aError, iNotifier->Data());
}

void CObserverAo_SignalStrength::HandleData(TInt aError, TData_SignalStrength const &aData)
{
  if (aError) {
    iInterface.ReportTransientError_SignalStrength(aError);
    if ((!iRetryAo->Retry())) {
      iInterface.RetriesExhausted_SignalStrength();
    }
  } else {
    iRetryAo->ResetFailures();
    iNotifier->MakeRequest();
    iInterface.ObservedData_SignalStrength(aData);
  }
}

void ClosureFunc_SignalStrength(bb_Blackboard *, enum bb_DataType, gpointer, int, gpointer arg)
{
  (reinterpret_cast<CObserverAo_SignalStrength *>(arg))->HandleFlightModeChange();
}

CObserverAo_NetworkInfo *CObserverAo_NetworkInfo::NewLC(ac_AppContext *aAppContext, MObserverObs_NetworkInfo &aInterface)
{
  CObserverAo_NetworkInfo *object = new (ELeave) CObserverAo_NetworkInfo(aAppContext, aInterface);
  CleanupStack::PushL(object);
  object->ConstructL();
  return object;
}

CObserverAo_NetworkInfo *CObserverAo_NetworkInfo::NewL(ac_AppContext *aAppContext, MObserverObs_NetworkInfo &aInterface)
{
  CObserverAo_NetworkInfo *object = NewLC(aAppContext, aInterface);
  CleanupStack::Pop();
  return object;
}

CObserverAo_NetworkInfo::CObserverAo_NetworkInfo(ac_AppContext *aAppContext, MObserverObs_NetworkInfo &aInterface) : iAppContext(aAppContext), iInterface(aInterface)
{
}

CObserverAo_NetworkInfo::~CObserverAo_NetworkInfo()
{
  BbUnregister();
  (delete iRetryAo);
  (delete iNotifier);
  (delete iGetter);
}

void CObserverAo_NetworkInfo::ConstructL()
{
  BbRegisterL();
  (iRetryAo = CRetryAo::NewL((*this), 20, 60));
  (iGetter = new (ELeave) CGetterAo_NetworkInfo(ac_Telephony(iAppContext), (*this)));
  (iNotifier = new (ELeave) CNotifyAo_NetworkInfo(ac_Telephony(iAppContext), (*this)));
  if ((!GetFlightMode())) {
    iGetter->MakeRequest();
  }
}

void CObserverAo_NetworkInfo::BbRegisterL()
{
  (iClosure.changed = ClosureFunc_NetworkInfo);
  (iClosure.arg = this);
  if ((!bb_Blackboard_register(ac_get_Blackboard(iAppContext), bb_dt_flightmode, iClosure, NULL))) {
    User::LeaveNoMemory();
  }
}

void CObserverAo_NetworkInfo::BbUnregister()
{
  bb_Blackboard_unregister(ac_get_Blackboard(iAppContext), iClosure);
}

void CObserverAo_NetworkInfo::MakeRequest()
{
  if (iGetterDone) {
    iNotifier->MakeRequest();
  } else {
    iGetter->MakeRequest();
  }
}

void CObserverAo_NetworkInfo::Cancel()
{
  iNotifier->Cancel();
  iGetter->Cancel();
  iRetryAo->Cancel();
  iRetryAo->ResetFailures();
  (iGetterDone = EFalse);
}

TBool CObserverAo_NetworkInfo::GetFlightMode() const
{
  return bb_Blackboard_board(ac_global_Blackboard)->flightmode;
}

void CObserverAo_NetworkInfo::HandleFlightModeChange()
{
  if (GetFlightMode()) {
    Cancel();
    iInterface.InFlightMode_NetworkInfo();
  } else {
    MakeRequest();
  }
}

void CObserverAo_NetworkInfo::RetryTimerExpired(CRetryAo *, TInt aError)
{
  if (aError) {
    er_log_symbian(er_FATAL, aError, "retry timer error in CObserverAo_NetworkInfo");
  } else {
    MakeRequest();
  }
}

void CObserverAo_NetworkInfo::GotData_NetworkInfo(TInt aError)
{
  HandleData(aError, iGetter->Data());
  if ((!aError)) {
    (iGetterDone = ETrue);
  }
}

void CObserverAo_NetworkInfo::ChangedData_NetworkInfo(TInt aError)
{
  HandleData(aError, iNotifier->Data());
}

void CObserverAo_NetworkInfo::HandleData(TInt aError, TData_NetworkInfo const &aData)
{
  if (aError) {
    iInterface.ReportTransientError_NetworkInfo(aError);
    if ((!iRetryAo->Retry())) {
      iInterface.RetriesExhausted_NetworkInfo();
    }
  } else {
    iRetryAo->ResetFailures();
    iNotifier->MakeRequest();
    iInterface.ObservedData_NetworkInfo(aData);
  }
}

void ClosureFunc_NetworkInfo(bb_Blackboard *, enum bb_DataType, gpointer, int, gpointer arg)
{
  (reinterpret_cast<CObserverAo_NetworkInfo *>(arg))->HandleFlightModeChange();
}

CObserverAo_NetworkRegistration *CObserverAo_NetworkRegistration::NewLC(ac_AppContext *aAppContext, MObserverObs_NetworkRegistration &aInterface)
{
  CObserverAo_NetworkRegistration *object = new (ELeave) CObserverAo_NetworkRegistration(aAppContext, aInterface);
  CleanupStack::PushL(object);
  object->ConstructL();
  return object;
}

CObserverAo_NetworkRegistration *CObserverAo_NetworkRegistration::NewL(ac_AppContext *aAppContext, MObserverObs_NetworkRegistration &aInterface)
{
  CObserverAo_NetworkRegistration *object = NewLC(aAppContext, aInterface);
  CleanupStack::Pop();
  return object;
}

CObserverAo_NetworkRegistration::CObserverAo_NetworkRegistration(ac_AppContext *aAppContext, MObserverObs_NetworkRegistration &aInterface) : iAppContext(aAppContext), iInterface(aInterface)
{
}

CObserverAo_NetworkRegistration::~CObserverAo_NetworkRegistration()
{
  BbUnregister();
  (delete iNotifier);
  (delete iGetter);
}

void CObserverAo_NetworkRegistration::ConstructL()
{
  BbRegisterL();
  (iGetter = new (ELeave) CGetterAo_NetworkRegistration(ac_Telephony(iAppContext), (*this)));
  (iNotifier = new (ELeave) CNotifyAo_NetworkRegistration(ac_Telephony(iAppContext), (*this)));
  if ((!GetFlightMode())) {
    iGetter->MakeRequest();
  }
}

void CObserverAo_NetworkRegistration::BbRegisterL()
{
  (iClosure.changed = ClosureFunc_NetworkRegistration);
  (iClosure.arg = this);
  if ((!bb_Blackboard_register(ac_get_Blackboard(iAppContext), bb_dt_flightmode, iClosure, NULL))) {
    User::LeaveNoMemory();
  }
}

void CObserverAo_NetworkRegistration::BbUnregister()
{
  bb_Blackboard_unregister(ac_get_Blackboard(iAppContext), iClosure);
}

void CObserverAo_NetworkRegistration::MakeRequest()
{
  if (iGetterDone) {
    iNotifier->MakeRequest();
  } else {
    iGetter->MakeRequest();
  }
}

void CObserverAo_NetworkRegistration::Cancel()
{
  iNotifier->Cancel();
  iGetter->Cancel();
  (iGetterDone = EFalse);
}

TBool CObserverAo_NetworkRegistration::GetFlightMode() const
{
  return bb_Blackboard_board(ac_global_Blackboard)->flightmode;
}

void CObserverAo_NetworkRegistration::HandleFlightModeChange()
{
  if (GetFlightMode()) {
    Cancel();
    iInterface.InFlightMode_NetworkRegistration();
  } else {
    MakeRequest();
  }
}

void CObserverAo_NetworkRegistration::GotData_NetworkRegistration(TInt aError)
{
  HandleData(aError, iGetter->Data());
  if ((!aError)) {
    (iGetterDone = ETrue);
  }
}

void CObserverAo_NetworkRegistration::ChangedData_NetworkRegistration(TInt aError)
{
  HandleData(aError, iNotifier->Data());
}

void CObserverAo_NetworkRegistration::HandleData(TInt aError, TData_NetworkRegistration const &aData)
{
  if (aError) {
    iInterface.Failed_NetworkRegistration(aError);
  } else {
    iNotifier->MakeRequest();
    iInterface.ObservedData_NetworkRegistration(aData);
  }
}

void ClosureFunc_NetworkRegistration(bb_Blackboard *, enum bb_DataType, gpointer, int, gpointer arg)
{
  (reinterpret_cast<CObserverAo_NetworkRegistration *>(arg))->HandleFlightModeChange();
}