path: root/wifi/java/android/net/wifi/passpoint/WifiPasspointManager.java

/*
 * Copyright (C) 2014 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 android.net.wifi.passpoint;

import android.content.Context;
import android.net.wifi.ScanResult;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.Messenger;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.RemoteException;
import android.util.Log;

import com.android.internal.util.AsyncChannel;
import com.android.internal.util.Protocol;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

/**
 * Provides APIs for managing Wifi Passpoint credentials.
 * @hide
 */
public class WifiPasspointManager {

    private static final String TAG = "PasspointManager";

    private static final boolean DBG = true;

    /* Passpoint states values */

    /** Passpoint is in an unknown state. This should only occur in boot time */
    public static final int PASSPOINT_STATE_UNKNOWN = 0;

    /** Passpoint is disabled. This occurs when wifi is disabled */
    public static final int PASSPOINT_STATE_DISABLED = 1;

    /** Passpoint is enabled and in discovery state */
    public static final int PASSPOINT_STATE_DISCOVERY = 2;

    /** Passpoint is enabled and in access state */
    public static final int PASSPOINT_STATE_ACCESS = 3;

    /** Passpoint is enabled and in provisioning state */
    public static final int PASSPOINT_STATE_PROVISION = 4;

    /* Passpoint callback error codes */

    /** Indicates that the operation failed due to an internal error */
    public static final int REASON_ERROR = 0;

    /** Indicates that the operation failed because wifi is disabled */
    public static final int REASON_WIFI_DISABLED = 1;

    /** Indicates that the operation failed because the framework is busy */
    public static final int REASON_BUSY = 2;

    /** Indicates that the operation failed because parameter is invalid */
    public static final int REASON_INVALID_PARAMETER = 3;

    /** Indicates that the operation failed because the server is not trusted */
    public static final int REASON_NOT_TRUSTED = 4;

    /**
     * protocol supported for Passpoint
     */
    public static final String PROTOCOL_DM = "OMA-DM-ClientInitiated";

    /**
     * protocol supported for Passpoint
     */
    public static final String PROTOCOL_SOAP = "SPP-ClientInitiated";

    /* Passpoint broadcasts */

    /**
     * Broadcast intent action indicating that the state of Passpoint
     * connectivity has changed
     */
    public static final String PASSPOINT_STATE_CHANGED_ACTION =
            "android.net.wifi.passpoint.STATE_CHANGE";

    /**
     * Broadcast intent action indicating that the saved Passpoint credential
     * list has changed
     */
    public static final String PASSPOINT_CRED_CHANGED_ACTION =
            "android.net.wifi.passpoint.CRED_CHANGE";

    /**
     * Broadcast intent action indicating that Passpoint online sign up is
     * avaiable.
     */
    public static final String PASSPOINT_OSU_AVAILABLE_ACTION =
            "android.net.wifi.passpoint.OSU_AVAILABLE";

    /**
     * Broadcast intent action indicating that user remediation is required
     */
    public static final String PASSPOINT_USER_REM_REQ_ACTION =
            "android.net.wifi.passpoint.USER_REM_REQ";

    /**
     * Interface for callback invocation when framework channel is lost
     */
    public interface ChannelListener {
        /**
         * The channel to the framework has been disconnected. Application could
         * try re-initializing using {@link #initialize}
         */
        public void onChannelDisconnected();
    }

    /**
     * Interface for callback invocation on an application action
     */
    public interface ActionListener {
        /** The operation succeeded */
        public void onSuccess();

        /**
         * The operation failed
         *
         * @param reason The reason for failure could be one of
         *            {@link #WIFI_DISABLED}, {@link #ERROR} or {@link #BUSY}
         */
        public void onFailure(int reason);
    }

    /**
     * Interface for callback invocation when doing OSU or user remediation
     */
    public interface OsuRemListener {
        /** The operation succeeded */
        public void onSuccess();

        /**
         * The operation failed
         *
         * @param reason The reason for failure could be one of
         *            {@link #WIFI_DISABLED}, {@link #ERROR} or {@link #BUSY}
         */
        public void onFailure(int reason);

        /**
         * Browser launch is requried for user interaction. When this callback
         * is called, app should launch browser / webview to the given URI.
         *
         * @param uri URI for browser launch
         */
        public void onBrowserLaunch(String uri);

        /**
         * When this is called, app should dismiss the previously lanched browser.
         */
        public void onBrowserDismiss();
    }

    /**
     * A channel that connects the application to the wifi passpoint framework.
     * Most passpoint operations require a Channel as an argument.
     * An instance of Channel is obtained by doing a call on {@link #initialize}
     */
    public static class Channel {
        private final static int INVALID_LISTENER_KEY = 0;

        private ChannelListener mChannelListener;

        private HashMap<Integer, Object> mListenerMap = new HashMap<Integer, Object>();
        private HashMap<Integer, Integer> mListenerMapCount = new HashMap<Integer, Integer>();
        private Object mListenerMapLock = new Object();
        private int mListenerKey = 0;

        private List<ScanResult> mAnqpRequest = new LinkedList<ScanResult>();
        private Object mAnqpRequestLock = new Object();

        private AsyncChannel mAsyncChannel;
        private PasspointHandler mHandler;
        Context mContext;

        Channel(Context context, Looper looper, ChannelListener l) {
            mAsyncChannel = new AsyncChannel();
            mHandler = new PasspointHandler(looper);
            mChannelListener = l;
            mContext = context;
        }

        private int putListener(Object listener) {
            return putListener(listener, 1);
        }

        private int putListener(Object listener, int count) {
            if (listener == null || count <= 0)
                return INVALID_LISTENER_KEY;
            int key;
            synchronized (mListenerMapLock) {
                do {
                    key = mListenerKey++;
                } while (key == INVALID_LISTENER_KEY);
                mListenerMap.put(key, listener);
                mListenerMapCount.put(key, count);
            }
            return key;
        }

        private Object peekListener(int key) {
            Log.d(TAG, "peekListener() key=" + key);
            if (key == INVALID_LISTENER_KEY)
                return null;
            synchronized (mListenerMapLock) {
                return mListenerMap.get(key);
            }
        }


        private Object getListener(int key, boolean forceRemove) {
            Log.d(TAG, "getListener() key=" + key + " force=" + forceRemove);
            if (key == INVALID_LISTENER_KEY)
                return null;
            synchronized (mListenerMapLock) {
                if (!forceRemove) {
                    int count = mListenerMapCount.get(key);
                    Log.d(TAG, "count=" + count);
                    mListenerMapCount.put(key, --count);
                    if (count > 0)
                        return null;
                }
                Log.d(TAG, "remove key");
                mListenerMapCount.remove(key);
                return mListenerMap.remove(key);
            }
        }

        private void anqpRequestStart(ScanResult sr) {
            Log.d(TAG, "anqpRequestStart sr.bssid=" + sr.BSSID);
            synchronized (mAnqpRequestLock) {
                mAnqpRequest.add(sr);
            }
        }

        private void anqpRequestFinish(WifiPasspointInfo result) {
            Log.d(TAG, "anqpRequestFinish pi.bssid=" + result.bssid);
            synchronized (mAnqpRequestLock) {
                for (ScanResult sr : mAnqpRequest)
                    if (sr.BSSID.equals(result.bssid)) {
                        Log.d(TAG, "find hit " + result.bssid);
                        /* sr.passpoint = result; */
                        mAnqpRequest.remove(sr);
                        Log.d(TAG, "mAnqpRequest.len=" + mAnqpRequest.size());
                        break;
                    }
            }
        }

        private void anqpRequestFinish(ScanResult sr) {
            Log.d(TAG, "anqpRequestFinish sr.bssid=" + sr.BSSID);
            synchronized (mAnqpRequestLock) {
                for (ScanResult sr1 : mAnqpRequest)
                    if (sr1.BSSID.equals(sr.BSSID)) {
                        mAnqpRequest.remove(sr1);
                        break;
                    }
            }
        }

        class PasspointHandler extends Handler {
            PasspointHandler(Looper looper) {
                super(looper);
            }

            @Override
            public void handleMessage(Message message) {
                Object listener = null;

                switch (message.what) {
                    case AsyncChannel.CMD_CHANNEL_DISCONNECTED:
                        if (mChannelListener != null) {
                            mChannelListener.onChannelDisconnected();
                            mChannelListener = null;
                        }
                        break;

                    case REQUEST_ANQP_INFO_SUCCEEDED:
                        WifiPasspointInfo result = (WifiPasspointInfo) message.obj;
                        anqpRequestFinish(result);
                        listener = getListener(message.arg2, false);
                        if (listener != null) {
                            ((ActionListener) listener).onSuccess();
                        }
                        break;

                    case REQUEST_ANQP_INFO_FAILED:
                        anqpRequestFinish((ScanResult) message.obj);
                        listener = getListener(message.arg2, false);
                        if (listener == null)
                            getListener(message.arg2, true);
                        if (listener != null) {
                            ((ActionListener) listener).onFailure(message.arg1);
                        }
                        break;

                    case START_OSU_SUCCEEDED:
                        listener = getListener(message.arg2, true);
                        if (listener != null) {
                            ((OsuRemListener) listener).onSuccess();
                        }
                        break;

                    case START_OSU_FAILED:
                        listener = getListener(message.arg2, true);
                        if (listener != null) {
                            ((OsuRemListener) listener).onFailure(message.arg1);
                        }
                        break;

                    case START_OSU_BROWSER:
                        listener = peekListener(message.arg2);
                        if (listener != null) {
                            ParcelableString str = (ParcelableString) message.obj;
                            if (str == null || str.string == null)
                                ((OsuRemListener) listener).onBrowserDismiss();
                            else
                                ((OsuRemListener) listener).onBrowserLaunch(str.string);
                        }
                        break;

                    default:
                        Log.d(TAG, "Ignored " + message);
                        break;
                }
            }
        }

    }

    public static class ParcelableString implements Parcelable {
        public String string;

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(Parcel out, int flags) {
            out.writeString(string);
        }

        public static final Parcelable.Creator<ParcelableString> CREATOR =
                new Parcelable.Creator<ParcelableString>() {
                    @Override
                    public ParcelableString createFromParcel(Parcel in) {
                        ParcelableString ret = new ParcelableString();
                        ret.string = in.readString();
                        return ret;
                    }
                    @Override
                    public ParcelableString[] newArray(int size) {
                        return new ParcelableString[size];
                    }
        };
    }

    private static final int BASE = Protocol.BASE_WIFI_PASSPOINT_MANAGER;

    public static final int REQUEST_ANQP_INFO                   = BASE + 1;
    public static final int REQUEST_ANQP_INFO_FAILED            = BASE + 2;
    public static final int REQUEST_ANQP_INFO_SUCCEEDED         = BASE + 3;
    public static final int REQUEST_OSU_ICON                    = BASE + 4;
    public static final int REQUEST_OSU_ICON_FAILED             = BASE + 5;
    public static final int REQUEST_OSU_ICON_SUCCEEDED          = BASE + 6;
    public static final int START_OSU                           = BASE + 7;
    public static final int START_OSU_BROWSER                   = BASE + 8;
    public static final int START_OSU_FAILED                    = BASE + 9;
    public static final int START_OSU_SUCCEEDED                 = BASE + 10;

    private Context mContext;
    IWifiPasspointManager mService;

    /**
     * TODO: doc
     * @param context
     * @param service
     */
    public WifiPasspointManager(Context context, IWifiPasspointManager service) {
        mContext = context;
        mService = service;
    }

    /**
     * Registers the application with the framework. This function must be the
     * first to be called before any async passpoint operations are performed.
     *
     * @param srcContext is the context of the source
     * @param srcLooper is the Looper on which the callbacks are receivied
     * @param listener for callback at loss of framework communication. Can be
     *            null.
     * @return Channel instance that is necessary for performing any further
     *         passpoint operations
     *
     */
    public Channel initialize(Context srcContext, Looper srcLooper, ChannelListener listener) {
        Messenger messenger = getMessenger();
        if (messenger == null)
            return null;

        Channel c = new Channel(srcContext, srcLooper, listener);
        if (c.mAsyncChannel.connectSync(srcContext, c.mHandler, messenger)
                == AsyncChannel.STATUS_SUCCESSFUL) {
            return c;
        } else {
            return null;
        }
    }

    /**
     * STOPSHIP: temp solution, should use supplicant manager instead, check
     * with b/13931972
     */
    public Messenger getMessenger() {
        try {
            return mService.getMessenger();
        } catch (RemoteException e) {
            return null;
        }
    }

    public int getPasspointState() {
        try {
            return mService.getPasspointState();
        } catch (RemoteException e) {
            return PASSPOINT_STATE_UNKNOWN;
        }
    }

    public void requestAnqpInfo(Channel c, List<ScanResult> requested, int mask,
            ActionListener listener) {
        Log.d(TAG, "requestAnqpInfo start");
        Log.d(TAG, "requested.size=" + requested.size());
        checkChannel(c);
        List<ScanResult> list = new ArrayList<ScanResult>();
        for (ScanResult sr : requested)
            if (sr.capabilities.contains("[HS20]")) {
                list.add(sr);
                c.anqpRequestStart(sr);
                Log.d(TAG, "adding " + sr.BSSID);
            }
        int count = list.size();
        Log.d(TAG, "after filter, count=" + count);
        if (count == 0) {
            if (DBG)
                Log.d(TAG, "ANQP info request contains no HS20 APs, skipped");
            listener.onSuccess();
            return;
        }
        int key = c.putListener(listener, count);
        for (ScanResult sr : list)
            c.mAsyncChannel.sendMessage(REQUEST_ANQP_INFO, mask, key, sr);
        Log.d(TAG, "requestAnqpInfo end");
    }

    public void requestOsuIcons(Channel c, List<WifiPasspointOsuProvider> requested,
            int resolution, ActionListener listener) {
    }

    public List<WifiPasspointPolicy> requestCredentialMatch(List<ScanResult> requested) {
        try {
            return mService.requestCredentialMatch(requested);
        } catch (RemoteException e) {
            return null;
        }
    }

    /**
     * Get a list of saved Passpoint credentials. Only those credentials owned
     * by the caller will be returned.
     *
     * @return The list of credentials
     */
    public List<WifiPasspointCredential> getCredentials() {
        try {
            return mService.getCredentials();
        } catch (RemoteException e) {
            return null;
        }
    }

    /**
     * Add a new Passpoint credential.
     *
     * @param cred The credential to be added
     * @return {@code true} if the operation succeeds, {@code false} otherwise
     */
    public boolean addCredential(WifiPasspointCredential cred) {
        try {
            return mService.addCredential(cred);
        } catch (RemoteException e) {
            return false;
        }
    }

    /**
     * Update an existing Passpoint credential. Only system or the owner of this
     * credential has the permission to do this.
     *
     * @param cred The credential to be updated
     * @return {@code true} if the operation succeeds, {@code false} otherwise
     */
    public boolean updateCredential(WifiPasspointCredential cred) {
        try {
            return mService.updateCredential(cred);
        } catch (RemoteException e) {
            return false;
        }
    }

    /**
     * Remove an existing Passpoint credential. Only system or the owner of this
     * credential has the permission to do this.
     *
     * @param cred The credential to be removed
     * @return {@code true} if the operation succeeds, {@code false} otherwise
     */
    public boolean removeCredential(WifiPasspointCredential cred) {
        try {
            return mService.removeCredential(cred);
        } catch (RemoteException e) {
            return false;
        }
    }

    public void startOsu(Channel c, WifiPasspointOsuProvider osu, OsuRemListener listener) {
        Log.d(TAG, "startOsu start");
        checkChannel(c);
        int key = c.putListener(listener);
        c.mAsyncChannel.sendMessage(START_OSU, 0, key, osu);
        Log.d(TAG, "startOsu end");
    }

    public void startRemediation(Channel c, OsuRemListener listener) {
    }

    public void connect(WifiPasspointPolicy policy) {
    }

    private static void checkChannel(Channel c) {
        if (c == null) throw new IllegalArgumentException("Channel needs to be initialized");
    }
}