Posts by peter_budo

import java.io.IOException;
import java.util.Vector;

import javax.bluetooth.*;

public class BlueChewFinder implements DiscoveryListener {
  private BlueChewMIDlet mBlueChewMIDlet;
  
  private Vector mNewServices;
  private Vector mServices;
  
  private boolean mSearching;
  private int mPendingServiceSearches;
  
  private boolean mTrucking;
  
  public BlueChewFinder(BlueChewMIDlet midlet) {
    mBlueChewMIDlet = midlet;
    mNewServices = new Vector();
    mServices = new Vector();
    mSearching = false;
    mPendingServiceSearches = 0;
    mTrucking = true;
  }
  
  public void start() {
    // Start looking for other devices.
    try {
      LocalDevice bt = LocalDevice.getLocalDevice();
      DiscoveryAgent da = bt.getDiscoveryAgent();
      boolean success = da.startInquiry(DiscoveryAgent.GIAC,
          this);
      mSearching = true;
    }
    catch (BluetoothStateException bse) {
      Log.log("start() threw " + bse);
    }
  }
  
  public void stop() {
    // Shut down any running inquiries.
    try {
      mTrucking = false;
      LocalDevice bt = LocalDevice.getLocalDevice();
      DiscoveryAgent da = bt.getDiscoveryAgent();
      da.cancelInquiry(this);
    }
    catch (BluetoothStateException bse) {
      Log.log("stop() threw " + bse);
    }
  }
  
  public String getURL(int i) {
    BlueChewService bcs = (BlueChewService)
        mServices.elementAt(i);
    String url = bcs.getURL();
    return url;
  }

  // DiscoveryListener methods
  
  public void deviceDiscovered(RemoteDevice remoteDevice,
      DeviceClass cod) {
    try {
      // Kick off a service search for that device.
      LocalDevice bt = LocalDevice.getLocalDevice();
      DiscoveryAgent da = bt.getDiscoveryAgent();
      
      UUID[] uuidSet = { BlueChewService.BLUECHEW_UUID };
      
      mPendingServiceSearches++;
      da.searchServices(
          null,
          uuidSet,
          remoteDevice,
          this);
    }
    catch (IOException ioe) {
      Log.log("deviceDiscovered(): " + ioe);
    }
    catch (Throwable t) {
      Log.log("deviceDiscovered(): " + t);
    }
  }
  
  public void inquiryCompleted(int discType) {
    mSearching = false;
  }
  
  public void servicesDiscovered(int transID,
      ServiceRecord[] servRecord) {
    for (int i = 0; i < servRecord.length; i++) {
      try {
        RemoteDevice bt = servRecord[i].getHostDevice();
        String name = bt.getFriendlyName(false);
        String address = bt.getBluetoothAddress();
        String url = servRecord[i].getConnectionURL(
            ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
        BlueChewService bcs = new BlueChewService(
            name, address, url);
        mNewServices.addElement(bcs);
      }
      catch (BluetoothStateException bse) {
        Log.log("servicesDiscovered(): " + bse);
      }
      catch (IOException ioe) {
        Log.log("servicesDiscovered(): " + ioe);
      }
    }
  }
  
  public void serviceSearchCompleted(int transID,
      int respCode) {
    mPendingServiceSearches--;
    
    if (mSearching == false && mPendingServiceSearches == 0) {
      reconcile();

      try { Thread.sleep(1000); }
      catch (InterruptedException ie) {}
      
      if (mTrucking == true)
        start();
    }
  }
  
  // BlueChewFinder methods
  
  public synchronized void reconcile() {
    // Remove items from mServices that are not in mNewServices.
    for (int i = 0; i < mServices.size(); i++) {
      BlueChewService bcs =
          (BlueChewService)mServices.elementAt(i);
      if (contains(mNewServices, bcs) == false) {
        mServices.removeElement(bcs);
        mBlueChewMIDlet.serviceRemoved(bcs, i);
      }
    }
    
    // Add items from mNewServices to mServices.
    for (int i = 0; i < mNewServices.size(); i++) {
      BlueChewService bcs =
          (BlueChewService)mNewServices.elementAt(i);
      if (contains(mServices, bcs) == false) {
        mServices.addElement(bcs);
        mBlueChewMIDlet.serviceAdded(bcs);
      }
    }
    
    mNewServices.removeAllElements();
  }
  
  // Compares for equality, not the same actual object.
  private boolean contains(Vector v, Object o) {
    boolean contained = false;
    
    for (int i = 0; i < v.size(); i++) {
      Object oc = v.elementAt(i);
      if (oc.equals(o))
        contained = true;
    }
    return contained;
  }
}

import java.io.*;
import java.util.*;

import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.MIDlet;

import javax.bluetooth.*;

public class BlueChewMIDlet
    extends MIDlet
    implements CommandListener, Runnable {
  private BlueChewServer mBlueChewServer;
  private BlueChewFinder mBlueChewFinder;
  
  private Form mSendForm;
  private TextField mMessageField;
  private ChoiceGroup mDestinations;
  private Command mSendCommand, mBackCommand, mExitCommand;
  
  public void startApp() {
    createUI();
    setupConnections();
    Display.getDisplay(this).setCurrent(mSendForm);
  }
  
  private void createUI() {
    if (mSendForm != null) return;
    
    mSendCommand = new Command("Send", Command.SCREEN, 0);
    mBackCommand = new Command("Back", Command.BACK, 0);
    mExitCommand = new Command("Exit", Command.EXIT, 0);
    
    mSendForm = new Form("BlueChewMIDlet");
    mMessageField = new TextField("Message:", "Hello, nurse!",
        512, TextField.ANY);
    mDestinations = new ChoiceGroup("Destinations",
        ChoiceGroup.MULTIPLE);
    mSendForm.append(mMessageField);
    mSendForm.append(mDestinations);
    mSendForm.addCommand(mSendCommand);
    mSendForm.addCommand(mExitCommand);
    mSendForm.setCommandListener(this);
  }

  private void setupConnections() {
    mBlueChewServer = new BlueChewServer(this);
    mBlueChewServer.start();

    mBlueChewFinder = new BlueChewFinder(this);
    mBlueChewFinder.start();
  }
  
  public void pauseApp() {}
  
  public void destroyApp(boolean unconditional) {
    mBlueChewServer.stop();
    mBlueChewFinder.stop();
  }
  
  public void commandAction(Command c, Displayable s) {
    if (c.getCommandType() == Command.EXIT) {
      destroyApp(true);
      notifyDestroyed();
    }
    else if (c == mSendCommand) {
      Form waitForm = new Form("Sending...");
      Display.getDisplay(this).setCurrent(waitForm);
      Thread t = new Thread(this);
      t.start();
    }
    else if (c == mBackCommand) {
      Display.getDisplay(this).setCurrent(mSendForm);
    }
  }
  
  // Runnable method
  
  public void run() {
    Vector urls = new Vector();
    
    // Synchronize so reconcile() won't run
    // at the same time.
    synchronized(mBlueChewFinder) {
      int n = mDestinations.size();
      boolean[] flags = new boolean[n];
      mDestinations.getSelectedFlags(flags);
      for (int i = 0; i < n; i++) {
        if (flags[i] == true) {
          String url = mBlueChewFinder.getURL(i);
          urls.addElement(url);
        }
      }
    }
    
    for (int i = 0; i < urls.size(); i++) {
      String url = (String)urls.elementAt(i);
      try { runURL(url); }
      catch (IOException ioe) {
        Log.log("BlueChewMIDlet.run(): " + ioe);
      }
    }
    Display.getDisplay(this).setCurrent(mSendForm);
  }
    
  private void runURL(String url) throws IOException {
    StreamConnection sc = null;
    DataOutputStream dataOut = null;
    
    try {
      sc = (StreamConnection)
          Connector.open(url);
      dataOut = new DataOutputStream(
          sc.openOutputStream());
      LocalDevice bt = LocalDevice.getLocalDevice();
      String from = bt.getFriendlyName() + ":" +
          bt.getBluetoothAddress();
      dataOut.writeUTF(from);
      dataOut.writeUTF(mMessageField.getString());
    }
    finally {
      try { if (dataOut != null) dataOut.close(); }
      catch (IOException ioe) {}
      try { if (sc != null) sc.close(); }
      catch (IOException ioe) {}
    }
  }
  
  // BlueChewServer callback
  
  public void messageReceived(String from, String message) {
    int layout = Item.LAYOUT_NEWLINE_AFTER;
    StringItem si;
    Form messageForm = new Form("Message");
    si = new StringItem("From:", from);
    si.setLayout(layout);
    messageForm.append(si);
    si = new StringItem("Message:", message);
    si.setLayout(layout);
    messageForm.append(si);
    messageForm.addCommand(mBackCommand);
    messageForm.setCommandListener(this);
    Display.getDisplay(this).setCurrent(messageForm);
  }
  
  // BlueChewFinder callbacks
  
  public void serviceAdded(BlueChewService bcs) {
    String s = bcs.getName() + ":" + bcs.getAddress();
    mDestinations.append(s, null);
  }
  
  public void serviceRemoved(BlueChewService bcs, int i) {
    mDestinations.delete(i);
  }
}

import java.io.*;

import javax.microedition.io.*;

import javax.bluetooth.*;

public class BlueChewServer implements Runnable {
  private BlueChewMIDlet mBlueChewMIDlet;
  
  private boolean mTrucking;
  private StreamConnectionNotifier mNotifier;
  
  public BlueChewServer(BlueChewMIDlet midlet) {
    mBlueChewMIDlet = midlet;
  }
  
  public void start() {
    mTrucking = true;
    Thread t = new Thread(this);
    t.start();
  }
  
  public void stop() {
    mTrucking = false;
    try { if (mNotifier != null) mNotifier.close(); }
    catch (IOException ioe) {}
  }    
  
  public void run() {
    // Make sure we're discoverable.
    try {
      LocalDevice bt = LocalDevice.getLocalDevice();
      bt.setDiscoverable(DiscoveryAgent.GIAC);
    }
    catch (BluetoothStateException bse) {
      Log.log("BlueChewServer.run(): " + bse);
    }

    // Start up the server.
    try {
      UUID uuid = BlueChewService.BLUECHEW_UUID;

      String cs = "btspp://localhost:" + uuid.toString()
          + ";name=BlueChew";

      mNotifier =
          (StreamConnectionNotifier)Connector.open(cs);
      
      while (mTrucking) {
        // Get the next incoming connection.
        StreamConnection sc = mNotifier.acceptAndOpen();
        
        // Service inline. We could spawn off a thread for
        // each but it seems unnecessary for this type of
        // application.
        DataInputStream dataIn = new DataInputStream(
            sc.openInputStream());
        String from = dataIn.readUTF();
        String message = dataIn.readUTF();
        mBlueChewMIDlet.messageReceived(from, message);
        dataIn.close();
        sc.close();
      }
    }
    catch (BluetoothStateException bse) {
      Log.log("BlueChewServer.run(): " + bse);
    }
    catch (IOException ioe) {
      if (mTrucking == true)
        Log.log("BlueChewServer.run(): " + ioe);
    }
  }
}

import javax.bluetooth.UUID;

public class BlueChewService {
  public static final UUID BLUECHEW_UUID = 
      new UUID("F0E0D0C0B0A000908070605040302010", false);
  
  private String mName;
  private String mAddress;
  private String mURL;
  
  public BlueChewService(String name, String address,
      String url) {
    mName = name;
    mAddress = address;
    mURL = url;
  }
  
  public String getName() { return mName; }
  public String getAddress() { return mAddress; }
  public String getURL() { return mURL; }
  
  public boolean equals(Object o) {
    if (o == this) return true;
    if (o instanceof BlueChewService == false) return false;
    
    BlueChewService bcs = (BlueChewService)o;
    if (bcs.getName().equals(mName) == false) return false;
    if (bcs.getAddress().equals(mAddress) == false)
      return false;
    if (bcs.getURL().equals(mURL) == false) return false;

    return true;
  }    
  
  public String toString() {
    return "[BlueChewService:" + mName + ":" + mAddress
        + ":" + mURL + "]";
  }
}

import java.util.Vector;

import javax.microedition.lcdui.*;

import javax.bluetooth.*;

public class Log {
  private static Vector sLines;
  
  private static Form sLogForm;
  
  public static void log(String s) {
    if (sLines == null) sLines = new Vector();
    
    // Prepend address information.
    try {
      LocalDevice bt = LocalDevice.getLocalDevice();
      String address = bt.getBluetoothAddress();
      s = address + ": " + s;
    }
    catch (BluetoothStateException bse) {}

    sLines.addElement(s);
    logToForm(s);
    System.out.println(s);
  }
  
  public static Form getLogForm() {
    if (sLogForm != null) return sLogForm;
    
    sLogForm = new Form("Log");
    
    for (int i = 0; i < sLines.size(); i++) {
      String s = (String)sLines.elementAt(i);
      logToForm(s);
    }
    return sLogForm;
  }
  
  protected static void logToForm(String s) {
    if (sLogForm == null) return;
    
    int layout = Item.LAYOUT_2 | Item.LAYOUT_NEWLINE_AFTER;
    StringItem si = new StringItem(null, s);
    si.setLayout(layout);
    //sLogForm.insert(0, si);
    sLogForm.append(si);
  }
}