Kotlin

allprojects {
    // Add the Sariska repository
    repositories {
        maven {
            url "https://github.com/SariskaIO/sariska-maven-repository/raw/master/releases"
        }
        
        // Add other repositories
        google()
        mavenCentral()
        maven { url 'https://www.jitpack.io' }
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            url "https://github.com/SariskaIO/sariska-maven-repository/raw/master/releases"
        }
        maven {
            url "https://maven.google.com"
        }
    }
}

dependencies {
    implementation 'io.sariska:sariska-media-transport:5.4.9'
}

import io.sariska.sdk.SariskaMediaTransport;
import io.sariska.sdk.Connection;
import io.sariska.sdk.Conference;
import io.sariska.sdk.JitsiRemoteTrack;
import io.sariska.sdk.JitsiLocalTrack;
import io.sariska.sdk.Participant;

SariskaMediaTransport.initializeSdk();

// Replace {your-token} with your actual Sariska token
val token = {your-token}
  
// Create a connection object
val connection = SariskaMediaTransport.JitsiConnection(token, "roomName", isNightly)
  
  
// Add event listeners for connection status
  
connection.addEventListener("CONNECTION_ESTABLISHED"), { 
// Handle successful connection establishment
}

connection.addEventListener("CONNECTION_FAILED"), { error->
  if (error === PASSWORD_REQUIRED) {
    // Token expired, update the connection with a new token
    connection.setToken(token)
  }
}

connection.addEventListener("CONNECTION_DISCONNECTED"), {
// Handle connection disconnection  
}
  

// Connect to the Sariska server
connection.connect()

// Create a conference object using the connection and optional configuration
val conference = connection.initJitsiConference(options);

// Join the conference
conference.join();

// Define options for local stream capture
val options = Bundle()

// Enable audio and video tracks in the stream
options.putBoolean("audio", true)
options.putBoolean("video", true)

// Set desired video resolution
options.putInt("resolution", 240) // Specify desired resolution
// ... (additional options for desktop sharing, facing mode, devices, etc.)

// Create local audio and video tracks based on the options
SariskaMediaTransport.createLocalTracks(options) { tracks ->
localTracks = tracks;
}

runOnUiThread(() -> {
    // Loop through each local track
    for (JitsiLocalTrack track : localTracks) {
        if (track.getType().equals("video")) {
            // Get the view for rendering the video track
            val view = track.render();
            
            // Set the view to fill the container
            view.setObjectFit("cover");
            
            // Add the video view to the container layout
            mLocalContainer.addView(view);
        }
    }
})

conference.addEventListener("USER_JOINED", (id,  participant)=>{
});

// Loop through all local tracks
for (JitsiLocalTrack track : localTracks) {
    // Add the track to the conference, allowing others to see/hear you
    conference.addTrack(track);
}

// Add an event listener to the conference for "TRACK_ADDED" events
conference.addEventListener("TRACK_ADDED") { p ->
    // Cast the event object to a JitsiRemoteTrack instance
    val track: JitsiRemoteTrack = p as JitsiRemoteTrack
    
    // Run code on the UI thread
    runOnUiThread {
        // Check if the track type is video
        if (track.getType().equals("video")) {
            // Render the video track using Jitsi's WebRTCView component
            val view: WebRTCView = track.render()
            
            // Set the view to cover the entire container
            view.setObjectFit("cover")
            
            // Store the view for potential later reference
            remoteView = view
            
            // Add the view to the container layout, displaying the remote video
            mRemoteContainer!!.addView(view)
        }
    }
}

conference.startTracking();

conference.addEventListener("DOMINANT_SPEAKER_CHANGED") { p ->
    // participantId is a string containing the ID of the dominant speaker
    val participantId = p as String 
}

// Listen for last N speakers changed event
conference.addEventListener("LAST_N_ENDPOINTS_CHANGED") { leavingEndpointIds,  enteringEndpointIds -> 
    // leavingEndpointIds: Array of IDs of users leaving lastN
    // enteringEndpointIds: Array of IDs of users entering lastN
};

// Set the number of last speakers to show
conference.setLastN(10)

// Set local participant property 
conference.setLocalParticipantProperty(key, value);

// Remove a local participant property
conference.rempveLocalParticipantProperty(key)

// Get the value of a local participant property 
conference.getLocalParticipantProperty(key)

// Listen for changes in participant properties
conference.addEventListener("PARTICIPANT_PROPERTY_CHANGED"){ participant, key, oldValue, newValue ->
}

conference.getParticipantCount(); 
// Pass true to include hidden participants

// Get all participants
conference.getParticipants(); // List of all participants

// Get participants excluding hidden users
conference.getParticipantsWithoutHidden(); // List of all participants

conference.selectParticipant(participantId) // Select participant with ID

conference.selectParticipants(participantIds) // Select participant with IDs

// Check if the local user is hidden
conference.isHidden()

// Get local user details
confernece.getUserId()
conference.getUserRole()
conference.getUserEmail()
conference.getUserAvatar()
conference.getUserName()

conference.setSubject(subject)

conference.getRemoteTracks();

conference.getLocalTracks()

conference.addEventListener("KICKED"){ id ->
   // Handle participant kicked
};

conference.addEventListener("PARTICIPANT_KICKED") { actorParticipant, kickedParticipant, reason ->
}

confernece.kickParticipant(id)

conference.grantOwner(id) // Grant owner rights to a participant

conference.addEventListener("USER_ROLE_CHANGED"){ id, role ->
    
    if (confernece.getUserId() === id ) {
        // My role changed, new role: role;
    } else {
       // Participant role changed: role;
    }
};

conference.revokeOwner(id) // Revoke owner rights from a participant

conference.setDisplayName(name); // Change the local user's display name

conference.addEventListener("DISPLAY_NAME_CHANGED"){ id, displayName->
    // Access the participant ID
};

conference.lock(password); // Lock the room with the specified password

conference.unlock();

conference.setLocalParticipantProperty("requestingTranscription", true);

conference.setLocalParticipantProperty("translation_language", 'hi'); // Example for Hindi

conference.addEventListener("SUBTITLES_RECEIVED"){ id, name, text->
// Handle received subtitle data (id, speaker name, text)
};

conference.setLocalParticipantProperty("requestingTranscription", false);

// Create a desktop track
val options = new Bundle();  
options.putBoolean("desktop", true);

val videoTrack = localTracks[1]; // Participant's local video track

SariskaMediaTransport.createLocalTracks(options, tracks -> {
    conference.replaceTrack(videoTrack, tracks[0]);
});

conference.sendMessage("message");

conference.sendMessage("message", participantId);

// Add an event listener to handle incoming messages
conference.addEventListener("MESSAGE_RECEIVED" ){ message, senderId->
// Process the received message
});

conference.startTranscriber();

conference.stopTranscriber();

conference.muteParticipant(participantId, mediaType)
// participantId: ID of the participant to be muted
// mediaType: Type of media to mute ('audio' or 'video')

// Mute a local track (audio or video)
track.mute()

// Unmute a previously muted local track
track.unmute()

conference.addEventListener(event: "LOCAL_STATS_UPDATED"){ stats in
// Handle local connection statistics
}

conference.addEventListener(event: "REMOTE_STATS_UPDATED") { id, stats-> 
// Handle remote connection statistics
}

conference.startP2PSession();

conference.stopP2PSession();

val options = new Bundle();
options.putString("callStatsID", 'callstats-id');
options.putString("callStatsSecret", 'callstats-secret');

val conference = connection.initJitsiConference(options);

val options = new Bundle();
options.putBoolean("startAudioMuted", true);
options.putBoolean("starVideoMuted", true);

val conference = connection.initJitsiConference(options);

val options = new Bundle();
options.putBoolean("startSilent", true);

val confernce = connection.initJitsiConference(options);

val options = new Bundle();
options.putString("broadcastId", "youtubeBroadcastID"); // Put any string this will become part of your publish URL
options.putString("mode", "stream");
options.putString("streamId", "youtubeStreamKey"); 

// Start live stream
conference.startRecording(options);

val options = new Bundle();
options.putString("mode", "stream");
options.putString("streamId", "rtmps://live-api-s.facebook.com:443/rtmp/FB-4742724459088842-0-AbwKHwKiTd9lFMPy");

// Start live stream
conference.startRecording(options);

val options = new Bundle();     
options.putString("mode", "stream");        
options.putString("streamId", "rtmp://live.twitch.tv/app/STREAM_KEY");      

// Start live stream
conference.startRecording(options);     

val options = new Bundle();
options.putString("mode", "stream");
options.putString("streamId", "rtmps://rtmp-server/rtmp"); // RTMP server URL

// Start live stream
conference.startRecording(options);

conference.addEventListener("RECORDER_STATE_CHANGED"){ sessionId, mode, status in
// Verify mode is "stream"
// Get the live streaming session ID
// Check the streaming status: on, off, or pending
};

conference.stopRecording(sessionId);

// Configure for Object-based storage
val options = new Bundle();
options.putString("mode", "file");
options.putString("serviceName", "s3");


// Configure for Dropbox
val options = new Bundle();
options.putString("mode", "file");
options.putString("serviceName", "dropbox");
options.putString("token", "dropbox_oauth_token");


// Start recording
conference.startRecording(options);


// Monitor recording state
conference.addEventListener("RECORDER_STATE_CHANGED"){ sessionId, mode, status ->
   val sessionId = sessionId as String; // Unique identifier for the cloud recording session
   val mode = mode as String; // Recording mode (e.g., "file")
   val status = status as String; // Current recording status ("on", "off", or "pending")
// Handle recording state changes based on mode, sessionId, and status
});

// Stop recording
conference.stopRecording(sessionId)

// Retrieve the phone pin and number for users to join via PSTN:

val phonePin = conference.getPhonePin() // Get the phone pin for PSTN access
val phoneNumber = conference.getPhoneNumber() // Get the phone number for PSTN access 

// Dial a phone number to invite a participant to the conference
conference.dial(phoneNumber)

// Join the lobby
conference.joinLobby(displayName, email); // Request to join the conference lobby

// Event listeners for lobby-related actions:
conference.addEventListener("LOBBY_USER_JOINED"){ id, name ->
    // Handle events when a user joins the lobby
    val id = id as String;
    val name = name as String
})

conference.addEventListener(event: "LOBBY_USER_UPDATED"), { id, participant ->
    // Handle events when a user's information in the lobby is updated
    val id = id as String;
    val name = participant as Participant
}


// Additional event listeners for lobby actions:
conference.addEventListener(event: "LOBBY_USER_LEFT") { id ->
    val id = id as String;
}

conference.addEventListener(event: "MEMBERS_ONLY_CHANGED") { enabled ->
    val enabled = enabled as Boolean;
}


// Moderator actions for lobby access:
conference.lobbyDenyAccess(participantId); // Deny access to a participant in the lobby
conference.lobbyApproveAccess(participantId); // Approve access to a participant in the lobby


// Lobby management methods:
conference.enableLobby() // Enable lobby mode for the conference (moderator only)
conference.disableLobby(); // Disable lobby mode for the conference (moderator only)
conference.isMembersOnly(); // Check if the conference is in members-only mode (lobby disabled)

// Initiate a SIP video call
conference.startSIPVideoCall("[email protected]", "display name"); // Start a SIP video call with the specified address and display name

// Terminate a SIP video call
conference.stopSIPVideoCall('[email protected]');

// Event listeners for SIP gateway state changes
conference.addEventListener("VIDEO_SIP_GW_SESSION_STATE_CHANGED", (state)=>{
    // Handle events when the SIP gateway session state changes (on, off, pending, retrying, failed)
}

// Event listener for SIP gateway availability changes
conference.addEventListener("VIDEO_SIP_GW_AVAILABILITY_CHANGED"){ status ->
    // Handle events when the SIP gateway availability changes (busy or available)
}

conference.addEventListener(event: "USER_STATUS_CHANGED"){ id, status ->
    val id = id as! String;
    val status = status as!
// - id: receiver's user id
// - status: "ringing", "busy", "rejected", "connected", "expired"
};