Support for video file instead of camera and output video out to file

webrtc/examples/androidapp/src/org/appspot/apprtc/ConnectActivity.java

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 126 matching lines @@
     connectButton = (ImageButton) findViewById(R.id.connect_button);
     connectButton.setOnClickListener(connectListener);
     addFavoriteButton = (ImageButton) findViewById(R.id.add_favorite_button);
     addFavoriteButton.setOnClickListener(addFavoriteListener);
 
     // If an implicit VIEW intent is launching the app, go directly to that URL.
     final Intent intent = getIntent();
     if ("android.intent.action.VIEW".equals(intent.getAction()) && !commandLineRun) {
       boolean loopback = intent.getBooleanExtra(CallActivity.EXTRA_LOOPBACK, false);
       int runTimeMs = intent.getIntExtra(CallActivity.EXTRA_RUNTIME, 0);
+      boolean useValuesFromIntent = intent.getBooleanExtra(
+          CallActivity.EXTRA_USE_VALUES_FROM_INTENT, false);
       String room = sharedPref.getString(keyprefRoom, "");
-      connectToRoom(room, true, loopback, runTimeMs);
+      connectToRoom(room, true, loopback, useValuesFromIntent, runTimeMs);
     }
   }
 
   @Override
   public boolean onCreateOptionsMenu(Menu menu) {
     getMenuInflater().inflate(R.menu.connect_menu, menu);
     return true;
   }
 
   @Override
@@ skipping 24 matching lines @@
   }
 
   @Override
   public boolean onOptionsItemSelected(MenuItem item) {
     // Handle presses on the action bar items.
     if (item.getItemId() == R.id.action_settings) {
       Intent intent = new Intent(this, SettingsActivity.class);
       startActivity(intent);
       return true;
     } else if (item.getItemId() == R.id.action_loopback) {
-      connectToRoom(null, false, true, 0);
+      connectToRoom(null, false, true, false, 0);
       return true;
     } else {
       return super.onOptionsItemSelected(item);
     }
   }
 
   @Override
   public void onPause() {
     super.onPause();
     String room = roomEditText.getText().toString();
@@ skipping 32 matching lines @@
   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
     if (requestCode == CONNECTION_REQUEST && commandLineRun) {
       Log.d(TAG, "Return: " + resultCode);
       setResult(resultCode);
       commandLineRun = false;
       finish();
     }
   }
 
+  /**
+   * Get a value from the shared preference or from the intent, if it does not
+   * exist the default is used.
+   */
+  private String sharedPrefGetString(int attributeId, String intentName,
+      int defaultId, boolean useFromIntent) {
+    String defaultValue = getString(defaultId);
+    if (useFromIntent) {
+      String value = getIntent().getStringExtra(intentName);
+      if (value != null) {
+        return value;
+      }
+      return defaultValue;
+    } else {
+      String attributeName = getString(attributeId);
+      return sharedPref.getString(attributeName, defaultValue);
+    }
+  }
+
+  /**
+   * Get a value from the shared preference or from the intent, if it does not
+   * exist the default is used.
+   */
+  private boolean sharedPrefGetBoolean(int attributeId, String intentName,
+      int defaultId, boolean useFromIntent) {
+    boolean defaultValue = Boolean.valueOf(getString(defaultId));
+    if (useFromIntent) {
+      return getIntent().getBooleanExtra(intentName, defaultValue);
+    } else {
+      String attributeName = getString(attributeId);
+      return sharedPref.getBoolean(attributeName, defaultValue);
+    }
+  }
+
   private void connectToRoom(
-      String roomId, boolean commandLineRun, boolean loopback, int runTimeMs) {
+      String roomId, boolean commandLineRun, boolean loopback,
+      boolean useValuesFromIntent, int runTimeMs) {
     this.commandLineRun = commandLineRun;
 
     // roomId is random for loopback.
     if (loopback) {
       roomId = Integer.toString((new Random()).nextInt(100000000));
     }
 
     String roomUrl = sharedPref.getString(
         keyprefRoomServerUrl, getString(R.string.pref_room_server_url_default));
 
     // Video call enabled flag.
-    boolean videoCallEnabled = sharedPref.getBoolean(
-        keyprefVideoCallEnabled, Boolean.valueOf(getString(R.string.pref_videocall_default)));
+    boolean videoCallEnabled = sharedPrefGetBoolean(
+        R.string.pref_videocall_key,
+        CallActivity.EXTRA_VIDEO_CALL,
+        R.string.pref_videocall_default,
+        useValuesFromIntent);
 
     // Use Camera2 option.
-    boolean useCamera2 = sharedPref.getBoolean(
-        keyprefCamera2, Boolean.valueOf(getString(R.string.pref_camera2_default)));
+    boolean useCamera2 = sharedPrefGetBoolean(
+        R.string.pref_camera2_key,
+        CallActivity.EXTRA_CAMERA2,
+        R.string.pref_camera2_default,
+        useValuesFromIntent);
 
     // Get default codecs.
-    String videoCodec =
-        sharedPref.getString(keyprefVideoCodec, getString(R.string.pref_videocodec_default));
-    String audioCodec =
-        sharedPref.getString(keyprefAudioCodec, getString(R.string.pref_audiocodec_default));
+    String videoCodec = sharedPrefGetString(
+        R.string.pref_videocodec_key,
+        CallActivity.EXTRA_VIDEOCODEC,
+        R.string.pref_videocodec_default,
+        useValuesFromIntent);
+    String audioCodec = sharedPrefGetString(
+        R.string.pref_audiocodec_key,
+        CallActivity.EXTRA_AUDIOCODEC,
+        R.string.pref_audiocodec_default,
+        useValuesFromIntent);
 
     // Check HW codec flag.
-    boolean hwCodec = sharedPref.getBoolean(
-        keyprefHwCodecAcceleration, Boolean.valueOf(getString(R.string.pref_hwcodec_default)));
+    boolean hwCodec = sharedPrefGetBoolean(
+        R.string.pref_hwcodec_key,
+        CallActivity.EXTRA_HWCODEC_ENABLED,
+        R.string.pref_hwcodec_default,
+        useValuesFromIntent);
 
     // Check Capture to texture.
-    boolean captureToTexture = sharedPref.getBoolean(keyprefCaptureToTexture,
-        Boolean.valueOf(getString(R.string.pref_capturetotexture_default)));
+    boolean captureToTexture = sharedPrefGetBoolean(
+        R.string.pref_capturetotexture_key,
+        CallActivity.EXTRA_CAPTURETOTEXTURE_ENABLED,
+        R.string.pref_capturetotexture_default,
+        useValuesFromIntent);
 
     // Check Disable Audio Processing flag.
-    boolean noAudioProcessing = sharedPref.getBoolean(keyprefNoAudioProcessingPipeline,
-        Boolean.valueOf(getString(R.string.pref_noaudioprocessing_default)));
+    boolean noAudioProcessing = sharedPrefGetBoolean(
+        R.string.pref_noaudioprocessing_key,
+        CallActivity.EXTRA_NOAUDIOPROCESSING_ENABLED,
+        R.string.pref_noaudioprocessing_default,
+        useValuesFromIntent);
 
     // Check Disable Audio Processing flag.
-    boolean aecDump = sharedPref.getBoolean(
-        keyprefAecDump, Boolean.valueOf(getString(R.string.pref_aecdump_default)));
+    boolean aecDump = sharedPrefGetBoolean(
+        R.string.pref_aecdump_key,
+        CallActivity.EXTRA_AECDUMP_ENABLED,
+        R.string.pref_aecdump_default,
+        useValuesFromIntent);
 
     // Check OpenSL ES enabled flag.
-    boolean useOpenSLES = sharedPref.getBoolean(
-        keyprefOpenSLES, Boolean.valueOf(getString(R.string.pref_opensles_default)));
+    boolean useOpenSLES = sharedPrefGetBoolean(
+        R.string.pref_opensles_key,
+        CallActivity.EXTRA_OPENSLES_ENABLED,
+        R.string.pref_opensles_default,
+        useValuesFromIntent);
 
     // Check Disable built-in AEC flag.
-    boolean disableBuiltInAEC = sharedPref.getBoolean(keyprefDisableBuiltInAec,
-        Boolean.valueOf(getString(R.string.pref_disable_built_in_aec_default)));
+    boolean disableBuiltInAEC = sharedPrefGetBoolean(
+        R.string.pref_disable_built_in_aec_key,
+        CallActivity.EXTRA_DISABLE_BUILT_IN_AEC,
+        R.string.pref_disable_built_in_aec_default,
+        useValuesFromIntent);
 
     // Check Disable built-in AGC flag.
-    boolean disableBuiltInAGC = sharedPref.getBoolean(keyprefDisableBuiltInAgc,
-        Boolean.valueOf(getString(R.string.pref_disable_built_in_agc_default)));
+    boolean disableBuiltInAGC = sharedPrefGetBoolean(
+        R.string.pref_disable_built_in_agc_key,
+        CallActivity.EXTRA_DISABLE_BUILT_IN_AGC,
+        R.string.pref_disable_built_in_agc_default,
+        useValuesFromIntent);
 
     // Check Disable built-in NS flag.
-    boolean disableBuiltInNS = sharedPref.getBoolean(keyprefDisableBuiltInNs,
-        Boolean.valueOf(getString(R.string.pref_disable_built_in_ns_default)));
+    boolean disableBuiltInNS = sharedPrefGetBoolean(
+        R.string.pref_disable_built_in_ns_key,
+        CallActivity.EXTRA_DISABLE_BUILT_IN_NS,
+        R.string.pref_disable_built_in_ns_default,
+        useValuesFromIntent);
 
     // Check Enable level control.
-    boolean enableLevelControl = sharedPref.getBoolean(keyprefEnableLevelControl,
-        Boolean.valueOf(getString(R.string.pref_enable_level_control_key)));
+    boolean enableLevelControl = sharedPrefGetBoolean(
+        R.string.pref_enable_level_control_key,
+        CallActivity.EXTRA_ENABLE_LEVEL_CONTROL,
+        R.string.pref_enable_level_control_key,
+        useValuesFromIntent);
 
     // Get video resolution from settings.
     int videoWidth = 0;
     int videoHeight = 0;
-    String resolution =
-        sharedPref.getString(keyprefResolution, getString(R.string.pref_resolution_default));
-    String[] dimensions = resolution.split("[ x]+");
-    if (dimensions.length == 2) {
-      try {
-        videoWidth = Integer.parseInt(dimensions[0]);
-        videoHeight = Integer.parseInt(dimensions[1]);
-      } catch (NumberFormatException e) {
-        videoWidth = 0;
-        videoHeight = 0;
-        Log.e(TAG, "Wrong video resolution setting: " + resolution);
+    if (useValuesFromIntent) {
+      videoWidth = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_WIDTH, 0);
+      videoHeight = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_HEIGHT, 0);
+    }
+    if (videoWidth == 0 && videoHeight == 0) {
+      String resolution = sharedPref.getString(
+          keyprefResolution,
+          getString(R.string.pref_resolution_default));
+      String[] dimensions = resolution.split("[ x]+");
+      if (dimensions.length == 2) {
+        try {
+          videoWidth = Integer.parseInt(dimensions[0]);
+          videoHeight = Integer.parseInt(dimensions[1]);
+        } catch (NumberFormatException e) {
+          videoWidth = 0;
+          videoHeight = 0;
+          Log.e(TAG, "Wrong video resolution setting: " + resolution);
+        }
       }
     }
 
     // Get camera fps from settings.
     int cameraFps = 0;
-    String fps = sharedPref.getString(keyprefFps, getString(R.string.pref_fps_default));
-    String[] fpsValues = fps.split("[ x]+");
-    if (fpsValues.length == 2) {
-      try {
-        cameraFps = Integer.parseInt(fpsValues[0]);
-      } catch (NumberFormatException e) {
-        Log.e(TAG, "Wrong camera fps setting: " + fps);
+    if (useValuesFromIntent) {
+      cameraFps = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_FPS, 0);
+    }
+    if (cameraFps == 0) {
+      String fps = sharedPref.getString(keyprefFps,
+          getString(R.string.pref_fps_default));
+      String[] fpsValues = fps.split("[ x]+");
+      if (fpsValues.length == 2) {
+        try {
+          cameraFps = Integer.parseInt(fpsValues[0]);
+        } catch (NumberFormatException e) {
+          cameraFps = 0;
+          Log.e(TAG, "Wrong camera fps setting: " + fps);
+        }
       }
     }
 
     // Check capture quality slider flag.
-    boolean captureQualitySlider = sharedPref.getBoolean(keyprefCaptureQualitySlider,
-        Boolean.valueOf(getString(R.string.pref_capturequalityslider_default)));
+    boolean captureQualitySlider = sharedPrefGetBoolean(
+        R.string.pref_capturequalityslider_key,
+        CallActivity.EXTRA_VIDEO_CAPTUREQUALITYSLIDER_ENABLED,
+        R.string.pref_capturequalityslider_default,
+        useValuesFromIntent);
 
     // Get video and audio start bitrate.
     int videoStartBitrate = 0;
-    String bitrateTypeDefault = getString(R.string.pref_maxvideobitrate_default);
-    String bitrateType = sharedPref.getString(keyprefVideoBitrateType, bitrateTypeDefault);
-    if (!bitrateType.equals(bitrateTypeDefault)) {
-      String bitrateValue = sharedPref.getString(
-          keyprefVideoBitrateValue, getString(R.string.pref_maxvideobitratevalue_default));
-      videoStartBitrate = Integer.parseInt(bitrateValue);
+    if (useValuesFromIntent) {
+      videoStartBitrate = getIntent().getIntExtra(CallActivity.EXTRA_VIDEO_BITRATE, 0);
     }
+    if (videoStartBitrate == 0) {
+      String bitrateTypeDefault = getString(
+          R.string.pref_maxvideobitrate_default);
+      String bitrateType = sharedPref.getString(
+          keyprefVideoBitrateType, bitrateTypeDefault);
+      if (!bitrateType.equals(bitrateTypeDefault)) {
+        String bitrateValue = sharedPref.getString(keyprefVideoBitrateValue,
+            getString(R.string.pref_maxvideobitratevalue_default));
+        videoStartBitrate = Integer.parseInt(bitrateValue);
+      }
+    }
+
     int audioStartBitrate = 0;
-    bitrateTypeDefault = getString(R.string.pref_startaudiobitrate_default);
-    bitrateType = sharedPref.getString(keyprefAudioBitrateType, bitrateTypeDefault);
-    if (!bitrateType.equals(bitrateTypeDefault)) {
-      String bitrateValue = sharedPref.getString(
-          keyprefAudioBitrateValue, getString(R.string.pref_startaudiobitratevalue_default));
-      audioStartBitrate = Integer.parseInt(bitrateValue);
+    if (useValuesFromIntent) {
+      audioStartBitrate = getIntent().getIntExtra(CallActivity.EXTRA_AUDIO_BITRATE, 0);
+    }
+    if (audioStartBitrate == 0) {
+      String bitrateTypeDefault = getString(R.string.pref_startaudiobitrate_default);
+      String bitrateType = sharedPref.getString(
+          keyprefAudioBitrateType, bitrateTypeDefault);
+      if (!bitrateType.equals(bitrateTypeDefault)) {
+        String bitrateValue = sharedPref.getString(keyprefAudioBitrateValue,
+            getString(R.string.pref_startaudiobitratevalue_default));
+        audioStartBitrate = Integer.parseInt(bitrateValue);
+      }
     }
 
     // Check statistics display option.
-    boolean displayHud = sharedPref.getBoolean(
-        keyprefDisplayHud, Boolean.valueOf(getString(R.string.pref_displayhud_default)));
+    boolean displayHud = sharedPrefGetBoolean(
+        R.string.pref_displayhud_key,
+        CallActivity.EXTRA_DISPLAY_HUD,
+        R.string.pref_displayhud_default,
+        useValuesFromIntent);
 
-    boolean tracing = sharedPref.getBoolean(
-        keyprefTracing, Boolean.valueOf(getString(R.string.pref_tracing_default)));
+    boolean tracing = sharedPrefGetBoolean(
+        R.string.pref_tracing_key,
+        CallActivity.EXTRA_TRACING,
+        R.string.pref_tracing_default,
+        useValuesFromIntent);
 
     // Start AppRTCMobile activity.
     Log.d(TAG, "Connecting to room " + roomId + " at URL " + roomUrl);
     if (validateUrl(roomUrl)) {
       Uri uri = Uri.parse(roomUrl);
       Intent intent = new Intent(this, CallActivity.class);
       intent.setData(uri);
       intent.putExtra(CallActivity.EXTRA_ROOMID, roomId);
       intent.putExtra(CallActivity.EXTRA_LOOPBACK, loopback);
       intent.putExtra(CallActivity.EXTRA_VIDEO_CALL, videoCallEnabled);
@@ skipping 13 matching lines @@
       intent.putExtra(CallActivity.EXTRA_DISABLE_BUILT_IN_AGC, disableBuiltInAGC);
       intent.putExtra(CallActivity.EXTRA_DISABLE_BUILT_IN_NS, disableBuiltInNS);
       intent.putExtra(CallActivity.EXTRA_ENABLE_LEVEL_CONTROL, enableLevelControl);
       intent.putExtra(CallActivity.EXTRA_AUDIO_BITRATE, audioStartBitrate);
       intent.putExtra(CallActivity.EXTRA_AUDIOCODEC, audioCodec);
       intent.putExtra(CallActivity.EXTRA_DISPLAY_HUD, displayHud);
       intent.putExtra(CallActivity.EXTRA_TRACING, tracing);
       intent.putExtra(CallActivity.EXTRA_CMDLINE, commandLineRun);
       intent.putExtra(CallActivity.EXTRA_RUNTIME, runTimeMs);
 
+      if (useValuesFromIntent) {
+        if (getIntent().hasExtra(CallActivity.EXTRA_VIDEO_FILE_AS_CAMERA)) {
+          String videoFileAsCamera = getIntent().getStringExtra(
+              CallActivity.EXTRA_VIDEO_FILE_AS_CAMERA);
+          intent.putExtra(CallActivity.EXTRA_VIDEO_FILE_AS_CAMERA,
+              videoFileAsCamera);
+        }
+
+        if (getIntent().hasExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE)) {
+          String saveRemoteVideoToFile = getIntent().getStringExtra(
+              CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE);
+          intent.putExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE,
+              saveRemoteVideoToFile);
+        }
+
+        if (getIntent().hasExtra(
+              CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH)) {
+          int videoOutWidth = getIntent().getIntExtra(
+              CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH, 0);
+          intent.putExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH,
+              videoOutWidth);
+        }
+
+        if (getIntent().hasExtra(
+              CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT)) {
+          int videoOutHeight = getIntent().getIntExtra(
+              CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT, 0);
+          intent.putExtra(CallActivity.EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT,
+              videoOutHeight);
+        }
+      }
+
       startActivityForResult(intent, CONNECTION_REQUEST);
     }
   }
 
   private boolean validateUrl(String url) {
     if (URLUtil.isHttpsUrl(url) || URLUtil.isHttpUrl(url)) {
       return true;
     }
 
     new AlertDialog.Builder(this)
         .setTitle(getText(R.string.invalid_url_title))
         .setMessage(getString(R.string.invalid_url_text, url))
         .setCancelable(false)
         .setNeutralButton(R.string.ok,
             new DialogInterface.OnClickListener() {
               public void onClick(DialogInterface dialog, int id) {
                 dialog.cancel();
               }
             })
         .create()
         .show();
     return false;
   }
 
   private final AdapterView.OnItemClickListener roomListClickListener =
       new AdapterView.OnItemClickListener() {
         @Override
         public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
           String roomId = ((TextView) view).getText().toString();
-          connectToRoom(roomId, false, false, 0);
+          connectToRoom(roomId, false, false, false, 0);
         }
       };
 
   private final OnClickListener addFavoriteListener = new OnClickListener() {
     @Override
     public void onClick(View view) {
       String newRoom = roomEditText.getText().toString();
       if (newRoom.length() > 0 && !roomList.contains(newRoom)) {
         adapter.add(newRoom);
         adapter.notifyDataSetChanged();
       }
     }
   };
 
   private final OnClickListener connectListener = new OnClickListener() {
     @Override
     public void onClick(View view) {
-      connectToRoom(roomEditText.getText().toString(), false, false, 0);
+      connectToRoom(roomEditText.getText().toString(), false, false, false, 0);
     }
   };
 }