Page History

        remoteRenderLayout.setPosition(0, 0, 100, 100);
    if (mSendAudio.isChecked()) {    remoteRender.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT);
        audioConstraints = new AudioConstraints(remoteRender.setMirror(false);
        if (mUseFEC.isChecked()) {remoteRender.requestLayout();

        localRenderLayout.setPosition(0, 0,   audioConstraints.setUseFEC(true100, 100);
        }localRender.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT);
        if (mUseStereo.isChecked()) {localRender.setMirror(true);
            audioConstraints.setUseStereo(truelocalRender.requestLayout();

        }
   switchRenderLayout.setPosition(0, 0, 100, 100);
     if (!mDefaultPublishAudioBitrate.isChecked() && mDefaultPublishAudioBitratenewSurfaceRenderer.getTextsetZOrderMediaOverlay().length() > 0) {
true);
        newSurfaceRenderer.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT);
       audioConstraints newSurfaceRenderer.setBitrate(Integer.parseInt(mPublishAudioBitrate.getText().toString()))setMirror(true);
        }
    }
    VideoConstraints videoConstraints = null;
    if (mSendVideo.isChecked()) {
        videoConstraints = new VideoConstraints();
        videoConstraints.setCameraId(((MediaDevice) mCameraSpinner.getSpinner().getSelectedItem()).getId());
        if (mCameraFPS.getText().length() > 0) {
            videoConstraints.setVideoFps(Integer.parseInt(mCameraFPS.getText().toString()));
        }
        if (mWidth.getText().length() > 0 && mHeight.getText().length() > 0) {
            videoConstraints.setResolution(Integer.parseInt(mWidth.getText().toString()),
                    Integer.parseInt(mHeight.getText().toString()));
        }
        if (!mDefaultPublishVideoBitrate.isChecked() && mPublishVideoBitrate.getText().length() > 0) {
             videoConstraints.setBitrate(Integer.parseInt(mPublishVideoBitrate.getText().toString()));
        }
    }
    return new Constraints(audioConstraints, videoConstraints);
}

@NonNull
private Constraints getConstraints() {
    AudioConstraints audioConstraints = @Overridenull;
       public void run(if (mSendAudio.isChecked()) {
        audioConstraints = new mStartButton.setText(R.string.action_stopAudioConstraints();
        if   mStartButton.setTag(R.string.action_stop);
(mUseFEC.isChecked()) {
            mStartButtonaudioConstraints.setEnabledsetUseFEC(true);
           mTestButton.setEnabled(false);}
        if   mStatusView.setText(connectionmUseStereo.getStatusisChecked());; {

            /**audioConstraints.setUseStereo(true);
         }
    * The options for the stream to publish are set.
             * The stream name is passed when StreamOptions object is created.if (!mDefaultPublishAudioBitrate.isChecked() && mDefaultPublishAudioBitrate.getText().length() > 0) {
            audioConstraints.setBitrate(Integer.parseInt(mPublishAudioBitrate.getText().toString()));
        }
    }
 * VideoConstraints object isVideoConstraints usedvideoConstraints to= setnull;
 the source camera, FPS and resolution.if (mSendVideo.isChecked()) {
        videoConstraints = new VideoConstraints();
  * Stream constraints are set with method StreamOptions.setConstraints(). videoConstraints.setCameraId(((MediaDevice) mCameraSpinner.getSpinner().getSelectedItem()).getId());
        if (mCameraFPS.getText().length() > 0)  */{
           StreamOptions streamOptions = new StreamOptions(streamName videoConstraints.setVideoFps(Integer.parseInt(mCameraFPS.getText().toString()));
        }
   Constraints constraints = getConstraints();
  if (mWidth.getText().length() > 0      streamOptions.setConstraints(constraints);
  && mHeight.getText().length() > 0) {
         String[] stripCodec = {(String) mStripStreamerCodec.getSpinner videoConstraints.setResolution(Integer.parseInt(mWidth.getText().getSelectedItemtoString()};
),
                    streamOptions.setStripCodecs(stripCodecInteger.parseInt(mHeight.getText().toString()));

        }
   /**
     if (!mDefaultPublishVideoBitrate.isChecked() && mPublishVideoBitrate.getText().length() > 0) {
      *  Stream is created with method Session.createStream(). videoConstraints.setBitrate(Integer.parseInt(mPublishVideoBitrate.getText().toString()));
        }
     */}
    return new      publishStream = session.createStream(streamOptions);
  Constraints(audioConstraints, videoConstraints);
}

case TEST_REQUEST_CODE: {
    if (grantResults.length ==   ...0 ||
       }
   });
}

SessionOptions sessionOptions = new SessionOptions(url);
sessionOptions.setLocalRenderer(localRender);
sessionOptions.setRemoteRenderer(remoteRender);

/**
  * Session for connection to WCS server is created with method createSession().
  */
session = Flashphoner.createSession(sessionOptions);

session.connect(new Connection());

publishStream = session.createStream(streamOptions);
if (mMuteAudio.isChecked()) {
    publishStream.muteAudio();
}
if   */(mMuteVideo.isChecked()) {
             publishStream.muteVideo();
}
...

ActivityCompat.requestPermissions(MediaDevicesActivity.this,
       StreamOptions streamOptions = new StreamOptions(streamName);
new String[]{Manifest.permission.RECORD_AUDIO, Manifest.permission.CAMERA},
         PUBLISH_REQUEST_CODE);

case PUBLISH_REQUEST_CODE: {
         streamOptions.setConstraints(new Constraints(mReceiveAudio.isChecked(), mReceiveVideo.isChecked()));
if (grantResults.length == 0 ||
           grantResults[0] != PackageManager.PERMISSION_GRANTED ||
      VideoConstraints videoConstraints = null;
  grantResults[1] != PackageManager.PERMISSION_GRANTED) {
        mStartButton.setEnabled(false);
       if (mReceiveVideomTestButton.isCheckedsetEnabled(false)) {;
        session.disconnect();
        Log.i(TAG, "Permission has been denied    videoConstraints = new VideoConstraints(by user");
    } else {
        /**
          if (!mDefaultPlayResolution.isChecked() && mPlayWidth.getText().length() > 0 && mPlayHeight.getText().length() > 0) {* Method Stream.publish() is called to publish stream.
          */
        publishStream.publish();
        Log.i(TAG, "Permission has been granted by user");
    }
    videoConstraints.setResolution(Integer.parseInt(mPlayWidth.getText().toString()),break;
}

publishStream.on(new StreamStatusEvent() {
    @Override
    public void onStreamStatus(final Stream stream, final StreamStatus streamStatus) {
            Integer.parseInt(mPlayHeight.getText().toString()));runOnUiThread(new Runnable() {
            @Override
            }
        public void run() {
                if (!mDefaultPlayBitrate.isChecked() && mPlayBitrate.getText().length() > 0StreamStatus.PUBLISHING.equals(streamStatus)) {
                    /**
        videoConstraints.setBitrate(Integer.parseInt(mPlayBitrate.getText().toString()));
              * The options for the stream to play are  }set.
                        if (!mDefaultPlayQuality.isChecked() && mPlayQuality.getText().length() > 0) {
        * The stream name is passed when StreamOptions object is created.
                      videoConstraints.setQuality(Integer.parseInt(mPlayQuality.getText().toString()));*/
                    StreamOptions streamOptions = new }StreamOptions(streamName);

                      }streamOptions.setConstraints(new Constraints(mReceiveAudio.isChecked(), mReceiveVideo.isChecked()));

                    AudioConstraintsVideoConstraints audioConstraintsvideoConstraints = null;
                    if (mReceiveAudiomReceiveVideo.isChecked()) {
                        audioConstraintsvideoConstraints = new AudioConstraintsVideoConstraints();
                        ...
                    }
                    streamOptions.setConstraints(new Constraints(audioConstraints, videoConstraints))AudioConstraints audioConstraints = null;
                    String[] stripCodec = {(String) mStripPlayerCodec.getSpinner().getSelectedItem()};if (mReceiveAudio.isChecked()) {
                    streamOptions.setStripCodecs(stripCodec);
    audioConstraints = new AudioConstraints();
             /**
       }
               * Stream is created with method Session.createStream().streamOptions.setConstraints(new Constraints(audioConstraints, videoConstraints));
                    String[] stripCodec */
  = {(String) mStripPlayerCodec.getSpinner().getSelectedItem()};
                  playStream = sessionstreamOptions.createStreamsetStripCodecs(streamOptionsstripCodec);

                    /**
                      * Callback function for stream status change Stream is addedcreated towith display the statusmethod Session.createStream().
                      */
                    playStream = session.on(new StreamStatusEvent() {createStream(streamOptions);
                        @Override...
                    /**
    public void onStreamStatus(final Stream stream, final StreamStatus streamStatus) {
          * Method Stream.play() is called to start playback of the stream.
        runOnUiThread(new Runnable() {
            */
                    @OverrideplayStream.play();
                    if (mSendVideo.isChecked())
           public void run() {
          mSwitchCameraButton.setEnabled(true);
                          if (!StreamStatus.PLAYING.equals(streamStatus)) {mSwitchRendererButton.setEnabled(true);
                   } else {
                   Log.e(TAG, "Can not playpublish stream " + stream.getName() + " " + streamStatus);
               }
               mStatusView.setText(streamStatus.toString());
           }
       });
    }
});

mSwitchCameraButton.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View view)   }{
        if (publishStream != null) {
                        mStatusView.setText(streamStatus.toString())mSwitchCameraButton.setEnabled(false);
            publishStream.switchCamera(new CameraSwitchHandler() {
                  }@Override
                  public void onCameraSwitchDone(boolean var1) {
      });
              runOnUiThread(new Runnable() {
        }
                @Override
    });

                    /**
public void run() {
                   * Method Stream.play() is called to start playback of the streammSwitchCameraButton.setEnabled(true);
                        */}
                    playStream.play(});
     
               if (mSendVideo.isChecked()) }

                @Override
        mSwitchCameraButton.setEnabled(true);
        public void onCameraSwitchError(String var1) {
        mSwitchRendererButton.setEnabled(true);
               } else runOnUiThread(new Runnable() {
                   Log.e(TAG, "Can not publish stream "@Override
 + stream.getName() + " " + streamStatus);
               }
  public void run() {
          mStatusView.setText(streamStatus.toString());
           }
       }mSwitchCameraButton.setEnabled(true);
    }
});

mSwitchRendererButton.setOnClickListener(new OnClickListener() {
      @Override
    public void onCameraSwitchDoneonClick(booleanView var1v) {
                    runOnUiThread(new Runnableif (spinner.getSelectedItemId() == 0){
            if (isSwitchRemoteRenderer) {
          @Override
      playStream.switchRenderer(remoteRender);
                isSwitchRemoteRenderer  public void run() {= false;
            }
            if    mSwitchCameraButton.setEnabled(true);(!isSwitchLocalRenderer) {
                publishStream.switchRenderer(newSurfaceRenderer);
        }
        isSwitchLocalRenderer = true;
          });

  } else {
            }

    publishStream.switchRenderer(localRender);
            @Override
    isSwitchLocalRenderer = false;
          public void onCameraSwitchError(String var1) {
}
        } else {
            runOnUiThread(newif Runnable(isSwitchLocalRenderer) {
                   publishStream.switchRenderer(localRender);
     @Override
           isSwitchLocalRenderer = false;
           public void}
 run() {
          if (!isSwitchRemoteRenderer) {
                mSwitchCameraButtonplayStream.setEnabledswitchRenderer(truenewSurfaceRenderer);
                isSwitchRemoteRenderer = true;
      }
      } else {
            }    playStream.switchRenderer(remoteRender);
                isSwitchRemoteRenderer }= false;
            });
        }
    }

});

       }
 mSpeakerPhone =          if (!isSwitchRemoteRenderer) {(CheckBox) findViewById(R.id.use_speakerphone);
                playStream.switchRenderer(newSurfaceRenderermSpeakerPhone.setChecked(Flashphoner.getAudioManager().getAudioManager().isSpeakerphoneOn());
                isSwitchRemoteRenderer = true;mSpeakerPhone.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
            }@Override
 else {
          public void onCheckedChanged(CompoundButton buttonView, boolean  playStream.switchRenderer(remoteRender);isChecked) {
                isSwitchRemoteRenderer = falseFlashphoner.getAudioManager().setUseSpeakerPhone(isChecked);
            }
        }
    }
});