How to Integrate Screen Share in Kotlin Video Chat App for Android?

Introduction

Ever need to show others exactly what's on your mobile screen during a video call? If your answer is 'Yes!', then you need to know that this very important feature is called Screen Sharing. Screen sharing is the process of showing your smartphone screen to the other participants. It enables everyone in the conference to view precisely what you see on your screen, which is useful for presentations, demos, and collaborations.

Integrating the Screen Share feature into your video app offers various possibilities for improved collaboration and communication. Whether delivering presentations or collaborating on projects, the Screen Share functionality allows users to easily share their displays during video chats.

Android developers may create compelling and interactive video experiences for users by following the steps below and leveraging VideoSDK's capabilities. Start implementing the Screen Share feature immediately to transform your video app's functionality and user engagement.

🎯 Goals

By the End of this Article:

Create a VideoSDK account and generate your VideoSDK auth token.
Integrate the VideoSDK library and dependencies into your project.
Implement core functionalities for video calls using VideoSDK.
Enable Screen Sharing Feature.

🚀 Getting Started with VideoSDK

To take advantage of the screen share functionality, we will need to use the capabilities that the VideoSDK offers. Before we dive into the implementation steps, let's make sure you complete the necessary prerequisites.

🔐 Create a VideoSDK Account

Go to your VideoSDK dashboard OR Sign Up (if you don't have an account). This account gives you access to the required Video SDK token, which acts as an authentication key that allows your application to interact with VideoSDK functionality.

🔑 Generate your Auth Token

Visit your VideoSDK dashboard and navigate to the "API Key" section to generate your auth token. This token plays a crucial role in authorizing your application to use VideoSDK features.

For a more visual understanding of the account creation and token generation process, consider referring to the provided tutorial.

🛠️ Prerequisites and Setup

Make sure your development environment meets the following requirements:

Java Development Kit is supported.
Android Studio version 3.0 or later.
Android SDK API level 21 or higher.
A mobile device with Android 5.0 or later version.

🔌 Integrate VideoSDK

Following the account creation and token generation steps, we'll guide you through the process of adding the VideoSDK library and other dependencies to your project. We'll also ensure your app has the required permissions to access features like audio recording, camera usage, and internet connectivity, all crucial for a seamless video experience.

STEP (a): Add the repositories to the project's`settings.gradle` file.

dependencyResolutionManagement {
  repositories {
    // ...
    google()
    mavenCentral()
    maven { url '<https://jitpack.io>' }
    maven { url "<https://maven.aliyun.com/repository/jcenter>" }
  }
}

STEP (b): Include the following dependency within your application's`build.gradle` file:

dependencies {
  implementation 'live.videosdk:rtc-android-sdk:0.1.26'

  // library to perform Network call to generate a meeting id
  implementation 'com.amitshekhar.android:android-networking:1.0.2'

  // Other dependencies specific to your app
}

If your project has set android.useAndroidX=true, then set android.enableJetifier=true in the gradle.properties file to migrate your project to AndroidX and avoid duplicate class conflicts.

STEP (c): Add permissions to your project

In /app/Manifests/AndroidManifest.xml, add the following permissions after </application>.

<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.CAMERA" />

These permissions are essential for enabling core functionalities like audio recording, internet connectivity for real-time communication, and camera access for video streams within your video application.

Essential Steps for Building the Video Calling Functionality

We'll now delve into the functionalities that make your video application after setting up your project with VideoSDK. This section outlines the essential steps for implementing core functionalities within your app.

This section will guide you through four key aspects:

STEP 1: Generate a`meetingId`

Now, we can create the meetingId from the VideoSDK's rooms API. You can refer to this documentation to generate meetingId.

STEP 2: Initializing the Meeting

After getting meetingId , the next step involves initializing the meeting for that we need to,

Initialize VideoSDK.
Configure VideoSDK with the token.
Initialize the meeting with required params such as meetingId, participantName, micEnabled, webcamEnabled and more.
Add MeetingEventListener for listening events such as Meeting Join/Left and Participant Join/Left.
Join the room with meeting.join() a method.

Please copy the .xml file of the MeetingActivity from here.

class MeetingActivity : AppCompatActivity() {
  // declare the variables we will be using to handle the meeting
  private var meeting: Meeting? = null
  private var micEnabled = true
  private var webcamEnabled = true

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)

    val token = "" // Replace with the token you generated from the VideoSDK Dashboard
    val meetingId = "" // Replace with the meetingId you have generated
    val participantName = "John Doe"

    // 1. Initialize VideoSDK
    VideoSDK.initialize(applicationContext)

    // 2. Configuration VideoSDK with Token
    VideoSDK.config(token)

    // 3. Initialize VideoSDK Meeting
    meeting = VideoSDK.initMeeting(
      this@MeetingActivity, meetingId, participantName,
      micEnabled, webcamEnabled,null, null, false, null, null)

    // 4. Add event listener for listening upcoming events
    meeting!!.addEventListener(meetingEventListener)

    // 5. Join VideoSDK Meeting
    meeting!!.join()

    (findViewById<View>(R.id.tvMeetingId) as TextView).text = meetingId
  }

  // creating the MeetingEventListener
  private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    override fun onMeetingJoined() {
      Log.d("#meeting", "onMeetingJoined()")
    }

    override fun onMeetingLeft() {
      Log.d("#meeting", "onMeetingLeft()")
      meeting = null
      if (!isDestroyed) finish()
    }

    override fun onParticipantJoined(participant: Participant) {
      Toast.makeText(
        this@MeetingActivity, participant.displayName + " joined",
        Toast.LENGTH_SHORT
      ).show()
    }

    override fun onParticipantLeft(participant: Participant) {
      Toast.makeText(
         this@MeetingActivity, participant.displayName + " left",
         Toast.LENGTH_SHORT
      ).show()
    }
  }
}

STEP 3: Handle Local Participant Media

After successfully entering the meeting, it's time to manage the webcam and microphone for the local participant (you).

To enable or disable the webcam, we'll use the Meeting class methods enableWebcam() and disableWebcam(), respectively. Similarly, to mute or unmute the microphone, we'll utilize the methods muteMic() and unmuteMic() .

class MeetingActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)
    //...Meeting Setup is Here

    // actions
    setActionListeners()
  }

  private fun setActionListeners() {
    // toggle mic
    findViewById<View>(R.id.btnMic).setOnClickListener { view: View? ->
      if (micEnabled) {
        // this will mute the local participant's mic
        meeting!!.muteMic()
        Toast.makeText(this@MeetingActivity, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        // this will unmute the local participant's mic
        meeting!!.unmuteMic()
        Toast.makeText(this@MeetingActivity, "Mic Enabled", Toast.LENGTH_SHORT).show()
      }
        micEnabled=!micEnabled
    }

    // toggle webcam
    findViewById<View>(R.id.btnWebcam).setOnClickListener { view: View? ->
      if (webcamEnabled) {
        // this will disable the local participant webcam
        meeting!!.disableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Disabled", Toast.LENGTH_SHORT).show()
      } else {
        // this will enable the local participant webcam
        meeting!!.enableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Enabled", Toast.LENGTH_SHORT).show()
      }
       webcamEnabled=!webcamEnabled
    }

    // leave meeting
    findViewById<View>(R.id.btnLeave).setOnClickListener { view: View? ->
      // this will make the local participant leave the meeting
      meeting!!.leave()
    }
  }
}

class MeetingActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_meeting)
    //...Meeting Setup is Here

    // actions
    setActionListeners()
  }

  private fun setActionListeners() {
    // toggle mic
    findViewById<View>(R.id.btnMic).setOnClickListener { view: View? ->
      if (micEnabled) {
        // this will mute the local participant's mic
        meeting!!.muteMic()
        Toast.makeText(this@MeetingActivity, "Mic Muted", Toast.LENGTH_SHORT).show()
      } else {
        // this will unmute the local participant's mic
        meeting!!.unmuteMic()
        Toast.makeText(this@MeetingActivity, "Mic Enabled", Toast.LENGTH_SHORT).show()
      }
        micEnabled=!micEnabled
    }

    // toggle webcam
    findViewById<View>(R.id.btnWebcam).setOnClickListener { view: View? ->
      if (webcamEnabled) {
        // this will disable the local participant webcam
        meeting!!.disableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Disabled", Toast.LENGTH_SHORT).show()
      } else {
        // this will enable the local participant webcam
        meeting!!.enableWebcam()
        Toast.makeText(this@MeetingActivity, "Webcam Enabled", Toast.LENGTH_SHORT).show()
      }
       webcamEnabled=!webcamEnabled
    }

    // leave meeting
    findViewById<View>(R.id.btnLeave).setOnClickListener { view: View? ->
      // this will make the local participant leave the meeting
      meeting!!.leave()
    }
  }
}

STEP 4: Handling the Participants' View

To display a list of participants in your video UI, we'll utilize a RecyclerView.

(a) This involves creating a new layout for the participant view named item_remote_peer.xml in the res/layout folder. You can copy item_remote_peer.xml file from here.

(b) Create a RecyclerView adapter ParticipantAdapter which will be responsible for displaying the participant list. Within this adapter, define a PeerViewHolder class that extends RecyclerView.ViewHolder.

class ParticipantAdapter(meeting: Meeting) : RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): PeerViewHolder {
    return PeerViewHolder(
      LayoutInflater.from(parent.context)
        .inflate(R.layout.item_remote_peer, parent, false)
    )
  }

  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
  }

  override fun getItemCount(): Int {
    return 0
  }

  class PeerViewHolder(view: View) : RecyclerView.ViewHolder(view) {
    // 'VideoView' to show Video Stream
    var participantView: VideoView
    var tvName: TextView

    init {
        tvName = view.findViewById(R.id.tvName)
        participantView = view.findViewById(R.id.participantView)
    }
  }
}

(c) Now, we will render a list of Participant for the meeting. We will initialize this list in the constructor of the ParticipantAdapter .

class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // creating a empty list which will store all participants
  private val participants: MutableList<Participant> = ArrayList()

  init {
    // adding the local participant(You) to the list
    participants.add(meeting.localParticipant)

    // adding Meeting Event listener to get the participant join/leave event in the meeting.
    meeting.addEventListener(object : MeetingEventListener() {
      override fun onParticipantJoined(participant: Participant) {
        // add participant to the list
        participants.add(participant)
        notifyItemInserted(participants.size - 1)
      }

      override fun onParticipantLeft(participant: Participant) {
        var pos = -1
        for (i in participants.indices) {
          if (participants[i].id == participant.id) {
            pos = i
            break
          }
        }
        // remove participant from the list
        participants.remove(participant)
        if (pos >= 0) {
          notifyItemRemoved(pos)
        }
      }
    })
  }

  // replace getItemCount() method with following.
  // this method returns the size of total number of participants
  override fun getItemCount(): Int {
    return participants.size
  }
  //...
}

(d) We have listed our participants. Let's set up the view holder to display a participant video,

class ParticipantAdapter(meeting: Meeting) :
    RecyclerView.Adapter<ParticipantAdapter.PeerViewHolder>() {

  // replace onBindViewHolder() method with following.
  override fun onBindViewHolder(holder: PeerViewHolder, position: Int) {
    val participant = participants[position]

    holder.tvName.text = participant.displayName

    // adding the initial video stream for the participant into the 'VideoView'
    for ((_, stream) in participant.streams) {
      if (stream.kind.equals("video", ignoreCase = true)) {
        holder.participantView.visibility = View.VISIBLE
        val videoTrack = stream.track as VideoTrack
        holder.participantView.addTrack(videoTrack)
        break
      }
    }

    // add Listener to the participant which will update start or stop the video stream of that participant
    participant.addEventListener(object : ParticipantEventListener() {
      override fun onStreamEnabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.visibility = View.VISIBLE
          val videoTrack = stream.track as VideoTrack
          holder.participantView.addTrack(videoTrack)
       }
      }

      override fun onStreamDisabled(stream: Stream) {
        if (stream.kind.equals("video", ignoreCase = true)) {
          holder.participantView.removeTrack()
          holder.participantView.visibility = View.GONE
        }
      }
    })
  }
}

(e) Now, add this adapter to the MeetingActivity,

override fun onCreate(savedInstanceState: Bundle?) {
  // Meeting Setup...
  //...
  val rvParticipants = findViewById<RecyclerView>(R.id.rvParticipants)
  rvParticipants.layoutManager = GridLayoutManager(this, 2)
  rvParticipants.adapter = ParticipantAdapter(meeting!!)
}

The screen share feature enhances the collaborative experience in video conferences by allowing participants to share their screens with others. Integrating screen share functionality into your video app using VideoSDK is straightforward and can significantly enhance the usability and effectiveness of your application.

Let's walk through the steps to enable screen-sharing functionality using VideoSDK.

The following diagram shows the flow of screen sharing in Android using VideoSDK:

To initiate screen sharing, utilize the enableScreenShare() function within the Meeting class. This enables the local participants to share their mobile screens with other participants seamlessly.

You can pass customized screen share tracks in enableScreenShare() by using Custom Screen Share Track.
Screen Share stream of the participant can be accessed from the onStreamEnabled event of ParticipantEventListener.

Screenshare permission

Before commencing screen sharing, it's crucial to address screen share permissions. The participant's screen share stream is facilitated through the MediaProjection API, compatible only with Build.VERSION_CODES.LOLLIPOP or higher.
To attain permission for screen sharing, acquire an instance of the MediaProjectionManager and invoke the createScreenCaptureIntent() method within an activity. This prompts a dialog for the user to authorize screen projection.

Following the permission grant, proceed to call the enableScreenShare() method.

private fun enableScreenShare() {
    val mediaProjectionManager = application.getSystemService(
        MEDIA_PROJECTION_SERVICE
    ) as MediaProjectionManager
    startActivityForResult(
        mediaProjectionManager.createScreenCaptureIntent(), CAPTURE_PERMISSION_REQUEST_CODE
    )
}

public override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return
    if (resultCode == RESULT_OK) {
        // Enabling screen share
        meeting!!.enableScreenShare(data)
    }
}

Customize notification

Upon initiating screen sharing, the presenter will receive a notification featuring a predefined title and message. Notification with pre-defined title and message will look like this:

You can Customise those titles, messages, and icons as per your requirements using <meta-data> specified in app/src/main/AndroidManifest.xml.
The notification appearance can be customized to align with specific requirements by modifying the titles, messages, and icons using <meta-data> specified in app/src/main/AndroidManifest.xml.

<application>
  <meta-data
    android:name="notificationTitle"
    android:value="@string/notificationTitle"
  />
  <meta-data
    android:name="notificationContent"
    android:value="@string/notificationContent"
  />
  <meta-data
    android:name="notificationIcon"
    android:resource="@mipmap/ic_launcher_round"
  />
</application>

You have to employ the disableScreenShare() function from the Meeting class. This action enables the local participant to halt sharing their mobile screen with other participants.

private fun disableScreenShare() {
    // Disabling screen share
    meeting!!.disableScreenShare()
}

Events associated with`enableScreenShare()`

The participant who shares their mobile screen will receive a callback on onStreamEnabled() of the Participant with Stream object.
While other Participants will receive onPresenterChanged() callback of the Meeting class with the participantId as presenterId who started the screen share.

Events associated with`disableScreenShare()`

The participant who shared their mobile screen will receive a callback on onStreamDisabled() of the Participant with Stream object.
While other Participants will receive onPresenterChanged() callback of the Meeting class with the presenterId as null indicating there is no presenter.

private fun setLocalListeners() {
    meeting!!.localParticipant.addEventListener(object : ParticipantEventListener() {
        //Callback for when the participant starts a stream
        override fun onStreamEnabled(stream: Stream) {
           if (stream.kind.equals("share", ignoreCase = true)) {
              Log.d("VideoSDK","Share Stream On: onStreamEnabled $stream");
            }
        }

        //Callback for when the participant stops a stream
        override fun onStreamDisabled(stream: Stream) {
            if (stream.kind.equals("share", ignoreCase = true)) {
               Log.d("VideoSDK","Share Stream On: onStreamDisabled $stream");
            }
        }
    });
}

private val meetingEventListener: MeetingEventListener = object : MeetingEventListener() {
    //Callback for when the presenter changes
    override fun onPresenterChanged(participantId: String) {
        if(!TextUtils.isEmpty(participantId))
        {
          Log.d("VideoSDK","$participantId started screen share");
        }else{
          Log.d("VideoSDK","some one stopped screen share");
        }
    }
}

That's it. Following these steps will allow you to effortlessly implement screen-share capability into your video app, increasing its adaptability and usefulness for users across a wide range of use cases.

For an in-depth exploration of the code snippets along with thorough explanations, I highly recommend delving into the GitHub repository. By navigating through the repository, you'll gain access to the complete set of code snippets, accompanied by detailed explanations that shed light on their functionality and implementation.

🎉 Conclusion

We have discussed the essential steps for integrating the screen share feature into your Android video app using VideoSDK. By following these steps, You may improve the collaborative experience of your video apps, allowing users to effortlessly exchange information during video conferences. Screen sharing feature not only increases user engagement but also extends the number of use cases for video communication services, making them more adaptable and beneficial to users.

Adding the screen-sharing functionality to your video app now opens up new avenues for collaboration and communication.

How to Integrate Screen Share in Kotlin Video Chat App for Android?

Table of contents

Introduction

🎯 Goals

🚀 Getting Started with VideoSDK

🔐 Create a VideoSDK Account

🔑 Generate your Auth Token

🛠️ Prerequisites and Setup

🔌 Integrate VideoSDK

STEP (a): Add the repositories to the project'ssettings.gradle file.

STEP (b): Include the following dependency within your application'sbuild.gradle file:

STEP (c): Add permissions to your project

Essential Steps for Building the Video Calling Functionality

STEP 1: Generate ameetingId

STEP 2: Initializing the Meeting

STEP 3: Handle Local Participant Media

STEP 4: Handling the Participants' View

Screen Share Feature Integration

How does Screen Share work?

Enable Screen Sharing

Screenshare permission​

Customize notification

Disable Screen Sharing

Events Associated with Screen Sharing

Events associated withenableScreenShare()

Events associated withdisableScreenShare()