Android Bluetooth : get Device Specific AT command

2020-06-20 23:44发布

站内问答 / Android
2013 2 6

I am using "android.bluetooth.headset.action.VENDOR_SPECIFIC_HEADSET_EVENT" intent to get device specific AT commands. But the broadcastreciever didn't fire when I send AT command from MY Bluetooth Kit.

When I send AT+CHUP\r from my kit the android work on this command internally and disconnects the call. But when I send AT+XEVENT=foo,3\r from kit but I am not getting any thing in receiver.

Help me out

2条回答
淡お忘
2楼-- · 2020-06-21 00:31

have you use this ?

public final class BluetoothHeadset implements BluetoothProfile {
private static final String TAG = "BluetoothHeadset";
private static final boolean DBG = true;
private static final boolean VDBG = false;
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_CONNECTION_STATE_CHANGED =
    "android.bluetooth.headset.profile.action.CONNECTION_STATE_CHANGED";@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_AUDIO_STATE_CHANGED =
    "android.bluetooth.headset.profile.action.AUDIO_STATE_CHANGED";
/**
 * Intent used to broadcast that the headset has posted a
 * vendor-specific event.
 * <p>This intent will have 4 extras and 1 category.
 * <ul>
 *  <li> {@link BluetoothDevice#EXTRA_DEVICE} - The remote Bluetooth Device
 *       </li>
 *  <li> {@link #EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD} - The vendor
 *       specific command </li>
 *  <li> {@link #EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD_TYPE} - The AT
 *       command type which can be one of  {@link #AT_CMD_TYPE_READ},
 *       {@link #AT_CMD_TYPE_TEST}, or {@link #AT_CMD_TYPE_SET},
 *       {@link #AT_CMD_TYPE_BASIC},{@link #AT_CMD_TYPE_ACTION}. </li>
 *  <li> {@link #EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_ARGS} - Command
 *       arguments. </li>
 * </ul>
 *
 *<p> The category is the Company ID of the vendor defining the
 * vendor-specific command. {@link BluetoothAssignedNumbers}
 * For example, for Plantronics specific events
 * Category will be {@link #VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY}.55
 * <p> For example, an AT+XEVENT=foo,3 will get translated into
 * <ul>
 *   <li> EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD = +XEVENT </li>
 *   <li> EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD_TYPE = AT_CMD_TYPE_SET </li>
 *   <li> EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_ARGS = foo, 3 </li>
 * </ul>
 * <p>Requires {@link android.Manifest.permission#BLUETOOTH} permission
 * to receive.*/
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String ACTION_VENDOR_SPECIFIC_HEADSET_EVENT =
        "android.bluetooth.headset.action.VENDOR_SPECIFIC_HEADSET_EVENT";
public static final String EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD =            "android.bluetooth.headset.extra.VENDOR_SPECIFIC_HEADSET_EVENT_CMD";
public static final String EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD_TYPE =
        "android.bluetooth.headset.extra.VENDOR_SPECIFIC_HEADSET_EVENT_CMD_TYPE";   public static final int AT_CMD_TYPE_READ = 0;
public static final int AT_CMD_TYPE_TEST = 1;
public static final int AT_CMD_TYPE_SET = 2;
public static final int AT_CMD_TYPE_BASIC = 3;
public static final int AT_CMD_TYPE_ACTION = 4;
public static final String EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_ARGS =
        "android.bluetooth.headset.extra.VENDOR_SPECIFIC_HEADSET_EVENT_ARGS";
public static final String VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY  =
        "android.bluetooth.headset.intent.category.companyid";
public static final String VENDOR_RESULT_CODE_COMMAND_ANDROID = "+ANDROID";
public static final int STATE_AUDIO_DISCONNECTED = 10;
public static final int STATE_AUDIO_CONNECTING = 11;
    public static final int STATE_AUDIO_CONNECTED = 12;
private Context mContext;    private ServiceListener mServiceListener;

private IBluetoothHeadset mService;
private BluetoothAdapter mAdapter;

final private IBluetoothStateChangeCallback mBluetoothStateChangeCallback =
        new IBluetoothStateChangeCallback.Stub() {
            public void onBluetoothStateChange(boolean up) {
                if (DBG) Log.d(TAG, "onBluetoothStateChange: up=" + up);
                if (!up) {
                    if (VDBG) Log.d(TAG,"Unbinding service...");
                    synchronized (mConnection) {
                        try {
                            mService = null;
                            mContext.unbindService(mConnection);
                        } catch (Exception re) {
                            Log.e(TAG,"",re);
                        }
                    }
                } else {
                    synchronized (mConnection) {
                        try {
                            if (mService == null) {
                                if (VDBG) Log.d(TAG,"Binding service...");
                                doBind();
                            }
                        } catch (Exception re) {
                            Log.e(TAG,"",re);
                        }
                    }
                }
            }
    };
    BluetoothHeadset(Context context, ServiceListener l) {
    mContext = context;
    mServiceListener = l;
    mAdapter = BluetoothAdapter.getDefaultAdapter();
    IBluetoothManager mgr = mAdapter.getBluetoothManager();
    if (mgr != null) {
        try {
            mgr.registerStateChangeCallback(mBluetoothStateChangeCallback);
        } catch (RemoteException e) {
                       }
    }
    doBind();
}

boolean doBind() {
    Intent intent = new Intent(IBluetoothHeadset.class.getName());
    ComponentName comp = intent.resolveSystemService(mContext.getPackageManager(), 0);
    intent.setComponent(comp);
    if (comp == null || !mContext.bindService(intent, mConnection, 0)) {
        Log.e(TAG, "Could not bind to Bluetooth Headset Service with " + intent);
        return false;        }
    return true;
}
 void close() {
    if (VDBG) log("close()");
    IBluetoothManager mgr = mAdapter.getBluetoothManager();
    if (mgr != null) {
        try {
            mgr.unregisterStateChangeCallback(mBluetoothStateChangeCallback);
        } catch (Exception e) {
            }
    }
    synchronized (mConnection) {
        if (mService != null) {
            try {
                mService = null;
                mContext.unbindService(mConnection);
            } catch (Exception re) {
                Log.e(TAG,"",re);
            }
        }
    }
    mServiceListener = null;
}    
public boolean connect(BluetoothDevice device) {
    if (DBG) log("connect(" + device + ")");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
            return mService.connect(device);
        } catch (RemoteException e) {
            Log.e(TAG, Log.getStackTraceString(new Throwable()));
            return false;
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return false;
}

public boolean disconnect(BluetoothDevice device) {
    if (DBG) log("disconnect(" + device + ")");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
            return mService.disconnect(device);
        } catch (RemoteException e) {
          Log.e(TAG, Log.getStackTraceString(new Throwable()));
          return false;
        }
    }

    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return false;
}
public List<BluetoothDevice> getConnectedDevices() {
    if (VDBG) log("getConnectedDevices()");
    if (mService != null && isEnabled()) {
        try {
            return mService.getConnectedDevices();
        } catch (RemoteException e) {
            Log.e(TAG, Log.getStackTraceString(new Throwable()));
            return new ArrayList<BluetoothDevice>();
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return new ArrayList<BluetoothDevice>();
}

public List<BluetoothDevice> getDevicesMatchingConnectionStates(int[] states) {
    if (VDBG) log("getDevicesMatchingStates()");
    if (mService != null && isEnabled()) {
        try {
            return mService.getDevicesMatchingConnectionStates(states);
        } catch (RemoteException e) {
            Log.e(TAG, Log.getStackTraceString(new Throwable()));
            return new ArrayList<BluetoothDevice>();
        }

    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return new ArrayList<BluetoothDevice>();
}
public int getConnectionState(BluetoothDevice device) {
    if (VDBG) log("getConnectionState(" + device + ")");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
            return mService.getConnectionState(device);
        } catch (RemoteException e) {
            Log.e(TAG, Log.getStackTraceString(new Throwable()));
            return BluetoothProfile.STATE_DISCONNECTED;
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return BluetoothProfile.STATE_DISCONNECTED;
}

public boolean setPriority(BluetoothDevice device, int priority) {
    if (DBG) log("setPriority(" + device + ", " + priority + ")");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        if (priority != BluetoothProfile.PRIORITY_OFF &&
            priority != BluetoothProfile.PRIORITY_ON) {
          return false;
        }
        try {
            return mService.setPriority(device, priority);
        } catch (RemoteException e) {
            Log.e(TAG, Log.getStackTraceString(new Throwable()));
            return false;
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return false;
}
public int getPriority(BluetoothDevice device) {
    if (VDBG) log("getPriority(" + device + ")");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
            return mService.getPriority(device);
        } catch (RemoteException e) {
            Log.e(TAG, Log.getStackTraceString(new Throwable()));
            return PRIORITY_OFF;
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return PRIORITY_OFF;
}

public boolean startVoiceRecognition(BluetoothDevice device) {
    if (DBG) log("startVoiceRecognition()");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
            return mService.startVoiceRecognition(device);
        } catch (RemoteException e) {
            Log.e(TAG,  Log.getStackTraceString(new Throwable()));
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return false;
}

public boolean stopVoiceRecognition(BluetoothDevice device) {
    if (DBG) log("stopVoiceRecognition()");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
            return mService.stopVoiceRecognition(device);
        } catch (RemoteException e) {
            Log.e(TAG,  Log.getStackTraceString(new Throwable()));
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return false;
}

public boolean isAudioConnected(BluetoothDevice device) {
    if (VDBG) log("isAudioConnected()");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
          return mService.isAudioConnected(device);
        } catch (RemoteException e) {
          Log.e(TAG,  Log.getStackTraceString(new Throwable()));
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return false;
}
public int getBatteryUsageHint(BluetoothDevice device) {
    if (VDBG) log("getBatteryUsageHint()");
    if (mService != null && isEnabled() &&
        isValidDevice(device)) {
        try {
            return mService.getBatteryUsageHint(device);
        } catch (RemoteException e) {
            Log.e(TAG,  Log.getStackTraceString(new Throwable()));
        }
    }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return -1;
}
public static boolean isBluetoothVoiceDialingEnabled(Context context) {
    return context.getResources().getBoolean(
            com.android.internal.R.bool.config_bluetooth_sco_off_call);
}

public boolean acceptIncomingConnect(BluetoothDevice device) {
    if (DBG) log("acceptIncomingConnect");
    if (mService != null && isEnabled()) {
        try {
            return mService.acceptIncomingConnect(device);
        } catch (RemoteException e) {Log.e(TAG, e.toString());}
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
    return false;
}
public boolean rejectIncomingConnect(BluetoothDevice device) {
    if (DBG) log("rejectIncomingConnect");
    if (mService != null) {
        try {
            return mService.rejectIncomingConnect(device);
        } catch (RemoteException e) {Log.e(TAG, e.toString());}
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
    return false;
}
public int getAudioState(BluetoothDevice device) {
    if (VDBG) log("getAudioState");
    if (mService != null && !isDisabled()) {
        try {
            return mService.getAudioState(device);
        } catch (RemoteException e) {Log.e(TAG, e.toString());}
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
    return BluetoothHeadset.STATE_AUDIO_DISCONNECTED;
}
public boolean isAudioOn() {
    if (VDBG) log("isAudioOn()");
    if (mService != null && isEnabled()) {
        try {
          return mService.isAudioOn();
        } catch (RemoteException e) {
          Log.e(TAG,  Log.getStackTraceString(new Throwable()));
        }        }
    if (mService == null) Log.w(TAG, "Proxy not attached to service");
    return false;
}
public boolean connectAudio() {
    if (mService != null && isEnabled()) {
        try {
            return mService.connectAudio();
        } catch (RemoteException e) {
            Log.e(TAG, e.toString());
        }
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
    return false;
}
public boolean disconnectAudio() {
    if (mService != null && isEnabled()) {
        try {
            return mService.disconnectAudio();
        } catch (RemoteException e) {
            Log.e(TAG, e.toString());
        }
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
    return false;
}
public boolean startScoUsingVirtualVoiceCall(BluetoothDevice device) {
    if (DBG) log("startScoUsingVirtualVoiceCall()");
    if (mService != null && isEnabled() && isValidDevice(device)) {
        try {
            return mService.startScoUsingVirtualVoiceCall(device);
        } catch (RemoteException e) {
            Log.e(TAG, e.toString());
        }
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
    return false;
}
public boolean stopScoUsingVirtualVoiceCall(BluetoothDevice device) {
    if (DBG) log("stopScoUsingVirtualVoiceCall()");
    if (mService != null && isEnabled() && isValidDevice(device)) {
        try {
            return mService.stopScoUsingVirtualVoiceCall(device);
        } catch (RemoteException e) {
            Log.e(TAG, e.toString());
        }
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
    return false;
}
public void phoneStateChanged(int numActive, int numHeld, int callState, String number,
                              int type) {
    if (mService != null && isEnabled()) {
        try {
            mService.phoneStateChanged(numActive, numHeld, callState, number, type);
        } catch (RemoteException e) {
            Log.e(TAG, e.toString());
        }
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
}
public void clccResponse(int index, int direction, int status, int mode, boolean mpty,
                         String number, int type) {
    if (mService != null && isEnabled()) {
        try {
            mService.clccResponse(index, direction, status, mode, mpty, number, type);
        } catch (RemoteException e) {
            Log.e(TAG, e.toString());
        }
    } else {
        Log.w(TAG, "Proxy not attached to service");
        if (DBG) Log.d(TAG, Log.getStackTraceString(new Throwable()));
    }
}
public boolean sendVendorSpecificResultCode(BluetoothDevice device, String command,
        String arg) {
    if (DBG) {
        log("sendVendorSpecificResultCode()");
    }
    if (command == null) {
        throw new IllegalArgumentException("command is null");
    }
    if (mService != null && isEnabled() &&
            isValidDevice(device)) {
        try {
            return mService.sendVendorSpecificResultCode(device, command, arg);
        } catch (RemoteException e) {
            Log.e(TAG, Log.getStackTraceString(new Throwable()));
        }
    }
    if (mService == null) {
        Log.w(TAG, "Proxy not attached to service");
    }
    return false;
}
private final ServiceConnection mConnection = new ServiceConnection() {
    public void onServiceConnected(ComponentName className, IBinder service) {
        if (DBG) Log.d(TAG, "Proxy object connected");
        mService = IBluetoothHeadset.Stub.asInterface(service);
        if (mServiceListener != null) {
            mServiceListener.onServiceConnected(BluetoothProfile.HEADSET, BluetoothHeadset.this);
        }
    }
    public void onServiceDisconnected(ComponentName className) {
        if (DBG) Log.d(TAG, "Proxy object disconnected");
        mService = null;
        if (mServiceListener != null) {
            mServiceListener.onServiceDisconnected(BluetoothProfile.HEADSET);
        }
    }
};    private boolean isEnabled() {
   if (mAdapter.getState() == BluetoothAdapter.STATE_ON) return true;
   return false;
}
private boolean isDisabled() {
   if (mAdapter.getState() == BluetoothAdapter.STATE_OFF) return true;
   return false;
}
private boolean isValidDevice(BluetoothDevice device) {
   if (device == null) return false;
   if (BluetoothAdapter.checkBluetoothAddress(device.getAddress())) return true;
   return false;
}
private static void log(String msg) {        Log.d(TAG, msg);    }

}

查看更多
0人赞 添加讨论(0) 举报
来，给爷笑一个
3楼-- · 2020-06-21 00:39

I also had a hard time getting the vendor specific headset event to work, but finally figured it out. You have to add the Category of vendor specific events you want to receive to the IntentFilter specified when registering the Broadcast Receiver.

After adding

filter.addCategory(BluetoothHeadset.VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY+"."+BluetoothAssignedNumbers.PLANTRONICS);

my receiver now gets the Vendor Specific broadcasts from the bluetooth headset. Events such as AT+XEVENT=foo,3\r

查看更多
0人赞 添加讨论(0) 举报
登录 后发表回答
相关问题
查看全部
相关文章
查看全部
收藏的人(6)