AdPlayer.initializePublisher(publisherId) {
    // initialize tags here
}
// this is optional
.onTagReady { tag: AdPlayerTag ->
    // tag instance available here
}
// this is optional
.onError { error: AdPlayerError ->
    // tag initialization failed
}

AdPlayer.initializePublisher(publisher, new AdPlayerTagInitCallback() {
	@Override
	public void onTagReady(@NonNull AdPlayerTag adPlayerTag) {
		// tag instance available here
	}

	@Override
	public void onError(@NonNull AdPlayerError adPlayerError) {
		// tag initialization failed
	}
});

coroutineScope.launch {
    AdPlayer.getTagWhenReady(tagId)
        .onSuccess { tag: AdPlayerTag ->
          // tag instance available here
        }.onFailure { error: AdPlayerError ->
          // tag initialization failed
        }
}

AdPlayer.getTagWhenReady(tagId, new AdPlayerTagInitCallback() {
	@Override
	public void onTagReady(@NonNull AdPlayerTag tag) {
		// tag instance available here
	}

	@Override
	public void onError(@NonNull AdPlayerError error) {
      // tag initialization failed
	}
});

AdPlayer.getTagNowOrNull(tagId)?.let { tag -> 
  // do action
}

AdPlayerTag tag = AdPlayer.getTagNowOrNull(tagId);

if (tag1 != null) {
	// do action
}

coroutineScope.launch {
    tag.playingState.collectLatest { playingState: AdPlayerPlayingState ->
        when (playingState) {
            is AdPlayerPlayingState.Initial -> {}
            is AdPlayerPlayingState.Playing -> {
                if (playingState.isAd) {
                    // the player is playing an ad
                } else {
                    // the player is playing content
                }
            }
            is AdPlayerPlayingState.NotPlaying -> {}
            is AdPlayerPlayingState.Dsiplay -> {}
        }
    }
}

tag.setPlayingStateListener(new AdPlayerPlayingStateListener() {
	@Override
	public void onStateChanged(@NonNull AdPlayerPlayingState newState) {
		if (newState.isPlaying()) {
			// the player is playing
		} else {
			// the player is not playing
		}
		if (newState.isAd()) {
			// the player is displaying an ad
		} else {
			// the player is not displaying an ad
		}
	}
});

AdPlayer.initializePublisher(publisherId) {
    addTag(tag1Id) {
        // configure your tag here
        label = "tag_label"
        backgroundColor = Color.BLACK
        macros = mutableListOf(
            AdPlayerMacro.CmsId(cmsId),
            AdPlayerMacro.PlaylistId(playlistId),
            AdPlayerMacro.Custom(customKey, customValue),
        )
    }
}

AdPlayerTagConfiguration tag = new AdPlayerTagConfiguration(tag1Id);
// configure your tag here
tag.setLabel("tag_label");
tag.setBackgroundColor(Color.BLACK);

List<AdPlayerMacro> macros = new ArrayList<>();
macros.add(new AdPlayerMacro.CmsId(cmsId));
macros.add(new AdPlayerMacro.PlaylistId(playlistId));
macros.add(new AdPlayerMacro.Custom(customKey, customValue));

tag.setMacros(macros);

AdPlayerPublisherConfiguration publisher = new AdPlayerPublisherConfiguration(publisherId, tag);

AdPlayer.initializePublisher(publisher);

AdPlayer.initializePublisher(publisherId) {
    addTag(tagId) {
        eventsListener { event: AdPlayerEvent ->
            when (event) {
                // handle events
            } 
        }
    }
}

coroutineScope.launch { 
    tag.eventsFlow.collectLatest { event: AdPlayerEvent ->
        when (event) { 
            // handle events
        }
    }
}

tag.eventsListener = object : AdPlayerTagEventsListener {
    override fun onAdPlayerEvent(event: AdPlayerEvent) {
        when (event) {
            // handle events
        }
    }
}

AdPlayerTagConfiguration tag = new AdPlayerTagConfiguration(tagId);
// configure your tag here
tag.setEventsListener(new AdPlayerTagEventsListener() {
	@Override
	public void onAdPlayerEvent(@NonNull AdPlayerEvent event) {
		switch (event.getType()) {
			// handle events
		}
	}
});

tag.setEventsListener(new AdPlayerTagEventsListener() {
	@Override
	public void onAdPlayerEvent(@NonNull AdPlayerEvent event) {
		switch (event.getType()) {
			// handle events
		}
	}
});

switch (event.getType()) {
	case AD_VOLUME_CHANGE: float volume = ((AdPlayerEvent.AdVolumeChange) event).getVolume();
}

tag.playingStateListener = object : AdPlayerPlayingStateListener {
    override fun onStateChanged(newState: AdPlayerPlayingState) {
        // handle state change
    }
}

coroutineScope.launch {
    tag.playingState.collectLatest { playingState ->
        // handle state change
    }
}

tag.setPlayingStateListener(new AdPlayerPlayingStateListener() {
	@Override
	public void onStateChanged(@NonNull AdPlayerPlayingState adPlayerPlayingState) {
		// handle state change here
	}
});