src/com/android/quicksearchbox/google/SearchBaseUrlHelper.java

/*
 * Copyright (C) 2010 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.quicksearchbox.google;

import com.android.quicksearchbox.R;
import com.android.quicksearchbox.SearchSettings;
import com.android.quicksearchbox.SearchSettingsImpl;
import com.android.quicksearchbox.util.HttpHelper;

import android.content.Context;
import android.content.SharedPreferences;
import android.os.AsyncTask;
import android.text.TextUtils;
import android.util.Log;

import java.util.Locale;

/**
 * Helper to build the base URL for all search requests.
 */
public class SearchBaseUrlHelper implements SharedPreferences.OnSharedPreferenceChangeListener {
    private static final boolean DBG = false;
    private static final String TAG = "QSB.SearchBaseUrlHelper";

    private static final String DOMAIN_CHECK_URL =
            "https://www.google.com/searchdomaincheck?format=domain";

    private static final long SEARCH_BASE_URL_EXPIRY_MS = 24 * 3600 * 1000L;

    private final HttpHelper mHttpHelper;
    private final Context mContext;
    private final SearchSettings mSearchSettings;

    /**
     * Note that this constructor will spawn a thread to issue a HTTP
     * request if shouldUseGoogleCom is false.
     */
    public SearchBaseUrlHelper(Context context, HttpHelper helper,
            SearchSettings searchSettings, SharedPreferences prefs) {
        mHttpHelper = helper;
        mContext = context;
        mSearchSettings = searchSettings;

        // Note: This earlier used an inner class, but that causes issues
        // because SharedPreferencesImpl uses a WeakHashMap< > and the listener
        // will be GC'ed unless we keep a reference to it here.
        prefs.registerOnSharedPreferenceChangeListener(this);

        maybeUpdateBaseUrlSetting(false);
    }

    /**
     * Update the base search url, either:
     * (a) it has never been set (first run)
     * (b) it has expired
     * (c) if the caller forces an update by setting the "force" parameter.
     *
     * @param force if true, then the URL is reset whether or not it has
     *     expired.
     */
    public void maybeUpdateBaseUrlSetting(boolean force) {
        long lastUpdateTime = mSearchSettings.getSearchBaseDomainApplyTime();
        long currentTime = System.currentTimeMillis();

        if (force || lastUpdateTime == -1 ||
                currentTime - lastUpdateTime >= SEARCH_BASE_URL_EXPIRY_MS) {
            if (mSearchSettings.shouldUseGoogleCom()) {
                setSearchBaseDomain(getDefaultBaseDomain());
            } else {
                checkSearchDomain();
            }
        }
    }

    /**
     * @return the base url for searches.
     */
    public String getSearchBaseUrl() {
        return mContext.getResources().getString(R.string.google_search_base_pattern,
                getSearchDomain(), GoogleSearch.getLanguage(Locale.getDefault()));
    }

    /**
     * @return the search domain. This is of the form "google.co.xx" or "google.com",
     *     used by UI code.
     */
    public String getSearchDomain() {
        String domain = mSearchSettings.getSearchBaseDomain();

        if (domain == null) {
            if (DBG) {
                Log.w(TAG, "Search base domain was null, last apply time=" +
                        mSearchSettings.getSearchBaseDomainApplyTime());
            }

            // This is required to deal with the case wherein getSearchDomain
            // is called before checkSearchDomain returns a valid URL. This will
            // happen *only* on the first run of the app when the "use google.com"
            // option is unchecked. In other cases, the previously set domain (or
            // the default) will be returned.
            //
            // We have no choice in this case but to use the default search domain.
            domain = getDefaultBaseDomain();
        }

        if (domain.startsWith(".")) {
            if (DBG) Log.d(TAG, "Prepending www to " + domain);
            domain = "www" + domain;
        }
        return domain;
    }

    /**
     * Issue a request to google.com/searchdomaincheck to retrieve the base
     * URL for search requests.
     */
    private void checkSearchDomain() {
        final HttpHelper.GetRequest request = new HttpHelper.GetRequest(DOMAIN_CHECK_URL);

        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void ... params) {
                if (DBG) Log.d(TAG, "Starting request to /searchdomaincheck");
                String domain;
                try {
                    domain = mHttpHelper.get(request);
                } catch (Exception e) {
                    if (DBG) Log.d(TAG, "Request to /searchdomaincheck failed : " + e);
                    // Swallow any exceptions thrown by the HTTP helper, in
                    // this rare case, we just use the default URL.
                    domain = getDefaultBaseDomain();

                    return null;
                }

                if (DBG) Log.d(TAG, "Request to /searchdomaincheck succeeded");
                setSearchBaseDomain(domain);

                return null;
            }
        }.execute();
    }

    private String getDefaultBaseDomain() {
        return mContext.getResources().getString(R.string.default_search_domain);
    }

    private void setSearchBaseDomain(String domain) {
        if (DBG) Log.d(TAG, "Setting search domain to : " + domain);

        mSearchSettings.setSearchBaseDomain(domain);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences pref, String key) {
        // Listen for changes only to the SEARCH_BASE_URL preference.
        if (DBG) Log.d(TAG, "Handling changed preference : " + key);
        if (SearchSettingsImpl.USE_GOOGLE_COM_PREF.equals(key)) {
            maybeUpdateBaseUrlSetting(true);
        }
    }
}