安卓下的TCP通信socket編程

一、安卓下的Socket基本實現原理

    服務端：首先聲明一個ServerSocket對象並指定端口號，然后調用ServerSocket的accept( )方法接收客戶端的數據。accept（）方法在沒有客戶端請求連接之前處於阻塞狀態，一旦接收到連接請求，則通過輸入流讀取接收的數據。代碼實例如下

 

import java.io.DataInputStream;
import java.net.*;
public class TCPServer {

    public static void main(String[] args) throws Exception{
        ServerSocket ss = new ServerSocket(8000);
        //不止接受一個客戶端
        while (true) {
        Socket s = ss.accept();//接受一個連接
        DataInputStream dis = new DataInputStream(s.getInputStream());//輸入管道
        System.out.println(dis.readUTF());
        dis.close();
        s.close();
        
        }
    }

}

     客戶端：創建一個Socket對象，指定服務器端的ip地址和端口號，申請連接。通過輸入流InPutStream讀取服務端的數據，通過輸出流OutPutStream向服務端寫數據

 

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.*;
public class TCPClient {

    public static void main(String[] args) throws Exception {
        Socket s = new Socket("192.168.1.100", 8000);//申請鏈接
        OutputStream os = s.getOutputStream();
        DataOutputStream dos = new DataOutputStream(os);
        dos.writeUTF("hello server!");
        dos.flush(); 
        dos.close();
        s.close();
    }
}

二、安卓下實現socket通信
       注意：一定要添加網絡訪問權限，一開始沒有添加一直報異常，異常信息為：SocketException:socket failed:EACCES(Permission denied)

      在manifest.xml文件中添加<uses-permission android:name="android.permission.INTERNET" />

     我在最剛開始寫這個安卓APP的時候沒有加這個網絡權限，然后報這個異常，在網上知道是這個原因之后加了網絡權限，還是報異常，這讓我十分苦惱，還嘗試了降低安卓運行版本的辦法，試圖降到4.0以下的版本，發現不能實現。后來意外發現在我的手機上運行安卓程序時出現的是這樣的情況

而運行其他安卓程序時是這樣的

於是我發現問題的所在了，還是因為我的手機APP沒有訪問網絡的權限，可是我明明加了呀，無奈之下我只好嘗試將這個APP卸載掉，再重新安裝試試，一試還真可以了，簡直是一個大大的驚喜！解決這個問題之后，運行的時候APP沒有在崩掉，但是並沒有連上開發板通信，打log程序運行到Socket socket = new Socket("192.168.1.100",9500)就不往下運行了，這個問題又困擾到我了，查看日志信息發現

原來在安卓里面，涉及到網絡連接等耗時操作時，不能將其放在UI主線程中，需要添加子線程，在子線程進行網絡連接，這就涉及到安卓線程間的通信了，用Handle來實現。

三、Handler
         handle的定義： 主要接受子線程發送的數據, 並用此數據配合主線程更新UI.
          解釋: 當應用程序啟動時，Android首先會開啟一個主線程 (也就是UI線程) , 主線程為管理界面中的UI控件，進行事件分發, 比如說, 你要是點擊一個 Button, Android會分發事件到Button上，來響應你的操作。  如果此時需要一個耗時的操作，例如: 聯網讀取數據，或者讀取本地較大的一個文件的時候，你不能把這些操作放在主線程中，如果你放在主線程中的話，界面會出現假死現象, 如果5秒鍾還沒有完成的話，會收到Android系統的一個錯誤提示  "強制關閉".  這個時候我們需要把這些耗時的操作，放在一個子線程中,更新UI只能在主線程中更新，子線程中操作是危險的. 這個時候，Handler就出現了來解決這個復雜的問題，由於Handler運行在主線程中(UI線程中)，它與子線程可以通過Message對象來傳遞數據，這個時候，Handler就承擔着接受子線程傳過來的(子線程用sedMessage()方法傳弟)Message對象，里面包含數據, 把這些消息放入主線程隊列中，配合主線程進行更新UI。

下面為安卓客戶端的MainActivity.java的代碼

package com.tanxiaoyi.newApp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.math.MathContext;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Map;

import com.tanxiaoyi.save.UserInfoUtil;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.StrictMode;
import android.text.TextUtils;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.Toast;


public class MainActivity extends Activity {
    protected static final String TAG = "TXY";
    //定義服務端的ip地址和端口號
    private final String SERVER_HOST_IP = "192.168.1.100";
    private final int SERVER_HOST_PORT = 9500;
    private Socket socket;
    private Thread thread = null; //聲明線程
    private OutputStream output;
    private InputStream In;
    
    private Button btn_load; // 聲明Button類型的對象
    private EditText et_secretKey;
    private Context mContext ;
    private CheckBox cb_rem ;
    private String secretKey = null;
    private String receive = null;
    public void toastText(String message)
      {
        Toast.makeText(this, message, Toast.LENGTH_LONG).show();
      }

      public void handleException(Exception e, String prefix)
      {
        e.printStackTrace();
        toastText(prefix + e.toString());
      }
      
    @Override
      public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mContext = this ;//this為MainActivity
        btn_load = (Button) findViewById(R.id.btn_load);
        cb_rem = (CheckBox) findViewById(R.id.cb_rem);
        et_secretKey = (EditText) findViewById(R.id.et_secretKey); 
        
        //連接服務器
        initClientSocket();
        
        //回顯秘鑰
        String parent_data = getSecreKey(mContext);
        et_secretKey.setText(parent_data);
        cb_rem.setChecked(true);
        
        
        btn_load.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                login();
                
            }
        });    
    }
    //登錄
    private void login ()  {
        
        //得到秘鑰
         secretKey = et_secretKey.getText().toString();
        //發送秘鑰
        sendSecretKey(secretKey);
        Boolean isrem = cb_rem.isChecked();//默認記住秘鑰
        if(TextUtils.isEmpty(secretKey)) {
            Toast.makeText(mContext, "秘鑰不能為空！", Toast.LENGTH_SHORT).show();
            return;
        }
        
        //判斷是否記住秘鑰，如果記住將秘鑰保存到本地
        if(isrem) {
            Boolean result = saveSecreKey(mContext,secretKey);
            if(result){
            Toast.makeText(mContext, "秘鑰保存成功！", Toast.LENGTH_SHORT).show();
            }
            else {
                Toast.makeText(mContext, "秘鑰保存失敗！", Toast.LENGTH_SHORT).show();
            }
        }else {
            //Toast.makeText(mContext, "無需保存！", Toast.LENGTH_SHORT).show();
        }
        
        
    }
    
    //保存秘鑰到本地
    private Boolean saveSecreKey(Context context, String secretKey) {
        try {
            SharedPreferences sharedPreferences = context.getSharedPreferences("secretKeyInfo.txt", context.MODE_PRIVATE);
            // 2.通過SharedPreference對象得到一個Editor對象
            Editor editor = sharedPreferences.edit();
            editor.putString("secretKey", secretKey);
            editor.commit();
            return true;
            }catch(Exception e) {
                e.printStackTrace();
        }
        return false ;
    }
    
    private String getSecreKey(Context context) {
        SharedPreferences sharedPreferences = context.getSharedPreferences("secretKeyInfo.txt", context.MODE_PRIVATE);
        // 2.通過SharedPreference對象獲取存放的數據
        String data = sharedPreferences.getString("secretKey", "");
        return data ;
    }
    
    //處理線程通信
    Handler handler = new Handler(){
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case 1:
            IsAndOs stream = (IsAndOs)msg.obj;
            output = stream.getOs();
            In = stream.getIs();
            //等輸入流的線程處理完之后再開這個線程
            thread = new Thread(receivedDataThread);
            thread.start();// 啟動接收線程
            
                break;
            case 2:
                receive= (String)msg.obj;
                if(!(receive ==null)) {
                    Toast.makeText(mContext, "連接成功！", Toast.LENGTH_SHORT).show();
                    Intent intent = new Intent(MainActivity.this,MainPageActivity.class);
                    startActivity(intent);
                }
                break;
            default:
                break;
            }
        };
    };
    
    private void initClientSocket()
      {
         //開啟子線程
          new Thread(new Runnable() {
            
            @Override
            public void run() {
                try {
                    socket = new Socket(SERVER_HOST_IP, SERVER_HOST_PORT);
                     /* 獲取輸出,輸入流 */
                      PrintStream op = new PrintStream(socket.getOutputStream(), true, "utf-8");
                      InputStream In =socket.getInputStream();
                      
                      IsAndOs io = new IsAndOs();
                      io.setIs(In);
                      io.setOs(op);
                      //傳到主線程的信息
                      Message msg = handler.obtainMessage();
                      //將輸入輸出流的類發送給主線程
                      msg.obj = io;
                      msg.what = 1;
                      //傳遞消息到主線程
                      handler.sendMessage(msg);
                } catch (UnknownHostException e) {
                      handleException(e, "unknown host exception: " + e.toString());
                } catch (IOException e) {
                    handleException(e, "io exception: " + e.toString());
                }
            }
        }).start();
      }
    
    // 接收線程
        private Runnable receivedDataThread = new Runnable()
        {
            @Override
            public void run()
            {
                
                try{
                        byte buffer[] = new byte[1024];
                        int count = In.read(buffer);
                        String receiveData = new String(buffer, 0, count);
                        Log.i(TAG, "read buffer:"+receiveData+",count="+count);
                        Message msg = handler.obtainMessage();;
                        msg.what = 2;
                        msg.obj = receiveData;
                        handler.sendMessage(msg); 

                    } catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                
            }
        };
        
        //發送秘鑰
        private void sendSecretKey(String msg)
          {
            ((PrintStream) output).print(msg);
          }
        //創建一個類來存放輸入輸出流
        public static class IsAndOs{
            private InputStream is;
            private OutputStream os;

            public void setIs(InputStream is){
                this.is = is;
            }

            public InputStream getIs(){
                return is;
            }

            public void setOs(OutputStream os){
                this.os = os;
            }

            public OutputStream getOs(){
                return os;
            }

        }
}

在這里，將通信網絡連接部分開了一個子線程，並傳消息（輸入輸出流對象）到主線程，同時開啟一個接收數據的線程，一定要重新開一個線程，要不然會報錯，客戶端在接收到數據后，再更新UI進行頁面跳轉。