apps/CtsVerifier/src/com/android/cts/verifier/p2p/testcase/P2pBroadcastReceiverTest.java

/*
 * Copyright (C) 2012 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.cts.verifier.p2p.testcase;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pInfo;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager.Channel;
import android.net.wifi.p2p.WifiP2pManager.PeerListListener;
import android.util.Log;

/**
 * The utility class for testing wifi direct broadcast intent.
 */
public class P2pBroadcastReceiverTest extends BroadcastReceiver
    implements PeerListListener {

    private static final String TAG = "P2pBroadcastReceiverTest";

    private final IntentFilter mIntentFilter = new IntentFilter();
    private Context mContext;
    private WifiP2pManager mP2pMgr;
    private Channel mChannel;

    private WifiP2pDeviceList mPeers;
    private WifiP2pInfo mP2pInfo;

    public P2pBroadcastReceiverTest(Context context) {
        this.mContext = context;
        mP2pMgr = (WifiP2pManager) context.getSystemService(Context.WIFI_P2P_SERVICE);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
    }

    public void init(Channel c) {
        mChannel = c;
        mContext.registerReceiver(this, mIntentFilter);
    }

    public synchronized void close() {
        mContext.unregisterReceiver(this);
        notifyAll();
    }

    /**
     * Wait until the specified target device is found.
     *
     * @param targetAddr the p2p device address of the target device.
     * @param msec timeout value.
     * @return the found device. Return null if the target device is not found
     * within the given timeout.
     * @throws InterruptedException
     */
    public synchronized WifiP2pDevice waitDeviceFound(String targetAddr, long msec)
            throws InterruptedException {

        Timeout t = new Timeout(msec);
        while (!t.isTimeout()) {
            if (mPeers != null) {
                for (WifiP2pDevice dev: mPeers.getDeviceList()) {
                    if (dev.deviceAddress.equals(targetAddr)) {
                        return dev;
                    }
                }
            }
            wait(t.getRemainTime());
        }
        Log.e(TAG, "Appropriate WIFI_P2P_PEERS_CHANGED_ACTION didn't occur");

        return null;
    }

    /**
     * Wait until a p2p group is created.
     *
     * @param msec timeout value
     * @return a established p2p information. Return null if a connection is NOT
     * established within the given timeout.
     * @throws InterruptedException
     */
    public synchronized WifiP2pInfo waitConnectionNotice(long msec) throws InterruptedException {
        Timeout t = new Timeout(msec);
        while (!t.isTimeout()) {
            if (mP2pInfo != null && mP2pInfo.groupFormed) {
                return mP2pInfo;
            }
            wait(t.getRemainTime());
        }
        Log.e(TAG, "Appropriate WIFI_P2P_CONNECTION_CHANGED_ACTION didn't occur");

        return null;
    }

    /**
     * Wait until a station gets connected.
     * @param msec
     * @return
     * @throws InterruptedException
     */
    public synchronized boolean waitPeerConnected(String targetAddr, long msec)
            throws InterruptedException {

        Timeout t = new Timeout(msec);
        while (!t.isTimeout()) {
            if (mPeers != null) {
                for (WifiP2pDevice dev: mPeers.getDeviceList()) {
                    if (dev.deviceAddress.equals(targetAddr)) {
                        if (dev.status == WifiP2pDevice.CONNECTED) {
                            return true;
                        }
                    }
                }
            }
            wait(t.getRemainTime());
        }
        Log.e(TAG, "Appropriate WIFI_P2P_PEERS_CHANGED_ACTION didn't occur");

        return false;
    }

    /**
     * Wait until a station gets disconnected.
     * @param msec
     * @return
     * @throws InterruptedException
     */
    public synchronized boolean waitPeerDisconnected(String targetAddr, long msec)
            throws InterruptedException {

        Timeout t = new Timeout(msec);

        boolean devicePresent;

        while (!t.isTimeout()) {
            devicePresent = false;
            if (mPeers != null) {
                for (WifiP2pDevice dev: mPeers.getDeviceList()) {
                    if (dev.deviceAddress.equals(targetAddr)) {
                        if (dev.status != WifiP2pDevice.CONNECTED) {
                            return true;
                        }
                        devicePresent = true;
                    }
                }
            }
            if (!devicePresent) return true;
            wait(t.getRemainTime());
        }
        Log.e(TAG, "Appropriate WIFI_P2P_PEERS_CHANGED_ACTION didn't occur");

        return false;
    }

    /**
     * Wait until a connection is disconnected.
     *
     * @param msec timeout value.
     * @return a disconnected p2p information. Return null if a connection is NOT disconnected
     * within the given timeout.
     * @throws InterruptedException
     */
    public synchronized WifiP2pInfo waitDisconnectionNotice(long msec) throws InterruptedException {
        Timeout t = new Timeout(msec);
        while (!t.isTimeout()) {
            if (mP2pInfo != null && !mP2pInfo.groupFormed) {
                return mP2pInfo;
            }
            wait(t.getRemainTime());
        }
        Log.e(TAG, "WIFI_P2P_CONNECTION_CHANGED_ACTION didn't occur");

        return null;
    }


    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) {
            Log.d(TAG, "WIFI_P2P_PEERS_CHANGED_ACTION");
            mP2pMgr.requestPeers(mChannel, this);
        } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) {
            Log.d(TAG, "WIFI_P2P_CONNECTION_CHANGED_ACTION");
            synchronized(this) {
                mP2pInfo = (WifiP2pInfo)intent.getParcelableExtra(
                        WifiP2pManager.EXTRA_WIFI_P2P_INFO);
                notifyAll();
            }
        }
    }

    @Override
    public synchronized void onPeersAvailable(WifiP2pDeviceList peers) {
        Log.d(TAG, "onPeersAvailable()");
        mPeers = peers;
        notifyAll();
    }
}