X-Git-Url: http://47.100.26.94:8080/?a=blobdiff_plain;f=app%2Fsrc%2Fmain%2Fjava%2Fai%2Fsuanzi%2Frtmpclient%2FMainActivity.java;h=223740a343ce31e85ea921e9468df1dcb10d3f67;hb=10722545a909e2aa6fbd1dcb26c431fb1a11801f;hp=31fcbf30cbff3899c687698a98c59e9765e0fb3c;hpb=214619593e74f6a04fa25f3614a99cf6b9704da5;p=rtmpclient.git

diff --git a/app/src/main/java/ai/suanzi/rtmpclient/MainActivity.java b/app/src/main/java/ai/suanzi/rtmpclient/MainActivity.java
index 31fcbf3..223740a 100644
--- a/app/src/main/java/ai/suanzi/rtmpclient/MainActivity.java
+++ b/app/src/main/java/ai/suanzi/rtmpclient/MainActivity.java
@@ -1,18 +1,399 @@
 package ai.suanzi.rtmpclient;
 
+import android.content.IntentFilter;
+import android.hardware.Camera;
+import android.net.Uri;
+import android.support.design.widget.TextInputEditText;
+import android.support.v7.app.ActionBar;
 import android.support.v7.app.AppCompatActivity;
 import android.os.Bundle;
+import android.util.DisplayMetrics;
 import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.Button;
+import android.widget.Toast;
+import android.content.Context;
 
-public class MainActivity extends AppCompatActivity {
+import java.io.File;
+import android.content.Intent;
+import de.mindpipe.android.logging.log4j.LogConfigurator;
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
+import android.net.wifi.WifiManager;
+import android.net.wifi.WifiInfo;
+import android.content.ServiceConnection;
+import android.content.ComponentName;
 
-    private static final String TAG = "PENG";
-    private Ffmpeg ffmpeg = new Ffmpeg();
+import ai.suanzi.rtmpclient.MyService.LocalBinder;
+import android.os.IBinder;
+import android.net.ConnectivityManager;
+import android.view.ViewGroup;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.client.methods.CloseableHttpResponse;
 
+//import org.apache.http.client.methods;
+import android.view.MotionEvent;
+import android.graphics.Color;
+import android.os.Build;
+import android.content.pm.ActivityInfo;
+import android.view.Display;
+import android.graphics.Point;
+import android.view.ViewConfiguration;
+import java.lang.reflect.Field;
+import android.view.Menu;
+import android.view.MenuItem;
+
+public class MainActivity extends AppCompatActivity implements MyService.MyServiceEventListener, CameraView.Callback {
+
+    private Logger gLogger;
+    private NetworkMonitor networkMonitor;
+    private UsbMonitor mUsbMonitor;
+    private ServiceHealthMonitor mServiceHealthMonitor;
+    private static final int INTERVAL = 3 * 60; // seconds
+
+    boolean mBounded = false;
+    MyService mServer;
+    Intent mIntent;
+    private boolean isFullScreen = false;
+
+    private CameraView mCameraView;
+
+    private void init(){
+
+        mIntent = new Intent(this, MyService.class);
+        mUsbMonitor = new UsbMonitor(new UsbMonitor.UsbListener() {
+            @Override
+            public void onCameraConnected() {
+                gLogger.error("onCameraConnected, current Usb Camera count: " + mUsbMonitor.getUsbCameraCount());
+                doUnbindService();
+                if(mUsbMonitor.hasUsbCamera()){
+                    doBindService();
+                }
+            }
+
+            @Override
+            public void onCameraDisconnected() {
+                gLogger.error("onCameraDisconnected, current camera count: " + mUsbMonitor.getUsbCameraCount());
+                doUnbindService();
+                if(mUsbMonitor.hasUsbCamera()){
+                    doBindService();
+                }
+            }
+        }, this);
+
+        networkMonitor = new NetworkMonitor(new NetworkMonitor.NetworkListener() {
+            @Override
+            public void onWifiConnected() {
+                gLogger.error("onWifiConnected");
+                doBindService();
+            }
+
+            @Override
+            public void onWifiDisconnected() {
+                gLogger.error("onWifiDisconnected");
+                doUnbindService();
+            }
+
+            @Override
+            public void onWifiEnabled() {
+                gLogger.error("onWifiEnabled");
+            }
+
+            @Override
+            public void onWifiDisabled() {
+                gLogger.error("onWifiDisabled");
+            }
+        });
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
+        registerReceiver(networkMonitor, filter);
+
+        mServiceHealthMonitor = new ServiceHealthMonitor(new ServiceHealthMonitor.Callback() {
+            @Override
+            public void onNotHealthy() {
+                gLogger.error("onNotHealthy, in " + INTERVAL + " seconds, the publishing may stopped or have error ");
+                doUnbindService();
+                doBindService();
+            }
+        });
+        mServiceHealthMonitor.setInterval(INTERVAL);
+    }
+
+
+    ServiceConnection mConnection = new ServiceConnection() {
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            Toast.makeText(MainActivity.this, "Service is disconnected", 1000).show();
+            gLogger.error("onServiceDisconnected ---------->");
+            mBounded = false;
+            mServer = null;
+        }
+
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            Toast.makeText(MainActivity.this, "Service is connected", 1000).show();
+            gLogger.error("onServiceConnected ---------->");
+            mBounded = true;
+            LocalBinder mLocalBinder = (LocalBinder)service;
+            mServer = mLocalBinder.getServiceInstance();
+            mServer.setServiceEventListener(MainActivity.this);
+            if(mServer.setRtmpUrl(UserInfo.toUrl())){
+                mServer.startPreview(mCameraView.getHolder());
+                Camera.Size cs = mServer.getBestPictureSize();
+                mCameraView.setLayout(cs.width, cs.height);
+            } else {
+                gLogger.error("onServiceConnected - setRtmpUrl failed");
+            }
+        }
+    };
+
+    private void doBindService(){
+        gLogger.debug("doBindService");
+        if(!mBounded && canStartService()) {
+            gLogger.debug("Start service --------->");
+            bindService(mIntent, mConnection, BIND_AUTO_CREATE);
+        }
+    }
+
+    private void doUnbindService() {
+        gLogger.debug("doUnbindService");
+        if(mBounded){
+            gLogger.debug("Stop service <---------");
+            unbindService(mConnection);
+            mBounded = false;
+        }
+    }
+
+    private class ScreenSize {
+        public ScreenSize(){ }
+        public int width = 0;
+        public int height = 0;
+    }
+
+    private ScreenSize getScreenSize(){
+        ScreenSize size = new ScreenSize();
+        WindowManager windowManager = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
+        final Display display = windowManager.getDefaultDisplay();
+        Point outPoint = new Point();
+        if(Build.VERSION.SDK_INT >= 19) {
+            display.getRealSize(outPoint); // include navigation bar
+        } else {
+            display.getSize(outPoint); // exclude navigation bar
+        }
+        size.width = outPoint.x;
+        size.height = outPoint.y;
+
+        return size;
+    }
+
+    private void initCameraView (){
+
+        ScreenSize size = getScreenSize();
+        CameraView.SCREEN_WIDTH = size.width;
+        CameraView.SCREEN_HEIGHT = size.height;
+        gLogger.debug("Screen size is w: " + CameraView.SCREEN_WIDTH  + ", h: " + CameraView.SCREEN_HEIGHT);
+
+        mCameraView = new CameraView(getApplicationContext(), this);
+        setContentView(R.layout.activity_main);
+
+        ViewGroup.LayoutParams lp = new ViewGroup.LayoutParams(640, 480);
+        addContentView(mCameraView, lp);
+        //setContentView(mCameraView);
+    }
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_main);
-        Log.e(TAG, "Ffmpeg Version: " + ffmpeg.getVersion());
+        LogUtil.config(this);
+        gLogger = Logger.getLogger(getClass());
+        gLogger.error("onCreate ---------> ");
+        UserInfo.readConfig(getExternalFilesDir(null) + File.separator + "config", getMacAddr());
+        initCameraView();
+        init();
+
+        if(canStartService()){
+            gLogger.error("Current network is available");
+            doBindService();
+        } else {
+            gLogger.error("Current network NOT available or no USB Camera connected");
+        }
+
+        if(!mServiceHealthMonitor.isAlive()) {
+            gLogger.debug("mServiceHealthMonitor start, interval " + INTERVAL);
+            mServiceHealthMonitor.start();
+        }
+        ////////// LogUtil.sendLogs();  /// Log test
+        //LogUtil.sendLogs();
+        // test
+        //new CheckVersionInfoTask(MainActivity.this).execute();
+    }
+
+    @Override
+    protected void onPause(){
+        super.onPause();
+        gLogger.debug("OnPause --------->");
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        gLogger.debug("OnResume ---------> ");
+    }
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        gLogger.debug("onStop --------->");
+    }
+
+    @Override
+    protected void onStart(){
+        super.onStart();
+        gLogger.debug("onStart --------->");
+    }
+
+    @Override
+    protected void onDestroy(){
+        super.onDestroy();
+        mUsbMonitor.unregisterReceiver();
+        unregisterReceiver(networkMonitor);
+        unbindService(mConnection);
+        gLogger.debug("onDestroy --------->");
+    }
+
+    @Override
+    protected void onRestart(){
+        super.onRestart();
+        gLogger.debug("onRestart ---------->");
+    }
+
+    @Override
+    public void onBackPressed() {
+        gLogger.debug("onBackPressed  --------->");
+        Intent intent = new Intent(Intent.ACTION_MAIN);
+        intent.addCategory(Intent.CATEGORY_HOME);
+        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        startActivity(intent);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        if(event.getAction() == MotionEvent.ACTION_UP) {
+            toggleFullScreen();
+        }
+        return super.onTouchEvent(event);
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        if (hasFocus && Build.VERSION.SDK_INT >= 19) {
+            toggleFullScreen();
+        }
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.main, menu);
+        return true;
+    }
+
+    private String getMacAddr() {
+        WifiManager manager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
+        WifiInfo info = manager.getConnectionInfo();
+        gLogger.debug("Mac Address is " + info.getMacAddress());
+        return info.getMacAddress().replace(":", ""); //02:00:00:00:00:00 - 020000000000
+    }
+
+    private boolean canStartService(){
+        if(System.getProperty("os.arch").equals("i686")){
+            return true;
+        }
+        return mUsbMonitor.hasUsbCamera() && NetworkMonitor.isNetworkAvailable(this);
+    }
+
+    // MyServiceEventListener
+    @Override
+    public void onCameraError(String msg){
+        gLogger.error("onCameraEvent " + msg);
+        //if(mUsbMonitor.hasUsbCamera()){
+            //mServer.reopenCamera();
+        //}
+    }
+
+    @Override
+    public void onEncoderError(String msg){
+        gLogger.error("onEncoderError: " + msg);
+        doUnbindService();
+        doBindService();
+    }
+
+    @Override
+    public void onPublishing(String msg){
+        mServiceHealthMonitor.record();
+    }
+
+    @Override
+    public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height){
+        if(mServer != null){
+            mServer.startPreview(holder);
+        }
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item)
+    {
+        switch (item.getItemId()) {
+            case R.id.action_settings:
+                Toast.makeText(MainActivity.this, "setting", Toast.LENGTH_SHORT).show();
+                break;
+            case R.id.action_mail:
+                gLogger.debug("onOptionsItemSelected - send mail button clicked");
+                LogUtil.sendLogs();
+                break;
+            case R.id.action_about:
+                break;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    private void restartApplication() {
+        final Intent intent = getPackageManager().getLaunchIntentForPackage(getPackageName());
+        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        startActivity(intent);
+    }
+
+    private void toggleFullScreen (){
+        View decorView = getWindow().getDecorView();
+        if(!isFullScreen) {
+            decorView.setSystemUiVisibility(
+                    View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                            | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+                            | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+                            | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
+                            | View.SYSTEM_UI_FLAG_FULLSCREEN
+                            | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
+        } else {
+            decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_VISIBLE);
+        }
+        isFullScreen = !isFullScreen;
+    }
+
+    private void getOverflowMenu() {
+
+        try {
+            ViewConfiguration config = ViewConfiguration.get(this);
+            Field menuKeyField = ViewConfiguration.class.getDeclaredField("sHasPermanentMenuKey");
+            if(menuKeyField != null) {
+                menuKeyField.setAccessible(true);
+                menuKeyField.setBoolean(config, false);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
     }
 }