基于Socket的Android手机视频实时传输_手机视频流怎么实时传输到服务器-CSDN博客

首先，简单介绍一下原理。主要是在手机客户端（Android）通过实现Camera.PreviewCallback接口，在其onPreviewFrame重载函数里面获取摄像头当前图像数据，然后通过Socket将图像数据和相关的用户名、命令等数据传输到服务器程序中。服务器端（PC端）采用C#编写，通过监听相应的端口，在获取数据后进行相应的命令解析和图像数据还原，然后将图像数据传递至PictureBox控件中用于显示，这样就实现了手机摄像头的视频数据实时传输到服务器上。如果需要将这些视频进行转发，通过服务器再将这些数据复制转发即可。效果如下：

对于Android客户端上主要有几个地方需要注意，第一个就是Socket通信。Socket通信可以通过Socket类来实现，直接结合PrintWriter来写入命令，如下定义的一个专门用于发送命令的线程类，当要连接到服务器和与服务器断开时，都需要发送命令通知服务器，此外在进行其他文字传输时也可以采用该方法，具体代码如下：

[java]view plaincopy 
   
 /**发送命令线程*/  
   class MySendCommondThread extends Thread{  
     private String commond;  
     public MySendCommondThread(String commond){  
         this.commond=commond;  
     }  
     public void run(){  
         //实例化Socket    
           try {  
             Socket socket=new Socket(serverUrl,serverPort);  
             PrintWriter out = new PrintWriter(socket.getOutputStream());  
             out.println(commond);  
             out.flush();  
         } catch (UnknownHostException e) {  
         } catch (IOException e) {  
         }    
     }  
   }  

如果是采用Socket发送文件，则可以通过OutputStream将ByteArrayInputStream数据流读入，而文件数据流则转换为ByteArrayOutputStream。如果需要在前面添加文字，同样也需要转换为byte，然后写入OutputStream。同样也可以通过定义一个线程类发送文件，如下：

[java]view plaincopy 
   
 /**发送文件线程*/  
    class MySendFileThread extends Thread{     
     private String username;  
     private String ipname;  
     private int port;  
     private byte byteBuffer[] = new byte[1024];  
     private OutputStream outsocket;   
     private ByteArrayOutputStream myoutputstream;  
       
     public MySendFileThread(ByteArrayOutputStream myoutputstream,String username,String ipname,int port){  
         this.myoutputstream = myoutputstream;  
         this.username=username;  
         this.ipname = ipname;  
         this.port=port;  
            try {  
             myoutputstream.close();  
         } catch (IOException e) {  
             e.printStackTrace();  
         }  
     }  
       
        public void run() {  
            try{  
             //将图像数据通过Socket发送出去  
                Socket tempSocket = new Socket(ipname, port);  
                outsocket = tempSocket.getOutputStream();  
                //写入头部数据信息  
             String msg=java.net.URLEncoder.encode("PHONEVIDEO|"+username+"|","utf-8");  
                byte[] buffer= msg.getBytes();  
                outsocket.write(buffer);  
                  
                ByteArrayInputStream inputstream = new ByteArrayInputStream(myoutputstream.toByteArray());  
                int amount;  
                while ((amount = inputstream.read(byteBuffer)) != -1) {  
                    outsocket.write(byteBuffer, 0, amount);  
                }  
                myoutputstream.flush();  
                myoutputstream.close();  
                tempSocket.close();                     
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  

而获取摄像头当前图像的关键在于onPreviewFrame()重载函数里面，该函数里面有两个参数，第一个参数为byte[]，为摄像头当前图像数据，通过YuvImage可以将该数据转换为图片文件，同时还可用对该图片进行压缩和裁剪，将图片进行压缩转换后转换为 ByteArrayOutputStream数据，即前面发送文件线程类中所需的文件数据，然后采用线程发送文件，如下代码：

[java]view plaincopy 
   
 @Override  
 public void onPreviewFrame(byte[] data, Camera camera) {  
     // TODO Auto-generated method stub  
     //如果没有指令传输视频，就先不传  
     if(!startSendVideo)  
         return;  
     if(tempPreRate<VideoPreRate){  
         tempPreRate++;  
         return;  
     }  
     tempPreRate=0;        
     try {  
           if(data!=null)  
           {  
             YuvImage image = new YuvImage(data,VideoFormatIndex, VideoWidth, VideoHeight,null);  
             if(image!=null)  
             {  
                 ByteArrayOutputStream outstream = new ByteArrayOutputStream();  
                 //在此设置图片的尺寸和质量   
                 image.compressToJpeg(new Rect(0, 0, (int)(VideoWidthRatio*VideoWidth),   
                     (int)(VideoHeightRatio*VideoHeight)), VideoQuality, outstream);    
                 outstream.flush();  
                 //启用线程将图像数据发送出去  
                 Thread th = new MySendFileThread(outstream,pUsername,serverUrl,serverPort);  
                 th.start();    
             }  
           }  
       } catch (IOException e) {  
           e.printStackTrace();  
       }  
 }  

值得注意的是，在调试中YuvImage可能找不到，在模拟机上无法执行该过程，但是编译后在真机中可以通过。此外，以上传输文字字符都是采用UTF编码，在服务器端接收时进行解析时需要采用对应的编码进行解析，否则可能会出现错误解析。

Android客户端中关键的部分主要就这些，新建一个Android项目（项目名称为SocketCamera），在main布局中添加一个SurfaceView和两个按钮，如下图所示：

然后在SocketCameraActivity.java中添加代码，具体如下：

[java]view plaincopy 
   
 package com.xzy;  
   
 import java.io.ByteArrayInputStream;  
 import java.io.ByteArrayOutputStream;  
 import java.io.IOException;  
 import java.io.OutputStream;  
 import java.io.PrintWriter;  
 import java.net.Socket;  
 import java.net.UnknownHostException;  
 import android.app.Activity;  
 import android.app.AlertDialog;  
 import android.content.DialogInterface;  
 import android.content.Intent;  
 import android.content.SharedPreferences;  
 import android.graphics.Rect;  
 import android.graphics.YuvImage;  
 import android.hardware.Camera;  
 import android.hardware.Camera.Size;  
 import android.os.Bundle;  
 import android.preference.PreferenceManager;  
 import android.view.Menu;  
 import android.view.MenuItem;  
 import android.view.SurfaceHolder;  
 import android.view.SurfaceView;  
 import android.view.View;  
 import android.view.WindowManager;  
 import android.view.View.OnClickListener;  
 import android.widget.Button;  
   
 public class SocketCameraActivity extends Activity implements SurfaceHolder.Callback,  
 Camera.PreviewCallback{       
     private SurfaceView mSurfaceview = null; // SurfaceView对象：(视图组件)视频显示  
     private SurfaceHolder mSurfaceHolder = null; // SurfaceHolder对象：(抽象接口)SurfaceView支持类  
     private Camera mCamera = null; // Camera对象，相机预览   
       
     /**服务器地址*/  
     private String pUsername="XZY";  
     /**服务器地址*/  
     private String serverUrl="192.168.1.100";  
     /**服务器端口*/  
     private int serverPort=8888;  
     /**视频刷新间隔*/  
     private int VideoPreRate=1;  
     /**当前视频序号*/  
     private int tempPreRate=0;  
     /**视频质量*/  
     private int VideoQuality=85;  
       
     /**发送视频宽度比例*/  
     private float VideoWidthRatio=1;  
     /**发送视频高度比例*/  
     private float VideoHeightRatio=1;  
       
     /**发送视频宽度*/  
     private int VideoWidth=320;  
     /**发送视频高度*/  
     private int VideoHeight=240;  
     /**视频格式索引*/  
     private int VideoFormatIndex=0;  
     /**是否发送视频*/  
     private boolean startSendVideo=false;  
     /**是否连接主机*/  
     private boolean connectedServer=false;  
       
     private Button myBtn01, myBtn02;  
     /** Called when the activity is first created. */  
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         setContentView(R.layout.main);  
           
         //禁止屏幕休眠        getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,   
                 WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);  
                  
         mSurfaceview = (SurfaceView) findViewById(R.id.camera_preview);  
         myBtn01=(Button)findViewById(R.id.button1);  
         myBtn02=(Button)findViewById(R.id.button2);  
                   
         //开始连接主机按钮  
         myBtn01.setOnClickListener(new OnClickListener(){  
             public void onClick(View v) {  
                 //Common.SetGPSConnected(LoginActivity.this, false);  
                 if(connectedServer){//停止连接主机，同时断开传输  
                     startSendVideo=false;  
                     connectedServer=false;                    
                     myBtn02.setEnabled(false);  
                     myBtn01.setText("开始连接");  
                     myBtn02.setText("开始传输");  
                     //断开连接  
                     Thread th = new MySendCommondThread("PHONEDISCONNECT|"+pUsername+"|");  
                     th.start();   
                 }  
                 else//连接主机  
                 {  
                     //启用线程发送命令PHONECONNECT  
                     Thread th = new MySendCommondThread("PHONECONNECT|"+pUsername+"|");  
                     th.start();   
                     connectedServer=true;  
                     myBtn02.setEnabled(true);  
                     myBtn01.setText("停止连接");  
                 }  
             }});  
           
         myBtn02.setEnabled(false);  
         myBtn02.setOnClickListener(new OnClickListener(){  
             public void onClick(View v) {  
                 if(startSendVideo)//停止传输视频  
                 {  
                     startSendVideo=false;  
                     myBtn02.setText("开始传输");  
                 }  
                 else{ // 开始传输视频  
                     startSendVideo=true;  
                     myBtn02.setText("停止传输");  
                 }  
             }});  
     }  
       
     @Override  
     public void onStart()//重新启动的时候  
     {     
         mSurfaceHolder = mSurfaceview.getHolder(); // 绑定SurfaceView，取得SurfaceHolder对象  
         mSurfaceHolder.addCallback(this); // SurfaceHolder加入回调接口         
         mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);// 设置显示器类型，setType必须设置  
         //读取配置文件  
         SharedPreferences preParas = PreferenceManager.getDefaultSharedPreferences(SocketCameraActivity.this);  
         pUsername=preParas.getString("Username", "XZY");  
         serverUrl=preParas.getString("ServerUrl", "192.168.0.100");  
         String tempStr=preParas.getString("ServerPort", "8888");  
         serverPort=Integer.parseInt(tempStr);  
         tempStr=preParas.getString("VideoPreRate", "1");  
         VideoPreRate=Integer.parseInt(tempStr);               
         tempStr=preParas.getString("VideoQuality", "85");  
         VideoQuality=Integer.parseInt(tempStr);  
         tempStr=preParas.getString("VideoWidthRatio", "100");  
         VideoWidthRatio=Integer.parseInt(tempStr);  
         tempStr=preParas.getString("VideoHeightRatio", "100");  
         VideoHeightRatio=Integer.parseInt(tempStr);  
         VideoWidthRatio=VideoWidthRatio/100f;  
         VideoHeightRatio=VideoHeightRatio/100f;  
           
         super.onStart();  
     }  
       
     @Override  
     protected void onResume() {  
         super.onResume();          
         InitCamera();  
     }  
       
     /**初始化摄像头*/  
     private void InitCamera(){  
         try{  
             mCamera = Camera.open();  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
     }  
    
     @Override  
     protected void onPause() {  
         super.onPause();  
         try{  
             if (mCamera != null) {  
                 mCamera.setPreviewCallback(null); // ！！这个必须在前，不然退出出错  
                 mCamera.stopPreview();  
                 mCamera.release();  
                 mCamera = null;  
             }   
         } catch (Exception e) {  
             e.printStackTrace();  
         }   
     }  
     @Override  
     public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {  
         // TODO Auto-generated method stub  
         if (mCamera == null) {  
             return;  
         }  
         mCamera.stopPreview();  
         mCamera.setPreviewCallback(this);  
         mCamera.setDisplayOrientation(90); //设置横行录制  
         //获取摄像头参数  
         Camera.Parameters parameters = mCamera.getParameters();  
         Size size = parameters.getPreviewSize();  
         VideoWidth=size.width;  
         VideoHeight=size.height;  
         VideoFormatIndex=parameters.getPreviewFormat();  
           
         mCamera.startPreview();  
     }  
   
     @Override  
     public void surfaceCreated(SurfaceHolder holder) {  
         // TODO Auto-generated method stub  
         try {  
             if (mCamera != null) {  
                 mCamera.setPreviewDisplay(mSurfaceHolder);  
                 mCamera.startPreview();  
             }  
         } catch (IOException e) {  
             e.printStackTrace();  
         }   
     }  
   
     @Override  
     public void surfaceDestroyed(SurfaceHolder holder) {  
         // TODO Auto-generated method stub  
         if (null != mCamera) {  
             mCamera.setPreviewCallback(null); // ！！这个必须在前，不然退出出错  
             mCamera.stopPreview();  
             mCamera.release();  
             mCamera = null;  
         }  
     }  
   
     @Override  
     public void onPreviewFrame(byte[] data, Camera camera) {  
         // TODO Auto-generated method stub  
         //如果没有指令传输视频，就先不传  
         if(!startSendVideo)  
             return;  
         if(tempPreRate<VideoPreRate){  
             tempPreRate++;  
             return;  
         }  
         tempPreRate=0;        
         try {  
               if(data!=null)  
               {  
                 YuvImage image = new YuvImage(data,VideoFormatIndex, VideoWidth, VideoHeight,null);  
                 if(image!=null)  
                 {  
                     ByteArrayOutputStream outstream = new ByteArrayOutputStream();  
                     //在此设置图片的尺寸和质量   
                     image.compressToJpeg(new Rect(0, 0, (int)(VideoWidthRatio*VideoWidth),   
                         (int)(VideoHeightRatio*VideoHeight)), VideoQuality, outstream);    
                     outstream.flush();  
                     //启用线程将图像数据发送出去  
                     Thread th = new MySendFileThread(outstream,pUsername,serverUrl,serverPort);  
                     th.start();    
                 }  
               }  
           } catch (IOException e) {  
               e.printStackTrace();  
           }  
     }  
           
     /**创建菜单*/      
     public boolean onCreateOptionsMenu(Menu menu)  
     {  
         menu.add(0,0,0,"系统设置");  
         menu.add(0,1,1,"关于程序");   
         menu.add(0,2,2,"退出程序");   
         return super.onCreateOptionsMenu(menu);  
     }  
     /**菜单选中时发生的相应事件*/    
     public boolean onOptionsItemSelected(MenuItem item)  
     {  
         super.onOptionsItemSelected(item);//获取菜单  
         switch(item.getItemId())//菜单序号  
         {  
             case 0:  
                 //系统设置  
                 {  
                     Intent intent=new Intent(this,SettingActivity.class);  
                     startActivity(intent);    
                 }  
                 break;    
             case 1://关于程序  
             {  
                 new AlertDialog.Builder(this)  
                 .setTitle("关于本程序")  
                 .setMessage("本程序由武汉大学水利水电学院肖泽云设计、编写。\nEmail：xwebsite@163.com")  
                 .setPositiveButton  
                 (  
                     "我知道了",  
                     new DialogInterface.OnClickListener()  
                     {                         
                         @Override  
                         public void onClick(DialogInterface dialog, int which)   
                         {  
                         }  
                     }  
                 )  
                 .show();  
             }  
             break;  
             case 2://退出程序  
                 {  
                     //杀掉线程强制退出  
                     android.os.Process.killProcess(android.os.Process.myPid());  
                 }  
                 break;  
         }         
         return true;  
     }  
       
     /**发送命令线程*/  
     class MySendCommondThread extends Thread{  
         private String commond;  
         public MySendCommondThread(String commond){  
             this.commond=commond;  
         }  
         public void run(){  
             //实例化Socket    
             try {  
                 Socket socket=new Socket(serverUrl,serverPort);  
                 PrintWriter out = new PrintWriter(socket.getOutputStream());  
                 out.println(commond);  
                 out.flush();  
             } catch (UnknownHostException e) {  
             } catch (IOException e) {  
             }    
         }  
     }  
       
     /**发送文件线程*/  
     class MySendFileThread extends Thread{    
         private String username;  
         private String ipname;  
         private int port;  
         private byte byteBuffer[] = new byte[1024];  
         private OutputStream outsocket;   
         private ByteArrayOutputStream myoutputstream;  
           
         public MySendFileThread(ByteArrayOutputStream myoutputstream,String username,String ipname,int port){  
             this.myoutputstream = myoutputstream;  
             this.username=username;  
             this.ipname = ipname;  
             this.port=port;  
             try {  
                 myoutputstream.close();  
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
           
         public void run() {  
             try{  
                 //将图像数据通过Socket发送出去  
                 Socket tempSocket = new Socket(ipname, port);  
                 outsocket = tempSocket.getOutputStream();  
                 //写入头部数据信息  
                 String msg=java.net.URLEncoder.encode("PHONEVIDEO|"+username+"|","utf-8");  
                 byte[] buffer= msg.getBytes();  
                 outsocket.write(buffer);  
                   
                 ByteArrayInputStream inputstream = new ByteArrayInputStream(myoutputstream.toByteArray());  
                 int amount;  
                 while ((amount = inputstream.read(byteBuffer)) != -1) {  
                     outsocket.write(byteBuffer, 0, amount);  
                 }  
                 myoutputstream.flush();  
                 myoutputstream.close();  
                 tempSocket.close();      
             } catch (IOException e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
 }  

此外还有一些参数，在res/xml新建一个setting.xml文件，添加服务器地址、端口、用户名等参数设置，如下：

[html]view plaincopy 
   
 <?xml version="1.0" encoding="utf-8"?>  
 <PreferenceScreen  
   xmlns:android="http://schemas.android.com/apk/res/android">  
  <PreferenceCategory android:title="服务器设置">  
     <EditTextPreference  
    android:key="Username"  
    android:title="用户名"      
    android:summary="用于连接服务器的用户名"  
    android:defaultValue="XZY"/>  
    <EditTextPreference  
    android:key="ServerUrl"  
    android:title="视频服务器地址"      
    android:summary="保存服务器地址"  
    android:defaultValue="192.168.1.100"/>  
 <EditTextPreference  
    android:key="ServerPort"  
    android:title="服务器端口"      
    android:summary="连接服务器的端口地址"  
    android:defaultValue="8888"/>  
    </PreferenceCategory>  
 <PreferenceCategory android:title="视频设置">  
     <EditTextPreference  
    android:key="VideoPreRate"  
    android:title="视频刷新间隔"      
    android:summary="设置视频刷新的间隔值，应大于等于0，值越大视频传输间隔越长"  
    android:defaultValue="1"/>  
 <EditTextPreference  
    android:key="VideoQuality"  
    android:title="图像质量"      
    android:summary="设置图像压缩的质量，值为0~100，值越高越清晰，但同时数据也更大"  
    android:defaultValue="85"/>  
 <EditTextPreference  
    android:key="VideoWidthRatio"  
    android:title="图像宽度缩放比例"      
    android:summary="设置图像的宽度缩放比例，值为0~100，值越高图像分辨率越高"  
    android:defaultValue="100"/>  
    <EditTextPreference  
    android:key="VideoHeightRatio"  
    android:title="图像高度缩放比例"      
    android:summary="设置图像的高度缩放比例，值为0~100，值越高图像分辨率越高"  
    android:defaultValue="100"/>  
     </PreferenceCategory>  
 </PreferenceScreen>  

编译程序，在模拟机上效果如下：

接下来就是服务器端接收手机传输的视频数据，这与一般CS架构中服务器程序类似，主要是监听端口，然后解析数据。现新建一个C#应用程序项目（项目名称为“手机摄像头”），首先定义一些全局变量，主要包括服务器地址、端口以及相关监听对象等，如下：

[csharp]view plaincopy 
   
 /// <summary>  
         /// 服务器状态，如果为false表示服务器暂停,true表示服务器开启  
         /// </summary>  
         public bool ServerStatus = false;  
         /// <summary>  
         /// 服务器地址  
         /// </summary>  
         public string ServerAddress;  
         /// <summary>  
         /// 服务器端口  
         /// </summary>  
         public int ServerPort;  
         /// <summary>  
         /// 开启服务的线程  
         /// </summary>  
         private Thread processor;  
         /// <summary>  
         /// 用于TCP监听  
         /// </summary>  
         private TcpListener tcpListener;  
         /// <summary>  
         /// 与客户端连接的套接字接口  
         /// </summary>  
         private Socket clientSocket;  
         /// <summary>  
         /// 用于处理客户事件的线程  
         /// </summary>  
         private Thread clientThread;  
         /// <summary>  
         /// 手机客户端所有客户端的套接字接口  
         /// </summary>  
         private Hashtable PhoneClientSockets = new Hashtable();  
         /// <summary>  
         /// 手机用户类数组  
         /// </summary>  
         public ArrayList PhoneUsersArray = new ArrayList();  
         /// <summary>  
         /// 手机用户名数组  
         /// </summary>  
         public ArrayList PhoneUserNamesArray = new ArrayList();  
         /// <summary>  
         /// 图像数据流  
         /// </summary>  
         private ArrayList StreamArray;  

然后定义处理客户端传递数据的函数ProcessClient()，主要对接收数据进行命令解析。如果是手机连接的命令（"PHONECONNECT"），就在记录该套接字对象，同时在列表中添加该对象；如果是断开连接的命令（"PHONEDISCONNECT"）,就移除该对象；如果是手机视频命令（"PHONEVIDEO"），就分解其包含的图像数据，如果存在该用户对应的视频窗口，就传递该图像数据到这个视频窗口中。具体代码如下：

[csharp]view plaincopy 
   
 #region 处理客户端传递数据及处理事情  
       /// <summary>  
       /// 处理客户端传递数据及处理事情  
       /// </summary>  
       private void ProcessClient()  
       {  
           Socket client = clientSocket;  
           bool keepalive = true;  
           while (keepalive)  
           {  
               Thread.Sleep(50);  
               Byte[] buffer = null;  
               bool tag = false;  
               try  
               {  
                   buffer = new Byte[1024];//client.Available  
                   int count = client.Receive(buffer, SocketFlags.None);//接收客户端套接字数据  
                   if (count > 0)//接收到数据  
                       tag = true;  
               }  
               catch (Exception e)  
               {  
                   keepalive = false;  
                   if (client.Connected)  
                       client.Disconnect(true);  
                   client.Close();  
               }  
               if (!tag)  
               {  
                   if (client.Connected)  
                       client.Disconnect(true);  
                   client.Close();  
                   keepalive = false;  
               }  
   
               string clientCommand = "";  
               try  
               {  
                   clientCommand = System.Text.Encoding.UTF8.GetString(buffer);//转换接收的数据,数据来源于客户端发送的消息  
                   if (clientCommand.Contains("%7C"))//从Android客户端传递部分数据  
                       clientCommand = clientCommand.Replace("%7C", "|");//替换UTF中字符%7C为|  
               }  
               catch  
               {  
               }  
               //分析客户端传递的命令来判断各种操作  
               string[] messages = clientCommand.Split('|');  
               if (messages != null && messages.Length > 0)  
               {  
                   string tempStr = messages[0];//第一个字符串为命令  
                   if (tempStr == "PHONECONNECT")//手机连接服务器  
                   {  
                       try  
                       {  
                           string tempClientName = messages[1].Trim();  
                           PhoneClientSockets.Remove(messages[1]);//删除之前与该用户的连接  
                           PhoneClientSockets.Add(messages[1], client);//建立与该客户端的Socket连接                          
   
                           UserClass tempUser = new UserClass();  
                           tempUser.UserName = tempClientName;  
                           tempUser.LoginTime = DateTime.Now;  
                           Socket tempSocket = (Socket)PhoneClientSockets[tempClientName];  
                           tempUser.IPAddress = tempSocket.RemoteEndPoint.ToString();  
   
                           int tempIndex = PhoneUserNamesArray.IndexOf(tempClientName);  
                           if (tempIndex >= 0)  
                           {  
                               PhoneUserNamesArray[tempIndex] = tempClientName;  
                               PhoneUsersArray[tempIndex] = tempUser;  
                               MemoryStream stream2 = (MemoryStream)StreamArray[tempIndex];  
                               if (stream2 != null)  
                               {  
                                   stream2.Close();  
                                   stream2.Dispose();  
                               }  
                           }  
                           else//新增加  
                           {  
                               PhoneUserNamesArray.Add(tempClientName);  
                               PhoneUsersArray.Add(tempUser);  
                               StreamArray.Add(null);  
                           }  
                           RefreshPhoneUsers();  
                       }  
                       catch (Exception except)  
                       {  
                       }  
                   }  
                   else if (tempStr == "PHONEDISCONNECT")//某个客户端退出了  
                   {  
                       try  
                       {  
                           string tempClientName = messages[1];  
                           RemovePhoneUser(tempClientName);  
   
                           int tempPhoneIndex = PhoneUserNamesArray.IndexOf(tempClientName);  
                           if (tempPhoneIndex >= 0)  
                           {  
                               PhoneUserNamesArray.RemoveAt(tempPhoneIndex);  
                               MemoryStream memStream = (MemoryStream)StreamArray[tempPhoneIndex];  
                               if (memStream != null)  
                               {  
                                   memStream.Close();  
                                   memStream.Dispose();  
                               }  
                               StreamArray.RemoveAt(tempPhoneIndex);  
                           }  
                           Socket tempSocket = (Socket)PhoneClientSockets[tempClientName];//第1个为客户端的ID,找到该套接字  
                           if (tempSocket != null)  
                           {  
                               tempSocket.Close();  
                               PhoneClientSockets.Remove(tempClientName);  
                           }  
                           keepalive = false;  
                       }  
                       catch (Exception except)  
                       {  
                       }  
                       RefreshPhoneUsers();  
                   }  
                   else if (tempStr == "PHONEVIDEO")//接收手机数据流  
                   {  
                       try  
                       {  
                           string tempClientName = messages[1];  
                           string tempForeStr = messages[0] + "%7C" + messages[1] + "%7C";  
                           int startCount = System.Text.Encoding.UTF8.GetByteCount(tempForeStr);  
                           try  
                           {  
                               MemoryStream stream = new MemoryStream();  
                               if (stream.CanWrite)  
                               {  
                                   stream.Write(buffer, startCount, buffer.Length - startCount);  
                                   int len = -1;  
                                   while ((len = client.Receive(buffer)) > 0)  
                                   {  
                                       stream.Write(buffer, 0, len);  
                                   }  
                               }  
                               stream.Flush();  
   
                               int tempPhoneIndex = PhoneUserNamesArray.IndexOf(tempClientName);  
                               if (tempPhoneIndex >= 0)  
                               {  
                                   MemoryStream stream2 = (MemoryStream)StreamArray[tempPhoneIndex];  
                                   if (stream2 != null)  
                                   {  
                                       stream2.Close();  
                                       stream2.Dispose();  
                                   }  
                                   StreamArray[tempPhoneIndex] = stream;  
   
                                   PhoneVideoForm form = GetPhoneVideoForm(tempClientName);  
                                   if (form != null)  
                                       form.DataStream = stream;  
                               }  
                           }  
                           catch  
                           {  
                           }  
                       }  
                       catch (Exception except)  
                       {  
                       }  
                   }  
               }  
               else//客户端发送的命令或字符串为空,结束连接  
               {  
                   try  
                   {  
                       client.Close();  
                       keepalive = false;  
                   }  
                   catch  
                   {  
                       keepalive = false;  
                   }  
               }  
           }  
       }  
       #endregion  