import android.app.Service;
import android.content.Intent;
-import android.graphics.SurfaceTexture;
import android.hardware.Camera;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
-import android.os.Looper;
-import android.util.Log;
import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-import android.view.WindowManager;
import android.widget.Toast;
import android.support.v4.app.NotificationCompat;
import android.graphics.BitmapFactory;
import android.app.Notification;
-import android.os.Message;
-import org.apache.log4j.Level;
import org.apache.log4j.Logger;
-import android.hardware.Camera.PreviewCallback;
-import android.os.IBinder;
import android.os.Binder;
-import android.content.Context;
-import android.graphics.PixelFormat;
-import java.io.IOException;
-import android.view.Gravity;
-public class MyService extends Service implements Camera.PreviewCallback {
- private Logger gLogger = Logger.getLogger("MyService");
- private Ffmpeg ffmpeg = Ffmpeg.getInstance();
- private Boolean isRunning = false;
- private FfmpegRunnable runnable;
+public class MyService extends Service implements Camera.PreviewCallback, Camera.ErrorCallback {
+
+ private static Logger gLogger = Logger.getLogger("MyService");
private Camera mCamera = null;
IBinder mBinder = new LocalBinder();
- private WindowManager mWindowManager;
- private SurfaceView mOutComeVideoView;
+ //private String rtmpUrl;
+ private long frameCount = 0;
+
+ // Preferred picture Size of the camera;
+ private Camera.Size mPreferredSize;
+ private MyServiceEventListener mListener;
+ public void setServiceEventListener(MyServiceEventListener listener){
+ mListener = listener;
+ }
+
public class LocalBinder extends Binder {
public MyService getServiceInstance(){
return MyService.this;
}
}
- private class FfmpegRunnable implements Runnable {
- private String url;
- private Camera.PreviewCallback cb;
- public FfmpegRunnable(String _url, Camera.PreviewCallback _cb){
- this.url = _url;
- this.cb = _cb;
- }
- @Override
- public void run(){
- gLogger.error("Run Ffmpeg url: " + url);
- isRunning = true;
- //ffmpeg.push(null, this.url);
- if (mCamera == null) {
- gLogger.error("open camea");
- try {
- mCamera = Camera.open(1);
- }catch (Exception e){
- e.printStackTrace();
+ public Camera getCameraInstance() {
+ if (mCamera == null) {
+ CameraHandlerThread mThread = new CameraHandlerThread("ThreadCamera");
+ synchronized (mThread) {
+ mThread.openCamera();
+ }
+ }
+ return mCamera;
+ }
+
+ private void openCameraOriginal() {
+ try {
+ gLogger.error("openCameraOriginal");
+ Camera.CameraInfo info = new Camera.CameraInfo();
+ int numCameras = Camera.getNumberOfCameras();
+ int backId = -1;
+ int frontId = -1;
+ int camerId = 0;
+ gLogger.debug("Number of Cameras is " + numCameras);
+ for(int i = 0; i < numCameras; i++){
+ Camera.getCameraInfo(i, info);
+ if(info.facing == Camera.CameraInfo.CAMERA_FACING_BACK){
+ gLogger.debug("CAMERA_FACING_BACK id is " + i);
+ backId = i;
+ } else if(info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT){
+ gLogger.debug("CAMERA_FACING_FRONT id is " + i);
+ frontId = i;
}
}
- /*
- SurfaceTexture st = new SurfaceTexture(0);
- try {
- mCamera.setPreviewTexture(st);
- }catch (Exception e){
- e.printStackTrace();
- }*/
- gLogger.error("start preview");
- mCamera.setPreviewCallback(this.cb);
- mCamera.startPreview();
+ if(frontId != -1) camerId = frontId;
+ else if(backId != -1) camerId = backId;
+ gLogger.debug("openCameraOriginal - camera id " + camerId);
+ mCamera = Camera.open(1);
+ } catch (Exception e) {
+ gLogger.error("openCameraOriginal - camera is not available. error: " + e.getMessage());
+ if(mListener != null) mListener.onCameraError("openCamera - error: " + e.getMessage());
+ }
+ }
+
+ private class CameraHandlerThread extends HandlerThread {
+ Handler mHandler;
+
+ public CameraHandlerThread(String name) {
+ super(name);
+ gLogger.error("CameraHandlerThread: " + name);
+ start();
+ mHandler = new Handler(getLooper());
+ }
+ synchronized void notifyCameraOpened() {
+ notify();
+ gLogger.debug("notifyCameraOpened");
+ }
+
+ void openCamera() {
+ mHandler.post(new Runnable() {
+ @Override
+ public void run() {
+ openCameraOriginal();
+ notifyCameraOpened();
+ }
+ });
+ try {
+ wait();
+ } catch (InterruptedException e) {
+ gLogger.error("wait was interrupted, " + e.getMessage());
+ }
}
}
private static final int NOTIFICATION_DOWNLOAD_PROGRESS_ID = 0x0001; //id不可设置为0,否则不能设置为前台service
private void createNotification(){
- gLogger.error("createNotification");
+ gLogger.debug("createNotification");
NotificationCompat.Builder builder=new NotificationCompat.Builder(this); //使用兼容版本
builder.setSmallIcon(R.mipmap.ic_launcher); //设置状态栏的通知图标
builder.setLargeIcon(BitmapFactory.decodeResource(getResources(),R.drawable.ic_launcher_background)); //设置通知栏横条的图标
@Override
public void onCreate() {
super.onCreate();
- gLogger.error("onCreate");
-
-
-// mWindowManager = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
-// mOutComeVideoView = new SurfaceView(this);
-//
-//
-// WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams(1, 1, WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
-// WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH, PixelFormat.TRANSLUCENT);
-// layoutParams.gravity = Gravity.LEFT | Gravity.TOP;
-// mWindowManager.addView(mOutComeVideoView, layoutParams);
-// mOutComeVideoView.getHolder().addCallback(this);
-//
-//
+ gLogger.error("onCreate ---> ");
createNotification();
- runnable = new FfmpegRunnable("xxxxxx", this);
- new Thread(runnable).start();
-
-
-
+ Toast.makeText(this, "Started to Publish!", Toast.LENGTH_LONG).show();
+ mCamera = getCameraInstance();
+ if(mCamera != null){
+ configCamera(mCamera);
+ mCamera.setErrorCallback(this);
+ }
}
@Override
public void onDestroy() {
stopForeground(true);
- Toast.makeText(this, "MyService Stopped", Toast.LENGTH_LONG).show();
- gLogger.error( "onDestroy");
super.onDestroy();
-
+ gLogger.error( "onDestroy --------->");
+ Toast.makeText(this, "MyService Stopped", Toast.LENGTH_LONG).show();
+ if(mCamera != null){
+ try {
+ mCamera.stopPreview();
+ mCamera.setPreviewCallback(null);
+ mCamera.release();
+ mCamera = null;
+ } catch (Exception e){
+ gLogger.error("onDestroy - error " + e.getMessage());
+ e.printStackTrace();
+ }
+ }
}
- @Override
- public void onStart(Intent intent, int startid){
- super.onStart(intent, startid);
- gLogger.error("onStart");
-
- }
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
- String url = "hahahahhah"; //intent.getExtras().getString("url");
-
-
- gLogger.error("onStartCommand: url is:" + url + ". isRunning: " + isRunning);
- runnable = new FfmpegRunnable(url, this);
- if (!isRunning) {
- createNotification();
- Toast.makeText(this, "Video stream pushed to " + url, Toast.LENGTH_LONG).show();
- new Thread(runnable).start();
- }
+ gLogger.error("onStartCommand");
return START_STICKY;
}
// Camera.PreviewCallback
@Override
public void onPreviewFrame(final byte[] data, Camera camera){
- gLogger.error("onPreviewFrame");
- ffmpeg.process(data);
+ if(frameCount % (15 * 60) == 0) {
+ gLogger.error("onPreviewFrame");
+ }
+ if(FfmpegHelper.processFrame(data) != 0){
+ gLogger.error("onPreviewFrame, processFrame close");
+ FfmpegHelper.close();
+ if(mListener != null) mListener.onEncoderError("processFrame");
+ } else {
+ if(frameCount % (15 * 60) == 0){
+ if(mListener != null) mListener.onPublishing("processFrame OK");
+ }
+ }
+ frameCount++;
}
- public void onChange (SurfaceHolder holder){
- gLogger.error("onChange");
+ public void startPreview (SurfaceHolder holder){
+ gLogger.debug("startPreview");
+ if(mCamera == null){
+ gLogger.error("startPreview - error: camera is null");
+ return;
+ }
try {
- if (holder == null){
- gLogger.error("xxxx holder is null xxxxxx");
- }
- if (mCamera == null) {
- gLogger.error("xxxx camera is null xxxx");
- }
-
+ mCamera.setPreviewCallback(this);
mCamera.setPreviewDisplay(holder);
mCamera.startPreview();
} catch (Exception e){
+ gLogger.error("startPreview - error: " + e.getMessage());
e.printStackTrace();
+ if(mListener != null) mListener.onCameraError("setPreviewDisplay - " + e.getMessage());
}
}
+ public void reopenCamera() {
+ gLogger.debug("reopenCamera");
+ if(mCamera != null){
+ mCamera.stopPreview();
+ mCamera.release();
+ mCamera = null;
+ }
+ openCameraOriginal();
+ }
+ public boolean setRtmpUrl (String url){
+ if(mCamera == null) {
+ gLogger.error("setRtmpUrl mCamera is null");
+ return false;
+ } else if (mPreferredSize == null) {
+ gLogger.error("setRtmpUrl mPreferredSize is null");
+ return false;
+ }
+ gLogger.error("setRtmpUrl - size: " + mPreferredSize.width + "x" + mPreferredSize.height + ". url: " + url);
+ int ret = FfmpegHelper.initEncoder(mPreferredSize.width, mPreferredSize.height, url);
+ if(ret != 0){
+ gLogger.error("setRtmpUrl, initEncoder error");
+ }
+ return ret == 0;
+ }
+
+ private void configCamera(Camera camera){
+ Camera.Parameters paras = null;
+ try {
+ paras = camera.getParameters();
+ } catch (RuntimeException e){
+ gLogger.error("configCamera - " + e.getMessage());
+ if(mListener != null) mListener.onCameraError("getParameters - " + e.getMessage());
+ return;
+ }
+ gLogger.error("Supported Picture Sizes:");
+ Camera.Size preferredSize = paras.getSupportedPictureSizes().get(0);
+ for (Camera.Size cc : paras.getSupportedPictureSizes()){
+ if (cc.width == 640) // chose 640 x 480 if exists
+ preferredSize = cc;
+ gLogger.error(cc.width + "x" + cc.height);
+ }
+ gLogger.error("Supported Preview fps range:");
+ for(int[] i : paras.getSupportedPreviewFpsRange()){
+ gLogger.error("[" + i[0] + "," + i[1] + "]");
+ }
+ mPreferredSize = preferredSize;
+ paras.setPictureSize(preferredSize.width, preferredSize.height); // use 640x480 preferred
+ camera.setParameters(paras);
+ camera.setDisplayOrientation(0);
+ gLogger.error("Preview Format: " + paras.getPreviewFormat() + ". Size: " + paras.getPreviewSize().width + "x" + paras.getPreviewSize().height);
+ gLogger.error("Picture Format: " + paras.getPictureFormat() + ". Size: " + paras.getPictureSize().width + "x" + paras.getPictureSize().height);
+ camera.setPreviewCallback(this);
+ }
+
+ public Camera.Size getBestPictureSize(){
+ return mPreferredSize;
+ }
+
+ // Camaer.onError callback
+ @Override
+ public void onError(int error, Camera camera){
+ gLogger.error("Camera.OnError, " + error);
+ switch (error) {
+ case Camera.CAMERA_ERROR_SERVER_DIED:
+ gLogger.error("CAMERA_ERROR_SERVER_DIED");
+ break;
+ case Camera.CAMERA_ERROR_UNKNOWN:
+ gLogger.error("CAMERA_ERROR_UNKNOWN");
+ break;
+ }
-// // SurfaceHolder.Callback implementation
-// @Override
-// public void surfaceCreated(final SurfaceHolder holder){
-// gLogger.error("SurfacedCreated");
-// }
-//
-// @Override
-// public void surfaceChanged(SurfaceHolder holder, int format, int widht, int height){
-// gLogger.error("surfaceChanged");
-// try {
-// mCamera.setPreviewDisplay(holder);
-// } catch (Exception e){
-// e.printStackTrace();
-// }
-// mCamera.startPreview();
-//
-// }
-//
-// @Override
-// public void surfaceDestroyed(SurfaceHolder holder){
-// gLogger.error("surfaceDestroyed");
-// }
+ if(mListener != null) mListener.onCameraError("OnError, " + error);
+ }
+
+
+ public interface MyServiceEventListener {
+ void onCameraError(String err);
+ void onEncoderError(String msg);
+ //void onIsPreviewing(String msg); // notify mainActivity if preview is running well
+ void onPublishing(String msg); // notify main activity if encoder is running well;
+ }
}