sdk/src/java/cyanogenmod/hardware/LiveDisplayConfig.java - SHIFTPHONES/android_lineage-sdk - Gitiles

 /*
  * Copyright (C) 2016 The CyanogenMod 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 cyanogenmod.hardware;

 import static cyanogenmod.hardware.LiveDisplayManager.FEATURE_COLOR_BALANCE;
 import static cyanogenmod.hardware.LiveDisplayManager.FEATURE_FIRST;
 import static cyanogenmod.hardware.LiveDisplayManager.FEATURE_LAST;
 import static cyanogenmod.hardware.LiveDisplayManager.MODE_FIRST;
 import static cyanogenmod.hardware.LiveDisplayManager.MODE_LAST;
 import static cyanogenmod.hardware.LiveDisplayManager.MODE_OFF;

 import android.os.Parcel;
 import android.os.Parcelable;
 import android.util.Range;

 import java.util.Arrays;
 import java.util.BitSet;
 import java.util.List;

 import cyanogenmod.os.Build;
 import cyanogenmod.os.Concierge;
 import cyanogenmod.os.Concierge.ParcelInfo;

 /**
  * Holder class for LiveDisplay static configuration.
  *
  * This class holds various defaults and hardware capabilities
  * which are involved with LiveDisplay.
  */
 public class LiveDisplayConfig implements Parcelable {

     private final BitSet mCapabilities;
     private final BitSet mAllModes = new BitSet();

     private final int mDefaultDayTemperature;
     private final int mDefaultNightTemperature;
     private final int mDefaultMode;

     private final boolean mDefaultAutoContrast;
     private final boolean mDefaultAutoOutdoorMode;
     private final boolean mDefaultCABC;
     private final boolean mDefaultColorEnhancement;

     private final Range<Integer> mColorTemperatureRange;
     private final Range<Integer> mColorBalanceRange;
     private final Range<Float> mHueRange;
     private final Range<Float> mSaturationRange;
     private final Range<Float> mIntensityRange;
     private final Range<Float> mContrastRange;
     private final Range<Float> mSaturationThresholdRange;

     public LiveDisplayConfig(BitSet capabilities, int defaultMode,
             int defaultDayTemperature, int defaultNightTemperature,
             boolean defaultAutoOutdoorMode, boolean defaultAutoContrast,
             boolean defaultCABC, boolean defaultColorEnhancement,
             Range<Integer> colorTemperatureRange,
             Range<Integer> colorBalanceRange,
             Range<Float> hueRange,
             Range<Float> saturationRange,
             Range<Float> intensityRange,
             Range<Float> contrastRange,
             Range<Float> saturationThresholdRange) {
         super();
         mCapabilities = (BitSet) capabilities.clone();
         mAllModes.set(MODE_FIRST, MODE_LAST);
         mDefaultMode = defaultMode;
         mDefaultDayTemperature = defaultDayTemperature;
         mDefaultNightTemperature = defaultNightTemperature;
         mDefaultAutoContrast = defaultAutoContrast;
         mDefaultAutoOutdoorMode = defaultAutoOutdoorMode;
         mDefaultCABC = defaultCABC;
         mDefaultColorEnhancement = defaultColorEnhancement;
         mColorTemperatureRange = colorTemperatureRange;
         mColorBalanceRange = colorBalanceRange;
         mHueRange = hueRange;
         mSaturationRange = saturationRange;
         mIntensityRange = intensityRange;
         mContrastRange = contrastRange;
         mSaturationThresholdRange = saturationThresholdRange;
     }

     private LiveDisplayConfig(Parcel parcel) {
         // Read parcelable version via the Concierge
         ParcelInfo parcelInfo = Concierge.receiveParcel(parcel);
         int parcelableVersion = parcelInfo.getParcelVersion();

         // temp vars
         long capabilities = 0;
         int defaultMode = 0;
         int defaultDayTemperature = -1;
         int defaultNightTemperature = -1;
         boolean defaultAutoContrast = false;
         boolean defaultAutoOutdoorMode = false;
         boolean defaultCABC = false;
         boolean defaultColorEnhancement = false;
         int minColorTemperature = 0;
         int maxColorTemperature = 0;
         int minColorBalance = 0;
         int maxColorBalance = 0;
         float[] paRanges = new float[10];

         if (parcelableVersion >= Build.CM_VERSION_CODES.FIG) {
             capabilities = parcel.readLong();
             defaultMode = parcel.readInt();
             defaultDayTemperature = parcel.readInt();
             defaultNightTemperature = parcel.readInt();
             defaultAutoContrast = parcel.readInt() == 1;
             defaultAutoOutdoorMode = parcel.readInt() == 1;
             defaultCABC = parcel.readInt() == 1;
             defaultColorEnhancement = parcel.readInt() == 1;
             minColorTemperature = parcel.readInt();
             maxColorTemperature = parcel.readInt();
             minColorBalance = parcel.readInt();
             maxColorBalance = parcel.readInt();
             parcel.readFloatArray(paRanges);
         }

         // set temps
         mCapabilities = BitSet.valueOf(new long[] { capabilities });
         mAllModes.set(MODE_FIRST, MODE_LAST);
         mDefaultMode = defaultMode;
         mDefaultDayTemperature = defaultDayTemperature;
         mDefaultNightTemperature = defaultNightTemperature;
         mDefaultAutoContrast = defaultAutoContrast;
         mDefaultAutoOutdoorMode = defaultAutoOutdoorMode;
         mDefaultCABC = defaultCABC;
         mDefaultColorEnhancement = defaultColorEnhancement;
         mColorTemperatureRange = Range.create(minColorTemperature, maxColorTemperature);
         mColorBalanceRange = Range.create(minColorBalance, maxColorBalance);
         mHueRange = Range.create(paRanges[0], paRanges[1]);
         mSaturationRange = Range.create(paRanges[2], paRanges[3]);
         mIntensityRange = Range.create(paRanges[4], paRanges[5]);
         mContrastRange = Range.create(paRanges[6], paRanges[7]);
         mSaturationThresholdRange = Range.create(paRanges[8], paRanges[9]);

         // Complete parcel info for the concierge
         parcelInfo.complete();
     }

     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder();
         sb.append("capabilities=").append(mCapabilities.toString());
         sb.append(" defaultMode=").append(mDefaultMode);
         sb.append(" defaultDayTemperature=").append(mDefaultDayTemperature);
         sb.append(" defaultNightTemperature=").append(mDefaultNightTemperature);
         sb.append(" defaultAutoOutdoorMode=").append(mDefaultAutoOutdoorMode);
         sb.append(" defaultAutoContrast=").append(mDefaultAutoContrast);
         sb.append(" defaultCABC=").append(mDefaultCABC);
         sb.append(" defaultColorEnhancement=").append(mDefaultColorEnhancement);
         sb.append(" colorTemperatureRange=").append(mColorTemperatureRange);
         if (mCapabilities.get(LiveDisplayManager.FEATURE_COLOR_BALANCE)) {
             sb.append(" colorBalanceRange=").append(mColorBalanceRange);
         }
         if (mCapabilities.get(LiveDisplayManager.FEATURE_PICTURE_ADJUSTMENT)) {
             sb.append(" hueRange=").append(mHueRange);
             sb.append(" saturationRange=").append(mSaturationRange);
             sb.append(" intensityRange=").append(mIntensityRange);
             sb.append(" contrastRange=").append(mContrastRange);
             sb.append(" saturationThresholdRange=").append(mSaturationThresholdRange);
         }
         return sb.toString();
     }

     @Override
     public int describeContents() {
         return 0;
     }

     @Override
     public void writeToParcel(Parcel out, int flags) {
         // Tell the concierge to prepare the parcel
         ParcelInfo parcelInfo = Concierge.prepareParcel(out);

         // ==== FIG =====
         long[] caps = mCapabilities.toLongArray();
         out.writeLong(caps != null && caps.length > 0 ? caps[0] : 0L);
         out.writeInt(mDefaultMode);
         out.writeInt(mDefaultDayTemperature);
         out.writeInt(mDefaultNightTemperature);
         out.writeInt(mDefaultAutoContrast ? 1 : 0);
         out.writeInt(mDefaultAutoOutdoorMode ? 1 : 0);
         out.writeInt(mDefaultCABC ? 1 : 0);
         out.writeInt(mDefaultColorEnhancement ? 1 : 0);
         out.writeInt(mColorTemperatureRange.getLower());
         out.writeInt(mColorTemperatureRange.getUpper());
         out.writeInt(mColorBalanceRange.getLower());
         out.writeInt(mColorBalanceRange.getUpper());
         out.writeFloatArray(new float[] {
                 mHueRange.getLower(), mHueRange.getUpper(),
                 mSaturationRange.getLower(), mSaturationRange.getUpper(),
                 mIntensityRange.getLower(), mIntensityRange.getUpper(),
                 mContrastRange.getLower(), mContrastRange.getUpper(),
                 mSaturationThresholdRange.getLower(), mSaturationThresholdRange.getUpper() } );

         // Complete the parcel info for the concierge
         parcelInfo.complete();
     }

     /**
      * Checks if a particular feature or mode is supported by the system.
      *
      * @param feature
      * @return true if capable
      */
     public boolean hasFeature(int feature) {
         return ((feature >= MODE_FIRST && feature <= MODE_LAST) ||
                 (feature >= FEATURE_FIRST && feature <= FEATURE_LAST)) &&
                 (feature == MODE_OFF || mCapabilities.get(feature));
     }

     /**
      * Checks if LiveDisplay is available for use on this device.
      *
      * @return true if any feature is enabled
      */
     public boolean isAvailable() {
         return !mCapabilities.isEmpty();
     }

     /**
      * Checks if LiveDisplay has support for adaptive modes.
      *
      * @return true if adaptive modes are available
      */
     public boolean hasModeSupport() {
         return isAvailable() && mCapabilities.intersects(mAllModes);
     }

     /**
      * Gets the default color temperature to use in the daytime. This is typically
      * set to 6500K, however this may not be entirely accurate. Use this value for
      * resetting controls to the default.
      *
      * @return the default day temperature in K
      */
     public int getDefaultDayTemperature() {
         return mDefaultDayTemperature;
     }

     /**
      * Gets the default color temperature to use at night. This is typically set
      * to 4500K, but this may not be entirely accurate. Use this value for resetting
      * controls to defaults.
      *
      * @return the default night color temperature
      */
     public int getDefaultNightTemperature() {
         return mDefaultNightTemperature;
     }

     /**
      * Get the default adaptive mode.
      *
      * @return the default mode
      */
     public int getDefaultMode() {
         return mDefaultMode;
     }

     /**
      * Get the default value for auto contrast
      *
      * @return true if enabled
      */
     public boolean getDefaultAutoContrast() {
         return mDefaultAutoContrast;
     }

     /**
      * Get the default value for automatic outdoor mode
      *
      * @return true if enabled
      */
     public boolean getDefaultAutoOutdoorMode() {
         return mDefaultAutoOutdoorMode;
     }

     /**
      * Get the default value for CABC
      *
      * @return true if enabled
      */
     public boolean getDefaultCABC() {
         return mDefaultCABC;
     }

     /**
      * Get the default value for color enhancement
      *
      * @return true if enabled
      */
     public boolean getDefaultColorEnhancement() {
         return mDefaultColorEnhancement;
     }

     /**
      * Get the range of supported color temperatures
      *
      * @return range in Kelvin
      */
     public Range<Integer> getColorTemperatureRange() {
         return mColorTemperatureRange;
     }

     /**
      * Get the range of supported color balance
      *
      * @return linear range which maps into the temperature range curve
      */
     public Range<Integer> getColorBalanceRange() {
         return mColorBalanceRange;
     }

     /**
      * Get the supported range for hue adjustment
      *
      * @return float range
      */
     public Range<Float> getHueRange() { return mHueRange; }

     /**
      * Get the supported range for saturation adjustment
      *
      * @return float range
      */
     public Range<Float> getSaturationRange() { return mSaturationRange; }

     /**
      * Get the supported range for intensity adjustment
      *
      * @return float range
      */
     public Range<Float> getIntensityRange() { return mIntensityRange; }

     /**
      * Get the supported range for contrast adjustment
      *
      * @return float range
      */
     public Range<Float> getContrastRange() { return mContrastRange; }

     /**
      * Get the supported range for saturation threshold adjustment
      *
      * @return float range
      */
     public Range<Float> getSaturationThresholdRange() {
         return mSaturationThresholdRange;
     }


     /**
      * Convenience method to get a list of all picture adjustment ranges
      * with a single call.
      *
      * @return List of float ranges
      */
     public List<Range<Float>> getPictureAdjustmentRanges() {
         return Arrays.asList(mHueRange, mSaturationRange, mIntensityRange,
                              mContrastRange, mSaturationThresholdRange);
     }

     /** @hide */
     public static final Parcelable.Creator<LiveDisplayConfig> CREATOR =
             new Parcelable.Creator<LiveDisplayConfig>() {
         public LiveDisplayConfig createFromParcel(Parcel in) {
             return new LiveDisplayConfig(in);
         }

         @Override
         public LiveDisplayConfig[] newArray(int size) {
             return new LiveDisplayConfig[size];
         }
     };
 }
	/*
	* Copyright (C) 2016 The CyanogenMod 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 cyanogenmod.hardware;

	import static cyanogenmod.hardware.LiveDisplayManager.FEATURE_COLOR_BALANCE;
	import static cyanogenmod.hardware.LiveDisplayManager.FEATURE_FIRST;
	import static cyanogenmod.hardware.LiveDisplayManager.FEATURE_LAST;
	import static cyanogenmod.hardware.LiveDisplayManager.MODE_FIRST;
	import static cyanogenmod.hardware.LiveDisplayManager.MODE_LAST;
	import static cyanogenmod.hardware.LiveDisplayManager.MODE_OFF;

	import android.os.Parcel;
	import android.os.Parcelable;
	import android.util.Range;

	import java.util.Arrays;
	import java.util.BitSet;
	import java.util.List;

	import cyanogenmod.os.Build;
	import cyanogenmod.os.Concierge;
	import cyanogenmod.os.Concierge.ParcelInfo;

	/**
	* Holder class for LiveDisplay static configuration.
	*
	* This class holds various defaults and hardware capabilities
	* which are involved with LiveDisplay.
	*/
	public class LiveDisplayConfig implements Parcelable {

	private final BitSet mCapabilities;
	private final BitSet mAllModes = new BitSet();

	private final int mDefaultDayTemperature;
	private final int mDefaultNightTemperature;
	private final int mDefaultMode;

	private final boolean mDefaultAutoContrast;
	private final boolean mDefaultAutoOutdoorMode;
	private final boolean mDefaultCABC;
	private final boolean mDefaultColorEnhancement;

	private final Range<Integer> mColorTemperatureRange;
	private final Range<Integer> mColorBalanceRange;
	private final Range<Float> mHueRange;
	private final Range<Float> mSaturationRange;
	private final Range<Float> mIntensityRange;
	private final Range<Float> mContrastRange;
	private final Range<Float> mSaturationThresholdRange;

	public LiveDisplayConfig(BitSet capabilities, int defaultMode,
	int defaultDayTemperature, int defaultNightTemperature,
	boolean defaultAutoOutdoorMode, boolean defaultAutoContrast,
	boolean defaultCABC, boolean defaultColorEnhancement,
	Range<Integer> colorTemperatureRange,
	Range<Integer> colorBalanceRange,
	Range<Float> hueRange,
	Range<Float> saturationRange,
	Range<Float> intensityRange,
	Range<Float> contrastRange,
	Range<Float> saturationThresholdRange) {
	super();
	mCapabilities = (BitSet) capabilities.clone();
	mAllModes.set(MODE_FIRST, MODE_LAST);
	mDefaultMode = defaultMode;
	mDefaultDayTemperature = defaultDayTemperature;
	mDefaultNightTemperature = defaultNightTemperature;
	mDefaultAutoContrast = defaultAutoContrast;
	mDefaultAutoOutdoorMode = defaultAutoOutdoorMode;
	mDefaultCABC = defaultCABC;
	mDefaultColorEnhancement = defaultColorEnhancement;
	mColorTemperatureRange = colorTemperatureRange;
	mColorBalanceRange = colorBalanceRange;
	mHueRange = hueRange;
	mSaturationRange = saturationRange;
	mIntensityRange = intensityRange;
	mContrastRange = contrastRange;
	mSaturationThresholdRange = saturationThresholdRange;
	}

	private LiveDisplayConfig(Parcel parcel) {
	// Read parcelable version via the Concierge
	ParcelInfo parcelInfo = Concierge.receiveParcel(parcel);
	int parcelableVersion = parcelInfo.getParcelVersion();

	// temp vars
	long capabilities = 0;
	int defaultMode = 0;
	int defaultDayTemperature = -1;
	int defaultNightTemperature = -1;
	boolean defaultAutoContrast = false;
	boolean defaultAutoOutdoorMode = false;
	boolean defaultCABC = false;
	boolean defaultColorEnhancement = false;
	int minColorTemperature = 0;
	int maxColorTemperature = 0;
	int minColorBalance = 0;
	int maxColorBalance = 0;
	float[] paRanges = new float[10];

	if (parcelableVersion >= Build.CM_VERSION_CODES.FIG) {
	capabilities = parcel.readLong();
	defaultMode = parcel.readInt();
	defaultDayTemperature = parcel.readInt();
	defaultNightTemperature = parcel.readInt();
	defaultAutoContrast = parcel.readInt() == 1;
	defaultAutoOutdoorMode = parcel.readInt() == 1;
	defaultCABC = parcel.readInt() == 1;
	defaultColorEnhancement = parcel.readInt() == 1;
	minColorTemperature = parcel.readInt();
	maxColorTemperature = parcel.readInt();
	minColorBalance = parcel.readInt();
	maxColorBalance = parcel.readInt();
	parcel.readFloatArray(paRanges);
	}

	// set temps
	mCapabilities = BitSet.valueOf(new long[] { capabilities });
	mAllModes.set(MODE_FIRST, MODE_LAST);
	mDefaultMode = defaultMode;
	mDefaultDayTemperature = defaultDayTemperature;
	mDefaultNightTemperature = defaultNightTemperature;
	mDefaultAutoContrast = defaultAutoContrast;
	mDefaultAutoOutdoorMode = defaultAutoOutdoorMode;
	mDefaultCABC = defaultCABC;
	mDefaultColorEnhancement = defaultColorEnhancement;
	mColorTemperatureRange = Range.create(minColorTemperature, maxColorTemperature);
	mColorBalanceRange = Range.create(minColorBalance, maxColorBalance);
	mHueRange = Range.create(paRanges[0], paRanges[1]);
	mSaturationRange = Range.create(paRanges[2], paRanges[3]);
	mIntensityRange = Range.create(paRanges[4], paRanges[5]);
	mContrastRange = Range.create(paRanges[6], paRanges[7]);
	mSaturationThresholdRange = Range.create(paRanges[8], paRanges[9]);

	// Complete parcel info for the concierge
	parcelInfo.complete();
	}

	@Override
	public String toString() {
	final StringBuilder sb = new StringBuilder();
	sb.append("capabilities=").append(mCapabilities.toString());
	sb.append(" defaultMode=").append(mDefaultMode);
	sb.append(" defaultDayTemperature=").append(mDefaultDayTemperature);
	sb.append(" defaultNightTemperature=").append(mDefaultNightTemperature);
	sb.append(" defaultAutoOutdoorMode=").append(mDefaultAutoOutdoorMode);
	sb.append(" defaultAutoContrast=").append(mDefaultAutoContrast);
	sb.append(" defaultCABC=").append(mDefaultCABC);
	sb.append(" defaultColorEnhancement=").append(mDefaultColorEnhancement);
	sb.append(" colorTemperatureRange=").append(mColorTemperatureRange);
	if (mCapabilities.get(LiveDisplayManager.FEATURE_COLOR_BALANCE)) {
	sb.append(" colorBalanceRange=").append(mColorBalanceRange);
	}
	if (mCapabilities.get(LiveDisplayManager.FEATURE_PICTURE_ADJUSTMENT)) {
	sb.append(" hueRange=").append(mHueRange);
	sb.append(" saturationRange=").append(mSaturationRange);
	sb.append(" intensityRange=").append(mIntensityRange);
	sb.append(" contrastRange=").append(mContrastRange);
	sb.append(" saturationThresholdRange=").append(mSaturationThresholdRange);
	}
	return sb.toString();
	}

	@Override
	public int describeContents() {
	return 0;
	}

	@Override
	public void writeToParcel(Parcel out, int flags) {
	// Tell the concierge to prepare the parcel
	ParcelInfo parcelInfo = Concierge.prepareParcel(out);

	// ==== FIG =====
	long[] caps = mCapabilities.toLongArray();
	out.writeLong(caps != null && caps.length > 0 ? caps[0] : 0L);
	out.writeInt(mDefaultMode);
	out.writeInt(mDefaultDayTemperature);
	out.writeInt(mDefaultNightTemperature);
	out.writeInt(mDefaultAutoContrast ? 1 : 0);
	out.writeInt(mDefaultAutoOutdoorMode ? 1 : 0);
	out.writeInt(mDefaultCABC ? 1 : 0);
	out.writeInt(mDefaultColorEnhancement ? 1 : 0);
	out.writeInt(mColorTemperatureRange.getLower());
	out.writeInt(mColorTemperatureRange.getUpper());
	out.writeInt(mColorBalanceRange.getLower());
	out.writeInt(mColorBalanceRange.getUpper());
	out.writeFloatArray(new float[] {
	mHueRange.getLower(), mHueRange.getUpper(),
	mSaturationRange.getLower(), mSaturationRange.getUpper(),
	mIntensityRange.getLower(), mIntensityRange.getUpper(),
	mContrastRange.getLower(), mContrastRange.getUpper(),
	mSaturationThresholdRange.getLower(), mSaturationThresholdRange.getUpper() } );

	// Complete the parcel info for the concierge
	parcelInfo.complete();
	}

	/**
	* Checks if a particular feature or mode is supported by the system.
	*
	* @param feature
	* @return true if capable
	*/
	public boolean hasFeature(int feature) {
	return ((feature >= MODE_FIRST && feature <= MODE_LAST) \|\|
	(feature >= FEATURE_FIRST && feature <= FEATURE_LAST)) &&
	(feature == MODE_OFF \|\| mCapabilities.get(feature));
	}

	/**
	* Checks if LiveDisplay is available for use on this device.
	*
	* @return true if any feature is enabled
	*/
	public boolean isAvailable() {
	return !mCapabilities.isEmpty();
	}

	/**
	* Checks if LiveDisplay has support for adaptive modes.
	*
	* @return true if adaptive modes are available
	*/
	public boolean hasModeSupport() {
	return isAvailable() && mCapabilities.intersects(mAllModes);
	}

	/**
	* Gets the default color temperature to use in the daytime. This is typically
	* set to 6500K, however this may not be entirely accurate. Use this value for
	* resetting controls to the default.
	*
	* @return the default day temperature in K
	*/
	public int getDefaultDayTemperature() {
	return mDefaultDayTemperature;
	}

	/**
	* Gets the default color temperature to use at night. This is typically set
	* to 4500K, but this may not be entirely accurate. Use this value for resetting
	* controls to defaults.
	*
	* @return the default night color temperature
	*/
	public int getDefaultNightTemperature() {
	return mDefaultNightTemperature;
	}

	/**
	* Get the default adaptive mode.
	*
	* @return the default mode
	*/
	public int getDefaultMode() {
	return mDefaultMode;
	}

	/**
	* Get the default value for auto contrast
	*
	* @return true if enabled
	*/
	public boolean getDefaultAutoContrast() {
	return mDefaultAutoContrast;
	}

	/**
	* Get the default value for automatic outdoor mode
	*
	* @return true if enabled
	*/
	public boolean getDefaultAutoOutdoorMode() {
	return mDefaultAutoOutdoorMode;
	}

	/**
	* Get the default value for CABC
	*
	* @return true if enabled
	*/
	public boolean getDefaultCABC() {
	return mDefaultCABC;
	}

	/**
	* Get the default value for color enhancement
	*
	* @return true if enabled
	*/
	public boolean getDefaultColorEnhancement() {
	return mDefaultColorEnhancement;
	}

	/**
	* Get the range of supported color temperatures
	*
	* @return range in Kelvin
	*/
	public Range<Integer> getColorTemperatureRange() {
	return mColorTemperatureRange;
	}

	/**
	* Get the range of supported color balance
	*
	* @return linear range which maps into the temperature range curve
	*/
	public Range<Integer> getColorBalanceRange() {
	return mColorBalanceRange;
	}

	/**
	* Get the supported range for hue adjustment
	*
	* @return float range
	*/
	public Range<Float> getHueRange() { return mHueRange; }

	/**
	* Get the supported range for saturation adjustment
	*
	* @return float range
	*/
	public Range<Float> getSaturationRange() { return mSaturationRange; }

	/**
	* Get the supported range for intensity adjustment
	*
	* @return float range
	*/
	public Range<Float> getIntensityRange() { return mIntensityRange; }

	/**
	* Get the supported range for contrast adjustment
	*
	* @return float range
	*/
	public Range<Float> getContrastRange() { return mContrastRange; }

	/**
	* Get the supported range for saturation threshold adjustment
	*
	* @return float range
	*/
	public Range<Float> getSaturationThresholdRange() {
	return mSaturationThresholdRange;
	}


	/**
	* Convenience method to get a list of all picture adjustment ranges
	* with a single call.
	*
	* @return List of float ranges
	*/
	public List<Range<Float>> getPictureAdjustmentRanges() {
	return Arrays.asList(mHueRange, mSaturationRange, mIntensityRange,
	mContrastRange, mSaturationThresholdRange);
	}

	/** @hide */
	public static final Parcelable.Creator<LiveDisplayConfig> CREATOR =
	new Parcelable.Creator<LiveDisplayConfig>() {
	public LiveDisplayConfig createFromParcel(Parcel in) {
	return new LiveDisplayConfig(in);
	}

	@Override
	public LiveDisplayConfig[] newArray(int size) {
	return new LiveDisplayConfig[size];
	}
	};
	}