camera/core/src/main/java/androidx/camera/core/SessionConfig.java - platform/frameworks/support - Git at Google

 /*
  * 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 androidx.camera.core;

 import android.hardware.camera2.CameraCaptureSession;
 import android.hardware.camera2.CameraDevice;
 import android.hardware.camera2.CameraDevice.StateCallback;
 import android.hardware.camera2.CaptureRequest;
 import android.hardware.camera2.CaptureRequest.Key;
 import android.util.Log;
 import android.view.Surface;

 import androidx.annotation.RestrictTo;
 import androidx.annotation.RestrictTo.Scope;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * Configurations needed for a capture session.
  *
  * <p>The SessionConfig contains all the {@link android.hardware.camera2} parameters that are
  * required to initialize a {@link android.hardware.camera2.CameraCaptureSession} and issue a {@link
  * CaptureRequest}.
  *
  * @hide
  */
 @RestrictTo(Scope.LIBRARY_GROUP)
 public final class SessionConfig {

     /** The set of {@link Surface} that data from the camera will be put into. */
     private final List<DeferrableSurface> mSurfaces;
     /** The state callback for a {@link CameraDevice}. */
     private final List<CameraDevice.StateCallback> mDeviceStateCallbacks;
     /** The state callback for a {@link CameraCaptureSession}. */
     private final List<CameraCaptureSession.StateCallback> mSessionStateCallbacks;
     /** The callbacks used in single requests. */
     private final List<CameraCaptureCallback> mSingleCameraCaptureCallbacks;
     /** The configuration for building the {@link CaptureRequest} used for repeating requests. */
     private final CaptureConfig mRepeatingCaptureConfig;

     /**
      * Private constructor for a SessionConfig.
      *
      * <p>In practice, the {@link SessionConfig.BaseBuilder} will be used to construct a
      * SessionConfig.
      *
      * @param surfaces               The set of {@link Surface} where data will be put into.
      * @param deviceStateCallbacks   The state callbacks for a {@link CameraDevice}.
      * @param sessionStateCallbacks  The state callbacks for a {@link CameraCaptureSession}.
      * @param repeatingCaptureConfig The configuration for building the {@link CaptureRequest}.
      */
     SessionConfig(
             List<DeferrableSurface> surfaces,
             List<StateCallback> deviceStateCallbacks,
             List<CameraCaptureSession.StateCallback> sessionStateCallbacks,
             List<CameraCaptureCallback> singleCameraCaptureCallbacks,
             CaptureConfig repeatingCaptureConfig) {
         mSurfaces = surfaces;
         mDeviceStateCallbacks = Collections.unmodifiableList(deviceStateCallbacks);
         mSessionStateCallbacks = Collections.unmodifiableList(sessionStateCallbacks);
         mSingleCameraCaptureCallbacks =
                 Collections.unmodifiableList(singleCameraCaptureCallbacks);
         mRepeatingCaptureConfig = repeatingCaptureConfig;
     }

     /** Returns an instance of a session configuration with minimal configurations. */
     public static SessionConfig defaultEmptySessionConfig() {
         return new SessionConfig(
                 new ArrayList<DeferrableSurface>(),
                 new ArrayList<CameraDevice.StateCallback>(0),
                 new ArrayList<CameraCaptureSession.StateCallback>(0),
                 new ArrayList<CameraCaptureCallback>(0),
                 new CaptureConfig.Builder().build());
     }

     public List<DeferrableSurface> getSurfaces() {
         return Collections.unmodifiableList(mSurfaces);
     }

     public Map<Key<?>, CaptureRequestParameter<?>> getCameraCharacteristics() {
         return mRepeatingCaptureConfig.getCameraCharacteristics();
     }

     public Config getImplementationOptions() {
         return mRepeatingCaptureConfig.getImplementationOptions();
     }

     public int getTemplateType() {
         return mRepeatingCaptureConfig.getTemplateType();
     }

     /** Obtains all registered {@link CameraDevice.StateCallback} callbacks. */
     public List<CameraDevice.StateCallback> getDeviceStateCallbacks() {
         return mDeviceStateCallbacks;
     }

     /** Obtains all registered {@link CameraCaptureSession.StateCallback} callbacks. */
     public List<CameraCaptureSession.StateCallback> getSessionStateCallbacks() {
         return mSessionStateCallbacks;
     }

     /** Obtains all registered {@link CameraCaptureCallback} callbacks for repeating requests. */
     public List<CameraCaptureCallback> getRepeatingCameraCaptureCallbacks() {
         return mRepeatingCaptureConfig.getCameraCaptureCallbacks();
     }

     /** Obtains all registered {@link CameraCaptureCallback} callbacks for single requests. */
     public List<CameraCaptureCallback> getSingleCameraCaptureCallbacks() {
         return mSingleCameraCaptureCallbacks;
     }

     public CaptureConfig getRepeatingCaptureConfig() {
         return mRepeatingCaptureConfig;
     }

     /**
      * Interface for unpacking a configuration into a SessionConfig.Builder
      *
      * <p>TODO(b/120949879): This will likely be removed once SessionConfig is refactored to
      * remove camera2 dependencies.
      *
      * @hide
      */
     @RestrictTo(Scope.LIBRARY_GROUP)
     public interface OptionUnpacker {

         /**
          * Apply the options from the config onto the builder
          * @param config the set of options to apply
          * @param builder the builder on which to apply the options
          */
         void unpack(UseCaseConfig<?> config, SessionConfig.Builder builder);
     }

     /**
      * Base builder for easy modification/rebuilding of a {@link SessionConfig}.
      *
      * @hide
      */
     @RestrictTo(Scope.LIBRARY_GROUP)
     static class BaseBuilder {
         protected final Set<DeferrableSurface> mSurfaces = new HashSet<>();
         protected final CaptureConfig.Builder mCaptureConfigBuilder = new CaptureConfig.Builder();
         protected List<CameraDevice.StateCallback> mDeviceStateCallbacks = new ArrayList<>();
         protected List<CameraCaptureSession.StateCallback> mSessionStateCallbacks =
                 new ArrayList<>();
         protected final List<CameraCaptureCallback> mInteropCameraCaptureCallbacks =
                 new ArrayList<>();
     }

     /**
      * Builder for easy modification/rebuilding of a {@link SessionConfig}.
      *
      * @hide
      */
     @RestrictTo(Scope.LIBRARY_GROUP)
     public static class Builder extends BaseBuilder {
         /**
          * Creates a {@link Builder} from a {@link UseCaseConfig}.
          *
          * <p>Populates the builder with all the properties defined in the base configuration.
          */
         public static Builder createFrom(UseCaseConfig<?> config) {
             OptionUnpacker unpacker = config.getOptionUnpacker(null);
             if (unpacker == null) {
                 throw new IllegalStateException(
                         "Implementation is missing option unpacker for "
                                 + config.getTargetName(config.toString()));
             }

             Builder builder = new Builder();

             // Unpack the configuration into this builder
             unpacker.unpack(config, builder);
             return builder;
         }

         /**
          * Set the template characteristics of the SessionConfig.
          *
          * @param templateType Template constant that must match those defined by {@link
          *                     CameraDevice}
          *                     <p>TODO(b/120949879): This is camera2 implementation detail that
          *                     should be moved
          */
         public void setTemplateType(int templateType) {
             mCaptureConfigBuilder.setTemplateType(templateType);
         }

         /**
          * Adds a {@link CameraDevice.StateCallback} callback.
          * @throws IllegalArgumentException if the callback already exists in the configuration.
          */
         // TODO(b/120949879): This is camera2 implementation detail that should be moved
         public void addDeviceStateCallback(CameraDevice.StateCallback deviceStateCallback) {
             if (mDeviceStateCallbacks.contains(deviceStateCallback)) {
                 throw new IllegalArgumentException("Duplicate device state callback.");
             }
             mDeviceStateCallbacks.add(deviceStateCallback);
         }

         /**
          * Adds all {@link CameraDevice.StateCallback} callbacks.
          * * @throws IllegalArgumentException if any callback already exists in the configuration.
          */
         public void addAllDeviceStateCallbacks(
                 Collection<CameraDevice.StateCallback> deviceStateCallbacks) {
             for (CameraDevice.StateCallback callback : deviceStateCallbacks) {
                 addDeviceStateCallback(callback);
             }
         }

         /**
          * Adds a {@link CameraCaptureSession.StateCallback} callback.
          * @throws IllegalArgumentException if the callback already exists in the configuration.
          */
         // TODO(b/120949879): This is camera2 implementation detail that should be moved
         public void addSessionStateCallback(
                 CameraCaptureSession.StateCallback sessionStateCallback) {
             if (mSessionStateCallbacks.contains(sessionStateCallback)) {
                 throw new IllegalArgumentException("Duplicate session state callback.");
             }
             mSessionStateCallbacks.add(sessionStateCallback);
         }

         /**
          * Adds all {@link CameraCaptureSession.StateCallback} callbacks.
          * @throws IllegalArgumentException if any callback already exists in the configuration.
          */
         public void addAllSessionStateCallbacks(
                 List<CameraCaptureSession.StateCallback> sessionStateCallbacks) {
             for (CameraCaptureSession.StateCallback callback : sessionStateCallbacks) {
                 addSessionStateCallback(callback);
             }
         }

         /**
          * Adds a {@link CameraCaptureCallback} callback for repeating requests.
          * <p>This callback does not call for single requests.
          * @throws IllegalArgumentException if the callback already exists in the configuration.
          */
         public void addRepeatingCameraCaptureCallback(CameraCaptureCallback cameraCaptureCallback) {
             mCaptureConfigBuilder.addCameraCaptureCallback(cameraCaptureCallback);
         }

         /**
          * Adds all {@link CameraCaptureCallback} callbacks.
          * <p>These callbacks do not call for single requests.
          * @throws IllegalArgumentException if any callback already exists in the configuration.
          */
         public void addAllRepeatingCameraCaptureCallbacks(
                 Collection<CameraCaptureCallback> cameraCaptureCallbacks) {
             mCaptureConfigBuilder.addAllCameraCaptureCallbacks(cameraCaptureCallbacks);
         }

         /**
          * Adds a {@link CameraCaptureCallback} callback for single and repeating requests.
          * <p>Listeners added here are available in both the
          * {@link #getRepeatingCameraCaptureCallbacks()} and
          * {@link #getSingleCameraCaptureCallbacks()} methods.
          * @throws IllegalArgumentException if the callback already exists in the configuration.
          */
         public void addCameraCaptureCallback(CameraCaptureCallback cameraCaptureCallback) {
             mCaptureConfigBuilder.addCameraCaptureCallback(cameraCaptureCallback);
             mInteropCameraCaptureCallbacks.add(cameraCaptureCallback);
         }

         /**
          * Adds all {@link CameraCaptureCallback} callbacks for single and repeating requests.
          * <p>Listeners added here are available in both the
          * {@link #getRepeatingCameraCaptureCallbacks()} and
          * {@link #getSingleCameraCaptureCallbacks()} methods.
          * @throws IllegalArgumentException if any callback already exists in the configuration.
          */
         public void addAllCameraCaptureCallbacks(
                 Collection<CameraCaptureCallback> cameraCaptureCallbacks) {
             mCaptureConfigBuilder.addAllCameraCaptureCallbacks(cameraCaptureCallbacks);
             mInteropCameraCaptureCallbacks.addAll(cameraCaptureCallbacks);
         }

         /** Obtain all {@link CameraCaptureCallback} callbacks for single requests. */
         public List<CameraCaptureCallback> getSingleCameraCaptureCallbacks() {
             return Collections.unmodifiableList(mInteropCameraCaptureCallbacks);
         }


         /** Add a surface to the set that the session repeatedly writes data to. */
         public void addSurface(DeferrableSurface surface) {
             mSurfaces.add(surface);
             mCaptureConfigBuilder.addSurface(surface);
         }

         /** Add a surface for the session which only used for single captures. */
         public void addNonRepeatingSurface(DeferrableSurface surface) {
             mSurfaces.add(surface);
         }

         /** Remove a surface from the set which the session repeatedly writes to. */
         public void removeSurface(DeferrableSurface surface) {
             mSurfaces.remove(surface);
             mCaptureConfigBuilder.removeSurface(surface);
         }

         /** Clears all surfaces from the set which the session writes to. */
         public void clearSurfaces() {
             mSurfaces.clear();
             mCaptureConfigBuilder.clearSurfaces();
         }

         /** Add the {@link CaptureRequest.Key} value pair that will be applied. */
         // TODO(b/120949879): This is camera2 implementation detail that should be moved
         public <T> void addCharacteristic(Key<T> key, T value) {
             mCaptureConfigBuilder.addCharacteristic(key, value);
         }

         /** Add the {@link CaptureRequestParameter} that will be applied. */
         // TODO(b/120949879): This is camera2 implementation detail that should be moved
         public void addCharacteristics(Map<Key<?>, CaptureRequestParameter<?>> characteristics) {
             mCaptureConfigBuilder.addCharacteristics(characteristics);
         }

         /** Set the {@link Config} for options that are implementation specific. */
         public void setImplementationOptions(Config config) {
             mCaptureConfigBuilder.setImplementationOptions(config);
         }

         /**
          * Builds an instance of a SessionConfig that has all the combined parameters of the
          * SessionConfig that have been added to the Builder.
          */
         public SessionConfig build() {
             return new SessionConfig(
                     new ArrayList<>(mSurfaces),
                     mDeviceStateCallbacks,
                     mSessionStateCallbacks,
                     mInteropCameraCaptureCallbacks,
                     mCaptureConfigBuilder.build());
         }
     }

     /**
      * Builder for combining multiple instances of {@link SessionConfig}. This will check if all
      * the parameters for the {@link SessionConfig} are compatible with each other
      *
      * @hide
      */
     @RestrictTo(Scope.LIBRARY_GROUP)
     public static final class ValidatingBuilder extends BaseBuilder {
         private static final String TAG = "ValidatingBuilder";
         private final List<CameraDevice.StateCallback> mDeviceStateCallbacks = new ArrayList<>();
         private final List<CameraCaptureSession.StateCallback> mSessionStateCallbacks =
                 new ArrayList<>();
         private final List<CameraCaptureCallback> mSingleCameraCaptureCallbacks =
                 new ArrayList<>();
         private boolean mValid = true;
         private boolean mTemplateSet = false;

         /**
          * Add the SessionConfig to the set of SessionConfig that have been aggregated by the
          * ValidatingBuilder
          */
         public void add(SessionConfig sessionConfig) {
             CaptureConfig captureConfig = sessionConfig.getRepeatingCaptureConfig();

             // Check template
             if (!mTemplateSet) {
                 mCaptureConfigBuilder.setTemplateType(captureConfig.getTemplateType());
                 mTemplateSet = true;
             } else if (mCaptureConfigBuilder.getTemplateType() != captureConfig.getTemplateType()) {
                 String errorMessage =
                         "Invalid configuration due to template type: "
                                 + mCaptureConfigBuilder.getTemplateType()
                                 + " != "
                                 + captureConfig.getTemplateType();
                 Log.d(TAG, errorMessage);
                 mValid = false;
             }

             // Check device state callbacks
             mDeviceStateCallbacks.addAll(sessionConfig.getDeviceStateCallbacks());

             // Check session state callbacks
             mSessionStateCallbacks.addAll(sessionConfig.getSessionStateCallbacks());

             // Check camera capture callbacks for repeating requests.
             mCaptureConfigBuilder.addAllCameraCaptureCallbacks(
                     sessionConfig.getRepeatingCameraCaptureCallbacks());

             // Check camera capture callbacks for single requests.
             mSingleCameraCaptureCallbacks.addAll(sessionConfig.getSingleCameraCaptureCallbacks());

             // Check surfaces
             mSurfaces.addAll(sessionConfig.getSurfaces());

             // Check capture request surfaces
             mCaptureConfigBuilder.getSurfaces().addAll(captureConfig.getSurfaces());

             mCaptureConfigBuilder.addImplementationOptions(
                     captureConfig.getImplementationOptions());

             if (!mSurfaces.containsAll(mCaptureConfigBuilder.getSurfaces())) {
                 String errorMessage =
                         "Invalid configuration due to capture request surfaces are not a subset "
                                 + "of surfaces";
                 Log.d(TAG, errorMessage);
                 mValid = false;
             }

             // Check characteristics
             for (Map.Entry<Key<?>, CaptureRequestParameter<?>> entry :
                     captureConfig.getCameraCharacteristics().entrySet()) {
                 Key<?> addedKey = entry.getKey();
                 if (mCaptureConfigBuilder.getCharacteristic().containsKey(entry.getKey())) {
                     // value is equal
                     CaptureRequestParameter<?> addedValue = entry.getValue();
                     CaptureRequestParameter<?> oldValue =
                             mCaptureConfigBuilder.getCharacteristic().get(addedKey);
                     if (!addedValue.getValue().equals(oldValue.getValue())) {
                         String errorMessage =
                                 "Invalid configuration due to conflicting CaptureRequest.Keys: "
                                         + addedValue
                                         + " != "
                                         + oldValue;
                         Log.d(TAG, errorMessage);
                         mValid = false;
                     }
                 } else {
                     mCaptureConfigBuilder.getCharacteristic().put(entry.getKey(), entry.getValue());
                 }
             }
         }

         /** Check if the set of SessionConfig that have been combined are valid */
         public boolean isValid() {
             return mTemplateSet && mValid;
         }

         /**
          * Builds an instance of a SessionConfig that has all the combined parameters of the
          * SessionConfig that have been added to the ValidatingBuilder.
          */
         public SessionConfig build() {
             if (!mValid) {
                 throw new IllegalArgumentException("Unsupported session configuration combination");
             }
             return new SessionConfig(
                     new ArrayList<>(mSurfaces),
                     mDeviceStateCallbacks,
                     mSessionStateCallbacks,
                     mSingleCameraCaptureCallbacks,
                     mCaptureConfigBuilder.build());
         }
     }
 }
	/*
	* 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 androidx.camera.core;

	import android.hardware.camera2.CameraCaptureSession;
	import android.hardware.camera2.CameraDevice;
	import android.hardware.camera2.CameraDevice.StateCallback;
	import android.hardware.camera2.CaptureRequest;
	import android.hardware.camera2.CaptureRequest.Key;
	import android.util.Log;
	import android.view.Surface;

	import androidx.annotation.RestrictTo;
	import androidx.annotation.RestrictTo.Scope;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* Configurations needed for a capture session.
	*
	* <p>The SessionConfig contains all the {@link android.hardware.camera2} parameters that are
	* required to initialize a {@link android.hardware.camera2.CameraCaptureSession} and issue a {@link
	* CaptureRequest}.
	*
	* @hide
	*/
	@RestrictTo(Scope.LIBRARY_GROUP)
	public final class SessionConfig {

	/** The set of {@link Surface} that data from the camera will be put into. */
	private final List<DeferrableSurface> mSurfaces;
	/** The state callback for a {@link CameraDevice}. */
	private final List<CameraDevice.StateCallback> mDeviceStateCallbacks;
	/** The state callback for a {@link CameraCaptureSession}. */
	private final List<CameraCaptureSession.StateCallback> mSessionStateCallbacks;
	/** The callbacks used in single requests. */
	private final List<CameraCaptureCallback> mSingleCameraCaptureCallbacks;
	/** The configuration for building the {@link CaptureRequest} used for repeating requests. */
	private final CaptureConfig mRepeatingCaptureConfig;

	/**
	* Private constructor for a SessionConfig.
	*
	* <p>In practice, the {@link SessionConfig.BaseBuilder} will be used to construct a
	* SessionConfig.
	*
	* @param surfaces The set of {@link Surface} where data will be put into.
	* @param deviceStateCallbacks The state callbacks for a {@link CameraDevice}.
	* @param sessionStateCallbacks The state callbacks for a {@link CameraCaptureSession}.
	* @param repeatingCaptureConfig The configuration for building the {@link CaptureRequest}.
	*/
	SessionConfig(
	List<DeferrableSurface> surfaces,
	List<StateCallback> deviceStateCallbacks,
	List<CameraCaptureSession.StateCallback> sessionStateCallbacks,
	List<CameraCaptureCallback> singleCameraCaptureCallbacks,
	CaptureConfig repeatingCaptureConfig) {
	mSurfaces = surfaces;
	mDeviceStateCallbacks = Collections.unmodifiableList(deviceStateCallbacks);
	mSessionStateCallbacks = Collections.unmodifiableList(sessionStateCallbacks);
	mSingleCameraCaptureCallbacks =
	Collections.unmodifiableList(singleCameraCaptureCallbacks);
	mRepeatingCaptureConfig = repeatingCaptureConfig;
	}

	/** Returns an instance of a session configuration with minimal configurations. */
	public static SessionConfig defaultEmptySessionConfig() {
	return new SessionConfig(
	new ArrayList<DeferrableSurface>(),
	new ArrayList<CameraDevice.StateCallback>(0),
	new ArrayList<CameraCaptureSession.StateCallback>(0),
	new ArrayList<CameraCaptureCallback>(0),
	new CaptureConfig.Builder().build());
	}

	public List<DeferrableSurface> getSurfaces() {
	return Collections.unmodifiableList(mSurfaces);
	}

	public Map<Key<?>, CaptureRequestParameter<?>> getCameraCharacteristics() {
	return mRepeatingCaptureConfig.getCameraCharacteristics();
	}

	public Config getImplementationOptions() {
	return mRepeatingCaptureConfig.getImplementationOptions();
	}

	public int getTemplateType() {
	return mRepeatingCaptureConfig.getTemplateType();
	}

	/** Obtains all registered {@link CameraDevice.StateCallback} callbacks. */
	public List<CameraDevice.StateCallback> getDeviceStateCallbacks() {
	return mDeviceStateCallbacks;
	}

	/** Obtains all registered {@link CameraCaptureSession.StateCallback} callbacks. */
	public List<CameraCaptureSession.StateCallback> getSessionStateCallbacks() {
	return mSessionStateCallbacks;
	}

	/** Obtains all registered {@link CameraCaptureCallback} callbacks for repeating requests. */
	public List<CameraCaptureCallback> getRepeatingCameraCaptureCallbacks() {
	return mRepeatingCaptureConfig.getCameraCaptureCallbacks();
	}

	/** Obtains all registered {@link CameraCaptureCallback} callbacks for single requests. */
	public List<CameraCaptureCallback> getSingleCameraCaptureCallbacks() {
	return mSingleCameraCaptureCallbacks;
	}

	public CaptureConfig getRepeatingCaptureConfig() {
	return mRepeatingCaptureConfig;
	}

	/**
	* Interface for unpacking a configuration into a SessionConfig.Builder
	*
	* <p>TODO(b/120949879): This will likely be removed once SessionConfig is refactored to
	* remove camera2 dependencies.
	*
	* @hide
	*/
	@RestrictTo(Scope.LIBRARY_GROUP)
	public interface OptionUnpacker {

	/**
	* Apply the options from the config onto the builder
	* @param config the set of options to apply
	* @param builder the builder on which to apply the options
	*/
	void unpack(UseCaseConfig<?> config, SessionConfig.Builder builder);
	}

	/**
	* Base builder for easy modification/rebuilding of a {@link SessionConfig}.
	*
	* @hide
	*/
	@RestrictTo(Scope.LIBRARY_GROUP)
	static class BaseBuilder {
	protected final Set<DeferrableSurface> mSurfaces = new HashSet<>();
	protected final CaptureConfig.Builder mCaptureConfigBuilder = new CaptureConfig.Builder();
	protected List<CameraDevice.StateCallback> mDeviceStateCallbacks = new ArrayList<>();
	protected List<CameraCaptureSession.StateCallback> mSessionStateCallbacks =
	new ArrayList<>();
	protected final List<CameraCaptureCallback> mInteropCameraCaptureCallbacks =
	new ArrayList<>();
	}

	/**
	* Builder for easy modification/rebuilding of a {@link SessionConfig}.
	*
	* @hide
	*/
	@RestrictTo(Scope.LIBRARY_GROUP)
	public static class Builder extends BaseBuilder {
	/**
	* Creates a {@link Builder} from a {@link UseCaseConfig}.
	*
	* <p>Populates the builder with all the properties defined in the base configuration.
	*/
	public static Builder createFrom(UseCaseConfig<?> config) {
	OptionUnpacker unpacker = config.getOptionUnpacker(null);
	if (unpacker == null) {
	throw new IllegalStateException(
	"Implementation is missing option unpacker for "
	+ config.getTargetName(config.toString()));
	}

	Builder builder = new Builder();

	// Unpack the configuration into this builder
	unpacker.unpack(config, builder);
	return builder;
	}

	/**
	* Set the template characteristics of the SessionConfig.
	*
	* @param templateType Template constant that must match those defined by {@link
	* CameraDevice}
	* <p>TODO(b/120949879): This is camera2 implementation detail that
	* should be moved
	*/
	public void setTemplateType(int templateType) {
	mCaptureConfigBuilder.setTemplateType(templateType);
	}

	/**
	* Adds a {@link CameraDevice.StateCallback} callback.
	* @throws IllegalArgumentException if the callback already exists in the configuration.
	*/
	// TODO(b/120949879): This is camera2 implementation detail that should be moved
	public void addDeviceStateCallback(CameraDevice.StateCallback deviceStateCallback) {
	if (mDeviceStateCallbacks.contains(deviceStateCallback)) {
	throw new IllegalArgumentException("Duplicate device state callback.");
	}
	mDeviceStateCallbacks.add(deviceStateCallback);
	}

	/**
	* Adds all {@link CameraDevice.StateCallback} callbacks.
	* * @throws IllegalArgumentException if any callback already exists in the configuration.
	*/
	public void addAllDeviceStateCallbacks(
	Collection<CameraDevice.StateCallback> deviceStateCallbacks) {
	for (CameraDevice.StateCallback callback : deviceStateCallbacks) {
	addDeviceStateCallback(callback);
	}
	}

	/**
	* Adds a {@link CameraCaptureSession.StateCallback} callback.
	* @throws IllegalArgumentException if the callback already exists in the configuration.
	*/
	// TODO(b/120949879): This is camera2 implementation detail that should be moved
	public void addSessionStateCallback(
	CameraCaptureSession.StateCallback sessionStateCallback) {
	if (mSessionStateCallbacks.contains(sessionStateCallback)) {
	throw new IllegalArgumentException("Duplicate session state callback.");
	}
	mSessionStateCallbacks.add(sessionStateCallback);
	}

	/**
	* Adds all {@link CameraCaptureSession.StateCallback} callbacks.
	* @throws IllegalArgumentException if any callback already exists in the configuration.
	*/
	public void addAllSessionStateCallbacks(
	List<CameraCaptureSession.StateCallback> sessionStateCallbacks) {
	for (CameraCaptureSession.StateCallback callback : sessionStateCallbacks) {
	addSessionStateCallback(callback);
	}
	}

	/**
	* Adds a {@link CameraCaptureCallback} callback for repeating requests.
	* <p>This callback does not call for single requests.
	* @throws IllegalArgumentException if the callback already exists in the configuration.
	*/
	public void addRepeatingCameraCaptureCallback(CameraCaptureCallback cameraCaptureCallback) {
	mCaptureConfigBuilder.addCameraCaptureCallback(cameraCaptureCallback);
	}

	/**
	* Adds all {@link CameraCaptureCallback} callbacks.
	* <p>These callbacks do not call for single requests.
	* @throws IllegalArgumentException if any callback already exists in the configuration.
	*/
	public void addAllRepeatingCameraCaptureCallbacks(
	Collection<CameraCaptureCallback> cameraCaptureCallbacks) {
	mCaptureConfigBuilder.addAllCameraCaptureCallbacks(cameraCaptureCallbacks);
	}

	/**
	* Adds a {@link CameraCaptureCallback} callback for single and repeating requests.
	* <p>Listeners added here are available in both the
	* {@link #getRepeatingCameraCaptureCallbacks()} and
	* {@link #getSingleCameraCaptureCallbacks()} methods.
	* @throws IllegalArgumentException if the callback already exists in the configuration.
	*/
	public void addCameraCaptureCallback(CameraCaptureCallback cameraCaptureCallback) {
	mCaptureConfigBuilder.addCameraCaptureCallback(cameraCaptureCallback);
	mInteropCameraCaptureCallbacks.add(cameraCaptureCallback);
	}

	/**
	* Adds all {@link CameraCaptureCallback} callbacks for single and repeating requests.
	* <p>Listeners added here are available in both the
	* {@link #getRepeatingCameraCaptureCallbacks()} and
	* {@link #getSingleCameraCaptureCallbacks()} methods.
	* @throws IllegalArgumentException if any callback already exists in the configuration.
	*/
	public void addAllCameraCaptureCallbacks(
	Collection<CameraCaptureCallback> cameraCaptureCallbacks) {
	mCaptureConfigBuilder.addAllCameraCaptureCallbacks(cameraCaptureCallbacks);
	mInteropCameraCaptureCallbacks.addAll(cameraCaptureCallbacks);
	}

	/** Obtain all {@link CameraCaptureCallback} callbacks for single requests. */
	public List<CameraCaptureCallback> getSingleCameraCaptureCallbacks() {
	return Collections.unmodifiableList(mInteropCameraCaptureCallbacks);
	}


	/** Add a surface to the set that the session repeatedly writes data to. */
	public void addSurface(DeferrableSurface surface) {
	mSurfaces.add(surface);
	mCaptureConfigBuilder.addSurface(surface);
	}

	/** Add a surface for the session which only used for single captures. */
	public void addNonRepeatingSurface(DeferrableSurface surface) {
	mSurfaces.add(surface);
	}

	/** Remove a surface from the set which the session repeatedly writes to. */
	public void removeSurface(DeferrableSurface surface) {
	mSurfaces.remove(surface);
	mCaptureConfigBuilder.removeSurface(surface);
	}

	/** Clears all surfaces from the set which the session writes to. */
	public void clearSurfaces() {
	mSurfaces.clear();
	mCaptureConfigBuilder.clearSurfaces();
	}

	/** Add the {@link CaptureRequest.Key} value pair that will be applied. */
	// TODO(b/120949879): This is camera2 implementation detail that should be moved
	public <T> void addCharacteristic(Key<T> key, T value) {
	mCaptureConfigBuilder.addCharacteristic(key, value);
	}

	/** Add the {@link CaptureRequestParameter} that will be applied. */
	// TODO(b/120949879): This is camera2 implementation detail that should be moved
	public void addCharacteristics(Map<Key<?>, CaptureRequestParameter<?>> characteristics) {
	mCaptureConfigBuilder.addCharacteristics(characteristics);
	}

	/** Set the {@link Config} for options that are implementation specific. */
	public void setImplementationOptions(Config config) {
	mCaptureConfigBuilder.setImplementationOptions(config);
	}

	/**
	* Builds an instance of a SessionConfig that has all the combined parameters of the
	* SessionConfig that have been added to the Builder.
	*/
	public SessionConfig build() {
	return new SessionConfig(
	new ArrayList<>(mSurfaces),
	mDeviceStateCallbacks,
	mSessionStateCallbacks,
	mInteropCameraCaptureCallbacks,
	mCaptureConfigBuilder.build());
	}
	}

	/**
	* Builder for combining multiple instances of {@link SessionConfig}. This will check if all
	* the parameters for the {@link SessionConfig} are compatible with each other
	*
	* @hide
	*/
	@RestrictTo(Scope.LIBRARY_GROUP)
	public static final class ValidatingBuilder extends BaseBuilder {
	private static final String TAG = "ValidatingBuilder";
	private final List<CameraDevice.StateCallback> mDeviceStateCallbacks = new ArrayList<>();
	private final List<CameraCaptureSession.StateCallback> mSessionStateCallbacks =
	new ArrayList<>();
	private final List<CameraCaptureCallback> mSingleCameraCaptureCallbacks =
	new ArrayList<>();
	private boolean mValid = true;
	private boolean mTemplateSet = false;

	/**
	* Add the SessionConfig to the set of SessionConfig that have been aggregated by the
	* ValidatingBuilder
	*/
	public void add(SessionConfig sessionConfig) {
	CaptureConfig captureConfig = sessionConfig.getRepeatingCaptureConfig();

	// Check template
	if (!mTemplateSet) {
	mCaptureConfigBuilder.setTemplateType(captureConfig.getTemplateType());
	mTemplateSet = true;
	} else if (mCaptureConfigBuilder.getTemplateType() != captureConfig.getTemplateType()) {
	String errorMessage =
	"Invalid configuration due to template type: "
	+ mCaptureConfigBuilder.getTemplateType()
	+ " != "
	+ captureConfig.getTemplateType();
	Log.d(TAG, errorMessage);
	mValid = false;
	}

	// Check device state callbacks
	mDeviceStateCallbacks.addAll(sessionConfig.getDeviceStateCallbacks());

	// Check session state callbacks
	mSessionStateCallbacks.addAll(sessionConfig.getSessionStateCallbacks());

	// Check camera capture callbacks for repeating requests.
	mCaptureConfigBuilder.addAllCameraCaptureCallbacks(
	sessionConfig.getRepeatingCameraCaptureCallbacks());

	// Check camera capture callbacks for single requests.
	mSingleCameraCaptureCallbacks.addAll(sessionConfig.getSingleCameraCaptureCallbacks());

	// Check surfaces
	mSurfaces.addAll(sessionConfig.getSurfaces());

	// Check capture request surfaces
	mCaptureConfigBuilder.getSurfaces().addAll(captureConfig.getSurfaces());

	mCaptureConfigBuilder.addImplementationOptions(
	captureConfig.getImplementationOptions());

	if (!mSurfaces.containsAll(mCaptureConfigBuilder.getSurfaces())) {
	String errorMessage =
	"Invalid configuration due to capture request surfaces are not a subset "
	+ "of surfaces";
	Log.d(TAG, errorMessage);
	mValid = false;
	}

	// Check characteristics
	for (Map.Entry<Key<?>, CaptureRequestParameter<?>> entry :
	captureConfig.getCameraCharacteristics().entrySet()) {
	Key<?> addedKey = entry.getKey();
	if (mCaptureConfigBuilder.getCharacteristic().containsKey(entry.getKey())) {
	// value is equal
	CaptureRequestParameter<?> addedValue = entry.getValue();
	CaptureRequestParameter<?> oldValue =
	mCaptureConfigBuilder.getCharacteristic().get(addedKey);
	if (!addedValue.getValue().equals(oldValue.getValue())) {
	String errorMessage =
	"Invalid configuration due to conflicting CaptureRequest.Keys: "
	+ addedValue
	+ " != "
	+ oldValue;
	Log.d(TAG, errorMessage);
	mValid = false;
	}
	} else {
	mCaptureConfigBuilder.getCharacteristic().put(entry.getKey(), entry.getValue());
	}
	}
	}

	/** Check if the set of SessionConfig that have been combined are valid */
	public boolean isValid() {
	return mTemplateSet && mValid;
	}

	/**
	* Builds an instance of a SessionConfig that has all the combined parameters of the
	* SessionConfig that have been added to the ValidatingBuilder.
	*/
	public SessionConfig build() {
	if (!mValid) {
	throw new IllegalArgumentException("Unsupported session configuration combination");
	}
	return new SessionConfig(
	new ArrayList<>(mSurfaces),
	mDeviceStateCallbacks,
	mSessionStateCallbacks,
	mSingleCameraCaptureCallbacks,
	mCaptureConfigBuilder.build());
	}
	}
	}