Scribd
Upload
9 views13 pages

Android ExoPlayer Source Code Overview

The document contains Java code for an Android application that implements a media player using ExoPlayer. It includes functionalities for video playback, subtitle selection, audio track selection, and volume/brightness control through gestures. The code also manages UI elements and user interactions to enhance the media playback experience.

Uploaded by

Ps Ps
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
9 views13 pages

Android ExoPlayer Source Code Overview

The document contains Java code for an Android application that implements a media player using ExoPlayer. It includes functionalities for video playback, subtitle selection, audio track selection, and volume/brightness control through gestures. The code also manages UI elements and user interactions to enhance the media playback experience.

Uploaded by

Ps Ps
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

java code

1 message

Rahul Singh <ps8303383@[Link]> Thu, Jun 19, 2025 at 3:32 PM


To: Pritesh Singh <priteshsingh8303@[Link]>

package [Link].ecoplayer2025;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].C;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];

@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";

//--------------
[Link] dataSourceFactory;

@SuppressLint("ClickableViewAccessibility")
@Override
protected void onCreate(Bundle savedInstanceState) {
[Link](savedInstanceState);
[Link](this);
[Link](getWindow(), getWindow().getDecorView()).
setAppearanceLightStatusBars(false);
[Link](getWindow(), getWindow().getDecorView()).
setAppearanceLightNavigationBars(false);
if ([Link].SDK_INT >= Build.VERSION_CODES.Q) {
getWindow().setNavigationBarContrastEnforced(false);
}
setContentView([Link].activity_player);
[Link](findViewById([Link]), (v, insets) -> {
Insets systemBars = [Link]([Link]());
[Link]([Link], [Link], [Link], [Link]);
return insets;
});
String stream = getIntent().getStringExtra("url");

[Link] videoTrackSelectionFactory = new [Link]();

defaultTrackSelector = new DefaultTrackSelector(this, videoTrackSelectionFactory);

DefaultRenderersFactory renderersFactory = new DefaultRenderersFactory(this)


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

playerView = findViewById([Link].player_view);
Uri uri = [Link](stream);
dataSourceFactory = new [Link]();
MediaSource mediaSource = buildMediaSource(uri);
exoPlayer = new [Link](this, renderersFactory)
.setTrackSelector(defaultTrackSelector)
.build();
[Link](exoPlayer);

[Link](mediaSource);
[Link]();
[Link](true);
[Link]();

// ............................................................
..............................
brightnessVolumeContainer = findViewById([Link].brightness_volume_container);
brightnessIcon = findViewById([Link].brightness_icon);
volumeIcon = findViewById([Link].volume_icon);
brightVolumeTV = findViewById([Link].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();

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

[Link]((view, motionEvent) -> {

[Link](motionEvent);

if ([Link]() == MotionEvent.ACTION_UP) {
[Link]([Link]);

if (!shouldShowController) {

[Link](false);

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


shouldShowController = true;
[Link](true);
}, 500);
}
}

if ([Link]() == MotionEvent.ACTION_DOWN) {
touchPositionX = (int) [Link]();
}
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 = [Link]().getDisplayMetrics().widthPixels;

if ([Link](distanceY) > [Link](distanceX)) {

[Link]([Link]);

shouldShowController = false;

if ([Link]() < deviceWidth / 2) {

[Link]([Link]);
[Link]([Link]);

boolean increase = distanceY > 0;

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

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


brightness = newValue;
}

[Link]([Link](brightness));
setScreenBrightness(brightness);
} else {

if (audioManager != null) {

[Link]([Link]);
[Link]([Link]);

boolean increase = distanceY > 0;

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

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


volume = newValue;
}

[Link]([Link](volume));
setVolume(volume);
}
}
}
return true;
}
});

ImageView backButton = [Link]([Link].Back_Button);


[Link](v -> {
[Link] mappedTrackInfo = defaultTrackSelector.
getCurrentMappedTrackInfo();

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

for (int rendererIndex = 0; rendererIndex < [Link]();


rendererIndex++) {
if ([Link](rendererIndex) == C.TRACK_TYPE_TEXT) {

TrackGroupArray trackGroups = [Link](rendererIndex);


int trackCount = [Link];
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 = [Link](i).getFormat(0);
String label = ([Link] != null) ? [Link] :
([Link] != null ? new Locale([Link]).
getDisplayLanguage() : "Subtitle" + (i + 1));//Subtitle
subtitleNames[i +1] = label;//+1

// Currently selected subtitle


Tracks currentTracks = [Link]();
for ([Link] group : [Link]()) {
if ([Link]() == C.TRACK_TYPE_TEXT &&
[Link]() &&
[Link]().equals([Link](i))) {
checkedItem = i + 1;//+1
}
}
}

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


//final int finalRendererIndex = rendererIndex;

[Link] builder = new [Link](this);


[Link]("Select Subtitle");

[Link](subtitleNames, checkedItem, (dialog, which) -> {


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

[Link]("OK", (dialog, which) -> {


[Link] paramsBuilder = defaultTrackSelector.
getParameters().buildUpon();

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

[Link]([Link]());
[Link](this, "Subtitle updated"+subtitleNames[selectedIndex[0]],
Toast.LENGTH_SHORT).show();
});

[Link]("Cancel", null);
[Link]();
break;

}
});

LinearLayout Ratio = [Link]([Link]);


[Link](v -> {
[Link] mappedTrackInfo = defaultTrackSelector.
getCurrentMappedTrackInfo();
if (mappedTrackInfo == null) {
[Link](this, "No tracks available", Toast.LENGTH_SHORT).show();
return;
}

for (int rendererIndex = 0; rendererIndex < [Link]();


rendererIndex++) {
if ([Link](rendererIndex) == C.TRACK_TYPE_AUDIO) {
TrackGroupArray trackGroups = [Link](rendererIndex);

String[] languageNames = new String[[Link]];


int checkedItem = -1;

for (int i = 0; i < [Link]; i++) {


Format format = [Link](i).getFormat(0);
String languageCode = [Link];
String label = [Link];

if (label != null && ![Link]()) {


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

// Check if this track is currently selected


Tracks currentTracks =[Link]();
for ([Link] group : [Link]()) {
if ([Link]() == C.TRACK_TYPE_AUDIO &&
[Link]() &&
[Link]().equals([Link](i))) {
checkedItem = i;
selectedIndex[0] = i;
break;
}
}
}

[Link] builder = new [Link](this);


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

[Link](newParams);
[Link](this, "Switched to " +languageNames[selectedIndex[0]],
Toast.LENGTH_SHORT).show();
});
[Link]("Cancel", null);
[Link]();
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 = [Link]([Link].Speed_Button);
[Link](v -> {
[Link] alt_bld = new [Link](this, [Link]);
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 [Link]() {
@Override
public void onClick(DialogInterface dialog, int which) {
PlaybackParameters param = new PlaybackParameters(playerSpeed
Group[tempSelectedGroup[0]]);
[Link](param);
selectedGroup[0] = tempSelectedGroup[0];
[Link]();
Speed_txt = groupName[selectedGroup[0]];
[Link]([Link], "Speed:"+groupName[selectedGroup[0]],
Toast.LENGTH_SHORT).show();
}
})
.setNegativeButton("Cancel", new [Link]() {
@Override
public void onClick(DialogInterface dialog, int which) {
[Link]();
}
});
AlertDialog alert = alt_bld.create();
[Link]();

});

ImageView unlock_button = [Link]([Link].UnLock_Button);


ImageView lock_button = [Link]([Link].Lock_Button);
ConstraintLayout constraintLayout = [Link]([Link].custom_control);
lock_button.setOnClickListener(v -> {
// controlsMode = [Link];
[Link]([Link]);
lock_button.setVisibility([Link]);
});
unlock_button.setOnClickListener(v -> {
// controlsMode = [Link];
[Link]([Link]);
lock_button.setVisibility([Link]);
});

ImageView setting_btn = [Link]([Link].Setting_Button);


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

TextView title = [Link]([Link].Exo_Title);


ImageView resize = [Link]([Link].Resize_Button);
ImageView fullscreen = [Link]([Link].Full_Button);
[Link](v -> {
if (isFullScreen) {
if (getSupportActionBar() != null) {
getSupportActionBar().show();
}
getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
//
LinearLayout controls = [Link]([Link]);
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
unlock_button.setVisibility([Link]);
setting_btn.setVisibility([Link]);
//
[Link]([Link]([Link],
[Link].full_close));
[Link] params = ([Link])
[Link]();
[Link] = params.MATCH_PARENT;
[Link] = (int) (200 * getApplicationContext().getResources().
getDisplayMetrics().density);
[Link](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 = [Link]([Link]);
[Link]([Link]);
[Link]([Link]);
[Link]([Link]);
unlock_button.setVisibility([Link]);
setting_btn.setVisibility([Link]);
//
[Link]([Link]([Link],
[Link].full_open));
[Link] params = ([Link])
[Link]();
[Link] = params.MATCH_PARENT;
[Link] = params.MATCH_PARENT;
[Link](params);
isFullScreen = true;

}
});

LinearLayout setting = [Link]([Link].Video_Button);


[Link](v -> {
if (videoQualities != null) {
if ([Link]() > 0) {
getQualityChooserDialog(this, videoQualities);
} else {
[Link](this, "No video quality found.", Toast.LENGTH_SHORT).show();
}
} else {
[Link](this, "Wait until video start.", Toast.LENGTH_SHORT).show();
}
});
[Link](new [Link]() {
@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 = [Link](uri);
MediaItem mediaItem = [Link](uri);
if (contentType==C.CONTENT_TYPE_RTSP) {
[Link](this, "RTSP", Toast.LENGTH_SHORT).show();
return new [Link]().createMediaSource(mediaItem);
} else if (contentType==C.CONTENT_TYPE_HLS) {
[Link](this, "HLS", Toast.LENGTH_SHORT).show();
return new [Link](dataSourceFactory).createMediaSource(mediaItem);
} else if (contentType==C.CONTENT_TYPE_DASH) {
[Link](this, "DASH", Toast.LENGTH_SHORT).show();
return new [Link](dataSourceFactory).createMediaSource(mediaItem);
} else if (contentType==C.CONTENT_TYPE_SS) {
[Link](this, "SS", Toast.LENGTH_SHORT).show();
return new [Link](dataSourceFactory).createMediaSource(mediaItem);
} else {
[Link](this, "PMS", Toast.LENGTH_SHORT).show();
return new [Link](dataSourceFactory).createMediaSource(mediaItem);
}
}
private void ShowDialog() {
final Dialog dialog = new Dialog(this);
[Link](Window.FEATURE_NO_TITLE);
[Link]([Link].bottom_sheet);
TextView speed_txt = [Link]([Link].Speed_bottom);
speed_txt.setText(Speed_txt);

[Link]([Link]()).setLayout([Link].MATCH_
PARENT,[Link].WRAP_CONTENT);
[Link]().setBackgroundDrawable(new ColorDrawable([Link]));
[Link]().getAttributes().windowAnimations = [Link];
[Link]().setGravity([Link]);
[Link]();

private ArrayList<String> getVideoQualitiesTracks() {

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

[Link] renderTrack = defaultTrackSelector.


getCurrentMappedTrackInfo();
assert renderTrack != null;
int renderCount = [Link]();

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

if (isSupportedFormat(renderTrack, rendererIndex)) {

int trackGroupType = [Link](rendererIndex);


TrackGroupArray trackGroups = [Link](rendererIndex);
int trackGroupsCount = [Link];

if (trackGroupType == C.TRACK_TYPE_VIDEO) {

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


int videoQualityTrackCount = [Link](groupIndex).length;

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

boolean isTrackSupported = [Link](rendererIndex,


groupIndex, trackIndex) == C.FORMAT_HANDLED;

if (isTrackSupported) {

TrackGroup track = [Link](groupIndex);

int videoWidth = [Link](trackIndex).width;


int videoHeight = [Link](trackIndex).height;

String quality = videoWidth + "x" + videoHeight;


[Link](quality);
}
}
}
}
}
}

return videoQualities;
}

private boolean isSupportedFormat([Link] mappedTrackInfo, int


rendererIndex) {

TrackGroupArray trackGroupArray = [Link](rendererIndex);


if ([Link] == 0) {
return false;
} else {
return [Link](rendererIndex) == C.TRACK_TYPE_VIDEO;
}
}
//______________________________________________________________________________________________

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


// CharSequence[] charSequences = new CharSequence[[Link]() + 1];
// charSequences[0] = "Auto";
//
// for (int i = 0; i < [Link](); i++) {
// charSequences[i + 1] = [Link](i); //.split("x")[1] + "p";
// }
//
// MaterialAlertDialogBuilder builder = new MaterialAlertDialogBuilder(context);
// [Link]("Select video quality:");
// [Link](charSequences, selectedQualityIndex, (dialogInterface, which) -
> selectedQualityIndex = which);
// [Link]("Ok", (dialogInterface, i) -> {
//
// if (selectedQualityIndex == 0) {
// [Link](context, [Link]([Link].app_name) + " will choose video
resolution automatically.", Toast.LENGTH_SHORT).show();
// [Link]([Link]().
setMaxVideoSizeSd());
// } else {
// String[] videoQualityInfo = [Link](selectedQualityIndex - 1).split("x");
//
// [Link](context, "Video will be played with " + videoQualityInfo[1] + "p
resolution.", Toast.LENGTH_SHORT).show();
//
// int videoWidth = [Link](videoQualityInfo[0]);
// int videoHeight = [Link](videoQualityInfo[1]);
//
// [Link](
// defaultTrackSelector
// .buildUponParameters()
// .setMaxVideoSize(videoWidth, videoHeight)
// .setMinVideoSize(videoWidth, videoHeight)
// );
// }
// });
// [Link]("Cancel", (dialogInterface, i) -> [Link]());
// [Link]();
// }

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


CharSequence[] charSequences = new CharSequence[[Link]() + 1];
charSequences[0] = "Auto";

for (int i = 0; i < [Link](); i++) {


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

[Link] builder = new [Link](context, [Link]);


[Link]("Video Quality");
[Link](charSequences, selectedQualityIndex, (dialogInterface, which) ->
selectedQualityIndex = which);
[Link]("Ok", (dialogInterface, i) -> {

if (selectedQualityIndex == 0) {
[Link](context, [Link]([Link].app_name) + " will choose video
resolution automatically.", Toast.LENGTH_SHORT).show();
[Link]([Link]().
setMaxVideoSizeSd());
} else {
String[] videoQualityInfo = [Link](selectedQualityIndex - 1).split("x");

[Link](context, "Video will be played with " + videoQualityInfo[1] + "p


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

int videoWidth = [Link](videoQualityInfo[0]);


int videoHeight = [Link](videoQualityInfo[1]);

[Link](
defaultTrackSelector
.buildUponParameters()
.setMaxVideoSize(videoWidth, videoHeight)
.setMinVideoSize(videoWidth, videoHeight)
);
}
});
[Link]("Cancel", (dialogInterface, i) -> [Link]());
[Link]();
}

//______________________________________________________________________________________________

//______________________________________________________________________________________________

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

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


setVolumeVariable();
}
return [Link](keyCode, event);
}
private void setScreenBrightness(int brightness1) {

float d = 1.0f / SHOW_MAX_BRIGHTNESS;

[Link] lp = getWindow().getAttributes();

[Link] = d * brightness1;

getWindow().setAttributes(lp);
}

private float getCurrentScreenBrightness() {


// Get the current screen brightness value
int currentBrightness = 0;
try {
currentBrightness = [Link](
getContentResolver(),
[Link].SCREEN_BRIGHTNESS
);
} catch ([Link] 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 = [Link](0f, [Link](1.0f, brightnessValue));

return brightnessValue;
}

private void setVolume(int volume1) {

int maxVolume = [Link](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;
}

[Link](AudioManager.STREAM_MUSIC, newVolume, 0);


}

private void setVolumeVariable() {

volume = (int) (([Link](AudioManager.STREAM_MUSIC) * 1.0f) /


[Link](AudioManager.STREAM_MUSIC) * SHOW_MAX_VOLUME);

if (volume > SHOW_MAX_VOLUME) {


volume = SHOW_MAX_VOLUME;
}
}
//______________________________________________________________________________________________
@Override
protected void onResume() {
[Link]();
[Link]();
if (brightness > 0) {
setScreenBrightness(brightness);
}
setVolume(volume);
}

@Override
protected void onPause() {
[Link]();
[Link]();
}

@Override
protected void onDestroy() {
[Link]();
[Link]();
}
}

You might also like