public void Activate()
{
Window window = NUIApplication.GetDefaultWindow();
window.BackgroundColor = Color.White;
windowSize = window.Size;
// Create Table
TableView table = new TableView(mRow, mColumn)
{
PositionUsesPivotPoint = true,
PivotPoint = PivotPoint.Center,
ParentOrigin = ParentOrigin.Center,
Size = new Size((float)(windowSize.Width * 0.8), (float)(windowSize.Height * 0.8)),
BackgroundColor = new Color(0.2f, 0.5f, 0.5f, 1.0f),
CellPadding = new Vector2(10, 10),
};
window.GetDefaultLayer().Add(table);
uint exampleCount = 0;
// Fill the contents in TableView
for (uint row = 0; row < mRow; row++)
{
for (uint column = 0; column < mColumn; column++)
{
TextLabel content = CreateText();
content.Name = "TextLabel" + exampleCount;
content.Text = "R" + row + " - C" + column;
///////////////////////////////////////////////////////////////////////////////////////////////
/// How to set Accessibility attribute to components ///
/// 1. Create AccessibilityManager. ///
/// 2. Set the focus order of each view and the index of order should start 1 (one). ///
/// 3. Set the information of each view's accessibility attribute. ///
/// There are four attributes, which will be read by screen reader. ///
/// And the order of reading is : Label -> Trait -> Value (Optional) -> Hint (Optional) ///
///////////////////////////////////////////////////////////////////////////////////////////////
AccessibilityManager manager = AccessibilityManager.Instance;
manager.SetFocusOrder(content, ++exampleCount);
manager.SetAccessibilityAttribute(content,
AccessibilityManager.AccessibilityAttribute.Label, content.Name);
manager.SetAccessibilityAttribute(content,
AccessibilityManager.AccessibilityAttribute.Trait, "Tile");
manager.SetAccessibilityAttribute(content,
AccessibilityManager.AccessibilityAttribute.Hint, "You can run this example");
table.AddChild(content, new TableView.CellPosition(row, column));
}
}
// You can connect with various Accessibility action signals.
// AccessibilityManager provides functionality of setting the focus and moving forward and backward.
// All touch interactions for screen will work with one more finger and tap.
AccessibilityManager.Instance.FocusedViewActivated += OnFocusedView;
}
protected override void OnAttached()
{
if (View == null)
{
return;
}
effect = TouchEffect.PickFrom(Element);
if (effect?.IsDisabled ?? true)
{
return;
}
effect.Element = (VisualElement)Element;
View.Touch += OnTouch;
UpdateClickHandler();
accessibilityManager = View.Context.GetSystemService(Context.AccessibilityService) as AccessibilityManager;
if (accessibilityManager != null)
{
accessibilityListener = new AccessibilityListener(this);
accessibilityManager.AddAccessibilityStateChangeListener(accessibilityListener);
accessibilityManager.AddTouchExplorationStateChangeListener(accessibilityListener);
}
if (Build.VERSION.SdkInt < BuildVersionCodes.Lollipop || !effect.NativeAnimation)
{
return;
}
View.Clickable = true;
View.LongClickable = true;
CreateRipple();
if (Group == null)
{
if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
View.Foreground = ripple;
}
return;
}
rippleView = new FrameLayout(Group.Context)
{
LayoutParameters = new ViewGroup.LayoutParams(-1, -1),
Clickable = false,
Focusable = false,
Enabled = false,
};
View.LayoutChange += OnLayoutChange;
rippleView.Background = ripple;
Group.AddView(rippleView);
rippleView.BringToFront();
}
private float getScreenHeight()
{
if (screenHeight < 0f)
{
AccessibilityManager accessibilityManager = Service.Get <AccessibilityManager>();
screenHeight = accessibilityManager.GetScreenSizeWithSoftKeys().y;
}
return(screenHeight);
}
/**
* {@inheritDoc}
*/
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(R.Layout.accessibility_manager);
mAccessibilityManager = (AccessibilityManager)GetSystemService(
Service.ACCESSIBILITY_SERVICE);
mAccessibilityStateView = (TextView)FindViewById(R.Id.accessibility_state);
RegisterAccessibilityStateChangeListener();
}
public bool Emit(AccessibilityManager arg)
{
bool ret = Interop.AccessibilityManage.AccessibilityActionSignal_Emit(swigCPtr, AccessibilityManager.getCPtr(arg));
if (NDalicPINVOKE.SWIGPendingException.Pending)
{
throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
protected override void OnCreate(Bundle savedInstanceState)
{
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(savedInstanceState);
global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
LoadApplication(new App());
accessibilityManager = (AccessibilityManager)GetSystemService("accessibility");
}
public bool IsVoiceAssistanceActive()
{
AccessibilityManager am = (AccessibilityManager)Android.App.Application.Context.GetSystemService(Context.AccessibilityService);
if (am != null & am.IsEnabled)
{
return(am.IsTouchExplorationEnabled);
}
return(false);
}
protected override void OnCreate(Bundle bundle)
{
AppDomain.CurrentDomain.UnhandledException += PlatformError.CurrentDomainUnhandledException;
TaskScheduler.UnobservedTaskException += PlatformError.TaskSchedulerUnobservedTaskException;
App.ScreenHeight = (int)(Resources.DisplayMetrics.HeightPixels / Resources.DisplayMetrics.Density);
App.ScreenWidth = (int)(Resources.DisplayMetrics.WidthPixels / Resources.DisplayMetrics.Density);
App.VersionName = Application.ApplicationContext.PackageManager
.GetPackageInfo(Application.ApplicationContext.PackageName, 0)
.VersionName;
AccessibilityManager accessibilityManager = (AccessibilityManager)GetSystemService(AccessibilityService);
//NOTE: ref: https://stackoverflow.com/a/12362545 we only use touch exploration events for checking if talkback is enabled
accessibilityManager.AddTouchExplorationStateChangeListener(this);
Accessibility.AccessibilityEnabled = accessibilityManager.IsTouchExplorationEnabled;
Xamarin.Forms.Forms.Init(this, bundle);
UserDialogs.Init(this);
CarouselViewRenderer.Init();
CachedImageRenderer.Init(true);
FlowListView.Init();
Rg.Plugins.Popup.Popup.Init(this, bundle);
LocalNotificationsImplementation.NotificationIconId = Resource.Mipmap.notification_icon;
//NOTE: We know. Lazy loading of service for platform specific version
#pragma warning disable CS0436 // Type conflicts with imported type
IWalkingDataService walkingDataService = CrossWalkingDataService.Current;
IUpdateService updateService = CrossUpdateService.Current;
IScreenshotService screenshotService = CrossScreenshotService.Current;
IShareImageService shareImageService = CrossImageShareService.Current;
#pragma warning restore CS0436 // Type conflicts with imported type
ScreenshotService.Activity = this;
ShareImageService.Context = this;
CrossServiceContainer.SetWalkingDataService(walkingDataService);
CrossServiceContainer.SetUpdateService(updateService);
CrossServiceContainer.SetScreenshotService(screenshotService);
CrossServiceContainer.SetShareImageService(shareImageService);
Log.Debug("MainActivity", "Mainactivity updateservice: " + updateService.ToString());
base.OnCreate(bundle);
Instance = this;
OnActivityCreated?.Invoke(this);
if (Settings.CanRequestReview())
{
RequestReview();
}
}
protected override void OnDetached()
{
if (effect?.Element == null)
{
return;
}
try
{
if (accessibilityManager != null)
{
accessibilityManager.RemoveAccessibilityStateChangeListener(accessibilityListener);
accessibilityManager.RemoveTouchExplorationStateChangeListener(accessibilityListener);
accessibilityListener.Dispose();
accessibilityManager = null;
accessibilityListener = null;
}
if (View != null)
{
View.LayoutChange -= OnLayoutChange;
View.Touch -= OnTouch;
View.Click -= OnClick;
if (Build.VERSION.SdkInt >= BuildVersionCodes.M && View.Foreground == ripple)
{
View.Foreground = null;
}
}
effect.Element = null;
effect = null;
if (rippleView != null)
{
rippleView.Pressed = false;
rippleView.Background = null;
Group?.RemoveView(rippleView);
rippleView.Dispose();
rippleView = null;
}
ripple?.Dispose();
ripple = null;
}
catch (ObjectDisposedException)
{
// Suppress exception
}
isHoverSupported = false;
}
public bool IsVoiceOverRunning()
{
AccessibilityManager am = (AccessibilityManager)Android.App.Application.Context.GetSystemService(Context.AccessibilityService);
if (am != null && am.IsEnabled)
{
var serviceInfoList = am.GetEnabledAccessibilityServiceList(FeedbackFlags.Spoken);
if (serviceInfoList != null)
{
return(true);
}
}
return(false);
}
public Boolean isAccessibilityServiceEnabled()
{
AccessibilityManager accessibilityManager = (AccessibilityManager)Application.Context.GetSystemService(AccessibilityService.AccessibilityService);
IList <AccessibilityServiceInfo> enabledServices = accessibilityManager.GetEnabledAccessibilityServiceList(FeedbackFlags.AllMask);
bool check = false;
for (int i = 0; i < enabledServices.Count; i++)
{
AccessibilityServiceInfo e = enabledServices[i];
if (e.ResolveInfo.ServiceInfo.PackageName == Application.Context.ApplicationInfo.PackageName)
{
check = true;
}
}
return(check);
}
public void SetAnnouncement(string text)
{
AccessibilityManager manager = (AccessibilityManager)Android.App.Application.Context.GetSystemService(Android.App.Application.AccessibilityService);
if (!(manager.IsEnabled || manager.IsTouchExplorationEnabled))
{
return;
}
// Sends the accessibility event to announce.
AccessibilityEvent e = AccessibilityEvent.Obtain();
e.EventType = EventTypes.Announcement;
e.Text.Add(new Java.Lang.String(text));
manager.SendAccessibilityEvent(e);
}
protected override void OnDetached()
{
if (effect?.Element == null)
{
return;
}
try
{
if (accessibilityManager != null)
{
accessibilityManager.RemoveAccessibilityStateChangeListener(accessibilityListener);
accessibilityManager.RemoveTouchExplorationStateChangeListener(accessibilityListener);
accessibilityListener.Dispose();
accessibilityManager = null;
accessibilityManager = null;
}
if (View != null)
{
View.LayoutChange -= LayoutChange;
View.Touch -= OnTouch;
View.Click -= OnClick;
}
effect.Element = null;
effect = null;
if (viewOverlay != null)
{
if (Group != null)
{
Group.RemoveView(viewOverlay);
}
viewOverlay.Pressed = false;
viewOverlay.Foreground = null;
viewOverlay.Dispose();
ripple?.Dispose();
}
}
catch (ObjectDisposedException)
{
// Suppress exception
}
isHoverSupported = false;
}
protected override void OnDetached()
{
if (_effect?.Control == null)
{
return;
}
try
{
if (_accessibilityManager != null)
{
_accessibilityManager.RemoveAccessibilityStateChangeListener(_accessibilityListener);
_accessibilityManager.RemoveTouchExplorationStateChangeListener(_accessibilityListener);
_accessibilityListener.Dispose();
_accessibilityManager = null;
_accessibilityManager = null;
}
if (View != null)
{
View.LayoutChange -= LayoutChange;
View.Touch -= OnTouch;
View.Click -= OnClick;
}
_effect.Control = null;
_effect = null;
if (_viewOverlay != null)
{
if (Group != null)
{
Group.RemoveView(_viewOverlay);
}
_viewOverlay.Pressed = false;
_viewOverlay.Foreground = null;
_viewOverlay.Dispose();
_ripple?.Dispose();
}
}
catch (ObjectDisposedException)
{
//suppress exception
}
_isHoverSupported = false;
}
protected override void OnAttached()
{
if (View == null)
{
return;
}
_effect = Element.PickTouchEff();
if (_effect?.IsDisabled ?? true)
{
return;
}
_effect.Control = Element as VisualElement;
View.Touch += OnTouch;
UpdateClickHandler();
_accessibilityManager = View.Context.GetSystemService(Context.AccessibilityService) as AccessibilityManager;
if (_accessibilityManager != null)
{
_accessibilityListener = new AccessibilityListener(this);
_accessibilityManager.AddAccessibilityStateChangeListener(_accessibilityListener);
_accessibilityManager.AddTouchExplorationStateChangeListener(_accessibilityListener);
}
if (_effect.NativeAnimation && Group != null && AndroidOS.Build.VERSION.SdkInt >= AndroidOS.BuildVersionCodes.Lollipop)
{
View.Clickable = true;
View.LongClickable = true;
_viewOverlay = new FrameLayout(Group.Context)
{
LayoutParameters = new ViewGroup.LayoutParams(-1, -1),
Clickable = false,
Focusable = false,
};
View.LayoutChange += LayoutChange;
CreateRipple();
_viewOverlay.Background = _ripple;
Group.AddView(_viewOverlay);
_viewOverlay.BringToFront();
}
}
public void Announce(string text)
{
AccessibilityManager manager = Android.App.Application.Context.GetSystemService(Android.Content.Context.AccessibilityService) as AccessibilityManager;
AccessibilityEvent announcement = AccessibilityEvent.Obtain();
if (manager == null || announcement == null)
{
return;
}
if (!(manager.IsEnabled || manager.IsTouchExplorationEnabled))
{
return;
}
announcement.EventType = EventTypes.Announcement;
announcement.Text?.Add(new Java.Lang.String(text));
manager.SendAccessibilityEvent(announcement);
}
public static void AnnounceForAccessibilityCompat(Context context, String text)
{
if ((int)Build.VERSION.SdkInt >= 4)
{
AccessibilityManager accessibilityManager = null;
if (null != context)
{
accessibilityManager = (AccessibilityManager)context.GetSystemService(Context.AccessibilityService);
}
if (null == accessibilityManager || !accessibilityManager.IsEnabled)
{
return;
}
// Prior to SDK 16, announcements could only be made through FOCUSED
// events. Jelly Bean (SDK 16) added support for speaking text verbatim
// using the ANNOUNCEMENT event type.
EventTypes eventType;
if ((int)Build.VERSION.SdkInt < 16)
{
eventType = EventTypes.ViewFocused;
}
else
{
eventType = EventTypes.Announcement;
}
// Construct an accessibility event with the minimum recommended
// attributes. An event without a class name or package may be dropped.
AccessibilityEvent ev = AccessibilityEvent.Obtain(eventType);
var textProxy = new Java.Lang.String(text);
ev.Text.Add(textProxy);
ev.ClassName = _instance.GetType().ToString();
ev.PackageName = context.PackageName;
// Sends the event directly through the accessibility manager. If your
// application only targets SDK 14+, you should just call
// getParent().requestSendAccessibilityEvent(this, event);
accessibilityManager.SendAccessibilityEvent(ev);
}
}
public override void SendAccessibilityEvent(EventTypes eventType)
{
base.SendAccessibilityEvent(eventType);
AccessibilityManager manager = (AccessibilityManager)Context.GetSystemService(Context.AccessibilityService);
if (!manager.IsEnabled)
{
return;
}
switch (eventType)
{
case EventTypes.ViewAccessibilityFocused:
manager.Interrupt();
AccessibilityFocused?.Invoke(this, EventArgs.Empty);
break;
default:
break;
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
// Create your application here
SetContentView(Resource.Layout.InGame);
accessibilityManager = (AccessibilityManager)GetSystemService(AccessibilityService);
View decorView = Window.DecorView;
var uiOptions = (int)decorView.SystemUiVisibility;
var newUiOptions = uiOptions;
Window.SetFlags(WindowManagerFlags.KeepScreenOn, WindowManagerFlags.KeepScreenOn);
//newUiOptions |= (int)SystemUiFlags.Fullscreen;
newUiOptions |= (int)SystemUiFlags.HideNavigation;
newUiOptions |= (int)SystemUiFlags.Immersive;
decorView.SystemUiVisibility = (StatusBarVisibility)newUiOptions;
if (!IPAddress.TryParse(Intent.Extras.GetString("ipAddress"), out ipAddress))
{
Console.WriteLine("ERROR in IP"); //TODO Better error handling
}
if (!int.TryParse(Intent.Extras.GetString("port"), out port))
{
Console.WriteLine("ERROR in port"); //TODO Better error handling
}
vibrator = (Vibrator)GetSystemService(VibratorService);
View v = FindViewById(Resource.Id.clickerView);
v.SetOnTouchListener(this);
v.SetOnHoverListener(this);
v.ImportantForAccessibility = ImportantForAccessibility.No;
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
// Create your application here
SetContentView(Resource.Layout.AlertLayout);
accessibilityManager = (AccessibilityManager)GetSystemService(AccessibilityService);
View decorView = Window.DecorView;
var uiOptions = (int)decorView.SystemUiVisibility;
var newUiOptions = uiOptions;
Window.SetFlags(WindowManagerFlags.KeepScreenOn, WindowManagerFlags.KeepScreenOn);
//newUiOptions |= (int)SystemUiFlags.Fullscreen;
newUiOptions |= (int)SystemUiFlags.HideNavigation;
newUiOptions |= (int)SystemUiFlags.Immersive;
decorView.SystemUiVisibility = (StatusBarVisibility)newUiOptions;
if (!IPAddress.TryParse(Intent.Extras.GetString("ipAddress"), out ipAddress))
{
Console.WriteLine("ERROR in IP");
Toast.MakeText(ApplicationContext, "Not Connected. Error in IP Address", ToastLength.Long).Show();
}
if (!int.TryParse(Intent.Extras.GetString("port"), out port))
{
Toast.MakeText(ApplicationContext, "Not Connected. Error in Port", ToastLength.Long).Show();
Console.WriteLine("ERROR in port");
}
vibrator = (Vibrator)GetSystemService(VibratorService);
mainView = FindViewById <LinearLayout>(Resource.Id.clickerView);
alertText = FindViewById <TextView>(Resource.Id.alertText);
var reconnectButton = FindViewById <Button>(Resource.Id.reConnectButton);
reconnectButton.Click += ReConnect;
//Load the Prohibitive Sound Assets
try
{
AssetFileDescriptor afd = Assets.OpenFd("prohibSound.wav");
prohibMediaPlayer = new MediaPlayer();
prohibMediaPlayer.SetDataSource(afd.FileDescriptor, afd.StartOffset, afd.Length);
prohibMediaPlayer.Prepare();
}
catch (Exception e) {
Console.WriteLine("Prohibitive Alert sound file error: " + e);
};
try
{
AssetFileDescriptor afd = Assets.OpenFd("pervSound.wav");
pervMediaPlayer = new MediaPlayer();
pervMediaPlayer.SetDataSource(afd.FileDescriptor, afd.StartOffset, afd.Length);
pervMediaPlayer.Prepare();
}
catch (Exception e)
{
Console.WriteLine("Prohibitive Alert sound file error: " + e);
};
}
void IOrderedTraversalController.UpdateTraversalOrder()
{
// traversal order wasn't added until API 22
if ((int)Forms.SdkInt < 22)
{
return;
}
// since getting and updating the traversal order is expensive, let's only do it when a screen reader is active
// note that this does NOT get auto updated when you enable TalkBack, so the page will need to be reloaded to enable this path
var am = AccessibilityManager.FromContext(Context);
if (!am.IsEnabled)
{
return;
}
SortedDictionary <int, List <ITabStopElement> > tabIndexes = null;
foreach (var child in Element.LogicalChildren)
{
if (!(child is VisualElement ve))
{
continue;
}
tabIndexes = ve.GetSortedTabIndexesOnParentPage(out _);
break;
}
if (tabIndexes == null)
{
return;
}
AView prevControl = null;
foreach (var idx in tabIndexes?.Keys)
{
var tabGroup = tabIndexes[idx];
foreach (var child in tabGroup)
{
if (child is Layout ||
!(
child is VisualElement ve && ve.IsTabStop &&
AutomationProperties.GetIsInAccessibleTree(ve) != false && // accessible == true
ve.GetRenderer()?.View is ITabStop tabStop)
)
{
continue;
}
var thisControl = tabStop.TabStop;
if (thisControl == null)
{
continue;
}
// this element should be the first thing focused after the root
if (prevControl == null)
{
thisControl.AccessibilityTraversalAfter = NoId;
}
else
{
if (thisControl != prevControl)
{
thisControl.AccessibilityTraversalAfter = prevControl.Id;
}
}
prevControl = thisControl;
}
}
}
private static bool IsServiceEnabled()
{
AccessibilityManager manager = (AccessibilityManager)Application.Context.GetSystemService(AccessibilityService);
return(manager.GetEnabledAccessibilityServiceList(FeedbackFlags.AllMask).Any(x => x.ResolveInfo.ServiceInfo.PackageName == Application.Context.ApplicationInfo.PackageName));
}
