android.bluetooth.BluetoothAdapter Java Examples

private void startBluetooth() {
	if (isBluetoothConnected) {
		Log.e("[Bluetooth] Already started, skipping...");
		return;
	}
	
	mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
	
	if (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled()) {
		if (mProfileListener != null) {
			Log.w("[Bluetooth] Headset profile was already opened, let's close it");
			mBluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, mBluetoothHeadset);
		}
		
		mProfileListener = new BluetoothProfile.ServiceListener() {
			public void onServiceConnected(int profile, BluetoothProfile proxy) {
			    if (profile == BluetoothProfile.HEADSET) {
			        Log.d("[Bluetooth] Headset connected");
			        mBluetoothHeadset = (BluetoothHeadset) proxy;
			        isBluetoothConnected = true;
			    }
			}
			public void onServiceDisconnected(int profile) {
			    if (profile == BluetoothProfile.HEADSET) {
			        mBluetoothHeadset = null;
			        isBluetoothConnected = false;
			        Log.d("[Bluetooth] Headset disconnected");
			        LinphoneManager.getInstance().routeAudioToReceiver();
			    }
			}
		};
		boolean success = mBluetoothAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.HEADSET);
		if (!success) {
			Log.e("[Bluetooth] getProfileProxy failed !");
		}
	} else {
		Log.w("[Bluetooth] Interface disabled on device");
	}
}
 

private void conditionalStart() {
    BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
    if (adapter == null) {
        NeatleLogger.e("Bluetooth LE scan failed to start. No bluetooth adapter found");
        return;
    }
    int adapterState = adapter.getState();
    if (adapterState != BluetoothAdapter.STATE_ON) {
        NeatleLogger.e("Bluetooth off, will start scanning when it turns on.");
        pause();
        return;
    }

    onStart(adapter, scanMode);
    doStarted = true;
    if (scanDuration > 0) {
        handler.postDelayed(pauseCallback, scanDuration);
    }
}
 

@Override
public void onCreate(){
    super.onCreate();
    mAdapter = BluetoothAdapter.getDefaultAdapter();

    mState = STATE_NONE;
    mNewState = mState;

    if(mAdapter == null){
        EventBus.getDefault().post(new UiToastEvent(getString(R.string.text_bluetooth_adapter_error), true, true));
        stopSelf();
    }else{
        if(Build.VERSION.SDK_INT > Build.VERSION_CODES.N_MR1){
            startForeground(Constants.BLUETOOTH_SERVICE_NOTIFICATION_ID, this.getNotification(null));
        }

        serialBluetoothCommunicationHandler = new SerialBluetoothCommunicationHandler(this);
        EventBus.getDefault().register(this);
    }
}
 

public static int getBleStatus(Context context) {
    if (!context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
        return STATUS_BLE_NOT_AVAILABLE;
    }

    final BluetoothAdapter adapter = getBluetoothAdapter(context);
    // Checks if Bluetooth is supported on the device.
    if (adapter == null) {
        return STATUS_BLUETOOTH_NOT_AVAILABLE;
    }

    if (!adapter.isEnabled()) {
        return STATUS_BLUETOOTH_DISABLED;
    }

    return STATUS_BLE_ENABLED;
}
 

@SuppressLint("MissingPermission")
boolean isBluetoothActuallyAvailable(){
    BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
    if(adapter == null || !adapter.isEnabled() ){
        //False positive
        return false;
    }
    if(android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH ){
        int state = adapter.getProfileConnectionState(BluetoothProfile.A2DP);
        if(state != BluetoothAdapter.STATE_CONNECTING && state != BluetoothAdapter.STATE_CONNECTED){
            //False positive
            return false;
        }
    }

    return true;
}
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    initView();

    mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
    mLocationManager.addGpsStatusListener(mGpsStatusListener);

    mWifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
    mConnectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
    intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
    registerReceiver(mReceiver, intentFilter);

    updateBlueToothStatus();
}
 

@Override
protected void onResume() {
    super.onResume();

  //如果没开蓝牙,请求打开蓝牙
    if (!mBluetoothAdapter.isEnabled()) {
        if (!mBluetoothAdapter.isEnabled()) {
            Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
            startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
        }
    }

    // Initializes list view adapter.
    mAdapter = new LeDeviceListAdapter(this);
    mLView.setAdapter(mAdapter);
    mLView.setOnItemClickListener(this);
    scanLeDevice(true);
}
 

@Override public final void stopLeScan(BluetoothAdapter.LeScanCallback callback)
{
    if (m_adaptor != null)
    {
        if (m_bleManager.getScanManager().isPostLollipopScan())
        {
            L_Util.stopNativeScan(m_adaptor);
        }
        else
        {
            m_adaptor.stopLeScan(callback);
        }
    }
    else
        m_bleManager.getLogger().e("Tried to stop scan (if it's even running), but the Bluetooth Adaptor is null!");
}
 

@Override
public void onReceive(Context context, Intent intent) {
    int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.STATE_OFF);

    switch (state) {
        case BluetoothAdapter.STATE_ON:
            startAdvertising();
            startServer();
            break;
        case BluetoothAdapter.STATE_OFF:
            stopServer();
            stopAdvertising();
            break;
        default:
            // Do nothing
            break;
    }
}
 

/**
 * Finds all bonded devices and tries to unbond it.
 */
private void unPairDevice() {
    ConnectedDevice connectedDevice = BluetoothUtils.getPairedMicrobit(this);
    String addressToDelete = connectedDevice.mAddress;
    // Get the paired devices and put them in a Set
    BluetoothAdapter mBluetoothAdapter = ((BluetoothManager) getSystemService(BLUETOOTH_SERVICE)).getAdapter();
    Set<BluetoothDevice> pairedDevices = mBluetoothAdapter.getBondedDevices();
    for(BluetoothDevice bt : pairedDevices) {
        logi("Paired device " + bt.getName());
        if(bt.getAddress().equals(addressToDelete)) {
            try {
                Method m = bt.getClass().getMethod("removeBond", (Class[]) null);
                m.invoke(bt, (Object[]) null);
            } catch(NoSuchMethodException | IllegalAccessException
                    | InvocationTargetException e) {
                Log.e(TAG, e.toString());
            }
        }
    }
}
 

private void startBluetooth() {
    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    if (mBluetoothAdapter != null) {
        Log.i("[Audio Manager] [Bluetooth] Adapter found");
        if (mAudioManager.isBluetoothScoAvailableOffCall()) {
            Log.i("[Audio Manager] [Bluetooth] SCO available off call, continue");
        } else {
            Log.w("[Audio Manager] [Bluetooth] SCO not available off call !");
        }

        mBluetoothReceiver = new BluetoothReceiver();
        IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
        mContext.registerReceiver(mBluetoothReceiver, filter);

        bluetoothAdapterStateChanged();
    }
}
 

@RequiresApi(api = Build.VERSION_CODES.JELLY_BEAN_MR2)
public AddBeaconChoicePreferenceDummy(Context context, Fragment fragment) {
    super(context);
    setKey(DUMMY);
    setIcon(android.R.drawable.ic_menu_add);
    setTitle(R.string.add_beacon_title);
    setSummary(R.string.add_beacon_summary);
    setOnPreferenceClickListener(prefs -> {
        BluetoothManager bluetoothManager = (BluetoothManager) getContext().getSystemService(Context.BLUETOOTH_SERVICE);
        if (bluetoothManager == null) {
            HyperLog.w(TAG, "Unable to get bluetooth manager");
        } else {
            BluetoothAdapter bluetoothAdapter = bluetoothManager.getAdapter();
            if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()) {
                Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                fragment.startActivityForResult(enableBtIntent, ON_DEMAND_BLUETOOTH_REQUEST_CODE);
                return true;
            }
        }
        BeaconScanDialogFragment instance = getInstance(getContext(), this::onScanResult,
                getSharedPreferences().getStringSet(BEACON_LIST, Collections.emptySet()));
        instance.show(fragment.requireFragmentManager(), null);
        return true;
    });
}
 

@Override
public void onReceive(Context context, Intent intent) {
    // TODO Auto-generated mEt_msgContenthod stub
    String action = intent.getAction();
    if (BluetoothDevice.ACTION_FOUND.equals(action)) {
        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
        if (mDeviceList.contains(device)) {  //防止重复添加蓝牙设备
            return;
        }
        mArrayList.add(device.getName() + "\n" + device.getAddress());
        mDeviceList.add(device);
        adapter.notifyDataSetChanged();    //通知数据源更新，刷新蓝牙列表
    } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
        //Toast.makeText(MainActivity.this, "搜索完成！", Toast.LENGTH_SHORT).show();
    }
}
 

public static void subscribe(
    Context context, String address, String characteristic, Listener listener) {
  synchronized (gattHandlers) {
    GattHandler gattHandler = gattHandlers.get(address);
    if (gattHandler == null) {
      BluetoothManager manager =
          (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
      if (manager == null) {
        return;
      }
      BluetoothAdapter adapter = manager.getAdapter();
      BluetoothDevice device = adapter.getRemoteDevice(address);
      gattHandler = new GattHandler();
      gattHandlers.put(address, gattHandler);
      device.connectGatt(context, true /* autoConnect */, gattHandler);
    }
    gattHandler.subscribe(characteristic, listener);
  }
}
 

public void setDiscoverable() {
    BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
    if (adapter == null) {
        return;
    }

    // change name if necessary
    String originalName = adapter.getName();
    if (originalName.lastIndexOf(_deviceNamePostFix) != originalName.length() - _deviceNamePostFix.length()) {
        if (_connectionHelperListener != null) {
            _connectionHelperListener.onAdapterNameChange(originalName);
        }

        Log.d(TAG, "setDiscoverable: Bluetooth device name set to " + (originalName + _deviceNamePostFix));
        adapter.setName(originalName + _deviceNamePostFix);
    }

    // set discoverable if necessary
    if (adapter.getScanMode() != BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
        Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
        discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
        _activity.startActivity(discoverableIntent);
    }
}
 

/**
 * Initialization / Finalization
 */
private void initialize() {
	Logs.d(TAG, "# Activity - initialize()");
	mService.setupService(mActivityHandler);
	
	// If BT is not on, request that it be enabled.
	// RetroWatchService.setupBT() will then be called during onActivityResult
	if(!mService.isBluetoothEnabled()) {
		Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
		startActivityForResult(enableIntent, Constants.REQUEST_ENABLE_BT);
	}
	
	// Load activity reports and display
	if(mRefreshTimer != null) {
		mRefreshTimer.cancel();
	}
	
	// Use below timer if you want scheduled job
	//mRefreshTimer = new Timer();
	//mRefreshTimer.schedule(new RefreshTimerTask(), 5*1000);
}
 

private void discoverableDevice() {

        boolean bonded = false;
        for (BluetoothDevice device : mPairedDevices) {
            if (mPairingAddress.equals(device.getAddress())) {
                bonded = true;
                break;
            }
        }

        if (!bonded) {
            Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
            discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
            mActivity.startActivity(discoverableIntent);
        }

        mAcceptThread = new AcceptThread();
        mAcceptThread.start();
    }
 

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_dash_board);

    setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);

    Toolbar toolbar = (Toolbar) findViewById(R.id.dash_board_toolbar);
    setSupportActionBar(toolbar);

    // Get local Bluetooth adapter
    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

    // If the adapter is null, then Bluetooth is not supported
    if (mBluetoothAdapter == null) {
        showSnackBar("Bluetooth is not available");
        finish();
    }
}
 

public static boolean isBluetoothEnabled() {
    // Must call Looper.prepare() due to ICS bug
    // And we can't call the function from UI thread when we receive a push notification)
    // http://stackoverflow.com/questions/5920578/bluetoothadapter-getdefault-throwing-runtimeexception-while-not-in-activity

    if (Looper.myLooper() == null) {
        Looper.prepare();
    }

    // Get bluetooth adapter
    BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

    // Null means device doesn't support Bluetooth
    if (bluetoothAdapter == null) {
        // No Bluetooth support
        return false;
    }
    else {
        // Check if it's enabled and return the result
        return bluetoothAdapter.isEnabled();
    }
}
 

public void onClick(View v) {
    int state = SharedPreferencesHelper.getBluetoothStatus(DisplayActivity.this);
    switch (state) {
        case Constants.BLUETOOTH_STATE_DISABLED:
            startActivityForResult(new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE), 0);
            break;
        case Constants.BLUETOOTH_STATE_ENABLED:
        case Constants.BLUETOOTH_STATE_CONNECTING:
        case Constants.BLUETOOTH_STATE_CONNECTED:
            boolean isMaster = (mDeviceLocation == Constants.DEVICE_LOCATION_HAND);
            if (isMaster) {
                Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
                discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
                startActivity(discoverableIntent);
            } else {
                Intent serverIntent = new Intent(DisplayActivity.this, BluetoothDeviceListActivity.class);
                startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);
            }
            break;
    }
}
 

/**
 * Turn on local bluetooth, calling the method will show users a request dialog
 * to grant or reject,so you can get the result from Activity#onActivityResult()
 *
 * @param activity    activity, note that to get the result whether users have granted
 *                    or rejected to enable bluetooth, you should handle the method
 *                    onActivityResult() of this activity
 * @param requestCode enable bluetooth request code
 */
public static void enableBluetooth(Activity activity, int requestCode) {
    if (activity == null || requestCode < 0) {
        return;
    }
    BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
    if (adapter != null && !adapter.isEnabled()) {
        Intent intent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        activity.startActivityForResult(intent, requestCode);
    }
}
 

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == BlUETOOTH_SETTINGS_REQUEST_CODE) {
        BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        if (!bluetoothAdapter.isEnabled() && bluetoothEnableDialog != null) {
            bluetoothEnableDialog.show();
        }
    }
}
 

/**
 * Enable the current {@link BluetoothAdapter} to be discovered (available for pairing) for
 * the next {@link #DISCOVERABLE_TIMEOUT_MS} ms.
 */
private void enableDiscoverable() {
    Log.d(TAG, "Registering for discovery.");
    Intent discoverableIntent =
            new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
    discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,
            DISCOVERABLE_TIMEOUT_MS);
    startActivityForResult(discoverableIntent, REQUEST_CODE_ENABLE_DISCOVERABLE);
}
 

private void checkState(int state) {
    if (state != BluetoothAdapter.STATE_TURNING_ON
            && state != BluetoothAdapter.STATE_TURNING_OFF) {
        finish();
    } else {
        ((TextView) findViewById(R.id.title))
                .setText(
                        getString(
                                state == BluetoothAdapter.STATE_TURNING_ON
                                        ? R.string.pref_bluetooth_turningOn
                                        : R.string.pref_bluetooth_turningOff));
    }
}
 

public GattServer(Context context, Listener listener) {
    mListener = listener;
    mBluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);

    // Update internal status
    onBluetoothStateChanged(context);

    // Set Ble status receiver
    IntentFilter filter = new IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
    LocalBroadcastManager.getInstance(context).registerReceiver(mBleAdapterStateReceiver, filter);
}
 

public static BluetoothDevice getDevice(BluetoothAdapter bluetoothAdapter) {
	BluetoothDevice innerprinter_device = null;
	Set<BluetoothDevice> devices = bluetoothAdapter.getBondedDevices();
	for (BluetoothDevice device : devices) {
		if (device.getAddress().equals(Innerprinter_Address)) {
			innerprinter_device = device;
			break;
		}
	}
	return innerprinter_device;
}
 

@Override public final boolean startLeScan(BluetoothAdapter.LeScanCallback callback)
{
    if (m_adaptor != null)
        return m_adaptor.startLeScan(callback);

    return false;
}
 

@Override
public void onReceive(final Context context, final Intent intent) {
    String action = intent.getAction();
    if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
        int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1);
        if (state == BluetoothAdapter.STATE_ON) {
            getManager().start();
        } else if (state == BluetoothAdapter.STATE_OFF) {
            getManager().stop();
        }
    }
}
 

/**
 * Instantiates a new BroadcastReceiverDelegator.
 *
 * @param context   the context of this object.
 * @param listener  a callback for handling Bluetooth events.
 * @param bluetooth a controller for the Bluetooth.
 */
public BroadcastReceiverDelegator(Context context, BluetoothDiscoveryDeviceListener listener, BluetoothController bluetooth) {
    this.listener = listener;
    this.context = context;
    this.listener.setBluetoothController(bluetooth);

    // Register for broadcasts when a device is discovered.
    IntentFilter filter = new IntentFilter();
    filter.addAction(BluetoothDevice.ACTION_FOUND);
    filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
    filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
    filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
    context.registerReceiver(this, filter);
}
 

@Nullable
private static BluetoothInfoModel extractBluetoothInfo(DeviceInfoHelper deviceInfoHelper) {
    BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    return bluetoothAdapter == null
            ? null
            : new BluetoothInfoModel(deviceInfoHelper.toBluetoothStateString(bluetoothAdapter.getState()));
}