repo created

app/src/main/java/com/nextcloud/talk/call/CallParticipantModel.java

@@ -0,0 +1,190 @@
+/*
+ * Nextcloud Talk - Android Client
+ *
+ * SPDX-FileCopyrightText: 2022 Daniel Calviño Sánchez <danxuliu@gmail.com>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+package com.nextcloud.talk.call;
+
+import android.os.Handler;
+
+import com.nextcloud.talk.models.json.participants.Participant;
+
+import org.webrtc.MediaStream;
+import org.webrtc.PeerConnection;
+
+import java.util.Objects;
+
+/**
+ * Read-only data model for (remote) call participants.
+ * <p>
+ * If the hand was never raised null is returned by "getRaisedHand()". Otherwise a RaisedHand object is returned with
+ * the current state (raised or not) and the timestamp when the raised hand state last changed.
+ * <p>
+ * The received audio and video are available only if the participant is sending them and also has them enabled.
+ * Before a connection is established it is not known whether audio and video are available or not, so null is returned
+ * in that case (therefore it should not be autoboxed to a plain boolean without checking that).
+ * <p>
+ * Audio and video in screen shares, on the other hand, are always seen as available.
+ * <p>
+ * Actor type and actor id will be set only in Talk >= 20.
+ * <p>
+ * Clients of the model can observe it with CallParticipantModel.Observer to be notified when any value changes.
+ * Getters called after receiving a notification are guaranteed to provide at least the value that triggered the
+ * notification, but it may return even a more up to date one (so getting the value again on the following
+ * notification may return the same value as before).
+ * <p>
+ * Besides onChange(), which notifies about changes in the model values, CallParticipantModel.Observer provides
+ * additional methods to be notified about one-time events that are not reflected in the model values, like reactions.
+ */
+public class CallParticipantModel {
+
+    protected final CallParticipantModelNotifier callParticipantModelNotifier = new CallParticipantModelNotifier();
+
+    protected final String sessionId;
+
+    protected Data<Participant.ActorType> actorType;
+    protected Data<String> actorId;
+    protected Data<String> userId;
+    protected Data<String> nick;
+
+    protected Data<Boolean> internal;
+
+    protected Data<RaisedHand> raisedHand;
+
+    protected Data<PeerConnection.IceConnectionState> iceConnectionState;
+    protected Data<MediaStream> mediaStream;
+    protected Data<Boolean> audioAvailable;
+    protected Data<Boolean> videoAvailable;
+
+    protected Data<PeerConnection.IceConnectionState> screenIceConnectionState;
+    protected Data<MediaStream> screenMediaStream;
+
+    public interface Observer {
+        void onChange();
+        void onReaction(String reaction);
+    }
+
+    protected class Data<T> {
+
+        private T value;
+
+        public T getValue() {
+            return value;
+        }
+
+        public void setValue(T value) {
+            if (Objects.equals(this.value, value)) {
+                return;
+            }
+
+            this.value = value;
+
+            callParticipantModelNotifier.notifyChange();
+        }
+    }
+
+    public CallParticipantModel(String sessionId) {
+        this.sessionId = sessionId;
+
+        this.actorType = new Data<>();
+        this.actorId = new Data<>();
+        this.userId = new Data<>();
+        this.nick = new Data<>();
+
+        this.internal = new Data<>();
+
+        this.raisedHand = new Data<>();
+
+        this.iceConnectionState = new Data<>();
+        this.mediaStream = new Data<>();
+        this.audioAvailable = new Data<>();
+        this.videoAvailable = new Data<>();
+
+        this.screenIceConnectionState = new Data<>();
+        this.screenMediaStream = new Data<>();
+    }
+
+    public String getSessionId() {
+        return sessionId;
+    }
+
+    public Participant.ActorType getActorType() {
+        return actorType.getValue();
+    }
+
+    public String getActorId() {
+        return actorId.getValue();
+    }
+
+    public String getUserId() {
+        return userId.getValue();
+    }
+
+    public String getNick() {
+        return nick.getValue();
+    }
+
+    public Boolean isInternal() {
+        return internal.getValue();
+    }
+
+    public RaisedHand getRaisedHand() {
+        return raisedHand.getValue();
+    }
+
+    public PeerConnection.IceConnectionState getIceConnectionState() {
+        return iceConnectionState.getValue();
+    }
+
+    public MediaStream getMediaStream() {
+        return mediaStream.getValue();
+    }
+
+    public Boolean isAudioAvailable() {
+        return audioAvailable.getValue();
+    }
+
+    public Boolean isVideoAvailable() {
+        return videoAvailable.getValue();
+    }
+
+    public PeerConnection.IceConnectionState getScreenIceConnectionState() {
+        return screenIceConnectionState.getValue();
+    }
+
+    public MediaStream getScreenMediaStream() {
+        return screenMediaStream.getValue();
+    }
+
+    /**
+     * Adds an Observer to be notified when any value changes.
+     *
+     * @param observer the Observer
+     * @see CallParticipantModel#addObserver(Observer, Handler)
+     */
+    public void addObserver(Observer observer) {
+        addObserver(observer, null);
+    }
+
+    /**
+     * Adds an observer to be notified when any value changes.
+     * <p>
+     * The observer will be notified on the thread associated to the given handler. If no handler is given the
+     * observer will be immediately notified on the same thread that changed the value; the observer will be
+     * immediately notified too if the thread of the handler is the same thread that changed the value.
+     * <p>
+     * An observer is expected to be added only once. If the same observer is added again it will be notified just
+     * once on the thread of the last handler.
+     *
+     * @param observer the Observer
+     * @param handler a Handler for the thread to be notified on
+     */
+    public void addObserver(Observer observer, Handler handler) {
+        callParticipantModelNotifier.addObserver(observer, handler);
+    }
+
+    public void removeObserver(Observer observer) {
+        callParticipantModelNotifier.removeObserver(observer);
+    }
+}