package com.j2medev.chapter8.bt;

import java.io.*;
import java.util.*;
import javax.bluetooth.*;
import javax.bluetooth.UUID;
import javax.microedition.io.*;

public class BTClient implements DiscoveryListener, Runnable {
    
    public static final String uuidString = "0123456789ABCDEF0123456789ABCDEF";
    public static UUID uuid;
    private LocalDevice localDevice;// 本地設備實例
    String localBTAddress;// 本地藍牙地址
    String localBTName;// 藍牙名稱
    BTClientUI ui;
    DiscoveryAgent discoveryAgent;// 發現代理
    Thread th;
    Thread readWorkTh;
    Thread writeWorkTh;
    StreamConnection conn;
    boolean exitFlag;
    boolean BTReady;//狀態標記
    DataInputStream in;
    DataOutputStream out;
    String sendText = "";
    Hashtable remoteDevices = new Hashtable();// 存儲找到的遠程設備
    String url = null;
    ServiceRecord serviceRecord;
    
    public BTClient(BTClientUI ui) {
        this.ui = ui;
        th = new Thread(this);
        th.start();
    }
    
    public boolean initBT() {
        boolean success = false;
        try {
            uuid = new UUID(uuidString, false);// 我們的UUID
            // 取得本地設備實例
            localDevice = LocalDevice.getLocalDevice();
            // 記錄藍牙地址
            localBTAddress = localDevice.getBluetoothAddress();
            // 記錄藍牙名稱
            localBTName = localDevice.getFriendlyName();
            localDevice.setDiscoverable(DiscoveryAgent.GIAC);
            // 取得藍牙代理
            discoveryAgent = localDevice.getDiscoveryAgent();
            success = true;
        } catch (Exception e) {
            System.err.println("初始化藍牙設備失敗：" + e);
        }
        return success;
    }
    
    public void search() {// 搜索設備，搜索服務
        try {
            // 清除remoteDevices
            remoteDevices.clear();
            // 將緩存的和已知的藍牙設備加入remoteDevices
            RemoteDevice[] cacheDevices = discoveryAgent
                    .retrieveDevices(DiscoveryAgent.CACHED);
            if (cacheDevices != null) {
                for (int i = 0; i < cacheDevices.length; i++) {
                    remoteDevices.put(cacheDevices[i].getBluetoothAddress(),
                            cacheDevices[i]);
                }
            }
            RemoteDevice[] preDevices = discoveryAgent
                    .retrieveDevices(DiscoveryAgent.PREKNOWN);
            if (preDevices != null) {
                for (int i = 0; i < preDevices.length; i++) {
                    remoteDevices.put(cacheDevices[i].getBluetoothAddress(),
                            cacheDevices[i]);
                }
            }
            // 在已知的設備上查詢服務
            searchServices(remoteDevices);
            if (serviceRecord != null)// 找到返回
                return;
            // 開始搜索設備
            discoveryAgent.startInquiry(DiscoveryAgent.GIAC, this);
            // 在搜索到的設備上查詢服務
            // searchServices(remoteDevices);
            // remoteDevices.clear();
        } catch (BluetoothStateException e) {
            e.printStackTrace();
        }
        if (serviceRecord != null) {
            notify();
        } else {
            ui.state.setText("未發現設備或服務");
        }
    }
    
    private void searchServices(Hashtable remotes)
    throws BluetoothStateException {// 搜索服務
        // 創建我們感興趣的UUID數組
        UUID[] UUIDs = new UUID[2];
        UUIDs[1] = new UUID(uuidString, false);// 我們的UUID
        UUIDs[0] = new UUID(0x0003);// 必須支持RFCOMM
        // 取出每一個設備查詢
        for (Enumeration e = remotes.keys(); e.hasMoreElements();) {
            String key = (String) e.nextElement();
            RemoteDevice remoteDevice = (RemoteDevice) remotes.get(key);
            // 查詢
            discoveryAgent.searchServices(null, UUIDs, remoteDevice, this);
        }
    }
    
    public void deviceDiscovered(RemoteDevice device, DeviceClass cod) {
        // 記錄找到的設備
        remoteDevices.put(device.getBluetoothAddress(), device);
    }
    
    public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
        // 發現感興趣的服務，這里直接使用第一個
        if (servRecord == null || servRecord.length == 0) {
            url = null;
            serviceRecord = null;
            return;
        }
        // 取得感興趣的連接URL
        serviceRecord = servRecord[0];
        url = serviceRecord.getConnectionURL(
                ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
    }
    
    public void serviceSearchCompleted(int transID, int respCode) {
        synchronized (this) {
            notifyAll();
        }
    }
    
    public void inquiryCompleted(int discType) {
        try {
            searchServices(remoteDevices);
        } catch (BluetoothStateException e) {
            e.printStackTrace();
        }
        remoteDevices.clear();
    }
    
    public void run() {
        if (!initBT()) {
            ui.state.setText("初始化失敗");
            return;
        }
        try {
            ui.state.setText("開始查找");
            // 等待啟動服務搜索
            synchronized (this) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (exitFlag)
                return;
            search();
            // 等待URL準備好
            synchronized (this) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (exitFlag)
                return;
            conn = (StreamConnection) Connector.open(url);
            in = conn.openDataInputStream();
            out = conn.openDataOutputStream();
            readWorkTh = new ReadWorkThread();
            readWorkTh.start();
            writeWorkTh = new WriteWorkThread();
            writeWorkTh.start();
            ui.state.setText("準備就緒");
            BTReady = true;
        } catch (IOException e) {
            ui.state.setText("初始化失敗");
            return;
        } catch (SecurityException e) {
            ui.state.setText("初始化失敗");
            return;
        }
        th = null;
    }
    
    public void close() {
        try {
            exitFlag = true;
            synchronized (this) {
                notify();
            }
            if (writeWorkTh != null) {
                synchronized (writeWorkTh) {
                    writeWorkTh.notify();
                }
            }
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
            if (conn != null)
                conn.close();
            if (readWorkTh != null) {
                readWorkTh.join();
            }
            if (writeWorkTh != null)
                writeWorkTh.join();
            if (th != null)
                th.join();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    public void send(String str) {
        if (writeWorkTh == null)
            return;
        sendText = str;
        synchronized (writeWorkTh) {
            writeWorkTh.notify();
        }
    }
    
    class ReadWorkThread extends Thread {
        public void run() {
            try {
                while (!exitFlag) {
                    String str = in.readUTF();
                    if (str != null) {
                        ui.receiveTF.setString(str);
                    }
                }
            } catch (IOException e) {
                if (!exitFlag)
                    ui.state.setText("讀取數據失敗");
            }
        }
    }
    
    class WriteWorkThread extends Thread {
        public void run() {
            try {
                while (!exitFlag) {
                    synchronized (this) {
                        try {
                            wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if (exitFlag)// 可能因為關閉操作被打斷
                            break;
                        if (sendText != null)
                            out.writeUTF(sendText);
                    }
                }
            } catch (IOException e) {
                if (!exitFlag)
                    ui.state.setText("寫書據失敗");
            }
        }
    }
    
    public void startSearch() {
        synchronized (this) {
            notifyAll();
        }
    }
}