update raise hand feature after arb

Author: rzdor

articles/communication-services/how-tos/calling-sdk/includes/raise-hand/raise-hand-android.md

@@ -39,23 +39,23 @@ Currently ACS calls aren't allowed to change state of other participants, for ex
 ```java
 RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND);
 //lower all hands on the call
-raiseHandFeature.lowerHandForEveryone();
+raiseHandFeature.lowerAllHands();
 //or we can provide array of CommunicationIdentifier to specify list of participants
 List<CommunicationIdentifier> identifiers = new ArrayList<>();
 CommunicationUserIdentifier acsUser = new CommunicationUserIdentifier(<USER_ID>);
 MicrosoftTeamsUserIdentifier teamsUser = new MicrosoftTeamsUserIdentifier(<USER_ID>);
 identifiers.add(new CommunicationUserIdentifier("<USER_ID>"));
 identifiers.add(new MicrosoftTeamsUserIdentifier("<USER_ID>"));
-raiseHandFeature.lowerHand(identifiers);
+raiseHandFeature.lowerHands(identifiers);
 ```
 
 ### Handle changed states
-The `Raise Hand` API allows you to subscribe to `raiseHandChanged` events. A `raiseHandChanged` event comes from a `call` instance and contain information about participant and new state.
+The `Raise Hand` API allows you to subscribe to `raiseHandChanged` or `loweredHandChanged` events. Event comes from a `call` instance and contain information about participant and new state.
 ```java
 RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND)
 
 // event example : {identifier: CommunicationIdentifier, isRaised: true, order:1}
-call.feature(Features.RAISE_HAND).addOnRaiseHandReceivedListener(raiseHandEvent -> {
+call.feature(Features.RAISE_HAND).addOnRaisedHandReceivedListener(raiseHandEvent -> {
     Log.i(TAG, String.format("Raise Hand: %s : %s", Utilities.toMRI(raiseHandEvent.getIdentifier()), raiseHandEvent.isRaised()));
 });
 ```
@@ -64,24 +64,17 @@ call.feature(Features.RAISE_HAND).addOnRaiseHandReceivedListener(raiseHandEvent
 To get information about all participants that have Raise Hand state on current call, you can use this api array is sorted by order field:
 ```java
 RaiseHandFeature raiseHandFeature = call.feature(Features.RAISE_HAND);
-List<RaiseHand> activeStates = raiseHandFeature.getStatus();
+List<RaiseHand> activeStates = raiseHandFeature.getRaisedHands();
 ```
 
 ### Order of raised Hands
 It possible to get order of all raised hand states on the call, this order is started from 1.
-There are two ways: get all raise hand state on the call or use `raiseHandChanged` event subscription.
 In event subscription when any participant will lower a hand - call will generate only one event, but not for all participants with order above.
 
 ```java
 const raiseHandFeature = call.feature(Features.RaiseHand );
-for (RaiseHand state : raiseHandFeature.getStatus() {
+for (RaiseHand state : raiseHandFeature.getRaisedHands() {
     CommunicationIdentifier identifier = state.getIdentifier();
     int order = state.getOrder();
 }
-
-
-// event example: {identifier: CommunicationIdentifier, isRaised: true, order:1}
-call.feature(Features.RAISE_HAND).addOnRaiseHandReceivedListener(raiseHandEvent -> {
-    Log.i(TAG, String.format("Raise Hand: %s : %s", Utilities.toMRI(raiseHandEvent.getIdentifier()), raiseHandEvent.getOrder()));
-});
 ```

articles/communication-services/how-tos/calling-sdk/includes/raise-hand/raise-hand-ios.md

@@ -50,15 +50,15 @@ Currently ACS calls aren't allowed to change state of other participants, for ex
 ```swift
 
 // remove raise hand states for all participants on the call
-raisehandFeature.lowerHandForEveryone(completionHandler: { (error) in
+raisehandFeature.lowerAllHands(completionHandler: { (error) in
     if let error = error {
         print ("Feature failed lower all hands %@", error as Error)
     }
 })
 
 // remove raise hand states for all remote participants on the call
 let identifiers = (call?.remoteParticipants.map {$0.identifier})!;
-raisehandFeature.lowerHand(participants: identifiers, completionHandler: { (error) in
+raisehandFeature.lowerHands(participants: identifiers, completionHandler: { (error) in
     if let error = error {
         print ("Feature failed lower hands %@", error as Error)
     }
@@ -67,7 +67,7 @@ raisehandFeature.lowerHand(participants: identifiers, completionHandler: { (erro
 // remove raise hand state of specific user
 var identifiers : [CommunicationIdentifier] = []
 identifiers.append(CommunicationUserIdentifier("<USER_ID>"))
-raisehandFeature.lowerHand(participants: identifiers, completionHandler: { (error) in
+raisehandFeature.lowerHands(participants: identifiers, completionHandler: { (error) in
     if let error = error {
         print ("Feature failed lower hands %@", error as Error)
     }
@@ -76,7 +76,7 @@ raisehandFeature.lowerHand(participants: identifiers, completionHandler: { (erro
 ```
 
 ### Handle changed states
-The `Raise Hand` API allows you to subscribe to `didReceiveRaiseHandEvent` events. A `didReceiveRaiseHandEvent` event comes from a `call` instance and contain information about participant and new state.
+The `Raise Hand` API allows you to subscribe to `didReceiveRaisedHand` and `didReceiveLoweredHand` events. Event comes from a `call` instance and contain information about participant and new state.
 ```swift
 self.callObserver = CallObserver(view:self)
 
@@ -85,10 +85,16 @@ raisehandFeature!.delegate = self.callObserver
 
 public class CallObserver : NSObject, RaiseHandCallFeatureDelegate
 {
-    // event example : {identifier: CommunicationIdentifier, isRaised: true, order:1}
-    public func raiseHandCallFeature(_ raiseHandCallFeature: RaiseHandCallFeature, didReceiveRaiseHandEvent args: RaiseHandEvent) {
-        os_log("Raise hand feature updated: %s : %d", log:log, Utilities.toMri(args.identifier), args.isRaised)
-        raiseHandCallFeature.status.forEach { raiseHand in
+    // event example : {identifier: CommunicationIdentifier}
+    public func raiseHandCallFeature(_ raiseHandCallFeature: RaiseHandCallFeature, didReceiveRaisedHand args: RaisedHandChangedEventArgs) {
+        os_log("Raise hand feature updated: %s is raised hand", log:log, Utilities.toMri(args.identifier))
+        raiseHandCallFeature.raisedHands.forEach { raiseHand in
+            os_log("Raise hand active: %s", log:log, Utilities.toMri(raiseHand.identifier))
+        }
+    }
+    public func raiseHandCallFeature(_ raiseHandCallFeature: RaiseHandCallFeature, didReceiveLoweredHand args: LoweredHandChangedEventArgs) {
+        os_log("Raise hand feature updated: %s is lowered hand", log:log, Utilities.toMri(args.identifier))
+        raiseHandCallFeature.raisedHands.forEach { raiseHand in
             os_log("Raise hand active: %s", log:log, Utilities.toMri(raiseHand.identifier))
         }
     }
@@ -99,19 +105,19 @@ public class CallObserver : NSObject, RaiseHandCallFeatureDelegate
 To get information about all participants that have Raise Hand state on current call, you can use this api array is sorted by order field:
 ```swift
 raisehandFeature = self.call!.feature(Features.raiseHand)
-raisehandFeature.status.forEach { raiseHand in
+raisehandFeature.raisedHands.forEach { raiseHand in
     os_log("Raise hand active: %s", log:log, Utilities.toMri(raiseHand.identifier))
 }
 ```
 
 ### Order of raised Hands
 It possible to get order of all raised hand states on the call, order is started from 1 and will be sorted.
-There are two ways: get all raise hand state on the call or use `didReceiveRaiseHandEvent` event subscription.
+There are two ways: get all raise hand state on the call or use `didReceiveRaisedHand` event subscription.
 In event subscription when any participant will lower a hand - call will generate only one event, but not for all participants with order above.
 
 ```swift
 raisehandFeature = self.call!.feature(Features.raiseHand)
-raisehandFeature.status.forEach { raiseHand in
+raisehandFeature.raisedHands.forEach { raiseHand in
     os_log("Raise hand active: %s with order %d", log:log, Utilities.toMri(raiseHand.identifier), raiseHand.order)
 }
 ```

articles/communication-services/how-tos/calling-sdk/includes/raise-hand/raise-hand-web.md

@@ -39,47 +39,50 @@ Currently ACS calls aren't allowed to change state of other participants, for ex
 ```js
 const raiseHandFeature = call.feature(Features.RaiseHand );
 //lower all hands on the call
-raiseHandFeature.lowerHandForEveryone();
+raiseHandFeature.lowerAllHands();
 //or we can provide array of CommunicationIdentifier to specify list of participants
 CommunicationUserIdentifier acsUser = new CommunicationUserIdentifier(<USER_ID>);
 MicrosoftTeamsUserIdentifier teamsUser = new MicrosoftTeamsUserIdentifier(<USER_ID>)
 CommunicationIdentifier participants[] = new CommunicationIdentifier[]{ acsUser, teamsUser };
-raiseHandFeature.lowerHand(participants);
+raiseHandFeature.lowerHands(participants);
 ```
 
 ### Handle changed states
-The `Raise Hand` API allows you to subscribe to `raiseHandChanged` events. A `raiseHandChanged` event comes from a `call` instance and contain information about participant and new state.
+The `Raise Hand` API allows you to subscribe to `raisedHandEvent` or `loweredHandEvent` events. Events comes from a `call` instance and contain information about participant.
 ```js
 const raiseHandFeature = call.feature(Features.RaiseHand );
 
-// event : {identifier: CommunicationIdentifier, isRaised: true, order:1}
-const isRaiseHandChangedHandler = (event) => {
-    console.log(`Participant ${event.identifier} ${event.isRaised ? "Raised" : "Lower"} hand`);
+// event : {identifier: CommunicationIdentifier}
+const raisedHandChangedHandler = (event) => {
+    console.log(`Participant ${event.identifier} raised hand`);
+};
+const loweredHandChangedHandler = (event) => {
+    console.log(`Participant ${event.identifier} lowered hand`);
 };
-raiseHandFeature.feature(SDK.Features.RaiseHand).on('raiseHandChanged', isRaiseHandChangedHandler):
+raiseHandFeature.feature(SDK.Features.RaiseHand).on('raisedHandEvent', raisedHandChangedHandler):
+raiseHandFeature.feature(SDK.Features.RaiseHand).on('loweredHandEvent', loweredHandChangedHandler):
 ```
 
 ### List of all participants with active state
 To get information about all participants that have Raise Hand state on current call, you can use this api array is sorted by order field:
 ```js
 const raiseHandFeature = call.feature(Features.RaiseHand );
-let activeStates = raiseHandFeature.getStatus();
+let activeStates = raiseHandFeature.getRaisedHands();
 ```
 
 ### Order of raised Hands
 It possible to get order of all raised hand states on the call, this order is started from 1.
-There are two ways: get all raise hand state on the call or use `raiseHandChanged` event subscription.
 In event subscription when any participant will lower a hand - call will generate only one event, but not for all participants with order above.
 
 ```js
 const raiseHandFeature = call.feature(Features.RaiseHand );
 
 // event : {identifier: CommunicationIdentifier, isRaised: true, order:1}
-const isRaiseHandChangedHandler = (event) => {
+const raiseHandChangedHandler = (event) => {
     console.log(`List of participants with raised hand`);
-    for (let state : raiseHandFeature.getStatus()) {
+    for (let state : raiseHandFeature.getRaisedHands()) {
         console.log(`Participant ${state.identifier} has order ${state.order}`);
     }
 };
-raiseHandFeature.feature(SDK.Features.RaiseHand).on('raiseHandChanged', isRaiseHandChangedHandler):
+raiseHandFeature.feature(SDK.Features.RaiseHand).on('raisedHandEvent', raiseHandChangedHandler):
 ```

articles/communication-services/how-tos/calling-sdk/includes/raise-hand/raise-hand-windows.md

@@ -42,49 +42,54 @@ Currently ACS calls aren't allowed to change state of other participants, for ex
 ```csharp
 
 // remove raise hand states for all participants on the call
-raiseHandCallFeature.LowerHandForEveryoneAsync();
+raiseHandCallFeature.LowerAllHandsAsync();
 
 // remove raise hand states for all remote participants on the call
 var participants = call.RemoteParticipants;
 var identifiers = participants.Select(p => p.Identifier).ToList().AsReadOnly();
-raiseHandCallFeature.LowerHandAsync(identifiers);
+raiseHandCallFeature.LowerHandsAsync(identifiers);
 
 // remove raise hand state of specific user
 var identifiers = new List<CallIdentifier>();
 identifiers.Add(new UserCallIdentifier("USER_ID"));
-raiseHandCallFeature.LowerHandAsync(identifiers);
+raiseHandCallFeature.LowerHandsAsync(identifiers);
 ```
 
 ### Handle changed states
-The `Raise Hand` API allows you to subscribe to `didReceiveRaiseHandEvent` events. A `didReceiveRaiseHandEvent` event comes from a `call` instance and contain information about participant and new state.
+The `Raise Hand` API allows you to subscribe to `RaisedHandReceived` events. A `LoweredhandReceived` event comes from a `call` instance and contain information about participant and new state.
 ```swift
 raiseHandCallFeature = (RaiseHandCallFeature)call.GetCallFeatureExtension(CallFeatureType.RaiseHand);
-raiseHandCallFeature.OnRaiseHandReceived += OnRaiseHandChange;
+raiseHandCallFeature.RaisedHandReceived += OnRaisedHandChange;
+raiseHandCallFeature.LoweredHandReceived += OnLoweredHandChange;
 
-private async void OnRaiseHandChange(object sender, RaiseHandEvent raiseHandEvent)
+private async void OnRaisedHandChange(object sender, RaisedHandChangedEventArgs args)
 {
-    Trace.WriteLine("RaiseHandEvent: participant " + raiseHandEvent.Identifier + " is raised hand " + raiseHandEvent.IsRaised);
+    Trace.WriteLine("RaiseHandEvent: participant " + args.Identifier + " is raised hand");
+}
+
+private async void OnLoweredHandChange(object sender, RaisedHandChangedEventArgs args)
+{
+    Trace.WriteLine("RaiseHandEvent: participant " + args.Identifier + " is lowered hand");
 }
 ```
 
 ### List of all participants with active state
 To get information about all participants that have Raise Hand state on current call, you can use this api array is sorted by order field:
 ```swift
 raiseHandCallFeature = (RaiseHandCallFeature)call.GetCallFeatureExtension(CallFeatureType.RaiseHand);
-foreach (RaiseHand rh in raiseHandCallFeature.Status.ToList())
+foreach (RaiseHand rh in raiseHandCallFeature.RaisedHands.ToList())
 {
     Trace.WriteLine("Participant " + rh.Identifier.RawId + " has raised hand ");
 }
 ```
 
 ### Order of raised Hands
 It possible to get order of all raised hand states on the call, order is started from 1 and will be sorted.
-There are two ways: get all raise hand state on the call or use `didReceiveRaiseHandEvent` event subscription.
 In event subscription when any participant will lower a hand - call will generate only one event, but not for all participants with order above.
 
 ```swift
 raiseHandCallFeature = (RaiseHandCallFeature)call.GetCallFeatureExtension(CallFeatureType.RaiseHand);
-foreach (RaiseHand rh in raiseHandCallFeature.Status.ToList())
+foreach (RaiseHand rh in raiseHandCallFeature.RaisedHands.ToList())
 {
     Trace.WriteLine(rh.Order + ". " + rh.Identifier.RawId);
 }