core/java/android/bluetooth/BluetoothA2dp.java - platform/frameworks/base.git - Git at Google

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.bluetooth;

 import android.annotation.SdkConstant;
 import android.annotation.SdkConstant.SdkConstantType;
 import android.server.BluetoothA2dpService;
 import android.content.Context;
 import android.os.ServiceManager;
 import android.os.RemoteException;
 import android.os.IBinder;
 import android.util.Log;

 import java.util.List;

 /**
  * Public API for controlling the Bluetooth A2DP Profile Service.
  *
  * BluetoothA2dp is a proxy object for controlling the Bluetooth A2DP
  * Service via IPC.
  *
  * Creating a BluetoothA2dp object will initiate a binding with the
  * BluetoothHeadset service. Users of this object should call close() when they
  * are finished, so that this proxy object can unbind from the service.
  *
  * Currently the BluetoothA2dp service runs in the system server and this
  * proxy object will be immediately bound to the service on construction.
  * However this may change in future releases, and error codes such as
  * BluetoothError.ERROR_IPC_NOT_READY will be returned from this API when the
  * proxy object is not yet attached.
  *
  * Currently this class provides methods to connect to A2DP audio sinks.
  *
  * @hide
  */
 public class BluetoothA2dp {
     private static final String TAG = "BluetoothA2dp";
     private static final boolean DBG = false;

     /** int extra for SINK_STATE_CHANGED_ACTION */
     public static final String SINK_STATE =
         "android.bluetooth.a2dp.intent.SINK_STATE";
     /** int extra for SINK_STATE_CHANGED_ACTION */
     public static final String SINK_PREVIOUS_STATE =
         "android.bluetooth.a2dp.intent.SINK_PREVIOUS_STATE";

     /** Indicates the state of an A2DP audio sink has changed.
      *  This intent will always contain SINK_STATE, SINK_PREVIOUS_STATE and
      *  BluetoothIntent.ADDRESS extras.
      */
     @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
     public static final String SINK_STATE_CHANGED_ACTION =
         "android.bluetooth.a2dp.intent.action.SINK_STATE_CHANGED";

     public static final int STATE_DISCONNECTED = 0;
     public static final int STATE_CONNECTING   = 1;
     public static final int STATE_CONNECTED    = 2;
     public static final int STATE_DISCONNECTING = 3;
     /** Playing implies connected */
     public static final int STATE_PLAYING    = 4;

     /** Default priority for a2dp devices that should allow incoming
      * connections */
     public static final int PRIORITY_AUTO = 100;
     /** Default priority for a2dp devices that should not allow incoming
      * connections */
     public static final int PRIORITY_OFF = 0;
     private final IBluetoothA2dp mService;
     private final Context mContext;

     /**
      * Create a BluetoothA2dp proxy object for interacting with the local
      * Bluetooth A2DP service.
      * @param c Context
      */
     public BluetoothA2dp(Context c) {
         mContext = c;
         IBinder b = ServiceManager.getService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE);
         if (b == null) {
             throw new RuntimeException("Bluetooth A2DP service not available!");
         }
         mService = IBluetoothA2dp.Stub.asInterface(b);
     }

     /** Initiate a connection to an A2DP sink.
      *  Listen for SINK_STATE_CHANGED_ACTION to find out when the
      *  connection is completed.
      *  @param address Remote BT address.
      *  @return Result code, negative indicates an immediate error.
      *  @hide
      */
     public int connectSink(String address) {
         if (DBG) log("connectSink(" + address + ")");
         try {
             return mService.connectSink(address);
         } catch (RemoteException e) {
             Log.w(TAG, "", e);
             return BluetoothError.ERROR_IPC;
         }
     }

     /** Initiate disconnect from an A2DP sink.
      *  Listen for SINK_STATE_CHANGED_ACTION to find out when
      *  disconnect is completed.
      *  @param address Remote BT address.
      *  @return Result code, negative indicates an immediate error.
      *  @hide
      */
     public int disconnectSink(String address) {
         if (DBG) log("disconnectSink(" + address + ")");
         try {
             return mService.disconnectSink(address);
         } catch (RemoteException e) {
             Log.w(TAG, "", e);
             return BluetoothError.ERROR_IPC;
         }
     }

     /** Check if a specified A2DP sink is connected.
      *  @param address Remote BT address.
      *  @return True if connected (or playing), false otherwise and on error.
      *  @hide
      */
     public boolean isSinkConnected(String address) {
         if (DBG) log("isSinkConnected(" + address + ")");
         int state = getSinkState(address);
         return state == STATE_CONNECTED || state == STATE_PLAYING;
     }

     /** Check if any A2DP sink is connected.
      * @return a List of connected A2DP sinks, or null on error.
      * @hide
      */
     public List<String> listConnectedSinks() {
         if (DBG) log("listConnectedSinks()");
         try {
             return mService.listConnectedSinks();
         } catch (RemoteException e) {
             Log.w(TAG, "", e);
             return null;
         }
     }

     /** Get the state of an A2DP sink
      *  @param address Remote BT address.
      *  @return State code, or negative on error
      *  @hide
      */
     public int getSinkState(String address) {
         if (DBG) log("getSinkState(" + address + ")");
         try {
             return mService.getSinkState(address);
         } catch (RemoteException e) {
             Log.w(TAG, "", e);
             return BluetoothError.ERROR_IPC;
         }
     }

     /**
      * Set priority of a2dp sink.
      * Priority is a non-negative integer. By default paired sinks will have
      * a priority of PRIORITY_AUTO, and unpaired headset PRIORITY_NONE (0).
      * Sinks with priority greater than zero will accept incoming connections
      * (if no sink is currently connected).
      * Priority for unpaired sink must be PRIORITY_NONE.
      * @param address Paired sink
      * @param priority Integer priority, for example PRIORITY_AUTO or
      *                 PRIORITY_NONE
      * @return Result code, negative indicates an error
      */
     public int setSinkPriority(String address, int priority) {
         if (DBG) log("setSinkPriority(" + address + ", " + priority + ")");
         try {
             return mService.setSinkPriority(address, priority);
         } catch (RemoteException e) {
             Log.w(TAG, "", e);
             return BluetoothError.ERROR_IPC;
         }
     }

     /**
      * Get priority of a2dp sink.
      * @param address Sink
      * @return non-negative priority, or negative error code on error.
      */
     public int getSinkPriority(String address) {
         if (DBG) log("getSinkPriority(" + address + ")");
         try {
             return mService.getSinkPriority(address);
         } catch (RemoteException e) {
             Log.w(TAG, "", e);
             return BluetoothError.ERROR_IPC;
         }
     }

     /**
      * Check class bits for possible A2DP Sink support.
      * This is a simple heuristic that tries to guess if a device with the
      * given class bits might be a A2DP Sink. It is not accurate for all
      * devices. It tries to err on the side of false positives.
      * @return True if this device might be a A2DP sink
      */
     public static boolean doesClassMatchSink(int btClass) {
         if (BluetoothClass.Service.hasService(btClass, BluetoothClass.Service.RENDER)) {
             return true;
         }
         // By the A2DP spec, sinks must indicate the RENDER service.
         // However we found some that do not (Chordette). So lets also
         // match on some other class bits.
         switch (BluetoothClass.Device.getDevice(btClass)) {
         case BluetoothClass.Device.AUDIO_VIDEO_HIFI_AUDIO:
         case BluetoothClass.Device.AUDIO_VIDEO_HEADPHONES:
         case BluetoothClass.Device.AUDIO_VIDEO_LOUDSPEAKER:
         case BluetoothClass.Device.AUDIO_VIDEO_CAR_AUDIO:
             return true;
         default:
             return false;
         }
     }

     /** Helper for converting a state to a string.
      * For debug use only - strings are not internationalized.
      * @hide
      */
     public static String stateToString(int state) {
         switch (state) {
         case STATE_DISCONNECTED:
             return "disconnected";
         case STATE_CONNECTING:
             return "connecting";
         case STATE_CONNECTED:
             return "connected";
         case STATE_DISCONNECTING:
             return "disconnecting";
         case STATE_PLAYING:
             return "playing";
         default:
             return "<unknown state " + state + ">";
         }
     }

     private static void log(String msg) {
         Log.d(TAG, msg);
     }
 }
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.bluetooth;

	import android.annotation.SdkConstant;
	import android.annotation.SdkConstant.SdkConstantType;
	import android.server.BluetoothA2dpService;
	import android.content.Context;
	import android.os.ServiceManager;
	import android.os.RemoteException;
	import android.os.IBinder;
	import android.util.Log;

	import java.util.List;

	/**
	* Public API for controlling the Bluetooth A2DP Profile Service.
	*
	* BluetoothA2dp is a proxy object for controlling the Bluetooth A2DP
	* Service via IPC.
	*
	* Creating a BluetoothA2dp object will initiate a binding with the
	* BluetoothHeadset service. Users of this object should call close() when they
	* are finished, so that this proxy object can unbind from the service.
	*
	* Currently the BluetoothA2dp service runs in the system server and this
	* proxy object will be immediately bound to the service on construction.
	* However this may change in future releases, and error codes such as
	* BluetoothError.ERROR_IPC_NOT_READY will be returned from this API when the
	* proxy object is not yet attached.
	*
	* Currently this class provides methods to connect to A2DP audio sinks.
	*
	* @hide
	*/
	public class BluetoothA2dp {
	private static final String TAG = "BluetoothA2dp";
	private static final boolean DBG = false;

	/** int extra for SINK_STATE_CHANGED_ACTION */
	public static final String SINK_STATE =
	"android.bluetooth.a2dp.intent.SINK_STATE";
	/** int extra for SINK_STATE_CHANGED_ACTION */
	public static final String SINK_PREVIOUS_STATE =
	"android.bluetooth.a2dp.intent.SINK_PREVIOUS_STATE";

	/** Indicates the state of an A2DP audio sink has changed.
	* This intent will always contain SINK_STATE, SINK_PREVIOUS_STATE and
	* BluetoothIntent.ADDRESS extras.
	*/
	@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
	public static final String SINK_STATE_CHANGED_ACTION =
	"android.bluetooth.a2dp.intent.action.SINK_STATE_CHANGED";

	public static final int STATE_DISCONNECTED = 0;
	public static final int STATE_CONNECTING = 1;
	public static final int STATE_CONNECTED = 2;
	public static final int STATE_DISCONNECTING = 3;
	/** Playing implies connected */
	public static final int STATE_PLAYING = 4;

	/** Default priority for a2dp devices that should allow incoming
	* connections */
	public static final int PRIORITY_AUTO = 100;
	/** Default priority for a2dp devices that should not allow incoming
	* connections */
	public static final int PRIORITY_OFF = 0;
	private final IBluetoothA2dp mService;
	private final Context mContext;

	/**
	* Create a BluetoothA2dp proxy object for interacting with the local
	* Bluetooth A2DP service.
	* @param c Context
	*/
	public BluetoothA2dp(Context c) {
	mContext = c;
	IBinder b = ServiceManager.getService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE);
	if (b == null) {
	throw new RuntimeException("Bluetooth A2DP service not available!");
	}
	mService = IBluetoothA2dp.Stub.asInterface(b);
	}

	/** Initiate a connection to an A2DP sink.
	* Listen for SINK_STATE_CHANGED_ACTION to find out when the
	* connection is completed.
	* @param address Remote BT address.
	* @return Result code, negative indicates an immediate error.
	* @hide
	*/
	public int connectSink(String address) {
	if (DBG) log("connectSink(" + address + ")");
	try {
	return mService.connectSink(address);
	} catch (RemoteException e) {
	Log.w(TAG, "", e);
	return BluetoothError.ERROR_IPC;
	}
	}

	/** Initiate disconnect from an A2DP sink.
	* Listen for SINK_STATE_CHANGED_ACTION to find out when
	* disconnect is completed.
	* @param address Remote BT address.
	* @return Result code, negative indicates an immediate error.
	* @hide
	*/
	public int disconnectSink(String address) {
	if (DBG) log("disconnectSink(" + address + ")");
	try {
	return mService.disconnectSink(address);
	} catch (RemoteException e) {
	Log.w(TAG, "", e);
	return BluetoothError.ERROR_IPC;
	}
	}

	/** Check if a specified A2DP sink is connected.
	* @param address Remote BT address.
	* @return True if connected (or playing), false otherwise and on error.
	* @hide
	*/
	public boolean isSinkConnected(String address) {
	if (DBG) log("isSinkConnected(" + address + ")");
	int state = getSinkState(address);
	return state == STATE_CONNECTED \|\| state == STATE_PLAYING;
	}

	/** Check if any A2DP sink is connected.
	* @return a List of connected A2DP sinks, or null on error.
	* @hide
	*/
	public List<String> listConnectedSinks() {
	if (DBG) log("listConnectedSinks()");
	try {
	return mService.listConnectedSinks();
	} catch (RemoteException e) {
	Log.w(TAG, "", e);
	return null;
	}
	}

	/** Get the state of an A2DP sink
	* @param address Remote BT address.
	* @return State code, or negative on error
	* @hide
	*/
	public int getSinkState(String address) {
	if (DBG) log("getSinkState(" + address + ")");
	try {
	return mService.getSinkState(address);
	} catch (RemoteException e) {
	Log.w(TAG, "", e);
	return BluetoothError.ERROR_IPC;
	}
	}

	/**
	* Set priority of a2dp sink.
	* Priority is a non-negative integer. By default paired sinks will have
	* a priority of PRIORITY_AUTO, and unpaired headset PRIORITY_NONE (0).
	* Sinks with priority greater than zero will accept incoming connections
	* (if no sink is currently connected).
	* Priority for unpaired sink must be PRIORITY_NONE.
	* @param address Paired sink
	* @param priority Integer priority, for example PRIORITY_AUTO or
	* PRIORITY_NONE
	* @return Result code, negative indicates an error
	*/
	public int setSinkPriority(String address, int priority) {
	if (DBG) log("setSinkPriority(" + address + ", " + priority + ")");
	try {
	return mService.setSinkPriority(address, priority);
	} catch (RemoteException e) {
	Log.w(TAG, "", e);
	return BluetoothError.ERROR_IPC;
	}
	}

	/**
	* Get priority of a2dp sink.
	* @param address Sink
	* @return non-negative priority, or negative error code on error.
	*/
	public int getSinkPriority(String address) {
	if (DBG) log("getSinkPriority(" + address + ")");
	try {
	return mService.getSinkPriority(address);
	} catch (RemoteException e) {
	Log.w(TAG, "", e);
	return BluetoothError.ERROR_IPC;
	}
	}

	/**
	* Check class bits for possible A2DP Sink support.
	* This is a simple heuristic that tries to guess if a device with the
	* given class bits might be a A2DP Sink. It is not accurate for all
	* devices. It tries to err on the side of false positives.
	* @return True if this device might be a A2DP sink
	*/
	public static boolean doesClassMatchSink(int btClass) {
	if (BluetoothClass.Service.hasService(btClass, BluetoothClass.Service.RENDER)) {
	return true;
	}
	// By the A2DP spec, sinks must indicate the RENDER service.
	// However we found some that do not (Chordette). So lets also
	// match on some other class bits.
	switch (BluetoothClass.Device.getDevice(btClass)) {
	case BluetoothClass.Device.AUDIO_VIDEO_HIFI_AUDIO:
	case BluetoothClass.Device.AUDIO_VIDEO_HEADPHONES:
	case BluetoothClass.Device.AUDIO_VIDEO_LOUDSPEAKER:
	case BluetoothClass.Device.AUDIO_VIDEO_CAR_AUDIO:
	return true;
	default:
	return false;
	}
	}

	/** Helper for converting a state to a string.
	* For debug use only - strings are not internationalized.
	* @hide
	*/
	public static String stateToString(int state) {
	switch (state) {
	case STATE_DISCONNECTED:
	return "disconnected";
	case STATE_CONNECTING:
	return "connecting";
	case STATE_CONNECTED:
	return "connected";
	case STATE_DISCONNECTING:
	return "disconnecting";
	case STATE_PLAYING:
	return "playing";
	default:
	return "<unknown state " + state + ">";
	}
	}

	private static void log(String msg) {
	Log.d(TAG, msg);
	}
	}