void OnEnable()
{
    m_player.prepareCompleted += OnPrepareCompleted;
}

void OnPrepareCompleted(VideoPlayer source)
{
    Debug.Log("OnPrepareCompleted");
    m_player.Play();
}

public void SetVideo(string path)
{
    m_player.source = VideoSource.Url;
    // I guess this process may not be finished now.
    m_player.url = path;
    m_player.Prepare();
}

public class UITagDrawer : PropertyDrawer
{
    // the object for string state
    class EditingState
    {
        public bool IsEditing = false;
    }

    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        /***/

        // get state object
        EditingState state = GUIUtility.GetStateObject(typeof(EditingState), GUIUtility.GetControlID(FocusType.Passive)) as EditingState;

        using (new EditorGUILayout.HorizontalScope(style))
        {
            Rect editButtonRect = new Rect(position.x, position.y, 16f, 16f);
            if (GUI.Button(editButtonRect, "E"))
            {
                // well since it's a class we dun need to set it back :>
                state.IsEditing = !state.IsEditing;
            }

            if (GUILayout.Button("X", GUILayout.Width(18)))
            {
                state.IsEditing = !state.IsEditing;
            }
            if (state.IsEditing)
            {
                // show text field
                tagStr = EditorGUILayout.TextField(tagStr);
            }
            else
            {
                // show lable
                EditorGUILayout.LabelField(tagStr);
            }
        }
        
    }
}

public static class InputBindSaveHelper
{
    static readonly string s_keyMappingPreferKey = "KeyMapping";

    public static void SaveActionMapRebinding(InputActionMap actionMap)
    {
        Dictionary<Guid, string> overridedActionPathDict = new Dictionary<Guid, string>();
        UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputAction> actions = actionMap.actions;
        for (int i = 0; i < actions.Count; i++)
        {
            InputAction action = actions[i];
            UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputBinding> actionBindings = action.bindings;
            for (int j = 0; j < actionBindings.Count; j++)
            {
                InputBinding actionBinding = actionBindings[j];
                if (string.IsNullOrEmpty(actionBinding.overridePath))
                    continue;
                overridedActionPathDict.Add(actionBinding.id, actionBinding.overridePath);
            }
        }

        BinaryFormatter binFormatter = new BinaryFormatter();
        MemoryStream mStream = new MemoryStream();
        binFormatter.Serialize(mStream, overridedActionPathDict);

        byte[] byteArr = mStream.ToArray();
        // idk why [Encoding.UTF8.GetString()] just doesnt work
        string encodingString = Convert.ToBase64String(byteArr, Base64FormattingOptions.InsertLineBreaks);
        PlayerPrefs.SetString(s_keyMappingPreferKey, encodingString);
    }

    public static void LoadActionMapRebinding(InputActionMap actionMap)
    {
        string encodingString = PlayerPrefs.GetString(s_keyMappingPreferKey);
        byte[] byteArr = Convert.FromBase64String(encodingString);

        BinaryFormatter binFormatter = new BinaryFormatter();
        MemoryStream mStream = new MemoryStream(byteArr);
        Dictionary<Guid, string> rebindSavePairDict = binFormatter.Deserialize(mStream) as Dictionary<Guid, string>;

        if (rebindSavePairDict != null)
        {
            UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputAction> actions = actionMap.actions;
            for (int i = 0; i < actions.Count; i++)
            {
                InputAction action = actions[i];
                UnityEngine.InputSystem.Utilities.ReadOnlyArray<InputBinding> actionBindings = action.bindings;
                for (int j = 0; j < actionBindings.Count; j++)
                {
                    InputBinding actionBinding = actionBindings[j];
                    // override
                    if (rebindSavePairDict.ContainsKey(actionBinding.id))
                    {
                        actionBinding.overridePath = rebindSavePairDict[actionBinding.id];
                        action.ApplyBindingOverride(actionBinding);
                    }
                }
            }

        }
    }
}

public class RaycastTarget : Graphic
{
    // Additionally, If you need a Raycast target that is not a rectangle, you can implement bool Raycast(Vector2 sp, Camera eventCamera) method from Graphic.
    public override void SetMaterialDirty() { return; }
    public override void SetVerticesDirty() { return; }
    /// Probably not necessary since the chain of calls `Rebuild()`->`UpdateGeometry()`->`DoMeshGeneration()`->`OnPopulateMesh()` won't happen; so here really just as a fail-safe.
    protected override void OnPopulateMesh(VertexHelper vh)
    {
        vh.Clear();
        return;
    }

#if UNITY_EDITOR

    private void OnDrawGizmos()
    {
        if (!this.enabled)
            return
        RectTransform rectTransform = this.transform as RectTransform;
        Color wireColor = Color.yellow;
        if (this.isActiveAndEnabled)
            wireColor.a *= 0.7f
        // Padding to be applied to the masking
        // X = Left, Y = Bottom, Z = Right, W = Top
        // if you wanna make it bigger, then the all value shouble be negative
        Vector4 padding = this.raycastPadding * -1.0f;
        Matrix4x4 localToWorld = rectTransform.localToWorldMatrix
        Vector3 topLeft = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.TopLeft);
        Vector3 topRight = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.TopRight);
        Vector3 bottomLeft = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.BottomLeft);
        Vector3 bottomRight = SomeUtils.GetOffsetLocalPosition(rectTransform, SomeUtils.UIOffsetType.BottomRight)
        topLeft = localToWorld.MultiplyPoint(topLeft + (Vector3.left * padding.x) + (Vector3.up * padding.w));
        topRight = localToWorld.MultiplyPoint(topRight + (Vector3.right * padding.z) + (Vector3.up * padding.w));
        bottomLeft = localToWorld.MultiplyPoint(bottomLeft + (Vector3.left * padding.x) + (Vector3.down * padding.y));
        bottomRight = localToWorld.MultiplyPoint(bottomRight + (Vector3.right * padding.z) + (Vector3.down * padding.y))
        Color tempColor = Gizmos.color;
        Gizmos.color = wireColor
        Gizmos.DrawLine(topLeft, topRight);
        Gizmos.DrawLine(topLeft, bottomLeft);
        Gizmos.DrawLine(bottomRight, topRight);
        Gizmos.DrawLine(bottomRight, bottomLeft);
        Gizmos.color = tempColor
    }

#endif

}

public void OnScrollWheel(InputAction.CallbackContext context)
{
    if (IsActive())
    {
        PointerEventData eventData = GetPointerData();
        eventData.button = PointerEventData.InputButton.Middle;
        eventData.Reset();
        eventData.scrollDelta = context.ReadValue<Vector2>()
        GameObject testScrollObject = ExecuteEventExecuteHierarchy(eventData.pointerCurrentRaycasgameObject, eventData, ExecuteEvents.scrollHandler)
        if (testScrollObject != null)
        {
            // to re-do the reycast cuz we may scroll a recyclscrollrect
            HandlePointerExitAndEnter(eventData, null);
            m_rayCastDelayFrame = SCROLL_RAYCAST_DELAY;
            // SCROLL_RAYCAST_DELAY =3 or 5, depends....
        }
    }
}

// will call in update
public override void Process()
{
    /*
    .....
    */
    CheckAndDoDelayRaycast();
}

void CheckAndDoDelayRaycast()
{
    if (m_rayCastDelayFrame < 0)
    {
        return;
    
    if (--m_rayCastDelayFrame == 0)
    {
        var eventData = GetPointerData();
        eventSystem.RaycastAll(eventData, m_RaycastResultCache);
        var firstRaycast = FindFirstRaycast(m_RaycastResultCache)
        eventData.pointerCurrentRaycast = firstRaycast;
        m_RaycastResultCache.Clear()
        var temp = eventData.pointerCurrentRaycast.gameObject;
        HandlePointerExitAndEnter(eventData, temp);
        m_rayCastDelayFrame = -1;
    }
}