+ * class MyObject {
+ * ...
+ * @Override
+ * String toString() {
+ * return ObjectPrinter.printPublicFields(this, ...);
+ * }
+ * }
+ *
+ * @Override
+ * public @NonNull ReturnType someMethod(ArgType1 arg1, ArgType2 arg2) throws ExceptionType {
+ * try {
+ * ReturnType result = mDelegate.someMethod(arg1, arg2);
+ * logReturn("someMethod", result, arg1, arg2);
+ * return result;
+ * } catch (Exception e) {
+ * logException("someMethod", e, arg1, arg2);
+ * throw e;
+ * }
+ * }
+ * - * This is intended to extract the non-business logic out of the underlying implementation and thus - * make it easier to maintain each one of those separate aspects. A design trade-off is being made - * here, in that this class would need to essentially eavesdrop on all the client-server - * communication and retain all state known to the client, while the client doesn't necessarily care - * about all of it, and while the server has its own representation of this information. However, - * in this case, this is a small amount of data, and the benefits in code elegance seem worth it. - * There is also some additional cost in employing a simplistic locking mechanism here, but - * following the same line of reasoning, the benefits in code simplicity outweigh it. + * This is intended to facilitate a pattern of decorating the core implementation (business logic) + * of the interface with every decorator implementing a different aspect of the service, such as + * validation and logging. This class acts as the top-level decorator, which also adds the binder- + * related functionality (hence, it extends ISoundTriggerMiddlewareService.Stub as rather than + * implements ISoundTriggerMiddlewareService), and does the same thing for child interfaces + * returned. *
- * Every public method in this class, overriding an interface method, must follow the following
- * pattern:
- *
- * @Override public T method(S arg) {
- * // Permission check.
- * checkPermissions();
- * // Input validation.
- * ValidationUtil.validateS(arg);
- * synchronized (this) {
- * // State validation.
- * if (...state is not valid for this call...) {
- * throw new IllegalStateException("State is invalid because...");
- * }
- * // From here on, every exception isn't client's fault.
- * try {
- * T result = mDelegate.method(arg);
- * // Update state.;
- * ...
- * return result;
- * } catch (Exception e) {
- * throw handleException(e);
- * }
- * }
- * }
- *
- * Exception handling approach:
- * We make sure all client faults (permissions, argument and state validation) happen first, and
- * would throw {@link SecurityException}, {@link IllegalArgumentException}/
- * {@link NullPointerException} or {@link
- * IllegalStateException}, respectively. All those exceptions are treated specially by Binder and
- * will get sent back to the client.
- * Once this is done, any subsequent fault is considered a server fault. Only {@link
- * RecoverableException}s thrown by the implementation are special-cased: they would get sent back
- * to the caller as a {@link ServiceSpecificException}, which is the behavior of Binder. Any other
- * exception gets wrapped with a {@link InternalServerError}, which is specifically chosen as a type
- * that does NOT get forwarded by binder. Those exceptions would be handled by a high-level
- * exception handler on the server side, typically resulting in rebooting the server.
+ * The inner class {@link Lifecycle} acts as both a factory, composing the various aspect-decorators
+ * to create a full-featured implementation, as well as as an entry-point for presenting this
+ * implementation as a system service.
*
* Exposing this service as a System Service:
- * Typical usage:
- *
+ * This is intended to extract the non-business logic out of the underlying implementation and thus
+ * make it easier to maintain each one of those separate aspects. A design trade-off is being made
+ * here, in that this class would need to essentially eavesdrop on all the client-server
+ * communication and retain all state known to the client, while the client doesn't necessarily care
+ * about all of it, and while the server has its own representation of this information. However,
+ * in this case, this is a small amount of data, and the benefits in code elegance seem worth it.
+ * There is also some additional cost in employing a simplistic locking mechanism here, but
+ * following the same line of reasoning, the benefits in code simplicity outweigh it.
+ *
+ * Every public method in this class, overriding an interface method, must follow the following
+ * pattern:
+ *
+ * Exception handling approach:
+ * Typical usage:
+ *
* Insert this line into {@link com.android.server.SystemServer}:
@@ -113,224 +62,100 @@ import java.util.Set;
public class SoundTriggerMiddlewareService extends ISoundTriggerMiddlewareService.Stub {
static private final String TAG = "SoundTriggerMiddlewareService";
+ @NonNull
private final ISoundTriggerMiddlewareService mDelegate;
- private final Context mContext;
- private Set
- * try {
- * ... Do server operations ...
- * } catch (Exception e) {
- * throw handleException(e);
- * }
- *
+ * @Override public T method(S arg) {
+ * // Permission check.
+ * checkPermissions();
+ * // Input validation.
+ * ValidationUtil.validateS(arg);
+ * synchronized (this) {
+ * // State validation.
+ * if (...state is not valid for this call...) {
+ * throw new IllegalStateException("State is invalid because...");
+ * }
+ * // From here on, every exception isn't client's fault.
+ * try {
+ * T result = mDelegate.method(arg);
+ * // Update state.;
+ * ...
+ * return result;
+ * } catch (Exception e) {
+ * throw handleException(e);
+ * }
+ * }
+ * }
+ *
+ * We make sure all client faults (permissions, argument and state validation) happen first, and
+ * would throw {@link SecurityException}, {@link IllegalArgumentException}/
+ * {@link NullPointerException} or {@link
+ * IllegalStateException}, respectively. All those exceptions are treated specially by Binder and
+ * will get sent back to the client.
+ * Once this is done, any subsequent fault is considered a server fault. Only {@link
+ * RecoverableException}s thrown by the implementation are special-cased: they would get sent back
+ * to the caller as a {@link ServiceSpecificException}, which is the behavior of Binder. Any other
+ * exception gets wrapped with a {@link InternalServerError}, which is specifically chosen as a type
+ * that does NOT get forwarded by binder. Those exceptions would be handled by a high-level
+ * exception handler on the server side, typically resulting in rebooting the server.
+ *
+ * {@hide}
+ */
+public class SoundTriggerMiddlewareValidation implements ISoundTriggerMiddlewareService, Dumpable {
+ private static final String TAG = "SoundTriggerMiddlewareValidation";
+
+ private final @NonNull ISoundTriggerMiddlewareService mDelegate;
+ private final @NonNull Context mContext;
+ private Map
+ * try {
+ * ... Do server operations ...
+ * } catch (Exception e) {
+ * throw handleException(e);
+ * }
+ *