/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndReprogramFallback().</remarks>
/// <param name="aDeviceId"></param>
/// <param name="aFileUri"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginReprogramFallback(String aDeviceId, String aFileUri, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionReprogramFallback, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionReprogramFallback.InputParameter(inIndex++), aDeviceId));
invocation.AddInput(new ArgumentString((ParameterString)iActionReprogramFallback.InputParameter(inIndex++), aFileUri));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetSender().</remarks>
/// <param name="aUri"></param>
/// <param name="aMetadata"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetSender(String aUri, String aMetadata, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetSender, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSetSender.InputParameter(inIndex++), aUri));
invocation.AddInput(new ArgumentString((ParameterString)iActionSetSender.InputParameter(inIndex++), aMetadata));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetAssociation().</remarks>
/// <param name="aInputIndex"></param>
/// <param name="aDeviceId"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetAssociation(uint aInputIndex, String aDeviceId, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetAssociation, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetAssociation.InputParameter(inIndex++), aInputIndex));
invocation.AddInput(new ArgumentString((ParameterString)iActionSetAssociation.InputParameter(inIndex++), aDeviceId));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndErase().</remarks>
/// <param name="aId"></param>
/// <param name="aAddress"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginErase(uint aId, uint aAddress, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionErase, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionErase.InputParameter(inIndex++), aId));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionErase.InputParameter(inIndex++), aAddress));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSwap().</remarks>
/// <param name="aIndex1"></param>
/// <param name="aIndex2"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSwap(uint aIndex1, uint aIndex2, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSwap, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSwap.InputParameter(inIndex++), aIndex1));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSwap.InputParameter(inIndex++), aIndex2));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetEnabled().</remarks>
/// <param name="aId"></param>
/// <param name="aEnabled"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetEnabled(String aId, bool aEnabled, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetEnabled, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSetEnabled.InputParameter(inIndex++), aId));
invocation.AddInput(new ArgumentBool((ParameterBool)iActionSetEnabled.InputParameter(inIndex++), aEnabled));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetColor().</remarks>
/// <param name="aIndex"></param>
/// <param name="aColor"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetColor(uint aIndex, uint aColor, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetColor, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetColor.InputParameter(inIndex++), aIndex));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetColor.InputParameter(inIndex++), aColor));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetUpdateFeedParams().</remarks>
/// <param name="aTopic"></param>
/// <param name="aChannel"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetUpdateFeedParams(String aTopic, String aChannel, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetUpdateFeedParams, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSetUpdateFeedParams.InputParameter(inIndex++), aTopic));
invocation.AddInput(new ArgumentString((ParameterString)iActionSetUpdateFeedParams.InputParameter(inIndex++), aChannel));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetAssociated().</remarks>
/// <param name="aAesKeyRsaEncrypted"></param>
/// <param name="aInitVectorRsaEncrypted"></param>
/// <param name="aTokenAesEncrypted"></param>
/// <param name="aAssociated"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetAssociated(byte[] aAesKeyRsaEncrypted, byte[] aInitVectorRsaEncrypted, byte[] aTokenAesEncrypted, bool aAssociated, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetAssociated, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentBinary((ParameterBinary)iActionSetAssociated.InputParameter(inIndex++), aAesKeyRsaEncrypted));
invocation.AddInput(new ArgumentBinary((ParameterBinary)iActionSetAssociated.InputParameter(inIndex++), aInitVectorRsaEncrypted));
invocation.AddInput(new ArgumentBinary((ParameterBinary)iActionSetAssociated.InputParameter(inIndex++), aTokenAesEncrypted));
invocation.AddInput(new ArgumentBool((ParameterBool)iActionSetAssociated.InputParameter(inIndex++), aAssociated));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndEraseSectors().</remarks>
/// <param name="aId"></param>
/// <param name="aFirstSector"></param>
/// <param name="aLastSector"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginEraseSectors(uint aId, uint aFirstSector, uint aLastSector, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionEraseSectors, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionEraseSectors.InputParameter(inIndex++), aId));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionEraseSectors.InputParameter(inIndex++), aFirstSector));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionEraseSectors.InputParameter(inIndex++), aLastSector));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndWrite().</remarks>
/// <param name="aId"></param>
/// <param name="aAddress"></param>
/// <param name="aSource"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginWrite(uint aId, uint aAddress, byte[] aSource, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionWrite, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionWrite.InputParameter(inIndex++), aId));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionWrite.InputParameter(inIndex++), aAddress));
invocation.AddInput(new ArgumentBinary((ParameterBinary)iActionWrite.InputParameter(inIndex++), aSource));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetParameter().</remarks>
/// <param name="aTarget"></param>
/// <param name="aName"></param>
/// <param name="aValue"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetParameter(String aTarget, String aName, String aValue, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetParameter, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSetParameter.InputParameter(inIndex++), aTarget));
invocation.AddInput(new ArgumentString((ParameterString)iActionSetParameter.InputParameter(inIndex++), aName));
invocation.AddInput(new ArgumentString((ParameterString)iActionSetParameter.InputParameter(inIndex++), aValue));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSet().</remarks>
/// <param name="aId"></param>
/// <param name="aUserName"></param>
/// <param name="aPassword"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSet(String aId, String aUserName, byte[] aPassword, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSet, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSet.InputParameter(inIndex++), aId));
invocation.AddInput(new ArgumentString((ParameterString)iActionSet.InputParameter(inIndex++), aUserName));
invocation.AddInput(new ArgumentBinary((ParameterBinary)iActionSet.InputParameter(inIndex++), aPassword));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetPreferences().</remarks>
/// <param name="aPreferences"></param>
/// <param name="aLeastCommonChangedNode"></param>
/// <param name="aExpectedRevision"></param>
/// <param name="aOnConflict"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetPreferences(String aPreferences, String aLeastCommonChangedNode, uint aExpectedRevision, String aOnConflict, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetPreferences, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSetPreferences.InputParameter(inIndex++), aPreferences));
invocation.AddInput(new ArgumentString((ParameterString)iActionSetPreferences.InputParameter(inIndex++), aLeastCommonChangedNode));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetPreferences.InputParameter(inIndex++), aExpectedRevision));
invocation.AddInput(new ArgumentString((ParameterString)iActionSetPreferences.InputParameter(inIndex++), aOnConflict));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndReLogin().</remarks>
/// <param name="aId"></param>
/// <param name="aCurrentToken"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginReLogin(String aId, String aCurrentToken, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionReLogin, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionReLogin.InputParameter(inIndex++), aId));
invocation.AddInput(new ArgumentString((ParameterString)iActionReLogin.InputParameter(inIndex++), aCurrentToken));
int outIndex = 0;
invocation.AddOutput(new ArgumentString((ParameterString)iActionReLogin.OutputParameter(outIndex++)));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndRenew().</remarks>
/// <param name="aSid"></param>
/// <param name="aRequestedDuration"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginRenew(String aSid, uint aRequestedDuration, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionRenew, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionRenew.InputParameter(inIndex++), aSid));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionRenew.InputParameter(inIndex++), aRequestedDuration));
int outIndex = 0;
invocation.AddOutput(new ArgumentUint((ParameterUint)iActionRenew.OutputParameter(outIndex++)));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSet().</remarks>
/// <param name="aDeviceId"></param>
/// <param name="aBankId"></param>
/// <param name="aFileUri"></param>
/// <param name="aMute"></param>
/// <param name="aPersist"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSet(String aDeviceId, uint aBankId, String aFileUri, bool aMute, bool aPersist, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSet, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSet.InputParameter(inIndex++), aDeviceId));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSet.InputParameter(inIndex++), aBankId));
invocation.AddInput(new ArgumentString((ParameterString)iActionSet.InputParameter(inIndex++), aFileUri));
invocation.AddInput(new ArgumentBool((ParameterBool)iActionSet.InputParameter(inIndex++), aMute));
invocation.AddInput(new ArgumentBool((ParameterBool)iActionSet.InputParameter(inIndex++), aPersist));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndRead().</remarks>
/// <param name="aId"></param>
/// <param name="aAddress"></param>
/// <param name="aLength"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginRead(uint aId, uint aAddress, uint aLength, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionRead, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionRead.InputParameter(inIndex++), aId));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionRead.InputParameter(inIndex++), aAddress));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionRead.InputParameter(inIndex++), aLength));
int outIndex = 0;
invocation.AddOutput(new ArgumentBinary((ParameterBinary)iActionRead.OutputParameter(outIndex++)));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSubscribe().</remarks>
/// <param name="aClientId"></param>
/// <param name="aUdn"></param>
/// <param name="aService"></param>
/// <param name="aRequestedDuration"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSubscribe(String aClientId, String aUdn, String aService, uint aRequestedDuration, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSubscribe, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSubscribe.InputParameter(inIndex++), aClientId));
invocation.AddInput(new ArgumentString((ParameterString)iActionSubscribe.InputParameter(inIndex++), aUdn));
invocation.AddInput(new ArgumentString((ParameterString)iActionSubscribe.InputParameter(inIndex++), aService));
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSubscribe.InputParameter(inIndex++), aRequestedDuration));
int outIndex = 0;
invocation.AddOutput(new ArgumentString((ParameterString)iActionSubscribe.OutputParameter(outIndex++)));
invocation.AddOutput(new ArgumentUint((ParameterUint)iActionSubscribe.OutputParameter(outIndex++)));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndPrepareForConnection().</remarks>
/// <param name="aRemoteProtocolInfo"></param>
/// <param name="aPeerConnectionManager"></param>
/// <param name="aPeerConnectionID"></param>
/// <param name="aDirection"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginPrepareForConnection(String aRemoteProtocolInfo, String aPeerConnectionManager, int aPeerConnectionID, String aDirection, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionPrepareForConnection, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionPrepareForConnection.InputParameter(inIndex++), aRemoteProtocolInfo));
invocation.AddInput(new ArgumentString((ParameterString)iActionPrepareForConnection.InputParameter(inIndex++), aPeerConnectionManager));
invocation.AddInput(new ArgumentInt((ParameterInt)iActionPrepareForConnection.InputParameter(inIndex++), aPeerConnectionID));
invocation.AddInput(new ArgumentString((ParameterString)iActionPrepareForConnection.InputParameter(inIndex++), aDirection));
int outIndex = 0;
invocation.AddOutput(new ArgumentInt((ParameterInt)iActionPrepareForConnection.OutputParameter(outIndex++)));
invocation.AddOutput(new ArgumentInt((ParameterInt)iActionPrepareForConnection.OutputParameter(outIndex++)));
invocation.AddOutput(new ArgumentInt((ParameterInt)iActionPrepareForConnection.OutputParameter(outIndex++)));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndClear().</remarks>
/// <param name="aId"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginClear(String aId, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionClear, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionClear.InputParameter(inIndex++), aId));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndUnsubscribe().</remarks>
/// <param name="aSid"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginUnsubscribe(String aSid, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionUnsubscribe, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionUnsubscribe.InputParameter(inIndex++), aSid));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetBootMode().</remarks>
/// <param name="aMode"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetBootMode(String aMode, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetBootMode, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSetBootMode.InputParameter(inIndex++), aMode));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndPushManifest().</remarks>
/// <param name="aUri"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginPushManifest(String aUri, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionPushManifest, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionPushManifest.InputParameter(inIndex++), aUri));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndConnectionComplete().</remarks>
/// <param name="aConnectionID"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginConnectionComplete(int aConnectionID, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionConnectionComplete, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentInt((ParameterInt)iActionConnectionComplete.InputParameter(inIndex++), aConnectionID));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetTarget().</remarks>
/// <param name="aNewTargetValue"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetTarget(bool aNewTargetValue, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetTarget, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentBool((ParameterBool)iActionSetTarget.InputParameter(inIndex++), aNewTargetValue));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetAudioChannels().</remarks>
/// <param name="aAudioChannels"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetAudioChannels(String aAudioChannels, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetAudioChannels, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionSetAudioChannels.InputParameter(inIndex++), aAudioChannels));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndSetDelay().</remarks>
/// <param name="aDelay"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginSetDelay(uint aDelay, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionSetDelay, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentUint((ParameterUint)iActionSetDelay.InputParameter(inIndex++), aDelay));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndGetChallengeResponse().</remarks>
/// <param name="aChallenge"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginGetChallengeResponse(String aChallenge, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionGetChallengeResponse, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionGetChallengeResponse.InputParameter(inIndex++), aChallenge));
int outIndex = 0;
invocation.AddOutput(new ArgumentString((ParameterString)iActionGetChallengeResponse.OutputParameter(outIndex++)));
iService.InvokeAction(invocation);
}
/// <summary>
/// Invoke the action asynchronously
/// </summary>
/// <remarks>Returns immediately and will run the client-specified callback when the action
/// later completes. Any output arguments can then be retrieved by calling
/// EndDeviceSettings().</remarks>
/// <param name="aDeviceId"></param>
/// <param name="aCallback">Delegate to run when the action completes.
/// This is guaranteed to be run but may indicate an error</param>
public void BeginDeviceSettings(String aDeviceId, CallbackAsyncComplete aCallback)
{
Invocation invocation = iService.Invocation(iActionDeviceSettings, aCallback);
int inIndex = 0;
invocation.AddInput(new ArgumentString((ParameterString)iActionDeviceSettings.InputParameter(inIndex++), aDeviceId));
int outIndex = 0;
invocation.AddOutput(new ArgumentString((ParameterString)iActionDeviceSettings.OutputParameter(outIndex++)));
iService.InvokeAction(invocation);
}
