//Code for initialization, capture completed, image availability events; also setting the source for the viewfinder.
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
// Check to see if the camera is available on the phone.
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true) ||
(PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) == true))
{
// Initialize the camera, when available.
if (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing))
{
// Use front-facing camera if available.
cam = new Microsoft.Devices.PhotoCamera(CameraType.FrontFacing);
}
else
{
// Otherwise, use standard camera on back of phone.
cam = new Microsoft.Devices.PhotoCamera(CameraType.Primary);
}
// Event is fired when the PhotoCamera object has been initialized.
cam.Initialized += new EventHandler <Microsoft.Devices.CameraOperationCompletedEventArgs>(cam_Initialized);
// Event is fired when the capture sequence is complete.
cam.CaptureCompleted += new EventHandler <CameraOperationCompletedEventArgs>(cam_CaptureCompleted);
// Event is fired when the capture sequence is complete and an image is available.
cam.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureImageAvailable);
// Event is fired when the capture sequence is complete and a thumbnail image is available.
cam.CaptureThumbnailAvailable += new EventHandler <ContentReadyEventArgs>(cam_CaptureThumbnailAvailable);
//Set the VideoBrush source to the camera.
viewfinderBrush.SetSource(cam);
}
else
{
// The camera is not supported on the phone.
this.Dispatcher.BeginInvoke(delegate()
{
// Write message.
// txtDebug.Text = "A Camera is not available on this phone.";
});
// Disable UI.
//ShutterButton.IsEnabled = false;
}
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true)
{
cam = new PhotoCamera(CameraType.Primary);
cam.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureImageAvailable);
viewfinderBrush.SetSource(cam);
}
else
{
if ((MessageBox.Show("A Camera is not available on this device.", "Quit", MessageBoxButton.OK) == MessageBoxResult.OK))
{
timer.Stop();
App.Quit();
}
}
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
if (e.NavigationMode == NavigationMode.Back)
{
return;
}
SystemTray.IsVisible = true;
_phoneHeight = Application.Current.Host.Content.ActualHeight;
_phoneWidth = Application.Current.Host.Content.ActualWidth;
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true) ||
(PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) == true))
{
if (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing))
{
cam = new PhotoCamera(CameraType.FrontFacing);
}
else
{
cam = new PhotoCamera(CameraType.Primary);
}
_cameraHeight = cam.AvailableResolutions.FirstOrDefault().Height;
_cameraWidth = cam.AvailableResolutions.FirstOrDefault().Width;
cam.CaptureCompleted += new EventHandler <CameraOperationCompletedEventArgs>(cam_CaptureCompleted);
cam.CaptureImageAvailable += new EventHandler <ContentReadyEventArgs>(cam_CaptureImageAvailable);
viewfinderBrush.SetSource(cam);
OnOrientationChanged(new OrientationChangedEventArgs(Orientation));
bmi = new BitmapImage(new Uri("/Images/Levels/L2.JPG", UriKind.Relative));
this.grimacePattern.Source = bmi;
startDate = DateTime.Now;
timer.Tick += new EventHandler(timer_Tick);
timer.Interval = new TimeSpan(0, 0, 1);
timer.Start();
}
else
{
Message = "A Camera is not available on this phone.";
}
}
//Code for initialization, capture completed, image availability events; also setting the source for the viewfinder.
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
MDEDB = new MDEDataContext();
int meetingID = int.Parse(NavigationContext.QueryString["meetingID"]);
meeting = new ObservableCollection <Meeting>(from Meeting m in MDEDB.Meetings where m.ID == meetingID select m)[0];
// Check to see if the camera is available on the phone.
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true) ||
(PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) == true))
{
// Initialize the camera, when available.
if (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing))
{
// Use front-facing camera if available.
cam = new Microsoft.Devices.PhotoCamera(CameraType.FrontFacing);
}
else
{
// Otherwise, use standard camera on back of phone.
cam = new Microsoft.Devices.PhotoCamera(CameraType.Primary);
}
// Event is fired when the PhotoCamera object has been initialized.
cam.Initialized += new EventHandler <Microsoft.Devices.CameraOperationCompletedEventArgs>(cam_Initialized);
// Event is fired when the capture sequence is complete and an image is available.
cam.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureImageAvailable);
//Set the VideoBrush source to the camera.
viewfinderBrush.SetSource(cam);
}
else
{
// The camera is not supported on the phone.
this.Dispatcher.BeginInvoke(delegate()
{
// Write message.
txtDebug.Text = "A Camera is not available on this phone.";
// Disable UI.
ShutterButton.IsEnabled = false;
});
}
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
List <BarcodeItem> main = new List <BarcodeItem>(AppContext.appContext.itemList);
this.FirstListBox.ItemsSource = main;
if (this.camera != null)
{
if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true)
{
this.camera = new PhotoCamera(CameraType.Primary);
this.camera.Initialized += OnPhotoCameraInitialized;
CameraButtons.ShutterKeyPressed += OnButtonFullPress;
// The event is fired when the viewfinder is tapped (for focus).
CodeScannerCanvas.Tap += new EventHandler <GestureEventArgs>(FocusTapped);
this.camera.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(CameraPictureReady);
viewfinderBrush.SetSource(this.camera);
}
}
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
//Check to see if camera is available on device
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true))
{
// Initialize the camera, when available
//Use standard camera on back of device
cam = new Microsoft.Devices.PhotoCamera(CameraType.Primary);
// Event is fired when the PhotoCamera object has been initialized.
cam.Initialized += new EventHandler <Microsoft.Devices.CameraOperationCompletedEventArgs>(cam_Initialized);
// Event is fired when the capture sequence is complete.
cam.CaptureCompleted += new EventHandler <CameraOperationCompletedEventArgs>(cam_CaptureCompleted);
// Event is fired when the capture sequence is complete and an image is available.
cam.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureImageAvailable);
// Event is fired when the capture sequence is complete and a thumbnail image is available.
cam.CaptureThumbnailAvailable += new EventHandler <ContentReadyEventArgs>(cam_CaptureThumbnailAvailable);
//Event fired when shutter button receives a full press
CameraButtons.ShutterKeyPressed += OnButtonFullPress;
//Set VideoBrush source to camera
viewfinderBrush.SetSource(cam);
}
else
{
//Camera not supported
this.Dispatcher.BeginInvoke(delegate()
{
//Write message to UI
txtDebug.Text = "A Camera is not available on this device.";
});
//Disable UI
ShutterButton.IsEnabled = false;
FlashButton.IsEnabled = false;
ResButton.IsEnabled = false;
}
}
public void InitializeCamera()
{
_cameraInitializedEvent.Reset();
// Check to see if the camera is available on the device.
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true) ||
(PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) == true))
{
// Initialize the default camera.
_camera = new Microsoft.Devices.PhotoCamera();
//Event is fired when the PhotoCamera object has been initialized
Camera.Initialized +=
new EventHandler <Microsoft.Devices.CameraOperationCompletedEventArgs>(CameraInitialized);
Camera.CaptureImageAvailable += CameraOnCaptureImageAvailable;
Camera.CaptureCompleted += CameraOnCaptureCompleted;
//Set the VideoBrush source to the camera
viewfinderBrush = new VideoBrush();
viewfinderBrush.SetSource(Camera);
videoRectangle.Fill = viewfinderBrush;
// initialize the shutter sound
// Audio
Stream stream = TitleContainer.OpenStream("shutter.wav");
_cameraShutterSound = SoundEffect.FromStream(stream);
CameraButtons.ShutterKeyPressed -= CameraButtonsOnShutterKeyPressed;
if (_photoOnPress)
{
CameraButtons.ShutterKeyPressed += CameraButtonsOnShutterKeyPressed;
}
}
else
{
// The camera is not supported on the device.
MessageBox.Show(
"Sorry, this sample requires a phone camera and no camera is detected. This application will not show any camera output.");
}
}
//Code for initialization, capture completed, image availability events; also setting the source for the viewfinder.
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
// Check to see if the camera is available on the device.
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true))
{
// use standard camera on back of device.
cam = new Microsoft.Devices.PhotoCamera(CameraType.Primary);
// Event is fired when the PhotoCamera object has been initialized.
cam.Initialized += new EventHandler <Microsoft.Devices.CameraOperationCompletedEventArgs>(cam_Initialized);
// The event is fired when auto-focus is complete.
cam.AutoFocusCompleted += new EventHandler <CameraOperationCompletedEventArgs>(cam_AutoFocusCompleted);
// The event is fired when the viewfinder is tapped (for focus).
viewfinderCanvas.Tap += new EventHandler <GestureEventArgs>(focus_Tapped);
//Set the VideoBrush source to the camera.
viewfinderBrush.SetSource(cam);
pumpFrames = true;
FramesThread = new System.Threading.Thread(PumpFrames);
// Start pump.
FramesThread.Start();
}
else
{
// The camera is not supported on the device.
this.Dispatcher.BeginInvoke(delegate()
{
// Write message.
txtDebug.Text = "A Camera is not available on this device.";
});
// Disable UI.
AFButton.IsEnabled = false;
ResButton.IsEnabled = false;
}
}
// Constructor
public MainPage()
{
InitializeComponent();
AccelerometerSensor = new Accelerometer();
AccelerometerSensor.CurrentValueChanged += new EventHandler <SensorReadingEventArgs <AccelerometerReading> >(AccelerometerSensor_ReadingChanged);
AccelerometerStartup();
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true))
{
viewfinderCanvas.Visibility = Visibility.Visible;
var cam = new Microsoft.Devices.PhotoCamera(CameraType.Primary);
if (Orientation == PageOrientation.PortraitUp || Orientation == PageOrientation.PortraitDown || Orientation == PageOrientation.Portrait)
{
// Rotate for LandscapeRight orientation.
viewfinderBrush.RelativeTransform =
new CompositeTransform()
{
CenterX = 0.5, CenterY = 0.5, Rotation = 90
};
}
viewfinderBrush.SetSource(cam);
}
}
public CameraPage()
{
InitializeComponent();
CameraButtons.ShutterKeyPressed += OnButtonFullPress;
if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary))
{
myCam = new PhotoCamera(CameraType.Primary);
ViewfinderCanvas.Height = myCam.Resolution.Height;
ViewfinderCanvas.Width = myCam.Resolution.Width;
ViewfinderBrush.SetSource(myCam);
//myCam.Initialized += cam_Initialized;
myCam.CaptureCompleted += myCam_CaptureCompleted;
}
else
{
MessageBox.Show("A Camera is not available on this device.", "Error!", MessageBoxButton.OK);
}
}
//Code for initialization, capture completed, image availability events; also setting the source for the viewfinder.
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
try
{
if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary))
{
cam = new Microsoft.Devices.PhotoCamera(CameraType.Primary);
cam.Initialized += new EventHandler <Microsoft.Devices.CameraOperationCompletedEventArgs>(cam_Initialized);
//cam.CaptureCompleted += new EventHandler<CameraOperationCompletedEventArgs>(cam_CaptureCompleted);
cam.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureImageAvailable);
cam.AutoFocusCompleted += new EventHandler <CameraOperationCompletedEventArgs>(cam_AutoFocusCompleted);
viewfinderCanvas.Tap += new EventHandler <System.Windows.Input.GestureEventArgs>(focus_Tapped);
CameraButtons.ShutterKeyHalfPressed += OnButtonHalfPress;
CameraButtons.ShutterKeyPressed += OnButtonFullPress;
CameraButtons.ShutterKeyReleased += OnButtonRelease;
viewfinderBrush.SetSource(cam);
}
}
catch (Exception ex) { LittleWatson.ReportException(ex); }
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
//this.Height = Application.Current.Host.Content.ActualHeight;
//this.Width = Application.Current.Host.Content.ActualWidth;
//LayoutRoot.Height = Application.Current.Host.Content.ActualHeight;
//LayoutRoot.Width = Application.Current.Host.Content.ActualWidth;
PageOrientation po = ((PhoneApplicationFrame)(Application.Current.RootVisual)).Orientation;
var landscapeRotation = 90;
if (po == PageOrientation.Landscape)
{
LayoutRoot.Width = Application.Current.Host.Content.ActualHeight;
LayoutRoot.Height = Application.Current.Host.Content.ActualWidth;
viewFeed.Width = Application.Current.Host.Content.ActualHeight;
viewFeed.Height = Application.Current.Host.Content.ActualWidth;
// CompositeTransform.Rotation = _photoCamera.SensorRotationInDegrees - 90;
landscapeRotation = 0;
}
else if (po == PageOrientation.LandscapeRight)
{
LayoutRoot.Width = Application.Current.Host.Content.ActualHeight;
LayoutRoot.Height = Application.Current.Host.Content.ActualWidth;
viewFeed.Width = Application.Current.Host.Content.ActualHeight;
viewFeed.Height = Application.Current.Host.Content.ActualWidth;
//CompositeTransform.Rotation = PhotoCaptureDeviceProp.SensorRotationInDegrees + 90;
landscapeRotation = 180;
}
else if (po == PageOrientation.PortraitUp)
{
LayoutRoot.Height = Application.Current.Host.Content.ActualHeight;
LayoutRoot.Width = Application.Current.Host.Content.ActualWidth;
viewFeed.Height = Application.Current.Host.Content.ActualHeight;
viewFeed.Width = Application.Current.Host.Content.ActualWidth;
landscapeRotation = 90;
//CompositeTransform.Rotation = PhotoCaptureDeviceProp.SensorRotationInDegrees;
}
else if (po == PageOrientation.PortraitDown)
{
LayoutRoot.Height = Application.Current.Host.Content.ActualHeight;
LayoutRoot.Width = Application.Current.Host.Content.ActualWidth;
viewFeed.Height = Application.Current.Host.Content.ActualHeight;
viewFeed.Width = Application.Current.Host.Content.ActualWidth;
//CompositeTransform.Rotation = PhotoCaptureDeviceProp.SensorRotationInDegrees + 180;
landscapeRotation = -90;
}
if (_photoCamera != null)
{
_videoBrush.RelativeTransform =
new CompositeTransform()
{
CenterX = 0.5, CenterY = 0.5, Rotation = landscapeRotation
};
_videoBrush.Stretch = Stretch.Fill;
}
// Check to see if the camera is available on the phone.
if (PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true)
{
_photoCamera = new PhotoCamera(CameraType.Primary);
// Event is fired when the PhotoCamera object has been initialized.
//_photoCamera.Initialized += PhotoCameraOnInitialized;
_videoBrush = new VideoBrush();
_videoBrush.RelativeTransform = new CompositeTransform()
{
CenterX = 0.5, CenterY = 0.5, Rotation = landscapeRotation
};
_videoBrush.Stretch = Stretch.Fill;
_videoBrush.SetSource(_photoCamera);
viewFeed.Fill = _videoBrush;
}
else
{
// The camera is not supported on the phone.
MessageBox.Show("A Camera is not available on this phone.");
}
}
//Code for initialization, capture completed, image availability events; also setting the source for the viewfinder.
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
string msg = "";
if (NavigationContext.QueryString.TryGetValue("msg", out msg))
{
patientid = msg;
}
// Check to see if the camera is available on the device.
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true) || (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) == true))
{
// Initialize the camera, when available.
if (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing))
{
// Otherwise, use standard camera on back of device.
cam = new Microsoft.Devices.PhotoCamera(CameraType.Primary);
}
else
{
// Use front-facing camera if available.
cam = new Microsoft.Devices.PhotoCamera(CameraType.FrontFacing);
}
// Event is fired when the PhotoCamera object has been initialized.
cam.Initialized += new EventHandler <Microsoft.Devices.CameraOperationCompletedEventArgs>(cam_Initialized);
// Event is fired when the capture sequence is complete.
cam.CaptureCompleted += new EventHandler <CameraOperationCompletedEventArgs>(cam_CaptureCompleted);
// Event is fired when the capture sequence is complete and an image is available.
cam.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureImageAvailable);
// Event is fired when the capture sequence is complete and a thumbnail image is available.
cam.CaptureThumbnailAvailable += new EventHandler <ContentReadyEventArgs>(cam_CaptureThumbnailAvailable);
// The event is fired when auto-focus is complete.
cam.AutoFocusCompleted += new EventHandler <CameraOperationCompletedEventArgs>(cam_AutoFocusCompleted);
// The event is fired when the viewfinder is tapped (for focus).
viewfinderCanvas.Tap += new EventHandler <GestureEventArgs>(focus_Tapped);
// The event is fired when the shutter button receives a half press.
CameraButtons.ShutterKeyHalfPressed += OnButtonHalfPress;
// The event is fired when the shutter button receives a full press.
CameraButtons.ShutterKeyPressed += OnButtonFullPress;
// The event is fired when the shutter button is released.
CameraButtons.ShutterKeyReleased += OnButtonRelease;
//Set the VideoBrush source to the camera.
viewfinderBrush.SetSource(cam);
viewfinderCanvas.Visibility = Visibility.Visible;
imageCanvas.Visibility = Visibility.Collapsed;
ShutterButton.Visibility = Visibility.Visible;
ShutterButton.IsEnabled = true;
ConfirmButton.Visibility = Visibility.Collapsed;
ConfirmButton.IsEnabled = false;
}
else
{
// The camera is not supported on the device.
this.Dispatcher.BeginInvoke(delegate()
{
// Write message.
txtDebug.Text = "A Camera is not available on this device.";
});
// Disable UI.
ShutterButton.IsEnabled = false;
FlashButton.IsEnabled = false;
AFButton.IsEnabled = false;
ResButton.IsEnabled = false;
}
}
/// <summary>
/// Determines whether a particular camera type is supported on the device.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>
/// <c>true</c> if the specified camera type is supported; otherwise, <c>false</c>.
/// </returns>
public override bool IsCameraTypeSupported(CameraType type)
{
return(PhotoCamera.IsCameraTypeSupported(Enum <Microsoft.Devices.CameraType> .ConvertFromOtherEnumValue(type)));
}
/**
* Initializing the ioctls.
*/
public void Init(Ioctls ioctls, Core core, Runtime runtime)
{
mCamera = new PhotoCamera(mCameraType);
mVideoBrush = new VideoBrush();
runtime.RegisterCleaner(delegate()
{
if (null != mCamera)
{
mCamera.Dispose();
mCamera = null;
}
});
mRuntime = runtime;
PhoneApplicationPage currentPage = (((PhoneApplicationFrame)Application.Current.RootVisual).Content as PhoneApplicationPage);
// set the initial camera orientation in respect to the current page orientation
SetInitialCameraOrientation(currentPage);
// handle current page orientation and adjust the camera orientation accordingly
HandleDeviceOrientation(currentPage);
/**
* Stores an output format in fmm parameter.
* @param _index int the index of the required format.
* @param _fmt int the momory address at which to write the output format dimensions.
*
* Note: the _index should be greater than 0 and smaller than the number of camera formats.
*/
ioctls.maCameraFormat = delegate(int _index, int _fmt)
{
System.Windows.Size dim;
if (GetCameraFormat(_index, out dim) == false)
{
return(MoSync.Constants.MA_CAMERA_RES_FAILED);
}
core.GetDataMemory().WriteInt32(_fmt + MoSync.Struct.MA_CAMERA_FORMAT.width,
(int)dim.Width);
core.GetDataMemory().WriteInt32(_fmt + MoSync.Struct.MA_CAMERA_FORMAT.height,
(int)dim.Height);
return(MoSync.Constants.MA_CAMERA_RES_OK);
};
/**
* Returns the number of different output formats supported by the current device's camera.
* \< 0 if there is no camera support.
* 0 if there is camera support, but the format is unknown.
*/
ioctls.maCameraFormatNumber = delegate()
{
// if the camera is not initialized, we cannot access any of its properties
if (!isCameraInitialized)
{
// because the cammera is supported but not initialized, we return 0
return(0);
}
IEnumerable <System.Windows.Size> res = mCamera.AvailableResolutions;
if (res == null)
{
return(0);
}
IEnumerator <System.Windows.Size> resolutions = res.GetEnumerator();
resolutions.MoveNext();
int number = 0;
while (resolutions.Current != null)
{
number++;
resolutions.MoveNext();
if (resolutions.Current == new System.Windows.Size(0, 0))
{
break;
}
}
return(number);
};
/**
* Starts the viewfinder and the camera
*/
ioctls.maCameraStart = delegate()
{
if (isCameraSnapshotInProgress)
{
return(MoSync.Constants.MA_CAMERA_RES_SNAPSHOT_IN_PROGRESS);
}
InitCamera();
MoSync.Util.RunActionOnMainThreadSync(() =>
{
mCameraPrev.StartViewFinder();
});
return(0);
};
/**
* stops the view finder and the camera.
*/
ioctls.maCameraStop = delegate()
{
if (isCameraSnapshotInProgress)
{
// We need to post snapshot failed if the camera was stopped during snapshot operation
postSnapshotEvent(snapshotPlaceHolder, mCamera.Resolution,
MoSync.Constants.MA_IMAGE_REPRESENTATION_UNKNOWN, MoSync.Constants.MA_CAMERA_RES_FAILED);
isCameraSnapshotInProgress = false;
}
MoSync.Util.RunActionOnMainThreadSync(() =>
{
mCameraPrev.StopViewFinder();
});
return(0);
};
/**
* Adds a previewWidget to the camera controller in devices that support native UI.
*/
ioctls.maCameraSetPreview = delegate(int _widgetHandle)
{
// if the camera is not initialized, we need to initialize it before
// setting the preview
if (!isCameraInitialized)
{
InitCamera();
}
IWidget w = runtime.GetModule <NativeUIModule>().GetWidget(_widgetHandle);
if (w.GetType() != typeof(MoSync.NativeUI.CameraPreview))
{
return(MoSync.Constants.MA_CAMERA_RES_FAILED);
}
mCameraPrev = (NativeUI.CameraPreview)w;
mCameraPrev.SetViewFinderContent(mVideoBrush);
return(MoSync.Constants.MA_CAMERA_RES_OK);
};
/**
* Returns the number of available Camera on the device.
*/
ioctls.maCameraNumber = delegate()
{
if (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) && PhotoCamera.IsCameraTypeSupported(CameraType.Primary))
{
return(2);
}
else if (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) || PhotoCamera.IsCameraTypeSupported(CameraType.Primary))
{
return(1);
}
return(0);
};
/**
* Captures an image and stores it as a new data object in the
* supplied placeholder.
* @param _formatIndex int the required format.
* @param _placeHolder int the placeholder used for storing the image.
*/
ioctls.maCameraSnapshot = delegate(int _formatIndex, int _placeHolder)
{
if (isCameraSnapshotInProgress)
{
return(MoSync.Constants.MA_CAMERA_RES_SNAPSHOT_IN_PROGRESS);
}
// If MA_CAMERA_SNAPSHOT_MAX_SIZE is sent via _formatIndex then we
// need to select the biggest available snapshot size/resolution.
if (MoSync.Constants.MA_CAMERA_SNAPSHOT_MAX_SIZE == _formatIndex)
{
_formatIndex = (int)ioctls.maCameraFormatNumber() - 1;
}
AutoResetEvent are = new AutoResetEvent(false);
System.Windows.Size dim;
if (GetCameraFormat(_formatIndex, out dim) == false)
{
return(MoSync.Constants.MA_CAMERA_RES_FAILED);
}
mCamera.Resolution = dim;
if (mCameraSnapshotDelegate != null)
{
mCamera.CaptureImageAvailable -= mCameraSnapshotDelegate;
}
mCameraSnapshotDelegate = delegate(object o, ContentReadyEventArgs args)
{
MoSync.Util.RunActionOnMainThreadSync(() =>
{
Resource res = runtime.GetResource(MoSync.Constants.RT_PLACEHOLDER, _placeHolder);
Stream data = null;
try
{
// as the camera always takes a snapshot in landscape left orientation,
// we need to rotate the resulting image 90 degrees for a current PortraitUp orientation
// and 180 degrees for a current LandscapeRight orientation
int rotateAngle = 0;
if (currentPage.Orientation == PageOrientation.PortraitUp)
{
rotateAngle = 90;
}
else if (currentPage.Orientation == PageOrientation.LandscapeRight)
{
rotateAngle = 180;
}
// if the current page is in a LandscapeLeft orientation, the orientation angle will be 0
data = RotateImage(args.ImageStream, rotateAngle);
}
catch
{
// the orientation angle was not a multiple of 90 - we keep the original image
data = args.ImageStream;
}
MemoryStream dataMem = new MemoryStream((int)data.Length);
MoSync.Util.CopySeekableStreams(data, 0, dataMem, 0, (int)data.Length);
res.SetInternalObject(dataMem);
});
are.Set();
};
mCamera.CaptureImageAvailable += mCameraSnapshotDelegate;
mCamera.CaptureImage();
are.WaitOne();
return(MoSync.Constants.MA_CAMERA_RES_OK);
};
/**
* Captures an image and stores it as a new data object in new
* placeholder that is sent via #EVENT_TYPE_CAMERA_SNAPSHOT event.
* @param _placeHolder int the placeholder used for storing the image.
* @param _sizeIndex int the required size index.
*/
ioctls.maCameraSnapshotAsync = delegate(int _placeHolder, int _sizeIndex)
{
if (isCameraSnapshotInProgress)
{
return(MoSync.Constants.MA_CAMERA_RES_SNAPSHOT_IN_PROGRESS);
}
// If MA_CAMERA_SNAPSHOT_MAX_SIZE is sent via _sizeIndex then we
// need to select the biggest available snapshot size/resolution.
if (MoSync.Constants.MA_CAMERA_SNAPSHOT_MAX_SIZE == _sizeIndex)
{
_sizeIndex = (int)ioctls.maCameraFormatNumber() - 1;
}
System.Windows.Size dim;
if (GetCameraFormat(_sizeIndex, out dim) == false)
{
return(MoSync.Constants.MA_CAMERA_RES_FAILED);
}
mCamera.Resolution = dim;
if (mCameraSnapshotDelegate != null)
{
mCamera.CaptureImageAvailable -= mCameraSnapshotDelegate;
}
mCameraSnapshotDelegate = delegate(object o, ContentReadyEventArgs args)
{
MoSync.Util.RunActionOnMainThreadSync(() =>
{
// If the camera was stopped and this delegate was still called then we do nothing here
// because in maCameraStop we already send the snapshot failed event.
if (!isCameraSnapshotInProgress)
{
return;
}
Stream data = null;
try
{
// as the camera always takes a snapshot in landscape left orientation,
// we need to rotate the resulting image 90 degrees for a current PortraitUp orientation
// and 180 degrees for a current LandscapeRight orientation
int rotateAngle = 0;
if (currentPage.Orientation == PageOrientation.PortraitUp)
{
// This is for the front camera.
if (mCamera.CameraType != CameraType.Primary)
{
rotateAngle = 270;
}
else
{
rotateAngle = 90;
}
}
else if (currentPage.Orientation == PageOrientation.LandscapeRight)
{
rotateAngle = 180;
}
// if the current page is in a LandscapeLeft orientation, the orientation angle will be 0
data = RotateImage(args.ImageStream, rotateAngle);
}
catch
{
// the orientation angle was not a multiple of 90 - we keep the original image
data = args.ImageStream;
}
Resource res = runtime.GetResource(MoSync.Constants.RT_PLACEHOLDER, _placeHolder);
MemoryStream dataMem = new MemoryStream((int)data.Length);
MoSync.Util.CopySeekableStreams(data, 0, dataMem, 0, (int)data.Length);
res.SetInternalObject(dataMem);
postSnapshotEvent(_placeHolder, mCamera.Resolution,
MoSync.Constants.MA_IMAGE_REPRESENTATION_RAW, MoSync.Constants.MA_CAMERA_RES_OK);
isCameraSnapshotInProgress = false;
});
};
mCamera.CaptureImageAvailable += mCameraSnapshotDelegate;
mCamera.CaptureImage();
snapshotPlaceHolder = _placeHolder;
isCameraSnapshotInProgress = true;
return(MoSync.Constants.MA_CAMERA_RES_OK);
};
/**
* Sets the property represented by the string situated at the
* _property address with the value situated at the _value address.
* @param _property int the property name address
* @param _value int the value address
*
* Note: the fallowing properties are not available on windows phone
* MA_CAMERA_FOCUS_MODE, MA_CAMERA_IMAGE_FORMAT, MA_CAMERA_ZOOM,
* MA_CAMERA_MAX_ZOOM.
*/
ioctls.maCameraSetProperty = delegate(int _property, int _value)
{
// if the camera is not initialized, we cannot access any of its properties
if (!isCameraInitialized)
{
return(MoSync.Constants.MA_CAMERA_RES_PROPERTY_NOTSUPPORTED);
}
String property = core.GetDataMemory().ReadStringAtAddress(_property);
String value = core.GetDataMemory().ReadStringAtAddress(_value);
if (property.Equals(MoSync.Constants.MA_CAMERA_FLASH_MODE))
{
if (value.Equals(MoSync.Constants.MA_CAMERA_FLASH_ON) && mCamera.IsFlashModeSupported(FlashMode.On))
{
mCamera.FlashMode = FlashMode.On;
mFlashMode = FlashMode.On;
}
else if (value.Equals(MoSync.Constants.MA_CAMERA_FLASH_OFF) && mCamera.IsFlashModeSupported(FlashMode.Off))
{
mCamera.FlashMode = FlashMode.Off;
mFlashMode = FlashMode.Off;
}
else if (value.Equals(MoSync.Constants.MA_CAMERA_FLASH_AUTO) && mCamera.IsFlashModeSupported(FlashMode.Auto))
{
mCamera.FlashMode = FlashMode.Auto;
mFlashMode = FlashMode.Auto;
}
else
{
return(MoSync.Constants.MA_CAMERA_RES_INVALID_PROPERTY_VALUE);
}
return(MoSync.Constants.MA_CAMERA_RES_OK);
}
else if (property.Equals(MoSync.Constants.MA_CAMERA_FOCUS_MODE))
{
return(MoSync.Constants.MA_CAMERA_RES_PROPERTY_NOTSUPPORTED);
}
else if (property.Equals(MoSync.Constants.MA_CAMERA_IMAGE_FORMAT))
{
return(MoSync.Constants.MA_CAMERA_RES_PROPERTY_NOTSUPPORTED);
}
else if (property.Equals(MoSync.Constants.MA_CAMERA_ZOOM))
{
return(MoSync.Constants.MA_CAMERA_RES_PROPERTY_NOTSUPPORTED);
}
else if (property.Equals(MoSync.Constants.MA_CAMERA_MAX_ZOOM))
{
return(MoSync.Constants.MA_CAMERA_RES_PROPERTY_NOTSUPPORTED);
}
else
{
return(MoSync.Constants.MA_CAMERA_RES_PROPERTY_NOTSUPPORTED);
}
};
/**
* Selects a camera from the avalable ones;
* in this eigther the back or the front camera is
* chosen
*/
ioctls.maCameraSelect = delegate(int _camera)
{
// if the camera is not initialized, we cannot access any of its properties
if (!isCameraInitialized)
{
return(MoSync.Constants.MA_CAMERA_RES_FAILED);
}
if (MoSync.Constants.MA_CAMERA_CONST_BACK_CAMERA == _camera)
{
if (mCamera.CameraType != CameraType.Primary)
{
mCameraType = CameraType.Primary;
InitCamera();
MoSync.Util.RunActionOnMainThreadSync(() =>
{
SetInitialCameraOrientation(currentPage);
}
);
}
}
else if (MoSync.Constants.MA_CAMERA_CONST_FRONT_CAMERA == _camera)
{
if (mCamera.CameraType != CameraType.FrontFacing)
{
mCameraType = CameraType.FrontFacing;
InitCamera();
MoSync.Util.RunActionOnMainThreadSync(() =>
{
SetInitialCameraOrientation(currentPage);
}
);
}
}
else
{
return(MoSync.Constants.MA_CAMERA_RES_FAILED);
}
return(MoSync.Constants.MA_CAMERA_RES_OK);
};
/**
* Retrieves the specified property value in the given buffer.
* @param _property int the address for the property string
* @param _value int the address for the property value string (the buffer)
* @param _bufSize int the buffer size
*/
ioctls.maCameraGetProperty = delegate(int _property, int _value, int _bufSize)
{
String property = core.GetDataMemory().ReadStringAtAddress(_property);
if (property.Equals(MoSync.Constants.MA_CAMERA_MAX_ZOOM))
{
core.GetDataMemory().WriteStringAtAddress(
_value,
"0",
_bufSize);
}
else if (property.Equals(MoSync.Constants.MA_CAMERA_ZOOM_SUPPORTED))
{
core.GetDataMemory().WriteStringAtAddress(
_value,
"false",
_bufSize);
}
else if (property.Equals(MoSync.Constants.MA_CAMERA_FLASH_SUPPORTED))
{
/*
* Since we cannot see if flash is supported because the camera may be not
* fully initialized when this is called, we assume that each windows phone
* has flash support for primary camera but not for the from camera.
*/
String result = "true";
if (mCamera.CameraType != CameraType.Primary)
{
result = "false";
}
core.GetDataMemory().WriteStringAtAddress(
_value,
result,
_bufSize);
}
else
{
return(MoSync.Constants.MA_CAMERA_RES_PROPERTY_NOTSUPPORTED);
}
return(0);
};
ioctls.maCameraRecord = delegate(int _stopStartFlag)
{
return(MoSync.Constants.MA_CAMERA_RES_FAILED);
};
}
//public int BatteryPercentage { get; private set; }
//public BatteryState BatteryState { get; private set; }
public DeviceInfo()
{
#if __IOS__
this.Manufacturer = "Apple";
this.Model = UIDevice.CurrentDevice.Model;
this.OperatingSystem = String.Format("{0} {1}", UIDevice.CurrentDevice.SystemName, UIDevice.CurrentDevice.SystemVersion);
this.DeviceId = UIDevice.CurrentDevice.IdentifierForVendor.AsString();
var screen = UIScreen.MainScreen.Bounds;
this.ScreenWidth = (int)screen.Width;
this.ScreenHeight = (int)screen.Height;
this.IsFrontCameraAvailable = UIImagePickerController.IsCameraDeviceAvailable(UIImagePickerControllerCameraDevice.Front);
this.IsRearCameraAvailable = UIImagePickerController.IsCameraDeviceAvailable(UIImagePickerControllerCameraDevice.Rear);
this.IsSimulator = (Runtime.Arch == Arch.SIMULATOR);
//this.BatteryPercentage = UIDevice.CurrentDevice.BatteryLevel;
#elif __ANDROID__
this.Manufacturer = B.Manufacturer;
this.Model = B.Model;
this.OperatingSystem = String.Format("{0} - SDK: {1}", B.VERSION.Release, B.VERSION.SdkInt);
this.IsSimulator = B.Product.Equals("google_sdk");
var d = Resources.System.DisplayMetrics;
this.ScreenWidth = (int)(d.WidthPixels / d.Density);
this.ScreenHeight = (int)(d.HeightPixels / d.Density);
var pm = Forms.Context.ApplicationContext.PackageManager;
this.IsRearCameraAvailable = pm.HasSystemFeature(PackageManager.FeatureCamera);
this.IsFrontCameraAvailable = pm.HasSystemFeature(PackageManager.FeatureCameraFront);
var tel = (TelephonyManager)Forms.Context.ApplicationContext.GetSystemService(Context.TelephonyService);
this.DeviceId = tel.DeviceId;
//var filter = new IntentFilter(Intent.ActionBatteryChanged);
//var battery = RegisterReceiver(null, filter);
//var level = battery.GetIntExtra(BatteryManager.ExtraLevel, -1);
//var scale = battery.GetIntExtra(BatteryManager.ExtraScale, -1);
//this.BatteryPercentage = Convert.ToInt32(Math.Floor(level * 100D / scale));
#elif WINDOWS_PHONE
this.Manufacturer = DeviceStatus.DeviceManufacturer;
this.Model = DeviceStatus.DeviceName;
this.OperatingSystem = Env.OSVersion.ToString();
var deviceIdBytes = (byte[])DeviceExtendedProperties.GetValue("DeviceUniqueId");
this.DeviceId = Convert.ToBase64String(deviceIdBytes);
this.IsRearCameraAvailable = PhotoCamera.IsCameraTypeSupported(CameraType.Primary);
this.IsFrontCameraAvailable = PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing);
this.IsSimulator = (DevEnv.DeviceType == DeviceType.Emulator);
switch (GetScaleFactor())
{
case 150:
this.ScreenWidth = 720;
this.ScreenHeight = 1280;
break;
case 160:
this.ScreenWidth = 768;
this.ScreenHeight = 1280;
break;
case 100:
default:
this.ScreenWidth = 480;
this.ScreenHeight = 800;
break;
}
#endif
}
public CameraViewModel()
{
SetUpCameraCommand = new RelayCommand <NavigationEventArgs>((e) =>
{
// Check to see if the camera is available on the phone.
if ((PhotoCamera.IsCameraTypeSupported(CameraType.Primary) == true) ||
(PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing) == true))
{
// Initialize the camera, when available.
if (PhotoCamera.IsCameraTypeSupported(CameraType.FrontFacing))
{
// Use front-facing camera if available.
cam = new PhotoCamera(CameraType.FrontFacing);
}
else
{
// Otherwise, use standard camera on back of phone.
cam = new PhotoCamera(CameraType.Primary);
}
//// Event is fired when the PhotoCamera object has been initialized.
//cam.Initialized += new EventHandler<Microsoft.Devices.CameraOperationCompletedEventArgs>(cam_Initialized);
// Event is fired when the capture sequence is complete.
//cam.CaptureCompleted += new EventHandler<CameraOperationCompletedEventArgs>(cam_CaptureCompleted);
//// Event is fired when the capture sequence is complete and an image is available.
cam.CaptureImageAvailable += new EventHandler <Microsoft.Devices.ContentReadyEventArgs>(cam_CaptureImageAvailable);
//// Event is fired when the capture sequence is complete and a thumbnail image is available.
//cam.CaptureThumbnailAvailable += new EventHandler<ContentReadyEventArgs>(cam_CaptureThumbnailAvailable);
CameraBackground = new VideoBrush();
CameraBackground.SetSource(cam);
CameraBackground.Stretch = Stretch.Uniform;
}
else
{
// TODO The camera is not supported on the phone, do something smart
}
});
CleanUpCameraCommand = new RelayCommand <NavigatingCancelEventArgs>((e) =>
{
if (cam != null)
{
// Dispose camera to minimize power consumption and to expedite shutdown.
cam.Dispose();
// Release memory, ensure garbage collection.
//cam.Initialized -= cam_Initialized;
//cam.CaptureCompleted -= cam_CaptureCompleted;
cam.CaptureImageAvailable -= cam_CaptureImageAvailable;
//cam.CaptureThumbnailAvailable -= cam_CaptureThumbnailAvailable;
}
});
TakePhotoCommand = new RelayCommand(() =>
{
if (cam != null)
{
try
{
// Start image capture.
cam.CaptureImage();
}
catch
{
// TODO
}
}
});
}