DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();  
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();  
Document doc = dBuilder.parse('VAST TAG URL');  
doc.getDocumentElement().normalize();

 <androidx.media3.ui.PlayerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/videoView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="16dp">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:orientation="horizontal">

        <TextView
            android:id="@+id/muteTextView"
            android:layout_width="0dp"
            android:layout_height="match_parent"
            android:layout_weight="1"
            android:gravity="center"
            android:text="Mute" />
    </LinearLayout>

</androidx.media3.ui.PlayerView>

public class VideoAdNativeActivity extends Activity implements Player.Listener, View.OnClickListener {

    private static final int PLAYER_UNMUTE = 1;
    private static final int PLAYER_MUTE = 0;
    private PlayerView playerView;
    private ExoPlayer player;
    private TextView muteTextView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.video_ad_native_detail);

        playerView = findViewById(R.id.videoView);
        muteTextView = findViewById(R.id.muteTextView);

        playerView.requestFocus();
        playerView.setOnClickListener(this);
        muteTextView.setOnClickListener(this);

        // Query and parse VAST
        ...

        // Instantiate the video ad player with a media item from the VAST
        initializePlayer(videoUrl);
    }

    private void initializePlayer(String videoUrl) {
        // Create an ExoPlayer and set it as the player for content and ads.
        player = new ExoPlayer.Builder(this)
                .build();

        // Create the MediaItem to play
        MediaItem mediaItem =
                new MediaItem.Builder()
                        .setUri(Uri.parse(videoUrl))
                        .build();
        player.setMediaItem(mediaItem);

        // Add listener on player events
        player.addListener(this);

        player.setVolume(PLAYER_VOLUME);
        playerView.setPlayer(player);

        // Disable default player controls (default controls allow seeking)
        playerView.setUseController(false);
        player.setPlayWhenReady(true);
        player.prepare();
    }
}

public AdSession getNativeAdSession(Context context) {
    Omid.activate(context.getApplicationContext());

    AdSessionConfiguration adSessionConfiguration =
        AdSessionConfiguration.createAdSessionConfiguration(
            CreativeType.VIDEO,
            ImpressionType.VIEWABLE,
            Owner.NATIVE,
            Owner.NATIVE, false);

    Partner partner = Partner.createPartner("criteo", "<version name>");
    final String omidJs = getOmidJs(context);

    VerificationScriptResource verificationScripts =
        VerificationScriptResource.createVerificationScriptResourceWithParameters(
            vendorKey,
            omidVerificationScript,
            omidVerificationParameters);

    AdSessionContext adSessionContext = AdSessionContext.createNativeAdSessionContext(
        partner,
        omidJs,
        Collections.singletonList(verificationScripts),
        null,
        null);

    AdSession adSession = AdSession.createAdSession(adSessionConfiguration, adSessionContext);
    return adSession;
}

public static String getOmidJs(Context context) {
    Resources res = context.getResources();
    try (InputStream inputStream = res.openRawResource(R.raw.omsdk_v1)) {
        byte[] b = new byte[inputStream.available()];
        final int bytesRead = inputStream.read(b);
        return new String(b, 0, bytesRead, "UTF-8");
    } catch (IOException e) {
        throw new UnsupportedOperationException("OM SDK JS library resource not found", e);
    }
}

public class VideoAdNativeActivity extends Activity implements Player.Listener, View.OnClickListener {
    [...]

    private MediaEvents mediaEvents;
    private AdEvents adEvents;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        [...]

        try {
            // Extract OMID verification script, parameters from VAST
            ...

            adSession = getNativeAdSession(this);
        } catch (Exception e) {
            // Call the 'verificationNotExecuted' tracker
            // if any errors occur while preparing OMID session
            emitBeacon(adVerificationNotExecuted);
        }

        mediaEvents = MediaEvents.createMediaEvents(adSession);
        adEvents = AdEvents.createAdEvents(adSession);
        adSession.registerAdView(playerView);
        adSession.start();

        [...]
    }

    [...]
}

public class VideoAdNativeActivity extends Activity implements Player.Listener, View.OnClickListener {
    [...]

    private final OkHttpClient client = new OkHttpClient();
    private final Callback emptyCallback = new Callback() {
        @Override
        public void onFailure(Call call, IOException e) { }

        @Override
        public void onResponse(Call call, Response response) { }
    };

    private void emitBeacon(String url) {
        Request request = new Request.Builder().url(url).build();
        client.newCall(request).enqueue(emptyCallback);
    }

    @Override
    public void onPlaybackStateChanged(@Player.State int playbackState) {
        switch (playbackState) {
            case ExoPlayer.STATE_READY:
                onStateReady();
                break;
            case ExoPlayer.STATE_ENDED:
                onStateEnded();
                break;
            case ExoPlayer.STATE_BUFFERING:
                onStateBuffering();
                break;
            case ExoPlayer.STATE_IDLE:
                break;
            default:
                throw new IllegalStateException("Unknown playbackState: " + playbackState);
        }
    }

    private boolean loaded = false;

    private void onStateReady() {
        if (!loaded) {
            emitBeacon(adImpression);
            loaded = true;

            // forward event to OMID
            VastProperties vastProperties = VastProperties.createVastPropertiesForNonSkippableMedia(false, Position.STANDALONE);
            adEvents.loaded(vastProperties);
            adEvents.impressionOccurred();
        }

        // forward event to OMID
        mediaEvents.bufferFinish();

        // launch polling thread to monitor video progress
        postProgress();
    }

    private void onStateBuffering() {
        // forward event to OMID
        mediaEvents.bufferStart();
    }

    [...]
}

public class VideoAdNativeActivity extends Activity implements Player.Listener, View.OnClickListener {
    [...]

    private final Handler handler = new Handler(Looper.getMainLooper());
    private final ProgressRunnable progressRunnable = new ProgressRunnable(this);
    private static final int PROGRESS_INTERVAL_MS = 100;

    private static class ProgressRunnable implements Runnable {
        private final WeakReference<VideoAdNativeActivity> videoAdNativeActivityWeakReference;

        ProgressRunnable(VideoAdNativeActivity videoAdNativeActivity) {
            this.videoAdNativeActivityWeakReference = new WeakReference<>(videoAdNativeActivity);
        }

        @Override
        public void run() {
            VideoAdNativeActivity videoAdNativeActivity = videoAdNativeActivityWeakReference.get();
            if (videoAdNativeActivity == null) {
                return;
            }
            videoAdNativeActivity.onProgress();
        }
    }

    private void onProgress() {
        if (adSession == null) { 
            return; 
        }
        if (complete) { 
            return; 
        }

        updateQuartile();
        postProgress();
    }

    private void postProgress() {
        handler.removeCallbacks(progressRunnable);
        handler.postDelayed(progressRunnable, PROGRESS_INTERVAL_MS);
    }

    [...]
}

// updateQuartile method does some calculations to get the currently playing quartile,
// executes some safety checks, and triggers the quartile event. 
private Quartile lastSentQuartile = Quartile.UNKNOWN;

private void updateQuartile() {
    final long duration = player.getDuration();
    final long currentPosition = player.getCurrentPosition();

    if (duration != 0 && !complete) {
        final Quartile currentQuartile = getQuartile(currentPosition, duration);

        // Don't send old quartile stats that we have either already sent, or passed.
        if (currentQuartile != lastSentQuartile && currentQuartile.ordinal() > lastSentQuartile.ordinal()) {
            sendQuartile(currentQuartile);
            lastSentQuartile = currentQuartile;
        }
    }
}

private void sendQuartile(Quartile quartile) {
    switch (quartile) {
        case START:
            // Fire start beacon
            emitBeacon(adStarted);

            // Forward event to OMID
            mediaEvents.start(player.getDuration(), PLAYER_VOLUME);
            break;

        case FIRST:
            // Fire firstQuartile beacon
            emitBeacon(adFirstQuartile);

            // Forward event to OMID
            mediaEvents.firstQuartile();
            break;

        case SECOND:
            // Fire midpoint beacon
            emitBeacon(adMidpoint);

            // Forward event to OMID
            mediaEvents.midpoint();
            break;

        case THIRD:
            // Fire thirdQuartile beacon
            emitBeacon(adThirdQuartile);

            // Forward event to OMID
            mediaEvents.thirdQuartile();
            break;

        case UNKNOWN:
        default:
            break;
    }
}

// Enum to represent quartiles and some helper methods to round the video position to the nearest completed quartile
public enum Quartile { UNKNOWN, START, FIRST, SECOND, THIRD }

// A way to detect when the quartile events occur
private static Quartile getQuartile(long position, long duration) {
    final double completionFraction = position / (double) duration;

    if (lessThan(completionFraction, 0.01)) {
        return Quartile.UNKNOWN;
    }

    if (lessThan(completionFraction, 0.25)) {
        return Quartile.START;
    }

    if (lessThan(completionFraction, 0.5)) {
        return Quartile.FIRST;
    }

    if (lessThan(completionFraction, 0.75)) {
        return Quartile.SECOND;
    }

    // We report Quartile.THIRD when completionFraction > 1 on purpose
    // since track might technically report elapsed time after its completion
    // and if Quartile.THIRD hasn't been reported already, it will be lost
    return Quartile.THIRD;
}

private static boolean lessThan(double a, double b) {
    return b - a > EPSILON;
}

private void onStateEnded() {
    if (!complete) {
        emitBeacon(adCompleted);

        // Forward event to OMID
        mediaEvents.complete();
        complete = true;
    }

    // Restart the video
    player.seekTo(0);
    player.play();
}

private void initializePlayer(String videoUrl) {
    [...]

    playerView.getViewTreeObserver().addOnPreDrawListener(() -> {
        // Check if at least 50% of the video is visible
        // And that the user didn't explicitly pause the playback
        if (isPlayingWhen50Visible && isVideoViewAtLeast50Visible(playerView)) {
            playVideo();
        } else {
            pauseVideo();
        }
        return true;
    });
}

private boolean isVideoViewAtLeast50Visible(View videoView) {
    // Get the visible rectangle of the view
    Rect visibleRect = new Rect();
    boolean isVisible = videoView.getGlobalVisibleRect(visibleRect);
    if (!isVisible) {
        return false;
    }

    // Get total area of the video view
    int totalArea = videoView.getWidth() * videoView.getHeight();
    if (totalArea == 0) {
        return false;
    }

    // Get the visible area
    int visibleArea = visibleRect.width() * visibleRect.height();
    return (visibleArea >= totalArea / 2);
}

public class VideoAdNativeActivity extends Activity implements Player.Listener, View.OnClickListener {
    [...]

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.videoView:
                if (clickThroughUrl != null) {
                    clickThroughHandler();
                } else {
                    handlePlayPause();
                }
                break;
            case R.id.muteTextView:
                toggleMute(mediaEvents, player, muteTextView);
                break;
        }
    }

    public void clickThroughHandler() {
        // Emit the click beacon
        if (adClickThrough != null) {
            emitBeacon(adClickThrough);
        }

        // Redirect the user to the ClickThrough URL
        try {
            Intent externalIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(clickThroughUrl));
            this.startActivity(externalIntent);
        } catch (ActivityNotFoundException e) {
            e.printStackTrace();
        }
    }

    private boolean isPlayingWhen50Visible = true;

    public void handlePlayPause() {
        if (isPlaying) {
            pauseVideo();
            emitBeacon(adPause);
        } else {
            playVideo();
            emitBeacon(adPlay);
        }
        isPlayingWhen50Visible = !isPlayingWhen50Visible;
    }

    private void playVideo() {
        player.play();
        // Forward event to OMID
        mediaEvents.resume();
    }

    private void pauseVideo() {
        player.pause();
        // Forward event to OMID
        mediaEvents.pause();
    }

    [...]
}

public void toggleMute() {
    int PLAYER_MUTE = 0;
    int PLAYER_UNMUTE = 1;
    float currentVolume = player.getVolume();
    float targetVolume;

    if (currentVolume == PLAYER_MUTE) {
        targetVolume = PLAYER_UNMUTE;
        muteTextView.setText("Mute");

        emitBeacon(adUnmute);
    } else {
        targetVolume = PLAYER_MUTE;
        muteTextView.setText("Unmute");

        emitBeacon(adMute);
    }

    player.setVolume(targetVolume);

    // Forward event to OMID
    mediaEvents.volumeChange(targetVolume);
}

public class VideoAdNativeActivity extends Activity implements Player.Listener, View.OnClickListener {
    [...]

    @Override
    public void onDestroy() {
        super.onDestroy();
        adSession.finish();
        adSession = null;

        handler.removeCallbacksAndMessages(null);
        releasePlayer();
    }

    private void releasePlayer() {
        if (player != null) {
            player.release();
            player = null;
        }
    }

    [...]
}

private void initializePlayer(String videoUrl, String ccUrl) {
    [...]

    // Create the MediaItem to play
    MediaItem.Builder mediaItemBuilder =
        new MediaItem.Builder()
            .setUri(Uri.parse(videoUrl));

    if (ccUrl != null) {
        // Set your VTT subtitle URI
        Uri subtitleUri = Uri.parse(ccUrl);

        // Prepare the subtitle configuration
        MediaItem.SubtitleConfiguration subtitleConfig = new MediaItem.SubtitleConfiguration.Builder(subtitleUri)
            .setMimeType(MimeTypes.TEXT_VTT) // The MIME type for WebVTT subtitles
            .setLanguage("en") // Optional: Specify the language
            .setSelectionFlags(C.SELECTION_FLAG_DEFAULT) // Optional: Set flags like default
            .build();

        mediaItemBuilder.setSubtitleConfigurations(Collections.singletonList(subtitleConfig));
    }

    MediaItem mediaItem = mediaItemBuilder.build();
  
    [...]
}