Merge pull request #50 from 3drobotics/video_pipeline_improvements

DRON-19 (Video pipeline improvements)

Author: m4gr3d

ClientLib/src/main/java/com/o3dr/android/client/Drone.java

@@ -64,7 +64,6 @@
  * Created by fhuya on 11/4/14.
  */
 public class Drone {
-
     private static final String CLAZZ_NAME = Drone.class.getName();
     private static final String TAG = Drone.class.getSimpleName();
 

ClientLib/src/main/java/com/o3dr/android/client/apis/CameraApi.java

@@ -27,7 +27,6 @@
  * @since 2.6.8
  */
 public class CameraApi extends Api {
-
     private static final ConcurrentHashMap<Drone, CameraApi> apiCache = new ConcurrentHashMap<>();
     private static final Builder<CameraApi> apiBuilder = new Builder<CameraApi>() {
         @Override
@@ -73,13 +72,14 @@ private CameraApi(Drone drone) {
      * Attempt to grab ownership and start the video stream from the connected drone. Can fail if
      * the video stream is already owned by another client.
      *
-     * @param surface  Surface object onto which the video is decoded.
-     * @param tag      Video tag.
-     * @param videoProps Non-null video properties. @see VIDEO_PROPS_UDP_PORT
-     * @param listener Register a callback to receive update of the command execution status.
+     * @param surface       Surface object onto which the video is decoded.
+     * @param tag           Video tag.
+     * @param videoProps    Non-null video properties. @see VIDEO_PROPS_UDP_PORT
+     * @param listener      Register a callback to receive update of the command execution status.
      * @since 2.6.8
      */
-    public void startVideoStream(@NonNull final Surface surface, final String tag, @NonNull Bundle videoProps, final AbstractCommandListener listener) {
+    public void startVideoStream(@NonNull final Surface surface, final String tag,
+                                 @NonNull Bundle videoProps, final AbstractCommandListener listener) {
         if (surface == null || videoProps == null) {
             postErrorEvent(CommandExecutionError.COMMAND_FAILED, listener);
             return;

ClientLib/src/main/java/com/o3dr/android/client/apis/ExperimentalApi.java

@@ -1,15 +1,24 @@
 package com.o3dr.android.client.apis;
 
 import android.os.Bundle;
+import android.os.Handler;
+import android.text.TextUtils;
+import android.util.Log;
 
 import com.o3dr.android.client.Drone;
+import com.o3dr.android.client.utils.connection.IpConnectionListener;
+import com.o3dr.android.client.utils.connection.UdpConnection;
 import com.o3dr.services.android.lib.coordinate.LatLongAlt;
+import com.o3dr.services.android.lib.drone.action.ExperimentalActions;
+import com.o3dr.services.android.lib.drone.attribute.error.CommandExecutionError;
 import com.o3dr.services.android.lib.mavlink.MavlinkMessageWrapper;
 import com.o3dr.services.android.lib.model.AbstractCommandListener;
 import com.o3dr.services.android.lib.model.action.Action;
 
+import java.nio.ByteBuffer;
 import java.util.concurrent.ConcurrentHashMap;
 
+import static com.o3dr.services.android.lib.drone.action.CameraActions.EXTRA_VIDEO_TAG;
 import static com.o3dr.services.android.lib.drone.action.ExperimentalActions.ACTION_SEND_MAVLINK_MESSAGE;
 import static com.o3dr.services.android.lib.drone.action.ExperimentalActions.ACTION_SET_RELAY;
 import static com.o3dr.services.android.lib.drone.action.ExperimentalActions.ACTION_SET_ROI;
@@ -22,12 +31,10 @@
 import static com.o3dr.services.android.lib.drone.action.ExperimentalActions.EXTRA_SERVO_PWM;
 import static com.o3dr.services.android.lib.drone.action.ExperimentalActions.EXTRA_SET_ROI_LAT_LONG_ALT;
 
-
 /**
  * Contains drone commands with no defined interaction model yet.
  */
 public class ExperimentalApi extends Api {
-
     private static final ConcurrentHashMap<Drone, ExperimentalApi> experimentalApiCache = new ConcurrentHashMap<>();
     private static final Builder<ExperimentalApi> apiBuilder = new Builder<ExperimentalApi>() {
         @Override
@@ -36,6 +43,10 @@ public ExperimentalApi build(Drone drone) {
         }
     };
 
+    private final CapabilityApi capabilityChecker;
+
+    private final VideoStreamObserver videoStreamObserver;
+
     /**
      * Retrieves an ExperimentalApi instance.
      *
@@ -50,6 +61,9 @@ public static ExperimentalApi getApi(final Drone drone) {
 
     private ExperimentalApi(Drone drone) {
         this.drone = drone;
+        this.capabilityChecker = CapabilityApi.getApi(drone);
+
+        videoStreamObserver = new VideoStreamObserver(drone.getHandler());
     }
 
     /**
@@ -149,4 +163,275 @@ public void setServo(int channel, int pwm, AbstractCommandListener listener) {
         params.putInt(EXTRA_SERVO_PWM, pwm);
         drone.performAsyncActionOnDroneThread(new Action(ACTION_SET_SERVO, params), listener);
     }
+
+    /**
+     * Attempt to grab ownership and get a lock for the video stream. Can fail if
+     * the video stream is already owned by another client.
+     *
+     * @param tag       Video tag.
+     * @param callback  Video stream observer callback.
+     *
+     * @since 2.8.1
+     */
+    public void startVideoStream(final String tag, final IVideoStreamCallback callback) {
+        if (callback == null) {
+            throw new NullPointerException("Video stream callback can't be null");
+        }
+
+        capabilityChecker.checkFeatureSupport(CapabilityApi.FeatureIds.SOLO_VIDEO_STREAMING,
+                new CapabilityApi.FeatureSupportListener() {
+                    @Override
+                    public void onFeatureSupportResult(String featureId, int result, Bundle resultInfo) {
+                        final AbstractCommandListener listener = new AbstractCommandListener() {
+                            @Override
+                            public void onSuccess() {
+                                // Start VideoStreamObserver to connect to vehicle video stream and receive
+                                // video stream packets.
+                                videoStreamObserver.setCallback(callback);
+                                videoStreamObserver.start();
+
+                                videoStreamObserver.getCallback().onVideoStreamConnecting();
+                            }
+
+                            @Override
+                            public void onError(int executionError) {
+                                videoStreamObserver.getCallback().onError(executionError);
+                            }
+
+                            @Override
+                            public void onTimeout() {
+                                videoStreamObserver.getCallback().onTimeout();
+                            }
+                        };
+
+                        switch (result) {
+                            case CapabilityApi.FEATURE_SUPPORTED:
+                                startVideoStreamForObserver(tag, listener);
+                                break;
+
+                            case CapabilityApi.FEATURE_UNSUPPORTED:
+                                postErrorEvent(CommandExecutionError.COMMAND_UNSUPPORTED, listener);
+                                break;
+
+                            default:
+                                postErrorEvent(CommandExecutionError.COMMAND_FAILED, listener);
+                                break;
+                        }
+                    }
+                });
+    }
+
+    /**
+     * Release ownership of the video stream.
+     *
+     * @param tag   Video tag.
+     *
+     * @since 2.8.1
+     */
+    public void stopVideoStream(final String tag) {
+        capabilityChecker.checkFeatureSupport(CapabilityApi.FeatureIds.SOLO_VIDEO_STREAMING,
+            new CapabilityApi.FeatureSupportListener() {
+                @Override
+                public void onFeatureSupportResult(String featureId, int result, Bundle resultInfo) {
+                    final AbstractCommandListener listener = new AbstractCommandListener() {
+                        @Override
+                        public void onSuccess() {
+                            videoStreamObserver.getCallback().onVideoStreamDisconnecting();
+
+                            videoStreamObserver.stop();
+                        }
+
+                        @Override
+                        public void onError(int executionError) {
+                            videoStreamObserver.getCallback().onError(executionError);
+                        }
+
+                        @Override
+                        public void onTimeout() {
+                            videoStreamObserver.getCallback().onTimeout();
+                        }
+                    };
+
+                    switch (result) {
+                        case CapabilityApi.FEATURE_SUPPORTED:
+                            stopVideoStreamForObserver(tag, listener);
+                            break;
+
+                        case CapabilityApi.FEATURE_UNSUPPORTED:
+                            postErrorEvent(CommandExecutionError.COMMAND_UNSUPPORTED, listener);
+                            break;
+
+                        default:
+                            postErrorEvent(CommandExecutionError.COMMAND_FAILED, listener);
+                            break;
+                    }
+                }
+            });
+    }
+
+    /**
+     * Prepending 'observer' to the tag for differentiation
+     * @param tag
+     * @return
+     */
+    private String getObserverTag(String tag){
+        return "observer"  + (TextUtils.isEmpty(tag) ? "" : "." + tag);
+    }
+
+    /**
+     * Attempt to grab ownership and start the video stream from the connected drone. Can fail if
+     * the video stream is already owned by another client.
+     *
+     * @param tag       Video tag.
+     * @param listener  Register a listener to receive update of the command execution status.
+     * @since 2.8.1
+     */
+    private void startVideoStreamForObserver(final String tag, AbstractCommandListener listener) {
+        final Bundle params = new Bundle();
+        params.putString(EXTRA_VIDEO_TAG, getObserverTag(tag));
+
+        drone.performAsyncActionOnDroneThread(new Action(ExperimentalActions.ACTION_START_VIDEO_STREAM_FOR_OBSERVER,
+            params), listener);
+    }
+
+    /**
+     * Stop the video stream from the connected drone, and release ownership.
+     *
+     * @param tag      Video tag.
+     * @param listener Register a listener to receive update of the command execution status.
+     * @since 2.8.1
+     */
+    private void stopVideoStreamForObserver(final String tag, AbstractCommandListener listener) {
+        final Bundle params = new Bundle();
+        params.putString(EXTRA_VIDEO_TAG, getObserverTag(tag));
+
+        drone.performAsyncActionOnDroneThread(new Action(ExperimentalActions.ACTION_STOP_VIDEO_STREAM_FOR_OBSERVER, params),
+            listener);
+    }
+
+    /**
+     * Observer for vehicle video stream.
+     */
+    private static class VideoStreamObserver implements IpConnectionListener {
+        private final String TAG = VideoStreamObserver.class.getSimpleName();
+
+        private static final int UDP_BUFFER_SIZE = 1500;
+        private static final long RECONNECT_COUNTDOWN_IN_MILLIS = 1000l;
+        private static final int SOLO_STREAM_UDP_PORT = 5600;
+
+        private UdpConnection linkConn;
+        private final Handler handler;
+
+        private final Runnable onVideoStreamConnected = new Runnable() {
+            @Override
+            public void run() {
+                handler.removeCallbacks(this);
+                if(callback != null)
+                    callback.onVideoStreamConnected();
+            }
+        };
+
+        private final Runnable onVideoStreamDisconnected = new Runnable() {
+            @Override
+            public void run() {
+                handler.removeCallbacks(this);
+                if(callback != null){
+                    callback.onVideoStreamDisconnected();
+                }
+            }
+        };
+
+        private IVideoStreamCallback callback;
+
+        public VideoStreamObserver(Handler handler) {
+            this.handler = handler;
+        }
+
+        public void setCallback(IVideoStreamCallback callback) {
+            this.callback = callback;
+        }
+
+        private IVideoStreamCallback getCallback() {
+            return callback;
+        }
+
+        private final Runnable reconnectTask = new Runnable() {
+            @Override
+            public void run() {
+                handler.removeCallbacks(reconnectTask);
+                if (linkConn != null)
+                    linkConn.connect();
+            }
+        };
+
+        public void start() {
+            if (this.linkConn == null) {
+                this.linkConn = new UdpConnection(handler, SOLO_STREAM_UDP_PORT,
+                    UDP_BUFFER_SIZE, true, 42);
+                this.linkConn.setIpConnectionListener(this);
+            }
+
+            handler.removeCallbacks(reconnectTask);
+
+            Log.d(TAG, "Connecting to video stream...");
+            this.linkConn.connect();
+        }
+
+        public void stop() {
+            Log.d(TAG, "Stopping video manager");
+
+            handler.removeCallbacks(reconnectTask);
+
+            if (this.linkConn != null) {
+                // Break the link.
+                this.linkConn.disconnect();
+                this.linkConn = null;
+            }
+        }
+
+        @Override
+        public void onIpConnected() {
+            Log.d(TAG, "Connected to video stream");
+
+            handler.post(onVideoStreamConnected);
+            handler.removeCallbacks(reconnectTask);
+        }
+
+        @Override
+        public void onIpDisconnected() {
+            Log.d(TAG, "Video stream disconnected");
+
+            handler.post(onVideoStreamDisconnected);
+            handler.postDelayed(reconnectTask, RECONNECT_COUNTDOWN_IN_MILLIS);
+        }
+
+        @Override
+        public void onPacketReceived(final ByteBuffer packetBuffer) {
+            handler.post(new Runnable() {
+                @Override
+                public void run() {
+                    callback.onVideoStreamPacketReceived(packetBuffer.array(), packetBuffer.limit());
+                }
+            });
+        }
+    }
+
+    /**
+     * Callback for directly observing video stream.
+     */
+    public interface IVideoStreamCallback {
+        void onVideoStreamConnecting();
+
+        void onVideoStreamConnected();
+
+        void onVideoStreamDisconnecting();
+
+        void onVideoStreamDisconnected();
+
+        void onError(int executionError);
+
+        void onTimeout();
+
+        void onVideoStreamPacketReceived(byte[] data, int dataSize);
+    }
 }