Success Criterion 2.5.4 - Level A

Motion Actuation

Ensure an alternative is provided for motion-triggered actions and make it possible to disable them. Users with limited hand function might not be able to shake their device. On the other hand, users with spasms might accidentally trigger actions.

Impact

• For users with (temporarily) limited hand function, shaking is often not possible. Make sure that these functions can also be activated in another way.

• Movement in a wheelchair or spasms can unintentionally activate functions. Make sure that these functions can be turned off.

Check

“Is an alternative option available for motion-triggered functions?“

This can be tested without assistive technologies.

Solution

Add alternatives for motion activated actions

Android

Motion input - Android

On Android, the SensorManager can be used in combination with SensorEventListener to detect movement.

An event through sensors should not be the only way to trigger actions. Make sure to provide a second way, such as a button, to trigger the same action.

Kotlin

class SensorActivity : AppCompatActivity(), SensorEventListener {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_NORMAL)
    }

    override fun onSensorChanged(event: SensorEvent?) {
        // Add alternative
    }
}

Contribute

Jetpack Compose

Motion input - Jetpack Compose

In Jetpack Compose, the SensorManager can be used in combination with SensorEventListener to detect movement.

An event through sensors should not be the only way to trigger actions. Make sure to provide a second way, such as a button, to trigger the same action.

Kotlin

val context = LocalContext.current
var sensorValue by remember { mutableStateOf("") }

DisposableEffect(Unit) {
    val sensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
    val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    val sensorListener = object : SensorEventListener {
        override fun onSensorChanged(event: SensorEvent?) {
            // Add alternative
        }

        override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {
            // Handle accuracy changes if necessary
        }
    }
    sensorManager.registerListener(sensorListener, sensor, SensorManager.SENSOR_DELAY_NORMAL)

    // Unregister the listener when the composable is disposed
    onDispose {
        sensorManager.unregisterListener(sensorListener)
    }
}

Contribute

iOS

Motion input - iOS

On iOS, it is common to use the motionEnded method to detect motion.

A motion event should not be the only way to trigger actions. Make sure to provide a second way, such as a button, to trigger the same action.

Swift

import UIKit

class MotionController: UIViewController {

    override var canBecomeFirstResponder: Bool{
        return true
    }

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        becomeFirstResponder()
    }

    override func motionEnded(_ motion: UIEvent.EventSubtype, with event: UIEvent?) {
        // Provide alternative
    }
}

Contribute

SwiftUI

Motion input - SwiftUI

In SwiftUI, there is no built-in method to detect when a user shakes their device. However, you can create this functionality yourself by overriding the motionEnded method in UIWindow and setting up a custom notification.

A motion event should not be the only way to trigger actions. Make sure to provide a second way, such as a button, to trigger the same action.

Swift

import SwiftUI
import Combine

// A view that includes a button and responds to shake gestures.
struct MotionResponsiveView: View {
    var body: some View {
        Button("Trigger Alternative Action") {
            // Action triggered by the button.
            // Replace with desired functionality.
        }
        .onReceive(
            NotificationCenter.default.publisher(
                for: UIDevice.deviceDidShakeNotification
            )
        ) { _ in
            // This action is performed when a shake gesture is detected.
        }
    }
}

// Extend UIDevice to define a custom notification for shake gestures.
extension UIDevice {
    static let deviceDidShakeNotification = Notification.Name(
        rawValue: "deviceDidShakeNotification"
    )
}

// Extend UIWindow to intercept shake gesture events and post a custom notification.
extension UIWindow {
    open override func motionEnded(
        _ motion: UIEvent.EventSubtype,
        with event: UIEvent?
    ) {
        super.motionEnded(motion, with: event)
        
        if motion == .motionShake {
            // Post a notification when a shake gesture is detected.
            NotificationCenter.default.post(
                name: UIDevice.deviceDidShakeNotification,
                object: nil
            )
        }
    }
}

Contribute

Flutter

Motion input - Flutter

With Flutter, packages like sensors_plus can be used to detect movement.

An event through sensors should not be the only way to trigger actions. Make sure to provide a second way, such as a button, to trigger the same action.

Dart

import 'package:sensors_plus/sensors_plus.dart';

accelerometerEvents.listen((AccelerometerEvent event) {
  // Provide alternative
});

Contribute

React Native

Motion input - React Native

In React Native, packages like expo-sensors can be used to detect motion.

An event through sensors should not be the only way to trigger actions. Make sure to provide a second way, such as a button, to trigger the same action.

JSX

import { Accelerometer } from 'expo-sensors';

export default function App() {
  const _subscribe = () => {
    setSubscription(
      Accelerometer.addListener(accelerometerData => {
        // Provide alternative
      })
    );
  };
}

Contribute

.NET MAUI

Motion input - .NET MAUI

In MAUI, to listen to motion events, you can use the Accelerometer API. Make sure to follow the setup instructions for each platform to ensure it works correctly.

C#

public void UpdateAccelerometer()
{
    if (Accelerometer.Default.IsSupported)
    {
        if (Accelerometer.Default.IsMonitoring)
        {
            // Turn off
            Accelerometer.Default.Stop();
            Accelerometer.Default.ReadingChanged -= Accelerometer_ReadingChanged;
        }
        else
        {
            // Turn on
            Accelerometer.Default.ReadingChanged += Accelerometer_ReadingChanged;
            Accelerometer.Default.Start(SensorSpeed.UI);
        }
    }
}

private void Accelerometer_ReadingChanged(object? sender, AccelerometerChangedEventArgs e)
{
    //Apply any logic
}

Contribute

Xamarin

Motion input - Xamarin

In Xamarin, the Accelerometer class can be used to listen to changes in acceleration of the device in three-dimensional space.

An event through acceleration should not be the only way to trigger actions. Make sure to provide a second way, such as a button, to trigger the same action.

C#

Accelerometer.ReadingChanged += Accelerometer_ReadingChanged;

void Accelerometer_ReadingChanged(object sender, AccelerometerChangedEventArgs e)
{
    // Provide alternative
}

Contribute

Resources

• WCAG 2.2 - Success Criterion 2.5.4 - Motion Actuation