/*
* Copyright 2022 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 androidx.wear.protolayout.expression.pipeline;
import static java.util.Collections.emptyMap;
import android.icu.util.ULocale;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RestrictTo;
import androidx.annotation.RestrictTo.Scope;
import androidx.annotation.UiThread;
import androidx.wear.protolayout.expression.DynamicBuilders;
import androidx.wear.protolayout.expression.pipeline.BoolNodes.ComparisonFloatNode;
import androidx.wear.protolayout.expression.pipeline.BoolNodes.ComparisonInt32Node;
import androidx.wear.protolayout.expression.pipeline.BoolNodes.FixedBoolNode;
import androidx.wear.protolayout.expression.pipeline.BoolNodes.LogicalBoolOp;
import androidx.wear.protolayout.expression.pipeline.BoolNodes.NotBoolOp;
import androidx.wear.protolayout.expression.pipeline.BoolNodes.StateBoolNode;
import androidx.wear.protolayout.expression.pipeline.ColorNodes.AnimatableFixedColorNode;
import androidx.wear.protolayout.expression.pipeline.ColorNodes.DynamicAnimatedColorNode;
import androidx.wear.protolayout.expression.pipeline.ColorNodes.FixedColorNode;
import androidx.wear.protolayout.expression.pipeline.ColorNodes.StateColorSourceNode;
import androidx.wear.protolayout.expression.pipeline.DurationNodes.BetweenInstancesNode;
import androidx.wear.protolayout.expression.pipeline.FloatNodes.AnimatableFixedFloatNode;
import androidx.wear.protolayout.expression.pipeline.FloatNodes.ArithmeticFloatNode;
import androidx.wear.protolayout.expression.pipeline.FloatNodes.DynamicAnimatedFloatNode;
import androidx.wear.protolayout.expression.pipeline.FloatNodes.FixedFloatNode;
import androidx.wear.protolayout.expression.pipeline.FloatNodes.Int32ToFloatNode;
import androidx.wear.protolayout.expression.pipeline.FloatNodes.StateFloatSourceNode;
import androidx.wear.protolayout.expression.pipeline.InstantNodes.FixedInstantNode;
import androidx.wear.protolayout.expression.pipeline.InstantNodes.PlatformTimeSourceNode;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.AnimatableFixedInt32Node;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.ArithmeticInt32Node;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.DynamicAnimatedInt32Node;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.FixedInt32Node;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.FloatToInt32Node;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.GetDurationPartOpNode;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.PlatformInt32SourceNode;
import androidx.wear.protolayout.expression.pipeline.Int32Nodes.StateInt32SourceNode;
import androidx.wear.protolayout.expression.pipeline.StringNodes.FixedStringNode;
import androidx.wear.protolayout.expression.pipeline.StringNodes.FloatFormatNode;
import androidx.wear.protolayout.expression.pipeline.StringNodes.Int32FormatNode;
import androidx.wear.protolayout.expression.pipeline.StringNodes.StateStringNode;
import androidx.wear.protolayout.expression.pipeline.StringNodes.StringConcatOpNode;
import androidx.wear.protolayout.expression.pipeline.sensor.SensorGateway;
import androidx.wear.protolayout.expression.proto.DynamicProto.AnimatableDynamicColor;
import androidx.wear.protolayout.expression.proto.DynamicProto.AnimatableDynamicFloat;
import androidx.wear.protolayout.expression.proto.DynamicProto.AnimatableDynamicInt32;
import androidx.wear.protolayout.expression.proto.DynamicProto.ConditionalColorOp;
import androidx.wear.protolayout.expression.proto.DynamicProto.ConditionalFloatOp;
import androidx.wear.protolayout.expression.proto.DynamicProto.ConditionalInt32Op;
import androidx.wear.protolayout.expression.proto.DynamicProto.ConditionalStringOp;
import androidx.wear.protolayout.expression.proto.DynamicProto.DynamicBool;
import androidx.wear.protolayout.expression.proto.DynamicProto.DynamicColor;
import androidx.wear.protolayout.expression.proto.DynamicProto.DynamicDuration;
import androidx.wear.protolayout.expression.proto.DynamicProto.DynamicFloat;
import androidx.wear.protolayout.expression.proto.DynamicProto.DynamicInstant;
import androidx.wear.protolayout.expression.proto.DynamicProto.DynamicInt32;
import androidx.wear.protolayout.expression.proto.DynamicProto.DynamicString;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;
/**
* Evaluates protolayout dynamic types.
*
* <p>Given a dynamic ProtoLayout data source, this builds up a sequence of {@link DynamicDataNode}
* instances, which can source the required data, and transform it into its final form.
*
* <p>Data source can include animations which will then emit value transitions.
*
* <p>In order to evaluate dynamic types, the caller needs to add any number of pending dynamic
* types with {@link #bind} methods and then call {@link BoundDynamicType#startEvaluation()} on each
* of them to start evaluation. Starting evaluation can be done for batches of dynamic types.
*
* <p>It's the callers responsibility to destroy those dynamic types after use, with {@link
* BoundDynamicType#close()}.
*
* <p>It's the callers responsibility to destroy those dynamic types after use, with {@link
* BoundDynamicType#close()}.
*/
public class DynamicTypeEvaluator implements AutoCloseable {
private static final String TAG = "DynamicTypeEvaluator";
@NonNull
private static final QuotaManager DISABLED_ANIMATIONS_QUOTA_MANAGER =
new QuotaManager() {
@Override
public boolean tryAcquireQuota(int quota) {
return false;
}
@Override
public void releaseQuota(int quota) {
throw new IllegalStateException(
"releaseQuota method is called when no quota is acquired!");
}
};
@NonNull private static final StateStore EMPTY_STATE_STORE = new StateStore(emptyMap());
@NonNull private final Config mConfig;
@NonNull private final StateStore mStateStore;
@NonNull private final QuotaManager mAnimationQuotaManager;
@NonNull private final TimeGateway mTimeGateway;
@Nullable private final EpochTimePlatformDataSource mTimeDataSource;
@Nullable private final SensorGatewayPlatformDataSource mSensorGatewayDataSource;
/** Configuration for {@link #DynamicTypeEvaluator(Config)}. */
public static final class Config {
private final boolean mPlatformDataSourcesInitiallyEnabled;
@Nullable private final StateStore mStateStore;
@Nullable private final QuotaManager mAnimationQuotaManager;
@Nullable private final TimeGateway mTimeGateway;
@Nullable private final SensorGateway mSensorGateway;
Config(
boolean platformDataSourcesInitiallyEnabled,
@Nullable StateStore stateStore,
@Nullable QuotaManager animationQuotaManager,
@Nullable TimeGateway timeGateway,
@Nullable SensorGateway sensorGateway) {
this.mPlatformDataSourcesInitiallyEnabled = platformDataSourcesInitiallyEnabled;
this.mStateStore = stateStore;
this.mAnimationQuotaManager = animationQuotaManager;
this.mTimeGateway = timeGateway;
this.mSensorGateway = sensorGateway;
}
/** Builds a {@link DynamicTypeEvaluator.Config}. */
public static final class Builder {
private boolean mPlatformDataSourcesInitiallyEnabled = false;
@Nullable private StateStore mStateStore = null;
@Nullable private QuotaManager mAnimationQuotaManager = null;
@Nullable private TimeGateway mTimeGateway = null;
@Nullable private SensorGateway mSensorGateway = null;
/**
* Sets whether sending updates from sensor and time sources should be allowed
* initially. After that, enabling updates from sensor and time sources can be done via
* {@link #enablePlatformDataSources()} or {@link #disablePlatformDataSources()}.
*
* <p>Defaults to {@code false}.
*/
@NonNull
public Builder setPlatformDataSourcesInitiallyEnabled(boolean value) {
mPlatformDataSourcesInitiallyEnabled = value;
return this;
}
/**
* Sets the state store that will be used for dereferencing the state keys in the
* dynamic types.
*
* <p>If not set, it's the equivalent of setting an empty state store (state bindings
* will trigger {@link DynamicTypeValueReceiver#onInvalidated()}).
*/
@NonNull
public Builder setStateStore(@NonNull StateStore value) {
mStateStore = value;
return this;
}
/**
* Sets the quota manager used for limiting the number of concurrently running
* animations.
*
* <p>If not set, animations are disabled and non-infinite animations will have the end
* value immediately.
*/
@NonNull
public Builder setAnimationQuotaManager(@NonNull QuotaManager value) {
mAnimationQuotaManager = value;
return this;
}
/**
* Sets the gateway used for time data.
*
* <p>If not set, a default 1hz {@link TimeGateway} implementation that utilizes a
* main-thread {@code Handler} to trigger is used.
*/
@NonNull
public Builder setTimeGateway(@NonNull TimeGateway value) {
mTimeGateway = value;
return this;
}
/**
* Sets the gateway used for sensor data.
*
* <p>If not set, sensor data will not be available (sensor bindings will trigger {@link
* DynamicTypeValueReceiver#onInvalidated()}).
*/
@NonNull
public Builder setSensorGateway(@NonNull SensorGateway value) {
mSensorGateway = value;
return this;
}
@NonNull
public Config build() {
return new Config(
mPlatformDataSourcesInitiallyEnabled,
mStateStore,
mAnimationQuotaManager,
mTimeGateway,
mSensorGateway);
}
}
/**
* Gets whether sending updates from sensor and time sources should be allowed initially.
* After that, enabling updates from sensor and time sources can be done via {@link
* #enablePlatformDataSources()} or {@link #disablePlatformDataSources()}.
*/
public boolean isPlatformDataSourcesInitiallyEnabled() {
return mPlatformDataSourcesInitiallyEnabled;
}
/**
* Gets the state store that will be used for dereferencing the state keys in the dynamic
* types, or {@code null} which is equivalent to an empty state store (state bindings will
* trigger {@link DynamicTypeValueReceiver#onInvalidated()}).
*/
@Nullable
public StateStore getStateStore() {
return mStateStore;
}
/**
* Gets the quota manager used for limiting the number of concurrently running animations,
* or {@code null} if animations are disabled, causing non-infinite animations to have to
* the end value immediately.
*/
@Nullable
public QuotaManager getAnimationQuotaManager() {
return mAnimationQuotaManager;
}
/**
* Gets the gateway used for sensor data, or {@code null} if sensor data is unavailable
* (sensor bindings will trigger {@link DynamicTypeValueReceiver#onInvalidated()}).
*/
@Nullable
public SensorGateway getSensorGateway() {
return mSensorGateway;
}
/**
* Gets the gateway used for time data, or {@code null} if a default 1hz {@link TimeGateway}
* that utilizes a main-thread {@code Handler} to trigger is used.
*/
@Nullable
public TimeGateway getTimeGateway() {
return mTimeGateway;
}
}
/** Constructs a {@link DynamicTypeEvaluator}. */
public DynamicTypeEvaluator(@NonNull Config config) {
this.mConfig = config;
this.mStateStore =
config.getStateStore() != null ? config.getStateStore() : EMPTY_STATE_STORE;
this.mAnimationQuotaManager =
config.getAnimationQuotaManager() != null
? config.getAnimationQuotaManager()
: DISABLED_ANIMATIONS_QUOTA_MANAGER;
Handler uiHandler = new Handler(Looper.getMainLooper());
MainThreadExecutor uiExecutor = new MainThreadExecutor(uiHandler);
this.mTimeGateway =
config.getTimeGateway() != null
? config.getTimeGateway()
: new TimeGatewayImpl(uiHandler);
this.mTimeDataSource = new EpochTimePlatformDataSource(uiExecutor, mTimeGateway);
if (config.isPlatformDataSourcesInitiallyEnabled()
&& this.mTimeGateway instanceof TimeGatewayImpl) {
((TimeGatewayImpl) this.mTimeGateway).enableUpdates();
}
if (config.getSensorGateway() != null) {
if (config.isPlatformDataSourcesInitiallyEnabled()) {
config.getSensorGateway().enableUpdates();
} else {
config.getSensorGateway().disableUpdates();
}
this.mSensorGatewayDataSource =
new SensorGatewayPlatformDataSource(uiExecutor, config.getSensorGateway());
} else {
this.mSensorGatewayDataSource = null;
}
}
/**
* Adds dynamic type from the given {@link DynamicBuilders.DynamicString} for evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* <p>Results of evaluation will be sent through the given {@link DynamicTypeValueReceiver} on
* the given {@link Executor}.
*
* @param stringSource The given String dynamic type that should be evaluated.
* @param locale The locale used for the given String source.
* @param executor The Executor to run the consumer on.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
public BoundDynamicType bind(
@NonNull DynamicBuilders.DynamicString stringSource,
@NonNull ULocale locale,
@NonNull Executor executor,
@NonNull DynamicTypeValueReceiver<String> consumer) {
return bind(
stringSource.toDynamicStringProto(),
locale,
new DynamicTypeValueReceiverOnExecutor<>(executor, consumer));
}
/**
* Adds pending dynamic type from the given {@link DynamicString} for future evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* @param stringSource The given String dynamic type that should be evaluated.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
* @param locale The locale used for the given String source.
*/
@NonNull
@RestrictTo(Scope.LIBRARY_GROUP)
public BoundDynamicType bind(
@NonNull DynamicString stringSource,
@NonNull ULocale locale,
@NonNull DynamicTypeValueReceiver<String> consumer) {
List<DynamicDataNode<?>> resultBuilder = new ArrayList<>();
bindRecursively(
stringSource,
new DynamicTypeValueReceiverOnExecutor<>(consumer),
locale,
resultBuilder);
return new BoundDynamicTypeImpl(resultBuilder);
}
/**
* Adds dynamic type from the given {@link DynamicBuilders.DynamicInt32} for evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* <p>Results of evaluation will be sent through the given {@link DynamicTypeValueReceiver} on
* the given {@link Executor}.
*
* @param int32Source The given integer dynamic type that should be evaluated.
* @param executor The Executor to run the consumer on.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
public BoundDynamicType bind(
@NonNull DynamicBuilders.DynamicInt32 int32Source,
@NonNull Executor executor,
@NonNull DynamicTypeValueReceiver<Integer> consumer) {
return bind(
int32Source.toDynamicInt32Proto(),
new DynamicTypeValueReceiverOnExecutor<>(executor, consumer));
}
/**
* Adds pending dynamic type from the given {@link DynamicInt32} for future evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* @param int32Source The given integer dynamic type that should be evaluated.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
@RestrictTo(Scope.LIBRARY_GROUP)
public BoundDynamicType bind(
@NonNull DynamicInt32 int32Source,
@NonNull DynamicTypeValueReceiver<Integer> consumer) {
List<DynamicDataNode<?>> resultBuilder = new ArrayList<>();
bindRecursively(
int32Source, new DynamicTypeValueReceiverOnExecutor<>(consumer), resultBuilder);
return new BoundDynamicTypeImpl(resultBuilder);
}
/**
* Adds dynamic type from the given {@link DynamicBuilders.DynamicFloat} for evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* <p>Results of evaluation will be sent through the given {@link DynamicTypeValueReceiver} on
* the given {@link Executor}.
*
* @param floatSource The given float dynamic type that should be evaluated.
* @param executor The Executor to run the consumer on.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
public BoundDynamicType bind(
@NonNull DynamicBuilders.DynamicFloat floatSource,
@NonNull Executor executor,
@NonNull DynamicTypeValueReceiver<Float> consumer) {
return bind(
floatSource.toDynamicFloatProto(),
new DynamicTypeValueReceiverOnExecutor<>(executor, consumer));
}
/**
* Adds pending dynamic type from the given {@link DynamicFloat} for future evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* @param floatSource The given float dynamic type that should be evaluated.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
@RestrictTo(Scope.LIBRARY_GROUP)
public BoundDynamicType bind(
@NonNull DynamicFloat floatSource, @NonNull DynamicTypeValueReceiver<Float> consumer) {
List<DynamicDataNode<?>> resultBuilder = new ArrayList<>();
bindRecursively(
floatSource, new DynamicTypeValueReceiverOnExecutor<>(consumer), resultBuilder);
return new BoundDynamicTypeImpl(resultBuilder);
}
/**
* Adds dynamic type from the given {@link DynamicBuilders.DynamicColor} for evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* <p>Results of evaluation will be sent through the given {@link DynamicTypeValueReceiver} on
* the given {@link Executor}.
*
* @param colorSource The given color dynamic type that should be evaluated.
* @param executor The Executor to run the consumer on.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
public BoundDynamicType bind(
@NonNull DynamicBuilders.DynamicColor colorSource,
@NonNull Executor executor,
@NonNull DynamicTypeValueReceiver<Integer> consumer) {
return bind(
colorSource.toDynamicColorProto(),
new DynamicTypeValueReceiverOnExecutor<>(executor, consumer));
}
/**
* Adds pending dynamic type from the given {@link DynamicColor} for future evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* @param colorSource The given color dynamic type that should be evaluated.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
@RestrictTo(Scope.LIBRARY_GROUP)
public BoundDynamicType bind(
@NonNull DynamicColor colorSource,
@NonNull DynamicTypeValueReceiver<Integer> consumer) {
List<DynamicDataNode<?>> resultBuilder = new ArrayList<>();
bindRecursively(
colorSource, new DynamicTypeValueReceiverOnExecutor<>(consumer), resultBuilder);
return new BoundDynamicTypeImpl(resultBuilder);
}
/**
* Adds dynamic type from the given {@link DynamicBuilders.DynamicDuration} for evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* <p>Results of evaluation will be sent through the given {@link DynamicTypeValueReceiver} on
* the given {@link Executor}.
*
* @param durationSource The given duration dynamic type that should be evaluated.
* @param executor The Executor to run the consumer on.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
public BoundDynamicType bind(
@NonNull DynamicBuilders.DynamicDuration durationSource,
@NonNull Executor executor,
@NonNull DynamicTypeValueReceiver<Duration> consumer) {
return bind(
durationSource.toDynamicDurationProto(),
new DynamicTypeValueReceiverOnExecutor<>(executor, consumer));
}
/**
* Adds pending dynamic type from the given {@link DynamicDuration} for future evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* @param durationSource The given durations dynamic type that should be evaluated.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
@RestrictTo(Scope.LIBRARY_GROUP)
public BoundDynamicType bind(
@NonNull DynamicDuration durationSource,
@NonNull DynamicTypeValueReceiver<Duration> consumer) {
List<DynamicDataNode<?>> resultBuilder = new ArrayList<>();
bindRecursively(
durationSource, new DynamicTypeValueReceiverOnExecutor<>(consumer), resultBuilder);
return new BoundDynamicTypeImpl(resultBuilder);
}
/**
* Adds dynamic type from the given {@link DynamicBuilders.DynamicInstant} for evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* <p>Results of evaluation will be sent through the given {@link DynamicTypeValueReceiver} on
* the given {@link Executor}.
*
* @param instantSource The given instant dynamic type that should be evaluated.
* @param executor The Executor to run the consumer on.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
public BoundDynamicType bind(
@NonNull DynamicBuilders.DynamicInstant instantSource,
@NonNull Executor executor,
@NonNull DynamicTypeValueReceiver<Instant> consumer) {
return bind(
instantSource.toDynamicInstantProto(),
new DynamicTypeValueReceiverOnExecutor<>(executor, consumer));
}
/**
* Adds pending dynamic type from the given {@link DynamicInstant} for future evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* @param instantSource The given instant dynamic type that should be evaluated.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
@RestrictTo(Scope.LIBRARY_GROUP)
public BoundDynamicType bind(
@NonNull DynamicInstant instantSource,
@NonNull DynamicTypeValueReceiver<Instant> consumer) {
List<DynamicDataNode<?>> resultBuilder = new ArrayList<>();
bindRecursively(
instantSource, new DynamicTypeValueReceiverOnExecutor<>(consumer), resultBuilder);
return new BoundDynamicTypeImpl(resultBuilder);
}
/**
* Adds dynamic type from the given {@link DynamicBuilders.DynamicBool} for evaluation.
* Evaluation will start immediately.
*
* <p>Results of evaluation will be sent through the given {@link DynamicTypeValueReceiver} on
* the given {@link Executor}.
*
* @param boolSource The given boolean dynamic type that should be evaluated.
* @param executor The Executor to run the consumer on.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
public BoundDynamicType bind(
@NonNull DynamicBuilders.DynamicBool boolSource,
@NonNull Executor executor,
@NonNull DynamicTypeValueReceiver<Boolean> consumer) {
return bind(
boolSource.toDynamicBoolProto(),
new DynamicTypeValueReceiverOnExecutor<>(executor, consumer));
}
/**
* Adds pending dynamic type from the given {@link DynamicBool} for future evaluation.
*
* <p>Evaluation of this dynamic type will start when {@link BoundDynamicType#startEvaluation()}
* is called on the returned object.
*
* @param boolSource The given boolean dynamic type that should be evaluated.
* @param consumer The registered consumer for results of the evaluation. It will be called from
* UI thread.
*/
@NonNull
@RestrictTo(Scope.LIBRARY_GROUP)
public BoundDynamicType bind(
@NonNull DynamicBool boolSource, @NonNull DynamicTypeValueReceiver<Boolean> consumer) {
List<DynamicDataNode<?>> resultBuilder = new ArrayList<>();
bindRecursively(
boolSource, new DynamicTypeValueReceiverOnExecutor<>(consumer), resultBuilder);
return new BoundDynamicTypeImpl(resultBuilder);
}
/**
* Same as {@link #bind}, but instead of returning one {@link BoundDynamicType}, all {@link
* DynamicDataNode} produced by evaluating given dynamic type are added to the given list.
*/
private void bindRecursively(
@NonNull DynamicString stringSource,
@NonNull DynamicTypeValueReceiverWithPreUpdate<String> consumer,
@NonNull ULocale locale,
@NonNull List<DynamicDataNode<?>> resultBuilder) {
DynamicDataNode<?> node;
switch (stringSource.getInnerCase()) {
case FIXED:
node = new FixedStringNode(stringSource.getFixed(), consumer);
break;
case INT32_FORMAT_OP:
{
NumberFormatter formatter =
new NumberFormatter(stringSource.getInt32FormatOp(), locale);
Int32FormatNode int32FormatNode = new Int32FormatNode(formatter, consumer);
node = int32FormatNode;
bindRecursively(
stringSource.getInt32FormatOp().getInput(),
int32FormatNode.getIncomingCallback(),
resultBuilder);
break;
}
case FLOAT_FORMAT_OP:
{
NumberFormatter formatter =
new NumberFormatter(stringSource.getFloatFormatOp(), locale);
FloatFormatNode floatFormatNode = new FloatFormatNode(formatter, consumer);
node = floatFormatNode;
bindRecursively(
stringSource.getFloatFormatOp().getInput(),
floatFormatNode.getIncomingCallback(),
resultBuilder);
break;
}
case STATE_SOURCE:
{
node =
new StateStringNode(
mStateStore, stringSource.getStateSource(), consumer);
break;
}
case CONDITIONAL_OP:
{
ConditionalOpNode<String> conditionalNode = new ConditionalOpNode<>(consumer);
ConditionalStringOp op = stringSource.getConditionalOp();
bindRecursively(
op.getCondition(),
conditionalNode.getConditionIncomingCallback(),
resultBuilder);
bindRecursively(
op.getValueIfTrue(),
conditionalNode.getTrueValueIncomingCallback(),
locale,
resultBuilder);
bindRecursively(
op.getValueIfFalse(),
conditionalNode.getFalseValueIncomingCallback(),
locale,
resultBuilder);
node = conditionalNode;
break;
}
case CONCAT_OP:
{
StringConcatOpNode concatNode = new StringConcatOpNode(consumer);
node = concatNode;
bindRecursively(
stringSource.getConcatOp().getInputLhs(),
concatNode.getLhsIncomingCallback(),
locale,
resultBuilder);
bindRecursively(
stringSource.getConcatOp().getInputRhs(),
concatNode.getRhsIncomingCallback(),
locale,
resultBuilder);
break;
}
case INNER_NOT_SET:
throw new IllegalArgumentException("DynamicString has no inner source set");
default:
throw new IllegalArgumentException("Unknown DynamicString source type");
}
resultBuilder.add(node);
}
/**
* Same as {@link #bind}, but instead of returning one {@link BoundDynamicType}, all {@link
* DynamicDataNode} produced by evaluating given dynamic type are added to the given list.
*/
private void bindRecursively(
@NonNull DynamicInt32 int32Source,
@NonNull DynamicTypeValueReceiverWithPreUpdate<Integer> consumer,
@NonNull List<DynamicDataNode<?>> resultBuilder) {
DynamicDataNode<Integer> node;
switch (int32Source.getInnerCase()) {
case FIXED:
node = new FixedInt32Node(int32Source.getFixed(), consumer);
break;
case PLATFORM_SOURCE:
node =
new PlatformInt32SourceNode(
int32Source.getPlatformSource(),
mSensorGatewayDataSource,
consumer);
break;
case ARITHMETIC_OPERATION:
{
ArithmeticInt32Node arithmeticNode =
new ArithmeticInt32Node(int32Source.getArithmeticOperation(), consumer);
node = arithmeticNode;
bindRecursively(
int32Source.getArithmeticOperation().getInputLhs(),
arithmeticNode.getLhsIncomingCallback(),
resultBuilder);
bindRecursively(
int32Source.getArithmeticOperation().getInputRhs(),
arithmeticNode.getRhsIncomingCallback(),
resultBuilder);
break;
}
case STATE_SOURCE:
{
node =
new StateInt32SourceNode(
mStateStore, int32Source.getStateSource(), consumer);
break;
}
case CONDITIONAL_OP:
{
ConditionalOpNode<Integer> conditionalNode = new ConditionalOpNode<>(consumer);
ConditionalInt32Op op = int32Source.getConditionalOp();
bindRecursively(
op.getCondition(),
conditionalNode.getConditionIncomingCallback(),
resultBuilder);
bindRecursively(
op.getValueIfTrue(),
conditionalNode.getTrueValueIncomingCallback(),
resultBuilder);
bindRecursively(
op.getValueIfFalse(),
conditionalNode.getFalseValueIncomingCallback(),
resultBuilder);
node = conditionalNode;
break;
}
case FLOAT_TO_INT:
{
FloatToInt32Node conversionNode =
new FloatToInt32Node(int32Source.getFloatToInt(), consumer);
node = conversionNode;
bindRecursively(
int32Source.getFloatToInt().getInput(),
conversionNode.getIncomingCallback(),
resultBuilder);
break;
}
case DURATION_PART:
{
GetDurationPartOpNode durationPartOpNode =
new GetDurationPartOpNode(int32Source.getDurationPart(), consumer);
node = durationPartOpNode;
bindRecursively(
int32Source.getDurationPart().getInput(),
durationPartOpNode.getIncomingCallback(),
resultBuilder);
break;
}
case ANIMATABLE_FIXED:
// We don't have to check if enableAnimations is true, because if it's false and
// we didn't have static value set, constructor has put QuotaManager that don't
// have any quota, so animations won't be played and they would jump to the end
// value.
node =
new AnimatableFixedInt32Node(
int32Source.getAnimatableFixed(), consumer, mAnimationQuotaManager);
break;
case ANIMATABLE_DYNAMIC:
// We don't have to check if enableAnimations is true, because if it's false and
// we didn't have static value set, constructor has put QuotaManager that don't
// have any quota, so animations won't be played and they would jump to the end
// value.
AnimatableDynamicInt32 dynamicNode = int32Source.getAnimatableDynamic();
DynamicAnimatedInt32Node animationNode =
new DynamicAnimatedInt32Node(
consumer, dynamicNode.getAnimationSpec(), mAnimationQuotaManager);
node = animationNode;
bindRecursively(
dynamicNode.getInput(), animationNode.getInputCallback(), resultBuilder);
break;
case INNER_NOT_SET:
throw new IllegalArgumentException("DynamicInt32 has no inner source set");
default:
throw new IllegalArgumentException("Unknown DynamicInt32 source type");
}
resultBuilder.add(node);
}
/**
* Same as {@link #bind}, but instead of returning one {@link BoundDynamicType}, all {@link
* DynamicDataNode} produced by evaluating given dynamic type are added to the given list.
*/
private void bindRecursively(
@NonNull DynamicDuration durationSource,
@NonNull DynamicTypeValueReceiverWithPreUpdate<Duration> consumer,
@NonNull List<DynamicDataNode<?>> resultBuilder) {
DynamicDataNode<?> node;
switch (durationSource.getInnerCase()) {
case BETWEEN:
BetweenInstancesNode betweenInstancesNode = new BetweenInstancesNode(consumer);
node = betweenInstancesNode;
bindRecursively(
durationSource.getBetween().getStartInclusive(),
betweenInstancesNode.getLhsIncomingCallback(),
resultBuilder);
bindRecursively(
durationSource.getBetween().getEndExclusive(),
betweenInstancesNode.getRhsIncomingCallback(),
resultBuilder);
break;
case INNER_NOT_SET:
throw new IllegalArgumentException("DynamicDuration has no inner source set");
default:
throw new IllegalArgumentException("Unknown DynamicDuration source type");
}
resultBuilder.add(node);
}
/**
* Same as {@link #bind}, but instead of returning one {@link BoundDynamicType}, all {@link
* DynamicDataNode} produced by evaluating given dynamic type are added to the given list.
*/
private void bindRecursively(
@NonNull DynamicInstant instantSource,
@NonNull DynamicTypeValueReceiverWithPreUpdate<Instant> consumer,
@NonNull List<DynamicDataNode<?>> resultBuilder) {
DynamicDataNode<?> node;
switch (instantSource.getInnerCase()) {
case FIXED:
node = new FixedInstantNode(instantSource.getFixed(), consumer);
break;
case PLATFORM_SOURCE:
node = new PlatformTimeSourceNode(mTimeDataSource, consumer);
break;
case INNER_NOT_SET:
throw new IllegalArgumentException("DynamicInstant has no inner source set");
default:
throw new IllegalArgumentException("Unknown DynamicInstant source type");
}
resultBuilder.add(node);
}
/**
* Same as {@link #bind}, but instead of returning one {@link BoundDynamicType}, all {@link
* DynamicDataNode} produced by evaluating given dynamic type are added to the given list.
*/
private void bindRecursively(
@NonNull DynamicFloat floatSource,
@NonNull DynamicTypeValueReceiverWithPreUpdate<Float> consumer,
@NonNull List<DynamicDataNode<?>> resultBuilder) {
DynamicDataNode<?> node;
switch (floatSource.getInnerCase()) {
case FIXED:
node = new FixedFloatNode(floatSource.getFixed(), consumer);
break;
case STATE_SOURCE:
node =
new StateFloatSourceNode(
mStateStore, floatSource.getStateSource(), consumer);
break;
case ARITHMETIC_OPERATION:
{
ArithmeticFloatNode arithmeticNode =
new ArithmeticFloatNode(floatSource.getArithmeticOperation(), consumer);
node = arithmeticNode;
bindRecursively(
floatSource.getArithmeticOperation().getInputLhs(),
arithmeticNode.getLhsIncomingCallback(),
resultBuilder);
bindRecursively(
floatSource.getArithmeticOperation().getInputRhs(),
arithmeticNode.getRhsIncomingCallback(),
resultBuilder);
break;
}
case INT32_TO_FLOAT_OPERATION:
{
Int32ToFloatNode toFloatNode = new Int32ToFloatNode(consumer);
node = toFloatNode;
bindRecursively(
floatSource.getInt32ToFloatOperation().getInput(),
toFloatNode.getIncomingCallback(),
resultBuilder);
break;
}
case CONDITIONAL_OP:
{
ConditionalOpNode<Float> conditionalNode = new ConditionalOpNode<>(consumer);
ConditionalFloatOp op = floatSource.getConditionalOp();
bindRecursively(
op.getCondition(),
conditionalNode.getConditionIncomingCallback(),
resultBuilder);
bindRecursively(
op.getValueIfTrue(),
conditionalNode.getTrueValueIncomingCallback(),
resultBuilder);
bindRecursively(
op.getValueIfFalse(),
conditionalNode.getFalseValueIncomingCallback(),
resultBuilder);
node = conditionalNode;
break;
}
case ANIMATABLE_FIXED:
// We don't have to check if enableAnimations is true, because if it's false and
// we didn't have static value set, constructor has put QuotaManager that don't
// have any quota, so animations won't be played and they would jump to the end
// value.
node =
new AnimatableFixedFloatNode(
floatSource.getAnimatableFixed(), consumer, mAnimationQuotaManager);
break;
case ANIMATABLE_DYNAMIC:
// We don't have to check if enableAnimations is true, because if it's false and
// we didn't have static value set, constructor has put QuotaManager that don't
// have any quota, so animations won't be played and they would jump to the end
// value.
AnimatableDynamicFloat dynamicNode = floatSource.getAnimatableDynamic();
DynamicAnimatedFloatNode animationNode =
new DynamicAnimatedFloatNode(
consumer, dynamicNode.getAnimationSpec(), mAnimationQuotaManager);
node = animationNode;
bindRecursively(
dynamicNode.getInput(), animationNode.getInputCallback(), resultBuilder);
break;
case INNER_NOT_SET:
throw new IllegalArgumentException("DynamicFloat has no inner source set");
default:
throw new IllegalArgumentException("Unknown DynamicFloat source type");
}
resultBuilder.add(node);
}
/**
* Same as {@link #bind}, but instead of returning one {@link BoundDynamicType}, all {@link
* DynamicDataNode} produced by evaluating given dynamic type are added to the given list.
*/
private void bindRecursively(
@NonNull DynamicColor colorSource,
@NonNull DynamicTypeValueReceiverWithPreUpdate<Integer> consumer,
@NonNull List<DynamicDataNode<?>> resultBuilder) {
DynamicDataNode<?> node;
switch (colorSource.getInnerCase()) {
case FIXED:
node = new FixedColorNode(colorSource.getFixed(), consumer);
break;
case STATE_SOURCE:
node =
new StateColorSourceNode(
mStateStore, colorSource.getStateSource(), consumer);
break;
case ANIMATABLE_FIXED:
// We don't have to check if enableAnimations is true, because if it's false and
// we didn't have static value set, constructor has put QuotaManager that don't
// have any quota, so animations won't be played and they would jump to the end
// value.
node =
new AnimatableFixedColorNode(
colorSource.getAnimatableFixed(), consumer, mAnimationQuotaManager);
break;
case ANIMATABLE_DYNAMIC:
// We don't have to check if enableAnimations is true, because if it's false and
// we didn't have static value set, constructor has put QuotaManager that don't
// have any quota, so animations won't be played and they would jump to the end
// value.
AnimatableDynamicColor dynamicNode = colorSource.getAnimatableDynamic();
DynamicAnimatedColorNode animationNode =
new DynamicAnimatedColorNode(
consumer, dynamicNode.getAnimationSpec(), mAnimationQuotaManager);
node = animationNode;
bindRecursively(
dynamicNode.getInput(), animationNode.getInputCallback(), resultBuilder);
break;
case CONDITIONAL_OP:
ConditionalOpNode<Integer> conditionalNode = new ConditionalOpNode<>(consumer);
ConditionalColorOp op = colorSource.getConditionalOp();
bindRecursively(
op.getCondition(),
conditionalNode.getConditionIncomingCallback(),
resultBuilder);
bindRecursively(
op.getValueIfTrue(),
conditionalNode.getTrueValueIncomingCallback(),
resultBuilder);
bindRecursively(
op.getValueIfFalse(),
conditionalNode.getFalseValueIncomingCallback(),
resultBuilder);
node = conditionalNode;
break;
case INNER_NOT_SET:
throw new IllegalArgumentException("DynamicColor has no inner source set");
default:
throw new IllegalArgumentException("Unknown DynamicColor source type");
}
resultBuilder.add(node);
}
/**
* Same as {@link #bind}, but instead of returning one {@link BoundDynamicType}, all {@link
* DynamicDataNode} produced by evaluating given dynamic type are added to the given list.
*/
private void bindRecursively(
@NonNull DynamicBool boolSource,
@NonNull DynamicTypeValueReceiverWithPreUpdate<Boolean> consumer,
@NonNull List<DynamicDataNode<?>> resultBuilder) {
DynamicDataNode<?> node;
switch (boolSource.getInnerCase()) {
case FIXED:
node = new FixedBoolNode(boolSource.getFixed(), consumer);
break;
case STATE_SOURCE:
node = new StateBoolNode(mStateStore, boolSource.getStateSource(), consumer);
break;
case INT32_COMPARISON:
{
ComparisonInt32Node compNode =
new ComparisonInt32Node(boolSource.getInt32Comparison(), consumer);
node = compNode;
bindRecursively(
boolSource.getInt32Comparison().getInputLhs(),
compNode.getLhsIncomingCallback(),
resultBuilder);
bindRecursively(
boolSource.getInt32Comparison().getInputRhs(),
compNode.getRhsIncomingCallback(),
resultBuilder);
break;
}
case LOGICAL_OP:
{
LogicalBoolOp logicalNode =
new LogicalBoolOp(boolSource.getLogicalOp(), consumer);
node = logicalNode;
bindRecursively(
boolSource.getLogicalOp().getInputLhs(),
logicalNode.getLhsIncomingCallback(),
resultBuilder);
bindRecursively(
boolSource.getLogicalOp().getInputRhs(),
logicalNode.getRhsIncomingCallback(),
resultBuilder);
break;
}
case NOT_OP:
{
NotBoolOp notNode = new NotBoolOp(consumer);
node = notNode;
bindRecursively(
boolSource.getNotOp().getInput(),
notNode.getIncomingCallback(),
resultBuilder);
break;
}
case FLOAT_COMPARISON:
{
ComparisonFloatNode compNode =
new ComparisonFloatNode(boolSource.getFloatComparison(), consumer);
node = compNode;
bindRecursively(
boolSource.getFloatComparison().getInputLhs(),
compNode.getLhsIncomingCallback(),
resultBuilder);
bindRecursively(
boolSource.getFloatComparison().getInputRhs(),
compNode.getRhsIncomingCallback(),
resultBuilder);
break;
}
case INNER_NOT_SET:
throw new IllegalArgumentException("DynamicBool has no inner source set");
default:
throw new IllegalArgumentException("Unknown DynamicBool source type");
}
resultBuilder.add(node);
}
/** Enables sending updates on sensor and time. */
@UiThread
public void enablePlatformDataSources() {
if (this.mTimeGateway instanceof TimeGatewayImpl) {
((TimeGatewayImpl) mTimeGateway).enableUpdates();
}
if (mConfig.getSensorGateway() != null) {
mConfig.getSensorGateway().enableUpdates();
}
}
/** Disables sending updates on sensor and time. */
@UiThread
public void disablePlatformDataSources() {
if (this.mTimeGateway instanceof TimeGatewayImpl) {
((TimeGatewayImpl) mTimeGateway).disableUpdates();
}
if (mConfig.getSensorGateway() != null) {
mConfig.getSensorGateway().disableUpdates();
}
}
/**
* Closes resources owned by this {@link DynamicTypeEvaluator}.
*
* <p>This will not close provided resources, like the {@link TimeGateway} or {@link
* SensorGateway}.
*/
@RestrictTo(Scope.LIBRARY_GROUP)
@Override
public void close() {
if (mTimeGateway instanceof TimeGatewayImpl) {
try {
((TimeGatewayImpl) mTimeGateway).close();
} catch (RuntimeException ex) {
Log.e(TAG, "Error while cleaning up time gateway", ex);
}
}
}
/**
* Wraps {@link DynamicTypeValueReceiver} and executes its methods on the given {@link
* Executor}.
*/
private static class DynamicTypeValueReceiverOnExecutor<T>
implements DynamicTypeValueReceiverWithPreUpdate<T> {
@NonNull private final Executor mExecutor;
@NonNull private final DynamicTypeValueReceiver<T> mConsumer;
DynamicTypeValueReceiverOnExecutor(@NonNull DynamicTypeValueReceiver<T> consumer) {
this(Runnable::run, consumer);
}
DynamicTypeValueReceiverOnExecutor(
@NonNull Executor executor, @NonNull DynamicTypeValueReceiver<T> consumer) {
this.mConsumer = consumer;
this.mExecutor = executor;
}
/** This method is noop in this class. */
@Override
@SuppressWarnings("ExecutorTaskName")
public void onPreUpdate() {}
@Override
@SuppressWarnings("ExecutorTaskName")
public void onData(@NonNull T newData) {
mExecutor.execute(() -> mConsumer.onData(newData));
}
@Override
@SuppressWarnings("ExecutorTaskName")
public void onInvalidated() {
mExecutor.execute(mConsumer::onInvalidated);
}
}
}