| /* |
| * Copyright (c) 2017 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. |
| */ |
| |
| /* |
| * Defines the native inteface that is used by state machine/service to either or receive messages |
| * from the native stack. This file is registered for the native methods in corresponding CPP file. |
| */ |
| package com.android.bluetooth.hfpclient; |
| |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import android.util.Log; |
| |
| class NativeInterface { |
| private static final String TAG = "NativeInterface"; |
| private static final boolean DBG = false; |
| |
| static { |
| classInitNative(); |
| } |
| |
| NativeInterface() {} |
| |
| // Native methods that call into the JNI interface |
| static native void classInitNative(); |
| |
| native void initializeNative(); |
| |
| native void cleanupNative(); |
| |
| static native boolean connectNative(byte[] address); |
| |
| static native boolean disconnectNative(byte[] address); |
| |
| static native boolean connectAudioNative(byte[] address); |
| |
| static native boolean disconnectAudioNative(byte[] address); |
| |
| static native boolean startVoiceRecognitionNative(byte[] address); |
| |
| static native boolean stopVoiceRecognitionNative(byte[] address); |
| |
| static native boolean setVolumeNative(byte[] address, int volumeType, int volume); |
| |
| static native boolean dialNative(byte[] address, String number); |
| |
| static native boolean dialMemoryNative(byte[] address, int location); |
| |
| static native boolean handleCallActionNative(byte[] address, int action, int index); |
| |
| static native boolean queryCurrentCallsNative(byte[] address); |
| |
| static native boolean queryCurrentOperatorNameNative(byte[] address); |
| |
| static native boolean retrieveSubscriberInfoNative(byte[] address); |
| |
| static native boolean sendDtmfNative(byte[] address, byte code); |
| |
| static native boolean requestLastVoiceTagNumberNative(byte[] address); |
| |
| static native boolean sendATCmdNative(byte[] address, int atCmd, int val1, int val2, |
| String arg); |
| |
| private BluetoothDevice getDevice(byte[] address) { |
| return BluetoothAdapter.getDefaultAdapter().getRemoteDevice(address); |
| } |
| |
| // Callbacks from the native back into the java framework. All callbacks are routed via the |
| // Service which will disambiguate which state machine the message should be routed through. |
| private void onConnectionStateChanged(int state, int peerFeat, int chldFeat, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED); |
| event.valueInt = state; |
| event.valueInt2 = peerFeat; |
| event.valueInt3 = chldFeat; |
| event.device = getDevice(address); |
| // BluetoothAdapter.getDefaultAdapter().getRemoteDevice(Utils.getAddressStringFromByte |
| // (address)); |
| if (DBG) { |
| Log.d(TAG, "Device addr " + event.device.getAddress() + " State " + state); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onAudioStateChanged(int state, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_AUDIO_STATE_CHANGED); |
| event.valueInt = state; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onAudioStateChanged: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onAudioStateChanged: Ignoring message because service not available: " |
| + event); |
| } |
| } |
| |
| private void onVrStateChanged(int state, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_VR_STATE_CHANGED); |
| event.valueInt = state; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onVrStateChanged: address " + address + " event " + event); |
| } |
| |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, |
| "onVrStateChanged: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onNetworkState(int state, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_NETWORK_STATE); |
| event.valueInt = state; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onNetworkStateChanged: address " + address + " event " + event); |
| } |
| |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, |
| "onNetworkStateChanged: Ignoring message because service not available: " |
| + event); |
| } |
| } |
| |
| private void onNetworkRoaming(int state, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_ROAMING_STATE); |
| event.valueInt = state; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onNetworkRoaming: incoming: " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, |
| "onNetworkRoaming: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onNetworkSignal(int signal, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_NETWORK_SIGNAL); |
| event.valueInt = signal; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onNetworkSignal: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onNetworkSignal: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onBatteryLevel(int level, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_BATTERY_LEVEL); |
| event.valueInt = level; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onBatteryLevel: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onBatteryLevel: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onCurrentOperator(String name, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_OPERATOR_NAME); |
| event.valueString = name; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onCurrentOperator: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, |
| "onCurrentOperator: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onCall(int call, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALL); |
| event.valueInt = call; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onCall: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onCall: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| /** |
| * CIEV (Call indicators) notifying if call(s) are getting set up. |
| * |
| * Values include: |
| * 0 - No current call is in setup |
| * 1 - Incoming call process ongoing |
| * 2 - Outgoing call process ongoing |
| * 3 - Remote party being alerted for outgoing call |
| */ |
| private void onCallSetup(int callsetup, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALLSETUP); |
| event.valueInt = callsetup; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onCallSetup: addr " + address + " device" + event.device); |
| Log.d(TAG, "onCallSetup: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onCallSetup: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| /** |
| * CIEV (Call indicators) notifying call held states. |
| * |
| * Values include: |
| * 0 - No calls held |
| * 1 - Call is placed on hold or active/held calls wapped (The AG has both an ACTIVE and HELD |
| * call) |
| * 2 - Call on hold, no active call |
| */ |
| private void onCallHeld(int callheld, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALLHELD); |
| event.valueInt = callheld; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onCallHeld: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onCallHeld: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onRespAndHold(int respAndHold, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_RESP_AND_HOLD); |
| event.valueInt = respAndHold; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onRespAndHold: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onRespAndHold: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onClip(String number, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CLIP); |
| event.valueString = number; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onClip: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onClip: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onCallWaiting(String number, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALL_WAITING); |
| event.valueString = number; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onCallWaiting: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onCallWaiting: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onCurrentCalls(int index, int dir, int state, int mparty, String number, |
| byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CURRENT_CALLS); |
| event.valueInt = index; |
| event.valueInt2 = dir; |
| event.valueInt3 = state; |
| event.valueInt4 = mparty; |
| event.valueString = number; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onCurrentCalls: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onCurrentCalls: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onVolumeChange(int type, int volume, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_VOLUME_CHANGED); |
| event.valueInt = type; |
| event.valueInt2 = volume; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onVolumeChange: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onVolumeChange: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onCmdResult(int type, int cme, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CMD_RESULT); |
| event.valueInt = type; |
| event.valueInt2 = cme; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onCmdResult: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, "onCmdResult: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onSubscriberInfo(String number, int type, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_SUBSCRIBER_INFO); |
| event.valueInt = type; |
| event.valueString = number; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onSubscriberInfo: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, |
| "onSubscriberInfo: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onInBandRing(int inBand, byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_IN_BAND_RINGTONE); |
| event.valueInt = inBand; |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onInBandRing: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, |
| "onInBandRing: Ignoring message because service not available: " + event); |
| } |
| } |
| |
| private void onLastVoiceTagNumber(String number, byte[] address) { |
| Log.w(TAG, "onLastVoiceTagNumber not supported"); |
| } |
| |
| private void onRingIndication(byte[] address) { |
| StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_RING_INDICATION); |
| event.device = getDevice(address); |
| if (DBG) { |
| Log.d(TAG, "onRingIndication: address " + address + " event " + event); |
| } |
| HeadsetClientService service = HeadsetClientService.getHeadsetClientService(); |
| if (service != null) { |
| service.messageFromNative(event); |
| } else { |
| Log.w(TAG, |
| "onRingIndication: Ignoring message because service not available: " + event); |
| } |
| } |
| } |