/*
 * Copyright (C) 2021 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 com.android.server.wifi;

import android.annotation.NonNull;
import android.content.Context;
import android.hardware.wifi.hostapd.ApInfo;
import android.hardware.wifi.hostapd.BandMask;
import android.hardware.wifi.hostapd.ChannelBandwidth;
import android.hardware.wifi.hostapd.ChannelParams;
import android.hardware.wifi.hostapd.ClientInfo;
import android.hardware.wifi.hostapd.DebugLevel;
import android.hardware.wifi.hostapd.EncryptionType;
import android.hardware.wifi.hostapd.FrequencyRange;
import android.hardware.wifi.hostapd.Generation;
import android.hardware.wifi.hostapd.HwModeParams;
import android.hardware.wifi.hostapd.IHostapd;
import android.hardware.wifi.hostapd.IHostapdCallback;
import android.hardware.wifi.hostapd.Ieee80211ReasonCode;
import android.hardware.wifi.hostapd.IfaceParams;
import android.hardware.wifi.hostapd.NetworkParams;
import android.net.MacAddress;
import android.net.wifi.ScanResult;
import android.net.wifi.SoftApConfiguration;
import android.net.wifi.SoftApConfiguration.BandType;
import android.net.wifi.SoftApInfo;
import android.net.wifi.WifiAnnotations;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.IBinder;
import android.os.IBinder.DeathRecipient;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.ServiceSpecificException;
import android.util.Log;

import com.android.internal.annotations.VisibleForTesting;
import com.android.modules.utils.build.SdkLevel;
import com.android.server.wifi.WifiNative.HostapdDeathEventHandler;
import com.android.server.wifi.util.ApConfigUtil;
import com.android.server.wifi.util.NativeUtil;
import com.android.wifi.resources.R;

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import javax.annotation.concurrent.ThreadSafe;

/**
 * To maintain thread-safety, the locking protocol is that every non-static method (regardless of
 * access level) acquires mLock.
 */
@ThreadSafe
/** The implementation of IHostapdHal which based on Stable AIDL interface */
public class HostapdHalAidlImp implements IHostapdHal {
    private static final String TAG = "HostapdHalAidlImp";
    private static final String HAL_INSTANCE_NAME = IHostapd.DESCRIPTOR + "/default";
    @VisibleForTesting
    public static final long WAIT_FOR_DEATH_TIMEOUT_MS = 50L;

    private final Object mLock = new Object();
    private boolean mVerboseLoggingEnabled = false;
    private boolean mVerboseHalLoggingEnabled = false;
    private final Context mContext;
    private final Handler mEventHandler;

    // Hostapd HAL interface objects
    private IHostapd mIHostapd;
    private HashMap<String, Runnable> mSoftApFailureListeners = new HashMap<>();
    private WifiNative.SoftApHalCallback mSoftApEventCallback;
    private Set<String> mActiveInstances = new HashSet<>();
    private HostapdDeathEventHandler mDeathEventHandler;
    private boolean mServiceDeclared = false;
    private CountDownLatch mWaitForDeathLatch;

    /**
     * Default death recipient. Called any time the service dies.
     */
    private class HostapdDeathRecipient implements DeathRecipient {
        private final IBinder mWho;
        @Override
        /* Do nothing as we override the default function binderDied(IBinder who). */
        public void binderDied() {
            synchronized (mLock) {
                Log.w(TAG, "IHostapd/IHostapd died. who " + mWho + " service "
                        + getServiceBinderMockable());
                if (mWho == getServiceBinderMockable()) {
                    if (mWaitForDeathLatch != null) {
                        mWaitForDeathLatch.countDown();
                    }
                    mEventHandler.post(() -> {
                        synchronized (mLock) {
                            Log.w(TAG, "Handle IHostapd/IHostapd died.");
                            hostapdServiceDiedHandler(mWho);
                        }
                    });
                }
            }
        }

        HostapdDeathRecipient(IBinder who) {
            mWho = who;
        }
    }

    public HostapdHalAidlImp(@NonNull Context context, @NonNull Handler handler) {
        mContext = context;
        mEventHandler = handler;
        Log.d(TAG, "init HostapdHalAidlImp");
    }

    /**
     * Enable/Disable verbose logging.
     *
     * @param enable true to enable, false to disable.
     */
    @Override
    public void enableVerboseLogging(boolean verboseEnabled, boolean halVerboseEnabled) {
        synchronized (mLock) {
            mVerboseLoggingEnabled = verboseEnabled;
            mVerboseHalLoggingEnabled = halVerboseEnabled;
            setDebugParams();
        }
    }

    /**
     * Returns whether or not the hostapd supports getting the AP info from the callback.
     */
    @Override
    public boolean isApInfoCallbackSupported() {
        // Supported in the AIDL implementation
        return true;
    }

    /**
     * Checks whether the IHostapd service is declared, and therefore should be available.
     * @return true if the IHostapd service is declared
     */
    @Override
    public boolean initialize() {
        synchronized (mLock) {
            if (mVerboseLoggingEnabled) {
                Log.i(TAG, "Checking if IHostapd service is declared.");
            }
            mServiceDeclared = serviceDeclared();
            return mServiceDeclared;
        }
    }

    /**
     * Register for callbacks with the hostapd service. On service-side event,
     * the hostapd service will trigger our IHostapdCallback implementation, which
     * in turn calls the proper SoftApHalCallback registered with us by WifiNative.
     */
    private boolean registerCallback(IHostapdCallback callback) {
        synchronized (mLock) {
            String methodStr = "registerCallback";
            try {
                mIHostapd.registerCallback(callback);
                return true;
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
            } catch (ServiceSpecificException e) {
                handleServiceSpecificException(e, methodStr);
            }
            return false;
        }
    }

    /**
     * Register the provided callback handler for SoftAp events.
     * <p>
     * Note that only one callback can be registered at a time - any registration overrides previous
     * registrations.
     *
     * @param ifaceName Name of the interface.
     * @param listener Callback listener for AP events.
     * @return true on success, false on failure.
     */
    @Override
    public boolean registerApCallback(@NonNull String ifaceName,
            @NonNull WifiNative.SoftApHalCallback callback) {
        // TODO(b/195980798) : Create a hashmap to associate the listener with the ifaceName
        synchronized (mLock) {
            if (callback == null) {
                Log.e(TAG, "registerApCallback called with a null callback");
                return false;
            }
            mSoftApEventCallback = callback;
            Log.i(TAG, "registerApCallback Successful in " + ifaceName);
            return true;
        }
    }

    /**
     * Add and start a new access point.
     *
     * @param ifaceName Name of the interface.
     * @param config Configuration to use for the AP.
     * @param isMetered Indicates if the network is metered or not.
     * @param onFailureListener A runnable to be triggered on failure.
     * @return true on success, false otherwise.
     */
    @Override
    public boolean addAccessPoint(@NonNull String ifaceName, @NonNull SoftApConfiguration config,
            boolean isMetered, Runnable onFailureListener) {
        synchronized (mLock) {
            final String methodStr = "addAccessPoint";
            Log.d(TAG, methodStr + ": " + ifaceName);
            if (!checkHostapdAndLogFailure(methodStr)) {
                return false;
            }
            try {
                IfaceParams ifaceParams = prepareIfaceParams(ifaceName, config);
                NetworkParams nwParams = prepareNetworkParams(isMetered, config);
                if (ifaceParams == null || nwParams == null) {
                    Log.e(TAG, "addAccessPoint parameters could not be prepared.");
                    return false;
                }
                mIHostapd.addAccessPoint(ifaceParams, nwParams);
                mSoftApFailureListeners.put(ifaceName, onFailureListener);
                return true;
            } catch (IllegalArgumentException e) {
                Log.e(TAG, "Unrecognized apBand: " + config.getBand());
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
            } catch (ServiceSpecificException e) {
                handleServiceSpecificException(e, methodStr);
            }
            return false;
        }
    }

    /**
     * Remove a previously started access point.
     *
     * @param ifaceName Name of the interface.
     * @return true on success, false otherwise.
     */
    @Override
    public boolean removeAccessPoint(@NonNull String ifaceName) {
        synchronized (mLock) {
            final String methodStr = "removeAccessPoint";
            if (!checkHostapdAndLogFailure(methodStr)) {
                return false;
            }
            try {
                mSoftApFailureListeners.remove(ifaceName);
                mSoftApEventCallback = null;
                mIHostapd.removeAccessPoint(ifaceName);
                return true;
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
            } catch (ServiceSpecificException e) {
                handleServiceSpecificException(e, methodStr);
            }
            return false;
        }
    }

    /**
     * Remove a previously connected client.
     *
     * @param ifaceName Name of the interface.
     * @param client Mac Address of the client.
     * @param reasonCode One of disconnect reason code which defined in {@link WifiManager}.
     * @return true on success, false otherwise.
     */
    @Override
    public boolean forceClientDisconnect(@NonNull String ifaceName,
            @NonNull MacAddress client, int reasonCode) {
        synchronized (mLock) {
            final String methodStr = "forceClientDisconnect";
            try {
                if (!checkHostapdAndLogFailure(methodStr)) {
                    return false;
                }
                byte[] clientMacByteArray = client.toByteArray();
                int disconnectReason;
                switch (reasonCode) {
                    case WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_BLOCKED_BY_USER:
                        disconnectReason = Ieee80211ReasonCode.WLAN_REASON_PREV_AUTH_NOT_VALID;
                        break;
                    case WifiManager.SAP_CLIENT_BLOCK_REASON_CODE_NO_MORE_STAS:
                        disconnectReason = Ieee80211ReasonCode.WLAN_REASON_DISASSOC_AP_BUSY;
                        break;
                    case WifiManager.SAP_CLIENT_DISCONNECT_REASON_CODE_UNSPECIFIED:
                        disconnectReason = Ieee80211ReasonCode.WLAN_REASON_UNSPECIFIED;
                        break;
                    default:
                        throw new IllegalArgumentException(
                                "Unknown disconnect reason code:" + reasonCode);
                }
                mIHostapd.forceClientDisconnect(ifaceName, clientMacByteArray, disconnectReason);
                return true;
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
            } catch (ServiceSpecificException e) {
                handleServiceSpecificException(e, methodStr);
            }
            return false;
        }
    }

    /**
     * Registers a death notification for hostapd.
     * @return Returns true on success.
     */
    @Override
    public boolean registerDeathHandler(@NonNull HostapdDeathEventHandler handler) {
        synchronized (mLock) {
            if (mDeathEventHandler != null) {
                Log.e(TAG, "Death handler already present");
            }
            mDeathEventHandler = handler;
            return true;
        }
    }

    /**
     * Deregisters a death notification for hostapd.
     * @return Returns true on success.
     */
    @Override
    public boolean deregisterDeathHandler() {
        synchronized (mLock) {
            if (mDeathEventHandler == null) {
                Log.e(TAG, "No Death handler present");
                return false;
            }
            mDeathEventHandler = null;
            return true;
        }
    }

    /**
     * Handle hostapd death.
     */
    private void hostapdServiceDiedHandler(IBinder who) {
        synchronized (mLock) {
            if (who != getServiceBinderMockable()) {
                Log.w(TAG, "Ignoring stale death recipient notification");
                return;
            }
            mIHostapd = null;
            if (mDeathEventHandler != null) {
                mDeathEventHandler.onDeath();
            }
        }
    }

    private class HostapdCallback extends IHostapdCallback.Stub {
        @Override
        public void onFailure(String ifaceName, String instanceName) {
            Log.w(TAG, "Failure on iface " + ifaceName + ", instance: " + instanceName);
            Runnable onFailureListener = mSoftApFailureListeners.get(ifaceName);
            if (onFailureListener != null) {
                mActiveInstances.remove(instanceName);
                if (mActiveInstances.size() == 0) {
                    onFailureListener.run();
                } else if (mSoftApEventCallback != null) {
                    mSoftApEventCallback.onInstanceFailure(instanceName);
                }
            }
        }

        @Override
        public void onApInstanceInfoChanged(ApInfo info) {
            Log.v(TAG, "onApInstanceInfoChanged on " + info.ifaceName + " / "
                    + info.apIfaceInstance);
            try {
                if (mSoftApEventCallback != null) {
                    mSoftApEventCallback.onInfoChanged(info.apIfaceInstance, info.freqMhz,
                            mapHalChannelBandwidthToSoftApInfo(info.channelBandwidth),
                            mapHalGenerationToWifiStandard(info.generation),
                            MacAddress.fromBytes(info.apIfaceInstanceMacAddress));
                }
                mActiveInstances.add(info.apIfaceInstance);
            } catch (IllegalArgumentException iae) {
                Log.e(TAG, " Invalid apIfaceInstanceMacAddress, " + iae);
            }
        }

        @Override
        public void onConnectedClientsChanged(ClientInfo info) {
            try {
                Log.d(TAG, "onConnectedClientsChanged on " + info.ifaceName
                        + " / " + info.apIfaceInstance
                        + " and Mac is " + MacAddress.fromBytes(info.clientAddress).toString()
                        + " isConnected: " + info.isConnected);
                if (mSoftApEventCallback != null) {
                    mSoftApEventCallback.onConnectedClientsChanged(info.apIfaceInstance,
                            MacAddress.fromBytes(info.clientAddress), info.isConnected);
                }
            } catch (IllegalArgumentException iae) {
                Log.e(TAG, " Invalid clientAddress, " + iae);
            }
        }

        @Override
        public String getInterfaceHash() {
            return IHostapdCallback.HASH;
        }

        @Override
        public int getInterfaceVersion() {
            return IHostapdCallback.VERSION;
        }
    }

    /**
     * Signals whether Initialization started and found the declared service
     */
    @Override
    public boolean isInitializationStarted() {
        synchronized (mLock) {
            return mServiceDeclared;
        }
    }

    /**
     * Signals whether Initialization completed successfully.
     */
    @Override
    public boolean isInitializationComplete() {
        synchronized (mLock) {
            return mIHostapd != null;
        }
    }

    /**
     * Indicates whether the AIDL service is declared
     */
    public static boolean serviceDeclared() {
        // Service Manager API ServiceManager#isDeclared supported after T.
        if (!SdkLevel.isAtLeastT()) {
            return false;
        }
        return ServiceManager.isDeclared(HAL_INSTANCE_NAME);
    }

    /**
     * Wrapper functions created to be mockable in unit tests
     */
    @VisibleForTesting
    protected IBinder getServiceBinderMockable() {
        synchronized (mLock) {
            if (mIHostapd == null) return null;
            return mIHostapd.asBinder();
        }
    }

    @VisibleForTesting
    protected IHostapd getHostapdMockable() {
        synchronized (mLock) {
            return IHostapd.Stub.asInterface(
                    ServiceManager.waitForDeclaredService(HAL_INSTANCE_NAME));
        }
    }

    /**
     * Start hostapd daemon
     *
     * @return true when succeed, otherwise false.
     */
    @Override
    public boolean startDaemon() {
        synchronized (mLock) {
            final String methodStr = "startDaemon";
            mIHostapd = getHostapdMockable();
            if (mIHostapd == null) {
                Log.e(TAG, "Service hostapd wasn't found.");
                return false;
            }
            Log.i(TAG, "Obtained IHostApd binder.");

            try {
                IBinder serviceBinder = getServiceBinderMockable();
                if (serviceBinder == null) return false;
                mWaitForDeathLatch = null;
                serviceBinder.linkToDeath(new HostapdDeathRecipient(serviceBinder), /* flags= */ 0);
                setDebugParams();
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
                return false;
            }

            if (!registerCallback(new HostapdCallback())) {
                Log.e(TAG, "Failed to register callback, stopping hostapd AIDL startup");
                mIHostapd = null;
                return false;
            }
            return true;
        }
    }

    /**
     * Terminate the hostapd daemon & wait for it's death.
     */
    @Override
    public void terminate() {
        synchronized (mLock) {
            final String methodStr = "terminate";
            if (!checkHostapdAndLogFailure(methodStr)) {
                return;
            }
            Log.i(TAG, "Terminate HostApd Service.");
            try {
                mWaitForDeathLatch = new CountDownLatch(1);
                mIHostapd.terminate();
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
            }
        }

        // Now wait for death listener callback to confirm that it's dead.
        try {
            if (!mWaitForDeathLatch.await(WAIT_FOR_DEATH_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
                Log.w(TAG, "Timed out waiting for confirmation of hostapd death");
            } else {
                Log.d(TAG, "Got service death confirmation");
            }
        } catch (InterruptedException e) {
            Log.w(TAG, "Failed to wait for hostapd death");
        }
    }

    private void handleRemoteException(RemoteException e, String methodStr) {
        synchronized (mLock) {
            hostapdServiceDiedHandler(getServiceBinderMockable());
            Log.e(TAG, "IHostapd." + methodStr + " failed with exception", e);
        }
    }

    /**
     * Set the debug log level for hostapd.
     *
     * @return true if request is sent successfully, false otherwise.
     */
    private boolean setDebugParams() {
        synchronized (mLock) {
            final String methodStr = "setDebugParams";
            if (!checkHostapdAndLogFailure(methodStr)) {
                return false;
            }
            try {
                mIHostapd.setDebugParams(mVerboseHalLoggingEnabled
                        ? DebugLevel.DEBUG : DebugLevel.INFO);
                return true;
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
            } catch (ServiceSpecificException e) {
                handleServiceSpecificException(e, methodStr);
            }
            return false;
        }
    }

    private static int getEncryptionType(SoftApConfiguration localConfig) {
        int encryptionType;
        switch (localConfig.getSecurityType()) {
            case SoftApConfiguration.SECURITY_TYPE_OPEN:
                encryptionType = EncryptionType.NONE;
                break;
            case SoftApConfiguration.SECURITY_TYPE_WPA2_PSK:
                encryptionType = EncryptionType.WPA2;
                break;
            case SoftApConfiguration.SECURITY_TYPE_WPA3_SAE_TRANSITION:
                encryptionType = EncryptionType.WPA3_SAE_TRANSITION;
                break;
            case SoftApConfiguration.SECURITY_TYPE_WPA3_SAE:
                encryptionType = EncryptionType.WPA3_SAE;
                break;
            case SoftApConfiguration.SECURITY_TYPE_WPA3_OWE_TRANSITION:
                encryptionType = EncryptionType.WPA3_OWE_TRANSITION;
                break;
            case SoftApConfiguration.SECURITY_TYPE_WPA3_OWE:
                encryptionType = EncryptionType.WPA3_OWE;
                break;
            default:
                // We really shouldn't default to None, but this was how NetworkManagementService
                // used to do this.
                encryptionType = EncryptionType.NONE;
                break;
        }
        return encryptionType;
    }

    private static int getHalBandMask(int apBand) throws IllegalArgumentException {
        int bandMask = 0;

        if (!ApConfigUtil.isBandValid(apBand)) {
            throw new IllegalArgumentException();
        }

        if (ApConfigUtil.containsBand(apBand, SoftApConfiguration.BAND_2GHZ)) {
            bandMask |= BandMask.BAND_2_GHZ;
        }
        if (ApConfigUtil.containsBand(apBand, SoftApConfiguration.BAND_5GHZ)) {
            bandMask |= BandMask.BAND_5_GHZ;
        }
        if (ApConfigUtil.containsBand(apBand, SoftApConfiguration.BAND_6GHZ)) {
            bandMask |= BandMask.BAND_6_GHZ;
        }
        if (ApConfigUtil.containsBand(apBand, SoftApConfiguration.BAND_60GHZ)) {
            bandMask |= BandMask.BAND_60_GHZ;
        }

        return bandMask;
    }

   /**
     * Prepare the acsChannelFreqRangesMhz in ChannelParams.
     */
    private void prepareAcsChannelFreqRangesMhz(ChannelParams channelParams,
            @BandType int band, SoftApConfiguration config) {
        List<FrequencyRange> ranges = new ArrayList<>();
        if ((band & SoftApConfiguration.BAND_2GHZ) != 0) {
            ranges.addAll(toAcsFreqRanges(SoftApConfiguration.BAND_2GHZ, config));
        }
        if ((band & SoftApConfiguration.BAND_5GHZ) != 0) {
            ranges.addAll(toAcsFreqRanges(SoftApConfiguration.BAND_5GHZ, config));
        }
        if ((band & SoftApConfiguration.BAND_6GHZ) != 0) {
            ranges.addAll(toAcsFreqRanges(SoftApConfiguration.BAND_6GHZ, config));
        }
        channelParams.acsChannelFreqRangesMhz = ranges.toArray(
                new FrequencyRange[ranges.size()]);
    }

    /**
     * Convert OEM and SoftApConfiguration channel restrictions to a list of FreqRanges
     */
    private List<FrequencyRange> toAcsFreqRanges(@BandType int band, SoftApConfiguration config) {
        List<Integer> allowedChannelList;
        List<FrequencyRange> frequencyRanges = new ArrayList<>();

        if (!ApConfigUtil.isBandValid(band) || ApConfigUtil.isMultiband(band)) {
            Log.e(TAG, "Invalid band : " + band);
            return frequencyRanges;
        }

        String oemConfig;
        switch (band) {
            case SoftApConfiguration.BAND_2GHZ:
                oemConfig = mContext.getResources().getString(
                        R.string.config_wifiSoftap2gChannelList);
                break;
            case SoftApConfiguration.BAND_5GHZ:
                oemConfig = mContext.getResources().getString(
                        R.string.config_wifiSoftap5gChannelList);
                break;
            case SoftApConfiguration.BAND_6GHZ:
                oemConfig = mContext.getResources().getString(
                        R.string.config_wifiSoftap6gChannelList);
                break;
            default:
                return frequencyRanges;
        }

        allowedChannelList = ApConfigUtil.collectAllowedAcsChannels(band, oemConfig,
                SdkLevel.isAtLeastT()
                        ? config.getAllowedAcsChannels(band) : new int[] {});
        if (allowedChannelList.isEmpty()) {
            Log.e(TAG, "Empty list of allowed channels");
            return frequencyRanges;
        }
        Collections.sort(allowedChannelList);

        // Convert the sorted list to a set of frequency ranges
        boolean rangeStarted = false;
        int prevChannel = -1;
        FrequencyRange freqRange = null;
        for (int channel : allowedChannelList) {
            // Continuation of an existing frequency range
            if (rangeStarted) {
                if (channel == prevChannel + 1) {
                    prevChannel = channel;
                    continue;
                }

                // End of the existing frequency range
                freqRange.endMhz = ApConfigUtil.convertChannelToFrequency(prevChannel, band);
                frequencyRanges.add(freqRange);
                // We will continue to start a new frequency range
            }

            // Beginning of a new frequency range
            freqRange = new FrequencyRange();
            freqRange.startMhz = ApConfigUtil.convertChannelToFrequency(channel, band);
            rangeStarted = true;
            prevChannel = channel;
        }

        // End the last range
        freqRange.endMhz = ApConfigUtil.convertChannelToFrequency(prevChannel, band);
        frequencyRanges.add(freqRange);

        return frequencyRanges;
    }

    /**
     * Map hal bandwidth to SoftApInfo.
     *
     * @param bandwidth The channel bandwidth of the AP which is defined in the HAL.
     * @return The channel bandwidth in the SoftApinfo.
     */
    @VisibleForTesting
    public int mapHalChannelBandwidthToSoftApInfo(int channelBandwidth) {
        switch (channelBandwidth) {
            case ChannelBandwidth.BANDWIDTH_20_NOHT:
                return SoftApInfo.CHANNEL_WIDTH_20MHZ_NOHT;
            case ChannelBandwidth.BANDWIDTH_20:
                return SoftApInfo.CHANNEL_WIDTH_20MHZ;
            case ChannelBandwidth.BANDWIDTH_40:
                return SoftApInfo.CHANNEL_WIDTH_40MHZ;
            case ChannelBandwidth.BANDWIDTH_80:
                return SoftApInfo.CHANNEL_WIDTH_80MHZ;
            case ChannelBandwidth.BANDWIDTH_80P80:
                return SoftApInfo.CHANNEL_WIDTH_80MHZ_PLUS_MHZ;
            case ChannelBandwidth.BANDWIDTH_160:
                return SoftApInfo.CHANNEL_WIDTH_160MHZ;
            case ChannelBandwidth.BANDWIDTH_320:
                return SoftApInfo.CHANNEL_WIDTH_320MHZ;
            case ChannelBandwidth.BANDWIDTH_2160:
                return SoftApInfo.CHANNEL_WIDTH_2160MHZ;
            case ChannelBandwidth.BANDWIDTH_4320:
                return SoftApInfo.CHANNEL_WIDTH_4320MHZ;
            case ChannelBandwidth.BANDWIDTH_6480:
                return SoftApInfo.CHANNEL_WIDTH_6480MHZ;
            case ChannelBandwidth.BANDWIDTH_8640:
                return SoftApInfo.CHANNEL_WIDTH_8640MHZ;
            default:
                return SoftApInfo.CHANNEL_WIDTH_INVALID;
        }
    }

    /**
     * Map SoftApInfo bandwidth to hal.
     *
     * @param channelBandwidth The channel bandwidth as defined in SoftApInfo
     * @return The channel bandwidth as defined in hal
     */
    @VisibleForTesting
    public int mapSoftApInfoBandwidthToHal(@WifiAnnotations.Bandwidth int channelBandwidth) {
        switch (channelBandwidth) {
            case SoftApInfo.CHANNEL_WIDTH_AUTO:
                return ChannelBandwidth.BANDWIDTH_AUTO;
            case SoftApInfo.CHANNEL_WIDTH_20MHZ_NOHT:
                return ChannelBandwidth.BANDWIDTH_20_NOHT;
            case SoftApInfo.CHANNEL_WIDTH_20MHZ:
                return ChannelBandwidth.BANDWIDTH_20;
            case SoftApInfo.CHANNEL_WIDTH_40MHZ:
                return ChannelBandwidth.BANDWIDTH_40;
            case SoftApInfo.CHANNEL_WIDTH_80MHZ:
                return ChannelBandwidth.BANDWIDTH_80;
            case SoftApInfo.CHANNEL_WIDTH_80MHZ_PLUS_MHZ:
                return ChannelBandwidth.BANDWIDTH_80P80;
            case SoftApInfo.CHANNEL_WIDTH_160MHZ:
                return ChannelBandwidth.BANDWIDTH_160;
            case SoftApInfo.CHANNEL_WIDTH_320MHZ:
                return ChannelBandwidth.BANDWIDTH_320;
            case SoftApInfo.CHANNEL_WIDTH_2160MHZ:
                return ChannelBandwidth.BANDWIDTH_2160;
            case SoftApInfo.CHANNEL_WIDTH_4320MHZ:
                return ChannelBandwidth.BANDWIDTH_4320;
            case SoftApInfo.CHANNEL_WIDTH_6480MHZ:
                return ChannelBandwidth.BANDWIDTH_6480;
            case SoftApInfo.CHANNEL_WIDTH_8640MHZ:
                return ChannelBandwidth.BANDWIDTH_8640;
            default:
                return ChannelBandwidth.BANDWIDTH_INVALID;
        }
    }

    /**
     * Map hal generation to wifi standard.
     *
     * @param generation The operation mode of the AP which is defined in HAL.
     * @return The wifi standard in the ScanResult.
     */
    @VisibleForTesting
    public int mapHalGenerationToWifiStandard(int generation) {
        switch (generation) {
            case Generation.WIFI_STANDARD_LEGACY:
                return ScanResult.WIFI_STANDARD_LEGACY;
            case Generation.WIFI_STANDARD_11N:
                return ScanResult.WIFI_STANDARD_11N;
            case Generation.WIFI_STANDARD_11AC:
                return ScanResult.WIFI_STANDARD_11AC;
            case Generation.WIFI_STANDARD_11AX:
                return ScanResult.WIFI_STANDARD_11AX;
            case Generation.WIFI_STANDARD_11BE:
                return ScanResult.WIFI_STANDARD_11BE;
            case Generation.WIFI_STANDARD_11AD:
                return ScanResult.WIFI_STANDARD_11AD;
            default:
                return ScanResult.WIFI_STANDARD_UNKNOWN;
        }
    }

    private NetworkParams prepareNetworkParams(boolean isMetered,
            SoftApConfiguration config) {
        NetworkParams nwParams = new NetworkParams();
        ArrayList<Byte> ssid = NativeUtil.byteArrayToArrayList(config.getWifiSsid().getBytes());
        nwParams.ssid = new byte[ssid.size()];
        for (int i = 0; i < ssid.size(); i++) {
            nwParams.ssid[i] = ssid.get(i);
        }

        final List<ScanResult.InformationElement> elements = config.getVendorElementsInternal();
        int totalLen = 0;
        for (ScanResult.InformationElement e : elements) {
            totalLen += 2 + e.bytes.length; // 1 byte ID + 1 byte payload len + payload
        }
        nwParams.vendorElements = new byte[totalLen];
        int i = 0;
        for (ScanResult.InformationElement e : elements) {
            nwParams.vendorElements[i++] = (byte) e.id;
            nwParams.vendorElements[i++] = (byte) e.bytes.length;
            for (int j = 0; j < e.bytes.length; j++) {
                nwParams.vendorElements[i++] = e.bytes[j];
            }
        }

        nwParams.isMetered = isMetered;
        nwParams.isHidden = config.isHiddenSsid();
        nwParams.encryptionType = getEncryptionType(config);
        nwParams.passphrase = (config.getPassphrase() != null)
                    ? config.getPassphrase() : "";

        if (nwParams.ssid == null || nwParams.passphrase == null) {
            return null;
        }
        return nwParams;
    }

    private IfaceParams prepareIfaceParams(String ifaceName, SoftApConfiguration config)
            throws IllegalArgumentException {
        IfaceParams ifaceParams = new IfaceParams();
        ifaceParams.name = ifaceName;
        ifaceParams.hwModeParams = prepareHwModeParams(config);
        ifaceParams.channelParams = prepareChannelParamsList(config);
        if (ifaceParams.name == null || ifaceParams.hwModeParams == null
                || ifaceParams.channelParams == null) {
            return null;
        }
        return ifaceParams;
    }

    private HwModeParams prepareHwModeParams(SoftApConfiguration config) {
        HwModeParams hwModeParams = new HwModeParams();
        hwModeParams.enable80211N = true;
        hwModeParams.enable80211AC = mContext.getResources().getBoolean(
                R.bool.config_wifi_softap_ieee80211ac_supported);
        hwModeParams.enable80211AX = ApConfigUtil.isIeee80211axSupported(mContext);
        //Update 80211ax support with the configuration.
        hwModeParams.enable80211AX &= config.isIeee80211axEnabledInternal();
        hwModeParams.enable6GhzBand = ApConfigUtil.isBandSupported(
                SoftApConfiguration.BAND_6GHZ, mContext);
        hwModeParams.enableHeSingleUserBeamformer = mContext.getResources().getBoolean(
                R.bool.config_wifiSoftapHeSuBeamformerSupported);
        hwModeParams.enableHeSingleUserBeamformee = mContext.getResources().getBoolean(
                R.bool.config_wifiSoftapHeSuBeamformeeSupported);
        hwModeParams.enableHeMultiUserBeamformer = mContext.getResources().getBoolean(
                R.bool.config_wifiSoftapHeMuBeamformerSupported);
        hwModeParams.enableHeTargetWakeTime = mContext.getResources().getBoolean(
                R.bool.config_wifiSoftapHeTwtSupported);
        hwModeParams.enable80211BE = ApConfigUtil.isIeee80211beSupported(mContext);
        //Update 80211be support with the configuration.
        hwModeParams.enable80211BE &= config.isIeee80211beEnabledInternal();

        if (SdkLevel.isAtLeastT()) {
            hwModeParams.maximumChannelBandwidth =
                    mapSoftApInfoBandwidthToHal(config.getMaxChannelBandwidth());
        } else {
            hwModeParams.maximumChannelBandwidth = ChannelBandwidth.BANDWIDTH_AUTO;
        }
        return hwModeParams;
    }

    private ChannelParams[] prepareChannelParamsList(SoftApConfiguration config)
            throws IllegalArgumentException {
        int nChannels = 1;
        boolean repeatBand = false;
        if (SdkLevel.isAtLeastS()) {
            nChannels = config.getChannels().size();
        }
        if (config.getSecurityType()
                == SoftApConfiguration.SECURITY_TYPE_WPA3_OWE_TRANSITION) {
            nChannels = 2;
            repeatBand = true;
        }
        ChannelParams[] channelParamsList = new ChannelParams[nChannels];
        for (int i = 0; i < nChannels; i++) {
            int band = config.getBand();
            int channel = config.getChannel();
            if (SdkLevel.isAtLeastS() && !repeatBand) {
                band = config.getChannels().keyAt(i);
                channel = config.getChannels().valueAt(i);
            }
            channelParamsList[i] = new ChannelParams();
            channelParamsList[i].channel = channel;
            channelParamsList[i].enableAcs = ApConfigUtil.isAcsSupported(mContext)
                    && channel == 0;
            channelParamsList[i].bandMask = getHalBandMask(band);
            channelParamsList[i].acsChannelFreqRangesMhz = new FrequencyRange[0];
            if (channelParamsList[i].enableAcs) {
                channelParamsList[i].acsShouldExcludeDfs = !mContext.getResources()
                        .getBoolean(R.bool.config_wifiSoftapAcsIncludeDfs);
                if (ApConfigUtil.isSendFreqRangesNeeded(band, mContext, config)) {
                    prepareAcsChannelFreqRangesMhz(channelParamsList[i], band, config);
                }
            }
            if (channelParamsList[i].acsChannelFreqRangesMhz == null) {
                return null;
            }
        }
        return channelParamsList;
    }

    /**
     * Returns false if Hostapd is null, and logs failure to call methodStr
     */
    private boolean checkHostapdAndLogFailure(String methodStr) {
        synchronized (mLock) {
            if (mIHostapd == null) {
                Log.e(TAG, "Can't call " + methodStr + ", IHostapd is null");
                return false;
            }
            return true;
        }
    }

    /**
     * Logs failure for a service specific exception. Error codes are defined in HostapdStatusCode
     */
    private void handleServiceSpecificException(
            ServiceSpecificException exception, String methodStr) {
        synchronized (mLock) {
            Log.e(TAG, "IHostapd." + methodStr + " failed: " + exception.toString());
        }
    }

    /**
     * Dump information about the AIDL implementation.
     *
     * TODO (b/202302891) Log version information once we freeze the AIDL interface
     */
    public void dump(PrintWriter pw) {
        pw.println("AIDL interface version: 1 (initial)");
    }
}