| /* |
| * Copyright (C) 2018 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.ActionBar; |
| import android.app.Activity; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.ServiceConnection; |
| import android.os.AsyncResult; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.Message; |
| import android.os.RemoteException; |
| import android.preference.Preference; |
| import android.preference.PreferenceCategory; |
| import android.preference.PreferenceFragment; |
| import android.preference.PreferenceScreen; |
| import android.telephony.AccessNetworkConstants; |
| import android.telephony.CellIdentity; |
| import android.telephony.CellInfo; |
| import android.telephony.NetworkRegistrationState; |
| import android.telephony.ServiceState; |
| import android.telephony.SubscriptionManager; |
| import android.telephony.TelephonyManager; |
| import android.util.Log; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| |
| import com.android.internal.logging.MetricsLogger; |
| import com.android.internal.logging.nano.MetricsProto.MetricsEvent; |
| 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.Arrays; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * "Choose network" settings UI for the Phone app. |
| */ |
| public class NetworkSelectSetting extends PreferenceFragment { |
| |
| private static final String TAG = "NetworkSelectSetting"; |
| private static final boolean DBG = true; |
| |
| private static final int EVENT_NETWORK_SELECTION_DONE = 1; |
| private static final int EVENT_NETWORK_SCAN_RESULTS = 2; |
| private static final int EVENT_NETWORK_SCAN_ERROR = 3; |
| private static final int EVENT_NETWORK_SCAN_COMPLETED = 4; |
| |
| private static final String PREF_KEY_CONNECTED_NETWORK_OPERATOR = |
| "connected_network_operator_preference"; |
| private static final String PREF_KEY_NETWORK_OPERATORS = "network_operators_preference"; |
| |
| // used to add/remove NetworkOperatorsPreference. |
| private PreferenceCategory mNetworkOperatorsPreferences; |
| // used to add/remove connected NetworkOperatorPreference. |
| private PreferenceCategory mConnectedNetworkOperatorsPreference; |
| // manage the progress bar on the top of the page. |
| private View mProgressHeader; |
| private Preference mStatusMessagePreference; |
| private List<CellInfo> mCellInfoList; |
| private int mPhoneId = SubscriptionManager.INVALID_PHONE_INDEX; |
| private ViewGroup mFrameLayout; |
| private NetworkOperatorPreference mSelectedNetworkOperatorPreference; |
| private TelephonyManager mTelephonyManager; |
| private NetworkOperators mNetworkOperators; |
| private List<String> mForbiddenPlmns; |
| |
| private final Runnable mUpdateNetworkOperatorsRunnable = () -> { |
| updateNetworkOperatorsPreferenceCategory(); |
| }; |
| |
| /** |
| * Create a new instance of this fragment. |
| */ |
| public static NetworkSelectSetting newInstance(int phoneId) { |
| Bundle args = new Bundle(); |
| args.putInt(NetworkSelectSettingActivity.KEY_PHONE_ID, phoneId); |
| NetworkSelectSetting fragment = new NetworkSelectSetting(); |
| fragment.setArguments(args); |
| |
| return fragment; |
| } |
| |
| @Override |
| public void onCreate(Bundle icicle) { |
| if (DBG) logd("onCreate"); |
| super.onCreate(icicle); |
| |
| mPhoneId = getArguments().getInt(NetworkSelectSettingActivity.KEY_PHONE_ID); |
| |
| addPreferencesFromResource(R.xml.choose_network); |
| mConnectedNetworkOperatorsPreference = |
| (PreferenceCategory) findPreference(PREF_KEY_CONNECTED_NETWORK_OPERATOR); |
| mNetworkOperatorsPreferences = |
| (PreferenceCategory) findPreference(PREF_KEY_NETWORK_OPERATORS); |
| mStatusMessagePreference = new Preference(getContext()); |
| mSelectedNetworkOperatorPreference = null; |
| mTelephonyManager = (TelephonyManager) |
| getContext().getSystemService(Context.TELEPHONY_SERVICE); |
| mNetworkOperators = new NetworkOperators(getContext()); |
| setRetainInstance(true); |
| } |
| |
| @Override |
| public void onViewCreated(View view, Bundle savedInstanceState) { |
| if (DBG) logd("onViewCreated"); |
| super.onViewCreated(view, savedInstanceState); |
| |
| if (getListView() != null) { |
| getListView().setDivider(null); |
| } |
| // Inflate progress bar |
| final Activity activity = getActivity(); |
| if (activity != null) { |
| ActionBar actionBar = activity.getActionBar(); |
| if (actionBar != null) { |
| // android.R.id.home will be triggered in |
| // {@link NetworkSelectSettingAcitivity#onOptionsItemSelected()} |
| actionBar.setDisplayHomeAsUpEnabled(true); |
| } |
| mFrameLayout = activity.findViewById(R.id.choose_network_content); |
| final LayoutInflater inflater = activity.getLayoutInflater(); |
| final View pinnedHeader = |
| inflater.inflate(R.layout.choose_network_progress_header, mFrameLayout, false); |
| mFrameLayout.addView(pinnedHeader); |
| mFrameLayout.setVisibility(View.VISIBLE); |
| mProgressHeader = pinnedHeader.findViewById(R.id.progress_bar_animation); |
| setProgressBarVisible(false); |
| } |
| forceConfigConnectedNetworkOperatorsPreferenceCategory(); |
| } |
| |
| @Override |
| public void onStart() { |
| if (DBG) logd("onStart"); |
| super.onStart(); |
| new AsyncTask<Void, Void, List<String>>() { |
| @Override |
| protected List<String> doInBackground(Void... voids) { |
| return Arrays.asList(mTelephonyManager.getForbiddenPlmns()); |
| } |
| |
| @Override |
| protected void onPostExecute(List<String> result) { |
| mForbiddenPlmns = result; |
| bindNetworkQueryService(); |
| } |
| }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); |
| } |
| |
| /** |
| * Invoked on each preference click in this hierarchy, overrides |
| * PreferenceActivity's implementation. Used to make sure we track the |
| * preference click events. |
| * Since the connected network operator is either faked (when no data connection) or already |
| * connected, we do not allow user to click the connected network operator. |
| */ |
| @Override |
| public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, |
| Preference preference) { |
| if (DBG) logd("User clicked the screen"); |
| stopNetworkQuery(); |
| setProgressBarVisible(false); |
| if (preference instanceof NetworkOperatorPreference) { |
| // Refresh the last selected item in case users reselect network. |
| if (mSelectedNetworkOperatorPreference != null) { |
| mSelectedNetworkOperatorPreference.setSummary(""); |
| } |
| |
| mSelectedNetworkOperatorPreference = (NetworkOperatorPreference) preference; |
| CellInfo cellInfo = mSelectedNetworkOperatorPreference.getCellInfo(); |
| if (DBG) logd("User click a NetworkOperatorPreference: " + cellInfo.toString()); |
| |
| // Send metrics event |
| MetricsLogger.action(getContext(), |
| MetricsEvent.ACTION_MOBILE_NETWORK_MANUAL_SELECT_NETWORK); |
| |
| // Connect to the network |
| Message msg = mHandler.obtainMessage(EVENT_NETWORK_SELECTION_DONE); |
| Phone phone = PhoneFactory.getPhone(mPhoneId); |
| if (phone != null) { |
| if (DBG) { |
| logd("Connect to the network: " + CellInfoUtil.getNetworkTitle(cellInfo)); |
| } |
| // Set summary as "Connecting" to the selected network. |
| mSelectedNetworkOperatorPreference.setSummary(R.string.network_connecting); |
| |
| // Set summary as "Disconnected" to the previously connected network |
| if (mConnectedNetworkOperatorsPreference.getPreferenceCount() > 0) { |
| NetworkOperatorPreference connectedNetworkOperator = (NetworkOperatorPreference) |
| (mConnectedNetworkOperatorsPreference.getPreference(0)); |
| if (!CellInfoUtil.getNetworkTitle(cellInfo).equals( |
| CellInfoUtil.getNetworkTitle(connectedNetworkOperator.getCellInfo()))) { |
| connectedNetworkOperator.setSummary(R.string.network_disconnected); |
| } |
| } |
| |
| // Select network manually via Phone |
| OperatorInfo operatorInfo = CellInfoUtil.getOperatorInfoFromCellInfo(cellInfo); |
| if (DBG) logd("manually selected network operator: " + operatorInfo.toString()); |
| phone.selectNetworkManually(operatorInfo, true, msg); |
| setProgressBarVisible(true); |
| return true; |
| } else { |
| loge("Error selecting network. phone is null."); |
| mSelectedNetworkOperatorPreference = null; |
| return false; |
| } |
| |
| } else { |
| preferenceScreen.setEnabled(false); |
| return false; |
| } |
| } |
| |
| @Override |
| public void onAttach(Activity activity) { |
| super.onAttach(activity); |
| if (!(getActivity() instanceof NetworkSelectSettingActivity)) { |
| throw new IllegalStateException("Parent activity is not NetworkSelectSettingActivity"); |
| } |
| } |
| |
| @Override |
| public void onStop() { |
| super.onStop(); |
| if (DBG) logd("onStop"); |
| getView().removeCallbacks(mUpdateNetworkOperatorsRunnable); |
| stopNetworkQuery(); |
| // Unbind the NetworkQueryService |
| unbindNetworkQueryService(); |
| } |
| |
| private final Handler mHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| AsyncResult ar; |
| switch (msg.what) { |
| case EVENT_NETWORK_SELECTION_DONE: |
| if (DBG) logd("network selection done: hide the progress header"); |
| setProgressBarVisible(false); |
| |
| ar = (AsyncResult) msg.obj; |
| if (ar.exception != null) { |
| if (DBG) logd("manual network selection: failed! "); |
| updateNetworkSelection(); |
| // Set summary as "Couldn't connect" to the selected network. |
| mSelectedNetworkOperatorPreference.setSummary( |
| R.string.network_could_not_connect); |
| } else { |
| if (DBG) logd("manual network selection: succeeded! "); |
| // Set summary as "Connected" to the selected network. |
| mSelectedNetworkOperatorPreference.setSummary(R.string.network_connected); |
| } |
| break; |
| |
| case EVENT_NETWORK_SCAN_RESULTS: |
| List<CellInfo> results = aggregateCellInfoList((List<CellInfo>) msg.obj); |
| mCellInfoList = new ArrayList<>(results); |
| if (DBG) logd("after aggregate: " + mCellInfoList.toString()); |
| if (mCellInfoList != null && mCellInfoList.size() != 0) { |
| updateNetworkOperators(); |
| } else { |
| addMessagePreference(R.string.empty_networks_list); |
| } |
| |
| break; |
| |
| case EVENT_NETWORK_SCAN_ERROR: |
| int error = msg.arg1; |
| if (DBG) logd("error while querying available networks " + error); |
| stopNetworkQuery(); |
| addMessagePreference(R.string.network_query_error); |
| break; |
| |
| case EVENT_NETWORK_SCAN_COMPLETED: |
| stopNetworkQuery(); |
| if (DBG) logd("scan complete"); |
| if (mCellInfoList == null) { |
| // In case the scan timeout before getting any results |
| addMessagePreference(R.string.empty_networks_list); |
| } |
| break; |
| } |
| return; |
| } |
| }; |
| |
| private void loadNetworksList() { |
| if (DBG) logd("load networks list..."); |
| setProgressBarVisible(true); |
| try { |
| if (mNetworkQueryService != null) { |
| if (DBG) logd("start network query"); |
| mNetworkQueryService |
| .startNetworkQuery(mCallback, mPhoneId, true /* is incremental result */); |
| } else { |
| if (DBG) logd("unable to start network query, mNetworkQueryService is null"); |
| addMessagePreference(R.string.network_query_error); |
| } |
| } catch (RemoteException e) { |
| loge("loadNetworksList: exception from startNetworkQuery " + e); |
| addMessagePreference(R.string.network_query_error); |
| } |
| } |
| |
| /** |
| * This implementation of INetworkQueryServiceCallback is used to receive |
| * callback notifications from the network query service. |
| */ |
| private final INetworkQueryServiceCallback mCallback = new INetworkQueryServiceCallback.Stub() { |
| |
| /** Returns the scan results to the user, this callback will be called at lease one time. */ |
| public void onResults(List<CellInfo> results) { |
| if (DBG) logd("get scan results."); |
| 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) logd("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) logd("get onError callback with error code: " + error); |
| Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_ERROR, error, 0 /* arg2 */); |
| msg.sendToTarget(); |
| } |
| }; |
| |
| /** |
| * Updates network operators from {@link INetworkQueryServiceCallback#onResults()}. |
| */ |
| private void updateNetworkOperators() { |
| if (DBG) logd("updateNetworkOperators"); |
| if (getActivity() != null) { |
| final View view = getView(); |
| final Handler handler = view.getHandler(); |
| if (handler != null && handler.hasCallbacks(mUpdateNetworkOperatorsRunnable)) { |
| return; |
| } |
| view.post(mUpdateNetworkOperatorsRunnable); |
| } |
| } |
| |
| /** |
| * Update the currently available network operators list, which only contains the unregistered |
| * network operators. So if the device has no data and the network operator in the connected |
| * network operator category shows "Disconnected", it will also exist in the available network |
| * operator category for user to select. On the other hand, if the device has data and the |
| * network operator in the connected network operator category shows "Connected", it will not |
| * exist in the available network category. |
| */ |
| private void updateNetworkOperatorsPreferenceCategory() { |
| mNetworkOperatorsPreferences.removeAll(); |
| |
| configConnectedNetworkOperatorsPreferenceCategory(); |
| for (int index = 0; index < mCellInfoList.size(); index++) { |
| if (!mCellInfoList.get(index).isRegistered()) { |
| NetworkOperatorPreference pref = new NetworkOperatorPreference( |
| mCellInfoList.get(index), getContext(), mForbiddenPlmns); |
| pref.setKey(CellInfoUtil.getNetworkTitle(mCellInfoList.get(index))); |
| pref.setOrder(index); |
| mNetworkOperatorsPreferences.addPreference(pref); |
| } |
| } |
| } |
| |
| /** |
| * Config the connected network operator preference when the page was created. When user get |
| * into this page, the device might or might not have data connection. |
| * - If the device has data: |
| * 1. use {@code ServiceState#getNetworkRegistrationStates()} to get the currently |
| * registered cellIdentity, wrap it into a CellInfo; |
| * 2. set the signal strength level as strong; |
| * 3. use {@link TelephonyManager#getNetworkOperatorName()} to get the title of the |
| * previously connected network operator, since the CellIdentity got from step 1 only has |
| * PLMN. |
| * - If the device has no data, we will remove the connected network operators list from the |
| * screen. |
| */ |
| private void forceConfigConnectedNetworkOperatorsPreferenceCategory() { |
| if (DBG) logd("Force config ConnectedNetworkOperatorsPreferenceCategory"); |
| if (mTelephonyManager.getDataState() == mTelephonyManager.DATA_CONNECTED) { |
| // Try to get the network registration states |
| ServiceState ss = mTelephonyManager.getServiceStateForSubscriber(mPhoneId); |
| List<NetworkRegistrationState> networkList = |
| ss.getNetworkRegistrationStates(AccessNetworkConstants.TransportType.WWAN); |
| if (networkList == null || networkList.size() == 0) { |
| loge("getNetworkRegistrationStates return null"); |
| // Remove the connected network operators category |
| removeConnectedNetworkOperatorPreference(); |
| return; |
| } |
| CellIdentity cellIdentity = networkList.get(0).getCellIdentity(); |
| CellInfo cellInfo = CellInfoUtil.wrapCellInfoWithCellIdentity(cellIdentity); |
| if (cellInfo != null) { |
| if (DBG) logd("Currently registered cell: " + cellInfo.toString()); |
| NetworkOperatorPreference pref = |
| new NetworkOperatorPreference(cellInfo, getContext(), mForbiddenPlmns); |
| pref.setTitle(mTelephonyManager.getNetworkOperatorName()); |
| pref.setSummary(R.string.network_connected); |
| // Update the signal strength icon, since the default signalStrength value would be |
| // zero (it would be quite confusing why the connected network has no signal) |
| pref.setIcon(NetworkOperatorPreference.NUMBER_OF_LEVELS - 1); |
| |
| mConnectedNetworkOperatorsPreference.addPreference(pref); |
| } else { |
| loge("Invalid CellIfno: " + cellInfo.toString()); |
| // Remove the connected network operators category |
| removeConnectedNetworkOperatorPreference(); |
| } |
| } else { |
| if (DBG) logd("No currently registered cell"); |
| // Remove the connected network operators category |
| removeConnectedNetworkOperatorPreference(); |
| } |
| } |
| |
| /** |
| * Configure the ConnectedNetworkOperatorsPreferenceCategory. The category only need to be |
| * configured if the category is currently empty or the operator network title of the previous |
| * connected network is different from the new one. |
| */ |
| private void configConnectedNetworkOperatorsPreferenceCategory() { |
| if (DBG) logd("config ConnectedNetworkOperatorsPreferenceCategory"); |
| // Remove the category if the CellInfo list is empty or does not have registered cell. |
| if (mCellInfoList.size() == 0) { |
| if (DBG) logd("empty cellinfo list"); |
| removeConnectedNetworkOperatorPreference(); |
| } |
| CellInfo connectedNetworkOperator = null; |
| for (CellInfo cellInfo: mCellInfoList) { |
| if (cellInfo.isRegistered()) { |
| connectedNetworkOperator = cellInfo; |
| break; |
| } |
| } |
| if (connectedNetworkOperator == null) { |
| if (DBG) logd("no registered network"); |
| removeConnectedNetworkOperatorPreference(); |
| return; |
| } |
| |
| // config the category if it is empty. |
| if (mConnectedNetworkOperatorsPreference.getPreferenceCount() == 0) { |
| if (DBG) logd("ConnectedNetworkSelectList is empty, add one"); |
| addConnectedNetworkOperatorPreference(connectedNetworkOperator); |
| return; |
| } |
| NetworkOperatorPreference previousConnectedNetworkOperator = (NetworkOperatorPreference) |
| (mConnectedNetworkOperatorsPreference.getPreference(0)); |
| |
| // config the category if the network title of the previous connected network is different |
| // from the new one. |
| String cTitle = CellInfoUtil.getNetworkTitle(connectedNetworkOperator); |
| String pTitle = CellInfoUtil.getNetworkTitle( |
| previousConnectedNetworkOperator.getCellInfo()); |
| if (!cTitle.equals(pTitle)) { |
| if (DBG) logd("reconfig the category: connected network changed"); |
| addConnectedNetworkOperatorPreference(connectedNetworkOperator); |
| return; |
| } |
| if (DBG) logd("same network operator is connected, only refresh the connected network"); |
| // Otherwise same network operator is connected, only refresh the connected network |
| // operator preference (first and the only one in this category). |
| ((NetworkOperatorPreference) mConnectedNetworkOperatorsPreference.getPreference(0)) |
| .refresh(); |
| return; |
| } |
| |
| /** |
| * Creates a Preference for the given {@link CellInfo} and adds it to the |
| * {@link #mConnectedNetworkOperatorsPreference}. |
| */ |
| private void addConnectedNetworkOperatorPreference(CellInfo cellInfo) { |
| if (DBG) logd("addConnectedNetworkOperatorPreference"); |
| // Remove the current ConnectedNetworkOperatorsPreference |
| removeConnectedNetworkOperatorPreference(); |
| final NetworkOperatorPreference pref = |
| new NetworkOperatorPreference(cellInfo, getContext(), mForbiddenPlmns); |
| pref.setSummary(R.string.network_connected); |
| mConnectedNetworkOperatorsPreference.addPreference(pref); |
| PreferenceScreen preferenceScreen = getPreferenceScreen(); |
| preferenceScreen.addPreference(mConnectedNetworkOperatorsPreference); |
| } |
| |
| /** Removes all preferences and hide the {@link #mConnectedNetworkOperatorsPreference}. */ |
| private void removeConnectedNetworkOperatorPreference() { |
| mConnectedNetworkOperatorsPreference.removeAll(); |
| PreferenceScreen preferenceScreen = getPreferenceScreen(); |
| preferenceScreen.removePreference(mConnectedNetworkOperatorsPreference); |
| } |
| |
| protected void setProgressBarVisible(boolean visible) { |
| if (mProgressHeader != null) { |
| mProgressHeader.setVisibility(visible ? View.VISIBLE : View.GONE); |
| } |
| } |
| |
| private void addMessagePreference(int messageId) { |
| if (DBG) logd("remove callback"); |
| getView().removeCallbacks(mUpdateNetworkOperatorsRunnable); |
| setProgressBarVisible(false); |
| if (DBG) logd("addMessagePreference"); |
| mStatusMessagePreference.setTitle(messageId); |
| removeConnectedNetworkOperatorPreference(); |
| mNetworkOperatorsPreferences.removeAll(); |
| mNetworkOperatorsPreferences.addPreference(mStatusMessagePreference); |
| } |
| |
| /** |
| * The Scan results may contains several cell infos with different radio technologies and signal |
| * strength for one network operator. Aggregate the CellInfoList by retaining only the cell info |
| * with the strongest signal strength. |
| */ |
| private List<CellInfo> aggregateCellInfoList(List<CellInfo> cellInfoList) { |
| if (DBG) logd("before aggregate: " + cellInfoList.toString()); |
| Map<String, CellInfo> map = new HashMap<>(); |
| for (CellInfo cellInfo: cellInfoList) { |
| String networkTitle = CellInfoUtil.getNetworkTitle(cellInfo); |
| if (cellInfo.isRegistered() || !map.containsKey(networkTitle)) { |
| map.put(networkTitle, cellInfo); |
| } else { |
| if (map.get(networkTitle).isRegistered() |
| || CellInfoUtil.getLevel(map.get(networkTitle)) |
| > CellInfoUtil.getLevel(cellInfo)) { |
| // Skip if the stored cellInfo is registered or has higher signal strength level |
| continue; |
| } |
| // Otherwise replace it with the new CellInfo |
| map.put(networkTitle, cellInfo); |
| } |
| } |
| return new ArrayList<>(map.values()); |
| } |
| |
| /** |
| * Service connection code for the NetworkQueryService. |
| * Handles the work of binding to a local object so that we can make |
| * the appropriate service calls. |
| */ |
| |
| /** Local service interface */ |
| private INetworkQueryService mNetworkQueryService = null; |
| /** Flag indicating whether we have called bind on the service. */ |
| boolean mShouldUnbind; |
| |
| /** Service connection */ |
| private final ServiceConnection mNetworkQueryServiceConnection = new ServiceConnection() { |
| |
| /** Handle the task of binding the local object to the service */ |
| public void onServiceConnected(ComponentName className, IBinder service) { |
| if (DBG) logd("connection created, binding local service."); |
| mNetworkQueryService = ((NetworkQueryService.LocalBinder) service).getService(); |
| // Load the network list only when the service is well connected. |
| loadNetworksList(); |
| } |
| |
| /** Handle the task of cleaning up the local binding */ |
| public void onServiceDisconnected(ComponentName className) { |
| if (DBG) logd("connection disconnected, cleaning local binding."); |
| mNetworkQueryService = null; |
| } |
| }; |
| |
| private void bindNetworkQueryService() { |
| if (DBG) logd("bindNetworkQueryService"); |
| getContext().bindService(new Intent(getContext(), NetworkQueryService.class).setAction( |
| NetworkQueryService.ACTION_LOCAL_BINDER), |
| mNetworkQueryServiceConnection, Context.BIND_AUTO_CREATE); |
| mShouldUnbind = true; |
| } |
| |
| private void unbindNetworkQueryService() { |
| if (DBG) logd("unbindNetworkQueryService"); |
| if (mShouldUnbind) { |
| if (DBG) logd("mShouldUnbind is true"); |
| // unbind the service. |
| getContext().unbindService(mNetworkQueryServiceConnection); |
| mShouldUnbind = false; |
| } |
| } |
| |
| /** |
| * Call {@link NotificationMgr#updateNetworkSelection(int, int)} to send notification about |
| * no service of user selected operator |
| */ |
| private void updateNetworkSelection() { |
| if (DBG) logd("Update notification about no service of user selected operator"); |
| final PhoneGlobals app = PhoneGlobals.getInstance(); |
| Phone phone = PhoneFactory.getPhone(mPhoneId); |
| if (phone != null) { |
| ServiceState ss = mTelephonyManager.getServiceStateForSubscriber(phone.getSubId()); |
| if (ss != null) { |
| app.notificationMgr.updateNetworkSelection(ss.getState(), phone.getSubId()); |
| } |
| } |
| } |
| |
| private void stopNetworkQuery() { |
| // Stop the network query process |
| try { |
| if (mNetworkQueryService != null) { |
| if (DBG) logd("Stop network query"); |
| mNetworkQueryService.stopNetworkQuery(); |
| mNetworkQueryService.unregisterCallback(mCallback); |
| } |
| } catch (RemoteException e) { |
| loge("Exception from stopNetworkQuery " + e); |
| } |
| } |
| |
| private void logd(String msg) { |
| Log.d(TAG, msg); |
| } |
| |
| private void loge(String msg) { |
| Log.e(TAG, msg); |
| } |
| } |
