Changing the video scale (Android Java)

Question

**How can I handle the scaling of my video class so that the video is displayed in different sizes! This is my code, but it doesn't work!

public class StreamingVideo extends SurfaceView implements SurfaceHolder.Callback {

    private MediaPlayer mediaPlayer;
    private OnStreamingListener onStreamingListener;

    private String uri;
    private boolean isFullscreen;
    private boolean isMuted;
    private boolean isPrepared;
    private boolean isStarted;

    private int scaleType = 0;
    public static final int SCALE_FIT = 0;
    public static final int SCALE_FILL = 1;
    public static final int SCALE_CROP = 2;

    private static final int videoWidth = 16;
    private static final int videoHeight = 9;

    public StreamingVideo(Context context) {
        super(context);
        initialize();
    }

    public StreamingVideo(Context context, AttributeSet attrs) {
        super(context, attrs);
        initialize();
    }

    private void initialize() {
        mediaPlayer = new MediaPlayer();
        mediaPlayer.setOnCompletionListener(mp -> {
            if (onStreamingListener != null) {
                onStreamingListener.onCompletion(mp);
            }
        });
        mediaPlayer.setOnErrorListener((mp, what, extra) -> {
            if (onStreamingListener != null) {
                onStreamingListener.onError(mp, what, extra);
            }
            return true;
        });
        mediaPlayer.setOnPreparedListener(mp -> {
            if (onStreamingListener != null) {
                onStreamingListener.onPrepared(mp);
            }
            isPrepared = true;
        });

        SurfaceHolder surfaceHolder = getHolder();
        surfaceHolder.addCallback(this);
    }

    public void setFullscreen(boolean fullscreen) {
        isFullscreen = fullscreen;
    }

    public void setStreaming(String uri) {
        this.uri = uri;
        if (mediaPlayer != null) {
            if (mediaPlayer.isPlaying()) {
                mediaPlayer.stop();
                mediaPlayer.reset();
                isPrepared = false;
                isStarted = false;
            }
            prepare(uri);
        }
    }

    public void fullscreen() {
        Activity activity = (Activity) getContext();
        View decorView = activity.getWindow().getDecorView();
        if (!isFullscreen) {
            decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
            if (onStreamingListener != null) {
                onStreamingListener.onFullscreeb(true);
            }
            isFullscreen = true;
        } else {
            activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
            decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);
            if (onStreamingListener != null) {
                onStreamingListener.onFullscreeb(false);
            }
            isFullscreen = false;
        }
    }

    public void mute() {
        if (mediaPlayer != null) {
            isMuted = !isMuted;
            float volume = isMuted ? 0f : 1f;
            mediaPlayer.setVolume(volume, volume);
        }
    }

    public void pause() {
        if (mediaPlayer != null && isPrepared && isStarted) {
            mediaPlayer.pause();
            isStarted = false;
        }
    }

    public void prepare(String uri) {
        try {
            mediaPlayer.setAudioAttributes(new AudioAttributes.Builder().setContentType(AudioAttributes.CONTENT_TYPE_MOVIE).build());
            mediaPlayer.setDataSource(getContext(), Uri.parse(uri));
            mediaPlayer.prepareAsync();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void play() {
        if (mediaPlayer != null && isPrepared && isStarted) {
            pause();
        } else if (mediaPlayer != null && isPrepared) {
            start();
        }
    }

    public void release() {
        if (mediaPlayer != null && isPrepared) {
            reset();
            mediaPlayer.release();
        }
    }


    public void reset() {
        if (mediaPlayer != null && isPrepared) {
            mediaPlayer.reset();
        }
    }

    public void seekTo(int position) {
        if (mediaPlayer != null && isPrepared) {
            mediaPlayer.seekTo(position);
        }
    }

    public void start() {
        if (mediaPlayer != null && isPrepared) {
            mediaPlayer.start();
            isStarted = true;
        }
    }

    public void stop() {
        if (mediaPlayer != null && isPrepared) {
            mediaPlayer.stop();
        }
    }

    @Override
    public void surfaceCreated(@NonNull SurfaceHolder holder) {
        mediaPlayer.setDisplay(holder);
        if (isPrepared && !isStarted) {
            start();
        }
    }

    @Override
    public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {

    }

    @Override
    public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
        pause();
    }

    public int getDuration() {
        if (mediaPlayer != null && isPrepared) {
            return mediaPlayer.getDuration();
        } else {
            return 0;
        }
    }

    public int getPosition() {
        if (mediaPlayer != null && isPrepared) {
            return mediaPlayer.getCurrentPosition();
        } else {
            return 0;
        }
    }

    public boolean isFullscreen() {
        return isFullscreen;
    }

    public boolean isMuted() {
        return isMuted;
    }

    public boolean isPrepared() {
        return isPrepared;
    }

    public boolean isStarted() {
        return isStarted;
    }

    public void setOnStreamingListener(OnStreamingListener onStreamingListener) {
        this.onStreamingListener = onStreamingListener;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        aspectRatio(widthMeasureSpec, heightMeasureSpec);
    }

    private void aspectRatio(int widthMeasureSpec, int heightMeasureSpec) {
        boolean isLandscape = getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);
        if (isLandscape) {
            width = Math.min(width, height * videoWidth / videoHeight);
        } else {
            height = Math.min(height, width * videoHeight / videoWidth);
        }
        setMeasuredDimension(width, height);
    }

    public String getUri() {
        if (uri != null && !uri.isEmpty()) {
            return uri;
        } else {
            return null;
        }
    }

    private void scale(int scaleType) {
        this.scaleType = scaleType;
        boolean isLandscape = getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
        int widthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY);
        int heightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY);
        int measuredWidth = getMeasuredWidth();
        int measuredHeight = getMeasuredHeight();

        switch (scaleType) {
            case SCALE_FIT:
                Toast.makeText(getContext(), "SCALE_FIT", Toast.LENGTH_SHORT).show();
                if (isLandscape) {
                    measuredWidth = Math.min(measuredWidth, measuredHeight * videoWidth / videoHeight);
                } else {
                    measuredHeight = Math.min(measuredHeight, measuredWidth * videoHeight / videoWidth);
                }
                break;
            case SCALE_FILL:
                Toast.makeText(getContext(), "SCALE_FILL", Toast.LENGTH_SHORT).show();
                if (isLandscape) {
                    measuredHeight = Math.min(measuredHeight, measuredWidth * videoHeight / videoWidth);
                } else {
                    measuredWidth = Math.min(measuredWidth, measuredHeight * videoWidth / videoHeight);
                }
                break;
            case SCALE_CROP:
                Toast.makeText(getContext(), "SCALE_CROP", Toast.LENGTH_SHORT).show();
                if (isLandscape) {
                    measuredHeight = Math.min(measuredHeight, measuredWidth * videoHeight / videoWidth);
                } else {
                    measuredWidth = Math.min(measuredWidth, measuredHeight * videoWidth / videoHeight);
                }
                break;
            default:

                break;
        }
        aspectRatio(measuredWidth, measuredHeight);
        requestLayout();
    }


    public int getScaleType() {
        return scaleType;
    }

    public void setScaleType(int scaleType) {
        this.scaleType = scaleType;
        scale(scaleType);
    }
}

I've tried different ways, but so far I haven't been successful! Could someone explain or even show me how to solve this problem, I've been racking my brain over this for weeks, I've even done some research, but nothing works!

Any feedback will be precious!!!