java code

1 message

Rahul Singh <[email protected]> Thu, Jun 19, 2025 at 3:32 PM

To: Pritesh Singh <[email protected]>

package com.codingclasses.ecoplayer2025;

import android.annotation.SuppressLint;
import android.app.Dialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.pm.ActivityInfo;
import android.content.res.Resources;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.provider.Settings;
import android.util.Log;
import android.view.GestureDetector;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.Window;
import android.view.WindowManager;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import android.widget.Toast;

import androidx.activity.EdgeToEdge;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.constraintlayout.widget.ConstraintLayout;
import androidx.core.content.ContextCompat;
import androidx.core.graphics.Insets;
import androidx.core.view.GestureDetectorCompat;
import androidx.core.view.ViewCompat;
import androidx.core.view.WindowCompat;
import androidx.core.view.WindowInsetsCompat;
import androidx.media3.common.C;
import androidx.media3.common.Format;
import androidx.media3.common.MediaItem;
import androidx.media3.common.PlaybackParameters;
import androidx.media3.common.Player;
import androidx.media3.common.TrackGroup;
import androidx.media3.common.TrackSelectionOverride;
import androidx.media3.common.TrackSelectionParameters;
import androidx.media3.common.Tracks;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.common.util.Util;
import androidx.media3.datasource.DataSource;
import androidx.media3.datasource.DefaultHttpDataSource;
import androidx.media3.exoplayer.DefaultRenderersFactory;
import androidx.media3.exoplayer.ExoPlayer;
import androidx.media3.exoplayer.dash.DashMediaSource;
import androidx.media3.exoplayer.hls.HlsMediaSource;
import androidx.media3.exoplayer.rtsp.RtspMediaSource;
import androidx.media3.exoplayer.smoothstreaming.SsMediaSource;
import androidx.media3.exoplayer.source.MediaSource;
import androidx.media3.exoplayer.source.ProgressiveMediaExtractor;
import androidx.media3.exoplayer.source.ProgressiveMediaSource;
import androidx.media3.exoplayer.source.TrackGroupArray;
import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection;
import androidx.media3.exoplayer.trackselection.DefaultTrackSelector;
import androidx.media3.exoplayer.trackselection.ExoTrackSelection;
import androidx.media3.exoplayer.trackselection.MappingTrackSelector;
import androidx.media3.ui.PlayerView;

import java.util.ArrayList;
import java.util.Locale;
import java.util.Objects;

@UnstableApi
public class PlayerActivity extends AppCompatActivity {

PlayerView playerView;
ExoPlayer exoPlayer;
private ArrayList<String> videoQualities;
private DefaultTrackSelector defaultTrackSelector;
private int selectedQualityIndex = 0;

boolean isFullScreen = false;

String Speed_txt = "1x";

final int[] selectedIndex = { -1 };

final int[] selected = {-1}; // Store selected index
// private ControlsMode controlsMode;
// public enum ControlsMode{
// LOCK,FULLSCREEN;
// }
// gesture
private int touchPositionX;
private GestureDetectorCompat gestureDetectorCompat;
private int brightness = 0;
private int volume = 0;
private AudioManager audioManager;
private final int SHOW_MAX_BRIGHTNESS = 100;
private final int SHOW_MAX_VOLUME = 50;
private boolean shouldShowController = true;
private LinearLayout brightnessVolumeContainer;
private ImageView volumeIcon, brightnessIcon;
private TextView brightVolumeTV;
private static final String TAG = "MADARA";

//--------------
DataSource.Factory dataSourceFactory;

@SuppressLint("ClickableViewAccessibility")
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
EdgeToEdge.enable(this);
WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView()).
setAppearanceLightStatusBars(false);
WindowCompat.getInsetsController(getWindow(), getWindow().getDecorView()).
setAppearanceLightNavigationBars(false);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
getWindow().setNavigationBarContrastEnforced(false);
}
setContentView(R.layout.activity_player);
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main), (v, insets) -> {
Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
return insets;
});
 String stream = getIntent().getStringExtra("url");

ExoTrackSelection.Factory videoTrackSelectionFactory = new AdaptiveTrackSelection.Factory();

defaultTrackSelector = new DefaultTrackSelector(this, videoTrackSelectionFactory);

DefaultRenderersFactory renderersFactory = new DefaultRenderersFactory(this)

.forceEnableMediaCodecAsynchronousQueueing()
.setExtensionRendererMode(DefaultRenderersFactory.EXTENSION_RENDERER_MODE_OFF);

playerView = findViewById(R.id.player_view);
Uri uri = Uri.parse(stream);
dataSourceFactory = new DefaultHttpDataSource.Factory();
MediaSource mediaSource = buildMediaSource(uri);
exoPlayer = new ExoPlayer.Builder(this, renderersFactory)
.setTrackSelector(defaultTrackSelector)
.build();
playerView.setPlayer(exoPlayer);

exoPlayer.setMediaSource(mediaSource);
exoPlayer.prepare();
exoPlayer.setPlayWhenReady(true);
exoPlayer.play();

// ............................................................
..............................
brightnessVolumeContainer = findViewById(R.id.brightness_volume_container);
brightnessIcon = findViewById(R.id.brightness_icon);
volumeIcon = findViewById(R.id.volume_icon);
brightVolumeTV = findViewById(R.id.brightness_volume_tv);
audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++
/* This block of codes set the current device volume and brightness to the video on startup */
brightness = (int) (getCurrentScreenBrightness() * 100);
setVolumeVariable();

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

playerView.setOnTouchListener((view, motionEvent) -> {

gestureDetectorCompat.onTouchEvent(motionEvent);

if (motionEvent.getAction() == MotionEvent.ACTION_UP) {
brightnessVolumeContainer.setVisibility(View.GONE);

if (!shouldShowController) {

playerView.setUseController(false);

new Handler().postDelayed(() -> {

shouldShowController = true;
playerView.setUseController(true);
}, 500);
}
}

if (motionEvent.getAction() == MotionEvent.ACTION_DOWN) {
touchPositionX = (int) motionEvent.getX();
}
return false;
});
// ..........................................................................................

// ************************************************************
******************************
gestureDetectorCompat = new GestureDetectorCompat(this, new GestureDetector.
OnGestureListener() {
@Override
public boolean onDown(@NonNull MotionEvent motionEvent) {
return false;
}

@Override
public void onShowPress(@NonNull MotionEvent motionEvent) {

@Override
public boolean onSingleTapUp(@NonNull MotionEvent motionEvent) {
return false;
}

@Override
public void onLongPress(@NonNull MotionEvent motionEvent) {

@Override
public boolean onFling(MotionEvent motionEvent, @NonNull MotionEvent motionEvent1, float
v, float v1) {
return false;
}

@Override
public boolean onScroll(MotionEvent motionEvent, @NonNull MotionEvent motionEvent1, float
distanceX, float distanceY) {

int deviceWidth = Resources.getSystem().getDisplayMetrics().widthPixels;

if (Math.abs(distanceY) > Math.abs(distanceX)) {

brightnessVolumeContainer.setVisibility(View.VISIBLE);

shouldShowController = false;

if (motionEvent.getX() < deviceWidth / 2) {

volumeIcon.setVisibility(View.GONE);
brightnessIcon.setVisibility(View.VISIBLE);

boolean increase = distanceY > 0;

int newValue = (increase) ? brightness + 1 : brightness - 1;

if (newValue >= 0 && newValue <= SHOW_MAX_BRIGHTNESS) {

brightness = newValue;
}

brightVolumeTV.setText(String.valueOf(brightness));
setScreenBrightness(brightness);
} else {

if (audioManager != null) {

volumeIcon.setVisibility(View.VISIBLE);
brightnessIcon.setVisibility(View.GONE);

boolean increase = distanceY > 0;

int newValue = (increase) ? volume + 1 : volume - 1;

if (newValue >= 0 && newValue <= SHOW_MAX_VOLUME) {

volume = newValue;
}

brightVolumeTV.setText(String.valueOf(volume));
setVolume(volume);
 }
}
}
return true;
}
});

ImageView backButton = playerView.findViewById(R.id.Back_Button);

backButton.setOnClickListener(v -> {
MappingTrackSelector.MappedTrackInfo mappedTrackInfo = defaultTrackSelector.
getCurrentMappedTrackInfo();

if (mappedTrackInfo == null) {
Toast.makeText(this, "No subtitle tracks found", Toast.LENGTH_SHORT).show();
return;
}

for (int rendererIndex = 0; rendererIndex < mappedTrackInfo.getRendererCount();

rendererIndex++) {
if (mappedTrackInfo.getRendererType(rendererIndex) == C.TRACK_TYPE_TEXT) {

TrackGroupArray trackGroups = mappedTrackInfo.getTrackGroups(rendererIndex);

int trackCount = trackGroups.length;
String[] subtitleNames = new String[trackCount +1];//+1
subtitleNames[0] = "Disable";

int checkedItem = 0; // default: subtitles off

for (int i = 0; i < trackCount; i++) {

Format format = trackGroups.get(i).getFormat(0);
String label = (format.label != null) ? format.label :
(format.language != null ? new Locale(format.language).
getDisplayLanguage() : "Subtitle" + (i + 1));//Subtitle
subtitleNames[i +1] = label;//+1

// Currently selected subtitle

Tracks currentTracks = exoPlayer.getCurrentTracks();
for (Tracks.Group group : currentTracks.getGroups()) {
if (group.getType() == C.TRACK_TYPE_TEXT &&
group.isSelected() &&
group.getMediaTrackGroup().equals(trackGroups.get(i))) {
checkedItem = i + 1;//+1
}
}
}

final int[] selectedIndex = {checkedItem}; // use array to modify in inner class

//final int finalRendererIndex = rendererIndex;

AlertDialog.Builder builder = new AlertDialog.Builder(this);

builder.setTitle("Select Subtitle");

builder.setSingleChoiceItems(subtitleNames, checkedItem, (dialog, which) -> {

selectedIndex[0] = which; // store selected index
});

builder.setPositiveButton("OK", (dialog, which) -> {

TrackSelectionParameters.Builder paramsBuilder = defaultTrackSelector.
getParameters().buildUpon();

if (selectedIndex[0] == 0) {
// Turn off subtitles
paramsBuilder.setTrackTypeDisabled(C.TRACK_TYPE_TEXT, true);
//paramsBuilder.setTrackTypeDisabled(finalRendererIndex, true);
} else {
TrackGroup selectedGroup = trackGroups.get(selectedIndex[0] -1);//-1
TrackSelectionOverride override = new TrackSelectionOverride(
selectedGroup, 0);
paramsBuilder.setTrackTypeDisabled(C.TRACK_TYPE_TEXT, false)
.clearOverridesOfType(C.TRACK_TYPE_TEXT)
.addOverride(override);
 }

defaultTrackSelector.setParameters(paramsBuilder.build());
Toast.makeText(this, "Subtitle updated"+subtitleNames[selectedIndex[0]],
Toast.LENGTH_SHORT).show();
});

builder.setNegativeButton("Cancel", null);
builder.show();
break;

}
});

LinearLayout Ratio = playerView.findViewById(R.id.Ratio);

Ratio.setOnClickListener(v -> {
MappingTrackSelector.MappedTrackInfo mappedTrackInfo = defaultTrackSelector.
getCurrentMappedTrackInfo();
if (mappedTrackInfo == null) {
Toast.makeText(this, "No tracks available", Toast.LENGTH_SHORT).show();
return;
}

for (int rendererIndex = 0; rendererIndex < mappedTrackInfo.getRendererCount();

rendererIndex++) {
if (mappedTrackInfo.getRendererType(rendererIndex) == C.TRACK_TYPE_AUDIO) {
TrackGroupArray trackGroups = mappedTrackInfo.getTrackGroups(rendererIndex);

String[] languageNames = new String[trackGroups.length];

int checkedItem = -1;

for (int i = 0; i < trackGroups.length; i++) {

Format format = trackGroups.get(i).getFormat(0);
String languageCode = format.language;
String label = format.label;

if (label != null && !label.isEmpty()) {

languageNames[i] = label;
} else if (languageCode != null) {
Locale locale = new Locale(languageCode);
languageNames[i] = locale.getDisplayLanguage();
} else {
languageNames[i] = "Unknown Language";
}

// Check if this track is currently selected

Tracks currentTracks =exoPlayer.getCurrentTracks();
for (Tracks.Group group : currentTracks.getGroups()) {
if (group.getType() == C.TRACK_TYPE_AUDIO &&
group.isSelected() &&
group.getMediaTrackGroup().equals(trackGroups.get(i))) {
checkedItem = i;
selectedIndex[0] = i;
break;
}
}
}

AlertDialog.Builder builder = new AlertDialog.Builder(this);

builder.setTitle("Select Audio Language");
builder.setSingleChoiceItems(languageNames, checkedItem, (dialog, which) ->
selectedIndex[0] = which);
builder.setPositiveButton("Ok", (dialogInterface, i) -> {
TrackGroup selectedGroup = trackGroups.get(selectedIndex[0]);
TrackSelectionOverride override = new TrackSelectionOverride(selectedGroup,
0);
TrackSelectionParameters newParams = defaultTrackSelector
.getParameters()
 .buildUpon()
.setOverrideForType(override)
.build();

defaultTrackSelector.setParameters(newParams);
Toast.makeText(this, "Switched to " +languageNames[selectedIndex[0]],
Toast.LENGTH_SHORT).show();
});
builder.setNegativeButton("Cancel", null);
builder.show();
break;
}
}
});
// ******************************************************************************************

String[] groupName = { "0.5x", "1.0x", "1.5x", "2.0x" };

float[] playerSpeedGroup = { 0.5f, 1f, 1.5f, 2f };
final int[] selectedGroup = {1};
final int[] tempSelectedGroup = {1};
LinearLayout speed = playerView.findViewById(R.id.Speed_Button);
speed.setOnClickListener(v -> {
AlertDialog.Builder alt_bld = new AlertDialog.Builder(this, R.style.AlertDialogTheme);
alt_bld.setTitle("Select Player Speed");
alt_bld.setSingleChoiceItems(groupName, selectedGroup[0], new DialogInterface
.OnClickListener() {
public void onClick(DialogInterface dialog, int item) {
tempSelectedGroup[0] = item;

}
})
.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
PlaybackParameters param = new PlaybackParameters(playerSpeed
Group[tempSelectedGroup[0]]);
exoPlayer.setPlaybackParameters(param);
selectedGroup[0] = tempSelectedGroup[0];
dialog.dismiss();
Speed_txt = groupName[selectedGroup[0]];
Toast.makeText(PlayerActivity.this, "Speed:"+groupName[selectedGroup[0]],
Toast.LENGTH_SHORT).show();
}
})
.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
}
});
AlertDialog alert = alt_bld.create();
alert.show();

});

ImageView unlock_button = playerView.findViewById(R.id.UnLock_Button);

ImageView lock_button = playerView.findViewById(R.id.Lock_Button);
ConstraintLayout constraintLayout = playerView.findViewById(R.id.custom_control);
lock_button.setOnClickListener(v -> {
// controlsMode = ControlsMode.FULLSCREEN;
constraintLayout.setVisibility(View.VISIBLE);
lock_button.setVisibility(View.INVISIBLE);
});
unlock_button.setOnClickListener(v -> {
// controlsMode = ControlsMode.LOCK;
constraintLayout.setVisibility(View.INVISIBLE);
lock_button.setVisibility(View.VISIBLE);
});

ImageView setting_btn = playerView.findViewById(R.id.Setting_Button);

setting_btn.setOnClickListener(v -> {
 ShowDialog();
});

TextView title = playerView.findViewById(R.id.Exo_Title);

ImageView resize = playerView.findViewById(R.id.Resize_Button);
ImageView fullscreen = playerView.findViewById(R.id.Full_Button);
fullscreen.setOnClickListener(v -> {
if (isFullScreen) {
if (getSupportActionBar() != null) {
getSupportActionBar().show();
}
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
//
LinearLayout controls = playerView.findViewById(R.id.LinearSetting);
controls.setVisibility(View.GONE);
title.setVisibility(View.GONE);
resize.setVisibility(View.GONE);
unlock_button.setVisibility(View.GONE);
setting_btn.setVisibility(View.VISIBLE);
//
fullscreen.setImageDrawable(ContextCompat.getDrawable(PlayerActivity.this,
R.drawable.full_close));
ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams)
playerView.getLayoutParams();
params.width = params.MATCH_PARENT;
params.height = (int) (200 * getApplicationContext().getResources().
getDisplayMetrics().density);
playerView.setLayoutParams(params);
isFullScreen = false;
} else {
if (getSupportActionBar() != null) {
getSupportActionBar().hide();
}
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
| View.SYSTEM_UI_FLAG_HIDE_NAVIGATION);
//
LinearLayout controls = playerView.findViewById(R.id.LinearSetting);
controls.setVisibility(View.VISIBLE);
title.setVisibility(View.VISIBLE);
resize.setVisibility(View.VISIBLE);
unlock_button.setVisibility(View.VISIBLE);
setting_btn.setVisibility(View.GONE);
//
fullscreen.setImageDrawable(ContextCompat.getDrawable(PlayerActivity.this,
R.drawable.full_open));
ConstraintLayout.LayoutParams params = (ConstraintLayout.LayoutParams)
playerView.getLayoutParams();
params.width = params.MATCH_PARENT;
params.height = params.MATCH_PARENT;
playerView.setLayoutParams(params);
isFullScreen = true;

}
});

LinearLayout setting = playerView.findViewById(R.id.Video_Button);

setting.setOnClickListener(v -> {
if (videoQualities != null) {
if (videoQualities.size() > 0) {
getQualityChooserDialog(this, videoQualities);
} else {
Toast.makeText(this, "No video quality found.", Toast.LENGTH_SHORT).show();
}
} else {
Toast.makeText(this, "Wait until video start.", Toast.LENGTH_SHORT).show();
}
});
 exoPlayer.addListener(new Player.Listener() {
@Override
public void onPlaybackStateChanged(int state) {
if (state == Player.STATE_READY) {
videoQualities = getVideoQualitiesTracks();
} else if (state == Player.STATE_BUFFERING) {

} else {

}
}
});
}

private MediaSource buildMediaSource(Uri uri) {

int contentType = Util.inferContentType(uri);
MediaItem mediaItem = MediaItem.fromUri(uri);
if (contentType==C.CONTENT_TYPE_RTSP) {
Toast.makeText(this, "RTSP", Toast.LENGTH_SHORT).show();
return new RtspMediaSource.Factory().createMediaSource(mediaItem);
} else if (contentType==C.CONTENT_TYPE_HLS) {
Toast.makeText(this, "HLS", Toast.LENGTH_SHORT).show();
return new HlsMediaSource.Factory(dataSourceFactory).createMediaSource(mediaItem);
} else if (contentType==C.CONTENT_TYPE_DASH) {
Toast.makeText(this, "DASH", Toast.LENGTH_SHORT).show();
return new DashMediaSource.Factory(dataSourceFactory).createMediaSource(mediaItem);
} else if (contentType==C.CONTENT_TYPE_SS) {
Toast.makeText(this, "SS", Toast.LENGTH_SHORT).show();
return new SsMediaSource.Factory(dataSourceFactory).createMediaSource(mediaItem);
} else {
Toast.makeText(this, "PMS", Toast.LENGTH_SHORT).show();
return new ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(mediaItem);
}
}
private void ShowDialog() {
final Dialog dialog = new Dialog(this);
dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
dialog.setContentView(R.layout.bottom_sheet);
TextView speed_txt = dialog.findViewById(R.id.Speed_bottom);
speed_txt.setText(Speed_txt);

Objects.requireNonNull(dialog.getWindow()).setLayout(ViewGroup.LayoutParams.MATCH_
PARENT,ViewGroup.LayoutParams.WRAP_CONTENT);
dialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
dialog.getWindow().getAttributes().windowAnimations = R.style.DialogAnimation;
dialog.getWindow().setGravity(Gravity.BOTTOM);
dialog.show();

private ArrayList<String> getVideoQualitiesTracks() {

ArrayList<String> videoQualities = new ArrayList<>();

MappingTrackSelector.MappedTrackInfo renderTrack = defaultTrackSelector.

getCurrentMappedTrackInfo();
assert renderTrack != null;
int renderCount = renderTrack.getRendererCount();

for (int rendererIndex = 0; rendererIndex < renderCount; rendererIndex++) {

if (isSupportedFormat(renderTrack, rendererIndex)) {

int trackGroupType = renderTrack.getRendererType(rendererIndex);

TrackGroupArray trackGroups = renderTrack.getTrackGroups(rendererIndex);
int trackGroupsCount = trackGroups.length;

if (trackGroupType == C.TRACK_TYPE_VIDEO) {

for (int groupIndex = 0; groupIndex < trackGroupsCount; groupIndex++) {

 int videoQualityTrackCount = trackGroups.get(groupIndex).length;

for (int trackIndex = 0; trackIndex < videoQualityTrackCount; trackIndex++) {

boolean isTrackSupported = renderTrack.getTrackSupport(rendererIndex,

groupIndex, trackIndex) == C.FORMAT_HANDLED;

if (isTrackSupported) {

TrackGroup track = trackGroups.get(groupIndex);

int videoWidth = track.getFormat(trackIndex).width;

int videoHeight = track.getFormat(trackIndex).height;

String quality = videoWidth + "x" + videoHeight;

videoQualities.add(quality);
}
}
}
}
}
}

return videoQualities;
}

private boolean isSupportedFormat(MappingTrackSelector.MappedTrackInfo mappedTrackInfo, int

rendererIndex) {

TrackGroupArray trackGroupArray = mappedTrackInfo.getTrackGroups(rendererIndex);

if (trackGroupArray.length == 0) {
return false;
} else {
return mappedTrackInfo.getRendererType(rendererIndex) == C.TRACK_TYPE_VIDEO;
}
}
//______________________________________________________________________________________________

// private void getQualityChooserDialog(Context context, ArrayList<String> arrayList) {

// CharSequence[] charSequences = new CharSequence[arrayList.size() + 1];
// charSequences[0] = "Auto";
//
// for (int i = 0; i < arrayList.size(); i++) {
// charSequences[i + 1] = arrayList.get(i); //.split("x")[1] + "p";
// }
//
// MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(context);
// builder.setTitle("Select video quality:");
// builder.setSingleChoiceItems(charSequences, selectedQualityIndex, (dialogInterface, which) -
> selectedQualityIndex = which);
// builder.setPositiveButton("Ok", (dialogInterface, i) -> {
//
// if (selectedQualityIndex == 0) {
// Toast.makeText(context, context.getText(R.string.app_name) + " will choose video
resolution automatically.", Toast.LENGTH_SHORT).show();
// defaultTrackSelector.setParameters(defaultTrackSelector.buildUponParameters().
setMaxVideoSizeSd());
// } else {
// String[] videoQualityInfo = arrayList.get(selectedQualityIndex - 1).split("x");
//
// Toast.makeText(context, "Video will be played with " + videoQualityInfo[1] + "p
resolution.", Toast.LENGTH_SHORT).show();
//
// int videoWidth = Integer.parseInt(videoQualityInfo[0]);
// int videoHeight = Integer.parseInt(videoQualityInfo[1]);
//
// defaultTrackSelector.setParameters(
// defaultTrackSelector
// .buildUponParameters()
// .setMaxVideoSize(videoWidth, videoHeight)
// .setMinVideoSize(videoWidth, videoHeight)
// );
// }
// });
// builder.setNegativeButton("Cancel", (dialogInterface, i) -> dialogInterface.cancel());
// builder.show();
// }

private void getQualityChooserDialog(Context context, ArrayList<String> arrayList) {

CharSequence[] charSequences = new CharSequence[arrayList.size() + 1];
charSequences[0] = "Auto";

for (int i = 0; i < arrayList.size(); i++) {

charSequences[i + 1] = arrayList.get(i); //.split("x")[1] + "p";
}

AlertDialog.Builder builder = new AlertDialog.Builder(context, R.style.AlertDialogTheme);

builder.setTitle("Video Quality");
builder.setSingleChoiceItems(charSequences, selectedQualityIndex, (dialogInterface, which) ->
selectedQualityIndex = which);
builder.setPositiveButton("Ok", (dialogInterface, i) -> {

if (selectedQualityIndex == 0) {
Toast.makeText(context, context.getText(R.string.app_name) + " will choose video
resolution automatically.", Toast.LENGTH_SHORT).show();
defaultTrackSelector.setParameters(defaultTrackSelector.buildUponParameters().
setMaxVideoSizeSd());
} else {
String[] videoQualityInfo = arrayList.get(selectedQualityIndex - 1).split("x");

Toast.makeText(context, "Video will be played with " + videoQualityInfo[1] + "p

resolution.", Toast.LENGTH_SHORT).show();

int videoWidth = Integer.parseInt(videoQualityInfo[0]);

int videoHeight = Integer.parseInt(videoQualityInfo[1]);

defaultTrackSelector.setParameters(
defaultTrackSelector
.buildUponParameters()
.setMaxVideoSize(videoWidth, videoHeight)
.setMinVideoSize(videoWidth, videoHeight)
);
}
});
builder.setNegativeButton("Cancel", (dialogInterface, i) -> dialogInterface.cancel());
builder.show();
}

//______________________________________________________________________________________________

//______________________________________________________________________________________________

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {

if (keyCode == KeyEvent.KEYCODE_VOLUME_UP || keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {

setVolumeVariable();
}
return super.onKeyUp(keyCode, event);
}
private void setScreenBrightness(int brightness1) {

float d = 1.0f / SHOW_MAX_BRIGHTNESS;

WindowManager.LayoutParams lp = getWindow().getAttributes();

lp.screenBrightness = d * brightness1;

getWindow().setAttributes(lp);
}

private float getCurrentScreenBrightness() {

 // Get the current screen brightness value
int currentBrightness = 0;
try {
currentBrightness = Settings.System.getInt(
getContentResolver(),
Settings.System.SCREEN_BRIGHTNESS
);
} catch (Settings.SettingNotFoundException e) {
Log.e(TAG, "getCurrentScreenBrightness: ", e);
}

// Get the maximum brightness value supported by the device's screen

int maxBrightness = 255; // Default value; you can get the actual maximum brightness using
system APIs

// Calculate the brightness value in the range [0, 1.0]

float brightnessValue = (float) currentBrightness / maxBrightness;

// Clamp the brightnessValue to the range [0, 1.0]

brightnessValue = Math.max(0f, Math.min(1.0f, brightnessValue));

return brightnessValue;
}

private void setVolume(int volume1) {

int maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);

float d = (maxVolume * 1.0f) / SHOW_MAX_VOLUME;

int newVolume = (int) (d * volume1);

if (newVolume > maxVolume) {

newVolume = maxVolume;
}
if (volume1 == SHOW_MAX_VOLUME && newVolume < maxVolume) {
newVolume = maxVolume;
}

audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, newVolume, 0);

}

private void setVolumeVariable() {

volume = (int) ((audioManager.getStreamVolume(AudioManager.STREAM_MUSIC) * 1.0f) /

audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC) * SHOW_MAX_VOLUME);

if (volume > SHOW_MAX_VOLUME) {

volume = SHOW_MAX_VOLUME;
}
}
//______________________________________________________________________________________________
@Override
protected void onResume() {
super.onResume();
exoPlayer.play();
if (brightness > 0) {
setScreenBrightness(brightness);
}
setVolume(volume);
}

@Override
protected void onPause() {
super.onPause();
exoPlayer.pause();
}

@Override
protected void onDestroy() {
exoPlayer.release();
 super.onDestroy();
}
}