手机J2ME蓝牙编程

我做的蓝牙类,有接口,可以响应接收事件,直接用,方便很


server类


import java.io.*;

import java.util.Vector;

import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;
import javax.microedition.io.StreamConnectionNotifier;

import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;

import javax.microedition.lcdui.TextBox;
import javax.microedition.lcdui.TextField;

public class Server implements Runnable{
public interface Serverinterface{
   void SOnReceive(String Message);
}
   StreamConnection conn1 = null;
LocalDevice local = null;
ClientProcessor processor;
DataOutputStream dos;
boolean isClosed = false;
boolean isOut = false;
StreamConnectionNotifier notifier;
String messagex = null,messagey=null;
String connectionURL =
      "btspp://localhost:F0E0D0C0B0A000908070605040302010;"
      + "authenticate=false;encrypt=false;name=RFCOMM Server";
Vector queue = new Vector();


Serverinterface si;
public Server(Serverinterface si) {
  
   this.si=si;
   Thread t = new Thread(this);
     t.start() ;

}


public void run()
{

     try {
         local = LocalDevice.getLocalDevice();
         local.setDiscoverable(DiscoveryAgent.GIAC);
         } catch (Exception e) {}

      try {
          notifier = (StreamConnectionNotifier)Connector.open(connectionURL);
          System.out.println("server is opening") ;
          } catch (IOException e1) {}

              processor = new ClientProcessor();
             while (!isClosed) {
                 StreamConnection conn = null;
                 try {
                     conn = notifier.acceptAndOpen();
                 } catch (IOException e) {
                     continue;
                 }
                 processor.addConnection(conn);
             }

}//end run


public void sendMessage(String message1,String message2)
{
    messagex = message1;
    messagey = message2;
    try {
            dos.writeUTF(messagex);
            System.out.println("afsfas");
            dos.writeUTF(messagey) ;
            dos.flush();
            dos.close();
        } catch (IOException e) {
        }
}

     private class ClientProcessor implements Runnable {
           private Thread processorThread;

           private Vector queue = new Vector();

           private boolean isOk = true;

           ClientProcessor() {
               processorThread = new Thread(this);
               processorThread.start();
           }

           public void run() {
               while (!isClosed) {

                   synchronized (this) {
                       if (queue.size() == 0) {
                           try {
                               wait();
                           } catch (InterruptedException e) {

                           }
                       }
                   }

                   //处理连接队列

                   StreamConnection conn;

                   synchronized (this) {

                       if (isClosed) {
                           return;
                       }
                       conn = (StreamConnection) queue.firstElement();
                       queue.removeElementAt(0);
                       processConnection(conn);
                   }
               }
           }


           void addConnection(StreamConnection conn) {
             synchronized (this) {
                   queue.addElement(conn);
                   notify();
               }
           }

}
private void readInputString(StreamConnection conn) {
       String message1,message2 = null;

       try {
           DataInputStream dis = conn.openDataInputStream();
           message1 = dis.readUTF();
           message2 = dis.readUTF() ;
           dis.close();
           si.SOnReceive(message1);
       } catch (Exception e) {
           e.printStackTrace();
           System.out.println("yi chang") ;
       }
   }


   private void processConnection(StreamConnection conn) {
    try{
     dos = conn.openDataOutputStream();
     }
    catch(Exception e){}
     readInputString(conn);
}

}

client类


import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import java.util.Vector;

import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Gauge;
import javax.microedition.lcdui.StringItem;
import javax.microedition.lcdui.TextField;


import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;

public class Client implements Runnable,DiscoveryListener{
public interface Clientinterface{
   void COnReceive(String Message);
}
private DiscoveryAgent discoveryAgent;
   private static final UUID ECHO_SERVER_UUID = new UUID(
           "F0E0D0C0B0A000908070605040302010", false);


   Vector devices = new Vector();
   Vector records = new Vector();
    String messagex,messagey;
    String message_1,message_2;
    StreamConnection   conn ;
    int i=1;
   int[] transIDs;
   Clientinterface ci;

public Client(Clientinterface ci)
{
   this.ci=ci;
   Thread t = new Thread(this);
     t.start() ;
}

public void sendMessage(String message1,String message2)
{
    message_1 = message1;
    message_2 = message2;
    Thread fetchThread=new Thread(){
      public void run(){
      try {
      ServiceRecord sr=(ServiceRecord)records.elementAt(0);
      String url = sr.getConnectionURL( ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);

      conn = (StreamConnection) Connector.open(url);
      DataOutputStream dos=conn.openDataOutputStream();
      dos.writeUTF(message_1);
      dos.writeUTF(message_2);
      dos.flush() ;
      dos.close();

       DataInputStream dis = conn.openDataInputStream();
       messagex = dis.readUTF();
       messagey = dis.readUTF();
       dis.close();
       System.out.println(i) ;
       i++;
       ci.COnReceive(messagex);
    }
    catch(Exception e)
    {
      System.out.println("yi chang1");
      e.printStackTrace() ;
    }
    }
   };
    fetchThread.start();

}


public synchronized void run()
{

    try {
           LocalDevice local = LocalDevice.getLocalDevice();
           discoveryAgent = local.getDiscoveryAgent() ;
        }catch (BluetoothStateException bse) {System.out.println("asssaaa1");}

          try {
                  discoveryAgent.startInquiry(DiscoveryAgent.GIAC,this);
               }catch (BluetoothStateException bse) {System.out.println("asssaaa1");}

              try{wait();}
              catch(Exception e){System.out.println("asssaaa1");}


                      UUID[] uuids = new UUID[1];
                        uuids[0] = ECHO_SERVER_UUID;
                        transIDs = new int[devices.size()];
        for (int i = 0; i < devices.size(); i++) {
               RemoteDevice rd = (RemoteDevice) devices.elementAt(i);
             try {
                System.out.println("begin searchservices") ;
                transIDs[i] = discoveryAgent.searchServices(null, uuids,
                        rd, this);
                System.out.println("000000000");
             } catch (BluetoothStateException e) {
            System.out.println("asssaaa1");
                continue;
            }
             System.out.println("111111111111");
        }
      try {
          wait();
      } catch (InterruptedException e1) {
       System.out.println("asssaaa2");
          e1.printStackTrace();
      }
      System.out.println("Client run end") ;

}

public void deviceDiscovered(RemoteDevice remoteDevice,DeviceClass deviceClass) {
         devices.addElement(remoteDevice);
         System.out.println("discovered a device ") ;
          System.out.println(remoteDevice.getBluetoothAddress()) ;
}

public void inquiryCompleted(int param) {
   System.out.println("start inquiry completed") ;
   switch (param) {
              case DiscoveryListener.INQUIRY_COMPLETED:
              break;
              case DiscoveryListener.INQUIRY_ERROR:
              break;
              case DiscoveryListener.INQUIRY_TERMINATED:
              break;
         }
         System.out.println("complete inquary ") ;
         synchronized (this) {
          notify();
      }

}

public void serviceSearchCompleted(int transID, int respCode) {
       System.out.println("complete service Search") ;
        switch(respCode)
         {
           case DiscoveryListener.SERVICE_SEARCH_COMPLETED:
                   break;
           case DiscoveryListener.SERVICE_SEARCH_DEVICE_NOT_REACHABLE:
                   break;
           case DiscoveryListener.SERVICE_SEARCH_ERROR:
                   break;
           case DiscoveryListener.SERVICE_SEARCH_NO_RECORDS:
                   break;
           case DiscoveryListener.SERVICE_SEARCH_TERMINATED:
                   break;
         }
         synchronized (this) {
       notify();
   }

}

public void servicesDiscovered(int transID,ServiceRecord[] serviceRecord) {
       System.out.println("get server") ;
       for (int i = 0; i < serviceRecord.length; i++) {
         records.addElement(serviceRecord[i]);
     }

}

}

使用两个类的例子


import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
public class main extends MIDlet implements CommandListener,Server.Serverinterface,Client.Clientinterface{

private Client btc;
private Server bts;
private Command cmd1,cmd2,cmd3,cmd4;
Form frm;
Display dis;
public main() {
   // TODO 自动生成构造函数存根
   cmd1=new Command("客户端",Command.OK,1);
   cmd2=new Command("服务端",Command.OK,2);
   cmd3=new Command("客户端sdf",Command.OK,1);
   cmd4=new Command("服务端sdf",Command.OK,1);
   dis=Display.getDisplay(this);
   frm=new Form("");
   frm.addCommand(cmd1);
   frm.addCommand(cmd2);
   frm.setCommandListener(this);
   dis.setCurrent(frm);
  
}

public void SOnReceive(String Message) {
   // TODO 自动生成方法存根
   System.out.println("fdsafdkjfldsjflsdklfdlsjflkasd   "+Message);
}

public void COnReceive(String Message) {
   // TODO 自动生成方法存根
   System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa   "+Message);
}

public void commandAction(Command arg0, Displayable arg1) {
   // TODO 自动生成方法存根
   if(arg0==cmd1){
    btc=new Client(this);
    try{
     Thread.sleep(1000);
    }
    catch(Exception ex){
    
    }
    frm.addCommand(cmd3);
    frm.removeCommand(cmd1);
    frm.removeCommand(cmd2);
   
   }
   if(arg0==cmd2){
    bts=new Server(this);
    frm.addCommand(cmd4);
    frm.removeCommand(cmd2);
    frm.removeCommand(cmd1);
   }
   if(arg0==cmd3){
    btc.sendMessage("client","ffffffa");
   }
   if(arg0==cmd4){
    bts.sendMessage("server","ffffffa");
   }
}

protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
   // TODO 自动生成方法存根

}

protected void pauseApp() {
   // TODO 自动生成方法存根

}
protected void startApp() throws MIDletStateChangeException {
   // TODO 自动生成方法存根
   
}

}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值