android-35/android/adservices/signals/ProtectedSignalsManager.java - platform/prebuilts/fullsdk/sources - Git at Google

 /*
  * Copyright (C) 2023 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.adservices.signals;

 import static android.adservices.common.AdServicesPermissions.ACCESS_ADSERVICES_PROTECTED_SIGNALS;

 import android.adservices.common.AdServicesStatusUtils;
 import android.adservices.common.FledgeErrorResponse;
 import android.adservices.common.SandboxedSdkContextUtils;
 import android.annotation.CallbackExecutor;
 import android.annotation.FlaggedApi;
 import android.annotation.NonNull;
 import android.annotation.RequiresApi;
 import android.annotation.RequiresPermission;
 import android.annotation.SuppressLint;
 import android.app.sdksandbox.SandboxedSdkContext;
 import android.content.Context;
 import android.os.Build;
 import android.os.LimitExceededException;
 import android.os.OutcomeReceiver;
 import android.os.RemoteException;

 import com.android.adservices.AdServicesCommon;
 import com.android.adservices.LoggerFactory;
 import com.android.adservices.ServiceBinder;
 import com.android.adservices.flags.Flags;

 import java.util.Objects;
 import java.util.concurrent.Executor;

 /** ProtectedSignalsManager provides APIs for apps and ad-SDKs to manage their protected signals. */
 @FlaggedApi(Flags.FLAG_PROTECTED_SIGNALS_ENABLED)
 @RequiresApi(Build.VERSION_CODES.S)
 public class ProtectedSignalsManager {
     private static final LoggerFactory.Logger sLogger = LoggerFactory.getFledgeLogger();
     /**
      * Constant that represents the service name for {@link ProtectedSignalsManager} to be used in
      * {@link android.adservices.AdServicesFrameworkInitializer#registerServiceWrappers}
      *
      * @hide
      */
     public static final String PROTECTED_SIGNALS_SERVICE = "protected_signals_service";

     @NonNull private Context mContext;
     @NonNull private ServiceBinder<IProtectedSignalsService> mServiceBinder;

     /**
      * Factory method for creating an instance of ProtectedSignalsManager.
      *
      * @param context The {@link Context} to use
      * @return A {@link ProtectedSignalsManager} instance
      */
     @SuppressLint("ManagerLookup")
     @NonNull
     // TODO(b/303896680): Investigate why this lint was not triggered for similar managers
     public static ProtectedSignalsManager get(@NonNull Context context) {
         // On T+, context.getSystemService() does more than just call constructor.
         return (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
                 ? context.getSystemService(ProtectedSignalsManager.class)
                 : new ProtectedSignalsManager(context);
     }

     /**
      * Create a service binder ProtectedSignalsManager
      *
      * @hide
      */
     public ProtectedSignalsManager(@NonNull Context context) {
         Objects.requireNonNull(context);

         // In case the ProtectedSignalsManager is initiated from inside a sdk_sandbox process the
         // fields will be immediately rewritten by the initialize method below.
         initialize(context);
     }

     /**
      * Initializes {@link ProtectedSignalsManager} with the given {@code context}.
      *
      * <p>This method is called by the {@link SandboxedSdkContext} to propagate the correct context.
      * For more information check the javadoc on the {@link
      * android.app.sdksandbox.SdkSandboxSystemServiceRegistry}.
      *
      * @hide
      * @see android.app.sdksandbox.SdkSandboxSystemServiceRegistry
      */
     public ProtectedSignalsManager initialize(@NonNull Context context) {
         Objects.requireNonNull(context);

         mContext = context;
         mServiceBinder =
                 ServiceBinder.getServiceBinder(
                         context,
                         AdServicesCommon.ACTION_PROTECTED_SIGNALS_SERVICE,
                         IProtectedSignalsService.Stub::asInterface);
         return this;
     }

     @NonNull
     IProtectedSignalsService getService() {
         IProtectedSignalsService service = mServiceBinder.getService();
         if (service == null) {
             throw new IllegalStateException("Unable to find the service");
         }
         return service;
     }

     /**
      * The updateSignals API will retrieve a JSON from the URI that describes which signals to add
      * or remove. This API also allows registering the encoder endpoint. The endpoint is used to
      * download an encoding logic, which enables encoding the signals.
      *
      * <p>The top level keys for the JSON must correspond to one of 5 commands:
      *
      * <p>"put" - Adds a new signal, overwriting any existing signals with the same key. The value
      * for this is a JSON object where the keys are base 64 strings corresponding to the key to put
      * for and the values are base 64 string corresponding to the value to put.
      *
      * <p>"append" - Appends a new signal/signals to a time series of signals, removing the oldest
      * signals to make room for the new ones if the size of the series exceeds the given maximum.
      * The value for this is a JSON object where the keys are base 64 strings corresponding to the
      * key to append to and the values are objects with two fields: "values" and "maxSignals" .
      * "values" is a list of base 64 strings corresponding to signal values to append to the time
      * series. "maxSignals" is the maximum number of values that are allowed in this timeseries. If
      * the current number of signals associated with the key exceeds maxSignals the oldest signals
      * will be removed. Note that you can append to a key added by put. Not that appending more than
      * the maximum number of values will cause a failure.
      *
      * <p>"put_if_not_present" - Adds a new signal only if there are no existing signals with the
      * same key. The value for this is a JSON object where the keys are base 64 strings
      * corresponding to the key to put for and the values are base 64 string corresponding to the
      * value to put.
      *
      * <p>"remove" - Removes the signal for a key. The value of this is a list of base 64 strings
      * corresponding to the keys of signals that should be deleted.
      *
      * <p>"update_encoder" - Provides an action to update the endpoint, and a URI which can be used
      * to retrieve an encoding logic. The sub-key for providing an update action is "action" and the
      * values currently supported are:
      *
      * <ol>
      *   <li>"REGISTER" : Registers the encoder endpoint if provided for the first time or
      *       overwrites the existing one with the newly provided endpoint. Providing the "endpoint"
      *       is required for the "REGISTER" action.
      * </ol>
      *
      * <p>The sub-key for providing an encoder endpoint is "endpoint" and the value is the URI
      * string for the endpoint.
      *
      * <p>On success, the onResult method of the provided OutcomeReceiver will be called with an
      * empty Object. This Object has no significance and is used merely as a placeholder.
      *
      * <p>Key may only be operated on by one command per JSON. If two command attempt to operate on
      * the same key, this method will through an {@link IllegalArgumentException}
      *
      * <p>This call fails with an {@link SecurityException} if
      *
      * <ol>
      *   <li>the {@code ownerPackageName} is not calling app's package name and/or
      *   <li>the buyer is not authorized to use the API.
      * </ol>
      *
      * <p>This call fails with an {@link IllegalArgumentException} if
      *
      * <ol>
      *   <li>The JSON retrieved from the server is not valid.
      *   <li>The provided URI is invalid.
      * </ol>
      *
      * <p>This call fails with {@link LimitExceededException} if the calling package exceeds the
      * allowed rate limits and is throttled.
      *
      * <p>This call fails with an {@link IllegalStateException} if an internal service error is
      * encountered.
      */
     @RequiresPermission(ACCESS_ADSERVICES_PROTECTED_SIGNALS)
     public void updateSignals(
             @NonNull UpdateSignalsRequest updateSignalsRequest,
             @NonNull @CallbackExecutor Executor executor,
             @NonNull OutcomeReceiver<Object, Exception> receiver) {
         Objects.requireNonNull(updateSignalsRequest);
         Objects.requireNonNull(executor);
         Objects.requireNonNull(receiver);

         try {
             final IProtectedSignalsService service = getService();

             service.updateSignals(
                     new UpdateSignalsInput.Builder(
                                     updateSignalsRequest.getUpdateUri(), getCallerPackageName())
                             .build(),
                     new UpdateSignalsCallback.Stub() {
                         @Override
                         public void onSuccess() {
                             executor.execute(() -> receiver.onResult(new Object()));
                         }

                         @Override
                         public void onFailure(FledgeErrorResponse failureParcel) {
                             executor.execute(
                                     () ->
                                             receiver.onError(
                                                     AdServicesStatusUtils.asException(
                                                             failureParcel)));
                         }
                     });
         } catch (RemoteException e) {
             sLogger.e(e, "Exception");
             receiver.onError(new IllegalStateException("Internal Error!", e));
         }
     }

     private String getCallerPackageName() {
         SandboxedSdkContext sandboxedSdkContext =
                 SandboxedSdkContextUtils.getAsSandboxedSdkContext(mContext);
         return sandboxedSdkContext == null
                 ? mContext.getPackageName()
                 : sandboxedSdkContext.getClientPackageName();
     }
 }
	/*
	* Copyright (C) 2023 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.adservices.signals;

	import static android.adservices.common.AdServicesPermissions.ACCESS_ADSERVICES_PROTECTED_SIGNALS;

	import android.adservices.common.AdServicesStatusUtils;
	import android.adservices.common.FledgeErrorResponse;
	import android.adservices.common.SandboxedSdkContextUtils;
	import android.annotation.CallbackExecutor;
	import android.annotation.FlaggedApi;
	import android.annotation.NonNull;
	import android.annotation.RequiresApi;
	import android.annotation.RequiresPermission;
	import android.annotation.SuppressLint;
	import android.app.sdksandbox.SandboxedSdkContext;
	import android.content.Context;
	import android.os.Build;
	import android.os.LimitExceededException;
	import android.os.OutcomeReceiver;
	import android.os.RemoteException;

	import com.android.adservices.AdServicesCommon;
	import com.android.adservices.LoggerFactory;
	import com.android.adservices.ServiceBinder;
	import com.android.adservices.flags.Flags;

	import java.util.Objects;
	import java.util.concurrent.Executor;

	/** ProtectedSignalsManager provides APIs for apps and ad-SDKs to manage their protected signals. */
	@FlaggedApi(Flags.FLAG_PROTECTED_SIGNALS_ENABLED)
	@RequiresApi(Build.VERSION_CODES.S)
	public class ProtectedSignalsManager {
	private static final LoggerFactory.Logger sLogger = LoggerFactory.getFledgeLogger();
	/**
	* Constant that represents the service name for {@link ProtectedSignalsManager} to be used in
	* {@link android.adservices.AdServicesFrameworkInitializer#registerServiceWrappers}
	*
	* @hide
	*/
	public static final String PROTECTED_SIGNALS_SERVICE = "protected_signals_service";

	@NonNull private Context mContext;
	@NonNull private ServiceBinder<IProtectedSignalsService> mServiceBinder;

	/**
	* Factory method for creating an instance of ProtectedSignalsManager.
	*
	* @param context The {@link Context} to use
	* @return A {@link ProtectedSignalsManager} instance
	*/
	@SuppressLint("ManagerLookup")
	@NonNull
	// TODO(b/303896680): Investigate why this lint was not triggered for similar managers
	public static ProtectedSignalsManager get(@NonNull Context context) {
	// On T+, context.getSystemService() does more than just call constructor.
	return (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU)
	? context.getSystemService(ProtectedSignalsManager.class)
	: new ProtectedSignalsManager(context);
	}

	/**
	* Create a service binder ProtectedSignalsManager
	*
	* @hide
	*/
	public ProtectedSignalsManager(@NonNull Context context) {
	Objects.requireNonNull(context);

	// In case the ProtectedSignalsManager is initiated from inside a sdk_sandbox process the
	// fields will be immediately rewritten by the initialize method below.
	initialize(context);
	}

	/**
	* Initializes {@link ProtectedSignalsManager} with the given {@code context}.
	*
	* <p>This method is called by the {@link SandboxedSdkContext} to propagate the correct context.
	* For more information check the javadoc on the {@link
	* android.app.sdksandbox.SdkSandboxSystemServiceRegistry}.
	*
	* @hide
	* @see android.app.sdksandbox.SdkSandboxSystemServiceRegistry
	*/
	public ProtectedSignalsManager initialize(@NonNull Context context) {
	Objects.requireNonNull(context);

	mContext = context;
	mServiceBinder =
	ServiceBinder.getServiceBinder(
	context,
	AdServicesCommon.ACTION_PROTECTED_SIGNALS_SERVICE,
	IProtectedSignalsService.Stub::asInterface);
	return this;
	}

	@NonNull
	IProtectedSignalsService getService() {
	IProtectedSignalsService service = mServiceBinder.getService();
	if (service == null) {
	throw new IllegalStateException("Unable to find the service");
	}
	return service;
	}

	/**
	* The updateSignals API will retrieve a JSON from the URI that describes which signals to add
	* or remove. This API also allows registering the encoder endpoint. The endpoint is used to
	* download an encoding logic, which enables encoding the signals.
	*
	* <p>The top level keys for the JSON must correspond to one of 5 commands:
	*
	* <p>"put" - Adds a new signal, overwriting any existing signals with the same key. The value
	* for this is a JSON object where the keys are base 64 strings corresponding to the key to put
	* for and the values are base 64 string corresponding to the value to put.
	*
	* <p>"append" - Appends a new signal/signals to a time series of signals, removing the oldest
	* signals to make room for the new ones if the size of the series exceeds the given maximum.
	* The value for this is a JSON object where the keys are base 64 strings corresponding to the
	* key to append to and the values are objects with two fields: "values" and "maxSignals" .
	* "values" is a list of base 64 strings corresponding to signal values to append to the time
	* series. "maxSignals" is the maximum number of values that are allowed in this timeseries. If
	* the current number of signals associated with the key exceeds maxSignals the oldest signals
	* will be removed. Note that you can append to a key added by put. Not that appending more than
	* the maximum number of values will cause a failure.
	*
	* <p>"put_if_not_present" - Adds a new signal only if there are no existing signals with the
	* same key. The value for this is a JSON object where the keys are base 64 strings
	* corresponding to the key to put for and the values are base 64 string corresponding to the
	* value to put.
	*
	* <p>"remove" - Removes the signal for a key. The value of this is a list of base 64 strings
	* corresponding to the keys of signals that should be deleted.
	*
	* <p>"update_encoder" - Provides an action to update the endpoint, and a URI which can be used
	* to retrieve an encoding logic. The sub-key for providing an update action is "action" and the
	* values currently supported are:
	*
	* <ol>
	* <li>"REGISTER" : Registers the encoder endpoint if provided for the first time or
	* overwrites the existing one with the newly provided endpoint. Providing the "endpoint"
	* is required for the "REGISTER" action.
	* </ol>
	*
	* <p>The sub-key for providing an encoder endpoint is "endpoint" and the value is the URI
	* string for the endpoint.
	*
	* <p>On success, the onResult method of the provided OutcomeReceiver will be called with an
	* empty Object. This Object has no significance and is used merely as a placeholder.
	*
	* <p>Key may only be operated on by one command per JSON. If two command attempt to operate on
	* the same key, this method will through an {@link IllegalArgumentException}
	*
	* <p>This call fails with an {@link SecurityException} if
	*
	* <ol>
	* <li>the {@code ownerPackageName} is not calling app's package name and/or
	* <li>the buyer is not authorized to use the API.
	* </ol>
	*
	* <p>This call fails with an {@link IllegalArgumentException} if
	*
	* <ol>
	* <li>The JSON retrieved from the server is not valid.
	* <li>The provided URI is invalid.
	* </ol>
	*
	* <p>This call fails with {@link LimitExceededException} if the calling package exceeds the
	* allowed rate limits and is throttled.
	*
	* <p>This call fails with an {@link IllegalStateException} if an internal service error is
	* encountered.
	*/
	@RequiresPermission(ACCESS_ADSERVICES_PROTECTED_SIGNALS)
	public void updateSignals(
	@NonNull UpdateSignalsRequest updateSignalsRequest,
	@NonNull @CallbackExecutor Executor executor,
	@NonNull OutcomeReceiver<Object, Exception> receiver) {
	Objects.requireNonNull(updateSignalsRequest);
	Objects.requireNonNull(executor);
	Objects.requireNonNull(receiver);

	try {
	final IProtectedSignalsService service = getService();

	service.updateSignals(
	new UpdateSignalsInput.Builder(
	updateSignalsRequest.getUpdateUri(), getCallerPackageName())
	.build(),
	new UpdateSignalsCallback.Stub() {
	@Override
	public void onSuccess() {
	executor.execute(() -> receiver.onResult(new Object()));
	}

	@Override
	public void onFailure(FledgeErrorResponse failureParcel) {
	executor.execute(
	() ->
	receiver.onError(
	AdServicesStatusUtils.asException(
	failureParcel)));
	}
	});
	} catch (RemoteException e) {
	sLogger.e(e, "Exception");
	receiver.onError(new IllegalStateException("Internal Error!", e));
	}
	}

	private String getCallerPackageName() {
	SandboxedSdkContext sandboxedSdkContext =
	SandboxedSdkContextUtils.getAsSandboxedSdkContext(mContext);
	return sandboxedSdkContext == null
	? mContext.getPackageName()
	: sandboxedSdkContext.getClientPackageName();
	}
	}