com/android/ims/rcs/uce/request/UceRequestCoordinator.java - platform/prebuilts/fullsdk/sources/android-31 - Git at Google

 /*
  * Copyright (c) 2021 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.ims.rcs.uce.request;

 import android.annotation.IntDef;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.telephony.ims.RcsUceAdapter;
 import android.util.Log;

 import com.android.ims.rcs.uce.request.UceRequestManager.RequestManagerCallback;
 import com.android.ims.rcs.uce.util.UceUtils;

 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;

 /**
  * The base class that is responsible for the communication and interaction between the UceRequests.
  */
 public abstract class UceRequestCoordinator {

     private static final String LOG_TAG = UceUtils.getLogPrefix() + "ReqCoordinator";

     /**
      * The UceRequest encountered error.
      */
     public static final int REQUEST_UPDATE_ERROR = 0;

     /**
      * The UceRequest received the onCommandError callback.
      */
     public static final int REQUEST_UPDATE_COMMAND_ERROR = 1;

     /**
      * The UceRequest received the onNetworkResponse callback.
      */
     public static final int REQUEST_UPDATE_NETWORK_RESPONSE = 2;

     /**
      * The UceRequest received the onNotifyCapabilitiesUpdate callback.
      */
     public static final int REQUEST_UPDATE_CAPABILITY_UPDATE = 3;

     /**
      * The UceRequest received the onResourceTerminated callback.
      */
     public static final int REQUEST_UPDATE_RESOURCE_TERMINATED = 4;

     /**
      * The UceRequest retrieve the valid capabilities from the cache.
      */
     public static final int REQUEST_UPDATE_CACHED_CAPABILITY_UPDATE = 5;

     /**
      * The UceRequest receive the onTerminated callback.
      */
     public static final int REQUEST_UPDATE_TERMINATED = 6;

     /**
      * The UceRequest does not need to request capabilities to network because all the capabilities
      * can be retrieved from the cache.
      */
     public static final int REQUEST_UPDATE_NO_NEED_REQUEST_FROM_NETWORK = 7;

     /**
      * The remote options request is done.
      */
     public static final int REQUEST_UPDATE_REMOTE_REQUEST_DONE = 8;

     /**
      * The capabilities request is timeout.
      */
     public static final int REQUEST_UPDATE_TIMEOUT = 9;

     @IntDef(value = {
             REQUEST_UPDATE_ERROR,
             REQUEST_UPDATE_COMMAND_ERROR,
             REQUEST_UPDATE_NETWORK_RESPONSE,
             REQUEST_UPDATE_TERMINATED,
             REQUEST_UPDATE_RESOURCE_TERMINATED,
             REQUEST_UPDATE_CAPABILITY_UPDATE,
             REQUEST_UPDATE_CACHED_CAPABILITY_UPDATE,
             REQUEST_UPDATE_NO_NEED_REQUEST_FROM_NETWORK,
             REQUEST_UPDATE_REMOTE_REQUEST_DONE,
             REQUEST_UPDATE_TIMEOUT,
     }, prefix="REQUEST_UPDATE_")
     @Retention(RetentionPolicy.SOURCE)
     @interface UceRequestUpdate {}

     protected static Map<Integer, String> REQUEST_EVENT_DESC = new HashMap<>();
     static {
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_ERROR, "REQUEST_ERROR");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_COMMAND_ERROR, "RETRIEVE_COMMAND_ERROR");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_NETWORK_RESPONSE, "REQUEST_NETWORK_RESPONSE");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_TERMINATED, "REQUEST_TERMINATED");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_RESOURCE_TERMINATED, "REQUEST_RESOURCE_TERMINATED");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_CAPABILITY_UPDATE, "REQUEST_CAPABILITY_UPDATE");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_CACHED_CAPABILITY_UPDATE, "REQUEST_CACHE_CAP_UPDATE");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_NO_NEED_REQUEST_FROM_NETWORK, "NO_NEED_REQUEST");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_REMOTE_REQUEST_DONE, "REMOTE_REQUEST_DONE");
         REQUEST_EVENT_DESC.put(REQUEST_UPDATE_TIMEOUT, "REQUEST_TIMEOUT");
     }

     /**
      * The result of the UceRequest. This is the used by the RequestCoordinator to record the
      * result of each sub-requests.
      */
     static class RequestResult {
         /**
          * Create a RequestResult that successfully completes the request.
          * @param taskId the task id of the UceRequest
          */
         public static RequestResult createSuccessResult(long taskId) {
             return new RequestResult(taskId);
         }

         /**
          * Create a RequestResult for the failed request.
          * @param taskId the task id of the UceRequest
          * @param errorCode the error code of the failed request
          * @param retry When the request can be retried.
          */
         public static RequestResult createFailedResult(long taskId, int errorCode, long retry) {
             return new RequestResult(taskId, errorCode, retry);
         }

         private final Long mTaskId;
         private final Boolean mIsSuccess;
         private final Optional<Integer> mErrorCode;
         private final Optional<Long> mRetryMillis;

         /**
          * The private constructor for the successful request.
          */
         private RequestResult(long taskId) {
             mTaskId = taskId;
             mIsSuccess = true;
             mErrorCode = Optional.empty();
             mRetryMillis = Optional.empty();
         }

         /**
          * The private constructor for the failed request.
          */
         private RequestResult(long taskId, int errorCode, long retryMillis) {
             mTaskId = taskId;
             mIsSuccess = false;
             mErrorCode = Optional.of(errorCode);
             mRetryMillis = Optional.of(retryMillis);
         }

         public long getTaskId() {
             return mTaskId;
         }

         public boolean isRequestSuccess() {
             return mIsSuccess;
         }

         public Optional<Integer> getErrorCode() {
             return mErrorCode;
         }

         public Optional<Long> getRetryMillis() {
             return mRetryMillis;
         }
     }

     // The default capability error code.
     protected static final int DEFAULT_ERROR_CODE = RcsUceAdapter.ERROR_GENERIC_FAILURE;

     protected final int mSubId;
     protected final long mCoordinatorId;
     protected volatile boolean mIsFinished;

     // The collection of activated requests.
     protected final Map<Long, UceRequest> mActivatedRequests;
     // The collection of the finished requests.
     protected final Map<Long, RequestResult> mFinishedRequests;
     // The lock of the activated and finished collection.
     protected final Object mCollectionLock = new Object();

     // The callback to communicate with UceRequestManager
     protected final RequestManagerCallback mRequestManagerCallback;

     public UceRequestCoordinator(int subId, Collection<UceRequest> requests,
             RequestManagerCallback requestMgrCallback) {
         mSubId = subId;
         mCoordinatorId = UceUtils.generateRequestCoordinatorId();
         mRequestManagerCallback = requestMgrCallback;

         // Set the coordinatorId to all the given UceRequests
         requests.forEach(request -> request.setRequestCoordinatorId(mCoordinatorId));

         // All the given requests are put in the activated request at the beginning.
         mFinishedRequests = new HashMap<>();
         mActivatedRequests = requests.stream().collect(
                 Collectors.toMap(UceRequest::getTaskId, request -> request));
     }

     /**
      * @return Get the request coordinator ID.
      */
     public long getCoordinatorId() {
         return mCoordinatorId;
     }

     /**
      * @return Get the collection of task ID of all the activated requests.
      */
     public @NonNull List<Long> getActivatedRequestTaskIds() {
         synchronized (mCollectionLock) {
             return mActivatedRequests.values().stream()
                     .map(request -> request.getTaskId())
                     .collect(Collectors.toList());
         }
     }

     /**
      * @return Get the UceRequest associated with the given taskId from the activated requests.
      */
     public @Nullable UceRequest getUceRequest(Long taskId) {
         synchronized (mCollectionLock) {
             return mActivatedRequests.get(taskId);
         }
     }

     /**
      * Remove the UceRequest associated with the given taskId from the activated collection and
      * add the {@link RequestResult} into the finished request collection. This method is called by
      * the coordinator instance when it receives the request updated event and judges this request
      * is finished.
      */
     protected void moveRequestToFinishedCollection(Long taskId, RequestResult requestResult) {
         synchronized (mCollectionLock) {
             mActivatedRequests.remove(taskId);
             mFinishedRequests.put(taskId, requestResult);
             mRequestManagerCallback.notifyUceRequestFinished(getCoordinatorId(), taskId);
         }
     }

     /**
      * Notify this coordinator instance is finished. This method sets the finish flag and clear all
      * the UceRequest collections and it can be used anymore after the method is called.
      */
     public void onFinish() {
         mIsFinished = true;
         synchronized (mCollectionLock) {
             mActivatedRequests.forEach((taskId, request) -> request.onFinish());
             mActivatedRequests.clear();
             mFinishedRequests.clear();
         }
     }

     /**
      * Notify the UceRequest associated with the given taskId in the coordinator is updated.
      */
     public abstract void onRequestUpdated(long taskId, @UceRequestUpdate int event);

     protected void logd(String log) {
         Log.d(LOG_TAG, getLogPrefix().append(log).toString());
     }

     protected void logw(String log) {
         Log.w(LOG_TAG, getLogPrefix().append(log).toString());
     }

     private StringBuilder getLogPrefix() {
         StringBuilder builder = new StringBuilder("[");
         builder.append(mSubId).append("][coordId=").append(mCoordinatorId).append("] ");
         return builder;
     }
 }
	/*
	* Copyright (c) 2021 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.ims.rcs.uce.request;

	import android.annotation.IntDef;
	import android.annotation.NonNull;
	import android.annotation.Nullable;
	import android.telephony.ims.RcsUceAdapter;
	import android.util.Log;

	import com.android.ims.rcs.uce.request.UceRequestManager.RequestManagerCallback;
	import com.android.ims.rcs.uce.util.UceUtils;

	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.util.Collection;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;
	import java.util.Optional;
	import java.util.stream.Collectors;

	/**
	* The base class that is responsible for the communication and interaction between the UceRequests.
	*/
	public abstract class UceRequestCoordinator {

	private static final String LOG_TAG = UceUtils.getLogPrefix() + "ReqCoordinator";

	/**
	* The UceRequest encountered error.
	*/
	public static final int REQUEST_UPDATE_ERROR = 0;

	/**
	* The UceRequest received the onCommandError callback.
	*/
	public static final int REQUEST_UPDATE_COMMAND_ERROR = 1;

	/**
	* The UceRequest received the onNetworkResponse callback.
	*/
	public static final int REQUEST_UPDATE_NETWORK_RESPONSE = 2;

	/**
	* The UceRequest received the onNotifyCapabilitiesUpdate callback.
	*/
	public static final int REQUEST_UPDATE_CAPABILITY_UPDATE = 3;

	/**
	* The UceRequest received the onResourceTerminated callback.
	*/
	public static final int REQUEST_UPDATE_RESOURCE_TERMINATED = 4;

	/**
	* The UceRequest retrieve the valid capabilities from the cache.
	*/
	public static final int REQUEST_UPDATE_CACHED_CAPABILITY_UPDATE = 5;

	/**
	* The UceRequest receive the onTerminated callback.
	*/
	public static final int REQUEST_UPDATE_TERMINATED = 6;

	/**
	* The UceRequest does not need to request capabilities to network because all the capabilities
	* can be retrieved from the cache.
	*/
	public static final int REQUEST_UPDATE_NO_NEED_REQUEST_FROM_NETWORK = 7;

	/**
	* The remote options request is done.
	*/
	public static final int REQUEST_UPDATE_REMOTE_REQUEST_DONE = 8;

	/**
	* The capabilities request is timeout.
	*/
	public static final int REQUEST_UPDATE_TIMEOUT = 9;

	@IntDef(value = {
	REQUEST_UPDATE_ERROR,
	REQUEST_UPDATE_COMMAND_ERROR,
	REQUEST_UPDATE_NETWORK_RESPONSE,
	REQUEST_UPDATE_TERMINATED,
	REQUEST_UPDATE_RESOURCE_TERMINATED,
	REQUEST_UPDATE_CAPABILITY_UPDATE,
	REQUEST_UPDATE_CACHED_CAPABILITY_UPDATE,
	REQUEST_UPDATE_NO_NEED_REQUEST_FROM_NETWORK,
	REQUEST_UPDATE_REMOTE_REQUEST_DONE,
	REQUEST_UPDATE_TIMEOUT,
	}, prefix="REQUEST_UPDATE_")
	@Retention(RetentionPolicy.SOURCE)
	@interface UceRequestUpdate {}

	protected static Map<Integer, String> REQUEST_EVENT_DESC = new HashMap<>();
	static {
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_ERROR, "REQUEST_ERROR");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_COMMAND_ERROR, "RETRIEVE_COMMAND_ERROR");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_NETWORK_RESPONSE, "REQUEST_NETWORK_RESPONSE");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_TERMINATED, "REQUEST_TERMINATED");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_RESOURCE_TERMINATED, "REQUEST_RESOURCE_TERMINATED");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_CAPABILITY_UPDATE, "REQUEST_CAPABILITY_UPDATE");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_CACHED_CAPABILITY_UPDATE, "REQUEST_CACHE_CAP_UPDATE");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_NO_NEED_REQUEST_FROM_NETWORK, "NO_NEED_REQUEST");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_REMOTE_REQUEST_DONE, "REMOTE_REQUEST_DONE");
	REQUEST_EVENT_DESC.put(REQUEST_UPDATE_TIMEOUT, "REQUEST_TIMEOUT");
	}

	/**
	* The result of the UceRequest. This is the used by the RequestCoordinator to record the
	* result of each sub-requests.
	*/
	static class RequestResult {
	/**
	* Create a RequestResult that successfully completes the request.
	* @param taskId the task id of the UceRequest
	*/
	public static RequestResult createSuccessResult(long taskId) {
	return new RequestResult(taskId);
	}

	/**
	* Create a RequestResult for the failed request.
	* @param taskId the task id of the UceRequest
	* @param errorCode the error code of the failed request
	* @param retry When the request can be retried.
	*/
	public static RequestResult createFailedResult(long taskId, int errorCode, long retry) {
	return new RequestResult(taskId, errorCode, retry);
	}

	private final Long mTaskId;
	private final Boolean mIsSuccess;
	private final Optional<Integer> mErrorCode;
	private final Optional<Long> mRetryMillis;

	/**
	* The private constructor for the successful request.
	*/
	private RequestResult(long taskId) {
	mTaskId = taskId;
	mIsSuccess = true;
	mErrorCode = Optional.empty();
	mRetryMillis = Optional.empty();
	}

	/**
	* The private constructor for the failed request.
	*/
	private RequestResult(long taskId, int errorCode, long retryMillis) {
	mTaskId = taskId;
	mIsSuccess = false;
	mErrorCode = Optional.of(errorCode);
	mRetryMillis = Optional.of(retryMillis);
	}

	public long getTaskId() {
	return mTaskId;
	}

	public boolean isRequestSuccess() {
	return mIsSuccess;
	}

	public Optional<Integer> getErrorCode() {
	return mErrorCode;
	}

	public Optional<Long> getRetryMillis() {
	return mRetryMillis;
	}
	}

	// The default capability error code.
	protected static final int DEFAULT_ERROR_CODE = RcsUceAdapter.ERROR_GENERIC_FAILURE;

	protected final int mSubId;
	protected final long mCoordinatorId;
	protected volatile boolean mIsFinished;

	// The collection of activated requests.
	protected final Map<Long, UceRequest> mActivatedRequests;
	// The collection of the finished requests.
	protected final Map<Long, RequestResult> mFinishedRequests;
	// The lock of the activated and finished collection.
	protected final Object mCollectionLock = new Object();

	// The callback to communicate with UceRequestManager
	protected final RequestManagerCallback mRequestManagerCallback;

	public UceRequestCoordinator(int subId, Collection<UceRequest> requests,
	RequestManagerCallback requestMgrCallback) {
	mSubId = subId;
	mCoordinatorId = UceUtils.generateRequestCoordinatorId();
	mRequestManagerCallback = requestMgrCallback;

	// Set the coordinatorId to all the given UceRequests
	requests.forEach(request -> request.setRequestCoordinatorId(mCoordinatorId));

	// All the given requests are put in the activated request at the beginning.
	mFinishedRequests = new HashMap<>();
	mActivatedRequests = requests.stream().collect(
	Collectors.toMap(UceRequest::getTaskId, request -> request));
	}

	/**
	* @return Get the request coordinator ID.
	*/
	public long getCoordinatorId() {
	return mCoordinatorId;
	}

	/**
	* @return Get the collection of task ID of all the activated requests.
	*/
	public @NonNull List<Long> getActivatedRequestTaskIds() {
	synchronized (mCollectionLock) {
	return mActivatedRequests.values().stream()
	.map(request -> request.getTaskId())
	.collect(Collectors.toList());
	}
	}

	/**
	* @return Get the UceRequest associated with the given taskId from the activated requests.
	*/
	public @Nullable UceRequest getUceRequest(Long taskId) {
	synchronized (mCollectionLock) {
	return mActivatedRequests.get(taskId);
	}
	}

	/**
	* Remove the UceRequest associated with the given taskId from the activated collection and
	* add the {@link RequestResult} into the finished request collection. This method is called by
	* the coordinator instance when it receives the request updated event and judges this request
	* is finished.
	*/
	protected void moveRequestToFinishedCollection(Long taskId, RequestResult requestResult) {
	synchronized (mCollectionLock) {
	mActivatedRequests.remove(taskId);
	mFinishedRequests.put(taskId, requestResult);
	mRequestManagerCallback.notifyUceRequestFinished(getCoordinatorId(), taskId);
	}
	}

	/**
	* Notify this coordinator instance is finished. This method sets the finish flag and clear all
	* the UceRequest collections and it can be used anymore after the method is called.
	*/
	public void onFinish() {
	mIsFinished = true;
	synchronized (mCollectionLock) {
	mActivatedRequests.forEach((taskId, request) -> request.onFinish());
	mActivatedRequests.clear();
	mFinishedRequests.clear();
	}
	}

	/**
	* Notify the UceRequest associated with the given taskId in the coordinator is updated.
	*/
	public abstract void onRequestUpdated(long taskId, @UceRequestUpdate int event);

	protected void logd(String log) {
	Log.d(LOG_TAG, getLogPrefix().append(log).toString());
	}

	protected void logw(String log) {
	Log.w(LOG_TAG, getLogPrefix().append(log).toString());
	}

	private StringBuilder getLogPrefix() {
	StringBuilder builder = new StringBuilder("[");
	builder.append(mSubId).append("][coordId=").append(mCoordinatorId).append("] ");
	return builder;
	}
	}