btutil.java

A bluetooth SMS patcher Java ME application I made quickly after I thought about making one. What i

            throw new BtUtilException("Could not initialize the bluetooth stack. " + e);
        }
    }

    /**
     * Mount a Serial Port Profile service URL for a given service UUID
     * @param uuid The UUID whose service URL should be mounted.
     */
    private String getDefaultSPPUrl(String uuid) {
        return "btspp://localhost:" + uuid + ";authenticate=false;encrypt=false";
    }

    /**
     * Check if the specified service is running.
     */
    private boolean isServiceRunning(String serviceUrl) {

        if (startedStreamServices == null) {
            return false;
        }

        return startedStreamServices.containsKey(serviceUrl);
    }



    /***************************************************************************
     * Bluetooth listener object.
     * Register this listener object to DiscoveryAgent in device discovery
     * and service discovery processes.
     */
    public class Listener implements DiscoveryListener {

        /**
         * A new device was found in the neighborhood.
         *
         * @param RemoteDevice The device just discovered.
         * @param DeviceClass ???
         */
        public void deviceDiscovered(RemoteDevice remoteDevice,
                DeviceClass deviceClass) {

            String deviceFriendlyName = "Unknown";

            try {

                deviceFriendlyName = remoteDevice.getFriendlyName(false);

            } catch (IOException ioe) {

                out.println("[BtUtil API] Error while getting device friendly name. " + ioe);

            }

            out.println("[BtUtil API] Device discovered [" + deviceFriendlyName + "]");

            //Util.printRemoteDevice( remoteDevice, deviceClass );
            remoteDevices.addElement( remoteDevice );

            //Notify listeners (BtUtilClientListener)
            out.println("[BtUtil API] Notifying " + clientListeners.size() + " listeners...");
            for (int i = 0; i < clientListeners.size(); i++) {
                final BtUtilClientListener l = (BtUtilClientListener)clientListeners.elementAt(i);
                final RemoteDevice deviceDiscovered = remoteDevice;
                Thread t = new Thread() {
                    public void run() {
                        l.deviceDiscovered(deviceDiscovered);
                    }
                };
                t.start();
            }
            out.println("[BtUtil API] Listeners notified");
        }

        /**
         * The device inquiry is finished.
         */
        public void inquiryCompleted(int complete) {
            out.println("[BtUtil API] Device discovery is completed. " +
                    getDeviceDiscoveryCompletionMessage(complete) +
                    " " + remoteDevices.size() + " device(s) found.");

            if ( remoteDevices.size() == 0 ) {
                //If no remote device was found

                out.println("[BtUtil API] No bluetooth device found.");

            } else {
                //If at least one remote device was found

                try {

                    //Just for debug purpose.
                    String friendlyName = null;
                    for (int i = 0; i < remoteDevices.size(); i++) {
                        friendlyName = ((RemoteDevice)remoteDevices.elementAt(i)).getFriendlyName(false);
                        out.println("[BtUtil API] Inquiry completed. Device found [" + friendlyName + "]");
                    }

                } catch (Exception e) {
                    out.println("[BtUtil API] Error when finishing the inquiry process. " + e);
                }
            }

            //Notify listeners (BtUtilClientListener)
            out.println("[BtUtil API] Inquiry completed. Notifying " + clientListeners.size() + " listeners...");
            for (int i = 0; i < clientListeners.size(); i++) {
                final BtUtilClientListener l = (BtUtilClientListener)clientListeners.elementAt(i);
                Thread t = new Thread() {
                    public void run() {

                        l.deviceDiscoveryFinished(remoteDevices);
                    }
                };
                t.start();
            }

            out.println("[BtUtil API] Inquiry completed. Listeners notified");

            //Wake up the discoverDevicesSync method.
            synchronized (remoteDevices) {
                deviceDiscoveryFinished = true;
                remoteDevices.notifyAll();
            }
        }

        /**
         * New services where found.
         */
        public void servicesDiscovered(int transId, ServiceRecord[] records) {

            if (records != null) {
                out.println("[BtUtil API] " + records.length + " new service(s) where found in transaction " + transId + ".");
            }

            for ( int i=0; i < records.length;  i ++ ) {
                ServiceRecord record = records[i];
                out.println("[BtUtil API] Service discovered URL: " + record.getConnectionURL(ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false));
                //out.println("[BtUtil API] Service discovered name: " + record.getAttributeValue(0x100));
                remoteServices.addElement( record );
            }
        }

        /**
         * The service discovery process is finished.
         */
        public void serviceSearchCompleted(int transId, int completedCode) {

            synchronized (remoteServices) {
                serviceDiscoveryFinished = true;
                remoteServices.notifyAll();
            }

            String completedMessage = getServiceSearchCompletionMessage(completedCode);

            out.println(
                    "[BtUtil API] Service discovery completed. " + completedMessage + ". " +
                    remoteServices.size() + " services discovered. ");

            //Notify BtUtilListeners
            out.println("[BtUtil API] Notifying " + clientListeners.size() +
                    " BtUtilClientListener listeners...");
            for (int i = 0; i < clientListeners.size(); i++) {
                final BtUtilClientListener l = (BtUtilClientListener)clientListeners.elementAt(i);
                Thread t = new Thread() {
                    public void run() {
                        l.serviceDiscoveryFinished(remoteServices);
                    }
                };
                t.start();

            }
            out.println("[BtUtil API] Listeners notified about service discovery end.");
        }

        /**
         * Translate the device discovery end code into a legible message
         *
         * @param int The code received by inquiryCompleted method.
         * @return String The message behind the received code.
         */
        private String getDeviceDiscoveryCompletionMessage(int completedCode) {
            String completedMessage = null;
            switch (completedCode) {
                case (DiscoveryListener.INQUIRY_COMPLETED) : {
                    completedMessage = "Normal completion of device discovery.";
                    break;
                }

                case (DiscoveryListener.INQUIRY_ERROR) : {
                    completedMessage = "The inquiry request failed to " +
                            "complete normally, but was not cancelled.";
                    break;
                }

                case (DiscoveryListener.INQUIRY_TERMINATED) : {
                    completedMessage = "Teh device discovery has been " +
                            "canceled by the application and did not complete.";
                    break;
                }

                default: {
                    completedMessage = "Unknown reason.";
                }
            }

            return completedMessage;
        }


        /**
         * Translate the service discovery end code into a legible message
         *
         * @param int The code received by serviceSearchCompleted method.
         * @return String The message behind the received code.
         */
        private String getServiceSearchCompletionMessage(int completedCode) {
            String completedMessage = null;
            switch (completedCode) {

                case (DiscoveryListener.SERVICE_SEARCH_COMPLETED) : {
                    completedMessage = "Service search completed normally";
                    break;
                }

                case (DiscoveryListener.SERVICE_SEARCH_DEVICE_NOT_REACHABLE) : {
                    completedMessage =
                            "The device specified in the search " +
                            "request could not be reached or the local device " +
                            "could not establish a connection to the remote device";
                    break;
                }

                case (DiscoveryListener.SERVICE_SEARCH_ERROR) : {
                    completedMessage =
                            "An error occurred while processing the request";
                    break;
                }

                case (DiscoveryListener.SERVICE_SEARCH_NO_RECORDS) : {
                    completedMessage =
                            "No records were found during the service search";
                    break;
                }

                case (DiscoveryListener.SERVICE_SEARCH_TERMINATED) : {
                    completedMessage =
                            "The service search request was cancelled by a " +
                            "call to DiscoveryAgent.cancelServiceSearch()";
                    break;
                }

                default : {
                    completedMessage = "Unkown reason.";
                }

            }

            return completedMessage;
        }

    } // Listener


    /**
     * Represents a service started from startStreamService
     */
    private class StartedStreamService {

        /** Handle to stop later ther service. */
        private StreamConnectionNotifier notifier;

        /**
         * Objects interested in receveing bluetooth server notifications.
         * Notifications types: connection established.
         */
        private Vector listeners = new Vector();


        public Vector getListeners() {
            return listeners;
        }

        public StreamConnectionNotifier getNotifier() {
            return notifier;
        }

        public void setNotifier(StreamConnectionNotifier notifier) {
            this.notifier = notifier;
        }

        public void setListeners(Vector listeners) {
            this.listeners = listeners;
        }

        public void addListener(BtUtilServerListener listener) {
            if (listeners == null) {
                listeners = new Vector();
            }

            listeners.addElement(listener);
        }
    }
}