android/src/main/java/com/google/samples/apps/iosched/util/WiFiUtils.java

/*
 * Copyright 2014 Google Inc. All rights reserved.
 *
 * 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.google.samples.apps.iosched.util;

import android.app.*;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.provider.Settings;
import android.text.Html;
import android.text.method.LinkMovementMethod;
import android.util.Log;
import android.widget.TextView;
import android.widget.Toast;

import com.google.samples.apps.iosched.BuildConfig;
import com.google.samples.apps.iosched.Config;
import com.google.samples.apps.iosched.R;

import java.util.List;

import static com.google.samples.apps.iosched.util.LogUtils.makeLogTag;

public class WiFiUtils {
    // Preference key and values associated with WiFi AP configuration.
    public static final String PREF_WIFI_AP_CONFIG = "pref_wifi_ap_config";
    public static final String WIFI_CONFIG_DONE = "done";
    public static final String WIFI_CONFIG_REQUESTED = "requested";

    private static final String TAG = makeLogTag(WiFiUtils.class);

    public static void installConferenceWiFi(final Context context) {
        // Create config
        WifiConfiguration config = new WifiConfiguration();
        // Must be in double quotes to tell system this is an ASCII SSID and passphrase.
        config.SSID = String.format("\"%s\"", Config.WIFI_SSID);
        config.preSharedKey = String.format("\"%s\"", Config.WIFI_PASSPHRASE);

        // Store config
        final WifiManager wifiManager =
                (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        int netId = wifiManager.addNetwork(config);
        if (netId != -1) {
            wifiManager.enableNetwork(netId, false);
            boolean result = wifiManager.saveConfiguration();
            if (!result) {
                Log.e(TAG, "Unknown error while calling WiFiManager.saveConfiguration()");
                Toast.makeText(context,
                        context.getResources().getString(R.string.wifi_install_error_message),
                        Toast.LENGTH_SHORT).show();
            }
        } else {
            Log.e(TAG, "Unknown error while calling WiFiManager.addNetwork()");
            Toast.makeText(context,
                    context.getResources().getString(R.string.wifi_install_error_message),
                    Toast.LENGTH_SHORT).show();
        }
    }

    /**
     * Helper method to decide whether to bypass conference WiFi setup.  Return true if
     * WiFi AP is already configured (WiFi adapter enabled) or WiFi configuration is complete
     * as per shared preference.
     */
    public static boolean shouldBypassWiFiSetup(final Context context) {
        final WifiManager wifiManager =
                (WifiManager) context.getSystemService(Context.WIFI_SERVICE);

        // Is WiFi on?
        if (wifiManager.isWifiEnabled()) {
            // Check for existing APs.
            final List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();
            final String conferenceSSID = String.format("\"%s\"", Config.WIFI_SSID);
            for(WifiConfiguration config : configs) {
                if (conferenceSSID.equalsIgnoreCase(config.SSID)) return true;
            }
        }

        return WIFI_CONFIG_DONE.equals(getWiFiConfigStatus(context));
    }

    public static boolean isWiFiEnabled(final Context context) {
        final WifiManager wifiManager =
                (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        return wifiManager.isWifiEnabled();
    }

    public static boolean isWiFiApConfigured(final Context context) {
        final WifiManager wifiManager =
                (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        final List<WifiConfiguration> configs = wifiManager.getConfiguredNetworks();

        if (configs == null) return false;

        // Check for existing APs.
        final String conferenceSSID = String.format("\"%s\"", Config.WIFI_SSID);
        for(WifiConfiguration config : configs) {
            if (conferenceSSID.equalsIgnoreCase(config.SSID)) return true;
        }
        return false;
    }

    // Stored preferences associated with WiFi AP configuration.
    public static String getWiFiConfigStatus(final Context context) {
        final SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
        return sp.getString(PREF_WIFI_AP_CONFIG, null);
    }

    public static void setWiFiConfigStatus(final Context context, final String status) {
        if (!WIFI_CONFIG_DONE.equals(status) && !WIFI_CONFIG_REQUESTED.equals(status))
            throw new IllegalArgumentException("Invalid WiFi Config status: " + status);
        final SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(context);
        sp.edit().putString(PREF_WIFI_AP_CONFIG, status).commit();
    }

    public static boolean installWiFiIfRequested(final Context context) {
        if (WIFI_CONFIG_REQUESTED.equals(getWiFiConfigStatus(context)) && isWiFiEnabled(context)) {
            installConferenceWiFi(context);
            if (isWiFiApConfigured(context)) {
                setWiFiConfigStatus(context, WiFiUtils.WIFI_CONFIG_DONE);
                return true;
            }
        }
        return false;
    }

    public static void showWiFiDialog(Activity activity) {
        FragmentManager fm = activity.getFragmentManager();
        FragmentTransaction ft = fm.beginTransaction();
        Fragment prev = fm.findFragmentByTag("dialog_wifi");
        if (prev != null) {
            ft.remove(prev);
        }
        ft.addToBackStack(null);
        new WiFiDialog(isWiFiEnabled(activity)).show(ft, "dialog_wifi");
    }

    public static class WiFiDialog extends DialogFragment {
        private boolean mWiFiEnabled;

        public WiFiDialog() {}

        public WiFiDialog(boolean wifiEnabled) {
            super();
            mWiFiEnabled = wifiEnabled;
        }

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            final int padding =
                    getResources().getDimensionPixelSize(R.dimen.content_padding_normal);
            final TextView wifiTextView = new TextView(getActivity());
            int dialogCallToActionText;
            int dialogPositiveButtonText;
            if (mWiFiEnabled) {
                dialogCallToActionText = R.string.calltoaction_wifi_configure;
                dialogPositiveButtonText = R.string.wifi_dialog_button_configure;
            } else {
                dialogCallToActionText = R.string.calltoaction_wifi_settings;
                dialogPositiveButtonText = R.string.wifi_dialog_button_settings;
            }
            wifiTextView.setText(Html.fromHtml(getString(R.string.description_setup_wifi_body) +
                    getString(dialogCallToActionText)));
            wifiTextView.setMovementMethod(LinkMovementMethod.getInstance());
            wifiTextView.setPadding(padding, padding, padding, padding);
            final Context context = getActivity();

            return new AlertDialog.Builder(context)
                    .setTitle(R.string.description_configure_wifi)
                    .setView(wifiTextView)
                    .setPositiveButton(dialogPositiveButtonText,
                            new DialogInterface.OnClickListener() {
                                public void onClick(DialogInterface dialog, int whichButton) {
                                    // Attempt to configure the Wi-Fi access point.
                                    if (mWiFiEnabled) {
                                        installConferenceWiFi(context);
                                        if (WiFiUtils.isWiFiApConfigured(context)) {
                                            WiFiUtils.setWiFiConfigStatus(
                                                    context,
                                                    WiFiUtils.WIFI_CONFIG_DONE);
                                        }
                                        // Launch Wi-Fi settings screen for user to enable Wi-Fi.
                                    } else {
                                        WiFiUtils.setWiFiConfigStatus(context,
                                                WiFiUtils.WIFI_CONFIG_REQUESTED);
                                        final Intent wifiIntent =
                                                new Intent(Settings.ACTION_WIFI_SETTINGS);
                                        wifiIntent.addFlags(
                                                Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
                                        startActivity(wifiIntent);
                                    }
                                    dialog.dismiss();
                                }
                            }
                    )
                    .create();
        }
    }

    /**
     * Returns whether we should or should not offer to set up wifi. If asCard == true
     * this will decide whether or not to offer wifi setup actively (as a card, for instance).
     * If asCard == false, this will return whether or not to offer wifi setup passively
     * (in the overflow menu, for instance).
     */
    public static boolean shouldOfferToSetupWifi(final Context context, boolean actively) {
        long now = UIUtils.getCurrentTime(context);
        if (now < Config.WIFI_SETUP_OFFER_START) {
            // too early to offer
            return false;
        }
        if (now > Config.CONFERENCE_END_MILLIS) {
            // too late
            return false;
        }
        if (!WiFiUtils.isWiFiEnabled(context)) {
            // no wifi, no offer
            return false;
        }
        if (!PrefUtils.isAttendeeAtVenue(context)) {
            // wifi setup not relevant
            return false;
        }
        if (WiFiUtils.isWiFiApConfigured(context)) {
            // already set up
            return false;
        }
        if (actively && PrefUtils.hasDeclinedWifiSetup(context)) {
            // user said no
            return false;
        }
        return true;
    }
}