src/android/car/cluster/NetworkedVirtualDisplay.java - platform/packages/apps/Car/Cluster - Git at Google

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.car.cluster;

 import android.annotation.NonNull;
 import android.content.Context;
 import android.hardware.display.DisplayManager;
 import android.hardware.display.DisplayManager.DisplayListener;
 import android.hardware.display.VirtualDisplay;
 import android.media.MediaCodec;
 import android.media.MediaCodec.BufferInfo;
 import android.media.MediaCodec.CodecException;
 import android.media.MediaCodecInfo;
 import android.media.MediaCodecInfo.CodecProfileLevel;
 import android.media.MediaFormat;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
 import android.os.Message;
 import android.util.Log;
 import android.view.Display;
 import android.view.Surface;

 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.RandomAccessFile;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.nio.ByteBuffer;
 import java.util.UUID;

 /**
  * This class encapsulates all work related to managing networked virtual display.
  * <p>
  * It opens a socket and listens on port {@code PORT} for connections, or the emulator pipe. Once
  * connection is established it creates virtual display and media encoder and starts streaming video
  * to that socket.  If the receiving part is disconnected, it will keep port open and virtual
  * display won't be destroyed.
  */
 public class NetworkedVirtualDisplay {
     private static final String TAG = "Cluster." + NetworkedVirtualDisplay.class.getSimpleName();

     private final String mUniqueId =  UUID.randomUUID().toString();

     private final DisplayManager mDisplayManager;
     private final int mWidth;
     private final int mHeight;
     private final int mDpi;

     private static final int FPS = 25;
     private static final int BITRATE = 6144000;
     private static final String MEDIA_FORMAT_MIMETYPE = MediaFormat.MIMETYPE_VIDEO_AVC;

     public static final int MSG_START = 0;
     public static final int MSG_STOP = 1;
     public static final int MSG_SEND_FRAME = 2;

     private static final String PIPE_NAME = "pipe:qemud:carCluster";
     private static final String PIPE_DEVICE = "/dev/qemu_pipe";

     // Constants shared with emulator in car-cluster-widget.cpp
     public static final int PIPE_START = 1;
     public static final int PIPE_STOP = 2;

     private static final int PORT = 5151;

     private SenderThread mActiveThread;
     private HandlerThread mBroadcastThread = new HandlerThread("BroadcastThread");

     private VirtualDisplay mVirtualDisplay;
     private MediaCodec mVideoEncoder;
     private Handler mHandler;
     private byte[] mBuffer = null;
     private int mLastFrameLength = 0;

     private final DebugCounter mCounter = new DebugCounter();

     NetworkedVirtualDisplay(Context context, int width, int height, int dpi) {
         mDisplayManager = context.getSystemService(DisplayManager.class);
         mWidth = width;
         mHeight = height;
         mDpi = dpi;

         DisplayListener displayListener = new DisplayListener() {
             @Override
             public void onDisplayAdded(int i) {
                 final Display display = mDisplayManager.getDisplay(i);
                 if (display != null && getDisplayName().equals(display.getName())) {
                     onVirtualDisplayReady(display);
                 }
             }

             @Override
             public void onDisplayRemoved(int i) {}

             @Override
             public void onDisplayChanged(int i) {}
         };

         mDisplayManager.registerDisplayListener(displayListener, new Handler());
     }

     /**
      * Opens socket and creates virtual display asynchronously once connection established.  Clients
      * of this class may subscribe to
      * {@link android.hardware.display.DisplayManager#registerDisplayListener(
      * DisplayListener, Handler)} to be notified when virtual display is created.
      * Note, that this method should be called only once.
      *
      * @return Unique display name associated with the instance of this class.
      *
      * @see {@link Display#getName()}
      *
      * @throws IllegalStateException thrown if networked display already started
      */
     public String start() {
         if (mBroadcastThread.isAlive()) {
             throw new IllegalStateException("Already started");
         }

         mBroadcastThread.start();
         mHandler = new BroadcastThreadHandler(mBroadcastThread.getLooper());
         mHandler.sendMessage(Message.obtain(mHandler, MSG_START));
         return getDisplayName();
     }

     public void release() {
         mHandler.sendMessage(Message.obtain(mHandler, MSG_STOP));
         mBroadcastThread.quitSafely();

         if (mVirtualDisplay != null) {
             mVirtualDisplay.setSurface(null);
             mVirtualDisplay.release();
             mVirtualDisplay = null;
         }
     }

     private String getDisplayName() {
         return "Cluster-" + mUniqueId;
     }

     private VirtualDisplay createVirtualDisplay() {
         Log.i(TAG, "createVirtualDisplay " + mWidth + "x" + mHeight +"@" + mDpi);
         return mDisplayManager.createVirtualDisplay(getDisplayName(), mWidth, mHeight, mDpi,
                 null, 0 /* flags */, null, null );
     }

     private void onVirtualDisplayReady(Display display) {
         Log.i(TAG, "onVirtualDisplayReady, display: " + display);
     }

     private void startCasting(Handler handler) {
         Log.i(TAG, "Start casting...");
         if (mVideoEncoder != null) {
             Log.i(TAG, "Already started casting");
             return;
         }
         mVideoEncoder = createVideoStream(handler);

         if (mVirtualDisplay == null) {
             mVirtualDisplay = createVirtualDisplay();
         }

         mVirtualDisplay.setSurface(mVideoEncoder.createInputSurface());
         mVideoEncoder.start();
         Log.i(TAG, "Video encoder started");
     }

     private MediaCodec createVideoStream(Handler handler) {
         MediaCodec encoder;
         try {
             encoder = MediaCodec.createEncoderByType(MEDIA_FORMAT_MIMETYPE);
         } catch (IOException e) {
             Log.e(TAG, "Failed to create video encoder for " + MEDIA_FORMAT_MIMETYPE, e);
             return null;
         }

         encoder.setCallback(new MediaCodec.Callback() {
             @Override
             public void onInputBufferAvailable(@NonNull MediaCodec codec, int index) {
                 // Nothing to do
             }

             @Override
             public void onOutputBufferAvailable(@NonNull MediaCodec codec, int index,
                     @NonNull BufferInfo info) {
                 mCounter.outputBuffers++;
                 doOutputBufferAvailable(index, info);
             }

             @Override
             public void onError(@NonNull MediaCodec codec, @NonNull CodecException e) {
                 Log.e(TAG, "onError, codec: " + codec, e);
                 mCounter.bufferErrors++;
                 stopCasting();
                 startCasting(handler);
             }

             @Override
             public void onOutputFormatChanged(@NonNull MediaCodec codec,
                     @NonNull MediaFormat format) {
                 Log.i(TAG, "onOutputFormatChanged, codec: " + codec + ", format: " + format);

             }
         }, handler);

         configureVideoEncoder(encoder, mWidth, mHeight);
         return encoder;
     }

     private void doOutputBufferAvailable(int index, @NonNull BufferInfo info) {
         mHandler.removeMessages(MSG_SEND_FRAME);

         ByteBuffer encodedData = mVideoEncoder.getOutputBuffer(index);
         if (encodedData == null) {
             throw new RuntimeException("couldn't fetch buffer at index " + index);
         }

         if (info.size != 0) {
             encodedData.position(info.offset);
             encodedData.limit(info.offset + info.size);
             mLastFrameLength = encodedData.remaining();
             if (mBuffer == null || mBuffer.length < mLastFrameLength) {
                 Log.i(TAG, "Allocating new buffer: " + mLastFrameLength);
                 mBuffer = new byte[mLastFrameLength];
             }
             encodedData.get(mBuffer, 0, mLastFrameLength);
             mVideoEncoder.releaseOutputBuffer(index, false);

             // Send this frame asynchronously (avoiding blocking on the socket). We might miss
             // frames if the consumer is not fast enough, but this is acceptable.
             sendFrameAsync(0);
         } else {
             Log.e(TAG, "Skipping empty buffer");
             mVideoEncoder.releaseOutputBuffer(index, false);
         }
     }

     private void sendFrameAsync(long delayMs) {
         Message msg = mHandler.obtainMessage(MSG_SEND_FRAME);
         mHandler.sendMessageDelayed(msg, delayMs);
     }

     private void sendFrame(byte[] buf, int len) {
         if (mActiveThread != null) {
             mActiveThread.send(buf, len);
         }
     }

     private void stopCasting() {
         Log.i(TAG, "Stopping casting...");

         if (mVirtualDisplay != null) {
             Surface surface = mVirtualDisplay.getSurface();
             if (surface != null) surface.release();
         }

         if (mVideoEncoder != null) {
             // Releasing encoder as stop/start didn't work well (couldn't create or reuse input
             // surface).
             try {
                 mVideoEncoder.stop();
                 mVideoEncoder.release();
             } catch (IllegalStateException e) {
                 // do nothing, already released
             }
             mVideoEncoder = null;
         }
         Log.i(TAG, "Casting stopped");
     }

     private class BroadcastThreadHandler extends Handler {
         private static final int MAX_FAIL_COUNT = 10;
         private int mFailConnectCounter;

         BroadcastThreadHandler(Looper looper) {
             super(looper);
         }

         @Override
         public void handleMessage(Message msg) {
             switch (msg.what) {
                 case MSG_START:
                     Log.i(TAG, "Received start message");

                     // Make sure mActiveThread cannot start multiple times
                     if (mActiveThread != null) {
                         Log.w(TAG, "Trying to start a running thread. Race condition may exist");
                         break;
                     }

                     // Failure to connect to either pipe or network returns null
                     if (mActiveThread == null) {
                         mActiveThread = tryPipeConnect();
                     }
                     if (mActiveThread == null) {
                         mActiveThread = tryNetworkConnect();
                     }
                     if (mActiveThread == null) {
                         // When failed attempt limit is reached, clean up and quit this thread.
                         mFailConnectCounter++;
                         if (mFailConnectCounter >= MAX_FAIL_COUNT) {
                             Log.e(TAG, "Too many failed connection attempts; aborting");
                             release();
                             throw new RuntimeException("Abort after failed connection attempts");
                         }
                         mHandler.sendMessage(Message.obtain(mHandler, MSG_START));
                         break;
                     }

                     try {
                         mFailConnectCounter = 0;
                         mCounter.clientsConnected++;
                         mActiveThread.start();
                         startCasting(this);
                     } catch (Exception e) {
                         Log.e(TAG, "Failed to start thread", e);
                         Log.e(TAG, "DebugCounter: " + mCounter);
                     }
                     break;

                 case MSG_STOP:
                     Log.i(TAG, "Received stop message");
                     stopCasting();
                     mCounter.clientsDisconnected++;
                     if (mActiveThread != null) {
                         mActiveThread.close();
                         try {
                             mActiveThread.join();
                         } catch (InterruptedException e) {
                             Log.e(TAG, "Waiting for active thread to close failed", e);
                         }
                         mActiveThread = null;
                     }
                     break;

                 case MSG_SEND_FRAME:
                     if (mActiveThread == null) {
                         // Stop the chaining signal if there's no client to send to
                         break;
                     }
                     sendFrame(mBuffer, mLastFrameLength);
                     // We will keep sending last frame every second as a heartbeat.
                     sendFrameAsync(1000L);
                     break;
             }
         }

         // Returns null if can't establish pipe connection
         // Otherwise returns the corresponding client thread
         private PipeThread tryPipeConnect() {
             try {
                 RandomAccessFile pipe = new RandomAccessFile(PIPE_DEVICE, "rw");
                 byte[] temp = new byte[PIPE_NAME.length() + 1];
                 temp[PIPE_NAME.length()] = 0;
                 System.arraycopy(PIPE_NAME.getBytes(), 0, temp, 0, PIPE_NAME.length());
                 pipe.write(temp);

                 // At this point, the pipe exists, so we will just wait for a start signal
                 // This is in case pipe still sends leftover stops from last instantiation
                 int signal = pipe.read();
                 while (signal != PIPE_START) {
                     Log.i(TAG, "Received non-start signal: " + signal);
                     signal = pipe.read();
                 }
                 return new PipeThread(mHandler, pipe);
             } catch (IOException e) {
                 Log.e(TAG, "Failed to establish pipe connection", e);
                 return null;
             }
         }

         // Returns null if can't establish network connection
         // Otherwise returns the corresponding client thread
         private SocketThread tryNetworkConnect() {
             try {
                 ServerSocket serverSocket = new ServerSocket(PORT);
                 Log.i(TAG, "Server socket opened");
                 Socket socket = serverSocket.accept();
                 socket.setTcpNoDelay(true);
                 socket.setKeepAlive(true);
                 socket.setSoLinger(true, 0);

                 InputStream inputStream = socket.getInputStream();
                 OutputStream outputStream = socket.getOutputStream();

                 return new SocketThread(mHandler, serverSocket, inputStream, outputStream);
             } catch (IOException e) {
                 Log.e(TAG, "Failed to establish network connection", e);
                 return null;
             }
         }
     }

     private static void configureVideoEncoder(MediaCodec codec, int width, int height) {
         MediaFormat format = MediaFormat.createVideoFormat(MEDIA_FORMAT_MIMETYPE, width, height);

         format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
                 MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
         format.setInteger(MediaFormat.KEY_BIT_RATE, BITRATE);
         format.setInteger(MediaFormat.KEY_FRAME_RATE, FPS);
         format.setInteger(MediaFormat.KEY_CAPTURE_RATE, FPS);
         format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, 1);
         format.setFloat(MediaFormat.KEY_I_FRAME_INTERVAL, 1); // 1 second between I-frames
         format.setInteger(MediaFormat.KEY_LEVEL, CodecProfileLevel.AVCLevel31);
         format.setInteger(MediaFormat.KEY_PROFILE,
                 MediaCodecInfo.CodecProfileLevel.AVCProfileBaseline);

         codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
     }

     @Override
     public String toString() {
         return getClass() + "{"
                 + ", receiver connected: " + (mActiveThread != null)
                 + ", encoder: " + mVideoEncoder
                 + ", virtualDisplay" + mVirtualDisplay
                 + "}";
     }

     private static class DebugCounter {
         long outputBuffers;
         long bufferErrors;
         long clientsConnected;
         long clientsDisconnected;

         @Override
         public String toString() {
             return getClass().getSimpleName() + "{"
                     + "outputBuffers=" + outputBuffers
                     + ", bufferErrors=" + bufferErrors
                     + ", clientsConnected=" + clientsConnected
                     + ", clientsDisconnected= " + clientsDisconnected
                     + "}";
         }
     }
 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.car.cluster;

	import android.annotation.NonNull;
	import android.content.Context;
	import android.hardware.display.DisplayManager;
	import android.hardware.display.DisplayManager.DisplayListener;
	import android.hardware.display.VirtualDisplay;
	import android.media.MediaCodec;
	import android.media.MediaCodec.BufferInfo;
	import android.media.MediaCodec.CodecException;
	import android.media.MediaCodecInfo;
	import android.media.MediaCodecInfo.CodecProfileLevel;
	import android.media.MediaFormat;
	import android.os.Handler;
	import android.os.HandlerThread;
	import android.os.Looper;
	import android.os.Message;
	import android.util.Log;
	import android.view.Display;
	import android.view.Surface;

	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.RandomAccessFile;
	import java.net.ServerSocket;
	import java.net.Socket;
	import java.nio.ByteBuffer;
	import java.util.UUID;

	/**
	* This class encapsulates all work related to managing networked virtual display.
	* <p>
	* It opens a socket and listens on port {@code PORT} for connections, or the emulator pipe. Once
	* connection is established it creates virtual display and media encoder and starts streaming video
	* to that socket. If the receiving part is disconnected, it will keep port open and virtual
	* display won't be destroyed.
	*/
	public class NetworkedVirtualDisplay {
	private static final String TAG = "Cluster." + NetworkedVirtualDisplay.class.getSimpleName();

	private final String mUniqueId = UUID.randomUUID().toString();

	private final DisplayManager mDisplayManager;
	private final int mWidth;
	private final int mHeight;
	private final int mDpi;

	private static final int FPS = 25;
	private static final int BITRATE = 6144000;
	private static final String MEDIA_FORMAT_MIMETYPE = MediaFormat.MIMETYPE_VIDEO_AVC;

	public static final int MSG_START = 0;
	public static final int MSG_STOP = 1;
	public static final int MSG_SEND_FRAME = 2;

	private static final String PIPE_NAME = "pipe:qemud:carCluster";
	private static final String PIPE_DEVICE = "/dev/qemu_pipe";

	// Constants shared with emulator in car-cluster-widget.cpp
	public static final int PIPE_START = 1;
	public static final int PIPE_STOP = 2;

	private static final int PORT = 5151;

	private SenderThread mActiveThread;
	private HandlerThread mBroadcastThread = new HandlerThread("BroadcastThread");

	private VirtualDisplay mVirtualDisplay;
	private MediaCodec mVideoEncoder;
	private Handler mHandler;
	private byte[] mBuffer = null;
	private int mLastFrameLength = 0;

	private final DebugCounter mCounter = new DebugCounter();

	NetworkedVirtualDisplay(Context context, int width, int height, int dpi) {
	mDisplayManager = context.getSystemService(DisplayManager.class);
	mWidth = width;
	mHeight = height;
	mDpi = dpi;

	DisplayListener displayListener = new DisplayListener() {
	@Override
	public void onDisplayAdded(int i) {
	final Display display = mDisplayManager.getDisplay(i);
	if (display != null && getDisplayName().equals(display.getName())) {
	onVirtualDisplayReady(display);
	}
	}

	@Override
	public void onDisplayRemoved(int i) {}

	@Override
	public void onDisplayChanged(int i) {}
	};

	mDisplayManager.registerDisplayListener(displayListener, new Handler());
	}

	/**
	* Opens socket and creates virtual display asynchronously once connection established. Clients
	* of this class may subscribe to
	* {@link android.hardware.display.DisplayManager#registerDisplayListener(
	* DisplayListener, Handler)} to be notified when virtual display is created.
	* Note, that this method should be called only once.
	*
	* @return Unique display name associated with the instance of this class.
	*
	* @see {@link Display#getName()}
	*
	* @throws IllegalStateException thrown if networked display already started
	*/
	public String start() {
	if (mBroadcastThread.isAlive()) {
	throw new IllegalStateException("Already started");
	}

	mBroadcastThread.start();
	mHandler = new BroadcastThreadHandler(mBroadcastThread.getLooper());
	mHandler.sendMessage(Message.obtain(mHandler, MSG_START));
	return getDisplayName();
	}

	public void release() {
	mHandler.sendMessage(Message.obtain(mHandler, MSG_STOP));
	mBroadcastThread.quitSafely();

	if (mVirtualDisplay != null) {
	mVirtualDisplay.setSurface(null);
	mVirtualDisplay.release();
	mVirtualDisplay = null;
	}
	}

	private String getDisplayName() {
	return "Cluster-" + mUniqueId;
	}

	private VirtualDisplay createVirtualDisplay() {
	Log.i(TAG, "createVirtualDisplay " + mWidth + "x" + mHeight +"@" + mDpi);
	return mDisplayManager.createVirtualDisplay(getDisplayName(), mWidth, mHeight, mDpi,
	null, 0 /* flags */, null, null );
	}

	private void onVirtualDisplayReady(Display display) {
	Log.i(TAG, "onVirtualDisplayReady, display: " + display);
	}

	private void startCasting(Handler handler) {
	Log.i(TAG, "Start casting...");
	if (mVideoEncoder != null) {
	Log.i(TAG, "Already started casting");
	return;
	}
	mVideoEncoder = createVideoStream(handler);

	if (mVirtualDisplay == null) {
	mVirtualDisplay = createVirtualDisplay();
	}

	mVirtualDisplay.setSurface(mVideoEncoder.createInputSurface());
	mVideoEncoder.start();
	Log.i(TAG, "Video encoder started");
	}

	private MediaCodec createVideoStream(Handler handler) {
	MediaCodec encoder;
	try {
	encoder = MediaCodec.createEncoderByType(MEDIA_FORMAT_MIMETYPE);
	} catch (IOException e) {
	Log.e(TAG, "Failed to create video encoder for " + MEDIA_FORMAT_MIMETYPE, e);
	return null;
	}

	encoder.setCallback(new MediaCodec.Callback() {
	@Override
	public void onInputBufferAvailable(@NonNull MediaCodec codec, int index) {
	// Nothing to do
	}

	@Override
	public void onOutputBufferAvailable(@NonNull MediaCodec codec, int index,
	@NonNull BufferInfo info) {
	mCounter.outputBuffers++;
	doOutputBufferAvailable(index, info);
	}

	@Override
	public void onError(@NonNull MediaCodec codec, @NonNull CodecException e) {
	Log.e(TAG, "onError, codec: " + codec, e);
	mCounter.bufferErrors++;
	stopCasting();
	startCasting(handler);
	}

	@Override
	public void onOutputFormatChanged(@NonNull MediaCodec codec,
	@NonNull MediaFormat format) {
	Log.i(TAG, "onOutputFormatChanged, codec: " + codec + ", format: " + format);

	}
	}, handler);

	configureVideoEncoder(encoder, mWidth, mHeight);
	return encoder;
	}

	private void doOutputBufferAvailable(int index, @NonNull BufferInfo info) {
	mHandler.removeMessages(MSG_SEND_FRAME);

	ByteBuffer encodedData = mVideoEncoder.getOutputBuffer(index);
	if (encodedData == null) {
	throw new RuntimeException("couldn't fetch buffer at index " + index);
	}

	if (info.size != 0) {
	encodedData.position(info.offset);
	encodedData.limit(info.offset + info.size);
	mLastFrameLength = encodedData.remaining();
	if (mBuffer == null \|\| mBuffer.length < mLastFrameLength) {
	Log.i(TAG, "Allocating new buffer: " + mLastFrameLength);
	mBuffer = new byte[mLastFrameLength];
	}
	encodedData.get(mBuffer, 0, mLastFrameLength);
	mVideoEncoder.releaseOutputBuffer(index, false);

	// Send this frame asynchronously (avoiding blocking on the socket). We might miss
	// frames if the consumer is not fast enough, but this is acceptable.
	sendFrameAsync(0);
	} else {
	Log.e(TAG, "Skipping empty buffer");
	mVideoEncoder.releaseOutputBuffer(index, false);
	}
	}

	private void sendFrameAsync(long delayMs) {
	Message msg = mHandler.obtainMessage(MSG_SEND_FRAME);
	mHandler.sendMessageDelayed(msg, delayMs);
	}

	private void sendFrame(byte[] buf, int len) {
	if (mActiveThread != null) {
	mActiveThread.send(buf, len);
	}
	}

	private void stopCasting() {
	Log.i(TAG, "Stopping casting...");

	if (mVirtualDisplay != null) {
	Surface surface = mVirtualDisplay.getSurface();
	if (surface != null) surface.release();
	}

	if (mVideoEncoder != null) {
	// Releasing encoder as stop/start didn't work well (couldn't create or reuse input
	// surface).
	try {
	mVideoEncoder.stop();
	mVideoEncoder.release();
	} catch (IllegalStateException e) {
	// do nothing, already released
	}
	mVideoEncoder = null;
	}
	Log.i(TAG, "Casting stopped");
	}

	private class BroadcastThreadHandler extends Handler {
	private static final int MAX_FAIL_COUNT = 10;
	private int mFailConnectCounter;

	BroadcastThreadHandler(Looper looper) {
	super(looper);
	}

	@Override
	public void handleMessage(Message msg) {
	switch (msg.what) {
	case MSG_START:
	Log.i(TAG, "Received start message");

	// Make sure mActiveThread cannot start multiple times
	if (mActiveThread != null) {
	Log.w(TAG, "Trying to start a running thread. Race condition may exist");
	break;
	}

	// Failure to connect to either pipe or network returns null
	if (mActiveThread == null) {
	mActiveThread = tryPipeConnect();
	}
	if (mActiveThread == null) {
	mActiveThread = tryNetworkConnect();
	}
	if (mActiveThread == null) {
	// When failed attempt limit is reached, clean up and quit this thread.
	mFailConnectCounter++;
	if (mFailConnectCounter >= MAX_FAIL_COUNT) {
	Log.e(TAG, "Too many failed connection attempts; aborting");
	release();
	throw new RuntimeException("Abort after failed connection attempts");
	}
	mHandler.sendMessage(Message.obtain(mHandler, MSG_START));
	break;
	}

	try {
	mFailConnectCounter = 0;
	mCounter.clientsConnected++;
	mActiveThread.start();
	startCasting(this);
	} catch (Exception e) {
	Log.e(TAG, "Failed to start thread", e);
	Log.e(TAG, "DebugCounter: " + mCounter);
	}
	break;

	case MSG_STOP:
	Log.i(TAG, "Received stop message");
	stopCasting();
	mCounter.clientsDisconnected++;
	if (mActiveThread != null) {
	mActiveThread.close();
	try {
	mActiveThread.join();
	} catch (InterruptedException e) {
	Log.e(TAG, "Waiting for active thread to close failed", e);
	}
	mActiveThread = null;
	}
	break;

	case MSG_SEND_FRAME:
	if (mActiveThread == null) {
	// Stop the chaining signal if there's no client to send to
	break;
	}
	sendFrame(mBuffer, mLastFrameLength);
	// We will keep sending last frame every second as a heartbeat.
	sendFrameAsync(1000L);
	break;
	}
	}

	// Returns null if can't establish pipe connection
	// Otherwise returns the corresponding client thread
	private PipeThread tryPipeConnect() {
	try {
	RandomAccessFile pipe = new RandomAccessFile(PIPE_DEVICE, "rw");
	byte[] temp = new byte[PIPE_NAME.length() + 1];
	temp[PIPE_NAME.length()] = 0;
	System.arraycopy(PIPE_NAME.getBytes(), 0, temp, 0, PIPE_NAME.length());
	pipe.write(temp);

	// At this point, the pipe exists, so we will just wait for a start signal
	// This is in case pipe still sends leftover stops from last instantiation
	int signal = pipe.read();
	while (signal != PIPE_START) {
	Log.i(TAG, "Received non-start signal: " + signal);
	signal = pipe.read();
	}
	return new PipeThread(mHandler, pipe);
	} catch (IOException e) {
	Log.e(TAG, "Failed to establish pipe connection", e);
	return null;
	}
	}

	// Returns null if can't establish network connection
	// Otherwise returns the corresponding client thread
	private SocketThread tryNetworkConnect() {
	try {
	ServerSocket serverSocket = new ServerSocket(PORT);
	Log.i(TAG, "Server socket opened");
	Socket socket = serverSocket.accept();
	socket.setTcpNoDelay(true);
	socket.setKeepAlive(true);
	socket.setSoLinger(true, 0);

	InputStream inputStream = socket.getInputStream();
	OutputStream outputStream = socket.getOutputStream();

	return new SocketThread(mHandler, serverSocket, inputStream, outputStream);
	} catch (IOException e) {
	Log.e(TAG, "Failed to establish network connection", e);
	return null;
	}
	}
	}

	private static void configureVideoEncoder(MediaCodec codec, int width, int height) {
	MediaFormat format = MediaFormat.createVideoFormat(MEDIA_FORMAT_MIMETYPE, width, height);

	format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
	MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
	format.setInteger(MediaFormat.KEY_BIT_RATE, BITRATE);
	format.setInteger(MediaFormat.KEY_FRAME_RATE, FPS);
	format.setInteger(MediaFormat.KEY_CAPTURE_RATE, FPS);
	format.setInteger(MediaFormat.KEY_CHANNEL_COUNT, 1);
	format.setFloat(MediaFormat.KEY_I_FRAME_INTERVAL, 1); // 1 second between I-frames
	format.setInteger(MediaFormat.KEY_LEVEL, CodecProfileLevel.AVCLevel31);
	format.setInteger(MediaFormat.KEY_PROFILE,
	MediaCodecInfo.CodecProfileLevel.AVCProfileBaseline);

	codec.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
	}

	@Override
	public String toString() {
	return getClass() + "{"
	+ ", receiver connected: " + (mActiveThread != null)
	+ ", encoder: " + mVideoEncoder
	+ ", virtualDisplay" + mVirtualDisplay
	+ "}";
	}

	private static class DebugCounter {
	long outputBuffers;
	long bufferErrors;
	long clientsConnected;
	long clientsDisconnected;

	@Override
	public String toString() {
	return getClass().getSimpleName() + "{"
	+ "outputBuffers=" + outputBuffers
	+ ", bufferErrors=" + bufferErrors
	+ ", clientsConnected=" + clientsConnected
	+ ", clientsDisconnected= " + clientsDisconnected
	+ "}";
	}
	}
	}