I create applications, that are divorced from any native framework. All rendering happens in OpenGL, with a context provided by GLFW, all in C, with no framework to rely on supplying compatibility. As such, standard screen readers like NVDA have no chance of picking up information ( excluding OCR ) and my applications are an accessibility black hole.
How can I provide an interface for screen readers to cling unto? I presume this is a per OS thing... How would that be possible on Windows, Linux, BSD or even android? In the *NIX world, I presume this would be Desktop environment dependent...
I'm finding a lot of information on this, with a framework as a starting point, but have a hard time finding resources on how to do it from scratch.
I'm fully aware this is far beyond the capability of a sole developer and know, that writing programs by ignoring native interfaces is a common accessibility hole, which you are advised to avoid.
However, I have a tough time finding resources and jump-in points to explore this topic. Can someone point me in the right direction?
TL;DR: How to provide screen-reader compatibility from scratch. Not in detail - but conceptually.
As you have already well identified, your app is an accessibility blackhole because you are using a rendering engine.
It's basicly the same for OpenGL, SDL, or <canvas> on the web, or any library rendering something without specific accessibility support.
WE can talk about several possibilities:
Become an accessibility server. Under windows, it means doing the necessary so that your app provide accessible components on demand from UIA / IAccessible2 interface.
Use a well known GUI toolkits having accessibility support and their provieded accessibility API to make your app.
Directly talk to screen readers via their respective API in order to make them say something and/or show something on a connected braille display.
Do specific screen reader scripting
However, it doesnt stops there. Supporting screen readers isn't sufficient to make your app really accessible. You must also think about many other things.
1. Accessibility server, UIA, IAccessible2
This option is of course the best, because users of assistive technologies in general (not only screen readers) will feel right at home with a perfectly accessible app if you do your job correctly.
However, it's also by far the hardest since you have to reinvent everything. You must decompose your interface into components, tell which category of component each of them are (more commonly called roles), make callback to fetch values and descriptions, etc.
IF you are making web development, compare that with if you had to use ARIA everywhere because there's no defaults, no titles, no paragraphs, no input fields, no buttons, etc.
That's an huge job ! But if you do it really well, your app will be well accessible.
You may get code and ideas on how to do it by looking at open source GUI toolkits or browsers which all do it.
Of course, the API to use are different for each OS. UIA and IAccessible2 are for windows, but MacOS and several linux desktops also have OS-specific accessibility API that are based on the same root principles.
Note about terminology: the accessibility server or provider is your app or the GUI toolkit you are using, while the accessibility client or consumer is the scren reader (or others assistive tools).
2. Use a GUI toolkit with good accessibility support
By chance, you aren't obliged to reinvent the wheel, of course !
Many people did the job of point 1 above and it resulted in libraries commonly called GUI toolkits.
Some of them are known to generally produce well accessible apps, while others are known to produce totally inaccessible apps.
QT, WXWidgets and Java SWT are three of them with quite good accessibility support.
So you can quite a lot simplify the job by simply using one of them and their associated accessibility API. You will be saved from talking more or less directly to the OS with UIA/IAccessible2 and similar API on other platforms.
Be careful though, it isn't as easy as it seems: all components provided by GUI toolkits aren't necessarily all accessible under all platforms.
Some components may be accessible out of the box, some other need configuration and/or a few specific code on your side, and some are unaccessible no matter what.
Some are accessible under windows but not under MacOS or vice-versa.
For example, GTK is the first choice for linux under GNOME for making accessible apps, but GTK under windows give quite poor results. Another example: wxWidgets's DataView control is known to be good under MacOS, but it is emulated under windows and therefore much less accessible.
In case of doubt, the best is to test yourself under all combinations of OS and screen readers you intent to support.
Sadly, for a game, using a GUI toolkit is perhaps not a viable option, even if there exist OpenGL components capable of displaying a 3D scene.
Here come the third possibility.
3. Talk directly to screen readers
Several screen readers provide an API to make them speak, adjust some settings and/or show something on braille display. If you can't, or don't want to use a GUI toolkit, this might be a solution.
Jaws come with an API called FSAPI, NVDA with NVDA controller client. Apple also alow to control several aspects of VoiceOver programatically.
There are still several disadvantages, though:
You are specificly targetting some screen readers. People using another one, or another assistive tool than a screen reader (a screen magnifier for example), are all out of luc. Or you may multiply support for a big forest of different API for different products on different platforms.
All of these screen reader specific API support different things that may not be supported by others. There is no standards at all here.
Thinking about WCAG and how it would be transposed to desktop apps, in fact you are bypassing most best practices, which all recommand first above anything else to use well known standard component, and only customize when really necessary.
So this third possibility should ideally be used if, and only if, using a good GUI toolkit isn't possible, or if the accessibility of the used GUI toolkit isn't sufficient.
I'm the autohr of UniversalSpeech, a small library trying to unify direct talking with several screen readers.
You may have a look at it if you are interested.
4. Screen reader scripting
If your app isn't accessible alone, you may distribute screen reader specific scripts to users.
These scripts can be instructed to fetch information to give to the user, add additional keyboard shortcuts and several other things.
Jaws has its own scripting language, while NVDA scripts are developed with Python. AS far as I know, there's also scripting capabilities with VoiceOver under MacOS.
I gave you this fourth point for your information, but since you are starting from a completely inaccessible app, I wouldn't advise you to go that way.
In order for scripts to be able to do useful things, you must have a working accessible base. A script can help fixing small accessibility issues, but it's nearly impossible to turn a completly inaccessible app into an accessible one just with a script.
Additionally, you must distribute these scripts separately from your app, and users have to install them. It may be a difficulty for some people, depending on your target audience.
Beyond screen reader support
Screen reader support isn't everything.
This is beyond your question, so I won't enter into details, but you shouldn't forget about the following points if you really want to make an accessible app which isn't only accessible but also comfortable to use for a screen reader user.
This isn't at all an exhaustive list of additional things to watch out.
Keyboard navigation: most blind and many visually impaired aren't comfortable with the mouse and/or a touch screen. You must provide a full and consist way of using your app only with a keyboard, or, on mobile, only by standard touch gestures supported by the screen reader. Navigation should be as simple as possible, and should as much as you can conform to user preferences and general OS conventions (i.e. functions of tab, space, enter, etc.). This in turn implies to have a good structure of components.
Gamepad, motion sensors and other inputs: unless it's absolutely mandatory because it's your core concept, don't force the use of them and always allow a keyboard fallback
Visual appearance: as much as you can, you should use the settings/preferences defined at OS level for disposition, colors, contrasts, fonts, text size, dark mode, high contrast mode, etc. rather than using your own
Audio: don't output anything if the user can't reasonably expect any, make sure the volume can be changed at any time very easily, and if possible if it isn't against your core concept, always allow it to be paused, resumed, stopped and muted. Same reflection can apply to other outputs like vibration which you should always be able to disable.
Is there are a way (a library) with which a web page can detect a screen reader being used on it? This can be just for a reporting/analytics purpose.
PS: A Drupal 8 website.
No. It is not possible. Screen readers operate as an application on the computer - this would be similar to trying to find out if someone viewing your website also had their calculator open - it is a privacy restriction. Also many of these users may be using Voiceover or Talkback on their mobile devices and there is no way to detect that either.
Your website should instead strive to follow web standards and work equally for all users.
I'm also curious as to what your specific goal is in detecting this, as screen readers are only one part of the accessibility tools that many people use - and focusing on just the screen reader user will not make your site accessible.
No. You can't. Definitely not.
One thing you can do is detecting if a user uses his mouse. This does not mean that he uses a screenreader or that he doesn't but is quite an indicator (but this should be categorized as "keyboard only users" not "screenreader users"). And that's, in my opinion, a question more interesting than knowing if a user uses a screenreader.
There are a lot of discussions about the wrongdoing of detecting screenreaders :
On Screen Reader Detection
Detecting screen readers in analytics, pros and cons
I've been playing around a little with both VoiceOver and the Text to speech functionality on my mac. I've noticed a few differences in the way numbers and punctuation is pronounced. For example the sentence "the year was 1978", is read out perfectly when I highlight it and use text to speech. With Voiceover however, it reads "the year was one nine seven eight".
How can I tell screen readers that I want something pronounced in a certain way? Is there ARIA attributes I can add for this kind of behaviour?
It is not just dates and years but prices and punctuation as well (and probably a lot of other things!).
I don't think you can control speech output with the APIs currently available.
I assume that you are talking about HTML page as you referenced ARIA attributes. WAI ARIA does not have attributes to control the screen reading. I believe W3C is coming up with Text-to-Speech synthesizing markup language (SSML) to provide better control over speech output.
If your issue is related to native Mac OS application screens, you can check out Apple's Speech Synthesis APIs.
The Apple VoiceOver as well as Microsoft Windows Narrator are very basic screen readers with little or no intelligence built in. Apple's text-to-speech is little advanced but it still lags behind commercial screen readers like JAWS. But good thing is that users with impaired vision typically have good screen readers which can read your content appropriately.
Common speech synthesizers allow their clients to configure whether numbers will be read as words or spelled-out (both on a global default and per-specific-case setting). E.g. Apple's speech synthesis API propagates this possibility using the NSSpeechNumberModeProperty property. VoiceOver users can then set only global (or at best per-app) default in VoiceOver Utility > Verbosity > Text > "Read numbers as:".
Now if you want to influence how screen readers should pronounce numbers in web content, there is a CSS Speech Module. It defines the speak-as property, which can have a value of normal or digits.
However whether such CSS value will be respected by a combination of particular version of particular screen reader and particular version on a particular browser running of particular version of particular OS is a thing you have to try yourself. The accessibility APIs on OS X currently have no way to specify pronunciation of digits in the returned strings, so if it worked for WebKit, it would have to be using some private extension to those public accessibility APIs. I just tried on OS X 10.9.3 and this does not work.
If I had to guess, you would be lucky to find a combination of screen reader / browser / OS where this would be implemented as of now. But this is just speculation.
I'm trying to make a version of my website optimize to Blackberry devices, however I lack of information regarding this devices and google seems not to be helping.
Have anyone create website optimize for blackberry before? or know any kind of post or information that could help?
I don't know if media queries could help since those devices seems to open screen standard resolutions.
From Optimizing A Web Site For BlackBerry Devices:
If you thought targeting Web sites to
work with several different browsers
was difficult enough, try throwing
BlackBerry support in the mix.
Designing a Web site to work with
BlackBerry handheld devices can be
frustrating because the BlackBerry Web
browser has fewer capabilities than a
standard Web browser. This lack of
features greatly affects design
strategy because slower download
speeds and limited screen size must
now be factored in.
The first thing you should do when
optimizing a site to support
BlackBerry devices is download and
install the official BlackBerry
Device Simulator and BlackBerry
Email and MDS Services Simulator
Package. The device simulator and
simulator package emulate the
functionality of actual BlackBerry
products and allow you to access and
test a Web site in a virtual
environment.
When you first open a site in
emulation, you'll probably notice the
BlackBerry's CSS support is limited
and your site may not look so great.
Since most front-end developers are
trained to be reactive, your initial
solution maybe to attach another
stylesheet, target the handheld medium
and adjust the classes and ids in that
stylesheet accordingly. Unfortunately,
the BlackBerry disregards both screen
and handheld media style declarations.
In fact, many of the useful style
declarations that could create a
loophole for the lack of media
support—including display:none and
visiblility:hidden—won't work on a
BlackBerry. For a complete list of
supported CSS declarations, refer to
the BlackBerry Content Developer
Guide.
So what's the solution? The real trick
to optimizing a Web site for
BlackBerry devices (without any hacks
or work-arounds) is using well-formed
XHTML in conjunction with CSS and
omitting unnecessary layout elements
using the screen medium. This focus on
semantically correct XHTML to drive
your layout may not look pretty on the
BlackBerry, but it's advantageous for
several reasons. For starters, since
you're dealing with a limited amount
of screen space and relying on what
equates to dial-up connection speeds
you want to keep the majority of your
display content for the BlackBerry as
text-based. Secondly, the well-formed
code will result in better overall
search engine optimization because
you're using code standards that are
friendlier to the search engine
indexing process. Finally, the focus
on semantics will make the site
scalable and rid you of any worries
associated with the consequences of
adding text, modifying links or
changing the appearance of an element
in your stylesheet.
With full-featured browsers integrated
into the latest generation of
handhelds (Safari on the iPhone, IE in
Windows Mobile devices) aesthetics
support on mobile devices is vastly
improving. Either way, good coding
standards promote graceful degradation
and a provide a certain level of
future proofing that ensures users can
view a Web site no matter how outdated
or cutting-edge their device is.
My website is designed to meet the accessibility guidelines.
I'm HOPING that this means screen readers should work well with them... But I have two questions:
Is this a fair assumption to make?
Are there any free/cheap screen
readers clients I can use to test or
online emulators?
Just because something meets the guideline doesn't mean it's guaranteed to be accessible, all screen readers have there different quirks. I'm a totally blind individual so comments on screen readers are below.
Note this is a rather long post so I’ve summarized it at the top. In summary if you want to make sure your site is mostly accessible use NVDA, if you want to make sure that blind individuals working in the government will be able to use your site use Jaws to test, if you want to be extra safe use Window-Eyes and Orca to test as well.
NVDA is an open source screen reader that is rather new. It isn't quite as good as some of the commercial screen readers out there but it gets the job done. I'd say if a site works with NVDA it's likely to work with most other screen readers. One issue with NVDA is the fact that its accessibility is only really good in Firefox so you'll have to use that to test.
Jaws is the most widely used screen reader out there. You can download a demo of it that will run for 40 minutes at a time then require you to reboot if you want to run it again. If you’re trying to insure 508 compliance this is probably the way to go since Jaws is the screen reader used by the US government.
Window-Eyes is the second most used screen reader. I don’t have any experience with it but I’ve been told it’s quite good as far as internet accessibility goes. Orca is a screen reader built into gnome that works with Firefox and Linux. It’s built into Ubuntu. I tried it about a year and a half ago and it was absolutely horrible but I’ve been told it’s gotten better.
NVDA is a free option:
NonVisual Desktop Access (NVDA) is a free and open source screen reader for the Microsoft Windows operating system. Providing feedback via synthetic speech and Braille, it enables blind or vision impaired people to access computers running Windows for no more cost than a sighted person. Major features include support for over 20 languages and the ability to run entirely from a USB drive with no installation.
Is this a fair assumption to make?
No, even if you think you know the ins and outs of accessibility well, only testing can really tell you this.
Are there any free/cheap screen
readers clients I can use to test or
online emulators?
The already mentioned NVDA looks like a viable option, or you can download a trial of JAWS which I believe is the most widely used screen reader on Windows. If you're really serious about accessibility and you have a requirement for ongoing testing, you might want to think about just buying a copy.
On a final note, it sounds like you already know this but no amount of automated accessibility testing can really tell you if your site is accessible, only real-world testing can do that! Which is what you're doing, so well done.