Android 手机采集摄像头视频 socket 视频传输实时传播

本是古典何须时尚 2023-06-14 14:58 6阅读 0赞

这里搜集了两种实现Android 手机采集摄像头视频 socket 视频传输实时传播的方法，两种都可以使用。

第一种如下：

1.通过客户端socket请求，服务端接受到请求后，获取socket的输出流对象outs。  
2.服务端通过Camera的setPreviewCallback方法回调采集摄像头视频数据，将一张张图片数据数据压缩，发送到客户端，因为是图片，需要在图片开头加个标记，然后指定数据长度发送。  
3.客户端接收数据，根据数据开头标记，以及数据的长度，接收数据，按一张张图片的形式，采用handle更新imageview。  
主要代码：

服务端代码：

public class MainActivity extends Activity {
     TextView tv;
     SurfaceView surfv;
     SurfaceHolder surfaceHolder;
     int screenWidth=300, screenHeight=300;
     public Handler mHandler = new Handler(){
      public void handleMessage(android.os.Message msg) {
       switch (msg.what) {
       case CamConstant.INIT_CAMERA:
        
        /*if(CamConstant.hadInit){
         return;
        }</div><div>    Camera camera = CameraUtil.initCamera(surfaceHolder);
        if( null != camera){
         CamConstant.hadInit = true;
        }*/
        break;
       case CamConstant.RECYCLE_CAMERA:
        CameraUtil.recycleCamera();
        CamConstant.hadInit = false;
        break;
       default:
        //tv.setText((CharSequence) msg.obj);
        tv.append((CharSequence) msg.obj+"\n");
        break;
       }
      };
     };
     @Override
     protected void onCreate(Bundle savedInstanceState) {
      setContentView(R.layout.activity_main);
      super.onCreate(savedInstanceState);
      MainApplication.mHandler = this.mHandler;
      tv = (TextView) findViewById(R.id.textView);
      surfv = (SurfaceView) findViewById(R.id.surview);
      DisplayMetrics dm = new DisplayMetrics();
      getWindowManager().getDefaultDisplay().getMetrics(dm);
         screenWidth = dm.widthPixels;// 获取屏幕分辨率宽度
         screenHeight = dm.heightPixels;
      surfaceHolder = surfv.getHolder();
      surfaceHolder.setFixedSize(screenWidth, screenHeight/4*2);
      surfaceHolder.addCallback(new Callback() {
       
       @Override
       public void surfaceDestroyed(SurfaceHolder holder) {
        // TODO Auto-generated method stub
       }
       
       @Override
       public void surfaceCreated(SurfaceHolder holder) {
        // TODO Auto-generated method stub
        CameraUtil.initCamera(surfaceHolder);
       }
       
       @Override
       public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // TODO Auto-generated method stub
       }
      });
      //tv.setMovementMethod(ScrollingMovementMethod.getInstance());
      startService();
     };
     public void startService(){
      Intent intent = new Intent(MainActivity.this, CamThreadService.class);
      startService(intent);
     }
     @Override
     protected void onDestroy() {
      // TODO Auto-generated method stub
      CameraUtil.recycleCamera();
      CamConstant.hadInit = false;
      if(ServiceUtil.isServiceRunning(this, "CamService")){
       stopService(new Intent(this, CamService.class));
      }
      super.onDestroy();
     }
     
     
    }

public class CamThreadService extends Service {
     Socket mClintSocket;
     ServerSocket serverSocket;
     @Override
     public IBinder onBind(Intent intent) {
      return null;
     }
     @Override
     public void onCreate() {
      L.e("启动11111");
      // TODO Auto-generated method stub
      new Thread(new Runnable() {
       
       @Override
       public void run() {
        // TODO Auto-generated method stub
        try {
         L.e("accept000");
         sendMSG("accept1111"); 
         serverSocket = new ServerSocket(CamConstant.Camera_Port);
         while(true){
          L.e("accept0001111");
          L.e("accept11111");
          sendMSG("accept222");
          mClintSocket = serverSocket.accept();
          L.e("accept22222");
          L.e("accept3333");
          new Thread(){
           public void run() {
            if(mClintSocket != null){
             sendMSG("accept3333");
             //初始化
             //MainApplication.mHandler.sendEmptyMessage(CamConstant.INIT_CAMERA);
             L.e("accept4444");
             boolean flag = true;
             while(flag){
              if(CameraUtil.mCamera != null){
               try {
                CameraUtil.mCamera.setPreviewCallback(new StreamIt(mClintSocket));
               } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
               }
               flag = false;
               mClintSocket = null;
              }
             }
            }
           };
          }.start();
         }
         
        } catch (IOException e) {
         // TODO Auto-generated catch block
         L.e("之行报错 停止");
         e.printStackTrace();
        }
        
       }
      }).start();
      super.onCreate();
      
     }
     /**
      * 视频流数据相关回调
      */
     private class StreamIt implements PreviewCallback {
      private OutputStream out;
      private InputStream in;
      private int  times = 0;
      public  StreamIt(Socket s) throws IOException {
       // TODO Auto-generated constructor stub
       this.out = s.getOutputStream();
       this.in = s.getInputStream();
       sendMSG("压缩后的数据11");
       int[] textures = new int[1];
       L.e("压缩后的数据1");
      }
      @Override
      public void onPreviewFrame(byte[] data, Camera camera) { 
       // TODO Auto-generated method stub
       Size size = camera.getParameters().getPreviewSize();
       try {
        L.e("压缩后的数据1.5");
        if(times == 0){
         YuvImage image = new YuvImage(data, ImageFormat.NV21, size.width, size.height, null);
         if(image != null){
          //这是源数据
          ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
          image.compressToJpeg(new Rect(0, 0, size.width, size.height), 100, outputStream);
          byte[] srcData = outputStream.toByteArray();
          int len = srcData.length;
          Bitmap src = BitmapFactory.decodeByteArray(srcData, 0, len);
          //压缩后的数据
          byte[] outdata = transImage(src, 640, 480);
          L.e("压缩后的数据2");
          sendMSG("压缩后的数据22");
          int datalen = outdata.length;
          out.write((byte) 0xA0);
          out.write(intTOBytes(datalen));
          out.write(outdata, 0, datalen);
          if(!src.isRecycled()){
           src.recycle();
          }
          
         }
        }
        
       } catch (Exception e) {
        // TODO: handle exception
        e.printStackTrace();
       }
      }
      /**
       * 数据转换，将bitmap转换为byte
       */
      private byte[] transImage(Bitmap bitmap, int width, int height){
       try{
        int bitmapWidth = bitmap.getWidth();
        int bitmapHeight = bitmap.getHeight();
        //缩放图片的尺寸
        float scaleWidth = (float) width/bitmapWidth;
        float scaleHeight = (float) height/bitmapHeight;
        Matrix matrix = new Matrix();
        matrix.postScale(scaleWidth, scaleHeight);
        //产生缩放后的Bitmap对象
        Bitmap resizeBitemp = Bitmap.createBitmap(bitmap, 0, 0, bitmapWidth, bitmapHeight, matrix, false);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        resizeBitemp.compress(CompressFormat.JPEG, 85, outputStream);
        byte[] byteArray = outputStream.toByteArray();
        outputStream.close();
        if(!bitmap.isRecycled()){
         bitmap.recycle();
        }
        if(!resizeBitemp.isRecycled()){
         resizeBitemp.recycle();
        }
        return byteArray;
        
       }catch(Exception ex){
        ex.printStackTrace();
        MainApplication.mHandler.sendEmptyMessage(CamConstant.RECYCLE_CAMERA);
       }
       return null;
      }
      /**
       * 将int 数值转换为4个字节
       */
      private byte[] intTOBytes(int value){
       Log.e("cam",value+"d");
       byte[] src = new byte[4];
       src[3] = (byte) ((value >> 24) & 0xFF);
       src[2] = (byte)((value >> 16) & 0xFF);
       src[1] = (byte)((value >> 8) & 0xFF);
       src[0] = (byte)(value & 0xFF);
       return src;
      }
     }
     @Override
     public void onDestroy() {
      // TODO Auto-generated method stub
       try {
        if(mClintSocket !=null){
         mClintSocket.close();
        }
       } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
       }
     
      MainApplication.mHandler.sendEmptyMessage(CamConstant.RECYCLE_CAMERA);
      super.onDestroy();
     }
     public void sendMSG(String text){
      Message msg = new Message();
      msg.what = 908;
      msg.obj = text;
      MainApplication.mHandler.sendMessage(msg);
     }
    }

客户端代码：

public class MainActivity extends Activity {
        RevImageThread revImageThread;
        public static ImageView image;
        private static TextView textView1;
        private static Bitmap bitmap;
        private static final int COMPLETED = 0x111;
        private MyHandler handler;
         
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            image=(ImageView)findViewById(R.id.imageView1);
            textView1 = (TextView) findViewById(R.id.textView1);
            textView1.setMovementMethod(ScrollingMovementMethod.getInstance());
            handler = new MyHandler();
            revImageThread = new RevImageThread(handler);
            new Thread(revImageThread).start();
            
        }
        
        static class MyHandler extends Handler{
            @Override
            public void handleMessage(Message msg){
            	if(msg.obj != null){
               	 	textView1.append(msg.obj.toString()+"\n");
            	}
                 if (msg.what == COMPLETED) {
                     bitmap = (Bitmap)msg.obj;
                    image.setImageBitmap(bitmap); 
                    super.handleMessage(msg);
                 }  
            }
        }
        
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    }

public class RevImageThread implements Runnable {
     
        public Socket s;
        public ServerSocket ss;
        
        //向UI线程发送消息
        private Handler handler;
        
        private Bitmap bitmap;
        private static final int COMPLETED = 0x111;
        
        public RevImageThread(Handler handler){
            this.handler = handler;
        }
        
        public void run()
        {    
     
        
            try {
                ss = new ServerSocket(ScoketIPandPort.SOCKTPORT);
            } catch (IOException e2) {
                // TODO Auto-generated catch block
                e2.printStackTrace();
            }
     
            while(true){
                
                    try {
    					s = ss.accept();
    	                Log.e("strat","ljq");
    					 new Thread(){
    		                	public void run() {
    		                        try {
    		                        		byte [] buffer = new byte[1024];
    		                        		InputStream ins = null;
    		                        		ins = s.getInputStream();
    		                        		Log.v("socket", "socketcc1111");
    		                        		if(s != null){
    		                        			Log.v("socket", "socketcc2222");
    		                            		while(true){
    		                            			int len = 0;
    		                            			int i = 0;
    		                            			int j = 0;
    		                            			boolean flag = true;
    		                            			/*while(flag){
    		                            				 i += ins.read();
    		                            				 Log.e("socket", ":"+i + " : " + j++);
    		                            			}
    		                            			*/
    		                            			if(ins.read() == 0xA0){
    		                                			byte[] src = new byte[4];
    		                                			len = ins.read(src);
     
    		                                			Log.v("sck", "src3:"+src[3]);
     
    		                                			Log.v("sck", "src2:"+src[2]);
     
    		                                			Log.v("sck", "src1:"+src[1]);
     
    		                                			Log.v("sck", "src0:"+src[0]);
    		                                			
    		                                			Log.v("sck", "src:"+src);
    		                                			Log.v("socket", "socketcc55551:"+len);
    		                                			Log.v("socket", "socketcc55552:"+src);
    		                                			len = bytesToInt(src, 0);
    		                                			Log.v("socket", "socketcc55553:"+src);
    		                                			Log.v("socket", "socketcc55554:"+len);
    		                                			//len = 4000000;
    			                            			byte[] srcData = new byte[len];
    			                            			sendMSG(len+":len");
    			                            			int readc = 0;
    			                            			
    			                            			ins.read(srcData, readc, len);
    			                            			Log.v("socket", "srcData0:"+srcData[0]);
    			                            			sendMSG("srcData0:"+srcData[0]);
    			                            			Log.v("socket", "srcData0:"+srcData[1]);
    			                            			Log.v("socket", "srcData0:"+srcData[2]);
    			                            			Log.v("socket", "srcData0:"+srcData[3]);
    			                            			Log.v("socket", "srcData0:"+srcData[4]);
    			                            			Log.v("socket", "srcData0:"+srcData[5]);
    			                            			Log.v("socket", "srcData0:"+srcData[6]);
    			                            			Log.v("socket", "srcData0:"+srcData[7]);
    			                            			Log.v("socket", "srcData0:"+srcData[len-1]);
    			                            			sendMSG(srcData[len-1]+"L");
    			                                		bitmap = BitmapFactory.decodeByteArray(srcData, 0, len);
    			                                		
    			                                		Message msg =handler.obtainMessage();
    			                                		msg.what = COMPLETED;
    			                                		msg.obj = bitmap;
    			                                		handler.removeMessages(COMPLETED);
    			                                		handler.sendMessage(msg);
    			                                		
    		                                		}
    		                            			
    		                  				//Message msg = new Message();
    		                                 /* ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 
    		                                  while( (len=ins.read(buffer)) != -1){      
    		                                      outStream.write(buffer, 0, len); 
    		                                  }
    		                                  ins.close();byte data[] = outStream.toByteArray(); 
    		                                  bitmap = BitmapFactory.decodeByteArray(data, 0, data.length); 
    		                                  */
    		                                	
    		                                  
    		                            		}
    		                        		}	
    		                        	} catch (IOException e) {
    		                              // TODO Auto-generated catch block
    		                              e.printStackTrace();
    		                              sendMSG(e.toString()+"bao cuo " +e.getMessage());
    		                          }
    		                	};
    		                }.start();
    				} catch (IOException e1) {
    					// TODO Auto-generated catch block
    					e1.printStackTrace();
    				}
                   /* if(!s.isClosed()){
                        s.close();
                    }*/
                    
              
                //Bitmap bitmap = BitmapFactory.decodeStream(ins);
                
            }
        }
        public int bytesToInt(byte[] src, int offset){
    		int value;
    		value = (int)((src[offset] & 0xFF))
    				| ((src[offset+1] & 0xFF)<<8)
    				| ((src[offset+2] & 0xFF)<<16)
    				| ((src[offset+3] & 0xFF)<<24);
    		return value;
    	}
        public int bytesToInt2(byte[] src, int offset){
    		int value;
    		value = (int)((src[offset] & 0xFF<<24)
    				| ((src[offset+1] & 0xFF)<<16)
    				| ((src[offset+2] & 0xFF)<<8)
    				| (src[offset+3] & 0xFF));
    		return value;
    	}
      /*  public static int bytesToInt2(byte[] src, int offset) {  
        	    int value;    
        	    value = (int) ( ((src[offset] & 0xFF)<<24)  
        	            |((src[offset+1] & 0xFF)<<16)  
        	            |((src[offset+2] & 0xFF)<<8)  
        	            |(src[offset+3] & 0xFF));  
        	    return value;  
        	} */
        public  void sendMSG(String text){
    		Message msg = new Message();
    		msg.what = 908;
    		msg.obj = text;
    		handler.sendMessage(msg);
    	}
    }

第二种方法：

该视频实现是基于TCP/IP协议的Socket(客户端)和ServerSocket(服务端)类，发送视频也就是不间断的发送图片。具体如下：

PC服务端：socketService类开启服务及监听，线程类TheadServer处理socket连接，并调用另外一个线程类ThreadClient发送图片到到另外一台手机上

视频发送端：MainVideoActivity 为显示界面，子线程ClientThread处理图片并发送到服务器

视频接受端：MainActivity为显示界面，子线程RevImageThread为接受服务端发送过来的图片

PC端 socketService类：

package com.socket;
    import java.io.IOException;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class socketService {
    
     /**
    	 * @param args
    	 * @throws IOException 
    	 */
    	public static void main(String[] args) throws IOException {
    
     ServerSocket ss = new ServerSocket(3000);
    		System.out.println("begin");
            
    		while(true){
    
     new Thread(new TheadServer(ss)).start();
    		}
    	}
    }

TheadServer 类:

package com.socket;
    
    import java.awt.Image;
    import java.awt.image.BufferedImage;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    import javax.imageio.ImageIO;
    
    public class TheadServer implements Runnable {
        private Socket s = null;
        private BufferedImage bufferedImage;
            public InputStream ins;
        public TheadServer(ServerSocket ss ) throws IOException{
            System.out.println("start thread");
            this.s=ss.accept();                    
        }
    
        @Override
        public void run(){    
            try {    
                    ins = s.getInputStream();
                    bufferedImage = ImageIO.read(ins);
                    ins.close();
                    ThreadClient tc = new ThreadClient(bufferedImage);
                    new Thread(tc).start();
                    
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                
            }finally{
                try {
                    if(!s.isClosed())
                        s.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

ThreadClient类:

package com.socket;
    
    import java.awt.Image;
    import java.awt.image.BufferedImage;
    import java.awt.image.RenderedImage;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.io.OutputStream;
    import java.io.Serializable;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    
    import javax.imageio.ImageIO;
    
    public class ThreadClient implements Runnable , Serializable {
        private BufferedImage bufferedImage;
        public ThreadClient(BufferedImage  image){
            this.bufferedImage = image;
            
        }
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                Socket s = new Socket();
                //接受视频端IP和端口
                s.connect(new InetSocketAddress("10.0.56.234", 40000), 2000);
                if(s.isConnected() && !s.isClosed()){
                    System.out.println("Client:"+s.getRemoteSocketAddress().toString());
                    OutputStream oos = s.getOutputStream();        
                    ImageIO.write(bufferedImage,"JPG",oos);
                    oos.write("\n".getBytes());
                    oos.flush();
                    oos.close();
                    s.close();
                }
    
            }  catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
    
    
    }

视频发送端:

MainVideoActivity 类：

package com.example.realtimevideo;
    
    
    import java.io.ByteArrayOutputStream;
    
    import com.example.threadConnect.ClientThread;
    
    
    import android.graphics.ImageFormat;
    import android.graphics.Rect;
    import android.graphics.YuvImage;
    import android.hardware.Camera;
    import android.hardware.Camera.PreviewCallback;
    import android.hardware.Camera.Size;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.app.Activity;
    import android.util.DisplayMetrics;
    import android.util.Log;
    import android.view.Menu;
    import android.view.SurfaceHolder;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.Window;
    import android.view.WindowManager;
    import android.view.SurfaceHolder.Callback;
    import android.view.SurfaceView;
    import android.widget.Button;
    
    public class MainVideoActivity extends Activity{
        MyHandler handler;
        ClientThread clientThread;
        ByteArrayOutputStream outstream;
        
        Button start;
        Button stop;
        SurfaceView surfaceView;
        SurfaceHolder  sfh;
        Camera camera;
        boolean isPreview = false;        //是否在浏览中
        int screenWidth=300, screenHeight=300;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            // 设置全屏
             requestWindowFeature(Window.FEATURE_NO_TITLE);
             getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
            setContentView(R.layout.activity_main_video);
            
            handler = new MyHandler();
            clientThread = new ClientThread(handler);
            new Thread(clientThread).start();
            
            DisplayMetrics dm = new DisplayMetrics();
            getWindowManager().getDefaultDisplay().getMetrics(dm);
            screenWidth = dm.widthPixels;// 获取屏幕分辨率宽度
            screenHeight = dm.heightPixels;
    
            
            start = (Button)findViewById(R.id.start);
            stop = (Button)findViewById(R.id.stop);
            surfaceView = (SurfaceView)findViewById(R.id.surfaceView);
            sfh = surfaceView.getHolder(); 
            sfh.setFixedSize(screenWidth, screenHeight/4*3);
             
            sfh.addCallback(new Callback(){
    
                @Override
                public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2,
                        int arg3) {
                    // TODO Auto-generated method stub
                    
                }
    
                @Override
                public void surfaceCreated(SurfaceHolder arg0) {
                    // TODO Auto-generated method stub
                    initCamera();
                }
    
                @Override
                public void surfaceDestroyed(SurfaceHolder arg0) {
                    if (camera != null) {
                        if (isPreview)
                            camera.stopPreview();
                        camera.release();
                        camera = null;
                    }
                    
                }
                
            });
            
            //开启连接服务
            start.setOnClickListener(new OnClickListener(){
    
                @Override
                public void onClick(View arg0) {
                    
                    start.setEnabled(false);
                }
                
            });
            
        }
        
    
        @Override
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.main_video, menu);
            return true;
        }
        
        @SuppressWarnings("deprecation")
        private void initCamera() {
            if (!isPreview) {
                camera = Camera.open();
                ClientThread.size = camera.getParameters().getPreviewSize();   
            }
            if (camera != null && !isPreview) {
                try{
                    camera.setPreviewDisplay(sfh);                 // 通过SurfaceView显示取景画面    
                    Camera.Parameters parameters = camera.getParameters();                
                    parameters.setPreviewSize(screenWidth, screenHeight/4*3);   
                     /* 每秒从摄像头捕获5帧画面， */  
                    parameters.setPreviewFrameRate(5); 
                    parameters.setPictureFormat(ImageFormat.NV21);           // 设置图片格式                
                    parameters.setPictureSize(screenWidth, screenHeight/4*3);    // 设置照片的大小
                    camera.setDisplayOrientation(90);
                    camera.setPreviewCallback(new PreviewCallback(){
    
                        @Override
                        public void onPreviewFrame(byte[] data, Camera c) {
                            // TODO Auto-generated method stub
                             Size size = camera.getParameters().getPreviewSize();          
                                try{ 
                                    //调用image.compressToJpeg（）将YUV格式图像数据data转为jpg格式
                                    YuvImage image = new YuvImage(data, ImageFormat.NV21, size.width, size.height, null);  
                                    if(image!=null){
                                        Message msg = clientThread.revHandler.obtainMessage();
                                        msg.what=0x111;
                                        msg.obj=image;
                                        clientThread.revHandler.sendMessage(msg);
                                        
                                        /*outstream = new ByteArrayOutputStream();
                                        image.compressToJpeg(new Rect(0, 0, size.width, size.height), 80, outstream); 
                                        outstream.flush();
                                        new Thread(clientThread).start();*/
                                    }
                                }catch(Exception ex){  
                                        Log.e("Sys","Error:"+ex.getMessage());  
                                }
                        }
                        
                    });
                    camera.startPreview();                                   // 开始预览                
                    camera.autoFocus(null);                                  // 自动对焦
                } catch (Exception e) {
                    e.printStackTrace();
                }
                isPreview = true;
            }
        }
        
        static class MyHandler extends Handler{
            @Override
            public void handleMessage(Message msg){
                if(msg.what==0x222){
                    //返回信息显示代码
                }
            }
        }
    }

ClientThread类：

package com.example.threadConnect;
    
    import java.io.BufferedReader;
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.UnsupportedEncodingException;
    import java.net.Socket;
    import java.net.SocketTimeoutException;
    import java.net.UnknownHostException;
    
    import android.graphics.Rect;
    import android.graphics.YuvImage;
    import android.hardware.Camera.Size;
    import android.os.Handler;
    import android.os.Looper;
    import android.os.Message;
    import android.util.Log;
    
    public class ClientThread implements Runnable {
        private static Socket socket ;
        private static ByteArrayOutputStream outputstream;
        private static byte byteBuffer[] = new byte[1024];
        public static Size size;
    
        //向UI线程发送消息
        private Handler handler;
        
        //接受UI线程消息
        public MyHandler revHandler;
        
        BufferedReader br= null;
        static OutputStream os = null;
        
        public ClientThread(Handler handler){
            this.handler=handler;
            
        }
    
        @Override
        public void run() {
    
                
                Looper.prepare();
                //接受UI发来的信息
                revHandler = new MyHandler();
                Looper.loop();
    
        }
        
        public static class MyHandler extends Handler{
            @Override
            public void handleMessage(Message msg){
                if(msg.what==0x111){
                    try {
                        socket = new Socket("10.0.56.232",3000);
                        os = socket.getOutputStream(); 
                        YuvImage image = (YuvImage) msg.obj;
                        if(socket.isOutputShutdown()){
                            socket.getKeepAlive();
                        
                        }else{
                            os = socket.getOutputStream();  
                            outputstream = new ByteArrayOutputStream();
                            image.compressToJpeg(new Rect(0, 0, size.width, size.height), 80, outputstream);
                            ByteArrayInputStream inputstream = new ByteArrayInputStream(outputstream.toByteArray());
                            int amount;
                            while ((amount = inputstream.read(byteBuffer)) != -1) {
                                os.write(byteBuffer, 0, amount);
                            }
                            os.write("\n".getBytes());
                            outputstream.flush();
                            outputstream.close();
                            os.flush();
                            os.close();
                            socket.close();
                        }
                    } catch (UnsupportedEncodingException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }

布局:

视频接受端:

MainActivity:

package com.example.socketphone;
    
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Looper;
    import android.os.Message;
    import android.app.Activity;
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.util.Log;
    import android.view.Menu;
    import android.widget.ImageView;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.ObjectInputStream;
    import java.net.Socket; 
    import java.net.ServerSocket;
    
    import com.example.Thread.RevImageThread;
    
    public class MainActivity extends Activity {
        RevImageThread revImageThread;
        public static ImageView image;
        private static Bitmap bitmap;
        private static final int COMPLETED = 0x111;
        private MyHandler handler;
         
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            image=(ImageView)findViewById(R.id.imageView1);
            handler = new MyHandler();
            revImageThread = new RevImageThread(handler);
            new Thread(revImageThread).start();
            
        }
        
        static class MyHandler extends Handler{
            @Override
            public void handleMessage(Message msg){
                 if (msg.what == COMPLETED) {
                     bitmap = (Bitmap)msg.obj;
                    image.setImageBitmap(bitmap); 
                    super.handleMessage(msg);
                 }  
            }
        }
        
        public boolean onCreateOptionsMenu(Menu menu) {
            // Inflate the menu; this adds items to the action bar if it is present.
            getMenuInflater().inflate(R.menu.main, menu);
            return true;
        }
    }

RevImageThread类:

package com.example.Thread;
    
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    import android.graphics.Bitmap;
    import android.graphics.BitmapFactory;
    import android.os.Handler;
    import android.os.Looper;
    import android.os.Message;
    import android.util.Log;
    
    public class RevImageThread implements Runnable {
    
        public Socket s;
        public ServerSocket ss;
        
        //向UI线程发送消息
        private Handler handler;
        
        private Bitmap bitmap;
        private static final int COMPLETED = 0x111;
        
        public RevImageThread(Handler handler){
            this.handler = handler;
        }
        
        public void run()
        {    
            byte [] buffer = new byte[1024];
            int len = 0;
    
        
            try {
                ss = new ServerSocket(40000);
            } catch (IOException e2) {
                // TODO Auto-generated catch block
                e2.printStackTrace();
            }
    
            InputStream ins = null;
            while(true){
                
                try {
                    s = ss.accept();
                    Log.e("strat","ljq");
                    ins = s.getInputStream();
                    
                    ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 
                    while( (len=ins.read(buffer)) != -1){      
                        outStream.write(buffer, 0, len); 
                    }
                    ins.close();byte data[] = outStream.toByteArray(); 
                    bitmap = BitmapFactory.decodeByteArray(data, 0, data.length); 
                    
                    Message msg =handler.obtainMessage();
                    msg.what = COMPLETED;
                    msg.obj = bitmap;
                    handler.sendMessage(msg);
                    
                    outStream.flush();
                    outStream.close();
                    if(!s.isClosed()){
                        s.close();
                    }
                    
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //Bitmap bitmap = BitmapFactory.decodeStream(ins);
                
            }
        }
    
    }

布局：

参考转自：

\[1\] [https://blog.csdn.net/a289973483/article/details/52790217][https_blog.csdn.net_a289973483_article_details_52790217]

\[2\] [https://www.cnblogs.com/lijiongquan/p/4729445.html][https_www.cnblogs.com_lijiongquan_p_4729445.html]

[https_blog.csdn.net_a289973483_article_details_52790217]: https://blog.csdn.net/a289973483/article/details/52790217
[https_www.cnblogs.com_lijiongquan_p_4729445.html]: https://www.cnblogs.com/lijiongquan/p/4729445.html