android/phone/NetworkQueryService.java

/*
 * Copyright (C) 2008 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.phone;

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.os.AsyncResult;
import android.os.Binder;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.telephony.AccessNetworkConstants;
import android.telephony.CellIdentityGsm;
import android.telephony.CellInfo;
import android.telephony.CellInfoGsm;
import android.telephony.NetworkScan;
import android.telephony.NetworkScanRequest;
import android.telephony.RadioAccessSpecifier;
import android.telephony.TelephonyManager;
import android.telephony.TelephonyScanManager;
import android.util.Log;

import com.android.internal.telephony.OperatorInfo;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.PhoneFactory;

import java.util.ArrayList;
import java.util.List;

/**
 * Service code used to assist in querying the network for service
 * availability.
 */
public class NetworkQueryService extends Service {
    // debug data
    private static final String LOG_TAG = "NetworkQuery";
    private static final boolean DBG = true;

    // static events
    private static final int EVENT_NETWORK_SCAN_VIA_PHONE_COMPLETED = 100;
    private static final int EVENT_NETWORK_SCAN_RESULTS = 200;
    private static final int EVENT_NETWORK_SCAN_ERROR = 300;
    private static final int EVENT_NETWORK_SCAN_COMPLETED = 400;

    // static states indicating the query status of the service
    private static final int QUERY_READY = -1;
    private static final int QUERY_IS_RUNNING = -2;

    // error statuses that will be retured in the callback.
    public static final int QUERY_OK = 0;
    public static final int QUERY_EXCEPTION = 1;

    static final String ACTION_LOCAL_BINDER = "com.android.phone.intent.action.LOCAL_BINDER";

    /** state of the query service */
    private int mState;

    private NetworkScan mNetworkScan;

    // NetworkScanRequest parameters
    private static final int SCAN_TYPE = NetworkScanRequest.SCAN_TYPE_ONE_SHOT;
    private static final boolean INCREMENTAL_RESULTS = true;
    // The parameters below are in seconds
    private static final int SEARCH_PERIODICITY_SEC = 5;
    private static final int MAX_SEARCH_TIME_SEC = 300;
    private static final int INCREMENTAL_RESULTS_PERIODICITY_SEC = 3;

    /**
     * Class for clients to access.  Because we know this service always
     * runs in the same process as its clients, we don't need to deal with
     * IPC.
     */
    public class LocalBinder extends Binder {
        INetworkQueryService getService() {
            return mBinder;
        }
    }
    private final IBinder mLocalBinder = new LocalBinder();

    /**
     * Local handler to receive the network query compete callback
     * from the RIL.
     */
    Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                // if the scan is complete, broadcast the results.
                // to all registerd callbacks.
                case EVENT_NETWORK_SCAN_VIA_PHONE_COMPLETED:
                    if (DBG) log("scan via Phone completed, broadcasting results");
                    broadcastQueryResults(msg);
                    break;

                case EVENT_NETWORK_SCAN_RESULTS:
                    if (DBG) log("get scan results, broadcasting results");
                    broadcastQueryResults(msg);
                    break;

                case EVENT_NETWORK_SCAN_ERROR:
                    if (DBG) log("get scan error, broadcasting error code");
                    broadcastQueryResults(msg);
                    break;

                case EVENT_NETWORK_SCAN_COMPLETED:
                    if (DBG) log("network scan or stop network query completed");
                    broadcastQueryResults(msg);
                    break;
            }
        }
    };

    /**
     * List of callback objects, also used to synchronize access to
     * itself and to changes in state.
     */
    final RemoteCallbackList<INetworkQueryServiceCallback> mCallbacks =
            new RemoteCallbackList<INetworkQueryServiceCallback>();

    /**
     * This implementation of NetworkScanCallbackImpl is used to receive callback notifications from
     * the Telephony Manager.
     */
    public class NetworkScanCallbackImpl extends TelephonyScanManager.NetworkScanCallback {

        /** Returns the scan results to the user, this callback will be called at least one time. */
        public void onResults(List<CellInfo> results) {
            if (DBG) log("got network scan results: " + results.size());
            Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_RESULTS, results);
            msg.sendToTarget();
        }

        /**
         * Informs the user that the scan has stopped.
         *
         * This callback will be called when the scan is finished or cancelled by the user.
         * The related NetworkScanRequest will be deleted after this callback.
         */
        public void onComplete() {
            if (DBG) log("network scan completed");
            Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_COMPLETED);
            msg.sendToTarget();
        }

        /**
         * Informs the user that there is some error about the scan.
         *
         * This callback will be called whenever there is any error about the scan, and the scan
         * will be terminated. onComplete() will NOT be called.
         */
        public void onError(int error) {
            if (DBG) log("network scan got error: " + error);
            Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_ERROR, error, 0 /* arg2 */);
            msg.sendToTarget();
        }
    }

    /**
     * Implementation of the INetworkQueryService interface.
     */
    private final INetworkQueryService.Stub mBinder = new INetworkQueryService.Stub() {

        /**
         * Starts a query with a INetworkQueryServiceCallback object if
         * one has not been started yet.  Ignore the new query request
         * if the query has been started already.  Either way, place the
         * callback object in the queue to be notified upon request
         * completion.
         */
        public void startNetworkQuery(
                INetworkQueryServiceCallback cb, int phoneId, boolean isIncrementalResult) {
            if (cb != null) {
                // register the callback to the list of callbacks.
                synchronized (mCallbacks) {
                    mCallbacks.register(cb);
                    if (DBG) log("registering callback " + cb.getClass().toString());

                    switch (mState) {
                        case QUERY_READY:

                            if (isIncrementalResult) {
                                if (DBG) log("start network scan via TelephonManager");
                                TelephonyManager tm = (TelephonyManager) getSystemService(
                                        Context.TELEPHONY_SERVICE);
                                // The Radio Access Specifiers below are meant to scan
                                // all the bands for all the supported technologies.
                                RadioAccessSpecifier gsm = new RadioAccessSpecifier(
                                        AccessNetworkConstants.AccessNetworkType.GERAN,
                                        null /* bands */,
                                        null /* channels */);
                                RadioAccessSpecifier lte = new RadioAccessSpecifier(
                                        AccessNetworkConstants.AccessNetworkType.EUTRAN,
                                        null /* bands */,
                                        null /* channels */);
                                RadioAccessSpecifier wcdma = new RadioAccessSpecifier(
                                        AccessNetworkConstants.AccessNetworkType.UTRAN,
                                        null /* bands */,
                                        null /* channels */);
                                RadioAccessSpecifier[] radioAccessSpecifier = {gsm, lte, wcdma};
                                NetworkScanRequest networkScanRequest = new NetworkScanRequest(
                                        SCAN_TYPE,
                                        radioAccessSpecifier,
                                        SEARCH_PERIODICITY_SEC,
                                        MAX_SEARCH_TIME_SEC,
                                        INCREMENTAL_RESULTS,
                                        INCREMENTAL_RESULTS_PERIODICITY_SEC,
                                        null /* List of PLMN ids (MCC-MNC) */);

                                // Construct a NetworkScanCallback
                                NetworkQueryService.NetworkScanCallbackImpl
                                        networkScanCallback =
                                        new NetworkQueryService.NetworkScanCallbackImpl();

                                // Request network scan
                                mNetworkScan = tm.requestNetworkScan(networkScanRequest,
                                        networkScanCallback);
                                mState = QUERY_IS_RUNNING;
                            } else {
                                Phone phone = PhoneFactory.getPhone(phoneId);
                                if (phone != null) {
                                    phone.getAvailableNetworks(
                                            mHandler.obtainMessage(
                                                    EVENT_NETWORK_SCAN_VIA_PHONE_COMPLETED));
                                    mState = QUERY_IS_RUNNING;
                                    if (DBG) log("start network scan via Phone");
                                } else {
                                    if (DBG) {
                                        log("phone is null");
                                    }
                                }
                            }

                            break;
                        // do nothing if we're currently busy.
                        case QUERY_IS_RUNNING:
                            if (DBG) log("query already in progress");
                            break;
                        default:
                    }
                }
            }
        }

        /**
         * Stops a query with a INetworkQueryServiceCallback object as
         * a token.
         */
        public void stopNetworkQuery() {
            if (DBG) log("stop network query");
            // Tells the RIL to terminate the query request.
            if (mNetworkScan != null) {
                try {
                    mNetworkScan.stop();
                    mState = QUERY_READY;
                } catch (RemoteException e) {
                    if (DBG) log("stop mNetworkScan failed");
                } catch (IllegalArgumentException e) {
                    // Do nothing, scan has already completed.
                }
            }
        }

        /**
         * Unregisters the callback without impacting an underlying query.
         */
        public void unregisterCallback(INetworkQueryServiceCallback cb) {
            if (cb != null) {
                synchronized (mCallbacks) {
                    if (DBG) log("unregistering callback " + cb.getClass().toString());
                    mCallbacks.unregister(cb);
                }
            }
        }
    };

    @Override
    public void onCreate() {
        mState = QUERY_READY;
    }

    /**
     * Required for service implementation.
     */
    @Override
    public void onStart(Intent intent, int startId) {
    }

    /**
     * Handle the bind request.
     */
    @Override
    public IBinder onBind(Intent intent) {
        if (DBG) log("binding service implementation");
        if (ACTION_LOCAL_BINDER.equals(intent.getAction())) {
            return mLocalBinder;
        }

        return mBinder;
    }

    /**
     * Broadcast the results from the query to all registered callback
     * objects.
     */
    private void broadcastQueryResults(Message msg) {
        // reset the state.
        synchronized (mCallbacks) {
            mState = QUERY_READY;

            // Make the calls to all the registered callbacks.
            for (int i = (mCallbacks.beginBroadcast() - 1); i >= 0; i--) {
                INetworkQueryServiceCallback cb = mCallbacks.getBroadcastItem(i);
                if (DBG) log("broadcasting results to " + cb.getClass().toString());
                try {
                    switch (msg.what) {
                        case EVENT_NETWORK_SCAN_VIA_PHONE_COMPLETED:
                            AsyncResult ar = (AsyncResult) msg.obj;
                            if (ar != null) {
                                cb.onResults(getCellInfoList((List<OperatorInfo>) ar.result));
                            } else {
                                if (DBG) log("AsyncResult is null.");
                            }
                            // Send the onComplete() callback to indicate the one-time network
                            // scan has completed.
                            cb.onComplete();
                            break;

                        case EVENT_NETWORK_SCAN_RESULTS:
                            cb.onResults((List<CellInfo>) msg.obj);
                            break;

                        case EVENT_NETWORK_SCAN_COMPLETED:
                            cb.onComplete();
                            break;

                        case EVENT_NETWORK_SCAN_ERROR:
                            cb.onError(msg.arg1);
                            break;
                    }
                } catch (RemoteException e) {
                }
            }

            // finish up.
            mCallbacks.finishBroadcast();
        }
    }

    /**
     * Wraps up a list of OperatorInfo object to a list of CellInfo object. GsmCellInfo is used here
     * only because operatorInfo does not contain technology type while CellInfo is an abstract
     * object that requires to specify technology type. It doesn't matter which CellInfo type to
     * use here, since we only want to wrap the operator info and PLMN to a CellInfo object.
     */
    private List<CellInfo> getCellInfoList(List<OperatorInfo> operatorInfoList) {
        List<CellInfo> cellInfoList = new ArrayList<>();
        for (OperatorInfo oi: operatorInfoList) {
            String operatorNumeric = oi.getOperatorNumeric();
            String mcc = null;
            String mnc = null;
            log("operatorNumeric: " + operatorNumeric);
            if (operatorNumeric != null && operatorNumeric.matches("^[0-9]{5,6}$")) {
                mcc = operatorNumeric.substring(0, 3);
                mnc = operatorNumeric.substring(3);
            }
            CellIdentityGsm cig = new CellIdentityGsm(
                    Integer.MAX_VALUE /* lac */,
                    Integer.MAX_VALUE /* cid */,
                    Integer.MAX_VALUE /* arfcn */,
                    Integer.MAX_VALUE /* bsic */,
                    mcc,
                    mnc,
                    oi.getOperatorAlphaLong(),
                    oi.getOperatorAlphaShort());

            CellInfoGsm ci = new CellInfoGsm();
            ci.setCellIdentity(cig);
            cellInfoList.add(ci);
        }
        return cellInfoList;
    }

    private static void log(String msg) {
        Log.d(LOG_TAG, msg);
    }
}