/*
* Copyright (C) 2020, University of the Basque Country (UPV/EHU)
* Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
*
* The original file was part of Open Source IMSDROID
* Copyright (C) 2010-2011, Mamadou Diop.
* Copyright (C) 2011, Doubango Telecom.
*
*
* Contact: Mamadou Diop <diopmamadou(at)doubango(dot)org>
*
* This file is part of Open Source Doubango Framework.
*
* This is free software: you can redistribute it and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* This is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
package org.doubango.ngn.media;
import android.graphics.PixelFormat;
import android.hardware.Camera;
import android.hardware.Camera.PreviewCallback;
import android.util.Log;
import android.view.SurfaceHolder;
import org.doubango.ngn.BuildConfig;
import org.doubango.ngn.NgnApplication;
import org.doubango.ngn.NgnEngine;
import org.doubango.ngn.utils.NgnConfigurationEntry;
import org.doubango.utils.Utils;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class NgnCameraProducer {
private static final String TAG = Utils.getTAG(NgnCameraProducer.class.getCanonicalName());
private static Camera instance;
private static boolean useFrontFacingCamera;
// Default values
private static int fps = 15;
private static int width = 176;
private static int height = 144;
private static SurfaceHolder holder = null;
private static PreviewCallback callback = null;
private static final int MIN_SDKVERSION_addCallbackBuffer = 7;
private static final int MIN_SDKVERSION_setPreviewCallbackWithBuffer = 7;
private static final int MIN_SDKVERSION_setDisplayOrientation = 8;
//private static final int MIN_SDKVERSION_getSupportedPreviewSizes = 5;
private static Method addCallbackBufferMethod = null;
private static Method setDisplayOrientationMethod = null;
private static Method setPreviewCallbackWithBufferMethod = null;
static{
NgnCameraProducer.useFrontFacingCamera = NgnEngine
.getInstance().getConfigurationService().getBoolean(NgnConfigurationEntry.GENERAL_USE_FFC,
NgnConfigurationEntry.DEFAULT_GENERAL_USE_FFC);
}
static{
if(NgnApplication.getSDKVersion() >= NgnCameraProducer.MIN_SDKVERSION_addCallbackBuffer){
// According to http://developer.android.com/reference/android/hardware/Camera.html both addCallbackBuffer and setPreviewCallbackWithBuffer
// are only available starting API level 8. But it's not true as these functions exist in API level 7 but are hidden.
try {
NgnCameraProducer.addCallbackBufferMethod = Camera.class.getMethod("addCallbackBuffer", byte[].class);
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
if(NgnApplication.getSDKVersion() >= NgnCameraProducer.MIN_SDKVERSION_setPreviewCallbackWithBuffer){
try {
NgnCameraProducer.setPreviewCallbackWithBufferMethod = Camera.class.getMethod(
"setPreviewCallbackWithBuffer", PreviewCallback.class);
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
if(NgnApplication.getSDKVersion() >= NgnCameraProducer.MIN_SDKVERSION_setDisplayOrientation){
try {
NgnCameraProducer.setDisplayOrientationMethod = Camera.class.getMethod("setDisplayOrientation", int.class);
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
}
public static Camera getCamera(){
return NgnCameraProducer.instance;
}
public static Camera openCamera(int fps, int width, int height, SurfaceHolder holder, PreviewCallback callback){
if(NgnCameraProducer.instance == null){
try{
if(NgnCameraProducer.useFrontFacingCamera){
NgnCameraProducer.instance = NgnCameraProducer.openFrontFacingCamera();
}
else{
NgnCameraProducer.instance = Camera.open();
}
NgnCameraProducer.fps = fps;
NgnCameraProducer.width = width;
NgnCameraProducer.height = height;
NgnCameraProducer.holder = holder;
NgnCameraProducer.callback = callback;
Camera.Parameters parameters = NgnCameraProducer.instance.getParameters();
/*
* http://developer.android.com/reference/android/graphics/ImageFormat.html#NV21
* YCrCb format used for images, which uses the NV21 encoding format.
* This is the default format for camera preview images, when not otherwise set with setPreviewFormat(int).
*/
parameters.setPreviewFormat(PixelFormat.YCbCr_420_SP);
parameters.setPreviewFrameRate(NgnCameraProducer.fps);
NgnCameraProducer.instance.setParameters(parameters);
try{
parameters.setPictureSize(NgnCameraProducer.width , NgnCameraProducer.height);
NgnCameraProducer.instance.setParameters(parameters);
}
catch(Exception e){
// FFMpeg converter will resize the video stream
Log.d(NgnCameraProducer.TAG, e.toString());
}
NgnCameraProducer.instance.setPreviewDisplay(NgnCameraProducer.holder);
NgnCameraProducer.initializeCallbacks(NgnCameraProducer.callback);
}
catch(Exception e){
NgnCameraProducer.releaseCamera();
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
return NgnCameraProducer.instance;
}
public static void releaseCamera(Camera camera){
if(camera != null){
camera.stopPreview();
NgnCameraProducer.deInitializeCallbacks(camera);
camera.release();
if(camera == NgnCameraProducer.instance){
NgnCameraProducer.instance = null;
}
}
}
public static void releaseCamera(){
if(NgnCameraProducer.instance != null){
NgnCameraProducer.instance.stopPreview();
NgnCameraProducer.deInitializeCallbacks();
NgnCameraProducer.instance.release();
NgnCameraProducer.instance = null;
}
}
public static void setDisplayOrientation(int degrees){
if(NgnCameraProducer.instance != null && NgnCameraProducer.setDisplayOrientationMethod != null){
try {
NgnCameraProducer.setDisplayOrientationMethod.invoke(NgnCameraProducer.instance, degrees);
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
}
public static void setDisplayOrientation(Camera camera, int degrees){
if(camera != null && NgnCameraProducer.setDisplayOrientationMethod != null){
try {
NgnCameraProducer.setDisplayOrientationMethod.invoke(camera, degrees);
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
}
public static void addCallbackBuffer(Camera camera, byte[] buffer) {
try {
NgnCameraProducer.addCallbackBufferMethod.invoke(camera, buffer);
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
public static void addCallbackBuffer(byte[] buffer) {
try {
NgnCameraProducer.addCallbackBufferMethod.invoke(NgnCameraProducer.instance, buffer);
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
public static boolean isAddCallbackBufferSupported(){
return NgnCameraProducer.addCallbackBufferMethod != null;
}
public static boolean isFrontFacingCameraEnabled(){
return NgnCameraProducer.useFrontFacingCamera;
}
public static void useRearCamera(){
NgnCameraProducer.useFrontFacingCamera = false;
}
public static void useFrontFacingCamera(){
NgnCameraProducer.useFrontFacingCamera = true;
}
public static Camera toggleCamera(){
if(NgnCameraProducer.instance != null){
NgnCameraProducer.useFrontFacingCamera = !NgnCameraProducer.useFrontFacingCamera;
NgnCameraProducer.releaseCamera();
NgnCameraProducer.openCamera(NgnCameraProducer.fps,
NgnCameraProducer.width,
NgnCameraProducer.height,
NgnCameraProducer.holder,
NgnCameraProducer.callback);
}
return NgnCameraProducer.instance;
}
private static void initializeCallbacks(PreviewCallback callback){
initializeCallbacks(callback, NgnCameraProducer.instance);
}
private static void initializeCallbacks(PreviewCallback callback, Camera camera){
if(BuildConfig.DEBUG)Log.d(TAG,"initializeCallbacks");
if(camera != null){
if(NgnCameraProducer.setPreviewCallbackWithBufferMethod != null){
if(BuildConfig.DEBUG)Log.w(TAG,"initializeCallbacks NgnCameraProducer.setPreviewCallbackWithBufferMethod!=null");
try {
NgnCameraProducer.setPreviewCallbackWithBufferMethod.invoke(camera, callback);
} catch (Exception e) {
if(BuildConfig.DEBUG)Log.e(NgnCameraProducer.TAG,"Error in initializeCallbacks"+ e.toString());
}
}
else{
if(BuildConfig.DEBUG)Log.d(TAG,"initializeCallbacks NgnCameraProducer.setPreviewCallbackWithBufferMethod==null");
camera.setPreviewCallback(callback);
}
}else{
if(BuildConfig.DEBUG)Log.w(TAG,"Camera is null in initializeCallbacks");
}
}
private static void deInitializeCallbacks(){
deInitializeCallbacks(NgnCameraProducer.instance);
}
private static void deInitializeCallbacks(Camera camera){
if(camera!= null){
if(NgnCameraProducer.setPreviewCallbackWithBufferMethod != null){
try {
NgnCameraProducer.setPreviewCallbackWithBufferMethod.invoke(camera, new Object[]{ null });
} catch (Exception e) {
Log.e(NgnCameraProducer.TAG, e.toString());
}
}
else{
camera.setPreviewCallback(null);
}
}
}
public static int getNumberOfCameras() {
// 1. Android 2.3 or later
if (NgnApplication.getSDKVersion() >= 9) {
try {
Method getNumberOfCamerasMethod = Camera.class.getDeclaredMethod("getNumberOfCameras");
if (getNumberOfCamerasMethod != null) {
return (Integer) getNumberOfCamerasMethod.invoke(null);
}
} catch (Exception e) {
e.printStackTrace();
}
}
return 1;
}
private static Camera openFrontFacingCamera() throws IllegalArgumentException, IllegalAccessException, InvocationTargetException{
Camera camera = null;
// 1. Android 2.3 or later
if(NgnApplication.getSDKVersion() >= 9){
try {
Method getNumberOfCamerasMethod = Camera.class.getDeclaredMethod("getNumberOfCameras");
if(getNumberOfCamerasMethod != null){
Integer numberOfCameras = (Integer)getNumberOfCamerasMethod.invoke(null);
if(numberOfCameras > 1){
Method openMethod = Camera.class.getDeclaredMethod("open", int.class);
if((camera = (Camera)openMethod.invoke(null, (numberOfCameras - 1))) != null){
return camera;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
//2. From mapper
if((camera = FrontFacingCameraMapper.getPreferredCamera()) != null){
return camera;
}
//3. Use switcher
if(FrontFacingCameraSwitcher.getSwitcher() != null){
camera = Camera.open();
FrontFacingCameraSwitcher.getSwitcher().invoke(camera, (int)1);
return camera;
}
//4. Use parameters
camera = Camera.open();
Camera.Parameters parameters = camera.getParameters();
parameters.set("camera-id", 2);
camera.setParameters(parameters);
return camera;
}
/***
* FrontFacingCameraSwitcher
* @author Mamadou Diop
*
*/
static class FrontFacingCameraSwitcher
{
private static Method DualCameraSwitchMethod;
static{
try{
FrontFacingCameraSwitcher.DualCameraSwitchMethod = Class.forName("android.hardware.Camera").getMethod("DualCameraSwitch",int.class);
}
catch(Exception e){
Log.d(NgnCameraProducer.TAG, e.toString());
}
}
static Method getSwitcher(){
return FrontFacingCameraSwitcher.DualCameraSwitchMethod;
}
}
static class FrontFacingCameraMapper
{
private static int preferredIndex = -1;
static FrontFacingCameraMapper Map[] = {
new FrontFacingCameraMapper("android.hardware.HtcFrontFacingCamera", "getCamera"),
// Sprint: HTC EVO 4G and Samsung Epic 4G
// DO not forget to change the manifest if you are using OS 1.6 and later
new FrontFacingCameraMapper("com.sprint.hardware.twinCamDevice.FrontFacingCamera", "getFrontFacingCamera"),
// Huawei U8230
new FrontFacingCameraMapper("android.hardware.CameraSlave", "open"),
// Default: Used for test reflection
// new FrontFacingCameraMapper("android.hardware.Camera", "open"),
};
static{
int index = 0;
for(FrontFacingCameraMapper ffc: FrontFacingCameraMapper.Map){
try{
Class.forName(ffc.className).getDeclaredMethod(ffc.methodName);
FrontFacingCameraMapper.preferredIndex = index;
break;
}
catch(Exception e){
Log.d(NgnCameraProducer.TAG, e.toString());
}
++index;
}
}
private final String className;
private final String methodName;
FrontFacingCameraMapper(String className, String methodName){
this.className = className;
this.methodName = methodName;
}
static Camera getPreferredCamera(){
if(FrontFacingCameraMapper.preferredIndex == -1){
return null;
}
try{
Method method = Class.forName(FrontFacingCameraMapper.Map[FrontFacingCameraMapper.preferredIndex].className)
.getDeclaredMethod(FrontFacingCameraMapper.Map[FrontFacingCameraMapper.preferredIndex].methodName);
return (Camera)method.invoke(null);
}
catch(Exception e){
Log.e(NgnCameraProducer.TAG, e.toString());
}
return null;
}
}
}