android-14.0.0_r21/s

/*
 * 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.BluetoothDevice;
import android.util.Log;

import com.android.bluetooth.btservice.AdapterService;
import com.android.internal.annotations.VisibleForTesting;

import java.util.Objects;

/**
 * Defines native calls that are used by state machine/service to either send or receive
 * messages to/from the native stack. This file is registered for the native methods in
 * corresponding CPP file.
 */
public class NativeInterface {
    private static final String TAG = "NativeInterface";
    private static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
    private AdapterService mAdapterService;

    static {
        classInitNative();
    }

    private NativeInterface() {
        mAdapterService = Objects.requireNonNull(AdapterService.getAdapterService(),
                "AdapterService cannot be null when NativeInterface init");
    }
    private static NativeInterface sInterface;
    private static final Object INSTANCE_LOCK = new Object();

    /**
     * This class is a singleton because native library should only be loaded once
     *
     * @return default instance
     */
    public static NativeInterface getInstance() {
        synchronized (INSTANCE_LOCK) {
            if (sInterface == null) {
                sInterface = new NativeInterface();
            }
        }
        return sInterface;
    }

    // Native wrappers to help unit testing
    /**
     * Initialize native stack
     */
    @VisibleForTesting
    public void initialize() {
        initializeNative();
    }

    /**
     * Close and clean up native stack
     */
    @VisibleForTesting
    public void cleanup() {
        cleanupNative();
    }

    /**
     * Connect to the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean connect(BluetoothDevice device) {
        return connectNative(getByteAddress(device));
    }

    /**
     * Disconnect from the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean disconnect(BluetoothDevice device) {
        return disconnectNative(getByteAddress(device));
    }

    /**
     * Initiate audio connection to the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean connectAudio(BluetoothDevice device) {
        return connectAudioNative(getByteAddress(device));
    }

    /**
     * Close audio connection from the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    public boolean disconnectAudio(BluetoothDevice device) {
        return disconnectAudioNative(getByteAddress(device));
    }

    /**
     * Initiate voice recognition to the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean startVoiceRecognition(BluetoothDevice device) {
        return startVoiceRecognitionNative(getByteAddress(device));
    }

    /**
     * Close voice recognition to the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean stopVoiceRecognition(BluetoothDevice device) {
        return stopVoiceRecognitionNative(getByteAddress(device));
    }

    /**
     * Set volume to the specified paired device
     *
     * @param device target device
     * @param volumeType type of volume as in
     *                  HeadsetClientHalConstants.VOLUME_TYPE_xxxx
     * @param volume  volume level
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean setVolume(BluetoothDevice device, int volumeType, int volume) {
        return setVolumeNative(getByteAddress(device), volumeType, volume);
    }

    /**
     * dial number from the specified paired device
     *
     * @param device target device
     * @param number  phone number to be dialed
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean dial(BluetoothDevice device, String number) {
        return dialNative(getByteAddress(device), number);
    }

    /**
     * Memory dialing from the specified paired device
     *
     * @param device target device
     * @param location  memory location
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean dialMemory(BluetoothDevice device, int location) {
        return dialMemoryNative(getByteAddress(device), location);
    }

    /**
     * Apply action to call
     *
     * @param device target device
     * @param action action (e.g. hold, terminate etc)
     * @param index call index
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean handleCallAction(BluetoothDevice device, int action, int index) {
        return handleCallActionNative(getByteAddress(device), action, index);
    }

    /**
     * Query current call status from the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean queryCurrentCalls(BluetoothDevice device) {
        return queryCurrentCallsNative(getByteAddress(device));
    }

    /**
     * Query operator name from the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean queryCurrentOperatorName(BluetoothDevice device) {
        return queryCurrentOperatorNameNative(getByteAddress(device));
    }

    /**
     * Retrieve subscriber number from the specified paired device
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public  boolean retrieveSubscriberInfo(BluetoothDevice device) {
        return retrieveSubscriberInfoNative(getByteAddress(device));
    }

    /**
     * Transmit DTMF code
     *
     * @param device target device
     * @param code DTMF code
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean sendDtmf(BluetoothDevice device, byte code) {
        return sendDtmfNative(getByteAddress(device), code);
    }

    /**
     * Request last voice tag
     *
     * @param device target device
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean requestLastVoiceTagNumber(BluetoothDevice device) {
        return requestLastVoiceTagNumberNative(getByteAddress(device));
    }

    /**
     * Send an AT command
     *
     * @param device target device
     * @param atCmd command code
     * @param val1 command specific argurment1
     * @param val2 command specific argurment2
     * @param arg other command specific argurments
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean sendATCmd(BluetoothDevice device, int atCmd, int val1, int val2, String arg) {
        return sendATCmdNative(getByteAddress(device), atCmd, val1, val2, arg);
    }

    /**
     * Set call audio policy to the specified paired device
     *
     * @param cmd Android specific command string
     * @return True on success, False on failure
     */
    @VisibleForTesting
    public boolean sendAndroidAt(BluetoothDevice device, String cmd) {
        if (device == null) {
            Log.w(TAG, "Don't need to send " + cmd + " because no remote device");
            return false;
        }
        return sendAndroidAtNative(getByteAddress(device), cmd);
    }

    // Native methods that call into the JNI interface
    private static native void classInitNative();

    private native void initializeNative();

    private native void cleanupNative();

    private static native boolean connectNative(byte[] address);

    private static native boolean disconnectNative(byte[] address);

    private static native boolean connectAudioNative(byte[] address);

    private static native boolean disconnectAudioNative(byte[] address);

    private static native boolean startVoiceRecognitionNative(byte[] address);

    private static native boolean stopVoiceRecognitionNative(byte[] address);

    private static native boolean setVolumeNative(byte[] address, int volumeType, int volume);

    private static native boolean dialNative(byte[] address, String number);

    private static native boolean dialMemoryNative(byte[] address, int location);

    private static native boolean handleCallActionNative(byte[] address, int action, int index);

    private static native boolean queryCurrentCallsNative(byte[] address);

    private static native boolean queryCurrentOperatorNameNative(byte[] address);

    private static native boolean retrieveSubscriberInfoNative(byte[] address);

    private static native boolean sendDtmfNative(byte[] address, byte code);

    private static native boolean requestLastVoiceTagNumberNative(byte[] address);

    private static native boolean sendATCmdNative(byte[] address, int atCmd, int val1, int val2,
            String arg);

    private static native boolean sendAndroidAtNative(byte[] address, String cmd);

    private BluetoothDevice getDevice(byte[] address) {
        return mAdapterService.getDeviceFromByte(address);
    }

    private byte[] getByteAddress(BluetoothDevice device) {
        return mAdapterService.getByteIdentityAddress(device);
    }

    // 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.
    @VisibleForTesting
    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 + " State " + state);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onAudioStateChanged: Ignoring message because service not available: "
                    + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }

        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onVrStateChanged: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }

        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onNetworkStateChanged: Ignoring message because service not available: "
                            + event);
        }
    }

    @VisibleForTesting
    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);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onNetworkSignal: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onBatteryLevel: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onCurrentOperator: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: 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
     */
    @VisibleForTesting
    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: device" + event.device);
            Log.d(TAG, "onCallSetup: 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
     */
    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCallHeld: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onRespAndHold: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onClip: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCallWaiting: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCurrentCalls: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onVolumeChange: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG, "onCmdResult: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onSubscriberInfo: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    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: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onInBandRing: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    void onLastVoiceTagNumber(String number, byte[] address) {
        Log.w(TAG, "onLastVoiceTagNumber not supported");
    }

    @VisibleForTesting
    void onRingIndication(byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_RING_INDICATION);
        event.device = getDevice(address);
        if (DBG) {
            Log.d(TAG, "onRingIndication: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onRingIndication: Ignoring message because service not available: " + event);
        }
    }

    @VisibleForTesting
    void onUnknownEvent(String eventString, byte[] address) {
        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_UNKNOWN_EVENT);
        event.device = getDevice(address);
        event.valueString = eventString;
        if (DBG) {
            Log.d(TAG, "onUnknownEvent: event " + event);
        }
        HeadsetClientService service = HeadsetClientService.getHeadsetClientService();
        if (service != null) {
            service.messageFromNative(event);
        } else {
            Log.w(TAG,
                    "onUnknowEvent: Ignoring message because service not available: " + event);
        }
    }

}