package com.anren.omplayer;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Matrix;
import android.media.AudioManager;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.TypedValue;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.webkit.CookieManager;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.RelativeLayout;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.Toast;

import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.LifecycleEventListener;
import com.facebook.react.bridge.WritableMap;
import com.facebook.react.uimanager.ThemedReactContext;
import com.facebook.react.uimanager.events.RCTEventEmitter;
import com.tencent.liteav.demo.play.SuperPlayerConst;
import com.tencent.liteav.demo.play.controller.TCVodControllerBase;
import com.tencent.liteav.demo.play.utils.TCTimeUtils;
import com.tencent.liteav.demo.play.utils.VideoGestureUtil;
import com.tencent.liteav.demo.play.view.TCPointSeekBar;
import com.tencent.liteav.demo.play.view.TCVolumeBrightnessProgressLayout;
import com.tencent.rtmp.ITXVodPlayListener;
import com.tencent.rtmp.TXLiveConstants;
import com.tencent.rtmp.TXVodPlayConfig;
import com.tencent.rtmp.TXVodPlayer;
import com.yqritc.scalablevideoview.ScalableType;
import com.yqritc.scalablevideoview.ScaleManager;
import com.yqritc.scalablevideoview.Size;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutionException;

/**
 * Created by lcg on 2017/6/23.
 */

public class OMVideoPlayerTc extends RelativeLayout implements ITXVodPlayListener, LifecycleEventListener, OMPlayerRateView.Callback {

    private static final String TAG = OMVideoPlayerTc.class.getSimpleName();

    private int progress;
    private int duration;
    private int playable;

    public enum Events {
        EVENT_LOAD_START("onOMVideoLoadStart"),
        EVENT_LOAD("onOMVideoLoad"),
        EVENT_LOAD_STALLED("onOMVideoLoadStalled"),
        EVENT_LOAD_RESUME("onOMVideoLoadResume"),
        EVENT_ERROR("onOMVideoError"),
        EVENT_PROGRESS("onOMVideoProgress"),
        EVENT_SEEK("onOMVideoSeek"),
        EVENT_END("onOMVideoEnd"),
        EVENT_STALLED("onOMPlaybackStalled"),
        EVENT_RESUME("onOMPlaybackResume"),
        EVENT_READY_FOR_DISPLAY("onOMReadyForDisplay"),
        EVENT_FULLSCREEN_WILL_PRESENT("onOMVideoFullscreenPlayerWillPresent"),
        EVENT_FULLSCREEN_DID_PRESENT("onOMVideoFullscreenPlayerDidPresent"),
        EVENT_FULLSCREEN_WILL_DISMISS("onOMVideoFullscreenPlayerWillDismiss"),
        EVENT_FULLSCREEN_DID_DISMISS("onOMVideoFullscreenPlayerDidDismiss"),
        EVENT_RATE_CHANGE("onOMPlaybackRateChange");

        private final String mName;

        Events(final String name) {
            mName = name;
        }

        @Override
        public String toString() {
            return mName;
        }
    }

    public static final int MSG_HIDETOOLBAR = 1;
    public static final int MSG_HIDELOCK = 2;

    public static final String EVENT_PROP_FAST_FORWARD = "canPlayFastForward";
    public static final String EVENT_PROP_SLOW_FORWARD = "canPlaySlowForward";
    public static final String EVENT_PROP_SLOW_REVERSE = "canPlaySlowReverse";
    public static final String EVENT_PROP_REVERSE = "canPlayReverse";
    public static final String EVENT_PROP_STEP_FORWARD = "canStepForward";
    public static final String EVENT_PROP_STEP_BACKWARD = "canStepBackward";

    public static final String EVENT_PROP_DURATION = "duration";
    public static final String EVENT_PROP_PLAYABLE_DURATION = "playableDuration";
    public static final String EVENT_PROP_CURRENT_TIME = "currentTime";
    public static final String EVENT_PROP_SEEK_TIME = "seekTime";
    public static final String EVENT_PROP_NATURALSIZE = "naturalSize";
    public static final String EVENT_PROP_WIDTH = "width";
    public static final String EVENT_PROP_HEIGHT = "height";
    public static final String EVENT_PROP_ORIENTATION = "orientation";

    public static final String EVENT_PROP_ERROR = "error";
    public static final String EVENT_PROP_WHAT = "what";
    public static final String EVENT_PROP_EXTRA = "extra";
    public static final String EVENT_PROP_RATE = "rate";

    private Handler mUpdateHandler = new Handler();
    private Runnable mTextUpdateRunnable = null;
    private Runnable mProgressUpdateRunnable = null;
    private String mToken = null;
    private String mSrcUriString = null;
    private ScalableType mResizeMode = ScalableType.FIT_CENTER;
    private boolean mRepeat = false;
    private volatile Boolean mPaused = null;
    private boolean mMuted = false;
    private float mVolume = 1.0f;
    private float mRate = 1.0f;
    private boolean mFullScreen = false;
    private boolean mPlayInBackground = false;
    private boolean mActiveStatePauseStatus = false;

    private boolean mMediaPlayerValid = false; // True if mMediaPlayer is in prepared, started, paused or completed state.

    private int mVideoDuration = 0;
    private int mVideoBufferedDuration = 0;
    private boolean isCompleted = false;
    private boolean mUseNativeControls = false;

    private ThemedReactContext mThemedReactContext = null;
    private OMFullScreenManager mFullScreenManager = null;
    private OMScalableVideoViewTc mVideoView = null;
    private TXVodPlayConfig mVodPlayConfig = null;
    private ViewGroup mToolbar = null;
    private ImageView mLock = null;
    private OMPlayerRateView mRateView = null;
    protected boolean mFirstShowRate;
    protected OMPlayerRate mDefaultVideoRate;
    protected GestureDetector mGestureDetector;
    protected OMVideoPlayerGestureUtil mVideoGestureUtil;
    protected boolean mLockScreen;
    protected boolean mShowingRate;

    protected List<OMPlayerRate> mVideoRateList = Arrays.asList(
            new OMPlayerRate(0, "0.7 X", 0.7f),
            new OMPlayerRate(1, "1 X", 1.0f),
            new OMPlayerRate(2, "1.25 X", 1.25f),
            new OMPlayerRate(3, "1.5 X", 1.5f),
            new OMPlayerRate(4, "2 X", 2.0f)
    );
    private TextView mRateText = null;
    private ListView mRateOptions = null;
    private OMVolumeBrightnessProgressLayout mGestureProgress = null;

//    protected TCPointSeekBar mSeekBarProgress;

    private OMVideoViewTc mParentView = null;

    private Timer mHideToolbarTimer = null;

    private Timer mHideLockTimer = null;

    private AudioManager mAm;

    private boolean mAutoPause = false;

    private long displayDelay = 3000;

    private final Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == MSG_HIDETOOLBAR){
                if (mToolbar != null){
                    mToolbar.setVisibility(GONE);
                    hideRateView();
                    mShowingRate = false;
                    mLock.setVisibility(GONE);
                }
            } else if (msg.what == MSG_HIDELOCK){
                if (mToolbar != null){
                    mLock.setVisibility(GONE);
                }
            }

            super.handleMessage(msg);
        }
    };

    private final OnClickListener onClickListener = new OnClickListener() {
        @Override
        public void onClick(View view) {
            if (view.getId() == R.id.play_pause_tc){
                if (mPaused != null) {
                    setPausedModifier(!mPaused);
                }
            } else if (view.getId() == R.id.fullscreen_tc){
                mParentView.setFullscreen(!mParentView.isFullscreen());
            } else if (view.getId() == R.id.rate_tc) {
                if (mRateView.isShown()) {
                    hideRateView();
                } else {
                    showRateView();
                }
            } else if (view.getId() == R.id.lock_tc) {
                changeLockState();
            }
        }
    };

    /**
     * 改变锁屏状态
     */
    private void changeLockState() {
        mLockScreen = !mLockScreen;
//        mLock.setVisibility(VISIBLE);
//        if (mHideLockViewRunnable!=null) {
//            this.getHandler().removeCallbacks(mHideLockViewRunnable);
//            this.getHandler().postDelayed(mHideLockViewRunnable, 7000);
//        }
        if (mLockScreen) {
            mLock.setImageResource(R.drawable.player_lock);

            scheduleHideLock();
//            mToolbar.setVisibility(GONE);
        } else {
            cancelHideLockTimer();
            mLock.setImageResource(R.drawable.player_unlock);
//            showToolbar();
        }
        showToolbar();
        mLock.setVisibility(VISIBLE);
    }

    private void scheduleHideLock() {
        cancelHideLockTimer();
        mHideLockTimer = new Timer();

        mHideLockTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                Message msg = new Message();
                msg.what = MSG_HIDELOCK;
                mHandler.sendMessage(msg);

                mHideToolbarTimer = null;
            }
        },2 * 1000);
    }

    private void cancelHideLockTimer() {
        if (mHideLockTimer != null){
            mHideLockTimer.cancel();
            mHideLockTimer = null;
        }
    }

    private final SeekBar.OnSeekBarChangeListener mSeekListener = new SeekBar.OnSeekBarChangeListener (){
        @Override
        public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
            if (!fromUser){
                return ;
            }
//            mVideoView.seekTo(progress);
            seekTo(progress);
        }

        @Override
        public void onStartTrackingTouch(SeekBar seekBar) {

        }

        @Override
        public void onStopTrackingTouch(SeekBar seekBar) {
            WritableMap event = Arguments.createMap();
            event.putDouble(EVENT_PROP_CURRENT_TIME, seekBar.getProgress() / 1000.0);
            event.putDouble(EVENT_PROP_SEEK_TIME, seekBar.getProgress() / 1000.0);
            sendEvent(OMVideoPlayerTc.Events.EVENT_SEEK.toString(), event);
        }
    };

    private AudioManager.OnAudioFocusChangeListener mAudioFocusChangeListener = new AudioManager.OnAudioFocusChangeListener() {
        @Override
        public void onAudioFocusChange(int focusChange) {
            if (focusChange == AudioManager.AUDIOFOCUS_LOSS_TRANSIENT ||
                    focusChange == AudioManager.AUDIOFOCUS_LOSS) {
                // Pause playback
                if (!mPaused) {
                    mAutoPause = true;
                    setPausedModifier(true);
                }


            } else if (focusChange == AudioManager.AUDIOFOCUS_GAIN) {
                // Resume playback
                if (mAutoPause && mPaused) {
                    setPausedModifier(false);

                }
            }
        }
    };

    private boolean requestAudioFocus() {
        // Request audio focus for playback
        int result = mAm.requestAudioFocus(mAudioFocusChangeListener,
                // Use the music stream.
                AudioManager.STREAM_MUSIC,
                // Request permanent focus.
                AudioManager.AUDIOFOCUS_GAIN);
        return result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED;
    }


    private void resetToolbar(){
        ((TextView)findViewById(R.id.current_time_tc)).setText("--:--/--:--");
        ((SeekBar)findViewById(R.id.seekbar_tc)).setProgress(0);
        ((SeekBar)findViewById(R.id.seekbar_tc)).setMax(0);
        ((ImageView)findViewById(R.id.play_pause_tc)).setImageResource(mFullScreen ? R.drawable.play_fullscreen : R.drawable.play_smallscreen);
    }

    public void sendEvent(String event, WritableMap params) {
        mThemedReactContext.getJSModule(RCTEventEmitter.class).receiveEvent(mParentView.getId(), event, params);
    }

    public OMVideoPlayerTc(ThemedReactContext themedReactContext, OMVideoViewTc parent){
        super(themedReactContext);

        mAm = (AudioManager) themedReactContext.getSystemService(Context.AUDIO_SERVICE);

        mParentView = parent;

        mThemedReactContext = themedReactContext;
        themedReactContext.addLifecycleEventListener(this);

        View.inflate(themedReactContext, R.layout.video_player_tc,this);
        mVideoView = (OMScalableVideoViewTc) findViewById(R.id.video_view_tc);
        mToolbar = (ViewGroup) findViewById(R.id.toolbar_tc);
        mLock = (ImageView) findViewById(R.id.lock_tc);
        mLock.setOnClickListener(onClickListener);
        mRateView = (OMPlayerRateView) findViewById(R.id.player_rate_view_tc);
        mRateView.setCallback(this);
        mRateText = (TextView) findViewById(R.id.rate_tc);
        mRateText.setOnClickListener(onClickListener);
//        mRateOptions = (ListView) findViewById(R.id.rate_options_tc);
        mGestureProgress = (OMVolumeBrightnessProgressLayout) findViewById(R.id.gesture_progress_tc);

//        mSeekBarProgress = findViewById(R.id.seekbar_progress);
//        mSeekBarProgress.setProgress(0);
//        mSeekBarProgress.setOnPointClickListener(this);
//        mSeekBarProgress.setOnSeekBarChangeListener(this);

        findViewById(R.id.play_pause_tc).setOnClickListener(onClickListener);
        findViewById(R.id.fullscreen_tc).setOnClickListener(onClickListener);
        ((SeekBar)findViewById(R.id.seekbar_tc)).setOnSeekBarChangeListener(mSeekListener);

        mTextUpdateRunnable = new Runnable() {
            @Override
            public void run() {
                if (mMediaPlayerValid && !isCompleted && !mPaused) {
                    TextView textView = ((TextView) findViewById(R.id.display_text_tc));
                    textView.setVisibility(View.VISIBLE);
                    float limitX = 0.25f;
                    float limitY = 0.25f;
                    float textWidth = textView.getWidth();
                    float textHeight = textView.getHeight();
                    float randomX = (float) (Math.random() * (getWidth() - textWidth));
                    float randomY = (float) (Math.random() * (getHeight() - textHeight));
                    boolean isOutX = randomX > (getWidth() * limitX - textWidth) && randomX < getWidth() * (1 - limitX);
                    boolean isOutY = randomY > (getHeight() * limitY - textHeight) && randomY < getHeight() * (1 - limitY);

                    if (isOutX && isOutY) {
                        if ((randomX + textWidth / 2) > getWidth() / 2) {
                            randomX = getWidth() * (1 - limitX);
                        } else {
                            randomX = getWidth() * limitX - textWidth;
                        }
                    }
                    textView.setTranslationX(randomX);
                    textView.setTranslationY(randomY);
                }
                mUpdateHandler.postDelayed(mTextUpdateRunnable, displayDelay);
            }
        };

//        mProgressUpdateRunnable = new Runnable() {
//            @Override
//            public void run() {
//
//                if (mMediaPlayerValid && !isCompleted &&!mPaused) {
//                    WritableMap event = Arguments.createMap();
//                    event.putDouble(EVENT_PROP_CURRENT_TIME, mVideoView.getCurrentPosition() / 1000.0);
//                    event.putDouble(EVENT_PROP_PLAYABLE_DURATION, mVideoBufferedDuration / 1000.0); //TODO:mBufferUpdateRunnable
//                    sendEvent(OMVideoPlayerTc.Events.EVENT_PROGRESS.toString(), event);
//                    Log.d(TAG, "PROGRESS:" + generateTime(mVideoView.getCurrentPosition()) + "/" + generateTime(mVideoView.getDuration()));
//                    ((TextView)findViewById(R.id.current_time_tc)).setText(generateTime(mVideoView.getCurrentPosition()) + "/" + generateTime(mVideoView.getDuration()));
////                    ((TextView)findViewById(R.id.end_time)).setText(generateTime(mVideoView.getDuration()));
//                    ((SeekBar)findViewById(R.id.seekbar_tc)).setProgress(mVideoView.getCurrentPosition());
//                    ((SeekBar)findViewById(R.id.seekbar_tc)).setMax(mVideoView.getDuration());
//
//                    // Check for update after an interval
//                    // TODO: The update interval is fixed at 250. There is a property in React component that defines this value. Totally ignored !!!
//
//                }
//                mUpdateHandler.postDelayed(mProgressUpdateRunnable, 250);
//            }
//        };

//        initializeMediaPlayerIfNeeded();

        mFullScreenManager = new OMFullScreenManager(themedReactContext);

        mVideoView.setSurfaceTextureListener(mVideoView);


        mGestureDetector = new GestureDetector(getContext(), new GestureDetector.SimpleOnGestureListener() {
            @Override
            public boolean onDoubleTap(MotionEvent e) {
                if (mLockScreen) return false;
                changePlayState();
//                showToolbar();
//                if (mHideViewRunnable != null) {
//                    TCVodControllerBase.this.getHandler().removeCallbacks(mHideViewRunnable);
//                    TCVodControllerBase.this.getHandler().postDelayed(mHideViewRunnable, 7000);
//                }
                return true;
            }


            //如果双击的话，则onSingleTapConfirmed不会执行
            @Override
            public boolean onSingleTapConfirmed(MotionEvent e) {
//                onToggleControllerView();
                showToolbar();
                return true;
            }

            @Override
            public boolean onScroll(MotionEvent downEvent, MotionEvent moveEvent, float distanceX, float distanceY) {
                if (mLockScreen) return false;
//                showToolbar();
                if (downEvent == null || moveEvent == null) {
                    return false;
                }
                if (mVideoGestureUtil != null && mGestureProgress != null) {
                    mVideoGestureUtil.check(mGestureProgress.getHeight(), downEvent, moveEvent, distanceX, distanceY);
                }
                return true;
            }

            @Override
            public boolean onDown(MotionEvent e) {
                if (mLockScreen) {
                    scheduleHideLock();
                    return true;
                }
//                showToolbar();
                if (mVideoGestureUtil != null) {
                    mVideoGestureUtil.reset(OMVideoPlayerTc.this.getWidth(), 0);
                }
                return true;
            }

        });
        mGestureDetector.setIsLongpressEnabled(false);

        mVideoGestureUtil = new OMVideoPlayerGestureUtil(mThemedReactContext.getCurrentActivity());
        mVideoGestureUtil.setVideoGestureListener(new OMVideoPlayerGestureUtil.VideoGestureListener() {
            @Override
            public void onBrightnessGesture(float newBrightness) {
                if (mGestureProgress != null) {
                    mGestureProgress.setProgress((int) (newBrightness * 100));
                    mGestureProgress.setImageResource(com.tencent.liteav.demo.play.R.drawable.ic_light_max);
                    mGestureProgress.show();
                }
            }

            @Override
            public void onVolumeGesture(float volumeProgress) {
                if (mGestureProgress != null) {
                    mGestureProgress.setImageResource(com.tencent.liteav.demo.play.R.drawable.ic_volume_max);
                    mGestureProgress.setProgress((int) volumeProgress);
                    mGestureProgress.show();
                }
            }

        });
    }

//    public void toggleFullscreen(){
//        mFullScreen = !mFullScreen;
//
//        if (mFullScreen){
//            mParentView.removeView(this);
//            mFullScreenManager.addView(this);
//            mFullScreenManager.show();
//            ((ImageView)findViewById(R.id.fullscreen)).setImageResource(R.drawable.shrink_fullscreen);
//        }
//        else {
//            mFullScreenManager.removeView(this);
//            mParentView.addView(this);
//            mFullScreenManager.hide();
//            ((ImageView)findViewById(R.id.fullscreen)).setImageResource(R.drawable.enlarge_fullscreen);
//            setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,ViewGroup.LayoutParams.MATCH_PARENT));
//        }
//
//        requestLayout();
//    }


    /**
     * 切换播放状态
     */
    protected void changePlayState() {
        // 播放中
        if (mVideoView.isPlaying()) {
            mVideoView.getMediaPlayer().pause();
//            show();
        }
        // 未播放
        else if (!mVideoView.isPlaying()) {
//            updateReplay(false);
            mVideoView.getMediaPlayer().resume();
//            show();
        }
    }

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

    @Override
    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
        super.onLayout(changed, left, top, right, bottom);

        if (!changed || !mMediaPlayerValid) {
            return;
        }

        int videoWidth = mVideoView.getVideoWidth();
        int videoHeight = mVideoView.getVideoHeight();

        if (videoWidth == 0 || videoHeight == 0) {
            return;
        }

        Size viewSize = new Size(getWidth(), getHeight());
        Size videoSize = new Size(videoWidth, videoHeight);
        ScaleManager scaleManager = new ScaleManager(viewSize, videoSize);
        Matrix matrix = scaleManager.getScaleMatrix(ScalableType.FIT_CENTER);
        if (matrix != null) {
            mVideoView.setTransform(matrix);
        }
    }

    private void initializeMediaPlayerIfNeeded(Map<String, String> headers) {
        if (mVideoView.getMediaPlayer() == null) {
//            mMediaPlayerValid = false;
            TXVodPlayer mediaPlayer = new TXVodPlayer(this.mThemedReactContext);

            mVodPlayConfig = new TXVodPlayConfig();

            mVodPlayConfig.setHeaders(headers);
            mediaPlayer.setConfig(mVodPlayConfig);
            mediaPlayer.setVodListener(this);
//            mediaPlayer.setRate();
            // mediaPlayer.setScreenOnWhilePlaying(true); //腾讯播放器不支持
//            mediaPlayer.setOnVideoSizeChangedListener(mVideoView);
//            mediaPlayer.setOnErrorListener(this);
//            mediaPlayer.setOnPreparedListener(this);
//            mediaPlayer.setOnBufferingUpdateListener(this);
//            mediaPlayer.setOnCompletionListener(this);
//            mediaPlayer.setOnInfoListener(this);

            mVideoView.setMediaPlayer(mediaPlayer);
        }
    }

    @Override
    public void onRateSelect(OMPlayerRate rate) {
        setRateModifier(rate.rate);
//        mRateView.setVisibility(GONE);

        WritableMap event = Arguments.createMap();
        event.putDouble(EVENT_PROP_RATE, rate.rate);
        sendEvent(Events.EVENT_RATE_CHANGE.toString(), event);

    }

    /**
     * 更新默认清晰度
     *
     * @param videoRate
     */
    public void updateVideoRate(OMPlayerRate videoRate) {
        mDefaultVideoRate = videoRate;
        if (mRateText != null) {
            mRateText.setText(videoRate.rate == 1.0f ? "倍速" : videoRate.name);
        }
        if (mVideoRateList != null && mVideoRateList.size() != 0) {
            for (int i = 0; i  < mVideoRateList.size(); i++) {
                OMPlayerRate rate = mVideoRateList.get(i);
                if (rate!=null && rate.rate != 0.0f && rate.rate == (mDefaultVideoRate.rate)) {
                    mRateView.setDefaultSelectedQuality(i);
                    break;
                }
            }
        }
    }

    /**
     * 显示播放速率选择UI
     */
    private void showRateView() {
        if (mVideoRateList == null || mVideoRateList.size() == 0) {
            Log.i(TAG, "showRateView mVideoRateList null");
            return;
        }
        // 设置默认播放速率文字
        mRateView.setVisibility(View.VISIBLE);
        mLock.setVisibility(GONE);
        mToolbar.setVisibility(View.GONE);
        mShowingRate = true;
        mLockScreen = true;
        if (mHideToolbarTimer != null) {
            mHideToolbarTimer.cancel();
            mHideToolbarTimer = null;
        }
        if (!mFirstShowRate && mDefaultVideoRate != null) {
            for (int i = 0; i  < mVideoRateList.size(); i++) {
                OMPlayerRate rate = mVideoRateList.get(i);
                if (rate!=null && rate.rate != 0.0f && rate.rate == (mDefaultVideoRate.rate)) {
                    mRateView.setDefaultSelectedQuality(i);
                    break;
                }
            }
            mFirstShowRate = true;
        }
        mRateView.setVideoRateList(mVideoRateList);
    }
    public void cleanupMediaPlayerResources() {
        TXVodPlayer mediaPlayer = mVideoView.getMediaPlayer();

        if ( mediaPlayer != null ) {
            mMediaPlayerValid = false;
            try {
                mediaPlayer.stopPlay(true);
            } catch (Exception e) {

            }
//            mediaPlayer.release();
            mVideoView.setMediaPlayer(null);
        }
    }
    public void setToken(final String tokenString) {

        mToken = tokenString;
        if (mSrcUriString == null || !mSrcUriString.endsWith(".m3u8")) {
            return;
        }
        setSrc(mSrcUriString);

    }

    public void setDisplayText(final String displayText) {
        TextView textView = ((TextView) findViewById(R.id.display_text_tc));
        textView.setText(displayText);
    }

    public void setDisplayTextSize(final float displayTextSize) {
        TextView textView = ((TextView) findViewById(R.id.display_text_tc));
        textView.setTextSize(displayTextSize);
    }

    public void setDisplayDelay(final long delay) {
        displayDelay = delay;
    }

    public void setSrc(final String uriString) {

        mSrcUriString = uriString;
        if (uriString.endsWith(".m3u8") && mToken == null) {
            return;
        }
//        mMediaPlayerValid = false;
        mVideoDuration = 0;
        mVideoBufferedDuration = 0;
//        setPausedModifier(true);
//        mPaused = true;

        resetToolbar();

        if (mVideoView.getMediaPlayer() != null) {
            try {
                mVideoView.getMediaPlayer().stopPlay(false);
            } catch (Exception e) {
                Log.e(TAG, "StopPlayError", e);
            }
            mVideoView.setMediaPlayer(null);
        }

        try {
            if (uriString.startsWith("http")) {
                // Use the shared CookieManager to access the cookies
                // set by WebViews inside the same app
                CookieManager cookieManager = CookieManager.getInstance();

                Uri parsedUrl = Uri.parse(uriString);
                Uri.Builder builtUrl = parsedUrl.buildUpon();

                String cookie = cookieManager.getCookie(builtUrl.build().toString());

                Map<String, String> headers = new HashMap<String, String>();

                if (cookie != null) {
                    headers.put("Cookie", cookie);
                }
                if (mToken != null) {
                    headers.put("User-Agent", mToken);
                }
//                else {
//                    return;
//                }
                if (uriString.startsWith("http://localhost")) {
                    mVideoView.setDataSource(uriString);
                } else {
                    mVideoView.setDataSource(mThemedReactContext, parsedUrl, headers);
                }
                initializeMediaPlayerIfNeeded(headers);
            } else {
                if (uriString.startsWith("content://")) {
                    Uri parsedUrl = Uri.parse(uriString);
                    mVideoView.setDataSource(mThemedReactContext, parsedUrl);
                } else {
                    mVideoView.setDataSource(uriString);
                }
                initializeMediaPlayerIfNeeded(null);
            }
        } catch (Exception e) {
            WritableMap event = Arguments.createMap();
            event.putString(OMVideoViewManager.PROP_SRC, uriString);
            event.putString("error", e.getMessage());
            sendEvent(OMVideoPlayerTc.Events.EVENT_ERROR.toString(), event);
            return;
        }

        WritableMap src = Arguments.createMap();
        src.putString(OMVideoViewManager.PROP_SRC_URI, uriString);

        WritableMap event = Arguments.createMap();
        event.putMap(OMVideoViewManager.PROP_SRC, src);
        sendEvent(OMVideoPlayerTc.Events.EVENT_LOAD_START.toString(), event);
        mMediaPlayerValid = true;
        if (mPaused != null && !mPaused) {
            mPaused = true;
            Log.d(TAG, "mPaused: true");
            setPausedModifier(false);
        }
//        src = Arguments.createMap();
//        src.putString(OMVideoViewManager.PROP_SRC_URI, uriString);
//        event = Arguments.createMap();
//        event.putMap(OMVideoViewManager.PROP_SRC, src);
//        sendEvent(OMVideoPlayerTc.Events.EVENT_LOAD.toString(), event);
        // not async to prevent random crashes on Android playback from local resource due to race conditions
//        try {
//            mVideoView.prepareAsync(this);
//        } catch (Exception e) {
//            WritableMap prepareEvent = Arguments.createMap();
//            prepareEvent.putString(OMVideoViewManager.PROP_SRC, uriString);
//            prepareEvent.putString("error", e.getMessage());
//            sendEvent(OMVideoPlayerTc.Events.EVENT_ERROR.toString(), prepareEvent);
//        }
    }

    public void setResizeModeModifier(final ScalableType resizeMode) {
        mResizeMode = resizeMode;

        if (mMediaPlayerValid) {
            mVideoView.setScalableType(resizeMode);
            invalidate();
        }
    }

    public void setRepeatModifier(final boolean repeat) {

        mRepeat = repeat;

        if (mMediaPlayerValid) {
            mVideoView.setLooping(repeat);
        }
    }

    public void setPausedModifier(final boolean paused) {

        if (!mMediaPlayerValid) {
            return;
        }
        if (mPaused == Boolean.valueOf(paused)) {
            return;
        }

        mPaused = paused;
        Log.d(TAG, "mPaused: mPaused=" + mPaused);

        isCompleted = false;

        if (mPaused) {
            if (mVideoView.isPlaying()) {
                mVideoView.pause();
                ((ImageView)findViewById(R.id.play_pause_tc)).setImageResource(mFullScreen ? R.drawable.play_fullscreen : R.drawable.play_smallscreen);
//                ((ImageView)findViewById(R.id.play_pause_tc)).setImageResource(R.drawable.ic_play);

                sendEvent(Events.EVENT_STALLED.toString(), Arguments.createMap());
            }
        } else {
            if (!mVideoView.isPlaying()/* && requestAudioFocus()*/) {
                mVideoView.start();
//                mPaused = false;
                mAutoPause = false;
                ((ImageView)findViewById(R.id.play_pause_tc)).setImageResource(mFullScreen ? R.drawable.pause_fullscreen : R.drawable.pause_smallscreen);
//                ((ImageView)findViewById(R.id.play_pause_tc)).setImageResource(R.drawable.ic_pause);
                // Also Start the Progress Update Handler
//                mUpdateHandler.post(mProgressUpdateRunnable);
                mUpdateHandler.post(mTextUpdateRunnable);
                sendEvent(Events.EVENT_RESUME.toString(), Arguments.createMap());
            }
        }
    }

    public boolean isPlaying() {
        return !mPaused;
    }

    public void setMutedModifier(final boolean muted) {
        mMuted = muted;

        if (!mMediaPlayerValid) {
            return;
        }

        if (mMuted) {
            mAm.setStreamVolume(AudioManager.STREAM_MUSIC, 0, 0);
        } else {
//            mAm.setStreamVolume(AudioManager.STREAM_MUSIC, (int)(mAm.getStreamMaxVolume(AudioManager.STREAM_MUSIC) * mVolume), 0);
            mAm.setStreamVolume(AudioManager.STREAM_MUSIC, mAm.getStreamVolume(AudioManager.STREAM_MUSIC), 0);
//            mVideoView.setVolume(mVolume, mVolume);
        }
    }

    public void setVolumeModifier(final float volume) {
        mVolume = volume;
        setMutedModifier(mMuted);
    }

    public void setRateModifier(final float rate) {
        mRate = rate;

        if (mMediaPlayerValid) {
            mVideoView.setRate(rate);

            for (OMPlayerRate playerRate : mVideoRateList) {
                if (playerRate.rate == rate) {
                    updateVideoRate(playerRate);
                    break;
                }
            }
            // TODO: Implement this.
//            Log.e(OMVideoViewManager.REACT_CLASS, "Setting playback rate is not yet supported on Android");
        }
    }

    public void applyModifiers() {
        setResizeModeModifier(mResizeMode);
        setRepeatModifier(mRepeat);
        if (mPaused != null) {
            setPausedModifier(mPaused);
        }
        setMutedModifier(mMuted);
        setRateModifier(mRate);
    }

    public void setPlayInBackground(final boolean playInBackground) {

        mPlayInBackground = playInBackground;
    }

    public void setControls(boolean controls) {
        this.mUseNativeControls = controls;
    }




    @Override
    public void onPlayEvent(TXVodPlayer player, int event, Bundle param) {
        if (event != TXLiveConstants.PLAY_EVT_PLAY_PROGRESS) {
            String playEventLog = "receive event: " + event + ", " + param.getString(TXLiveConstants.EVT_DESCRIPTION);
            Log.d(TAG, playEventLog);
        }

        if (event == TXLiveConstants.PLAY_EVT_VOD_PLAY_PREPARED || event == TXLiveConstants.PLAY_EVT_VOD_LOADING_END) {
//            stopLoadingAnimation();
        }

        if (event == TXLiveConstants.PLAY_EVT_VOD_PLAY_PREPARED) {
            this.onPrepared(player);
//            BitrateView view = (BitrateView)findViewById(R.id.bitrate_view);
//            view.setDataSource(mVodPlayer.getSupportedBitrates());
//            view.setListener(new BitrateView.OnSelectBitrateListener() {
//                @Override
//                public void onBitrateIndex(int index) {
//                    mVodPlayer.setBitrateIndex(index);
//                }
//            });
//        }

//        if (event == TXLiveConstants.PLAY_EVT_PLAY_BEGIN) {
//            stopLoadingAnimation();
//            Log.d("AutoMonitor", "PlayFirstRender,cost=" +(System.currentTimeMillis()-mStartPlayTS));
//            if (mPhoneListener.isInBackground()) {
//                mVodPlayer.pause();
//            }



        } else if (event == TXLiveConstants.PLAY_EVT_PLAY_PROGRESS ) {
//            if (mStartSeek) {
//                return;
//            }

            progress = param.getInt(TXLiveConstants.EVT_PLAY_PROGRESS_MS);
            mVideoDuration = duration = param.getInt(TXLiveConstants.EVT_PLAY_DURATION_MS);
            playable = param.getInt(TXLiveConstants.EVT_PLAYABLE_DURATION_MS);
            ((SeekBar)findViewById(R.id.seekbar_tc)).setProgress(progress);
            ((SeekBar)findViewById(R.id.seekbar_tc)).setMax(duration);
            ((TextView)findViewById(R.id.current_time_tc)).setText(generateTime(progress) + "/" + generateTime(duration));

            WritableMap omEvent = Arguments.createMap();
            omEvent.putDouble(EVENT_PROP_CURRENT_TIME, progress / 1000.0);
            omEvent.putDouble(EVENT_PROP_PLAYABLE_DURATION, playable / 1000.0); //TODO:mBufferUpdateRunnable
            sendEvent(OMVideoPlayerTc.Events.EVENT_PROGRESS.toString(), omEvent);

            Log.d(TAG, String.format("PROGRESS:%d:%d:%d", progress, duration, playable));
//            if (mSeekBar != null) {
//                mSeekBar.setProgress(progress);
//                mSeekBar.setSecondaryProgress(playable);
//            }
//            if (mTextStart != null) {
//                mTextStart.setText(String.format("%02d:%02d",progress/1000/60,progress/1000%60));
//            }
//            if (mTextDuration != null) {
//                mTextDuration.setText(String.format("%02d:%02d",duration/1000/60,duration/1000%60));
//            }
//            if (mSeekBar != null) {
//                mSeekBar.setMax(duration);
//            }
            return;
        } else if (event == TXLiveConstants.PLAY_EVT_PLAY_END) {
            Log.d(TAG, "mVodPlayerPreload resume");
            onCompletion(player);
        } else if (event == TXLiveConstants.PLAY_ERR_NET_DISCONNECT || event == TXLiveConstants.PLAY_ERR_FILE_NOT_FOUND || event == TXLiveConstants.PLAY_ERR_HLS_KEY) {
            player.pause();
            onError(player, event, event);
//            stopPlayVod();
//            mVideoPlay = false;
//            mVideoPause = false;
//            if (mTextStart != null) {
//                mTextStart.setText("00:00");
//            }
//            if (mSeekBar != null) {
//                mSeekBar.setProgress(0);
//            }

        } else if (event == TXLiveConstants.PLAY_EVT_PLAY_LOADING){
//            startLoadingAnimation();
        } else if (event == TXLiveConstants.PLAY_EVT_RCV_FIRST_I_FRAME) {
//            stopLoadingAnimation();
//            findViewById(R.id.playerHeaderView).setVisibility(View.GONE);
//            if (mPhoneListener.isInBackground()) {
//                mVodPlayer.pause();
//            }
//        } else if (event == TXLiveConstants.PLAY_EVT_CHANGE_RESOLUTION) {
        } else if (event == TXLiveConstants.PLAY_WARNING_RECONNECT) {
            player.resume();
//            startLoadingAnimation();
        } else if (event == TXLiveConstants.PLAY_EVT_CHANGE_ROTATION) {
            return;
        }

        if (event < 0) {
            Toast.makeText(getContext(), param.getString(TXLiveConstants.EVT_DESCRIPTION), Toast.LENGTH_SHORT).show();
        }
    }



    @Override
    public void onNetStatus(TXVodPlayer player, Bundle status) {

    }



    @Override
    public void onHostPause() {
//        if (mVideoView.getMediaPlayer() != null && !mPlayInBackground) {
//            mActiveStatePauseStatus = mPaused;
//
//            // Pause the video in background
//            setPausedModifier(true);
//        }
    }

    @Override
    public void onHostResume() {
//        if (mVideoView.getMediaPlayer() != null && !mPlayInBackground) {
//            new Handler().post(new Runnable() {
//                @Override
//                public void run() {
//                    // Restore original state
//                    setPausedModifier(mActiveStatePauseStatus);
//                }
//            });
//
//        }
    }

    @Override
    public void onHostDestroy() {
    }


//    @Override
    public void onPrepared(TXVodPlayer mp) {

        mMediaPlayerValid = true;
//        mVideoDuration = (int) mp.getDuration();

//        ((TextView)findViewById(R.id.current_time_tc)).setText(generateTime((long) mp.getCurrentPlaybackTime()) + "/" + generateTime((long) mp.getDuration()));
//        ((TextView)findViewById(R.id.end_time)).setText(generateTime(mp.getDuration()));
//        ((SeekBar)findViewById(R.id.seekbar_tc)).setMax((int)mp.getDuration());

        WritableMap naturalSize = Arguments.createMap();
        naturalSize.putInt(EVENT_PROP_WIDTH, mp.getWidth());
        naturalSize.putInt(EVENT_PROP_HEIGHT, mp.getHeight());
        if (mp.getWidth() > mp.getHeight())
            naturalSize.putString(EVENT_PROP_ORIENTATION, "landscape");
        else
            naturalSize.putString(EVENT_PROP_ORIENTATION, "portrait");

        WritableMap event = Arguments.createMap();
        event.putDouble(EVENT_PROP_DURATION, mp.getDuration());
        event.putDouble(EVENT_PROP_CURRENT_TIME, mp.getCurrentPlaybackTime());
        event.putMap(EVENT_PROP_NATURALSIZE, naturalSize);
        // TODO: Actually check if you can.
        event.putBoolean(EVENT_PROP_FAST_FORWARD, true);
        event.putBoolean(EVENT_PROP_SLOW_FORWARD, true);
        event.putBoolean(EVENT_PROP_SLOW_REVERSE, true);
        event.putBoolean(EVENT_PROP_REVERSE, true);
        event.putBoolean(EVENT_PROP_FAST_FORWARD, true);
        event.putBoolean(EVENT_PROP_STEP_BACKWARD, true);
        event.putBoolean(EVENT_PROP_STEP_FORWARD, true);
        sendEvent(OMVideoPlayerTc.Events.EVENT_LOAD.toString(), event);

        showToolbar();

        applyModifiers();
    }

//    @Override
    private boolean onError(TXVodPlayer mp, int what, int extra) {

        WritableMap error = Arguments.createMap();
        error.putInt(EVENT_PROP_WHAT, what);
        error.putInt(EVENT_PROP_EXTRA, extra);
        WritableMap event = Arguments.createMap();
        event.putMap(EVENT_PROP_ERROR, error);
        sendEvent( OMVideoPlayerTc.Events.EVENT_ERROR.toString(), event);
        return true;
    }

//    @Override
//    private boolean onInfo(TXVodPlayer mp, int what, int extra) {
//        switch (what) {
//            case TXVodPlayer.MEDIA_INFO_BUFFERING_START:
//                sendEvent(OMVideoPlayerTc.Events.EVENT_LOAD_STALLED.toString(), Arguments.createMap());
//                break;
//            case TXVodPlayer.MEDIA_INFO_BUFFERING_END:
//                sendEvent(OMVideoPlayerTc.Events.EVENT_LOAD_RESUME.toString(), Arguments.createMap());
//                break;
//            case TXVodPlayer.MEDIA_INFO_VIDEO_RENDERING_START:
//                sendEvent(OMVideoPlayerTc.Events.EVENT_READY_FOR_DISPLAY.toString(), Arguments.createMap());
//                break;
//
//            default:
//        }
//        return false;
//    }

//    @Override
//    private void onBufferingUpdate(TXVodPlayer mp, int percent) {
//        mVideoBufferedDuration = (int) Math.round((double) (mVideoDuration * percent) / 100.0);
//    }

    public void seekTo(int msec) {

        if (mMediaPlayerValid) {
//            WritableMap event = Arguments.createMap();
//            event.putDouble(EVENT_PROP_CURRENT_TIME, mVideoView.getCurrentPosition() / 1000.0);
//            event.putDouble(EVENT_PROP_SEEK_TIME, msec / 1000.0);
//            sendEvent(OMVideoPlayerTc.Events.EVENT_SEEK.toString(), event);

            WritableMap event = Arguments.createMap();
            event.putDouble(EVENT_PROP_CURRENT_TIME, msec / 1000.0);
            event.putDouble(EVENT_PROP_PLAYABLE_DURATION, mVideoBufferedDuration / 1000.0); //TODO:mBufferUpdateRunnable
            sendEvent(OMVideoPlayerTc.Events.EVENT_PROGRESS.toString(), event);

            Log.d(TAG, "PROGRESS:" + generateTime(msec) + "/" + generateTime(mVideoView.getDuration()));

            mVideoView.seekTo(msec);
            if (isCompleted && mVideoDuration != 0 && msec < mVideoDuration) {
                isCompleted = false;
            }
        }
    }

//    @Override
    private void onCompletion(TXVodPlayer mp) {

        isCompleted = true;
        mPaused = null;
        Log.d(TAG, "mPaused: " + null);
//        setPausedModifier(true);
//        mPaused = true;

        sendEvent(OMVideoPlayerTc.Events.EVENT_END.toString(), null);

//        ((TextView)findViewById(R.id.current_time)).setText("00:00/" + generateTime(mVideoView.getDuration()));
//        ((TextView)findViewById(R.id.end_time)).setText(generateTime(mVideoView.getDuration()));
//        ((ImageView)findViewById(R.id.play_pause)).setImageResource(R.drawable.ic_play);
//        ((SeekBar)findViewById(R.id.seekbar)).setMax(mp.getDuration());
//        ((SeekBar)findViewById(R.id.seekbar)).setProgress(0);

        mAm.abandonAudioFocus(mAudioFocusChangeListener);
        resetToolbar();

        mp.seek(0);
    }

    private String generateTime(long time) {
        int totalSeconds = (int) (time / 1000);
        int seconds = totalSeconds % 60;
        int minutes = (totalSeconds / 60) % 60;
        int hours = totalSeconds / 3600;
        return hours > 0 ? String.format("%02d:%02d:%02d", hours, minutes,
                seconds) : String.format("%02d:%02d", minutes, seconds);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {

        if (mGestureDetector != null) {
            return mGestureDetector.onTouchEvent(event);
        } else {
            return super.onTouchEvent(event);
        }
    }
    public void hideRateView() {

        mRateView.setVisibility(GONE);
        if (mShowingRate == true) {
            mShowingRate = false;
            mLockScreen = false;
        }
    }
    public void showToolbar(){
        if (mToolbar == null){
            return;
        }
        hideRateView();

        if (mHideToolbarTimer != null){
            mHideToolbarTimer.cancel();
            mHideToolbarTimer = null;

            mToolbar.setVisibility(GONE);
            mLock.setVisibility(GONE);

            return ;
        }
        mLock.setVisibility(VISIBLE);
        mToolbar.setVisibility(mLockScreen ? GONE : VISIBLE);

        if (mLockScreen) {
            scheduleHideLock();
            return;
        } else {
            cancelHideLockTimer();
        }
        mHideToolbarTimer = new Timer();

        mHideToolbarTimer.schedule(new TimerTask() {
            @Override
            public void run() {
                Message msg = new Message();
                msg.what = MSG_HIDETOOLBAR;
                mHandler.sendMessage(msg);

                mHideToolbarTimer = null;
            }
        },10 * 1000);
    }

    public void setFullScreen(final boolean fullscreen) {
        mUpdateHandler.post(new Runnable() {
            @Override
            public void run() {
                View rateButton = findViewById(R.id.rate_tc);
                ImageView playButton = (ImageView) findViewById(R.id.play_pause_tc);
                LayoutParams playButtonLayoutParams = (LayoutParams) playButton.getLayoutParams();
                final View toolBar = findViewById(R.id.toolbar_tc);
                LayoutParams toolbarLayoutParams = (LayoutParams) toolBar.getLayoutParams();
                LayoutParams seekbarLayoutParams = (LayoutParams) findViewById(R.id.seekbar_tc).getLayoutParams();
                TextView curTimeTV = (TextView) findViewById(R.id.current_time_tc);
                LayoutParams currentTimeLayoutParams = (LayoutParams) curTimeTV.getLayoutParams();
                ImageView fullScreenButton = (ImageView) findViewById(R.id.fullscreen_tc);
                LayoutParams fullScreenButtonLayoutParams = (LayoutParams) fullScreenButton.getLayoutParams();
                if (fullscreen) {
                    playButtonLayoutParams.width = convertDpToPixel(35, getContext());
                    playButton.setImageResource(mVideoView.isPlaying() ? R.drawable.pause_fullscreen : R.drawable.play_fullscreen);
                    rateButton.setVisibility(VISIBLE);
                    fullScreenButton.setImageResource(R.drawable.exit_fullscreen);
                    fullScreenButtonLayoutParams.width = convertDpToPixel(35, getContext());
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        toolBar.setBackgroundResource(R.drawable.progressbar_fullscreen);
                        toolbarLayoutParams.height = convertDpToPixel(95, getContext());
                        seekbarLayoutParams.removeRule(RelativeLayout.LEFT_OF);
                        seekbarLayoutParams.removeRule(RelativeLayout.RIGHT_OF);
                        seekbarLayoutParams.width = LayoutParams.MATCH_PARENT;
                        seekbarLayoutParams.addRule(RelativeLayout.ALIGN_PARENT_TOP, 1);
                        seekbarLayoutParams.setMargins(0, convertDpToPixel(30, getContext()), 0, convertDpToPixel(61, getContext()));
                        DisplayMetrics metrics = getResources().getDisplayMetrics();
                        int widthDp = Math.round(metrics.widthPixels / metrics.density);
                        int heightDp = Math.round(metrics.heightPixels / metrics.density);
                        int largerDp = widthDp > heightDp ? widthDp : heightDp;
                        curTimeTV.setPadding(0, curTimeTV.getPaddingTop(), convertDpToPixel(406 * largerDp / 667, getContext()), curTimeTV.getPaddingBottom());
                    }
                }
                else {
                    toolBar.setBackgroundResource(R.drawable.progressbar_smallscreen);
                    playButton.setImageResource(mVideoView.isPlaying() ? R.drawable.pause_smallscreen : R.drawable.play_smallscreen);
                    playButtonLayoutParams.width = convertDpToPixel(25, getContext());
                    rateButton.setVisibility(GONE);
                    fullScreenButton.setImageResource(R.drawable.fullscreen);
                    fullScreenButtonLayoutParams.width = convertDpToPixel(25, getContext());
//                    ((ImageView)findViewById(R.id.fullscreen_tc)).setImageResource(R.drawable.enlarge_fullscreen);
                    toolbarLayoutParams.height = convertDpToPixel(40, getContext());
                    seekbarLayoutParams.addRule(RelativeLayout.LEFT_OF, R.id.current_time_tc);
                    seekbarLayoutParams.addRule(RelativeLayout.RIGHT_OF, R.id.play_pause_tc);
//                    seekbarLayoutParams.height = LayoutParams.WRAP_CONTENT;
                    seekbarLayoutParams.width = LayoutParams.WRAP_CONTENT;
                    seekbarLayoutParams.removeRule(RelativeLayout.ALIGN_PARENT_TOP);
                    seekbarLayoutParams.setMargins(0, 0, 0, 0);
                    curTimeTV.setPadding(0, curTimeTV.getPaddingTop(), 0, curTimeTV.getPaddingBottom());
//                    currentTimeLayoutParams.width = getPixelValue(getContext(), R.dimen.d_85dp);
//                    currentTimeLayoutParams.setMarginEnd(getPixelValue(getContext(), R.dimen.d_9dp));
//                    currentTimeLayoutParams.setMarginEnd(9);
                }
                requestLayout();
//                LayoutWrapContentUpdater.wrapContentAgain((ViewGroup) toolBar, true);
            }
        });
    }
    public static int getPixelValue(Context context, int dimenId) {
        Resources resources = context.getResources();
        return (int) TypedValue.applyDimension(
                TypedValue.COMPLEX_UNIT_DIP,
                dimenId,
                resources.getDisplayMetrics()
        );
    }
    /**
     * This method converts dp unit to equivalent pixels, depending on device density.
     *
     * @param dp A value in dp (density independent pixels) unit. Which we need to convert into pixels
     * @param context Context to get resources and device specific display metrics
     * @return A float value to represent px equivalent to dp depending on device density
     */
    public static int convertDpToPixel(int dp, Context context){
        return (int) (dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT));
    }

    /**
     * This method converts device specific pixels to density independent pixels.
     *
     * @param px A value in px (pixels) unit. Which we need to convert into db
     * @param context Context to get resources and device specific display metrics
     * @return A float value to represent dp equivalent to px value
     */
    public static float convertPixelsToDp(int px, Context context){
        return (int) (px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT));
    }
}
