com/android/internal/telephony/dataconnection/DataThrottler.java - platform/prebuilts/fullsdk/sources/android-31 - Git at Google

 /*
  * Copyright (C) 2020 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.internal.telephony.dataconnection;

 import android.annotation.ElapsedRealtimeLong;
 import android.annotation.NonNull;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.os.AsyncResult;
 import android.os.Handler;
 import android.os.Message;
 import android.os.PersistableBundle;
 import android.telephony.AccessNetworkConstants;
 import android.telephony.Annotation;
 import android.telephony.Annotation.ApnType;
 import android.telephony.CarrierConfigManager;
 import android.telephony.SubscriptionManager;
 import android.telephony.data.ApnSetting;
 import android.telephony.data.ThrottleStatus;

 import com.android.internal.telephony.Phone;
 import com.android.internal.telephony.RetryManager;
 import com.android.telephony.Rlog;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;

 /**
  * Data throttler tracks the throttling status of the data network and notifies registrants when
  * there are changes.  The throttler is per phone and per transport type.
  */
 public class DataThrottler extends Handler {
     private static final String TAG = DataThrottler.class.getSimpleName();

     private static final int EVENT_SET_RETRY_TIME = 1;
     private static final int EVENT_CARRIER_CONFIG_CHANGED = 2;
     private static final int EVENT_RESET = 3;
     private static final int EVENT_AIRPLANE_MODE_CHANGED = 4;
     private static final int EVENT_TRACING_AREA_CODE_CHANGED = 5;

     private final Phone mPhone;
     private final int mSlotIndex;
     private final @AccessNetworkConstants.TransportType int mTransportType;
     private boolean mResetWhenAreaCodeChanged = false;

     /**
      * Callbacks that report the apn throttle status.
      */
     private final List<DataThrottler.Callback> mCallbacks = new ArrayList<>();

     /**
      * Keeps track of detailed information of the throttle status that is meant to be
      * reported to other components.
      */
     private final Map<Integer, ThrottleStatus> mThrottleStatus = new ConcurrentHashMap<>();

     private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
             if (intent.getAction().equals(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED)) {
                 if (mPhone.getPhoneId() == intent.getIntExtra(CarrierConfigManager.EXTRA_SLOT_INDEX,
                         SubscriptionManager.INVALID_SIM_SLOT_INDEX)) {
                     if (intent.getBooleanExtra(
                             CarrierConfigManager.EXTRA_REBROADCAST_ON_UNLOCK, false)) {
                         // Ignore the rebroadcast one to prevent multiple carrier config changed
                         // event during boot up.
                         return;
                     }
                     int subId = intent.getIntExtra(SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX,
                             SubscriptionManager.INVALID_SUBSCRIPTION_ID);
                     if (SubscriptionManager.isValidSubscriptionId(subId)) {
                         sendEmptyMessage(EVENT_CARRIER_CONFIG_CHANGED);
                     }
                 }
             }
         }
     };

     public DataThrottler(Phone phone, int transportType) {
         super(null, false);
         mPhone = phone;
         mSlotIndex = phone.getPhoneId();
         mTransportType = transportType;

         IntentFilter filter = new IntentFilter();
         filter.addAction(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
         mPhone.getContext().registerReceiver(mBroadcastReceiver, filter, null, mPhone);

         mPhone.getServiceStateTracker().registerForAirplaneModeChanged(this,
                 EVENT_AIRPLANE_MODE_CHANGED, null);
         mPhone.getServiceStateTracker().registerForAreaCodeChanged(this,
                 EVENT_TRACING_AREA_CODE_CHANGED, null);
     }

     @Override
     public void handleMessage(Message msg) {
         AsyncResult ar;
         switch (msg.what) {
             case EVENT_SET_RETRY_TIME:
                 int apnTypes = msg.arg1;
                 int newRequestType = msg.arg2;
                 long retryElapsedTime = (long) msg.obj;
                 setRetryTimeInternal(apnTypes, retryElapsedTime, newRequestType);
                 break;
             case EVENT_CARRIER_CONFIG_CHANGED:
                 onCarrierConfigChanged();
                 break;
             case EVENT_RESET:
                 resetInternal();
                 break;
             case EVENT_AIRPLANE_MODE_CHANGED:
                 ar = (AsyncResult) msg.obj;
                 if (!(Boolean) ar.result) {
                     resetInternal();
                 }
                 break;
             case EVENT_TRACING_AREA_CODE_CHANGED:
                 if (mResetWhenAreaCodeChanged) {
                     resetInternal();
                 }
                 break;
         }
     }

     @NonNull
     private PersistableBundle getCarrierConfig() {
         CarrierConfigManager configManager = (CarrierConfigManager) mPhone.getContext()
                 .getSystemService(Context.CARRIER_CONFIG_SERVICE);
         if (configManager != null) {
             // If an invalid subId is used, this bundle will contain default values.
             PersistableBundle config = configManager.getConfigForSubId(mPhone.getSubId());
             if (config != null) {
                 return config;
             }
         }
         // Return static default defined in CarrierConfigManager.
         return CarrierConfigManager.getDefaultConfig();
     }

     private void onCarrierConfigChanged() {
         PersistableBundle config = getCarrierConfig();
         mResetWhenAreaCodeChanged = config.getBoolean(
                 CarrierConfigManager.KEY_UNTHROTTLE_DATA_RETRY_WHEN_TAC_CHANGES_BOOL, false);
     }

     /**
      * Set the retry time and handover failure mode for the give APN types.
      *
      * @param apnTypes APN types
      * @param retryElapsedTime The elapsed time that data connection for APN types should not be
      * retried. {@link RetryManager#NO_SUGGESTED_RETRY_DELAY} indicates throttling does not exist.
      * {@link RetryManager#NO_RETRY} indicates retry should never happen.
      */
     public void setRetryTime(@ApnType int apnTypes, @ElapsedRealtimeLong long retryElapsedTime,
             @DcTracker.RequestNetworkType int newRequestType) {
         sendMessage(obtainMessage(EVENT_SET_RETRY_TIME, apnTypes, newRequestType,
                 retryElapsedTime));
     }

     /**
      * Set the retry time and handover failure mode for the give APN types. This is running on the
      * handler thread.
      *
      * @param apnTypes APN types
      * @param retryElapsedTime The elapsed time that data connection for APN types should not be
      * retried. {@link RetryManager#NO_SUGGESTED_RETRY_DELAY} indicates throttling does not exist.
      * {@link RetryManager#NO_RETRY} indicates retry should never happen.
      */
     private void setRetryTimeInternal(@ApnType int apnTypes, @ElapsedRealtimeLong
             long retryElapsedTime, @DcTracker.RequestNetworkType int newRequestType) {
         if (retryElapsedTime < 0) {
             retryElapsedTime = RetryManager.NO_SUGGESTED_RETRY_DELAY;
         }

         List<ThrottleStatus> changedStatuses = new ArrayList<>();
         while (apnTypes != 0) {

             //Extract the least significant bit.
             int apnType = apnTypes & -apnTypes;

             //Update the apn throttle status
             ThrottleStatus newStatus = createStatus(apnType, retryElapsedTime, newRequestType);

             ThrottleStatus oldStatus = mThrottleStatus.get(apnType);

             //Check to see if there is a change that needs to be applied
             if (!newStatus.equals(oldStatus)) {
                 //Mark as changed status
                 changedStatuses.add(newStatus);

                 //Put the new status in the temp space
                 mThrottleStatus.put(apnType, newStatus);
             }

             //Remove the least significant bit.
             apnTypes &= apnTypes - 1;
         }

         if (changedStatuses.size() > 0) {
             sendThrottleStatusChanged(changedStatuses);
         }
     }

     /**
      * Get the earliest retry time for the given APN type. The time is the system's elapse time.
      *
      * Note the DataThrottler is running phone process's main thread, which is most of the telephony
      * components running on. Calling this method from other threads might run into race conditions.
      *
      * @param apnType APN type
      * @return The earliest retry time for APN type. The time is the system's elapse time.
      * {@link RetryManager#NO_SUGGESTED_RETRY_DELAY} indicates there is no throttling for given APN
      * type, {@link RetryManager#NO_RETRY} indicates retry should never happen.
      */
     @ElapsedRealtimeLong
     public long getRetryTime(@ApnType int apnType) {
         // This is the workaround to handle the mistake that
         // ApnSetting.TYPE_DEFAULT = ApnTypes.DEFAULT | ApnTypes.HIPRI.
         if (apnType == ApnSetting.TYPE_DEFAULT) {
             apnType &= ~(ApnSetting.TYPE_HIPRI);
         }

         ThrottleStatus status = mThrottleStatus.get(apnType);
         if (status != null) {
             if (status.getThrottleType() == ThrottleStatus.THROTTLE_TYPE_NONE) {
                 return RetryManager.NO_SUGGESTED_RETRY_DELAY;
             } else {
                 return status.getThrottleExpiryTimeMillis();
             }
         }
         return RetryManager.NO_SUGGESTED_RETRY_DELAY;
     }

     /**
      * Resets retry times for all APNs to {@link RetryManager.NO_SUGGESTED_RETRY_DELAY}.
      */
     public void reset() {
         sendEmptyMessage(EVENT_RESET);
     }

     /**
      * Resets retry times for all APNs to {@link RetryManager.NO_SUGGESTED_RETRY_DELAY}.
      */
     private void resetInternal() {
         final List<Integer> apnTypes = new ArrayList<>();
         for (ThrottleStatus throttleStatus : mThrottleStatus.values()) {
             apnTypes.add(throttleStatus.getApnType());
         }

         for (int apnType : apnTypes) {
             setRetryTime(apnType, RetryManager.NO_SUGGESTED_RETRY_DELAY,
                     DcTracker.REQUEST_TYPE_NORMAL);
         }
     }

     private ThrottleStatus createStatus(@Annotation.ApnType int apnType, long retryElapsedTime,
             @DcTracker.RequestNetworkType int newRequestType) {
         ThrottleStatus.Builder builder = new ThrottleStatus.Builder();

         if (retryElapsedTime == RetryManager.NO_SUGGESTED_RETRY_DELAY) {
             builder
                     .setNoThrottle()
                     .setRetryType(getRetryType(newRequestType));
         } else if (retryElapsedTime == RetryManager.NO_RETRY) {
             builder
                     .setThrottleExpiryTimeMillis(RetryManager.NO_RETRY)
                     .setRetryType(ThrottleStatus.RETRY_TYPE_NONE);
         } else {
             builder
                     .setThrottleExpiryTimeMillis(retryElapsedTime)
                     .setRetryType(getRetryType(newRequestType));
         }
         return builder
                 .setSlotIndex(mSlotIndex)
                 .setTransportType(mTransportType)
                 .setApnType(apnType)
                 .build();
     }

     private static int getRetryType(@DcTracker.RequestNetworkType int newRequestType) {
         if (newRequestType == DcTracker.REQUEST_TYPE_NORMAL) {
             return ThrottleStatus.RETRY_TYPE_NEW_CONNECTION;
         }

         if (newRequestType == DcTracker.REQUEST_TYPE_HANDOVER) {
             return  ThrottleStatus.RETRY_TYPE_HANDOVER;
         }

         loge("createStatus: Unknown requestType=" + newRequestType);
         return ThrottleStatus.RETRY_TYPE_NEW_CONNECTION;
     }

     private void sendThrottleStatusChanged(List<ThrottleStatus> statuses) {
         synchronized (mCallbacks) {
             for (int i = 0; i < mCallbacks.size(); i++) {
                 mCallbacks.get(i).onThrottleStatusChanged(statuses);
             }
         }
     }

     private static void loge(String s) {
         Rlog.e(TAG, s);
     }

     /**
      * Reports changes to apn throttle statuses.
      *
      * Note: All statuses are sent when first registered.
      *
      * @param callback status changes callback
      */
     public void registerForThrottleStatusChanges(DataThrottler.Callback callback) {
         synchronized (mCallbacks) {
             //Only add if it's not there already
             if (!mCallbacks.contains(callback)) {
                 //Report everything the first time
                 List<ThrottleStatus> throttleStatuses =
                         new ArrayList<>(mThrottleStatus.values());
                 callback.onThrottleStatusChanged(throttleStatuses);
                 mCallbacks.add(callback);
             }
         }
     }

     /**
      * Unregister the callback
      * @param callback the callback to unregister
      */
     public void unregisterForThrottleStatusChanges(DataThrottler.Callback callback) {
         synchronized (mCallbacks) {
             mCallbacks.remove(callback);
         }
     }

     /**
      * Callback for when throttle statuses change
      */
     public interface Callback {
         /**
          * Called whenever the throttle status of an APN has changed.
          *
          * Note: Called with all statuses when first registered.
          *
          * @param throttleStatuses the status changes
          */
         void onThrottleStatusChanged(List<ThrottleStatus> throttleStatuses);
     }
 }
	/*
	* Copyright (C) 2020 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.internal.telephony.dataconnection;

	import android.annotation.ElapsedRealtimeLong;
	import android.annotation.NonNull;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.os.AsyncResult;
	import android.os.Handler;
	import android.os.Message;
	import android.os.PersistableBundle;
	import android.telephony.AccessNetworkConstants;
	import android.telephony.Annotation;
	import android.telephony.Annotation.ApnType;
	import android.telephony.CarrierConfigManager;
	import android.telephony.SubscriptionManager;
	import android.telephony.data.ApnSetting;
	import android.telephony.data.ThrottleStatus;

	import com.android.internal.telephony.Phone;
	import com.android.internal.telephony.RetryManager;
	import com.android.telephony.Rlog;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Map;
	import java.util.concurrent.ConcurrentHashMap;

	/**
	* Data throttler tracks the throttling status of the data network and notifies registrants when
	* there are changes. The throttler is per phone and per transport type.
	*/
	public class DataThrottler extends Handler {
	private static final String TAG = DataThrottler.class.getSimpleName();

	private static final int EVENT_SET_RETRY_TIME = 1;
	private static final int EVENT_CARRIER_CONFIG_CHANGED = 2;
	private static final int EVENT_RESET = 3;
	private static final int EVENT_AIRPLANE_MODE_CHANGED = 4;
	private static final int EVENT_TRACING_AREA_CODE_CHANGED = 5;

	private final Phone mPhone;
	private final int mSlotIndex;
	private final @AccessNetworkConstants.TransportType int mTransportType;
	private boolean mResetWhenAreaCodeChanged = false;

	/**
	* Callbacks that report the apn throttle status.
	*/
	private final List<DataThrottler.Callback> mCallbacks = new ArrayList<>();

	/**
	* Keeps track of detailed information of the throttle status that is meant to be
	* reported to other components.
	*/
	private final Map<Integer, ThrottleStatus> mThrottleStatus = new ConcurrentHashMap<>();

	private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	if (intent.getAction().equals(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED)) {
	if (mPhone.getPhoneId() == intent.getIntExtra(CarrierConfigManager.EXTRA_SLOT_INDEX,
	SubscriptionManager.INVALID_SIM_SLOT_INDEX)) {
	if (intent.getBooleanExtra(
	CarrierConfigManager.EXTRA_REBROADCAST_ON_UNLOCK, false)) {
	// Ignore the rebroadcast one to prevent multiple carrier config changed
	// event during boot up.
	return;
	}
	int subId = intent.getIntExtra(SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX,
	SubscriptionManager.INVALID_SUBSCRIPTION_ID);
	if (SubscriptionManager.isValidSubscriptionId(subId)) {
	sendEmptyMessage(EVENT_CARRIER_CONFIG_CHANGED);
	}
	}
	}
	}
	};

	public DataThrottler(Phone phone, int transportType) {
	super(null, false);
	mPhone = phone;
	mSlotIndex = phone.getPhoneId();
	mTransportType = transportType;

	IntentFilter filter = new IntentFilter();
	filter.addAction(CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED);
	mPhone.getContext().registerReceiver(mBroadcastReceiver, filter, null, mPhone);

	mPhone.getServiceStateTracker().registerForAirplaneModeChanged(this,
	EVENT_AIRPLANE_MODE_CHANGED, null);
	mPhone.getServiceStateTracker().registerForAreaCodeChanged(this,
	EVENT_TRACING_AREA_CODE_CHANGED, null);
	}

	@Override
	public void handleMessage(Message msg) {
	AsyncResult ar;
	switch (msg.what) {
	case EVENT_SET_RETRY_TIME:
	int apnTypes = msg.arg1;
	int newRequestType = msg.arg2;
	long retryElapsedTime = (long) msg.obj;
	setRetryTimeInternal(apnTypes, retryElapsedTime, newRequestType);
	break;
	case EVENT_CARRIER_CONFIG_CHANGED:
	onCarrierConfigChanged();
	break;
	case EVENT_RESET:
	resetInternal();
	break;
	case EVENT_AIRPLANE_MODE_CHANGED:
	ar = (AsyncResult) msg.obj;
	if (!(Boolean) ar.result) {
	resetInternal();
	}
	break;
	case EVENT_TRACING_AREA_CODE_CHANGED:
	if (mResetWhenAreaCodeChanged) {
	resetInternal();
	}
	break;
	}
	}

	@NonNull
	private PersistableBundle getCarrierConfig() {
	CarrierConfigManager configManager = (CarrierConfigManager) mPhone.getContext()
	.getSystemService(Context.CARRIER_CONFIG_SERVICE);
	if (configManager != null) {
	// If an invalid subId is used, this bundle will contain default values.
	PersistableBundle config = configManager.getConfigForSubId(mPhone.getSubId());
	if (config != null) {
	return config;
	}
	}
	// Return static default defined in CarrierConfigManager.
	return CarrierConfigManager.getDefaultConfig();
	}

	private void onCarrierConfigChanged() {
	PersistableBundle config = getCarrierConfig();
	mResetWhenAreaCodeChanged = config.getBoolean(
	CarrierConfigManager.KEY_UNTHROTTLE_DATA_RETRY_WHEN_TAC_CHANGES_BOOL, false);
	}

	/**
	* Set the retry time and handover failure mode for the give APN types.
	*
	* @param apnTypes APN types
	* @param retryElapsedTime The elapsed time that data connection for APN types should not be
	* retried. {@link RetryManager#NO_SUGGESTED_RETRY_DELAY} indicates throttling does not exist.
	* {@link RetryManager#NO_RETRY} indicates retry should never happen.
	*/
	public void setRetryTime(@ApnType int apnTypes, @ElapsedRealtimeLong long retryElapsedTime,
	@DcTracker.RequestNetworkType int newRequestType) {
	sendMessage(obtainMessage(EVENT_SET_RETRY_TIME, apnTypes, newRequestType,
	retryElapsedTime));
	}

	/**
	* Set the retry time and handover failure mode for the give APN types. This is running on the
	* handler thread.
	*
	* @param apnTypes APN types
	* @param retryElapsedTime The elapsed time that data connection for APN types should not be
	* retried. {@link RetryManager#NO_SUGGESTED_RETRY_DELAY} indicates throttling does not exist.
	* {@link RetryManager#NO_RETRY} indicates retry should never happen.
	*/
	private void setRetryTimeInternal(@ApnType int apnTypes, @ElapsedRealtimeLong
	long retryElapsedTime, @DcTracker.RequestNetworkType int newRequestType) {
	if (retryElapsedTime < 0) {
	retryElapsedTime = RetryManager.NO_SUGGESTED_RETRY_DELAY;
	}

	List<ThrottleStatus> changedStatuses = new ArrayList<>();
	while (apnTypes != 0) {

	//Extract the least significant bit.
	int apnType = apnTypes & -apnTypes;

	//Update the apn throttle status
	ThrottleStatus newStatus = createStatus(apnType, retryElapsedTime, newRequestType);

	ThrottleStatus oldStatus = mThrottleStatus.get(apnType);

	//Check to see if there is a change that needs to be applied
	if (!newStatus.equals(oldStatus)) {
	//Mark as changed status
	changedStatuses.add(newStatus);

	//Put the new status in the temp space
	mThrottleStatus.put(apnType, newStatus);
	}

	//Remove the least significant bit.
	apnTypes &= apnTypes - 1;
	}

	if (changedStatuses.size() > 0) {
	sendThrottleStatusChanged(changedStatuses);
	}
	}

	/**
	* Get the earliest retry time for the given APN type. The time is the system's elapse time.
	*
	* Note the DataThrottler is running phone process's main thread, which is most of the telephony
	* components running on. Calling this method from other threads might run into race conditions.
	*
	* @param apnType APN type
	* @return The earliest retry time for APN type. The time is the system's elapse time.
	* {@link RetryManager#NO_SUGGESTED_RETRY_DELAY} indicates there is no throttling for given APN
	* type, {@link RetryManager#NO_RETRY} indicates retry should never happen.
	*/
	@ElapsedRealtimeLong
	public long getRetryTime(@ApnType int apnType) {
	// This is the workaround to handle the mistake that
	// ApnSetting.TYPE_DEFAULT = ApnTypes.DEFAULT \| ApnTypes.HIPRI.
	if (apnType == ApnSetting.TYPE_DEFAULT) {
	apnType &= ~(ApnSetting.TYPE_HIPRI);
	}

	ThrottleStatus status = mThrottleStatus.get(apnType);
	if (status != null) {
	if (status.getThrottleType() == ThrottleStatus.THROTTLE_TYPE_NONE) {
	return RetryManager.NO_SUGGESTED_RETRY_DELAY;
	} else {
	return status.getThrottleExpiryTimeMillis();
	}
	}
	return RetryManager.NO_SUGGESTED_RETRY_DELAY;
	}

	/**
	* Resets retry times for all APNs to {@link RetryManager.NO_SUGGESTED_RETRY_DELAY}.
	*/
	public void reset() {
	sendEmptyMessage(EVENT_RESET);
	}

	/**
	* Resets retry times for all APNs to {@link RetryManager.NO_SUGGESTED_RETRY_DELAY}.
	*/
	private void resetInternal() {
	final List<Integer> apnTypes = new ArrayList<>();
	for (ThrottleStatus throttleStatus : mThrottleStatus.values()) {
	apnTypes.add(throttleStatus.getApnType());
	}

	for (int apnType : apnTypes) {
	setRetryTime(apnType, RetryManager.NO_SUGGESTED_RETRY_DELAY,
	DcTracker.REQUEST_TYPE_NORMAL);
	}
	}

	private ThrottleStatus createStatus(@Annotation.ApnType int apnType, long retryElapsedTime,
	@DcTracker.RequestNetworkType int newRequestType) {
	ThrottleStatus.Builder builder = new ThrottleStatus.Builder();

	if (retryElapsedTime == RetryManager.NO_SUGGESTED_RETRY_DELAY) {
	builder
	.setNoThrottle()
	.setRetryType(getRetryType(newRequestType));
	} else if (retryElapsedTime == RetryManager.NO_RETRY) {
	builder
	.setThrottleExpiryTimeMillis(RetryManager.NO_RETRY)
	.setRetryType(ThrottleStatus.RETRY_TYPE_NONE);
	} else {
	builder
	.setThrottleExpiryTimeMillis(retryElapsedTime)
	.setRetryType(getRetryType(newRequestType));
	}
	return builder
	.setSlotIndex(mSlotIndex)
	.setTransportType(mTransportType)
	.setApnType(apnType)
	.build();
	}

	private static int getRetryType(@DcTracker.RequestNetworkType int newRequestType) {
	if (newRequestType == DcTracker.REQUEST_TYPE_NORMAL) {
	return ThrottleStatus.RETRY_TYPE_NEW_CONNECTION;
	}

	if (newRequestType == DcTracker.REQUEST_TYPE_HANDOVER) {
	return ThrottleStatus.RETRY_TYPE_HANDOVER;
	}

	loge("createStatus: Unknown requestType=" + newRequestType);
	return ThrottleStatus.RETRY_TYPE_NEW_CONNECTION;
	}

	private void sendThrottleStatusChanged(List<ThrottleStatus> statuses) {
	synchronized (mCallbacks) {
	for (int i = 0; i < mCallbacks.size(); i++) {
	mCallbacks.get(i).onThrottleStatusChanged(statuses);
	}
	}
	}

	private static void loge(String s) {
	Rlog.e(TAG, s);
	}

	/**
	* Reports changes to apn throttle statuses.
	*
	* Note: All statuses are sent when first registered.
	*
	* @param callback status changes callback
	*/
	public void registerForThrottleStatusChanges(DataThrottler.Callback callback) {
	synchronized (mCallbacks) {
	//Only add if it's not there already
	if (!mCallbacks.contains(callback)) {
	//Report everything the first time
	List<ThrottleStatus> throttleStatuses =
	new ArrayList<>(mThrottleStatus.values());
	callback.onThrottleStatusChanged(throttleStatuses);
	mCallbacks.add(callback);
	}
	}
	}

	/**
	* Unregister the callback
	* @param callback the callback to unregister
	*/
	public void unregisterForThrottleStatusChanges(DataThrottler.Callback callback) {
	synchronized (mCallbacks) {
	mCallbacks.remove(callback);
	}
	}

	/**
	* Callback for when throttle statuses change
	*/
	public interface Callback {
	/**
	* Called whenever the throttle status of an APN has changed.
	*
	* Note: Called with all statuses when first registered.
	*
	* @param throttleStatuses the status changes
	*/
	void onThrottleStatusChanged(List<ThrottleStatus> throttleStatuses);
	}
	}