BluetoothReflection.java

Go to the documentation of this file.

// -*- mode: java; c-basic-offset: 2; -*-
// Copyright 2009-2011 Google, All Rights reserved
// Copyright 2011-2012 MIT, All rights reserved
// Released under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
 
package com.google.appinventor.components.runtime.util;
 
// Even though the code doesn't need these imports, javadoc does.
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothClass;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Set;
import java.util.UUID;
 
public class BluetoothReflection {
  private static final int BOND_BONDED = 0xC; // from android.bluetooth.BluetoothDevice
 
  private BluetoothReflection() {
  }
 
  // BluetoothAdapter methods
 
  public static Object getBluetoothAdapter() {
    // return BluetoothAdapter.getDefaultAdapter();
    Class bluetoothAdapterClass;
    try {
      bluetoothAdapterClass = Class.forName("android.bluetooth.BluetoothAdapter");
    } catch (ClassNotFoundException e) {
      // Bluetooth is not available on this Android device.
      return null;
    }
    return invokeStaticMethod(getMethod(bluetoothAdapterClass, "getDefaultAdapter"));
  }
 
  public static boolean isBluetoothEnabled(Object bluetoothAdapter) {
    // boolean enabled = bluetoothAdapter.isEnabled();
    return (Boolean) invokeMethod(getMethod(bluetoothAdapter.getClass(), "isEnabled"),
        bluetoothAdapter);
  }
 
  public static Set getBondedDevices(Object bluetoothAdapter) {
    // return bluetoothAdapter.getBondedDevices();
    return (Set) invokeMethod(getMethod(bluetoothAdapter.getClass(), "getBondedDevices"),
        bluetoothAdapter);
  }
 
  public static boolean checkBluetoothAddress(Object bluetoothAdapter, String address) {
    // return bluetoothAdapter.checkBluetoothAddress(address);
    return (Boolean) invokeMethod(
        getMethod(bluetoothAdapter.getClass(), "checkBluetoothAddress", String.class),
        bluetoothAdapter, address);
  }
 
  public static Object getRemoteDevice(Object bluetoothAdapter, String address)
      throws IllegalArgumentException {
    // return bluetoothAdapter.getRemoteDevice(address);
    return invokeMethodThrowsIllegalArgumentException(
        getMethod(bluetoothAdapter.getClass(), "getRemoteDevice", String.class),
        bluetoothAdapter, address);
  }
 
  public static Object listenUsingRfcommWithServiceRecord(Object bluetoothAdapter, String name,
      UUID uuid) throws IOException {
    // return bluetoothAdapter.listenUsingRfcommWithServiceRecord(name, uuid);
    return invokeMethodThrowsIOException(getMethod(bluetoothAdapter.getClass(),
        "listenUsingRfcommWithServiceRecord", String.class, UUID.class),
        bluetoothAdapter, name, uuid);
  }
 
  // Note: The following @link generates a Javadoc warning because we build against a
  // version of the jar that doesn't yet have the method, which was added in API level 10.
  public static Object listenUsingInsecureRfcommWithServiceRecord(
      Object bluetoothAdapter, String name, UUID uuid) throws IOException {
    // return bluetoothAdapter.listenUsingInsecureRfcommWithServiceRecord(name, uuid);
    return invokeMethodThrowsIOException(getMethod(bluetoothAdapter.getClass(),
        "listenUsingInsecureRfcommWithServiceRecord", String.class, UUID.class),
        bluetoothAdapter, name, uuid);
  }
 
  // BluetoothDevice methods
 
  public static String getBluetoothDeviceName(Object bluetoothDevice) {
    // return bluetoothDevice.getName();
    return (String) invokeMethod(getMethod(bluetoothDevice.getClass(), "getName"),
        bluetoothDevice);
  }
 
  public static String getBluetoothDeviceAddress(Object bluetoothDevice) {
    // return bluetoothDevice.getAddress();
    return (String) invokeMethod(getMethod(bluetoothDevice.getClass(), "getAddress"),
        bluetoothDevice);
  }
 
  public static boolean isBonded(Object bluetoothDevice) {
    // return bluetoothDevice.getBondState() == BOND_BONDED;
    int bondState = (Integer) invokeMethod(getMethod(bluetoothDevice.getClass(), "getBondState"),
        bluetoothDevice);
    return bondState == BOND_BONDED;
  }
 
  public static Object getBluetoothClass(Object bluetoothDevice) {
    // return bluetoothDevice.getBluetoothClass();
    return invokeMethod(getMethod(bluetoothDevice.getClass(), "getBluetoothClass"),
        bluetoothDevice);
  }
 
  public static Object createRfcommSocketToServiceRecord(Object bluetoothDevice, UUID uuid)
      throws IOException {
    // return bluetoothDevice.createRfcommSocketToServiceRecord(uuid);
    return invokeMethodThrowsIOException(
        getMethod(bluetoothDevice.getClass(), "createRfcommSocketToServiceRecord", UUID.class),
        bluetoothDevice, uuid);
  }
 
  // Note: The following @link generates a Javadoc warning because we build against a
  // version of the jar that doesn't yet have the method, which was added in API level 10.
  public static Object createInsecureRfcommSocketToServiceRecord(Object bluetoothDevice, UUID uuid)
      throws IOException {
    // return bluetoothDevice.createInsecureRfcommSocketToServiceRecord(uuid);
    return invokeMethodThrowsIOException(
        getMethod(bluetoothDevice.getClass(),
            "createInsecureRfcommSocketToServiceRecord", UUID.class),
        bluetoothDevice, uuid);
  }
 
  // BluetoothClass methods
 
  public static int getDeviceClass(Object bluetoothClass) {
    // return bluetoothClass.getBluetoothClass();
    return (Integer) invokeMethod(getMethod(bluetoothClass.getClass(), "getDeviceClass"),
        bluetoothClass);
  }
 
  // BluetoothSocket methods
 
  public static void connectToBluetoothSocket(Object bluetoothSocket) throws IOException {
    // bluetoothSocket.connect();
    invokeMethodThrowsIOException(getMethod(bluetoothSocket.getClass(), "connect"),
        bluetoothSocket);
  }
 
  public static boolean isBluetoothSocketConnected(Object bluetoothSocket) {
    return (Boolean)invokeMethod(getMethod(bluetoothSocket.getClass(), "isConnected"),
            bluetoothSocket);
  }
 
  public static InputStream getInputStream(Object bluetoothSocket) throws IOException {
    // return bluetoothSocket.getInputStream();
    return (InputStream) invokeMethodThrowsIOException(
        getMethod(bluetoothSocket.getClass(), "getInputStream"),
        bluetoothSocket);
  }
 
  public static OutputStream getOutputStream(Object bluetoothSocket) throws IOException {
    // return bluetoothSocket.getOutputStream();
    return (OutputStream) invokeMethodThrowsIOException(
        getMethod(bluetoothSocket.getClass(), "getOutputStream"),
        bluetoothSocket);
  }
 
  public static void closeBluetoothSocket(Object bluetoothSocket) throws IOException {
    // bluetoothSocket.close();
    invokeMethodThrowsIOException(getMethod(bluetoothSocket.getClass(), "close"),
        bluetoothSocket);
  }
 
  // BluetoothServerSocket methods
 
  public static Object accept(Object bluetoothServerSocket) throws IOException {
    // return bluetoothServerSocket.accept();
    return invokeMethodThrowsIOException(getMethod(bluetoothServerSocket.getClass(), "accept"),
        bluetoothServerSocket);
  }
 
  public static void closeBluetoothServerSocket(Object bluetoothServerSocket) throws IOException {
    // bluetoothServerSocket.close();
    invokeMethodThrowsIOException(getMethod(bluetoothServerSocket.getClass(), "close"),
        bluetoothServerSocket);
  }
 
 
  // Reflection helper methods
 
  private static Method getMethod(Class clazz, String name) {
    try {
      return clazz.getMethod(name, new Class[0]);
    } catch (NoSuchMethodException e) {
      throw new RuntimeException(e);
    }
  }
 
  private static Method getMethod(Class clazz, String name, Class<?>... parameterTypes) {
    try {
      return clazz.getMethod(name, parameterTypes);
    } catch (NoSuchMethodException e) {
      throw new RuntimeException(e);
    }
  }
 
  private static Object invokeStaticMethod(Method method) {
    try {
      return method.invoke(null);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      cause.printStackTrace();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else {
        throw new RuntimeException(cause);
      }
    }
  }
 
  private static Object invokeMethod(Method method, Object thisObject, Object... args) {
    try {
      return method.invoke(thisObject, args);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      cause.printStackTrace();
      if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else {
        throw new RuntimeException(cause);
      }
    }
  }
 
  private static Object invokeMethodThrowsIllegalArgumentException(Method method,
      Object thisObject, Object... args) throws IllegalArgumentException {
    try {
      return method.invoke(thisObject, args);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      cause.printStackTrace();
      if (cause instanceof IllegalArgumentException) {
        throw (IllegalArgumentException) cause;
      } else if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else {
        throw new RuntimeException(e);
      }
    }
  }
 
  private static Object invokeMethodThrowsIOException(Method method, Object thisObject,
      Object... args) throws IOException {
    try {
      return method.invoke(thisObject, args);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      cause.printStackTrace();
      if (cause instanceof IOException) {
        throw (IOException) cause;
      } else if (cause instanceof RuntimeException) {
        throw (RuntimeException) cause;
      } else {
        throw new RuntimeException(e);
      }
    }
  }
}