The devices seem to connect to an Android phone as a Bluetooth keyboard and I suspect the key presses emulate the “cursor up” and “cursor down” keys you’d find on a full-sized keyboard.
While playing an episode with AntennaPod, the app seems to respond to the keypresses, but in non-useful ways. One key causes the playback screen to shrink down to banner size. The other key causes the playback to skip forward about 7 minutes.
Suggested solution:
Capture these keypresses and use them to skip forward and skip backward (emulating the FF and RW buttons on the GUI).
I believe you’re observing that the TikTok developers used non-standard keypress codes. Though it may be possible to add that non-standard functionality to AntennaPod, wouldn’t it make more sense for the TikTok team to add the standard functionality?
Can you maybe try it on a different phone? Also, do you have other devices that can control forward/backward skipping like some headsets have and does this work fine on your device?
Yes, other Bluetooth devices and other Android phones work as expected with AntennaPod. For example, the Forward and Backward buttons on my Bluetooth headset do cause AntennaPod to skip forward and back, just like the buttons on the GUI.
I don’t think there is a compatibility issue, or a “non-standard keypress” issue. It’s simply a matter of mapping the devices keypresses to the desired action.
TikTok, Facebook Reels, and YouTube Shorts, all use the “swipe up” and “swipe down” motions to flip to the next video. The “TikTok rings” emulate the screen swipes. In fact, they will cause ebook apps like the Kindle app to flip the page because those apps also use “swipe up” to mean “next page”.
It’s probably sending some sort of “page down” key code.
I wrote some test programs to reverse engineer the “TP-1” TikTok ring. It’s trickier than you might think. These devices don’t send standard keypress events. Instead, each button press sends a series of stylus swipe events!
The Challenge:
The TikTok ring acts like a Bluetooth stylus. Each “button” press (up or down) translates to a series of stylus touch events mimicking a stylus swipe. Standard key event handling won’t work. We need a way to recognize and interpret these swipes.
The Solution:
The key is to monitor the stylus’s position during the “swipe” action. Here’s the algorithm:
Initial Position: When the “swipe” begins (MotionEvent.ACTION_DOWN), record the sum of the stylus’s x and y coordinates. This represents the starting point.
Ignore Intermediate Events: Ignore all subsequent stylus movement events between the ACTION_DOWN and ACTION_UP events. These are just the points of the swipe.
Final Position: When the “swipe” ends (MotionEvent.ACTION_UP), record the sum of the stylus’s x and y coordinates again. This is the ending point.
Direction: Compare the initial and final position sums:
If the final sum is less than the initial sum, the “swipe” was up.
If the final sum is greater than the initial sum, the “swipe” was down.
Why this works:
This method is robust across both portrait and landscape orientations. By using the sum of x and y, we ensure that at least one coordinate will change significantly during the swipe, while the other remains relatively constant. This allows us to reliably determine the swipe direction regardless of screen orientation.
Code Example (Kotlin):
/*
TikTok Ring Bluetooth device name: TP-1
InputDevice 20482
The device type is "stylus"
Use the ToolType to determine which event is from a stylus.
Use the ActionMasked to determine if this is a "stylus down touch" event.
*/
package com.williamfrantz.ringdecoder
import android.util.Log
import android.view.MotionEvent
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
var initialPositionSum = 0f
override fun dispatchTouchEvent(event: MotionEvent): Boolean {
if (isStylusEvent(event)) return handleStylusTouch(event)
return super.dispatchTouchEvent(event)
}
private fun isStylusEvent(event: MotionEvent) =
event.pointerCount > 0 && MotionEvent.TOOL_TYPE_STYLUS == event.getToolType(0)
private fun handleStylusTouch(event: MotionEvent): Boolean {
when (event.actionMasked) {
MotionEvent.ACTION_DOWN -> initialPositionSum = event.x + event.y
MotionEvent.ACTION_UP -> handleStylusSwipe(event.x + event.y < initialPositionSum)
// Ignore all other stylus events
}
return true
}
private fun handleStylusSwipe(isUp: Boolean) {
when (isUp) {
true -> Log.d("keyking", "NEXT") // Swipe Up
false -> Log.d("keyking", "PREVIOUS") // Swipe Down
}
}
}
Key Code Points:
isStylusEvent(): Checks if the event is from a stylus.
handleStylusTouch(): Manages the ACTION_DOWN and ACTION_UP events, calculating the swipe direction.
handleStylusSwipe(): Interprets the swipe direction (up/down) and performs the desired action (e.g., “NEXT,” “PREVIOUS”).
Integration:
This code provides a solid foundation for integrating TikTok ring control. Simply adapt the handleStylusSwipe() function to trigger the appropriate actions within your application.
Finger swipes will be unaffected. They will still be detected and processed as usual by Android. However, if you swipe with a stylus (or one of these TikTok rings), this program will capture those events.
This means that it only works when the screen is on. Also, scrolling the screen is a normal interaction in AntennaPod, we can’t just remap that to something else. I’m not convinced that we can add support for these rings then.
After some more testing, it seems like the display has to be on and the app has to have focus in order to detect the MotionEvents. That would severely limit the usefulness of this feature. I’ll keep working on it and see if those limitations can be overcome.
This is one of the best-documented requests I’ve seen here. I never would have guessed that they’d be using stylus swipe events rather than keypress events.