248 lines
7.5 KiB
Java
248 lines
7.5 KiB
Java
/*
|
|
* Copyright (C) 2019 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.service.controls.templates;
|
|
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.os.Bundle;
|
|
import android.service.controls.Control;
|
|
import android.util.Log;
|
|
|
|
import com.android.internal.util.Preconditions;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
|
|
/**
|
|
* A template for a temperature related {@link Control} that supports multiple modes.
|
|
*
|
|
* Both the current mode and the active mode for the control can be specified. The combination of
|
|
* the {@link Control#getDeviceType} and the current and active mode will determine colors and
|
|
* transitions for the UI element.
|
|
*/
|
|
public final class TemperatureControlTemplate extends ControlTemplate {
|
|
|
|
private static final String TAG = "ThermostatTemplate";
|
|
|
|
private static final @TemplateType int TYPE = TYPE_TEMPERATURE;
|
|
private static final String KEY_TEMPLATE = "key_template";
|
|
private static final String KEY_CURRENT_MODE = "key_current_mode";
|
|
private static final String KEY_CURRENT_ACTIVE_MODE = "key_current_active_mode";
|
|
private static final String KEY_MODES = "key_modes";
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef({
|
|
MODE_UNKNOWN,
|
|
MODE_OFF,
|
|
MODE_HEAT,
|
|
MODE_COOL,
|
|
MODE_HEAT_COOL,
|
|
MODE_ECO
|
|
})
|
|
public @interface Mode {}
|
|
|
|
private static final int NUM_MODES = 6;
|
|
|
|
/**
|
|
* Use when the current or active mode of the device is not known
|
|
*/
|
|
public static final @Mode int MODE_UNKNOWN = 0;
|
|
|
|
/**
|
|
* Indicates that the current or active mode of the device is off.
|
|
*/
|
|
public static final @Mode int MODE_OFF = 1;
|
|
|
|
/**
|
|
* Indicates that the current or active mode of the device is set to heat.
|
|
*/
|
|
public static final @Mode int MODE_HEAT = 2;
|
|
|
|
/**
|
|
* Indicates that the current or active mode of the device is set to cool.
|
|
*/
|
|
public static final @Mode int MODE_COOL = 3;
|
|
|
|
/**
|
|
* Indicates that the current or active mode of the device is set to heat-cool.
|
|
*/
|
|
public static final @Mode int MODE_HEAT_COOL = 4;
|
|
|
|
/**
|
|
* Indicates that the current or active mode of the device is set to eco.
|
|
*/
|
|
public static final @Mode int MODE_ECO = 5;
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef(flag = true, value = {
|
|
FLAG_MODE_OFF,
|
|
FLAG_MODE_HEAT,
|
|
FLAG_MODE_COOL,
|
|
FLAG_MODE_HEAT_COOL,
|
|
FLAG_MODE_ECO
|
|
})
|
|
public @interface ModeFlag {}
|
|
|
|
/**
|
|
* Flag to indicate that the device supports off mode.
|
|
*/
|
|
public static final int FLAG_MODE_OFF = 1 << MODE_OFF;
|
|
|
|
/**
|
|
* Flag to indicate that the device supports heat mode.
|
|
*/
|
|
public static final int FLAG_MODE_HEAT = 1 << MODE_HEAT;
|
|
|
|
/**
|
|
* Flag to indicate that the device supports cool mode.
|
|
*/
|
|
public static final int FLAG_MODE_COOL = 1 << MODE_COOL;
|
|
|
|
/**
|
|
* Flag to indicate that the device supports heat-cool mode.
|
|
*/
|
|
public static final int FLAG_MODE_HEAT_COOL = 1 << MODE_HEAT_COOL;
|
|
|
|
/**
|
|
* Flag to indicate that the device supports eco mode.
|
|
*/
|
|
public static final int FLAG_MODE_ECO = 1 << MODE_ECO;
|
|
private static final int ALL_FLAGS =
|
|
FLAG_MODE_OFF |
|
|
FLAG_MODE_HEAT |
|
|
FLAG_MODE_COOL |
|
|
FLAG_MODE_HEAT_COOL |
|
|
FLAG_MODE_ECO;
|
|
|
|
private static final int[] modeToFlag = new int[]{
|
|
0,
|
|
FLAG_MODE_OFF,
|
|
FLAG_MODE_HEAT,
|
|
FLAG_MODE_COOL,
|
|
FLAG_MODE_HEAT_COOL,
|
|
FLAG_MODE_ECO
|
|
};
|
|
|
|
private final @NonNull ControlTemplate mTemplate;
|
|
private final @Mode int mCurrentMode;
|
|
private final @Mode int mCurrentActiveMode;
|
|
private final @ModeFlag int mModes;
|
|
|
|
/**
|
|
* Construct a new {@link TemperatureControlTemplate}.
|
|
*
|
|
* The current and active mode have to be among the ones supported by the flags.
|
|
*
|
|
* @param templateId the identifier for this template object
|
|
* @param controlTemplate a template to use for interaction with the user
|
|
* @param currentMode the current mode for the {@link Control}
|
|
* @param currentActiveMode the current active mode for the {@link Control}
|
|
* @param modesFlag a flag representing the available modes for the {@link Control}
|
|
* @throws IllegalArgumentException if the parameters passed do not make a valid template.
|
|
*/
|
|
public TemperatureControlTemplate(@NonNull String templateId,
|
|
@NonNull ControlTemplate controlTemplate,
|
|
@Mode int currentMode,
|
|
@Mode int currentActiveMode,
|
|
@ModeFlag int modesFlag) {
|
|
super(templateId);
|
|
Preconditions.checkNotNull(controlTemplate);
|
|
mTemplate = controlTemplate;
|
|
|
|
if (currentMode < 0 || currentMode >= NUM_MODES) {
|
|
Log.e(TAG, "Invalid current mode:" + currentMode);
|
|
mCurrentMode = MODE_UNKNOWN;
|
|
} else {
|
|
mCurrentMode = currentMode;
|
|
}
|
|
|
|
if (currentActiveMode < 0 || currentActiveMode >= NUM_MODES) {
|
|
Log.e(TAG, "Invalid current active mode:" + currentActiveMode);
|
|
mCurrentActiveMode = MODE_UNKNOWN;
|
|
} else {
|
|
mCurrentActiveMode = currentActiveMode;
|
|
}
|
|
|
|
mModes = modesFlag & ALL_FLAGS;
|
|
if (mCurrentMode != MODE_UNKNOWN && (modeToFlag[mCurrentMode] & mModes) == 0) {
|
|
throw new IllegalArgumentException("Mode " + mCurrentMode + " not supported in flag.");
|
|
}
|
|
if (mCurrentActiveMode != MODE_UNKNOWN && (modeToFlag[mCurrentActiveMode] & mModes) == 0) {
|
|
throw new IllegalArgumentException(
|
|
"Mode " + currentActiveMode + " not supported in flag.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param b
|
|
* @hide
|
|
*/
|
|
TemperatureControlTemplate(@NonNull Bundle b) {
|
|
super(b);
|
|
mTemplate = ControlTemplate.createTemplateFromBundle(b.getBundle(KEY_TEMPLATE));
|
|
mCurrentMode = b.getInt(KEY_CURRENT_MODE);
|
|
mCurrentActiveMode = b.getInt(KEY_CURRENT_ACTIVE_MODE);
|
|
mModes = b.getInt(KEY_MODES);
|
|
}
|
|
|
|
/**
|
|
* @return
|
|
* @hide
|
|
*/
|
|
@Override
|
|
@NonNull
|
|
Bundle getDataBundle() {
|
|
Bundle b = super.getDataBundle();
|
|
b.putBundle(KEY_TEMPLATE, mTemplate.getDataBundle());
|
|
b.putInt(KEY_CURRENT_MODE, mCurrentMode);
|
|
b.putInt(KEY_CURRENT_ACTIVE_MODE, mCurrentActiveMode);
|
|
b.putInt(KEY_MODES, mModes);
|
|
return b;
|
|
}
|
|
|
|
@NonNull
|
|
public ControlTemplate getTemplate() {
|
|
return mTemplate;
|
|
}
|
|
|
|
public int getCurrentMode() {
|
|
return mCurrentMode;
|
|
}
|
|
|
|
public int getCurrentActiveMode() {
|
|
return mCurrentActiveMode;
|
|
}
|
|
|
|
public int getModes() {
|
|
return mModes;
|
|
}
|
|
|
|
/**
|
|
* @return {@link ControlTemplate#TYPE_TEMPERATURE}
|
|
*/
|
|
@Override
|
|
public int getTemplateType() {
|
|
return TYPE;
|
|
}
|
|
}
|