private void UpdatePreview()
{
if (CameraDevice == null || previewSession == null)
{
return;
}
previewBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
SetAutoFlash(previewBuilder);
previewRequest = previewBuilder.Build();
previewSession.SetRepeatingRequest(previewRequest, cameraCaptureListener, backgroundHandler);
}
private void SessionConfigured(object sender, CameraCaptureSession e)
{
((StateCallback)sender).Configured -= SessionConfigured;
_captureSession = e;
// Auto focus should be continuous for camera preview.
_previewRequestBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
// Flash is automatically enabled when necessary.
Utils.SetAutoFlash(_previewRequestBuilder, _manager, _cameraId);
e.SetRepeatingRequest(_previewRequest = _previewRequestBuilder.Build(), _captureListener,
_backgroundThread.Handler);
}
private void UpdatePreview()
{
if (CameraDevice == null || _previewSession == null)
{
return;
}
// Reset the auto-focus trigger
_previewBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
SetAutoFlash(_previewBuilder);
_previewRequest = _previewBuilder.Build();
_previewSession.SetRepeatingRequest(_previewRequest, _cameraCaptureListener, _backgroundHandler);
}
// Lock the focus as the first step for a still image capture.
private void LockFocus()
{
try
{
mPreviewRequestBuilder.Set(CaptureRequest.ControlAfTrigger, (int)ControlAFTrigger.Start);
// Tell #mCaptureCallback to wait for the lock.
mState = CameraConstants.CameraStates.STATE_WAITING_LOCK;
mCaptureSession.Capture(mPreviewRequestBuilder.Build(), mCaptureCallback,
mBackgroundHandler);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
// Run the precapture sequence for capturing a still image. This method should be called when
// we get a response in {@link #mCaptureCallback} from {@link #lockFocus()}.
public void RunPrecaptureSequence()
{
try
{
// This is how to tell the camera to trigger.
mPreviewRequestBuilder.Set(CaptureRequest.ControlAePrecaptureTrigger, (int)ControlAEPrecaptureTrigger.Start);
// Tell #mCaptureCallback to wait for the precapture sequence to be set.
mState = STATE_WAITING_PRECAPTURE;
mCaptureSession.Capture(mPreviewRequestBuilder.Build(), mCaptureCallback, mBackgroundHandler);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
public void StartPreview()
{
if (liveTextureView.SurfaceTexture == null)
{
return;
}
var texture = liveTextureView.SurfaceTexture;
texture.SetDefaultBufferSize(previewSize.Width, previewSize.Height);
var surface = new Surface(texture);
previewBuilder = CameraDevice.CreateCaptureRequest(CameraTemplate.Preview);
previewBuilder.AddTarget(surface);
CameraDevice.CreateCaptureSession(new List <Surface> {
surface
}, new CameraCaptureStateListener
{
OnConfigureFailedAction = (CameraCaptureSession session) =>
{
},
OnConfiguredAction = (CameraCaptureSession session) =>
{
previewSession = session;
previewBuilder.Set(CaptureRequest.ControlMode, new Java.Lang.Integer((int)ControlMode.Auto));
var thread = new HandlerThread("CameraPicture");
thread.Start();
var backgroundHandler = new Handler(thread.Looper);
previewSession.SetRepeatingRequest(previewBuilder.Build(), null, backgroundHandler);
}
}, null);
}
private void UpdatePreview()
{
if (cameraDevice != null && cameraCaptureSession != null)
{
try
{
captureRequestBuilder.Set(CaptureRequest.ControlMode, new Java.Lang.Integer((int)ControlMode.Auto));
HandlerThread thread = new HandlerThread("CameraPicture");
thread.Start();
Handler backgroundHandler = new Handler(thread.Looper);
cameraCaptureSession.SetRepeatingRequest(captureRequestBuilder.Build(), null, backgroundHandler);
}
catch (CameraAccessException error)
{
ShowToastMessage("Failed to access camera");
DebugMessage("ErrorMessage: \n" + error.Message + "\n" + "Stacktrace: \n " + error.StackTrace);
}
catch (IllegalStateException error)
{
ShowToastMessage("Failed to access camera");
DebugMessage("ErrorMessage: \n" + error.Message + "\n" + "Stacktrace: \n " + error.StackTrace);
}
}
}
public void CapturePreviewShot()
{
try
{
//final Activity activity = getActivity();
if (null == mCameraDevice)
{
return;
}
// This is the CaptureRequest.Builder that we use to take a picture.
//final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
CaptureRequest.Builder captureBuilder = mCameraDevice.CreateCaptureRequest(CameraTemplate.Preview);
captureBuilder.AddTarget(mImageReader.Surface);
// Use the same AE and AF modes as the preview.
captureBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
//SetAutoFlash(captureBuilder);
// Orientation
int rotation = (int)WindowManager.DefaultDisplay.Rotation;
captureBuilder.Set(CaptureRequest.JpegOrientation, GetOrientation(rotation));
mCaptureSession.StopRepeating();
//mCaptureSession.Capture(captureBuilder.Build(), new CameraCapturePreviewSessionCallback(this), null);
mCaptureSession.Capture(captureBuilder.Build(), new CameraCapturePreviewSessionCallback(this), mBackgroundHandler);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
private void StartRecord()
{
SetupMediaRecorder();
Surface recordSurface = mediaRecorder.Surface;
CaptureRequest.Builder builder = cameraDevice.CreateCaptureRequest(CameraTemplate.Record);
builder.AddTarget(recordSurface);
SetUpCaptureRequestBuilder(builder);
List <Surface> surfaces = new List <Surface>();
surfaces.Add(recordSurface);
cameraDevice.CreateCaptureSession(surfaces, new CameraCapturerRecordStateListener()
{
OnConfiguredAction = (CameraCaptureSession session) =>
{
try
{
session.SetRepeatingRequest(builder.Build(), null, backgroundHandler);
}
catch (CameraAccessException ex)
{
Log.WriteLine(LogPriority.Info, "Capture Session error: ", ex.ToString());
}
}
}, backgroundHandler);
mediaRecorder.Start();
videoButton.Text = "Stop record";
recordingVideo = true;
}
public void CaptureStillPicture()
{
try
{
if (Device == null)
{
return;
}
// This is the CaptureRequest.Builder that we use to take a picture.
if (stillCaptureBuilder == null)
{
stillCaptureBuilder = Device.CreateCaptureRequest(CameraTemplate.StillCapture);
}
stillCaptureBuilder.AddTarget(mImageReader.Surface);
// Use the same AE and AF modes as the preview.
stillCaptureBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
SetAutoFlash(stillCaptureBuilder);
// Orientation
var windowManager = Context.GetSystemService(Context.WindowService).JavaCast <IWindowManager>();
int rotation = (int)windowManager.DefaultDisplay.Rotation;
stillCaptureBuilder.Set(CaptureRequest.JpegOrientation, GetOrientation(rotation));
CaptureSession.StopRepeating();
CaptureSession.Capture(stillCaptureBuilder.Build(), new CameraCaptureStillPictureSessionCallback(this), null);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
public void TakePhoto()
{
if (_context == null || CameraDevice == null)
{
return;
}
if (_captureBuilder == null)
{
_captureBuilder = CameraDevice.CreateCaptureRequest(CameraTemplate.StillCapture);
}
_captureBuilder.AddTarget(_imageReader.Surface);
_captureBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
SetAutoFlash(_captureBuilder);
_previewSession.StopRepeating();
_previewSession.Capture(_captureBuilder.Build(),
new CameraCaptureStillPictureSessionCallback
{
OnCaptureCompletedAction = session =>
{
UnlockFocus();
}
}, null);
}
// Capture a still picture. This method should be called when we get a response in
// {@link #mCaptureCallback} from both {@link #lockFocus()}.
public void CaptureStillPicture()
{
try
{
var activity = Activity;
if (null == activity || null == CameraDevice)
{
return;
}
// This is the CaptureRequest.Builder that we use to take a picture.
//if (_stillCaptureBuilder == null)
//{
_stillCaptureBuilder = CameraDevice.CreateCaptureRequest(CameraTemplate.StillCapture);
//}
_stillCaptureBuilder.AddTarget(_imageReader.Surface);
// Use the same AE and AF modes as the preview.
_stillCaptureBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
SetAutoFlash(_stillCaptureBuilder);
CaptureSession.StopRepeating();
CaptureSession.Capture(_stillCaptureBuilder.Build(), new CameraCaptureStillPictureSessionCallback(this), null);
}
catch (CameraAccessException ex)
{
#if DEBUG
ex.PrintStackTrace();
#endif
}
}
/// <summary>
/// Capture a still picture. This method should be called when we get a response in
/// CaptureCallback from both LockFocus()
/// </summary>
public void CaptureStillPicture()
{
try
{
var activity = Activity;
if (null == activity || null == CameraDevice)
{
return;
}
// This is the CaptureRequest.Builder that we use to take a picture.
CaptureRequest.Builder captureBuilder =
CameraDevice.CreateCaptureRequest(CameraTemplate.StillCapture);
captureBuilder.AddTarget(mImageReader.Surface);
// Use the same AE and AF modes as the preview.
captureBuilder.Set(CaptureRequest.ControlAfMode,
(int)ControlAFMode.ContinuousPicture);
SetAutoFlash(captureBuilder);
// Orientation
int rotation = (int)activity.WindowManager.DefaultDisplay.Rotation;
captureBuilder.Set(CaptureRequest.JpegOrientation, GetOrientation(rotation));
var captureCallback = new CameraCaptureSessionCaptureCallback2(this);
CaptureSession.StopRepeating();
CaptureSession.Capture(captureBuilder.Build(), captureCallback, null);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
// Capture a still picture. This method should be called when we get a response in
// {@link #mCaptureCallback} from both {@link #lockFocus()}.
public void CaptureStillPicture()
{
try
{
var activity = Activity;
if (null == activity || null == mCameraDevice)
{
return;
}
// This is the CaptureRequest.Builder that we use to take a picture.
if (stillCaptureBuilder == null)
{
stillCaptureBuilder = mCameraDevice.CreateCaptureRequest(CameraTemplate.StillCapture);
}
stillCaptureBuilder.AddTarget(mImageReader.Surface);
// Use the same AE and AF modes as the preview.
stillCaptureBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
SetAutoFlash(stillCaptureBuilder);
stillCaptureBuilder.Set(CaptureRequest.JpegOrientation, 90);//TODO
mCaptureSession.StopRepeating();
mCaptureSession.Capture(stillCaptureBuilder.Build(), new CaptureStillPictureSessionCallback(this), null);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
/// <summary>
/// Updates the camera preview, StartPreview() needs to be called in advance
/// </summary>
private void UpdatePreview()
{
if (_cameraDevice != null && _previewSession != null)
{
try
{
// The camera preview can be run in a background thread. This is a Handler for the camere preview
_previewBuilder.Set(CaptureRequest.ControlMode, new Java.Lang.Integer((int)ControlMode.Auto));
// We create a Handler since we want to handle the resulting JPEG in a background thread
HandlerThread thread = new HandlerThread("CameraPicture");
thread.Start();
Handler backgroundHandler = new Handler(thread.Looper);
// Finally, we start displaying the camera preview
//if (_previewSession.IsReprocessable)
_previewSession.SetRepeatingRequest(_previewBuilder.Build(), null, backgroundHandler);
}
catch (CameraAccessException error)
{
Log.WriteLine(LogPriority.Error, error.Source, error.Message);
}
catch (IllegalStateException error)
{
Log.WriteLine(LogPriority.Error, error.Source, error.Message);
}
}
}
// Capture a still picture. This method should be called when we get a response in
// {@link #mCaptureCallback} from both {@link #lockFocus()}.
public void CaptureStillPicture()
{
try
{
if (null == mCameraDevice)
{
return;
}
// This is the CaptureRequest.Builder that we use to take a picture.
stillCaptureBuilder = mCameraDevice.CreateCaptureRequest(CameraTemplate.StillCapture);
stillCaptureBuilder.AddTarget(mImageReader.Surface);
// Use the same AE and AF modes as the preview.
stillCaptureBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
SetFlash(stillCaptureBuilder);
// Orientation
int rotation = (int)WindowManager.DefaultDisplay.Rotation;
var orient = GetOrientation(rotation);
stillCaptureBuilder.Set(CaptureRequest.JpegOrientation, orient);
mCaptureSession.StopRepeating();
mCaptureSession.Capture(stillCaptureBuilder.Build(), new CameraCaptureStillPictureSessionCallback(this), null);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
private void CaptureStillPicture()
{
try
{
// This is the CaptureRequest.Builder that we use to take a picture.
if (_stillCaptureBuilder == null)
{
_stillCaptureBuilder = _cameraDevice.CreateCaptureRequest(CameraTemplate.StillCapture);
}
_stillCaptureBuilder.AddTarget(_imageReader.Surface);
// Use the same AE and AF modes as the preview.
_stillCaptureBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.ContinuousPicture);
Utils.SetAutoFlash(_stillCaptureBuilder, _manager, _cameraId);
var rotation = Utils.CalculateRotation();
_stillCaptureBuilder.Set(CaptureRequest.JpegOrientation, Utils.GetOrientation(rotation));
_captureSession.StopRepeating();
var stillCaptureListener = new CameraCaptureListener();
stillCaptureListener.CaptureResultAvailable += StillCaptureHandler;
_captureSession.Capture(_stillCaptureBuilder.Build(),
stillCaptureListener, null);
}
catch (CameraAccessException e)
{
Debug.WriteLine(e);
throw;
}
}
void OnConfigured(object sender, CameraCaptureSessionEventArgs e)
{
// The camera is already closed
if (null == cameraDevice)
{
return;
}
// When the session is ready, we start displaying the preview.
captureSession = e.Session;
try
{
// Auto focus should be continuous for camera preview.
previewRequestBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.Edof);
// Flash is automatically enabled when necessary. For now, we skip this.
// SetAutoFlash(previewRequestBuilder);
// Finally, we start displaying the camera preview.
previewRequest = previewRequestBuilder.Build();
if (captureListener == null)
{
captureListener = new CameraCaptureListener();
captureListener.CaptureCompleted += OnCaptureCompleted;
captureListener.CaptureProgressed += OnCaptureProgressed;
}
captureSession.SetRepeatingRequest(previewRequest, captureListener, backgroundHandler);
}
catch (CameraAccessException ex)
{
ex.PrintStackTrace();
}
}
public void TakePhoto()
{
var characteristics = cameraManager.GetCameraCharacteristics(CameraDevice.Id);
var jpegSizes = ((StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap)).GetOutputSizes((int)ImageFormatType.Jpeg);
var width = jpegSizes[0].Width;
var height = jpegSizes[0].Height;
var reader = ImageReader.NewInstance(width, height, ImageFormatType.Jpeg, 1);
var outputSurfaces = new List <Surface> {
reader.Surface
};
CaptureRequest.Builder captureBuilder = CameraDevice.CreateCaptureRequest(CameraTemplate.StillCapture);
captureBuilder.AddTarget(reader.Surface);
captureBuilder.Set(CaptureRequest.ControlMode, (int)ControlMode.Auto);
// Orientation
var windowManager = Context.GetSystemService(Context.WindowService).JavaCast <IWindowManager>();
SurfaceOrientation rotation = windowManager.DefaultDisplay.Rotation;
captureBuilder.Set(CaptureRequest.JpegOrientation, orientation);
var readerListener = new ImageAvailableListener();
readerListener.Photo += (sender, e) =>
{
(Element as Controls.CameraPage).SetPhotoResult(e, width, height);
};
HandlerThread thread = new HandlerThread("CameraPicture");
thread.Start();
Handler backgroundHandler = new Handler(thread.Looper);
reader.SetOnImageAvailableListener(readerListener, backgroundHandler);
var captureListener = new CameraCaptureListener();
captureListener.PhotoComplete += (sender, e) =>
{
StartPreview();
};
CameraDevice.CreateCaptureSession(outputSurfaces, new CameraCaptureStateListener()
{
OnConfiguredAction = (CameraCaptureSession session) =>
{
try
{
previewSession = session;
session.Capture(captureBuilder.Build(), captureListener, backgroundHandler);
}
catch (CameraAccessException ex)
{
Log.WriteLine(LogPriority.Info, "Capture Session error: ", ex.ToString());
}
}
}, backgroundHandler);
}
/// <summary>
/// Lock the focus as the first step for a still image capture.
/// </summary>
private void LockFocus()
{
try
{
// This is how to tell the camera to lock focus.
PreviewRequestBuilder.Set(CaptureRequest.ControlAfTrigger, (int)ControlAFTrigger.Start);
// Tell #CaptureCallback to wait for the lock.
CurrentCameraState = STATE_WAITING_LOCK;
// this will kick off the image-capture pipeline
CaptureSession.Capture(PreviewRequestBuilder.Build(), CaptureCallback, _backgroundHandler);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
// Lock the focus as the first step for a still image capture.
void LockFocus()
{
try
{
// This is how to tell the camera to lock focus.
mPreviewRequestBuilder.Set(CaptureRequest.ControlAfTrigger, (int)ControlAFTrigger.Start);
// Tell #mCaptureCallback to wait for the lock.
mState = STATE_WAITING_LOCK;
mCaptureSession.Capture(mPreviewRequestBuilder.Build(),
mCaptureCallback,
mBackgroundHandler);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
/** Creates a new {@link CameraCaptureSession} for camera preview. */
private void createCameraPreviewSession()
{
try
{
SurfaceTexture texture = textureView.SurfaceTexture;
// assert texture != null;
// We configure the size of default buffer to be the size of camera preview we want.
texture.SetDefaultBufferSize(previewSize.Width, previewSize.Height);
// This is the output Surface we need to start preview.
Surface surface = new Surface(texture);
// We set up a CaptureRequest.Builder with the output Surface.
previewRequestBuilder = cameraDevice.CreateCaptureRequest(CameraTemplate.Preview);
previewRequestBuilder.AddTarget(surface);
StateCallback call = new StateCallback();
call.OnConfiguredHandler += (sender, e) =>
{
if (null == cameraDevice)
{
return;
}
// When the session is ready, we start displaying the preview.
captureSession = e;// cameraCaptureSession;
try
{
// Auto focus should be continuous for camera preview.
previewRequestBuilder.Set(
CaptureRequest.ControlAeMode,
(int)ControlAFMode.ContinuousPicture);
// ly, we start displaying the camera preview.
previewRequest = previewRequestBuilder.Build();
CaptureCallback captureCallback = new CaptureCallback();
captureSession.SetRepeatingRequest(previewRequest, captureCallback, backgroundHandler);
}
catch (CameraAccessException ex)
{
Log.Error(TAG, "Failed to set up config to capture Camera", e);
}
};
// Here, we create a CameraCaptureSession for camera preview.
cameraDevice.CreateCaptureSession(new System.Collections.Generic.List <Surface>()
{
surface
}, call, null);
}
catch (CameraAccessException e)
{
Log.Error(TAG, "Failed to preview Camera", e);
}
}
// 拍照前，先对焦
private void lockFocus()
{
if (captureSession != null && state == STATE_PREVIEW)
{
try
{
//previewRequestBuilder.Set(CaptureRequest.ControlAfTrigger,
// ControlAFTrigger.Start;
state = STATE_WAITING_FOR_LOCK;
captureSession.Capture(previewRequestBuilder.Build(), captureCallback,
backgroundHandler);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
}
public override void OnConfigured
(
CameraCaptureSession captureSession
)
{
captureSession.Capture(_captureBuilder.Build(),
_captureListener,
_backgroundHandler);
}
//Update the preview
public void UpdatePreview()
{
if (null == mCameraDevice)
{
return;
}
try
{
setUpCaptureRequestBuilder(mPreviewRequestBuilder);
HandlerThread thread = new HandlerThread("CameraPreview");
thread.Start();
mCaptureSession.SetRepeatingRequest(mPreviewRequestBuilder.Build(), null, mBackgroundHandler);
}
catch (CameraAccessException e)
{
e.PrintStackTrace();
}
}
/// <summary>
/// Stops the live preview, and requests a still capture from the camera session.
/// When the still capture is handled, the live preview is started again.
/// </summary>
public void CaptureImage()
{
if (CancellationToken.IsCancellationRequested)
{
return;
}
CaptureRequest.Builder builder = Camera.CreateCaptureRequest(CameraTemplate.StillCapture);
builder.AddTarget(Reader.Surface);
Session.Capture(builder.Build(), CaptureListener, null);
}
public override void OnOpened(CameraDevice camera)
{
CaptureRequest.Builder builder = camera.CreateCaptureRequest(CameraTemplate.Preview);
builder.AddTarget(_surface);
builder.AddTarget(_reader.Surface);
CaptureRequest captureRequest = builder.Build();
camera.CreateCaptureSession(new List <Surface> {
_surface, _reader.Surface
}, new MySessionCallback(captureRequest, _cameraPreviewView, _reader), new Handler(msg => { }));
}
public void AdjustFocus(int focusValue)
{
if (mPreviewRequestBuilder == null)
{
return;
}
if (minimumLens != null && minimumLens != 0)
{
mPreviewRequestBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.Off);
float num = (((float)focusValue) * (float)minimumLens / 100);
mPreviewRequestBuilder.Set(CaptureRequest.LensFocusDistance, num);
mCaptureSession?.SetRepeatingRequest(mPreviewRequest = mPreviewRequestBuilder.Build(), null, mBackgroundHandler);
}
else if (availableFocalLenths != null && availableFocalLenths.Any())
{
availableFocalLenths = availableFocalLenths.OrderBy((arg) => arg).ToArray();
mPreviewRequestBuilder.Set(CaptureRequest.ControlAfMode, (int)ControlAFMode.Off);
float max1 = (float)availableFocalLenths.Last();//10000
float min1 = (float)availableFocalLenths.First();
var foc = ((focusValue * (max1 - min1)) / 100 + min1);
mPreviewRequestBuilder.Set(CaptureRequest.LensFocalLength, foc);
mCaptureSession?.SetRepeatingRequest(mPreviewRequest = mPreviewRequestBuilder.Build(), null, mBackgroundHandler);
}
}
public override void OnConfigured(CameraCaptureSession session)
{
_session = session;
_builder.Set(CaptureRequest.ControlMode, null);
HandlerThread thread = new HandlerThread("CameraPreview");
thread.Start();
Handler backgroundHandler = new Handler(thread.Looper);
_session.SetRepeatingRequest(_builder.Build(), null, backgroundHandler);
System.Diagnostics.Debug.WriteLine("Session configurée");
}
private CaptureRequest CreateCaptureRequest()
{
try
{
CaptureRequest.Builder builder = _cameraDevice.CreateCaptureRequest(CameraTemplate.Preview);
builder.AddTarget(_surface);
return(builder.Build());
}
catch (CameraAccessException e)
{
Log.Error(_tag, e.Message);
return(null);
}
}
