/**
**
** Copyright 2006, 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.development;

import android.app.Activity;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.ConnectivityManager.NetworkCallback;
import android.net.EthernetManager;
import android.net.IpConfiguration;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.Message;
import android.os.IBinder;
import android.os.INetworkManagementService;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.util.SparseArray;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.TextView;

import libcore.io.IoUtils;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.Proxy;
import java.net.Socket;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
import static android.net.NetworkCapabilities.*;

import com.android.internal.util.MessageUtils;

public class Connectivity extends Activity {
    private static final String TAG = "DevToolsConnectivity";
    private static final String GET_SCAN_RES = "Get Results";
    private static final String START_SCAN = "Start Scan";
    private static final String PROGRESS_SCAN = "In Progress";

    private static final long SCAN_CYCLES = 15;

    private static final int EVENT_TOGGLE_WIFI = 1;
    private static final int EVENT_TOGGLE_SCREEN = 2;

    private EditText mDCOnDurationEdit;
    private EditText mDCOffDurationEdit;
    private TextView mDCCycleCountView;
    private long mDCOnDuration = 120000;
    private long mDCOffDuration = 120000;
    private int mDCCycleCount = 0;

    private EditText mSCOnDurationEdit;
    private EditText mSCOffDurationEdit;
    private TextView mSCCycleCountView;
    private long mSCOnDuration = 120000;
    private long mSCOffDuration = 12000;
    private int mSCCycleCount = 0;

    private boolean mDelayedCycleStarted = false;

    private Button mScanButton;
    private TextView mScanResults;
    private EditText mScanCyclesEdit;
    private CheckBox mScanDisconnect;
    private long mScanCycles = SCAN_CYCLES;
    private long mScanCur = -1;
    private long mStartTime = -1;
    private long mStopTime;
    private long mTotalScanTime = 0;
    private long mTotalScanCount = 0;

    private TextView mLinkStatsResults;
    private TextView mHttpRequestResults;

    private String mTdlsAddr = null;

    private WifiManager mWm;
    private WifiManager.MulticastLock mWml;
    private PowerManager mPm;
    private ConnectivityManager mCm;
    private INetworkManagementService mNetd;
    private EthernetManager mEm;

    private WifiScanReceiver mScanRecv;
    IntentFilter mIntentFilter;

    private WakeLock mWakeLock = null;
    private WakeLock mScreenonWakeLock = null;

    private boolean mScreenOffToggleRunning = false;
    private boolean mScreenOff = false;

    private static final String CONNECTIVITY_TEST_ALARM =
            "com.android.development.CONNECTIVITY_TEST_ALARM";
    private static final String TEST_ALARM_EXTRA = "CONNECTIVITY_TEST_EXTRA";
    private static final String TEST_ALARM_ON_EXTRA = "CONNECTIVITY_TEST_ON_EXTRA";
    private static final String TEST_ALARM_OFF_EXTRA = "CONNECTIVITY_TEST_OFF_EXTRA";
    private static final String TEST_ALARM_CYCLE_EXTRA = "CONNECTIVITY_TEST_CYCLE_EXTRA";
    private static final String SCREEN_ON = "SCREEN_ON";
    private static final String SCREEN_OFF = "SCREEN_OFF";

    private static final String NETWORK_CONDITIONS_MEASURED =
            "android.net.conn.NETWORK_CONDITIONS_MEASURED";

    private void logBroadcast(Intent intent) {
        StringBuilder sb = new StringBuilder();
        Bundle b = intent.getExtras();
        for (String key : b.keySet()) {
            sb.append(String.format(" %s=%s", key, b.get(key)));
        }
        Log.d(TAG, "Got broadcast " + intent.getAction() + " extras:" + sb.toString());
    }

    public BroadcastReceiver mReceiver = new BroadcastReceiver() {
        public void onReceive(Context context, Intent intent) {
            logBroadcast(intent);

            if (intent.getAction().equals(CONNECTIVITY_TEST_ALARM)) {
                String extra = (String)intent.getExtra(TEST_ALARM_EXTRA);
                PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
                Long on = new Long(120000);
                Long off = new Long(120000);
                int cycle = 0;
                try {
                    on = Long.parseLong((String)intent.getExtra(TEST_ALARM_ON_EXTRA));
                    off = Long.parseLong((String)intent.getExtra(TEST_ALARM_OFF_EXTRA));
                    cycle = Integer.parseInt((String)intent.getExtra(TEST_ALARM_CYCLE_EXTRA));
                } catch (Exception e) {}

                if (extra.equals(SCREEN_ON)) {
                    mScreenonWakeLock = mPm.newWakeLock(PowerManager.FULL_WAKE_LOCK |
                            PowerManager.ACQUIRE_CAUSES_WAKEUP,
                            "ConnectivityTest");
                    mScreenonWakeLock.acquire();

                    mSCCycleCount = cycle+1;
                    mSCOnDuration = on;
                    mSCOffDuration = off;
                    mSCCycleCountView.setText(Integer.toString(mSCCycleCount));

                    scheduleAlarm(mSCOnDuration, SCREEN_OFF);
                } else if (extra.equals(SCREEN_OFF)) {

                    mSCCycleCount = cycle;
                    mSCOnDuration = on;
                    mSCOffDuration = off;

                    mScreenonWakeLock.release();
                    mScreenonWakeLock = null;
                    scheduleAlarm(mSCOffDuration, SCREEN_ON);
                    pm.goToSleep(SystemClock.uptimeMillis());
                }
            }
        }
    };

    public Handler mHandler2 = new Handler() {
        public void handleMessage(Message msg) {
            switch(msg.what) {
                case EVENT_TOGGLE_WIFI:
                    Log.e(TAG, "EVENT_TOGGLE_WIFI");
                    if (mDelayedCycleStarted && mWm != null) {
                        long delay;
                        switch (mWm.getWifiState()) {
                            case WifiManager.WIFI_STATE_ENABLED:
                            case WifiManager.WIFI_STATE_ENABLING:
                                mWm.setWifiEnabled(false);
                                delay = mDCOffDuration;
                                break;
                            default:
                                mWm.setWifiEnabled(true);
                                delay = mDCOnDuration;
                                mDCCycleCount++;
                                mDCCycleCountView.setText(Integer.toString(mDCCycleCount));
                        }
                        sendMessageDelayed(obtainMessage(EVENT_TOGGLE_WIFI),
                                delay);
                    }
                    break;
            }
        }
    };

   /**
     * Wifi Scan Listener
     */
    private class WifiScanReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();

            if (action.equals(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) {
                mStopTime = SystemClock.elapsedRealtime();
                if (mStartTime != -1) {
                    mTotalScanTime += (mStopTime - mStartTime);
                    mStartTime = -1;
                }
                Log.d(TAG, "Scan: READY " + mScanCur);
                mScanResults.setVisibility(View.INVISIBLE);

                List<ScanResult> wifiScanResults = mWm.getScanResults();
                if (wifiScanResults != null) {
                    mTotalScanCount += wifiScanResults.size();
                    mScanResults.setText("Current scan = " + Long.toString(wifiScanResults.size()));
                    mScanResults.setVisibility(View.VISIBLE);
                    Log.d(TAG, "Scan: Results = " + wifiScanResults.size());
                }

                mScanCur--;
                mScanCyclesEdit.setText(Long.toString(mScanCur));
                if (mScanCur == 0) {
                    unregisterReceiver(mScanRecv);
                    mScanButton.setText(GET_SCAN_RES);
                    mScanResults.setVisibility(View.INVISIBLE);
                } else {
                    Log.d(TAG, "Scan: START " + mScanCur);
                    mStartTime = SystemClock.elapsedRealtime();
                    mWm.startScan();
                }
            }
        }
    }

    private static class DevToolsNetworkCallback extends NetworkCallback {
        private static final String TAG = "DevToolsNetworkCallback";

        public void onAvailable(Network network) {
            Log.d(TAG, "onAvailable: " + network);
        }

        public void onCapabilitiesChanged(Network network, NetworkCapabilities nc) {
            Log.d(TAG, "onCapabilitiesChanged: " + network + " " + nc.toString());
        }

        public void onLinkPropertiesChanged(Network network, LinkProperties lp) {
            Log.d(TAG, "onLinkPropertiesChanged: " + network + " " + lp.toString());
        }

        public void onLosing(Network network, int maxMsToLive) {
            Log.d(TAG, "onLosing: " + network + " " + maxMsToLive);
        }

        public void onLost(Network network) {
            Log.d(TAG, "onLost: " + network);
        }
    }
    private DevToolsNetworkCallback mCallback;

    private class RequestableNetwork {
        private final NetworkRequest mRequest;
        private final int mRequestButton, mReleaseButton, mProgressBar;
        private NetworkCallback mCallback;
        private Network mNetwork;

        public RequestableNetwork(NetworkRequest request, int requestButton, int releaseButton,
                int progressBar) {
            mRequest = request;
            mRequestButton = requestButton;
            mReleaseButton = releaseButton;
            mProgressBar = progressBar;
        }

        public RequestableNetwork(int capability, int requestButton, int releaseButton,
                int progressBar) {
            this(new NetworkRequest.Builder()
                    .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
                    .addCapability(capability)
                    .build(),
                    requestButton, releaseButton, progressBar);
        }

        public void addOnClickListener() {
            findViewById(mRequestButton).setOnClickListener(
                    new View.OnClickListener() { public void onClick(View v) { request(); }});
            findViewById(mReleaseButton).setOnClickListener(
                    new View.OnClickListener() { public void onClick(View v) { release(); }});
        }

        public void setRequested(boolean requested) {
            findViewById(mRequestButton).setEnabled(!requested);
            findViewById(mReleaseButton).setEnabled(requested);
            findViewById(mProgressBar).setVisibility(
                    requested ? View.VISIBLE : View.GONE);
        }

        public void request() {
            if (mCallback == null) {
                mCallback = new NetworkCallback() {
                    @Override
                    public void onAvailable(Network network) {
                        mNetwork = network;
                        onHttpRequestResults(null);
                        runOnUiThread(() -> findViewById(mProgressBar).setVisibility(View.GONE));
                    }
                    @Override
                    public void onLost(Network network) {
                        mNetwork = null;
                        onHttpRequestResults(null);
                    }
                };
                mCm.requestNetwork(mRequest, mCallback);
                setRequested(true);
            }
        }

        public void release() {
            if (mCallback != null) {
                mNetwork = null;
                onHttpRequestResults(null);
                mCm.unregisterNetworkCallback(mCallback);
                mCallback = null;
                setRequested(false);
            }
        }

        public Network getNetwork() {
            return mNetwork;
        }
    }

    private final ArrayList<RequestableNetwork> mRequestableNetworks = new ArrayList<>();
    private final RequestableNetwork mBoundTestNetwork;
    private boolean mRequestRunning;

    private void addRequestableNetwork(RequestableNetwork network) {
        mRequestableNetworks.add(network);
    }

    private void addRequestableNetwork(int capability, int requestButton, int releaseButton,
            int progressBar) {
        mRequestableNetworks.add(new RequestableNetwork(capability, requestButton, releaseButton,
                progressBar));
    }

    private static class DevToolsEthListener implements EthernetManager.InterfaceStateListener {
        private static final String TAG = DevToolsEthListener.class.getSimpleName();

        private static final SparseArray<String> STATE_NAMES = MessageUtils.findMessageNames(
                new Class[]{EthernetManager.class}, new String[]{"STATE_"});

        private static final SparseArray<String> ROLE_NAMES = MessageUtils.findMessageNames(
                new Class[]{EthernetManager.class}, new String[]{"ROLE_"});

        private String stateName(int state) {
            return STATE_NAMES.get(state, Integer.toString(state));
        }

        private String roleName(int role) {
            return ROLE_NAMES.get(role, Integer.toString(role));
        }

        @Override
        public void onInterfaceStateChanged(String iface, int state, int role,
                IpConfiguration configuration) {
            Log.d(TAG, iface + " " + stateName(state) + " " + roleName(role)
                    + " " + configuration);
        }
    }

    private final DevToolsEthListener mEthListener = new DevToolsEthListener();

    public Connectivity() {
        super();
        addRequestableNetwork(NET_CAPABILITY_MMS, R.id.request_mms, R.id.release_mms,
                R.id.mms_progress);
        addRequestableNetwork(NET_CAPABILITY_SUPL, R.id.request_supl, R.id.release_supl,
                R.id.supl_progress);
        addRequestableNetwork(NET_CAPABILITY_INTERNET, R.id.request_cell, R.id.release_cell,
                R.id.cell_progress);

        // Make bound requests use cell data.
        mBoundTestNetwork = mRequestableNetworks.get(mRequestableNetworks.size() - 1);

        NetworkRequest wifiRequest = new NetworkRequest.Builder()
            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
            .build();
        addRequestableNetwork(new RequestableNetwork(wifiRequest,
                R.id.request_wifi, R.id.release_wifi, R.id.wifi_progress));
    }

    final NetworkRequest mEmptyRequest = new NetworkRequest.Builder().clearCapabilities().build();

    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);

        setContentView(R.layout.connectivity);

        mWm = (WifiManager)getSystemService(Context.WIFI_SERVICE);
        mWml = mWm.createMulticastLock(TAG);
        mWml.setReferenceCounted(false);
        mPm = (PowerManager)getSystemService(Context.POWER_SERVICE);
        mCm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
        mNetd = INetworkManagementService.Stub.asInterface(b);
        mEm = getSystemService(EthernetManager.class);

        findViewById(R.id.enableWifi).setOnClickListener(mClickListener);
        findViewById(R.id.disableWifi).setOnClickListener(mClickListener);
        findViewById(R.id.acquireWifiMulticastLock).setOnClickListener(mClickListener);
        findViewById(R.id.releaseWifiMulticastLock).setOnClickListener(mClickListener);
        findViewById(R.id.releaseWifiMulticastLock).setEnabled(false);

        findViewById(R.id.startDelayedCycle).setOnClickListener(mClickListener);
        findViewById(R.id.stopDelayedCycle).setOnClickListener(mClickListener);
        mDCOnDurationEdit = (EditText)findViewById(R.id.dc_wifi_on_duration);
        mDCOnDurationEdit.setText(Long.toString(mDCOnDuration));
        mDCOffDurationEdit = (EditText)findViewById(R.id.dc_wifi_off_duration);
        mDCOffDurationEdit.setText(Long.toString(mDCOffDuration));
        mDCCycleCountView = (TextView)findViewById(R.id.dc_wifi_cycles_done);
        mDCCycleCountView.setText(Integer.toString(mDCCycleCount));

        findViewById(R.id.startScreenCycle).setOnClickListener(mClickListener);
        findViewById(R.id.stopScreenCycle).setOnClickListener(mClickListener);
        mSCOnDurationEdit = (EditText)findViewById(R.id.sc_wifi_on_duration);
        mSCOnDurationEdit.setText(Long.toString(mSCOnDuration));
        mSCOffDurationEdit = (EditText)findViewById(R.id.sc_wifi_off_duration);
        mSCOffDurationEdit.setText(Long.toString(mSCOffDuration));
        mSCCycleCountView = (TextView)findViewById(R.id.sc_wifi_cycles_done);
        mSCCycleCountView.setText(Integer.toString(mSCCycleCount));

        mScanButton = (Button)findViewById(R.id.startScan);
        mScanButton.setOnClickListener(mClickListener);
        mScanCyclesEdit = (EditText)findViewById(R.id.sc_scan_cycles);
        mScanCyclesEdit.setText(Long.toString(mScanCycles));
        mScanDisconnect = (CheckBox)findViewById(R.id.scanDisconnect);
        mScanDisconnect.setChecked(true);
        mScanResults = (TextView)findViewById(R.id.sc_scan_results);
        mScanResults.setVisibility(View.INVISIBLE);

        mScanRecv = new WifiScanReceiver();
        mIntentFilter = new IntentFilter();
        mIntentFilter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);

        findViewById(R.id.startTdls).setOnClickListener(mClickListener);
        findViewById(R.id.stopTdls).setOnClickListener(mClickListener);

        findViewById(R.id.report_all_bad).setOnClickListener(mClickListener);

        findViewById(R.id.default_request).setOnClickListener(mClickListener);
        findViewById(R.id.bound_http_request).setOnClickListener(mClickListener);
        findViewById(R.id.bound_socket_request).setOnClickListener(mClickListener);

        findViewById(R.id.link_stats).setOnClickListener(mClickListener);

        for (RequestableNetwork network : mRequestableNetworks) {
            network.setRequested(false);
            network.addOnClickListener();
        }
        onHttpRequestResults(null);

        IntentFilter broadcastFilter = new IntentFilter();
        broadcastFilter.addAction(CONNECTIVITY_ACTION);
        broadcastFilter.addAction(CONNECTIVITY_TEST_ALARM);
        broadcastFilter.addAction(NETWORK_CONDITIONS_MEASURED);

        registerReceiver(mReceiver, broadcastFilter);

        mLinkStatsResults = (TextView)findViewById(R.id.stats);
        mLinkStatsResults.setVisibility(View.VISIBLE);

        mHttpRequestResults = (TextView)findViewById(R.id.http_response);
        mHttpRequestResults.setVisibility(View.VISIBLE);

        mCallback = new DevToolsNetworkCallback();
        mCm.registerNetworkCallback(mEmptyRequest, mCallback);

        mEm.addInterfaceStateListener(this::runOnUiThread, mEthListener);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        for (RequestableNetwork network : mRequestableNetworks) {
            network.release();
        }
        mCm.unregisterNetworkCallback(mCallback);
        mCallback = null;
        mEm.removeInterfaceStateListener(mEthListener);
        unregisterReceiver(mReceiver);
        mWml.release();
    }

    @Override
    public void onResume() {
        super.onResume();
        findViewById(R.id.connectivity_layout).requestFocus();
    }

    private View.OnClickListener mClickListener = new View.OnClickListener() {
        public void onClick(View v) {
            switch (v.getId()) {
                case R.id.enableWifi:
                    mWm.setWifiEnabled(true);
                    break;
                case R.id.disableWifi:
                    mWm.setWifiEnabled(false);
                    break;
                case R.id.acquireWifiMulticastLock:
                case R.id.releaseWifiMulticastLock:
                    onWifiMulticastLock(v.getId() == R.id.acquireWifiMulticastLock);
                    break;
                case R.id.startDelayedCycle:
                    onStartDelayedCycle();
                    break;
                case R.id.stopDelayedCycle:
                    onStopDelayedCycle();
                    break;
                case R.id.startScreenCycle:
                    onStartScreenCycle();
                    break;
                case R.id.stopScreenCycle:
                    onStopScreenCycle();
                    break;
                case R.id.startScan:
                    onStartScanCycle();
                    break;
                case R.id.startTdls:
                    onStartTdls();
                    break;
                case R.id.stopTdls:
                    onStopTdls();
                    break;
                case R.id.default_request:
                    onHttpRequest(DEFAULT);
                    break;
                case R.id.bound_http_request:
                    onHttpRequest(HTTPS);
                    break;
                case R.id.bound_socket_request:
                    onHttpRequest(SOCKET);
                    break;
                case R.id.report_all_bad:
                    onReportAllBad();
                    break;
                case R.id.link_stats:
                    onLinkStats();
                    break;
            }
        }
    };


    private void onStartDelayedCycle() {
        if (!mDelayedCycleStarted) {
            mDelayedCycleStarted = true;
            try {
                mDCOnDuration = Long.parseLong(mDCOnDurationEdit.getText().toString());
                mDCOffDuration = Long.parseLong(mDCOffDurationEdit.getText().toString());
            } catch (Exception e) { };
            mDCCycleCount = 0;

            mWakeLock = mPm.newWakeLock(PowerManager.FULL_WAKE_LOCK, "ConnectivityTest");
            mWakeLock.acquire();
            mHandler2.sendMessage(mHandler2.obtainMessage(EVENT_TOGGLE_WIFI));
        }
    }

    private void onStopDelayedCycle() {
        if (mDelayedCycleStarted) {
            mDelayedCycleStarted = false;
            mWakeLock.release();
            mWakeLock = null;
            if(mHandler2.hasMessages(EVENT_TOGGLE_WIFI)) {
                mHandler2.removeMessages(EVENT_TOGGLE_WIFI);
            }
        }
    }

    private void onStartScreenCycle() {
        try {
            mSCOnDuration = Long.parseLong(mSCOnDurationEdit.getText().toString());
            mSCOffDuration = Long.parseLong(mSCOffDurationEdit.getText().toString());
        } catch (Exception e) { };
        mSCCycleCount = 0;

        mScreenonWakeLock = mPm.newWakeLock(PowerManager.FULL_WAKE_LOCK,
                "ConnectivityTest");
        mScreenonWakeLock.acquire();

        scheduleAlarm(10, SCREEN_OFF);
    }

    private void scheduleAlarm(long delayMs, String eventType) {
        AlarmManager am = (AlarmManager)getSystemService(Context.ALARM_SERVICE);
        Intent i = new Intent(CONNECTIVITY_TEST_ALARM);

        i.putExtra(TEST_ALARM_EXTRA, eventType);
        i.putExtra(TEST_ALARM_ON_EXTRA, Long.toString(mSCOnDuration));
        i.putExtra(TEST_ALARM_OFF_EXTRA, Long.toString(mSCOffDuration));
        i.putExtra(TEST_ALARM_CYCLE_EXTRA, Integer.toString(mSCCycleCount));

        PendingIntent p = PendingIntent.getBroadcast(this, 0, i,
                PendingIntent.FLAG_UPDATE_CURRENT|PendingIntent.FLAG_IMMUTABLE);

        am.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, SystemClock.elapsedRealtime() + delayMs, p);
    }

    private void onStopScreenCycle() {
    }

    private void onReportAllBad() {
        Network[] networks = mCm.getAllNetworks();
        for (Network network : networks) {
            mCm.reportBadNetwork(network);
        }
    }

    private void onStartScanCycle() {
        if (mScanCur == -1) {
            try {
                mScanCur = Long.parseLong(mScanCyclesEdit.getText().toString());
                mScanCycles = mScanCur;
            } catch (Exception e) { };
            if (mScanCur <= 0) {
                mScanCur = -1;
                mScanCycles = SCAN_CYCLES;
                return;
            }
        }
        if (mScanCur > 0) {
            registerReceiver(mScanRecv, mIntentFilter);
            mScanButton.setText(PROGRESS_SCAN);
            mScanResults.setVisibility(View.INVISIBLE);
            if (mScanDisconnect.isChecked())
                mWm.disconnect();
            mTotalScanTime = 0;
            mTotalScanCount = 0;
            Log.d(TAG, "Scan: START " + mScanCur);
            mStartTime = SystemClock.elapsedRealtime();
            mWm.startScan();
        } else {
            // Show results
            mScanResults.setText("Average Scan Time = " +
                Long.toString(mTotalScanTime / mScanCycles) + " ms ; Average Scan Amount = " +
                Long.toString(mTotalScanCount / mScanCycles));
            mScanResults.setVisibility(View.VISIBLE);
            mScanButton.setText(START_SCAN);
            mScanCur = -1;
            mScanCyclesEdit.setText(Long.toString(mScanCycles));
            if (mScanDisconnect.isChecked())
                mWm.reassociate();
        }
    }

    private void onStartTdls() {
        mTdlsAddr = ((EditText)findViewById(R.id.sc_ip_mac)).getText().toString();
        Log.d(TAG, "TDLS: START " + mTdlsAddr);
        InetAddress inetAddress = null;
        try {
            inetAddress = InetAddress.getByName(mTdlsAddr);
            mWm.setTdlsEnabled(inetAddress, true);
        } catch (Exception e) {
            mWm.setTdlsEnabledWithMacAddress(mTdlsAddr, true);
        }
    }

    private void onStopTdls() {
        if (mTdlsAddr == null) return;
        Log.d(TAG, "TDLS: STOP " + mTdlsAddr);
        InetAddress inetAddress = null;
        try {
            inetAddress = InetAddress.getByName(mTdlsAddr);
            mWm.setTdlsEnabled(inetAddress, false);
        } catch (Exception e) {
            mWm.setTdlsEnabledWithMacAddress(mTdlsAddr, false);
        }
    }

    private void onLinkStats() {
        Log.e(TAG, "LINK STATS:  ");
        try {
            mWm.getWifiActivityEnergyInfoAsync(getMainExecutor(), info -> {
                if (info != null) {
                    mLinkStatsResults.setText(" power " + info.toString());
                } else {
                    mLinkStatsResults.setText(" null! ");
                }
            });
        } catch (Exception e) {
            mLinkStatsResults.setText(" failed! " + e.toString());
        }
    }


    private final static int DEFAULT = 0;
    private final static int SOCKET = 1;
    private final static int HTTPS  = 2;

    private void onHttpRequestResults(final String results) {
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                boolean enabled = !mRequestRunning;
                findViewById(R.id.default_request).setEnabled(enabled);

                enabled = !mRequestRunning && mBoundTestNetwork.getNetwork() != null;
                findViewById(R.id.bound_http_request).setEnabled(enabled);
                findViewById(R.id.bound_socket_request).setEnabled(enabled);

                if (!TextUtils.isEmpty(results) || !mRequestRunning) {
                    ((TextView) findViewById(R.id.http_response)).setText(results);
                }
            }
        });
    }

    private String doSocketRequest(Network network, String host, String path) throws IOException {
        Socket sock = network.getSocketFactory().createSocket(host, 80);
        try {
          sock.setSoTimeout(5000);
          OutputStreamWriter writer = new OutputStreamWriter(sock.getOutputStream());
          String request = String.format(
                  "GET %s HTTP/1.1\nHost: %s\nConnection: close\n\n", path, host);
          writer.write(request);
          writer.flush();
          BufferedReader reader = new BufferedReader(new InputStreamReader(sock.getInputStream()));
          String line = reader.readLine();

          if (line == null || !line.startsWith("HTTP/1.1 200")) {
              // Error.
              return "Error: " + line;
          }

          do {
              // Consume headers.
              line = reader.readLine();
          } while (!TextUtils.isEmpty(line));

          // Return first line of body.
          return reader.readLine();
        } finally {
            if (sock != null) {
                IoUtils.closeQuietly(sock);
            }
        }
    }

    private void onHttpRequest(final int type) {
        mRequestRunning = true;
        onHttpRequestResults(null);

        Thread requestThread = new Thread() {
            public void run() {
                final String path = "/ip.js?fmt=text";
                final String randomHost =
                        "h" + Integer.toString(new Random().nextInt()) + ".ds.ipv6test.google.com";
                final String fixedHost = "google-ipv6test.appspot.com";

                Network network = mBoundTestNetwork.getNetwork();
                HttpURLConnection conn = null;
                InputStreamReader in = null;

                try {
                    final URL httpsUrl = new URL("https", fixedHost, path);
                    BufferedReader reader;

                    switch (type) {
                        case DEFAULT:
                            conn = (HttpURLConnection) httpsUrl.openConnection(Proxy.NO_PROXY);
                            in = new InputStreamReader(conn.getInputStream());
                            reader = new BufferedReader(in);
                            onHttpRequestResults(reader.readLine());
                            break;
                        case SOCKET:
                            String response = doSocketRequest(network, randomHost, path);
                            onHttpRequestResults(response);
                            break;
                        case HTTPS:
                            conn = (HttpURLConnection) network.openConnection(httpsUrl,
                                    Proxy.NO_PROXY);
                            in = new InputStreamReader(conn.getInputStream());
                            reader = new BufferedReader(in);
                            onHttpRequestResults(reader.readLine());
                            break;
                        default:
                            throw new IllegalArgumentException("Cannot happen");
                    }
                } catch(IOException e) {
                    onHttpRequestResults("Error! ");
                } finally {
                    mRequestRunning = false;
                    if (in != null) IoUtils.closeQuietly(in);
                    if (conn != null) conn.disconnect();
                }
            }
        };
        requestThread.start();
    }

    private void onWifiMulticastLock(boolean enable) {
        Log.d(TAG, (enable ? "Acquiring" : "Releasing") + " wifi multicast lock");
        if (enable) {
            mWml.acquire();
        } else {
            mWml.release();
        }
        findViewById(R.id.acquireWifiMulticastLock).setEnabled(!enable);
        findViewById(R.id.releaseWifiMulticastLock).setEnabled(enable);
    }
}