309 lines
11 KiB
Java
309 lines
11 KiB
Java
/*
|
|
* Copyright 2017 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 android.telephony.data;
|
|
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.annotation.SystemApi;
|
|
import android.net.LinkProperties;
|
|
import android.os.RemoteException;
|
|
import android.telephony.data.DataService.DataServiceProvider;
|
|
|
|
import com.android.telephony.Rlog;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Data service callback, which is for bound data service to invoke for solicited and unsolicited
|
|
* response. The caller is responsible to create a callback object for each single asynchronous
|
|
* request.
|
|
*
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
public class DataServiceCallback {
|
|
|
|
private static final String TAG = DataServiceCallback.class.getSimpleName();
|
|
|
|
private static final boolean DBG = true;
|
|
|
|
/**
|
|
* Result of data requests
|
|
* @hide
|
|
*/
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef({RESULT_SUCCESS, RESULT_ERROR_UNSUPPORTED, RESULT_ERROR_INVALID_ARG, RESULT_ERROR_BUSY,
|
|
RESULT_ERROR_ILLEGAL_STATE, RESULT_ERROR_TEMPORARILY_UNAVAILABLE})
|
|
public @interface ResultCode {}
|
|
|
|
/** Request is completed successfully */
|
|
public static final int RESULT_SUCCESS = 0;
|
|
/** Request is not supported */
|
|
public static final int RESULT_ERROR_UNSUPPORTED = 1;
|
|
/** Request contains invalid arguments */
|
|
public static final int RESULT_ERROR_INVALID_ARG = 2;
|
|
/** Service is busy */
|
|
public static final int RESULT_ERROR_BUSY = 3;
|
|
/** Request sent in illegal state */
|
|
public static final int RESULT_ERROR_ILLEGAL_STATE = 4;
|
|
/**
|
|
* Service is temporarily unavailable. Frameworks should retry the request again.
|
|
* @hide
|
|
*/
|
|
public static final int RESULT_ERROR_TEMPORARILY_UNAVAILABLE = 5;
|
|
|
|
private final IDataServiceCallback mCallback;
|
|
|
|
/** @hide */
|
|
public DataServiceCallback(IDataServiceCallback callback) {
|
|
mCallback = callback;
|
|
}
|
|
|
|
/**
|
|
* Called to indicate result for the request {@link DataServiceProvider#setupDataCall(int,
|
|
* DataProfile, boolean, boolean, int, LinkProperties, DataServiceCallback)} .
|
|
*
|
|
* @param result The result code. Must be one of the {@link ResultCode}.
|
|
* @param response Setup data call response.
|
|
*/
|
|
public void onSetupDataCallComplete(@ResultCode int result,
|
|
@Nullable DataCallResponse response) {
|
|
if (mCallback != null) {
|
|
try {
|
|
if (DBG) Rlog.d(TAG, "onSetupDataCallComplete");
|
|
mCallback.onSetupDataCallComplete(result, response);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onSetupDataCallComplete on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onSetupDataCallComplete: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to indicate result for the request {@link DataServiceProvider#deactivateDataCall(int,
|
|
* int, DataServiceCallback)}
|
|
*
|
|
* @param result The result code. Must be one of the {@link ResultCode}.
|
|
*/
|
|
public void onDeactivateDataCallComplete(@ResultCode int result) {
|
|
if (mCallback != null) {
|
|
try {
|
|
if (DBG) Rlog.d(TAG, "onDeactivateDataCallComplete");
|
|
mCallback.onDeactivateDataCallComplete(result);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onDeactivateDataCallComplete on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onDeactivateDataCallComplete: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to indicate result for the request {@link DataServiceProvider#setInitialAttachApn(
|
|
* DataProfile, boolean, DataServiceCallback)}.
|
|
*
|
|
* @param result The result code. Must be one of the {@link ResultCode}.
|
|
*/
|
|
public void onSetInitialAttachApnComplete(@ResultCode int result) {
|
|
if (mCallback != null) {
|
|
try {
|
|
mCallback.onSetInitialAttachApnComplete(result);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onSetInitialAttachApnComplete on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onSetInitialAttachApnComplete: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to indicate result for the request {@link DataServiceProvider#setDataProfile(List,
|
|
* boolean, DataServiceCallback)}.
|
|
*
|
|
* @param result The result code. Must be one of the {@link ResultCode}.
|
|
*/
|
|
public void onSetDataProfileComplete(@ResultCode int result) {
|
|
if (mCallback != null) {
|
|
try {
|
|
mCallback.onSetDataProfileComplete(result);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onSetDataProfileComplete on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onSetDataProfileComplete: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to indicate result for the request {@link DataServiceProvider#requestDataCallList(
|
|
* DataServiceCallback)}.
|
|
*
|
|
* @param result The result code. Must be one of the {@link ResultCode}.
|
|
* @param dataCallList List of the current active data connection. If no data call is presented,
|
|
* set it to an empty list.
|
|
*/
|
|
public void onRequestDataCallListComplete(@ResultCode int result,
|
|
@NonNull List<DataCallResponse> dataCallList) {
|
|
if (mCallback != null) {
|
|
try {
|
|
mCallback.onRequestDataCallListComplete(result, dataCallList);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onRequestDataCallListComplete on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onRequestDataCallListComplete: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to indicate that data connection list changed. If no data call is presented, set it to
|
|
* an empty list.
|
|
*
|
|
* @param dataCallList List of the current active data connection.
|
|
*/
|
|
public void onDataCallListChanged(@NonNull List<DataCallResponse> dataCallList) {
|
|
if (mCallback != null) {
|
|
try {
|
|
if (DBG) Rlog.d(TAG, "onDataCallListChanged");
|
|
mCallback.onDataCallListChanged(dataCallList);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onDataCallListChanged on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onDataCallListChanged: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to indicate result for the request {@link DataService#startHandover}.
|
|
*
|
|
* @param result The result code. Must be one of the {@link ResultCode}
|
|
*
|
|
* @hide
|
|
*/
|
|
public void onHandoverStarted(@ResultCode int result) {
|
|
if (mCallback != null) {
|
|
try {
|
|
if (DBG) Rlog.d(TAG, "onHandoverStarted");
|
|
mCallback.onHandoverStarted(result);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onHandoverStarted on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onHandoverStarted: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to indicate result for the request {@link DataService#cancelHandover}.
|
|
*
|
|
* @param result The result code. Must be one of the {@link ResultCode}
|
|
*
|
|
* @hide
|
|
*/
|
|
public void onHandoverCancelled(@ResultCode int result) {
|
|
if (mCallback != null) {
|
|
try {
|
|
if (DBG) Rlog.d(TAG, "onHandoverCancelled");
|
|
mCallback.onHandoverCancelled(result);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "Failed to onHandoverCancelled on the remote");
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onHandoverCancelled: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the result code as a string
|
|
*
|
|
* @param resultCode The result code. Must be one of the {@link ResultCode}
|
|
* @return the string representation
|
|
*
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public static String resultCodeToString(@DataServiceCallback.ResultCode int resultCode) {
|
|
switch (resultCode) {
|
|
case RESULT_SUCCESS:
|
|
return "RESULT_SUCCESS";
|
|
case RESULT_ERROR_UNSUPPORTED:
|
|
return "RESULT_ERROR_UNSUPPORTED";
|
|
case RESULT_ERROR_INVALID_ARG:
|
|
return "RESULT_ERROR_INVALID_ARG";
|
|
case RESULT_ERROR_BUSY:
|
|
return "RESULT_ERROR_BUSY";
|
|
case RESULT_ERROR_ILLEGAL_STATE:
|
|
return "RESULT_ERROR_ILLEGAL_STATE";
|
|
case RESULT_ERROR_TEMPORARILY_UNAVAILABLE:
|
|
return "RESULT_ERROR_TEMPORARILY_UNAVAILABLE";
|
|
default:
|
|
return "Unknown(" + resultCode + ")";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unthrottles the APN on the current transport.
|
|
* The APN is throttled when {@link IDataService#setupDataCall} fails within
|
|
* the time specified by {@link DataCallResponse#getRetryDurationMillis} and will remain
|
|
* throttled until this method is called.
|
|
* <p/>
|
|
* see: {@link DataCallResponse#getRetryDurationMillis}
|
|
*
|
|
* @param apn Access Point Name defined by the carrier.
|
|
*/
|
|
public void onApnUnthrottled(final @NonNull String apn) {
|
|
if (mCallback != null) {
|
|
try {
|
|
if (DBG) Rlog.d(TAG, "onApnUnthrottled");
|
|
mCallback.onApnUnthrottled(apn);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "onApnUnthrottled: remote exception", e);
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onApnUnthrottled: callback is null!");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unthrottles the DataProfile on the current transport.
|
|
* The DataProfile is throttled when {@link IDataService#setupDataCall} fails within
|
|
* the time specified by {@link DataCallResponse#getRetryDurationMillis} and will remain
|
|
* throttled until this method is called.
|
|
* <p/>
|
|
* see: {@link DataCallResponse#getRetryDurationMillis}
|
|
*
|
|
* @param dataProfile DataProfile containing the APN to be throttled
|
|
*/
|
|
public void onDataProfileUnthrottled(final @NonNull DataProfile dataProfile) {
|
|
if (mCallback != null) {
|
|
try {
|
|
if (DBG) Rlog.d(TAG, "onDataProfileUnthrottled");
|
|
mCallback.onDataProfileUnthrottled(dataProfile);
|
|
} catch (RemoteException e) {
|
|
Rlog.e(TAG, "onDataProfileUnthrottled: remote exception", e);
|
|
}
|
|
} else {
|
|
Rlog.e(TAG, "onDataProfileUnthrottled: callback is null!");
|
|
}
|
|
}
|
|
}
|