TASK: Bluetooth transfers

[Jeff-Stammler]

Can we transmit the data .csv files over bluetooth to a PC?

If so,
Do we need bluetooth pairing in Settings page, or Submit page?
Can we pair bluetooth without advertising? (can we specify a MAC address?)
Can the PC connect to multiple devices at one and accept multiple transfers?

Research Links:

• https://www.bing.com/videos/riverview/relatedvideo?q=bluetooth+example+in+java&mid=F8C17D0D0274FB29EE85F8C17D0D0274FB29EE85&FORM=VIRE
• https://www.bing.com/search?pglt=169&q=bluetooth+example+in+java&cvid=43ec82c273c8477c9caed0a52b92f0c9&gs_lcrp=EgZjaHJvbWUyBggAEEUYOTIGCAEQABhAMgYIAhAAGEAyBggDEAAYQDIGCAQQABhAMgYIBRAAGEAyBggGEAAYQDIGCAcQABhAMgYICBAAGEDSAQg1OTI3ajBqMagCALACAA&FORM=ANNTA1&PC=U531
• https://developer.android.com/develop/connectivity/bluetooth#ManagingAConnection
• https://developer.android.com/develop/connectivity/bluetooth/transfer-data
• https://developer.android.com/develop/connectivity/bluetooth#ConnectingDevices
• https://stackoverflow.com/questions/11502497/android-bluetooth-file-sending
• https://www.bing.com/search?pglt=169&q=how+to+send+a+file+over+bluetooth+in+java+for+android&cvid=f86fc2422c83487eba9cad726cb73f33&gs_lcrp=EgZjaHJvbWUyBggAEEUYOdIBCTEwMDU1ajBqMagCALACAA&FORM=ANSPA1&PC=U531
• https://stackoverflow.com/questions/46841534/pair-a-bluetooth-device-in-android-studio
• https://examples.javacodegeeks.com/android/android-bluetooth-connection-example/#google_vignette

[Jeff-Stammler]

From AI (needing BlueCove on windows since Java SE doesn't support BT)

import javax.bluetooth.;
import javax.microedition.io.;
import java.io.*;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**

• Multi-device Bluetooth file receiver using BlueCove.

• Works on Windows, Linux, macOS (with proper Bluetooth stack support).
  */
  public class MultiBluetoothReceiver {

  private static final String SERVICE_NAME = "BTMultiReceiver";
  private static final String SERVICE_UUID = new UUID("1101", true).toString(); // SPP UUID
  private final ExecutorService threadPool = Executors.newCachedThreadPool();

  public static void main(String[] args) {
  new MultiBluetoothReceiver().startServer();
  }

  public void startServer() {
  try {
  // Create a Bluetooth server URL
  String connectionURL = "btspp://localhost:" + SERVICE_UUID + ";name=" + SERVICE_NAME;

       // Open server connection
       StreamConnectionNotifier notifier = (StreamConnectionNotifier) Connector.open(connectionURL);
       System.out.println("Bluetooth server started. Waiting for connections...");
  
       while (true) {
           // Accept incoming connection
           StreamConnection connection = notifier.acceptAndOpen();
           System.out.println("Device connected.");
  
           // Handle each device in its own thread
           threadPool.execute(() -> handleClient(connection));
       }
   } catch (IOException e) {
       System.err.println("Server error: " + e.getMessage());
       e.printStackTrace();
   }
  

  }

  private void handleClient(StreamConnection connection) {
  try (InputStream in = connection.openInputStream()) {
  File saveDir = new File("BT_Received");
  if (!saveDir.exists()) saveDir.mkdirs();

       File receivedFile = new File(saveDir, "file_" + System.currentTimeMillis() + ".bin");
       try (FileOutputStream fos = new FileOutputStream(receivedFile)) {
           byte[] buffer = new byte[4096];
           int bytesRead;
           while ((bytesRead = in.read(buffer)) != -1) {
               fos.write(buffer, 0, bytesRead);
           }
           System.out.println("File saved: " + receivedFile.getAbsolutePath());
       }
   } catch (IOException e) {
       System.err.println("Error receiving file: " + e.getMessage());
   } finally {
       try {
           connection.close();
       } catch (IOException ignored) {}
   }
  

  }
  }
  How It Works
  BlueCove Setup

Add BlueCove JAR to your project:
BlueCove Download
Or via Maven:
Xml

Copy code

net.sf.bluecove
bluecove
2.1.1

On Linux, you may need bluecove-gpl for native support.
Multiple Connections

ExecutorService handles each device in its own thread.
acceptAndOpen() blocks until a device connects.
File Storage

Files are saved in a BT_Received folder in the working directory.
Each file gets a timestamp-based name to avoid overwriting.
UUID

"1101" is the standard Serial Port Profile (SPP) UUID.
Must match the sender’s UUID.
Security

This example accepts any incoming connection without authentication.
For production, you should implement pairing and authentication.

[Jeff-Stammler]

And the sender code (android):

package com.example.bluetoothsender;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Environment;
import android.util.Log;

import java.io.File;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.util.Set;
import java.util.UUID;

public class BluetoothFileSender {

private static final String TAG = "BTFileSender";
private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); // SPP UUID
private final BluetoothAdapter bluetoothAdapter;

public BluetoothFileSender() {
    bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
}

/**
 * Sends a file to a paired device by name.
 */
public void sendFileToDevice(String deviceName, String filePath) {
    if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()) {
        Log.e(TAG, "Bluetooth not available or not enabled.");
        return;
    }

    BluetoothDevice targetDevice = findPairedDeviceByName(deviceName);
    if (targetDevice == null) {
        Log.e(TAG, "Device not found: " + deviceName);
        return;
    }

    new Thread(() -> {
        try (BluetoothSocket socket = targetDevice.createRfcommSocketToServiceRecord(MY_UUID)) {
            bluetoothAdapter.cancelDiscovery(); // Stop discovery to speed up connection
            socket.connect();
            Log.i(TAG, "Connected to " + targetDevice.getName());

            sendFile(socket, filePath);

        } catch (Exception e) {
            Log.e(TAG, "Error connecting or sending file: " + e.getMessage(), e);
        }
    }).start();
}

/**
 * Finds a paired device by name.
 */
private BluetoothDevice findPairedDeviceByName(String name) {
    Set<BluetoothDevice> pairedDevices = bluetoothAdapter.getBondedDevices();
    for (BluetoothDevice device : pairedDevices) {
        if (device.getName().equalsIgnoreCase(name)) {
            return device;
        }
    }
    return null;
}

/**
 * Sends the file over the connected socket.
 */
private void sendFile(BluetoothSocket socket, String filePath) {
    File file = new File(filePath);
    if (!file.exists()) {
        Log.e(TAG, "File not found: " + filePath);
        return;
    }

    try (OutputStream out = socket.getOutputStream();
         FileInputStream fis = new FileInputStream(file)) {

        byte[] buffer = new byte[4096];
        int bytesRead;
        while ((bytesRead = fis.read(buffer)) != -1) {
            out.write(buffer, 0, bytesRead);
        }
        out.flush();
        Log.i(TAG, "File sent successfully: " + file.getName());

    } catch (Exception e) {
        Log.e(TAG, "Error sending file: " + e.getMessage(), e);
    }
}

}
Usage in an Activity
Java

Copy code
BluetoothFileSender sender = new BluetoothFileSender();
String filePath = Environment.getExternalStorageDirectory() + "/testfile.txt";
sender.sendFileToDevice("ReceiverDeviceName", filePath);
Permissions (AndroidManifest.xml)
Xml

Copy code





Runtime Permissions
On Android 6+ you must request:

BLUETOOTH_CONNECT
BLUETOOTH_SCAN
READ_EXTERNAL_STORAGE
Example:

Java

Copy code
ActivityCompat.requestPermissions(this,
new String[]{
Manifest.permission.BLUETOOTH_CONNECT,
Manifest.permission.BLUETOOTH_SCAN,
Manifest.permission.READ_EXTERNAL_STORAGE
}, 1);
How It Works
Paired Device Search: Finds the receiver by name from bonded devices.
SPP Connection: Uses the same UUID as the receiver (1101).
File Transfer: Streams file bytes over RFCOMM.
Threading: Runs in a background thread to avoid blocking the UI.