text: #include "CpAvOpenhomeOrgRadio1.h"
  #include <OpenHome/Net/Core/CpProxy.h>
  #include <OpenHome/Net/Private/CpiService.h>
  #include <OpenHome/Private/Thread.h>
  #include <OpenHome/Net/Private/AsyncPrivate.h>
  #include <OpenHome/Net/Core/CpDevice.h>
  #include <OpenHome/Net/Private/Error.h>
  #include <OpenHome/Net/Private/CpiDevice.h>
  
  namespace OpenHome {
  namespace Net {
  
  class SyncPlayAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncPlayAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
  };
  
  class SyncPauseAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncPauseAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
  };
  
  class SyncStopAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncStopAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
  };
  
  class SyncSeekSecondAbsoluteAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncSeekSecondAbsoluteAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
  };
  
  class SyncSeekSecondRelativeAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncSeekSecondRelativeAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
  };
  
  class SyncChannelAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncChannelAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aUri, Brh& aMetadata);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      Brh& iUri;
      Brh& iMetadata;
  };
  
  class SyncSetChannelAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncSetChannelAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
  };
  
  class SyncTransportStateAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncTransportStateAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aValue);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      Brh& iValue;
  };
  
  class SyncIdAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncIdAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TUint& aValue);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      TUint& iValue;
  };
  
  class SyncSetIdAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncSetIdAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
  };
  
  class SyncReadAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncReadAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aMetadata);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      Brh& iMetadata;
  };
  
  class SyncReadListAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncReadListAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aChannelList);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      Brh& iChannelList;
  };
  
  class SyncIdArrayAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncIdArrayAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TUint& aToken, Brh& aArray);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      TUint& iToken;
      Brh& iArray;
  };
  
  class SyncIdArrayChangedAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncIdArrayChangedAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TBool& aValue);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      TBool& iValue;
  };
  
  class SyncChannelsMaxAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncChannelsMaxAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TUint& aValue);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      TUint& iValue;
  };
  
  class SyncProtocolInfoAvOpenhomeOrgRadio1 : public SyncProxyAction
  {
  public:
      SyncProtocolInfoAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aValue);
      virtual void CompleteRequest(IAsync& aAsync);
  private:
      CpProxyAvOpenhomeOrgRadio1& iService;
      Brh& iValue;
  };
  
  } // namespace Net
  } // namespace OpenHome
  
  
  using namespace OpenHome;
  using namespace OpenHome::Net;
  
  
  // SyncPlayAvOpenhomeOrgRadio1
  
  SyncPlayAvOpenhomeOrgRadio1::SyncPlayAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy)
      : iService(aProxy)
  {
  }
  
  void SyncPlayAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndPlay(aAsync);
  }
  
  // SyncPauseAvOpenhomeOrgRadio1
  
  SyncPauseAvOpenhomeOrgRadio1::SyncPauseAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy)
      : iService(aProxy)
  {
  }
  
  void SyncPauseAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndPause(aAsync);
  }
  
  // SyncStopAvOpenhomeOrgRadio1
  
  SyncStopAvOpenhomeOrgRadio1::SyncStopAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy)
      : iService(aProxy)
  {
  }
  
  void SyncStopAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndStop(aAsync);
  }
  
  // SyncSeekSecondAbsoluteAvOpenhomeOrgRadio1
  
  SyncSeekSecondAbsoluteAvOpenhomeOrgRadio1::SyncSeekSecondAbsoluteAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy)
      : iService(aProxy)
  {
  }
  
  void SyncSeekSecondAbsoluteAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndSeekSecondAbsolute(aAsync);
  }
  
  // SyncSeekSecondRelativeAvOpenhomeOrgRadio1
  
  SyncSeekSecondRelativeAvOpenhomeOrgRadio1::SyncSeekSecondRelativeAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy)
      : iService(aProxy)
  {
  }
  
  void SyncSeekSecondRelativeAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndSeekSecondRelative(aAsync);
  }
  
  // SyncChannelAvOpenhomeOrgRadio1
  
  SyncChannelAvOpenhomeOrgRadio1::SyncChannelAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aUri, Brh& aMetadata)
      : iService(aProxy)
      , iUri(aUri)
      , iMetadata(aMetadata)
  {
  }
  
  void SyncChannelAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndChannel(aAsync, iUri, iMetadata);
  }
  
  // SyncSetChannelAvOpenhomeOrgRadio1
  
  SyncSetChannelAvOpenhomeOrgRadio1::SyncSetChannelAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy)
      : iService(aProxy)
  {
  }
  
  void SyncSetChannelAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndSetChannel(aAsync);
  }
  
  // SyncTransportStateAvOpenhomeOrgRadio1
  
  SyncTransportStateAvOpenhomeOrgRadio1::SyncTransportStateAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aValue)
      : iService(aProxy)
      , iValue(aValue)
  {
  }
  
  void SyncTransportStateAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndTransportState(aAsync, iValue);
  }
  
  // SyncIdAvOpenhomeOrgRadio1
  
  SyncIdAvOpenhomeOrgRadio1::SyncIdAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TUint& aValue)
      : iService(aProxy)
      , iValue(aValue)
  {
  }
  
  void SyncIdAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndId(aAsync, iValue);
  }
  
  // SyncSetIdAvOpenhomeOrgRadio1
  
  SyncSetIdAvOpenhomeOrgRadio1::SyncSetIdAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy)
      : iService(aProxy)
  {
  }
  
  void SyncSetIdAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndSetId(aAsync);
  }
  
  // SyncReadAvOpenhomeOrgRadio1
  
  SyncReadAvOpenhomeOrgRadio1::SyncReadAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aMetadata)
      : iService(aProxy)
      , iMetadata(aMetadata)
  {
  }
  
  void SyncReadAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndRead(aAsync, iMetadata);
  }
  
  // SyncReadListAvOpenhomeOrgRadio1
  
  SyncReadListAvOpenhomeOrgRadio1::SyncReadListAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aChannelList)
      : iService(aProxy)
      , iChannelList(aChannelList)
  {
  }
  
  void SyncReadListAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndReadList(aAsync, iChannelList);
  }
  
  // SyncIdArrayAvOpenhomeOrgRadio1
  
  SyncIdArrayAvOpenhomeOrgRadio1::SyncIdArrayAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TUint& aToken, Brh& aArray)
      : iService(aProxy)
      , iToken(aToken)
      , iArray(aArray)
  {
  }
  
  void SyncIdArrayAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndIdArray(aAsync, iToken, iArray);
  }
  
  // SyncIdArrayChangedAvOpenhomeOrgRadio1
  
  SyncIdArrayChangedAvOpenhomeOrgRadio1::SyncIdArrayChangedAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TBool& aValue)
      : iService(aProxy)
      , iValue(aValue)
  {
  }
  
  void SyncIdArrayChangedAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndIdArrayChanged(aAsync, iValue);
  }
  
  // SyncChannelsMaxAvOpenhomeOrgRadio1
  
  SyncChannelsMaxAvOpenhomeOrgRadio1::SyncChannelsMaxAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, TUint& aValue)
      : iService(aProxy)
      , iValue(aValue)
  {
  }
  
  void SyncChannelsMaxAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndChannelsMax(aAsync, iValue);
  }
  
  // SyncProtocolInfoAvOpenhomeOrgRadio1
  
  SyncProtocolInfoAvOpenhomeOrgRadio1::SyncProtocolInfoAvOpenhomeOrgRadio1(CpProxyAvOpenhomeOrgRadio1& aProxy, Brh& aValue)
      : iService(aProxy)
      , iValue(aValue)
  {
  }
  
  void SyncProtocolInfoAvOpenhomeOrgRadio1::CompleteRequest(IAsync& aAsync)
  {
      iService.EndProtocolInfo(aAsync, iValue);
  }
  
  
  // CpProxyAvOpenhomeOrgRadio1
  
  CpProxyAvOpenhomeOrgRadio1::CpProxyAvOpenhomeOrgRadio1(CpDevice& aDevice)
      : iCpProxy("av-openhome-org", "Radio", 1, aDevice.Device())
  {
      OpenHome::Net::Parameter* param;
      TChar** allowedValues;
      TUint index;
  
      iActionPlay = new Action("Play");
  
      iActionPause = new Action("Pause");
  
      iActionStop = new Action("Stop");
  
      iActionSeekSecondAbsolute = new Action("SeekSecondAbsolute");
      param = new OpenHome::Net::ParameterUint("Value");
      iActionSeekSecondAbsolute->AddInputParameter(param);
  
      iActionSeekSecondRelative = new Action("SeekSecondRelative");
      param = new OpenHome::Net::ParameterInt("Value");
      iActionSeekSecondRelative->AddInputParameter(param);
  
      iActionChannel = new Action("Channel");
      param = new OpenHome::Net::ParameterString("Uri");
      iActionChannel->AddOutputParameter(param);
      param = new OpenHome::Net::ParameterString("Metadata");
      iActionChannel->AddOutputParameter(param);
  
      iActionSetChannel = new Action("SetChannel");
      param = new OpenHome::Net::ParameterString("Uri");
      iActionSetChannel->AddInputParameter(param);
      param = new OpenHome::Net::ParameterString("Metadata");
      iActionSetChannel->AddInputParameter(param);
  
      iActionTransportState = new Action("TransportState");
      index = 0;
      allowedValues = new TChar*[4];
      allowedValues[index++] = (TChar*)"Stopped";
      allowedValues[index++] = (TChar*)"Playing";
      allowedValues[index++] = (TChar*)"Paused";
      allowedValues[index++] = (TChar*)"Buffering";
      param = new OpenHome::Net::ParameterString("Value", allowedValues, 4);
      iActionTransportState->AddOutputParameter(param);
      delete[] allowedValues;
  
      iActionId = new Action("Id");
      param = new OpenHome::Net::ParameterUint("Value");
      iActionId->AddOutputParameter(param);
  
      iActionSetId = new Action("SetId");
      param = new OpenHome::Net::ParameterUint("Value");
      iActionSetId->AddInputParameter(param);
      param = new OpenHome::Net::ParameterString("Uri");
      iActionSetId->AddInputParameter(param);
  
      iActionRead = new Action("Read");
      param = new OpenHome::Net::ParameterUint("Id");
      iActionRead->AddInputParameter(param);
      param = new OpenHome::Net::ParameterString("Metadata");
      iActionRead->AddOutputParameter(param);
  
      iActionReadList = new Action("ReadList");
      param = new OpenHome::Net::ParameterString("IdList");
      iActionReadList->AddInputParameter(param);
      param = new OpenHome::Net::ParameterString("ChannelList");
      iActionReadList->AddOutputParameter(param);
  
      iActionIdArray = new Action("IdArray");
      param = new OpenHome::Net::ParameterUint("Token");
      iActionIdArray->AddOutputParameter(param);
      param = new OpenHome::Net::ParameterBinary("Array");
      iActionIdArray->AddOutputParameter(param);
  
      iActionIdArrayChanged = new Action("IdArrayChanged");
      param = new OpenHome::Net::ParameterUint("Token");
      iActionIdArrayChanged->AddInputParameter(param);
      param = new OpenHome::Net::ParameterBool("Value");
      iActionIdArrayChanged->AddOutputParameter(param);
  
      iActionChannelsMax = new Action("ChannelsMax");
      param = new OpenHome::Net::ParameterUint("Value");
      iActionChannelsMax->AddOutputParameter(param);
  
      iActionProtocolInfo = new Action("ProtocolInfo");
      param = new OpenHome::Net::ParameterString("Value");
      iActionProtocolInfo->AddOutputParameter(param);
  
      Functor functor;
      functor = MakeFunctor(*this, &CpProxyAvOpenhomeOrgRadio1::UriPropertyChanged);
      iUri = new PropertyString("Uri", functor);
      AddProperty(iUri);
      functor = MakeFunctor(*this, &CpProxyAvOpenhomeOrgRadio1::MetadataPropertyChanged);
      iMetadata = new PropertyString("Metadata", functor);
      AddProperty(iMetadata);
      functor = MakeFunctor(*this, &CpProxyAvOpenhomeOrgRadio1::TransportStatePropertyChanged);
      iTransportState = new PropertyString("TransportState", functor);
      AddProperty(iTransportState);
      functor = MakeFunctor(*this, &CpProxyAvOpenhomeOrgRadio1::IdPropertyChanged);
      iId = new PropertyUint("Id", functor);
      AddProperty(iId);
      functor = MakeFunctor(*this, &CpProxyAvOpenhomeOrgRadio1::IdArrayPropertyChanged);
      iIdArray = new PropertyBinary("IdArray", functor);
      AddProperty(iIdArray);
      functor = MakeFunctor(*this, &CpProxyAvOpenhomeOrgRadio1::ChannelsMaxPropertyChanged);
      iChannelsMax = new PropertyUint("ChannelsMax", functor);
      AddProperty(iChannelsMax);
      functor = MakeFunctor(*this, &CpProxyAvOpenhomeOrgRadio1::ProtocolInfoPropertyChanged);
      iProtocolInfo = new PropertyString("ProtocolInfo", functor);
      AddProperty(iProtocolInfo);
  }
  
  CpProxyAvOpenhomeOrgRadio1::~CpProxyAvOpenhomeOrgRadio1()
  {
      DestroyService();
      delete iActionPlay;
      delete iActionPause;
      delete iActionStop;
      delete iActionSeekSecondAbsolute;
      delete iActionSeekSecondRelative;
      delete iActionChannel;
      delete iActionSetChannel;
      delete iActionTransportState;
      delete iActionId;
      delete iActionSetId;
      delete iActionRead;
      delete iActionReadList;
      delete iActionIdArray;
      delete iActionIdArrayChanged;
      delete iActionChannelsMax;
      delete iActionProtocolInfo;
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncPlay()
  {
      SyncPlayAvOpenhomeOrgRadio1 sync(*this);
      BeginPlay(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginPlay(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionPlay, aFunctor);
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndPlay(IAsync& aAsync)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("Play"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncPause()
  {
      SyncPauseAvOpenhomeOrgRadio1 sync(*this);
      BeginPause(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginPause(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionPause, aFunctor);
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndPause(IAsync& aAsync)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("Pause"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncStop()
  {
      SyncStopAvOpenhomeOrgRadio1 sync(*this);
      BeginStop(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginStop(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionStop, aFunctor);
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndStop(IAsync& aAsync)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("Stop"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncSeekSecondAbsolute(TUint aValue)
  {
      SyncSeekSecondAbsoluteAvOpenhomeOrgRadio1 sync(*this);
      BeginSeekSecondAbsolute(aValue, sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginSeekSecondAbsolute(TUint aValue, FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionSeekSecondAbsolute, aFunctor);
      TUint inIndex = 0;
      const Action::VectorParameters& inParams = iActionSeekSecondAbsolute->InputParameters();
      invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aValue));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndSeekSecondAbsolute(IAsync& aAsync)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("SeekSecondAbsolute"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncSeekSecondRelative(TInt aValue)
  {
      SyncSeekSecondRelativeAvOpenhomeOrgRadio1 sync(*this);
      BeginSeekSecondRelative(aValue, sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginSeekSecondRelative(TInt aValue, FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionSeekSecondRelative, aFunctor);
      TUint inIndex = 0;
      const Action::VectorParameters& inParams = iActionSeekSecondRelative->InputParameters();
      invocation->AddInput(new ArgumentInt(*inParams[inIndex++], aValue));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndSeekSecondRelative(IAsync& aAsync)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("SeekSecondRelative"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncChannel(Brh& aUri, Brh& aMetadata)
  {
      SyncChannelAvOpenhomeOrgRadio1 sync(*this, aUri, aMetadata);
      BeginChannel(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginChannel(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionChannel, aFunctor);
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionChannel->OutputParameters();
      invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
      invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndChannel(IAsync& aAsync, Brh& aUri, Brh& aMetadata)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("Channel"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      ((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aUri);
      ((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aMetadata);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncSetChannel(const Brx& aUri, const Brx& aMetadata)
  {
      SyncSetChannelAvOpenhomeOrgRadio1 sync(*this);
      BeginSetChannel(aUri, aMetadata, sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginSetChannel(const Brx& aUri, const Brx& aMetadata, FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionSetChannel, aFunctor);
      TUint inIndex = 0;
      const Action::VectorParameters& inParams = iActionSetChannel->InputParameters();
      invocation->AddInput(new ArgumentString(*inParams[inIndex++], aUri));
      invocation->AddInput(new ArgumentString(*inParams[inIndex++], aMetadata));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndSetChannel(IAsync& aAsync)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("SetChannel"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncTransportState(Brh& aValue)
  {
      SyncTransportStateAvOpenhomeOrgRadio1 sync(*this, aValue);
      BeginTransportState(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginTransportState(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionTransportState, aFunctor);
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionTransportState->OutputParameters();
      invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndTransportState(IAsync& aAsync, Brh& aValue)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("TransportState"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      ((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aValue);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncId(TUint& aValue)
  {
      SyncIdAvOpenhomeOrgRadio1 sync(*this, aValue);
      BeginId(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginId(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionId, aFunctor);
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionId->OutputParameters();
      invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndId(IAsync& aAsync, TUint& aValue)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("Id"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      aValue = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncSetId(TUint aValue, const Brx& aUri)
  {
      SyncSetIdAvOpenhomeOrgRadio1 sync(*this);
      BeginSetId(aValue, aUri, sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginSetId(TUint aValue, const Brx& aUri, FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionSetId, aFunctor);
      TUint inIndex = 0;
      const Action::VectorParameters& inParams = iActionSetId->InputParameters();
      invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aValue));
      invocation->AddInput(new ArgumentString(*inParams[inIndex++], aUri));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndSetId(IAsync& aAsync)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("SetId"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncRead(TUint aId, Brh& aMetadata)
  {
      SyncReadAvOpenhomeOrgRadio1 sync(*this, aMetadata);
      BeginRead(aId, sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginRead(TUint aId, FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionRead, aFunctor);
      TUint inIndex = 0;
      const Action::VectorParameters& inParams = iActionRead->InputParameters();
      invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aId));
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionRead->OutputParameters();
      invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndRead(IAsync& aAsync, Brh& aMetadata)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("Read"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      ((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aMetadata);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncReadList(const Brx& aIdList, Brh& aChannelList)
  {
      SyncReadListAvOpenhomeOrgRadio1 sync(*this, aChannelList);
      BeginReadList(aIdList, sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginReadList(const Brx& aIdList, FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionReadList, aFunctor);
      TUint inIndex = 0;
      const Action::VectorParameters& inParams = iActionReadList->InputParameters();
      invocation->AddInput(new ArgumentString(*inParams[inIndex++], aIdList));
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionReadList->OutputParameters();
      invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndReadList(IAsync& aAsync, Brh& aChannelList)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("ReadList"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      ((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aChannelList);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncIdArray(TUint& aToken, Brh& aArray)
  {
      SyncIdArrayAvOpenhomeOrgRadio1 sync(*this, aToken, aArray);
      BeginIdArray(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginIdArray(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionIdArray, aFunctor);
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionIdArray->OutputParameters();
      invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
      invocation->AddOutput(new ArgumentBinary(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndIdArray(IAsync& aAsync, TUint& aToken, Brh& aArray)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("IdArray"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      aToken = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
      ((ArgumentBinary*)invocation.OutputArguments()[index++])->TransferTo(aArray);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncIdArrayChanged(TUint aToken, TBool& aValue)
  {
      SyncIdArrayChangedAvOpenhomeOrgRadio1 sync(*this, aValue);
      BeginIdArrayChanged(aToken, sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginIdArrayChanged(TUint aToken, FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionIdArrayChanged, aFunctor);
      TUint inIndex = 0;
      const Action::VectorParameters& inParams = iActionIdArrayChanged->InputParameters();
      invocation->AddInput(new ArgumentUint(*inParams[inIndex++], aToken));
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionIdArrayChanged->OutputParameters();
      invocation->AddOutput(new ArgumentBool(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndIdArrayChanged(IAsync& aAsync, TBool& aValue)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("IdArrayChanged"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      aValue = ((ArgumentBool*)invocation.OutputArguments()[index++])->Value();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncChannelsMax(TUint& aValue)
  {
      SyncChannelsMaxAvOpenhomeOrgRadio1 sync(*this, aValue);
      BeginChannelsMax(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginChannelsMax(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionChannelsMax, aFunctor);
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionChannelsMax->OutputParameters();
      invocation->AddOutput(new ArgumentUint(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndChannelsMax(IAsync& aAsync, TUint& aValue)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("ChannelsMax"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      aValue = ((ArgumentUint*)invocation.OutputArguments()[index++])->Value();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SyncProtocolInfo(Brh& aValue)
  {
      SyncProtocolInfoAvOpenhomeOrgRadio1 sync(*this, aValue);
      BeginProtocolInfo(sync.Functor());
      sync.Wait();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::BeginProtocolInfo(FunctorAsync& aFunctor)
  {
      Invocation* invocation = iCpProxy.GetService().Invocation(*iActionProtocolInfo, aFunctor);
      TUint outIndex = 0;
      const Action::VectorParameters& outParams = iActionProtocolInfo->OutputParameters();
      invocation->AddOutput(new ArgumentString(*outParams[outIndex++]));
      iCpProxy.GetInvocable().InvokeAction(*invocation);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::EndProtocolInfo(IAsync& aAsync, Brh& aValue)
  {
      ASSERT(((Async&)aAsync).Type() == Async::eInvocation);
      Invocation& invocation = (Invocation&)aAsync;
      ASSERT(invocation.Action().Name() == Brn("ProtocolInfo"));
  
      Error::ELevel level;
      TUint code;
      const TChar* ignore;
      if (invocation.Error(level, code, ignore)) {
          THROW_PROXYERROR(level, code);
      }
      TUint index = 0;
      ((ArgumentString*)invocation.OutputArguments()[index++])->TransferTo(aValue);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyUriChanged(Functor& aFunctor)
  {
      iCpProxy.GetLock().Wait();
      iUriChanged = aFunctor;
      iCpProxy.GetLock().Signal();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyMetadataChanged(Functor& aFunctor)
  {
      iCpProxy.GetLock().Wait();
      iMetadataChanged = aFunctor;
      iCpProxy.GetLock().Signal();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyTransportStateChanged(Functor& aFunctor)
  {
      iCpProxy.GetLock().Wait();
      iTransportStateChanged = aFunctor;
      iCpProxy.GetLock().Signal();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyIdChanged(Functor& aFunctor)
  {
      iCpProxy.GetLock().Wait();
      iIdChanged = aFunctor;
      iCpProxy.GetLock().Signal();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyIdArrayChanged(Functor& aFunctor)
  {
      iCpProxy.GetLock().Wait();
      iIdArrayChanged = aFunctor;
      iCpProxy.GetLock().Signal();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyChannelsMaxChanged(Functor& aFunctor)
  {
      iCpProxy.GetLock().Wait();
      iChannelsMaxChanged = aFunctor;
      iCpProxy.GetLock().Signal();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyProtocolInfoChanged(Functor& aFunctor)
  {
      iCpProxy.GetLock().Wait();
      iProtocolInfoChanged = aFunctor;
      iCpProxy.GetLock().Signal();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::PropertyUri(Brhz& aUri) const
  {
      AutoMutex a(iCpProxy.PropertyReadLock());
      if (iCpProxy.GetSubscriptionStatus() != CpProxy::eSubscribed) {
          THROW(ProxyNotSubscribed);
      }
      aUri.Set(iUri->Value());
  }
  
  void CpProxyAvOpenhomeOrgRadio1::PropertyMetadata(Brhz& aMetadata) const
  {
      AutoMutex a(iCpProxy.PropertyReadLock());
      if (iCpProxy.GetSubscriptionStatus() != CpProxy::eSubscribed) {
          THROW(ProxyNotSubscribed);
      }
      aMetadata.Set(iMetadata->Value());
  }
  
  void CpProxyAvOpenhomeOrgRadio1::PropertyTransportState(Brhz& aTransportState) const
  {
      AutoMutex a(iCpProxy.PropertyReadLock());
      if (iCpProxy.GetSubscriptionStatus() != CpProxy::eSubscribed) {
          THROW(ProxyNotSubscribed);
      }
      aTransportState.Set(iTransportState->Value());
  }
  
  void CpProxyAvOpenhomeOrgRadio1::PropertyId(TUint& aId) const
  {
      AutoMutex a(iCpProxy.PropertyReadLock());
      if (iCpProxy.GetSubscriptionStatus() != CpProxy::eSubscribed) {
          THROW(ProxyNotSubscribed);
      }
      aId = iId->Value();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::PropertyIdArray(Brh& aIdArray) const
  {
      AutoMutex a(iCpProxy.PropertyReadLock());
      if (iCpProxy.GetSubscriptionStatus() != CpProxy::eSubscribed) {
          THROW(ProxyNotSubscribed);
      }
      aIdArray.Set(iIdArray->Value());
  }
  
  void CpProxyAvOpenhomeOrgRadio1::PropertyChannelsMax(TUint& aChannelsMax) const
  {
      AutoMutex a(iCpProxy.PropertyReadLock());
      if (iCpProxy.GetSubscriptionStatus() != CpProxy::eSubscribed) {
          THROW(ProxyNotSubscribed);
      }
      aChannelsMax = iChannelsMax->Value();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::PropertyProtocolInfo(Brhz& aProtocolInfo) const
  {
      AutoMutex a(iCpProxy.PropertyReadLock());
      if (iCpProxy.GetSubscriptionStatus() != CpProxy::eSubscribed) {
          THROW(ProxyNotSubscribed);
      }
      aProtocolInfo.Set(iProtocolInfo->Value());
  }
  
  void CpProxyAvOpenhomeOrgRadio1::UriPropertyChanged()
  {
      ReportEvent(iUriChanged);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::MetadataPropertyChanged()
  {
      ReportEvent(iMetadataChanged);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::TransportStatePropertyChanged()
  {
      ReportEvent(iTransportStateChanged);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::IdPropertyChanged()
  {
      ReportEvent(iIdChanged);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::IdArrayPropertyChanged()
  {
      ReportEvent(iIdArrayChanged);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::ChannelsMaxPropertyChanged()
  {
      ReportEvent(iChannelsMaxChanged);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::ProtocolInfoPropertyChanged()
  {
      ReportEvent(iProtocolInfoChanged);
  }
  
  
  void CpProxyAvOpenhomeOrgRadio1::Subscribe()
  {
    iCpProxy.Subscribe();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::Unsubscribe()
  {
   iCpProxy.Unsubscribe();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyChanged(Functor& aFunctor)
  {
    iCpProxy.SetPropertyChanged(aFunctor);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::SetPropertyInitialEvent(Functor& aFunctor)
  {
    iCpProxy.SetPropertyInitialEvent(aFunctor);
  }
  void CpProxyAvOpenhomeOrgRadio1::AddProperty(Property* aProperty)
  {
    iCpProxy.AddProperty(aProperty);
  }
  
  void CpProxyAvOpenhomeOrgRadio1::DestroyService()
  {
    iCpProxy.DestroyService();
  }
  
  void CpProxyAvOpenhomeOrgRadio1::ReportEvent(Functor aFunctor)
  {
    iCpProxy.ReportEvent(aFunctor);
  }
  
  TUint CpProxyAvOpenhomeOrgRadio1::Version() const
  {
    return iCpProxy.Version();
  }
  
  
  