java - ब्लूओव, लैपटॉप, और ब्लूटूथ के साथ एक एंड्रॉइड टैबलेट



android bluetooth (2)

मैं एक साधारण आवेदन के माध्यम से ब्लूटूथ का उपयोग करने की मूल बातें प्राप्त करने की कोशिश कर रहा हूं। मुझे एक लैपटॉप एप्लिकेशन भी पसंद है, इसलिए मैं केवल ब्लूटूथ कॉमिक्स को डिबग कर सकता हूं नीचे दिए गए कोड मेरा प्रयास है कि लैपटॉप ग्राहक (ब्लूकोव 2.1.0 का प्रयोग करके) और टैबलेट सर्वर (एंड्रॉइड 2.2) के साथ है।

जो मैं समझता हूं, इससे लिखित रूप में काम करना चाहिए, और लैपटॉप टैबलेट और उसकी पेशकश की गई सेवा दोनों को उठा रहा है। हालांकि, लाइन "StreamConnection conn = (StreamConnection) Connector.open(url, Connector.READ_WRITE);" हर बार रिटर्न रिटर्न

कोई भी विचार गलत क्या हो रहा है? यहां कोड से आउटपुट दिया गया है:

ब्लूकोव संस्करण 2.1.0 winsock पर
पता: 68 ए 3 सी 44 ए 5265
नाम: WS1497
उपकरण पूछताछ शुरू कर रहा है ...
डिवाइस की खोज की गई: 2013E061D922
डिवाइस की खोज की: 00242BFE7375
INQUIRY_COMPLETED
डिवाइस जांच पूर्ण।
सेवा की जांच शुरू की गई
से: गैलेक्सी टैब
सेवा खोज पूर्ण - कोड: 1
से: WS1190
सेवा खोज पूरा - कोड: 4
ब्लूटूथ डिवाइस:
1. 2013E061D922 (गैलेक्सी टैब)
2. 00242BFE7375 (डब्ल्यूएस 11 9 0)
btspp: // 2013E061D922: 20; प्रमाणित = गलत; एन्क्रिप्ट = गलत; मास्टर = गलत ---- = नल
धागा "मुख्य" java.lang.NullPointerException में अपवाद
MainClass.main पर (MainClass.java:104)
ब्लूओव स्टैक शटडाउन पूरा हुआ

और यहाँ मैं उपयोग कर रहा हूँ कोड है:

लैपटॉप कोड:

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

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;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;

public class MainClass implements DiscoveryListener {

// object used for waiting
private static Object lock = new Object();

// vector containing the devices discovered
private static Vector<RemoteDevice> vecDevices = new Vector<RemoteDevice>();
private static Vector<String> vecServices = new Vector<String>();

// main method of the application
public static void main(String[] args) throws IOException {

    // create an instance of this class
    MainClass bluetoothDeviceDiscovery = new MainClass();

    // display local device address and name
    LocalDevice localDevice = LocalDevice.getLocalDevice();

    System.out.println("Address: " + localDevice.getBluetoothAddress());
    System.out.println("Name: " + localDevice.getFriendlyName());

    // find devices
    DiscoveryAgent agent = localDevice.getDiscoveryAgent();

    System.out.println("Starting device inquiry...");
    agent.startInquiry(DiscoveryAgent.GIAC, bluetoothDeviceDiscovery);

    try {
        synchronized (lock) {
            lock.wait();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    System.out.println("Device Inquiry Completed. ");
    System.out.println("Service Inquiry Started. ");

    UUID uuids[] = new UUID[1];
    uuids[0] = new UUID("fa87c0d0afac11de8a390800200c9a66", false);

    for (RemoteDevice rd : vecDevices) {
        System.out.println("From: " + rd.getFriendlyName(false));
        agent.searchServices(null, uuids, rd, bluetoothDeviceDiscovery);
        try {
            synchronized (lock) {
                lock.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // print all devices in vecDevices
    int deviceCount = vecDevices.size();

    if (deviceCount <= 0) {
        System.out.println("No Devices Found .");
    } else {
        // print bluetooth device addresses and names in the format [ No.
        // address (name) ]
        System.out.println("Bluetooth Devices: ");
        for (int i = 0; i < deviceCount; i++) {
            RemoteDevice remoteDevice = (RemoteDevice) vecDevices
                    .elementAt(i);
            System.out.println((i + 1) + ". "
                    + remoteDevice.getBluetoothAddress() + " ("
                    + remoteDevice.getFriendlyName(false) + ")");
        }
    }

    // System.out.println("SR: " + sr.toString());
    for (String url : vecServices) {
        try {
            String url = sr
                    .getConnectionURL(
                            ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
            StreamConnection conn = (StreamConnection) Connector.open(url, Connector.READ_WRITE);
            System.out.println(url + " ----=" + conn);
            DataInputStream din = new DataInputStream(
                    conn.openDataInputStream());
            synchronized (lock) {
                try {
                    lock.wait(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            while (din.available() != 0) {
                System.out.print(din.readChar());
            }
            System.out.println();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}// end main

// methods of DiscoveryListener

/**
 * This call back method will be called for each discovered bluetooth
 * devices.
 */
public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
    System.out.println("Device discovered: "
            + btDevice.getBluetoothAddress());
    // add the device to the vector
    if (!vecDevices.contains(btDevice)) {
        vecDevices.addElement(btDevice);
    }
}

// no need to implement this method since services are not being discovered
public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
    for (ServiceRecord sr : servRecord) {
        vecServices.add(sr.getConnectionURL(ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false));
    }
}

// no need to implement this method since services are not being discovered
public void serviceSearchCompleted(int transID, int respCode) {
    System.out.println("Service search completed - code: " + respCode);
    synchronized (lock) {
        lock.notify();
    }
}

/**
 * This callback method will be called when the device discovery is
 * completed.
 */
public void inquiryCompleted(int discType) {
    switch (discType) {
    case DiscoveryListener.INQUIRY_COMPLETED:
        System.out.println("INQUIRY_COMPLETED");
        break;

    case DiscoveryListener.INQUIRY_TERMINATED:
        System.out.println("INQUIRY_TERMINATED");
        break;

    case DiscoveryListener.INQUIRY_ERROR:
        System.out.println("INQUIRY_ERROR");
        break;

    default:
        System.out.println("Unknown Response Code");
        break;
    }
    synchronized (lock) {
        lock.notify();
    }
}// end method
}// end class

एंड्रॉयड:

package com.mira.Bluetooth;

import java.io.IOException;

import java.util.UUID;

import android.app.Activity;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;

import android.os.Bundle;

import android.util.Log;

public class BluetoothAndroidActivity extends Activity implements Runnable {
    BluetoothServerSocket bss;
    Thread t;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        BluetoothAdapter bta = BluetoothAdapter.getDefaultAdapter();

        for (BluetoothDevice btd : bta.getBondedDevices()) {
            Log.i("Bluetooth Device Found",
                  btd.toString() + "; " + btd.getName());
        }

        try {
            bss =
bta.listenUsingRfcommWithServiceRecord("BluetoothChat", UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66"));
            t = new Thread(this);
            t.start();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        boolean bContinue = true;
        while (bContinue) {
            try {
                Thread.sleep(100);
            } catch (Exception e) {

            }

            try {
                System.out.println("Listening for connection");
                BluetoothSocket bs = bss.accept();
                System.out.println("Connection received");
                bs.getOutputStream().write("Hello BlueTooth World".getBytes());
                bs.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                bContinue = false;
            }
        }
    }

    /*
 * (non-Javadoc)
 *
 * @see android.app.Activity#onDestroy()
 */

    @Override
    protected void onStop() {
        try {
            System.out.println("Killing ServerSocket");
            bss.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        super.onStop();
    }
}

यह एक पुराना सवाल है, इसलिए मुझे नहीं पता कि कोई भी अभी भी एक जवाब की तलाश कर रहा है, लेकिन यहां एक है ... :) जिस पंक्ति के बारे में आपने पूछा है वह शून्य लौट रहा है क्योंकि url रिक्त है अपने कोड में से एक के बजाय यह UUID आज़माएं: 0000110100001000800000805f9b34fb


एक लंबे समय के बाद एक अद्यतन के बिट - पता चला, ब्लूटूथ को "0000xxxx0000000800000805f9b34fb" फ़ॉर्म लेने के लिए UUID की आवश्यकता है, जो कि केवल 16 बिट पहचानकर्ताओं का उपयोग न करें बल्कि 128 बिट UUIDs का उपयोग करने के सवाल क्यों नहीं करता है

मुझे नहीं पता है कि ब्लूकोव मेरे लैपटॉप पर इसके साथ काम करता है, लेकिन मेरे लैपटॉप पर मेरे हालिया प्रयोगों को लिनक्स और 'ब्लूज़' से प्रयोग करने से पता चलता है कि उस फॉर्म का काम यूयूआईडी का काम करता है। एंड्रॉइड को अपने दस्तावेज़ों में कुछ प्रकार की नोट के रूप में शामिल करना चाहिए।





bluecove