This commit is contained in:
James Babcock committed 2026-10-24 23:57:02 -07:00
commit ae48313b81
48 files changed
+1946 -213

No files matched your search

+21 -19
View File
@@ -46,6 +46,17 @@ def faceclawNdkHostTag = {
return "linux-x86_64"
}
// Host tools carry .exe on Windows. Call the binaries themselves: the NDK's
// target-prefixed clang wrappers are bash scripts (or .cmd files) that only add
// --target.
def faceclawHostExecutable = { File dir, String name ->
return file("$dir/$name${Os.isFamily(Os.FAMILY_WINDOWS) ? ".exe" : ""}")
}
def faceclawNdkTool = { File ndkRoot, String name ->
return faceclawHostExecutable(file("$ndkRoot/toolchains/llvm/prebuilt/${faceclawNdkHostTag()}/bin"), name)
}
def faceclawFindNdkRoot = {
def explicitNdk = System.getenv("ANDROID_NDK_HOME")
if (explicitNdk != null && file(explicitNdk).exists()) {
@@ -111,12 +122,7 @@ tasks.register("prepareFaceclawNativeLibs") {
if (ndkRoot == null || !ndkRoot.exists()) {
throw new GradleException("Android NDK is required to build libfaceclaw_lc3.so")
}
// The NDK ships the clang driver twice: extensionless (a Unix shell script)
// and as .cmd (the CreateProcess-launchable one Windows needs).
def clangBin = "$ndkRoot/toolchains/llvm/prebuilt/${faceclawNdkHostTag()}/bin/aarch64-linux-android24-clang"
def clang = Os.isFamily(Os.FAMILY_WINDOWS)
? file("${clangBin}.cmd")
: file(clangBin)
def clang = faceclawNdkTool(ndkRoot, "clang")
if (!clang.exists()) {
throw new GradleException("Could not find Android clang at $clang")
}
@@ -130,6 +136,7 @@ tasks.register("prepareFaceclawNativeLibs") {
exec {
commandLine([
clang.absolutePath,
"--target=aarch64-linux-android24",
"-shared",
"-fPIC",
"-O3",
@@ -197,8 +204,8 @@ tasks.register("prepareFaceclawLlama") {
if (cmakeDir == null) {
throw new GradleException("Android SDK cmake package is required to build libfaceclaw_llama.so")
}
def cmake = file("$cmakeDir/bin/cmake")
def ninja = file("$cmakeDir/bin/ninja")
def cmake = faceclawHostExecutable(file("$cmakeDir/bin"), "cmake")
def ninja = faceclawHostExecutable(file("$cmakeDir/bin"), "ninja")
def march = "-march=armv8.2-a+dotprod+fp16"
// Configure once; afterwards the ninja no-op build keeps this cheap while
@@ -232,18 +239,13 @@ tasks.register("prepareFaceclawLlama") {
}
// The static-linked lib carries llama.cpp's full debug info (~50MB);
// strip it so the APK only pays for the code (~8MB).
def ndkRootForStrip = faceclawFindNdkRoot()
if (ndkRootForStrip != null) {
// Windows wants llvm-strip.exe; the extensionless file is a Unix script.
def llvmStripBin = "$ndkRootForStrip/toolchains/llvm/prebuilt/${faceclawNdkHostTag()}/bin/llvm-strip"
def llvmStrip = Os.isFamily(Os.FAMILY_WINDOWS) && file("${llvmStripBin}.exe").exists()
? file("${llvmStripBin}.exe")
: file(llvmStripBin)
if (llvmStrip.exists()) {
exec {
commandLine([llvmStrip.absolutePath, "--strip-unneeded", llamaSo.absolutePath])
}
def llvmStrip = faceclawNdkTool(ndkRoot, "llvm-strip")
if (llvmStrip.exists()) {
exec {
commandLine([llvmStrip.absolutePath, "--strip-unneeded", llamaSo.absolutePath])
}
} else {
logger.warn("Could not find llvm-strip at $llvmStrip; packaging an unstripped libfaceclaw_llama.so (~50MB)")
}
}
}
@@ -9,6 +9,7 @@ import android.graphics.Color
import android.graphics.drawable.BitmapDrawable
import android.graphics.drawable.Drawable
import android.graphics.drawable.Icon
import android.os.Build
import android.os.Bundle
import android.os.Handler
import android.os.Looper
@@ -182,6 +183,33 @@ class FaceclawMediaNotificationListenerService : NotificationListenerService() {
return out.toByteArray()
}
/**
* The picture attached to one active notification (BigPictureStyle: a
* photo, a screenshot, Dexcom's glucose graph), scaled to fit
* maxWidth x maxHeight as a gray packet with the tone handling (and
* light-background inversion) of ImageFileLoader.bitmapToGrayPacket;
* empty when the notification or its picture is unavailable.
*/
@JvmStatic
fun getNotificationPictureGray(
key: String?, maxWidth: Int, maxHeight: Int, gamma: Float, dither: Boolean, invertLightBackground: Boolean,
): ByteArray {
val service = activeService
if (service == null || maxWidth <= 0 || maxHeight <= 0) {
return ByteArray(0)
}
val statusBarNotification = findActiveNotificationByKey(service, key)
if (statusBarNotification == null || statusBarNotification.notification == null) {
return ByteArray(0)
}
val picture = loadNotificationPicture(service, statusBarNotification.notification)
if (picture == null) {
return ByteArray(0)
}
return ImageFileLoader.bitmapToGrayPacket(
halveToward(picture, maxWidth, maxHeight), maxWidth, maxHeight, gamma, dither, invertLightBackground)
}
@JvmStatic
fun getActiveNotificationsJson(maxNotifications: Int): String {
val service = activeService
@@ -541,6 +569,79 @@ class FaceclawMediaNotificationListenerService : NotificationListenerService() {
return (flags and android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) != 0
}
/** Whether a notification carries a picture for loadNotificationPicture, without loading it. */
@Suppress("DEPRECATION")
private fun hasNotificationPicture(extras: Bundle): Boolean {
return extras.get(Notification.EXTRA_PICTURE) != null
|| (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && extras.get(Notification.EXTRA_PICTURE_ICON) != null)
}
/**
* A notification's attached picture: BigPictureStyle's bitmap
* (EXTRA_PICTURE) or, from Android 12, its Icon (EXTRA_PICTURE_ICON).
* Newer releases swap large pictures for a content URI to a bitmap
* the system has offloaded (Dexcom's graph arrives that way); the
* offload provider lets enabled notification listeners open those.
*/
@Suppress("DEPRECATION")
private fun loadNotificationPicture(service: FaceclawMediaNotificationListenerService, notification: Notification): Bitmap? {
val extras: Bundle = notification.extras ?: return null
try {
val picture: Bitmap? = extras.getParcelable(Notification.EXTRA_PICTURE)
if (picture != null) {
return softwareBitmap(picture)
}
} catch (t: Throwable) {
Log.w(TAG, "failed to read notification picture", t)
}
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
return null
}
try {
val icon: Icon? = extras.getParcelable(Notification.EXTRA_PICTURE_ICON)
val drawable: Drawable? = icon?.loadDrawable(service)
if (drawable is BitmapDrawable && drawable.bitmap != null) {
return softwareBitmap(drawable.bitmap)
}
if (drawable != null && drawable.intrinsicWidth > 0 && drawable.intrinsicHeight > 0) {
val bitmap = Bitmap.createBitmap(drawable.intrinsicWidth, drawable.intrinsicHeight, Bitmap.Config.ARGB_8888)
drawable.setBounds(0, 0, bitmap.width, bitmap.height)
drawable.draw(Canvas(bitmap))
return bitmap
}
} catch (t: Throwable) {
Log.w(TAG, "failed to load notification picture icon", t)
}
return null
}
/** Hardware bitmaps can't be read back pixel by pixel or drawn on a software canvas; copy those. */
private fun softwareBitmap(bitmap: Bitmap): Bitmap {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && bitmap.config == Bitmap.Config.HARDWARE) {
return bitmap.copy(Bitmap.Config.ARGB_8888, false)
}
return bitmap
}
/**
* Halve a picture while it is still at least twice the size it will
* be shown at, leaving the last (under 2x) step of fitting it into
* maxWidth x maxHeight to bitmapToGrayPacket. As with icons
* (renderIconScaled), one filtered pass from a much larger source
* samples too sparsely: a graph's thin lines break up into dots.
*/
private fun halveToward(source: Bitmap, maxWidth: Int, maxHeight: Int): Bitmap {
var bitmap = source
while ((bitmap.width >= maxWidth * 2 || bitmap.height >= maxHeight * 2) && bitmap.width >= 2 && bitmap.height >= 2) {
val halved = Bitmap.createScaledBitmap(bitmap, bitmap.width / 2, bitmap.height / 2, true)
if (bitmap !== source) {
bitmap.recycle()
}
bitmap = halved
}
return bitmap
}
/**
* Debug aid for garbled-icon reports: saves each rendered icon to
* <externalFilesDir>/debug-icons/ (adb-pullable) so extraction problems can
@@ -630,8 +731,10 @@ class FaceclawMediaNotificationListenerService : NotificationListenerService() {
}
}
out.put("lines", lines)
out.put("hasPicture", hasNotificationPicture(extras))
} else {
out.put("lines", JSONArray())
out.put("hasPicture", false)
}
val actionsJson = JSONArray()
@@ -132,10 +132,15 @@ class ImageFileLoader private constructor() {
* round on its own, which turns smooth gradients into visible bands.
* Dithered output is already quantized: every byte is a level times 16,
* which BmpUtil re-quantizes back to exactly that level.
*
* invertLightBackground shows a picture drawn on a light background
* (a chart, a screenshot) as its negative; see GrayPacket.fromArgb.
*/
@JvmStatic
@JvmOverloads
fun bitmapToGrayPacket(
source: Bitmap?, maxWidth: Int, maxHeight: Int, gamma: Float, dither: Boolean): ByteArray {
source: Bitmap?, maxWidth: Int, maxHeight: Int, gamma: Float, dither: Boolean,
invertLightBackground: Boolean = false): ByteArray {
if (source == null || source.width <= 0 || source.height <= 0
|| maxWidth <= 0 || maxHeight <= 0) {
return ByteArray(0)
@@ -152,7 +157,7 @@ class ImageFileLoader private constructor() {
}
val pixels = IntArray(width * height)
scaled.getPixels(pixels, 0, width, 0, 0, width, height)
return GrayPacket.fromArgb(pixels, width, height, gamma, dither)
return GrayPacket.fromArgb(pixels, width, height, gamma, dither, invertLightBackground)
} catch (e: Exception) {
Log.w(TAG, "bitmap conversion failed", e)
return ByteArray(0)