private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <UIImage> mvxValueEventArgs)
{
if (KittenImageView != null && mvxValueEventArgs.Value != null)
{
KittenImageView.Image = mvxValueEventArgs.Value;
}
}
protected override void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs)
{
// it is guarannted that SaveInstanceState call will be executed before OnStop (thus before Fragment detach)
// it is safe to assume that Fragment has activity attached
if (!FragmentView.GetType().IsFragmentCacheable(Fragment.Activity.GetType()))
{
return;
}
var mvxBundle = FragmentView.CreateSaveStateBundle();
if (mvxBundle != null)
{
IMvxSavedStateConverter converter;
if (!Mvx.TryResolve(out converter))
{
MvxTrace.Warning("Saved state converter not available - saving state will be hard");
}
else
{
converter.Write(bundleArgs.Value, mvxBundle);
}
}
var cache = Mvx.Resolve <IMvxMultipleViewModelCache>();
cache.Cache(FragmentView.ViewModel, FragmentView.UniqueImmutableCacheTag);
}
protected override void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs)
{
if (!FragmentView.GetType().IsOwnedViewModelFragment())
{
return;
}
var mvxBundle = FragmentView.CreateSaveStateBundle();
if (mvxBundle != null)
{
IMvxSavedStateConverter converter;
if (!Mvx.TryResolve(out converter))
{
MvxTrace.Warning("Saved state converter not available - saving state will be hard");
}
else
{
converter.Write(bundleArgs.Value, mvxBundle);
}
}
var cache = Mvx.Resolve <IMvxMultipleViewModelCache>();
cache.Cache(FragmentView.ViewModel);
}
private void MoveJoystickOnNewCoordinates(object sender, MvxValueEventArgs<CartesianPositionParameters> eventArgs)
{
if (ViewModel != null)
{
ViewModel.Movement.RollCommand.Execute(eventArgs.Value);
}
}
private void MoveJoystickOnNewCoordinates(object sender, MvxValueEventArgs <CartesianPositionParameters> eventArgs)
{
if (ViewModel != null)
{
ViewModel.Movement.RollCommand.Execute(eventArgs.Value);
}
}
private void OnWillAppearCalled(object sender, MvxValueEventArgs <bool> e)
{
var topController = sender as IMvxEventSourceViewController;
topController.ViewDidDisappearCalled -= OnDidDisappearCalled;
topController.ViewWillAppearCalled -= OnWillAppearCalled;
}
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 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);
}
}
}
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <Bitmap> mvxValueEventArgs)
{
using (var h = new Handler(Looper.MainLooper))
h.Post(() =>
{
this.SetImageBitmap(mvxValueEventArgs.Value);
});
}
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs)
{
InvokeOnMainThread(() =>
{
if (ImageView != null)
ImageView.Image = mvxValueEventArgs.Value;
});
}
// Note - this is public because we use it in weak referenced situations
public virtual void ImageHelperOnImageChanged(
object sender,
MvxValueEventArgs <UIImage> mvxValueEventArgs)
{
var helper = (IMvxResizedImageHelper <UIImage>)sender;
_imageSetAction(mvxValueEventArgs.Value, helper.CurrentImageState);
}
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <UIImage> mvxValueEventArgs)
{
var imageView = _imageView();
if (imageView != null && mvxValueEventArgs.Value != null)
{
imageView.Image = mvxValueEventArgs.Value;
}
}
public void HandleSelectedSalepointMarkers(object sender, MvxValueEventArgs <int?> e)
{
ClearOrdersMarkers();
if (e.Value.HasValue)
{
SetOrdersMarkers();
}
}
private void CurrentImageRequestOnError(object sender, MvxValueEventArgs <Exception> mvxExceptionEventArgs)
{
if (sender != _currentImageRequest)
{
return;
}
HttpImageErrorSeen();
ClearCurrentHttpImageRequest();
}
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs <UIImage> mvxValueEventArgs)
{
InvokeOnMainThread(() =>
{
if (ImageView != null)
{
ImageView.Image = mvxValueEventArgs.Value;
}
});
}
protected override void EventSourceOnActivityResultCalled(object sender,
MvxValueEventArgs <MvxActivityResultParameters> args)
{
var sink = Mvx.IoCProvider.Resolve <IMvxIntentResultSink>();
var resultParameters = args.Value;
var intentResult = new MvxIntentResultEventArgs(resultParameters.RequestCode, resultParameters.ResultCode,
resultParameters.Data);
sink.OnResult(intentResult);
}
private void OnMapDelegateDetailsClick(object sender, MvxValueEventArgs <IMapAnnotation> e)
{
var venueAnnotation = e.Value as VenueAnnotation;
if (venueAnnotation != null &&
ViewModel.NavigateVenueCommand.CanExecute(venueAnnotation.Venue))
{
ViewModel.NavigateVenueCommand.Execute(venueAnnotation.Venue);
}
}
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 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);
}
}
}
private void OnServiceStatus(object sender, MvxValueEventArgs <StatusInteraction> args)
{
UIAlertView alert = new UIAlertView()
{
Title = args.Value.Title,
Message = args.Value.Message
};
alert.AddButton("OK");
alert.Show();
}
private void CurrentImageRequestOnComplete(object sender, MvxValueEventArgs <T> mvxValueEventArgs)
{
if (sender != _currentImageRequest)
{
return;
}
var image = mvxValueEventArgs.Value;
NewImageAvailable(image);
ClearCurrentHttpImageRequest();
}
private void CurrentImageRequestOnError(object sender, MvxValueEventArgs <Exception> mvxExceptionEventArgs)
{
if (sender != _currentImageRequest)
{
return;
}
Mvx.Trace("failed to download image {0} : {1}", _currentImageRequest.Url, mvxExceptionEventArgs.Value.ToLongString());
HttpImageErrorSeen();
ClearCurrentHttpImageRequest();
}
private void OnDidDisappearCalled(object sender, MvxValueEventArgs <bool> e)
{
var controller = sender as IUnbindable;
if (controller != null)
{
UnbindCycle(ref controller);
}
sender.DisposeIfDisposable();
sender = null;
}
private void OnZoomToVenue(object sender, MvxValueEventArgs <Venue> e)
{
EndSearch();
var annotation = GetAnnotationByVenue(ViewModel.SelectedVenueOnMap);
var shiftedCoord = annotation.Coordinate;
shiftedCoord.Latitude += 0.0008f;
VenuesMapView.SetRegion(
MapUtil.CoordinateRegionForCoordinates(shiftedCoord), true);
}
private void OnActivityResult(object sender, MvxValueEventArgs <MvxActivityResultParameters> args)
{
switch (args.Value.RequestCode)
{
case FileSelectedRequestCode:
if (args.Value.Data != null)
{
var inputStream = OpenStreamForUri(args.Value.Data.Data);
_streamWaitingTaskCompletionSource.SetResult(inputStream);
}
break;
}
}
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 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 EventSourceOnStartActivityForResultCalled(object sender,
MvxValueEventArgs <MvxStartActivityForResultParameters> MvxValueEventArgs)
{
var requestCode = MvxValueEventArgs.Value.RequestCode;
switch (requestCode)
{
case (int)MvxIntentRequestCode.PickFromFile:
MvxLog.Instance.Warn("Warning - activity request code may clash with Mvx code for {0}",
(MvxIntentRequestCode)requestCode);
break;
}
}
protected override void EventSourceOnSaveInstanceStateCalled(object sender, MvxValueEventArgs <Bundle> bundleArgs)
{
var converter = Mvx.Resolve <IMvxSavedStateConverter>();
var mvxBundle = AndroidView.CreateSaveStateBundle();
if (mvxBundle != null)
{
converter.Write(bundleArgs.Value, mvxBundle);
}
var cache = Mvx.Resolve <IMvxSingleViewModelCache>();
cache.Cache(AndroidView.ViewModel, bundleArgs.Value);
}
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> eventArgs)
{
var requestCode = eventArgs.Value.RequestCode;
switch (requestCode)
{
case (int)MvxIntentRequestCode.PickFromFile:
MvxLogHost.GetLog <MvxActivityAdapter>()?.Log(LogLevel.Warning,
"Warning - activity request code may clash with Mvx code for {requestCode}",
(MvxIntentRequestCode)requestCode);
break;
}
}
private void OnRefreshCompleted(object sender, MvxValueEventArgs <bool> e)
{
var pullToRefresh =
ListView.RefreshControl != null &&
ListView.RefreshControl.Refreshing;
if (pullToRefresh)
{
ListView.RefreshControl.EndRefreshing();
}
UpdateMessageState(Localization.NoContentAvailable, !e.Value);
OnViewModelRefreshed(e.Value, pullToRefresh);
}
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);
}
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);
}
private void OnInteractionRequested(object sender, MvxValueEventArgs <bool> eventArgs)
{
Activity.RunOnUiThread(() =>
{
if (eventArgs.Value)
{
_btnUpload.setProgress(100);
_btnUpload.Enabled = false;
}
else
{
_btnUpload.setProgress(-1);
}
});
}
private void PermissionChanged(object sender, MvxValueEventArgs <MvxLocationPermission> e)
{
Console.WriteLine("Permission changed: " + e.Value.ToString());
if (e.Value != MvxLocationPermission.Denied)
{
return;
}
TaskCompletionSource <MvxCoordinates> source;
lock (_lock)
{
source = _taskSource;
_taskSource = null;
}
source?.SetException(new Exception(MvxLocationErrorCode.PermissionDenied.ToString()));
}
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);
}
});
}
private void OpenPopupMenu(object sender, MvxValueEventArgs<PopupMenuRequest> request)
{
this.CleanAll();
_currentRequest = request.Value;
var view = base.Target as View;
if (view == null)
return;
_menu = new PopupMenu(view.Context, view);
int menuId = Menu.First + 1;
foreach (var item in _currentRequest.LstPopupItem)
{
_menu.Menu.Add(0, menuId, item.Order, item.Title);
menuId++;
}
_menu.MenuItemClick += MenuItemClick;
_menu.DismissEvent += MenuDismissEvent;
_menu.Show();
}
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<Bitmap> mvxValueEventArgs)
{
SetImageBitmap(mvxValueEventArgs.Value);
}
protected override void EventSourceOnCreateCalled(object sender, MvxValueEventArgs<Bundle> eventArgs)
{
this.AndroidView.OnViewCreate(eventArgs.Value);
}
public override void HandleAwakeCalled(object sender, MvxValueEventArgs<NSObject> e)
{
this.WatchOSView.OnViewCreate();
base.HandleAwakeCalled(sender, e);
}
protected virtual void EventSourceOnActivityResultCalled(object sender,
MvxValueEventArgs<MvxActivityResultParameters>
MvxValueEventArgs)
{
}
protected virtual void EventSourceOnNewIntentCalled(object sender, MvxValueEventArgs<Intent> MvxValueEventArgs)
{
}
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 EventSourceOnCreateWillBeCalled(object sender,
MvxValueEventArgs<Bundle> MvxValueEventArgs)
{
this.BindingContext.ClearAllBindings();
base.EventSourceOnCreateWillBeCalled(sender, MvxValueEventArgs);
}
protected override void HandleSaveInstanceStateCalled(object sender, MvxValueEventArgs<Bundle> bundleArgs)
{
if (!FragmentView.GetType().IsOwnedViewModelFragment())
return;
var mvxBundle = FragmentView.CreateSaveStateBundle();
if (mvxBundle != null)
{
IMvxSavedStateConverter converter;
if (!Mvx.TryResolve(out converter))
{
MvxTrace.Warning("Saved state converter not available - saving state will be hard");
}
else
{
converter.Write(bundleArgs.Value, mvxBundle);
}
}
var cache = Mvx.Resolve<IMvxMultipleViewModelCache>();
cache.Cache(FragmentView.ViewModel);
}
protected override void HandleCreateViewCalled(object sender,
MvxValueEventArgs<MvxCreateViewParameters> args)
{
FragmentView.EnsureBindingContextIsSet(args.Value.Inflater);
}
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs)
{
if (ImageView != null)
ImageView.Image = mvxValueEventArgs.Value;
}
protected virtual void EventSourceOnSaveInstanceStateCalled(object sender,
MvxValueEventArgs<Bundle> mvxValueEventArgs)
{
}
protected virtual void HandleCreateViewCalled(object sender,
MvxValueEventArgs<MvxCreateViewParameters> mvxValueEventArgs)
{
}
protected virtual void EventSourceOnCreateCalled(object sender, MvxValueEventArgs<Bundle> MvxValueEventArgs)
{
}
protected override void EventSourceOnActivityResultCalled(object sender,
MvxValueEventArgs<MvxActivityResultParameters>
args)
{
var sink = Mvx.Resolve<IMvxIntentResultSink>();
var resultParameters = args.Value;
var intentResult = new MvxIntentResultEventArgs(resultParameters.RequestCode, resultParameters.ResultCode,
resultParameters.Data);
sink.OnResult(intentResult);
}
private void ImageHelperOnImageChanged(object sender, MvxValueEventArgs<UIImage> mvxValueEventArgs)
{
Image = mvxValueEventArgs.Value;
}
protected override void EventSourceOnNewIntentCalled(object sender, MvxValueEventArgs<Intent> MvxValueEventArgs)
{
this.AndroidView.OnViewNewIntent();
}
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)
{
}
