150. (TWOK/UTIL) [Android/Java] C_TcpIp_Server_Single_Socket_Module : TCP IP 소켓 통신 서버 모듈

---

[설 명]

​

프로그램 : Android / Java

​

설 명 : C_TcpIp_Server_Single_Socket_Module : TCP IP 소켓 통신 서버 모듈

 

---

[소스 코드]

 

package com.example.javaproject.C_Module;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.DhcpInfo;
import android.net.Network;
import android.net.NetworkInfo;
import android.net.wifi.WifiManager;

import com.example.javaproject.C_Util;
import com.example.javaproject.S_FinalData;
import com.example.javaproject.S_Log;

import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class C_TcpIp_Server_Single_Socket_Module {


    /**
     * // --------------------------------------------------------------------------------------
     * TODO [클래스 설명]
     * // --------------------------------------------------------------------------------------
     * 1. [설명] : TCP/IP 통신 서버 모듈 클래스
     * // --------------------------------------------------------------------------------------
     * 2. 참고 : 서버 소켓을 활성화 하기 위해서는 특정 인터넷 사용 가능한 와이파이 또는 로컬 핫스팟에 연결이 필요
     * // --------------------------------------------------------------------------------------
     * 3. 참고 사이트 :
     *
     * [안드로이드 : 스마트 콘피그 (SmartConfig) 와이파이 Wifi 연결 및 소켓 통신 수행]
     *
     * https://blog.naver.com/kkh0977/223132108515?trackingCode=blog_bloghome_searchlist
     *
     *
     * [안드로이드 기기 로컬 핫스팟 WIFI 와이파이 SSID 조회 및 다이렉트 AP 연결 로직]
     *
     * https://blog.naver.com/kkh0977/223646733424?trackingCode=blog_bloghome_searchlist
     *
     *
     * [WifiInfo 및 DhcpInfo 사용해 현재 연결된 와이파이 (wifi) 정보 확인 실시]
     *
     * https://blog.naver.com/kkh0977/222295029304?trackingCode=blog_bloghome_searchlist
     * // --------------------------------------------------------------------------------------
     * */





    /**
     * // --------------------------------------------------------------------------------------
     * TODO [빠른 로직 찾기 : 주석 로직 찾기]
     * // --------------------------------------------------------------------------------------
     * // [SEARCH FAST] : [소켓 서버 활성 수행]
     * // --------------------------------------------------------------------------------------
     * // [SEARCH FAST] : [서버 소켓 생성 실시]
     * // --------------------------------------------------------------------------------------
     * // [SEARCH FAST] : [소켓 연결 종료]
     * // --------------------------------------------------------------------------------------
     * // [SEARCH FAST] : [클라이언트 소켓 리셋 및 재연결 대기]
     * // --------------------------------------------------------------------------------------
     * // [SEARCH FAST] : [hello 메시지 전송] : send_Client_Hello
     * // --------------------------------------------------------------------------------------
     * //
     * // --------------------------------------------------------------------------------------
     * //
     * // --------------------------------------------------------------------------------------
     */






    // ------------------------------------------------------------------------------------------
    // TODO [사용 방법]
    // ------------------------------------------------------------------------------------------
    /*
    try {

        // -------------------------------------------------
        // TODO [1]. 서버 소켓 통신을 하기 위한 PORT 선언
        // -------------------------------------------------
        int port = 18501;


        // --------------------------------------
        // TODO [2]. [서버 소켓 모듈 클래스 인스턴스 초기화]
        // --------------------------------------
        C_TcpIp_Server_Single_Socket_Module c_server_socket_module = C_TcpIp_Server_Single_Socket_Module.getInstance();
        c_server_socket_module.setContext(A_Intro.this);


        // --------------------------------------
        // TODO [3]. [서버 소켓 활성 수행]
        // --------------------------------------
        if(c_server_socket_module.openServer(port) == true) { // [소켓 연결 상태 확인]


            // --------------------------------------
            // TODO [4]. [hello 메시지 전달 수행]
            // --------------------------------------
            boolean result = c_server_socket_module.send_Client_Hello();


            // --------------------------------------
            // TODO [5]. [서버 소켓 연결 종료]
            // --------------------------------------
            c_server_socket_module.closeSocket();

        }
        else {
            S_Log._E_("서버 소켓 활성 실패", null);
        }

    }
    catch (Exception e) {
        S_Log._printStackTrace_(null, S_FinalData.LOG_BUG_STATE, null, e);
    }
    */
    // ------------------------------------------------------------------------------------------





    // ------------------------------------------------------------------------------------------
    // TODO [전역 변수 선언]
    // ------------------------------------------------------------------------------------------

    private String ACTIVITY_NAME = "C_TcpIp_Server_Single_Socket_Module";

    private Context mMainCtx; // [컨텍스트]

    String ip = ""; // [아이피 주소]
    ServerSocket mServer = null; // [서버 소켓]
    Socket mSocket = null; // [클라이언트 소켓]
    Thread mThread = null; // [서버 스레드]

    InputStream receiveInputStream = null;

    BufferedWriter sendWriter = null;

    ArrayList clientList; // [클라이언트 담음]

    public static final String RETURN_SUCCESS_FLAG = "RETURN_SUCCESS_FLAG"; // [리턴 데이터 반환 키 값]
    public static final String RETURN_ERROR_MESSAGE = "RETURN_ERROR_MESSAGE"; // [리턴 데이터 반환 키 값]




    // ------------------------------------------------------------------------------------------
    // TODO [콘텍스트 지정]
    // ------------------------------------------------------------------------------------------
    public void setContext(Context ctx) {
        mMainCtx = ctx;
    }




    // ------------------------------------------------------------------------------------------
    // TODO [인스턴스 생성]
    // ------------------------------------------------------------------------------------------
    public static C_TcpIp_Server_Single_Socket_Module getInstance() { return C_TcpIp_Server_Single_Socket_Module.LazyHolder.INSTANCE; }
    private static class LazyHolder {
        private static final C_TcpIp_Server_Single_Socket_Module INSTANCE = new C_TcpIp_Server_Single_Socket_Module();
    }





    // ------------------------------------------------------------------------------------------
    // TODO [SEARCH FAST] : [소켓 서버 활성 수행]
    // ------------------------------------------------------------------------------------------
    public synchronized boolean openServer(int port) {

        // [상태 체크 변수]
        final boolean[] isConnection = {false};


        // [로직 처리 수행]
        if(mServer != null && mSocket != null && mThread != null) { // TODO [소켓이 널이 아닌 경우]
            S_Log._E_(ACTIVITY_NAME + " :: openServer :: 서버 소켓 오픈 실패", new String[]{ "설 명 :: 소켓 연결 된 상태 (ServerSocket Not Null)" });
        }
        else { // TODO [소켓이 널인 경우]
            S_Log._D_(ACTIVITY_NAME + " :: openServer :: 서버 소켓 오픈 수행", null);

            try {

                // TODO [클라이언트 리스트 초기화]
                clientList = new ArrayList();


                // TODO [서버 소켓 생성]
                mServer = createSocket(port);
                mServer.setSoTimeout(0);


                if (mServer != null){ // TODO [소켓 연결 에러 발생 시 상단에서 Exception 발생]

                    // TODO [리턴 변수 삽입]
                    isConnection[0] = true;

                    mThread = new Thread(new Runnable() {
                        @Override
                        public void run() {
                            try {

                                // TODO [while 클라이언트 접속 상태 체크]
                                while (true) {


                                    // ------------------------------------------------
                                    // TODO [접속 된 클라이언트가 없는 경우]
                                    // ------------------------------------------------
                                    if(clientList.isEmpty() == true) {
                                        S_Log._W_(ACTIVITY_NAME + " :: openServer :: 서버 소켓 :: 클라이언트 접속 대기 중 ..", null);

                                        // TODO [클라이언트 소켓 접속 허용 설정]
                                        mSocket = mServer.accept();


                                        // TODO [접속한 클라이언트 IP 및 메시지 확인]
                                        String clientIp = String.valueOf(mSocket.getInetAddress()).replaceAll("/", "");


                                        // TODO [중복 접속 확인]
                                        int ip_check = 0;
                                        for(int i=0; i<clientList.size(); i++) {
                                            if(clientIp.equals(clientList.get(i))) {
                                                ip_check ++;
                                            }
                                        }
                                        if(ip_check <= 0) {
                                            clientList.add(clientIp);
                                        }


                                        S_Log._W_(ACTIVITY_NAME + " :: openServer :: 서버 소켓 :: 클라이언트 접속 확인", new String[]{
                                                "Client IP :: " + String.valueOf(clientList)
                                        });

                                    }
                                    // ------------------------------------------------



                                    // ------------------------------------------------
                                    // TODO [클라이언트로 전달 받은 메시지 확인]
                                    // ------------------------------------------------
                                    String clientMessage = "";

                                    receiveInputStream = mSocket.getInputStream();

                                    byte[] bytes = new byte[receiveInputStream.available()]; // [전체 배열 크기 선언]

                                    int readByteCount = receiveInputStream.read(bytes);

                                    if (readByteCount > 0) { // TODO [실시간 클라이언트로 부터 수신 받은 데이터가 있을 경우]

                                        byte[] subBuffer = new byte[readByteCount];
                                        System.arraycopy(bytes, 0, subBuffer,0, readByteCount);

                                        clientMessage = new String(subBuffer, "UTF-8");

                                        // [로그 출력]
                                        S_Log._W_(ACTIVITY_NAME + " :: openServer :: [클라이언트 >> 서버] :: 전달 받은 메시지 확인", new String[]{
                                                "Client IP :: " + String.valueOf(clientList),
                                                "Client Message :: " + String.valueOf(clientMessage)
                                        });

                                        // ----------------------------------------------
                                        // TODO [로직 분기 처리] : [클라이언트 소켓 리셋 갱신 : 재접속 대기]
                                        // ----------------------------------------------
                                        if (clientMessage.trim().equals("reset") == true){
                                            clientSocketReset();
                                        }
                                        // ----------------------------------------------


                                        // ----------------------------------------------
                                        // TODO [로직 분기 처리] : [hello 메시지 전송]
                                        // ----------------------------------------------
                                        if (clientMessage.trim().equals("hello") == true){

                                            boolean result = send_Client_Hello();

                                            S_Log._W_("send_Client_Hello :: result", new String[]{String.valueOf(result)});
                                        }
                                        // ----------------------------------------------


                                    }
                                    // ------------------------------------------------



                                    // ------------------------------------------------
                                    // TODO [무한 루프 탈출 로직 작성]

                                    // ------------------------------------------------
                                    if (mServer == null || mThread == null || mSocket == null) {
                                        S_Log._E_(ACTIVITY_NAME + " :: openServer :: 서버 소켓 접속 체크 종료", new String[]{"설 명 :: 소켓 연결 종료 된 상태 (ServerSocket Is Null)"});

                                        // [소켓 연결 종료]
                                        closeSocket();

                                        // [무한 루프 탈출]
                                        break;
                                    }

                                    // ------------------------------------------------

                                }

                            } catch (Exception e) {
                                S_Log._printStackTrace_(null, S_FinalData.LOG_BUG_STATE, null, e);

                                // [Exception 발생 시 소켓 연결 종료]
                                closeSocket();
                            }
                        }
                    });
                    mThread.start(); // [스레드 수행]

                }
                else {
                    S_Log._E_(ACTIVITY_NAME + " :: openServer :: 서버 소켓 오픈 실패", new String[]{ "설 명 :: ServerSocket Is Null" });
                }

            }
            catch (Exception es){
                S_Log._printStackTrace_(null, S_FinalData.LOG_BUG_STATE, null, es);
            }

        }

        // [리턴 반환 수행]
        return isConnection[0];
    }





    // ------------------------------------------------------------------------------------------
    // TODO [SEARCH FAST] : [서버 소켓 생성 실시]
    // ------------------------------------------------------------------------------------------
    private synchronized ServerSocket createSocket(int port) {

        ConnectivityManager connectivity = (ConnectivityManager) mMainCtx.getSystemService(Context.CONNECTIVITY_SERVICE);
        ServerSocket sock = null;

        try{
            if (connectivity != null) {

                for (Network network : connectivity.getAllNetworks()) { // TODO [연결된 네트워크 확인]

                    NetworkInfo networkInfo = connectivity.getNetworkInfo(network);

                    if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_WIFI) { // TODO [와이파이 연결 상태 체크]

                        if (networkInfo.isConnected()) {

                            WifiManager wifimanager = (WifiManager) mMainCtx.getSystemService(Context.WIFI_SERVICE);

                            DhcpInfo dhcpInfo = wifimanager.getDhcpInfo();
                            int wIp = dhcpInfo.ipAddress;

                            ip = String.format("%d.%d.%d.%d", (wIp & 0xff), (wIp >> 8 & 0xff), (wIp >> 16 & 0xff), (wIp >> 24 & 0xff));

                            if (C_Util.stringNotNull(ip) == true){
                                S_Log._W_(ACTIVITY_NAME + " :: createSocket :: 서버 소켓 생성 성공", new String[]{
                                        "IP :: " + String.valueOf(ip),
                                        "PORT :: " + String.valueOf(port)
                                });

                                // [서버 소켓 지정 실시]
                                sock =  new ServerSocket(port);
                            }
                            else {
                                S_Log._E_(ACTIVITY_NAME + " :: createSocket :: 서버 소켓 생성 에러", new String[]{ "ip is null" });
                            }

                        }

                    }
                }
            }
            else {
                S_Log._E_(ACTIVITY_NAME + " :: createSocket :: 서버 소켓 생성 에러", new String[]{ "ConnectivityManager is null" });
            }
        } catch (Exception e) {
            S_Log._E_(ACTIVITY_NAME + " :: createSocket :: 서버 소켓 생성 에러", new String[]{ String.valueOf(e.getMessage()) });
        }
        return sock;
    }





    // ------------------------------------------------------------------------------------------
    // TODO [SEARCH FAST] : [소켓 연결 종료]
    // ------------------------------------------------------------------------------------------
    public synchronized void closeSocket() {

        // [로직 처리 수행]
        try {

            // [클라이언트 리스트 초기화]
            if(clientList != null){
                clientList.clear();
            }

            // [스트림 닫기]
            if (receiveInputStream != null){
                receiveInputStream.close();
            }

            // [스트림 닫기]
            if (sendWriter != null){
                sendWriter.close();
            }

            // [서버 소켓 닫기]
            if (mServer != null){
                mServer.close();
                mServer = null;
            }

            // [클라이언트 소켓 닫기]
            if(mSocket != null) {
                mSocket.close();
                mSocket = null;
            }

            // [스레드 닫기]
            if (mThread != null){
                mThread.interrupt();
            }

        }
        catch (Exception e) {
            S_Log._printStackTrace_(null, S_FinalData.LOG_BUG_STATE, null, e);
        }

        S_Log._E_(ACTIVITY_NAME + " :: closeSocket :: 서버 소켓 연결 종료 수행", null);

    }





    // ------------------------------------------------------------------------------------------
    // TODO [SEARCH FAST] : [클라이언트 소켓 리셋 및 재연결 대기]
    // ------------------------------------------------------------------------------------------
    public synchronized void clientSocketReset() {

        // [로직 처리 수행]
        try {

            // [클라이언트 소켓 및 리스트 초기화]
            if(mSocket != null){

                if (clientList != null){

                    // TODO [접속한 클라이언트 IP 확인]
                    String clientIp = String.valueOf(mSocket.getInetAddress()).replaceAll("/", "");


                    // TODO [클라이언트 리스트 확인]
                    int ip_check = 0;
                    for(int i=0; i<clientList.size(); i++) {
                        if(clientIp.equals(clientList.get(i))) {
                            ip_check ++;
                        }
                    }
                    if(ip_check > 0) {
                        int index = clientList.indexOf(clientIp);
                        clientList.remove(index);

                        mSocket.close(); // [기존 소켓 닫기]

                        S_Log._E_(ACTIVITY_NAME + " :: clientSocketReset :: 클라이언트 소켓 접속 해제 확인", new String[]{
                                "Client IP :: " + String.valueOf(clientIp)
                        });
                    }
                    else {
                        S_Log._E_(ACTIVITY_NAME + " :: clientSocketReset :: Client List Equals Ip False", null);
                    }

                }
                else {
                    S_Log._E_(ACTIVITY_NAME + " :: clientSocketReset :: Client List Is Null", null);
                }

            }
            else {
                S_Log._E_(ACTIVITY_NAME + " :: clientSocketReset :: Client Socket Is Null", null);
            }

        }
        catch (Exception e) {
            S_Log._printStackTrace_(null, S_FinalData.LOG_BUG_STATE, null, e);
        }

    }





    // ------------------------------------------------------------------------------------------
    // TODO [SEARCH FAST] : [hello 메시지 전송] : send_Client_Hello
    // ------------------------------------------------------------------------------------------
    public synchronized boolean send_Client_Hello() {

        /**
         * // ----------------------------------------
         * TODO [JSON] : [Server >> Client]
         * // ----------------------------------------
         *
         * {
         *   "type" : "hello"
         * }
         *
         * // ----------------------------------------
         * */



        // -----------------------------------------------
        // [리턴 변수 선언]
        // -----------------------------------------------
        boolean returnData = false;



        // -----------------------------------------------
        // [로직 처리 수행]
        // -----------------------------------------------
        try {

            if (mSocket != null){

                // -----------------------------------------

                // TODO [JSON 데이터 전송 수행]
                JSONObject reqJson = new JSONObject();
                reqJson.put("type", "hello");

                String requestData = reqJson.toString();

                S_Log._D_(ACTIVITY_NAME + " :: send_Client_Hello :: [서버 >> 클라이언트] >> 메시지 전달 수행 :: onSend", new String[]{
                        "DATA :: " + requestData.toString()
                });

                sendWriter = new BufferedWriter( new OutputStreamWriter( mSocket.getOutputStream(), "UTF-8"));
                sendWriter.write(requestData);
                sendWriter.newLine();
                sendWriter.flush();

                // -----------------------------------------

                // [리턴 데이터 삽입]
                returnData = true;

                // -----------------------------------------

            }
            else {
                S_Log._E_(ACTIVITY_NAME + " :: send_Client_Hello :: [서버 >> 클라이언트] >> 메시지 전달 수행 :: Error", new String[]{ "Client Socket Is Null" });
            }

        }
        catch (Exception e){
            S_Log._printStackTrace_(null, S_FinalData.LOG_BUG_STATE, null, e);
        }


        // [리턴 반환 실시]
        return returnData;
    }


} // TODO [클래스 종료]

---