private void MoveJoystickOnNewCoordinates(object sender, MvxValueEventArgs<CartesianPositionParameters> eventArgs)
 {
     if (ViewModel != null)
     {
         ViewModel.Movement.RollCommand.Execute(eventArgs.Value);
     }
 }

 private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs)
 {
     InvokeOnMainThread(() =>
     {
         if (ImageView != null)
             ImageView.Image = mvxValueEventArgs.Value;
     });
 }

        protected override void HandleCreateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs)
        {
            FragmentView.EnsureSetupInitialized();

            // Create is called after Fragment is attached to Activity
            // it's safe to assume that Fragment has activity
            if (!FragmentView.GetType().IsFragmentCacheable(Fragment.Activity.GetType()))
                return;

            FragmentView.RegisterFragmentViewToCacheIfNeeded(Fragment.Activity.GetType());

            Bundle bundle = null;
            MvxViewModelRequest request = null;
            if (bundleArgs?.Value != null)
            {
                // saved state
                bundle = bundleArgs.Value;
            }
            else
            {
                var fragment = FragmentView as Fragment;
                if (fragment?.Arguments != null)
                {
                    bundle = fragment.Arguments;
                    var json = bundle.GetString("__mvxViewModelRequest");
                    if (!string.IsNullOrEmpty(json))
                    {
                        IMvxNavigationSerializer serializer;
                        if (!Mvx.TryResolve(out serializer))
                        {
                            MvxTrace.Warning(
                                "Navigation Serializer not available, deserializing ViewModel Request will be hard");
                        }
                        else
                        {
                            request = serializer.Serializer.DeserializeObject<MvxViewModelRequest>(json);
                        }
                    }
                }
            }

            IMvxSavedStateConverter converter;
            if (!Mvx.TryResolve(out converter))
            {
                MvxTrace.Warning("Saved state converter not available - saving state will be hard");
            }
            else
            {
                if (bundle != null)
                {
                    var mvxBundle = converter.Read(bundle);
                    FragmentView.OnCreate(mvxBundle, request);
                }
            }
        }

        protected override void NewIntent(MvxValueEventArgs<Intent> e)
        {
            string id=GetIdFromTag(e.Value);
            var tagAsNdefMessage = e.Value.GetParcelableArrayExtra(NfcAdapter.ExtraNdefMessages);
            if (tagAsNdefMessage != null)
            {

                var tag = tagAsNdefMessage[0] as NdefMessage;
                byte[] message = tag.ToByteArray();
                var ndefMessage = NdefLibrary.Ndef.NdefMessage.FromByteArray(message);
                NewMessage(id,ndefMessage);
            }
        }

        protected override void HandleCreateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs)
        {
            FragmentView.EnsureSetupInitialized();

            if (!FragmentView.GetType().IsOwnedViewModelFragment())
                return;

            Bundle bundle = null;
            MvxViewModelRequest request = null;
            if (bundleArgs != null && bundleArgs.Value != null)
            {
                // saved state
                bundle = bundleArgs.Value;
            }
            else
            {
                var fragment = FragmentView as Fragment;
                if (fragment != null && fragment.Arguments != null)
                {
                    bundle = fragment.Arguments;
                    var json = bundle.GetString("__mvxViewModelRequest");
                    if (!string.IsNullOrEmpty(json))
                    {
                        IMvxNavigationSerializer serializer;
                        if (!Mvx.TryResolve(out serializer))
                        {
                            MvxTrace.Warning(
                                "Navigation Serializer not available, deserializing ViewModel Request will be hard");
                        }
                        else
                        {
                            request = serializer.Serializer.DeserializeObject<MvxViewModelRequest>(json);
                        }
                    }
                }
            }

            IMvxSavedStateConverter converter;
            if (!Mvx.TryResolve(out converter))
            {
                MvxTrace.Warning("Saved state converter not available - saving state will be hard");
            }
            else
            {
                if (bundle != null)
                {
                    var mvxBundle = converter.Read(bundle);
                    FragmentView.OnCreate(mvxBundle, request);
                }
            }
        }

 protected override void EventSourceOnStartActivityForResultCalled(object sender,
                                                                   MvxValueEventArgs
                                                                       <MvxStartActivityForResultParameters>
                                                                       MvxValueEventArgs)
 {
     var requestCode = MvxValueEventArgs.Value.RequestCode;
     switch (requestCode)
     {
         case (int)MvxIntentRequestCode.PickFromFile:
             MvxTrace.Warning("Warning - activity request code may clash with Mvx code for {0}",
                            (MvxIntentRequestCode)requestCode);
             break;
     }
 }

        private void AccelerometerOnReadingAvailable(object sender, MvxValueEventArgs<Reading> mvxValueEventArgs)
        {
            // note that the switchover between Y and X here is deliberate!
            // and that we invert Y
            // this may need tweaking platform-by-platform 
            // and phone by phone - and maybe at runtime too!

            var parameters = new CartesianPositionParameters
                {
                    X = MakeSafe(-mvxValueEventArgs.Value.Y),
                    Y = MakeSafe(mvxValueEventArgs.Value.X),
                };

            DoRoll(parameters);
        }

 protected override void EventSourceOnSaveInstanceStateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs)
 {
     var mvxBundle = AndroidView.CreateSaveStateBundle();
     if (mvxBundle != null)
     {
         IMvxSavedStateConverter converter;
         if (!Mvx.TryResolve<IMvxSavedStateConverter>(out converter))
         {
             MvxTrace.Warning("Saved state converter not available - saving state will be hard");
         }
         else
         {
             converter.Write(bundleArgs.Value, mvxBundle);
         }
     }
     var cache = Mvx.Resolve<IMvxSingleViewModelCache>();
     cache.Cache(AndroidView.ViewModel, bundleArgs.Value);
 }

        private void SpeechListenerOnHeard(object sender, MvxValueEventArgs<PossibleWord> e)
        {
            if (!SpeechIsOn)
                return;

            MethodInfo methodInfo;
            if (!_speechMethods.TryGetValue(e.Value.Word, out methodInfo))
                return;

            methodInfo.Invoke(this, new object[0]);

            this.InvokeOnMainThread(() =>
                {
                    HeardSoFar.Insert(0, e.Value.Word);
                    while (HeardSoFar.Count > 100)
                    {
                        HeardSoFar.RemoveAt(HeardSoFar.Count - 1);
                    }
                });
        }

 protected virtual void HandleAttachCalled(object sender, MvxValueEventArgs<Activity> e)
 {
 }

 protected virtual void HandleCreateCalled(object sender, MvxValueEventArgs<Bundle> e)
 {
 }

 protected virtual void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs<Bundle> e)
 {
 }

 protected override void EventSourceOnCreateCalled(object sender, MvxValueEventArgs<Bundle> eventArgs)
 {
     this.AndroidView.OnViewCreate(eventArgs.Value);
 }

 private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<Bitmap> mvxValueEventArgs)
 {
     using (var h = new Handler(Looper.MainLooper)) h.Post(() => { this.SetImageBitmap(mvxValueEventArgs.Value); });
 }

 public virtual void HandleViewDidAppearCalled(object sender, MvxValueEventArgs<bool> e)
 {
 }

 public override void HandleAwakeCalled(object sender, MvxValueEventArgs<NSObject> e)
 {
     this.WatchOSView.OnViewCreate();
     base.HandleAwakeCalled(sender, e);
 }

 private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs)
 {
     Image = mvxValueEventArgs.Value;
 }

 private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<Bitmap> mvxValueEventArgs)
 {
     SetImageBitmap(mvxValueEventArgs.Value);
 }

 protected virtual void HandleCreateViewCalled(object sender,
                                               MvxValueEventArgs<MvxCreateViewParameters> mvxValueEventArgs)
 {
 }

 protected virtual void EventSourceOnSaveInstanceStateCalled(object sender,
                                                             MvxValueEventArgs<Bundle> mvxValueEventArgs)
 {
 }