@elizaos/app-core 2.0.0-beta.3 → 2.0.11-beta.5

package/platforms/android/app/src/main/java/ai/elizaos/app/MainActivity.java

@@ -5,19 +5,28 @@ import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.Bundle;
 import android.util.Log;
+import android.view.WindowManager;
 import android.webkit.WebSettings;
 import android.webkit.WebView;
 
 import androidx.core.content.ContextCompat;
+import androidx.core.splashscreen.SplashScreen;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
 
 import com.getcapacitor.BridgeActivity;
 
+import ai.elizaos.app.BuildConfig;
+
 import java.lang.reflect.Method;
 
 public class MainActivity extends BridgeActivity {
 
     private static final String TAG = "ElizaMainActivity";
-    private static final int REQUEST_NOTIFICATION_PERMISSION = 1001;
+
+    private static final int REQUEST_CODE_POST_NOTIFICATIONS = 1001;
 
     /**
      * One UA marker entry. The MainActivity reads `systemProp` via
@@ -52,11 +61,18 @@ public class MainActivity extends BridgeActivity {
      */
     private static final UserAgentMarker[] BRAND_USER_AGENT_MARKERS = new UserAgentMarker[] {
         new UserAgentMarker("ro.elizaos.product", "ElizaOS/"),
-        // BRAND_USER_AGENT_MARKERS_INJECTION_POINT
     };
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
+        // Install the AndroidX splash screen BEFORE super.onCreate so it swaps
+        // the launch theme (AppTheme.NoActionBarLaunch / Theme.SplashScreen) to
+        // the activity's postSplashScreenTheme (AppTheme.NoActionBar). Without
+        // it the splash theme persists and Android renders a native AppCompat
+        // action bar — the orange "Eliza" top bar with splash.png stretched
+        // across it — above the Capacitor WebView.
+        SplashScreen.installSplashScreen(this);
+
         // Per Android docs, must precede the first WebView instantiation.
         // BridgeActivity.super.onCreate constructs the Capacitor WebView,
         // so the toggle is set first to stay race-proof against future
@@ -66,31 +82,44 @@ public class MainActivity extends BridgeActivity {
         }
 
         registerPlugin(AgentPlugin.class);
+        registerPlugin(BatteryOptimizationPlugin.class);
+        registerPlugin(VoiceCapturePlugin.class);
+        registerPlugin(ElizaVoicePlugin.class);
+        registerPlugin(ResourceProbePlugin.class);
         super.onCreate(savedInstanceState);
 
-        // The Capacitor WebView serves the renderer at https://localhost
-        // (its default secure-context origin); the on-device Eliza agent
-        // listens at http://127.0.0.1:31337. Without this knob the WebView
-        // blocks every fetch to the loopback agent as a mixed-content
-        // upgrade, surfacing in the UI as "Backend Timeout: /api/auth/status
-        // - Failed to fetch" even though the agent is up. Granting
-        // MIXED_CONTENT_ALWAYS_ALLOW only matters for loopback in this app
-        // — the network_security_config still pins the WebView's allowed
-        // cleartext hosts, and the Capacitor server.hostname locks the
-        // page origin.
+        // Keep the screen on while the agent app is in the foreground.
+        // Voice turns (ASR → LLM → TTS) on local-runtime builds regularly
+        // take 1-5 seconds; screen-off mid-turn breaks the "is the agent
+        // still working?" feedback and confuses the user. The flag is
+        // window-scoped — Android releases it automatically when the window
+        // is no longer visible (app moved to background or fully covered),
+        // so background instances don't drain battery. Same flag set by
+        // every video / voice-calling app (Snapchat, YouTube, Zoom, Meet).
+        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+
+        // Hide the bottom system navigation bar (the white gesture pill) for a
+        // clean, full-bleed agent home — iOS-style. We hide ONLY the navigation
+        // bars, never the status bar (the system clock/battery stay). Transient-
+        // by-swipe so the user can still reveal it with an edge swipe; re-applied
+        // in onWindowFocusChanged so it stays hidden after dialogs / resume.
+        applyImmersiveNavigationBar();
+
         if (getBridge() != null && getBridge().getWebView() != null) {
             WebSettings settings = getBridge().getWebView().getSettings();
-            settings.setMixedContentMode(WebSettings.MIXED_CONTENT_ALWAYS_ALLOW);
+            settings.setMixedContentMode(resolveMixedContentMode());
             applyBrandUserAgentMarkers(settings);
             // Synchronous fast path for the on-device agent bearer that
             // bypasses Capacitor's plugin executor. See ElizaNativeBridge
             // for the dead-Handler bug it works around.
             getBridge().getWebView().addJavascriptInterface(
-                new ElizaNativeBridge(), ElizaNativeBridge.JS_NAME);
+                new ElizaNativeBridge(this), ElizaNativeBridge.JS_NAME);
+            ElizaAndroidSystemBridge.install(getBridge().getWebView(), this);
+            publishGestureInset();
         }
 
         // Auto-start the local Eliza agent runtime as a foreground service.
-        // shouldAutoStart() returns true on branded devices (AOSP/MiladyOS —
+        // shouldAutoStart() returns true on branded devices (AOSP/ElizaOS —
         // the device IS the agent) and on stock Android only when the user
         // picked Local mode in onboarding. Cloud/Remote modes skip this so
         // we don't burn battery on a service they never call. The boot
@@ -98,7 +127,121 @@ public class MainActivity extends BridgeActivity {
         // the user opens the app.
         if (ElizaAgentService.shouldAutoStart(this)) {
             ElizaAgentService.start(this);
+            // Ask for notification consent only once the user (or the device
+            // image) has actually committed to running the on-device agent.
+            // A fresh stock install auto-starts the service so the dashboard
+            // has something to talk to, but the user has chosen nothing yet —
+            // cold-asking there is the first-run nag we want to avoid
+            // (iOS-style: ask only when there is a reason). The foreground
+            // service still runs without the grant; its notification is just
+            // suppressed until later granted in settings or on a later launch
+            // once a runtime mode is persisted.
+            if (ElizaAgentService.hasCommittedRuntimeChoice(this)) {
+                requestPostNotificationsIfNeeded();
+            }
         }
+
+        ElizaWorkScheduler.enqueuePeriodic(getApplicationContext());
+    }
+
+    @Override
+    public void onWindowFocusChanged(boolean hasFocus) {
+        super.onWindowFocusChanged(hasFocus);
+        // The system restores the nav bar after dialogs / resume; re-hide it
+        // whenever we regain focus so the full-bleed home stays clean.
+        if (hasFocus) {
+            applyImmersiveNavigationBar();
+        }
+    }
+
+    /**
+     * Hide the bottom navigation bar (gesture pill) while keeping the status
+     * bar. Uses the AndroidX controller so it is correct across API levels;
+     * transient-by-swipe so the bar is still reachable.
+     */
+    private void applyImmersiveNavigationBar() {
+        try {
+            WindowCompat.setDecorFitsSystemWindows(getWindow(), false);
+            WindowInsetsControllerCompat controller =
+                WindowCompat.getInsetsController(
+                    getWindow(), getWindow().getDecorView());
+            if (controller != null) {
+                controller.hide(WindowInsetsCompat.Type.navigationBars());
+                controller.setSystemBarsBehavior(
+                    WindowInsetsControllerCompat
+                        .BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
+                // The status bar stays visible over the live orange ambient
+                // home, so its icons must be light (white). Paired with the
+                // transparent android:statusBarColor in styles.xml, the orange
+                // draws full-bleed under the clock/battery — no flat band.
+                controller.setAppearanceLightStatusBars(false);
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "Failed to apply immersive navigation bar", e);
+        }
+    }
+
+    /**
+     * Publish the bottom gesture-navigation inset (the home-pill zone apps must
+     * not put critical UI under) to the WebView as the CSS var
+     * `--android-gesture-inset-bottom`. We hide the navigation bar, which zeroes
+     * `env(safe-area-inset-bottom)`, so the floating chat composer would
+     * otherwise sit on top of the gesture-home zone. The renderer folds this var
+     * into its bottom clearance via max(); it defaults to 0px off-Android.
+     */
+    private void publishGestureInset() {
+        final WebView webView = getBridge() != null ? getBridge().getWebView() : null;
+        if (webView == null) {
+            return;
+        }
+        ViewCompat.setOnApplyWindowInsetsListener(
+            getWindow().getDecorView(),
+            (v, insets) -> {
+                int px = insets
+                    .getInsets(WindowInsetsCompat.Type.mandatorySystemGestures())
+                    .bottom;
+                float dp = px / getResources().getDisplayMetrics().density;
+                String js =
+                    "document.documentElement.style.setProperty("
+                        + "'--android-gesture-inset-bottom','" + dp + "px')";
+                webView.post(() -> webView.evaluateJavascript(js, null));
+                return insets;
+            });
+        ViewCompat.requestApplyInsets(getWindow().getDecorView());
+    }
+
+    private static int resolveMixedContentMode() {
+        // The local/AOSP app serves the renderer from Capacitor's
+        // https://localhost origin while the on-device agent listens on
+        // http://127.0.0.1:31337. Debug sideload builds and privileged AOSP
+        // builds need that loopback bridge; cloud/Play rewrites this
+        // activity and keeps mixed content blocked.
+        if (BuildConfig.DEBUG || BuildConfig.AOSP_BUILD) {
+            return WebSettings.MIXED_CONTENT_ALWAYS_ALLOW;
+        }
+        return WebSettings.MIXED_CONTENT_NEVER_ALLOW;
+    }
+
+    /**
+     * On API 33+ (Tiramisu) Android requires runtime consent for posting
+     * notifications. The foreground gateway service already declares the
+     * permission in the manifest, but without runtime grant its notification
+     * is suppressed. We request it lazily and non-blockingly here — if the
+     * user denies, the FGS still runs and pushes notifications only when
+     * later re-granted in system settings.
+     */
+    private void requestPostNotificationsIfNeeded() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            return;
+        }
+        int state = ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS);
+        if (state == PackageManager.PERMISSION_GRANTED) {
+            return;
+        }
+        requestPermissions(
+            new String[] { Manifest.permission.POST_NOTIFICATIONS },
+            REQUEST_CODE_POST_NOTIFICATIONS
+        );
     }
 
     @Override
@@ -134,8 +277,8 @@ public class MainActivity extends BridgeActivity {
      * Iterate over `BRAND_USER_AGENT_MARKERS` and append each marker's
      * `<uaPrefix><tag>` token to the WebView's User-Agent when the
      * named system property is non-empty. On stock Android no marker
-     * matches and the UA is left untouched, preserving the
-     * RuntimeGate picker. Idempotent — already-present markers aren't
+     * matches and the UA is left untouched, preserving first-run runtime
+     * setup. Idempotent — already-present markers aren't
      * duplicated.
      *
      * The framework's default `ro.elizaos.product` → `ElizaOS/` entry
@@ -183,20 +326,4 @@ public class MainActivity extends BridgeActivity {
         }
     }
 
-    /**
-     * On Android 13+ (API 33), POST_NOTIFICATIONS is a runtime permission.
-     * Without it, the foreground service notification is silently suppressed.
-     */
-    private void requestNotificationPermissionIfNeeded() {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-            return;
-        }
-        int result = ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS);
-        if (result != PackageManager.PERMISSION_GRANTED) {
-            requestPermissions(
-                new String[]{ Manifest.permission.POST_NOTIFICATIONS },
-                REQUEST_NOTIFICATION_PERMISSION
-            );
-        }
-    }
 }

package/platforms/android/app/src/main/java/ai/elizaos/app/ResourceProbePlugin.java

@@ -0,0 +1,169 @@
+package ai.elizaos.app;
+
+import android.app.ActivityManager;
+import android.content.Context;
+import android.os.BatteryManager;
+import android.os.Build;
+import android.os.Debug;
+import android.os.PowerManager;
+import android.system.Os;
+import android.system.OsConstants;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+import org.json.JSONObject;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+/**
+ * Capacitor plugin that surfaces a live device-resource snapshot to JS for the
+ * Mobile Resource Workbench (issue #8800) — the Android parity of the iOS
+ * {@code ElizaIntent.getResourceSnapshot}.
+ *
+ * <p>Reads:
+ * <ul>
+ *   <li><b>thermalState</b> — {@link PowerManager#getCurrentThermalStatus()}
+ *       (API 29+), mapped to the shared {@code nominal/fair/serious/critical}
+ *       model; {@code "unknown"} on older OSes.</li>
+ *   <li><b>battery</b> — {@link BatteryManager} level (%), charge counter (µAh),
+ *       instantaneous current (µA), and charging flag.</li>
+ *   <li><b>memory</b> — {@link Debug#getMemoryInfo} total PSS (the app's real
+ *       footprint) plus {@link ActivityManager.MemoryInfo} device available RAM.</li>
+ *   <li><b>cpuTimeMs</b> — process user+system jiffies from {@code /proc/self/stat}
+ *       converted via {@code sysconf(_SC_CLK_TCK)}.</li>
+ *   <li><b>lowPowerMode</b> — {@link PowerManager#isPowerSaveMode()}.</li>
+ * </ul>
+ *
+ * <p>Every value the OS cannot provide is returned as JSON {@code null}, never a
+ * fabricated zero (AGENTS.md §3/§7).
+ */
+@CapacitorPlugin(name = "ResourceProbe")
+public class ResourceProbePlugin extends Plugin {
+
+    @PluginMethod
+    public void getResourceSnapshot(PluginCall call) {
+        Context context = getContext();
+        JSObject result = new JSObject();
+        result.put("platform", "android");
+
+        result.put("thermalState", readThermalState(context));
+        result.put("lowPowerMode", readPowerSaveMode(context));
+
+        BatteryManager bm = (BatteryManager) context.getSystemService(Context.BATTERY_SERVICE);
+        result.put("batteryLevelPct", readBatteryProperty(bm, BatteryManager.BATTERY_PROPERTY_CAPACITY));
+        result.put("batteryChargeMicroAmpHours",
+            readBatteryProperty(bm, BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER));
+        result.put("batteryCurrentMicroAmps",
+            readBatteryProperty(bm, BatteryManager.BATTERY_PROPERTY_CURRENT_NOW));
+        result.put("isCharging", bm != null && bm.isCharging());
+
+        result.put("residentMemoryMb", readTotalPssMb());
+        result.put("availableRamMb", readAvailableRamMb(context));
+        result.put("cpuTimeMs", readProcessCpuTimeMs());
+
+        result.put("capturedAtMs", System.currentTimeMillis());
+        call.resolve(result);
+    }
+
+    private static String readThermalState(Context context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+            return "unknown";
+        }
+        PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        if (pm == null) {
+            return "unknown";
+        }
+        switch (pm.getCurrentThermalStatus()) {
+            case PowerManager.THERMAL_STATUS_NONE:
+                return "nominal";
+            case PowerManager.THERMAL_STATUS_LIGHT:
+            case PowerManager.THERMAL_STATUS_MODERATE:
+                return "fair";
+            case PowerManager.THERMAL_STATUS_SEVERE:
+            case PowerManager.THERMAL_STATUS_CRITICAL:
+                return "serious";
+            case PowerManager.THERMAL_STATUS_EMERGENCY:
+            case PowerManager.THERMAL_STATUS_SHUTDOWN:
+                return "critical";
+            default:
+                return "unknown";
+        }
+    }
+
+    private static Object readPowerSaveMode(Context context) {
+        PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        return pm != null ? (Object) pm.isPowerSaveMode() : JSONObject.NULL;
+    }
+
+    /** A BatteryManager integer property, or JSON null when unavailable/sentinel. */
+    private static Object readBatteryProperty(BatteryManager bm, int property) {
+        if (bm == null) {
+            return JSONObject.NULL;
+        }
+        int value = bm.getIntProperty(property);
+        // BatteryManager returns Integer.MIN_VALUE for unsupported properties.
+        return value == Integer.MIN_VALUE ? JSONObject.NULL : (Object) value;
+    }
+
+    /** Total PSS of this process in MB, or JSON null when the probe fails. */
+    private static Object readTotalPssMb() {
+        try {
+            Debug.MemoryInfo info = new Debug.MemoryInfo();
+            Debug.getMemoryInfo(info);
+            // getTotalPss() is in KB.
+            return info.getTotalPss() / 1024.0;
+        } catch (RuntimeException e) {
+            return JSONObject.NULL;
+        }
+    }
+
+    private static Object readAvailableRamMb(Context context) {
+        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+        if (am == null) {
+            return JSONObject.NULL;
+        }
+        ActivityManager.MemoryInfo info = new ActivityManager.MemoryInfo();
+        am.getMemoryInfo(info);
+        return info.availMem / 1_048_576.0;
+    }
+
+    /**
+     * Process user+system CPU time in ms from {@code /proc/self/stat} fields 14
+     * (utime) and 15 (stime), in clock ticks, converted via
+     * {@code sysconf(_SC_CLK_TCK)}.
+     */
+    private static Object readProcessCpuTimeMs() {
+        try {
+            byte[] raw = Files.readAllBytes(Paths.get("/proc/self/stat"));
+            String stat = new String(raw, StandardCharsets.UTF_8);
+            // The comm field (2nd) is parenthesised and may contain spaces; split
+            // after the closing ')' so the remaining fields are space-delimited.
+            int close = stat.lastIndexOf(')');
+            if (close < 0 || close + 2 > stat.length()) {
+                return JSONObject.NULL;
+            }
+            String[] fields = stat.substring(close + 2).trim().split("\\s+");
+            // After comm, field index 0 is "state"; utime is field 14 and stime
+            // field 15 in the 1-based proc layout → indices 11 and 12 here.
+            if (fields.length < 13) {
+                return JSONObject.NULL;
+            }
+            long utime = Long.parseLong(fields[11]);
+            long stime = Long.parseLong(fields[12]);
+            long ticksPerSecond = Os.sysconf(OsConstants._SC_CLK_TCK);
+            if (ticksPerSecond <= 0) {
+                ticksPerSecond = 100; // POSIX-conventional default on Android
+            }
+            return ((utime + stime) * 1000.0) / ticksPerSecond;
+        } catch (IOException | NumberFormatException | RuntimeException e) {
+            return JSONObject.NULL;
+        }
+    }
+}

package/platforms/android/app/src/main/java/ai/elizaos/app/VoiceCapturePlugin.java

@@ -0,0 +1,119 @@
+package ai.elizaos.app;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import androidx.core.content.ContextCompat;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+/**
+ * Capacitor plugin that starts/stops the {@link ElizaVoiceCaptureService}
+ * microphone foreground service from JS.
+ *
+ * <p>The in-WebView voice pill captures via getUserMedia and dies when the
+ * WebView is backgrounded. This plugin lets the renderer engage the native
+ * always-on / VAD-gated capture path that survives backgrounding by holding
+ * a microphone-typed FGS (R10 §6.2).
+ *
+ * <p>RECORD_AUDIO is a runtime permission. {@link #startBackgroundCapture}
+ * rejects with {@code record_audio_denied} when it is not granted rather than
+ * starting a mic FGS that the OS would immediately kill. JS should call
+ * {@link #requestMicPermission} (user gesture) first, or rely on the WebView
+ * getUserMedia grant the voice pill already triggers.
+ */
+@CapacitorPlugin(name = "VoiceCapture")
+public class VoiceCapturePlugin extends Plugin {
+
+    private static final int REQUEST_CODE_RECORD_AUDIO = 2001;
+
+    @PluginMethod
+    public void startBackgroundCapture(PluginCall call) {
+        Context context = getContext();
+        if (!hasRecordAudio(context)) {
+            JSObject result = new JSObject();
+            result.put("started", false);
+            result.put("reason", "record_audio_denied");
+            call.resolve(result);
+            return;
+        }
+        String mode = call.getString("mode");
+        try {
+            ElizaVoiceCaptureService.start(context);
+            if (mode != null && !mode.isEmpty()) {
+                ElizaVoiceCaptureService.setMode(context, mode);
+            }
+            JSObject result = new JSObject();
+            result.put("started", true);
+            call.resolve(result);
+        } catch (RuntimeException e) {
+            call.reject("Failed to start voice capture service", e);
+        }
+    }
+
+    @PluginMethod
+    public void stopBackgroundCapture(PluginCall call) {
+        try {
+            ElizaVoiceCaptureService.stop(getContext());
+            JSObject result = new JSObject();
+            result.put("stopped", true);
+            call.resolve(result);
+        } catch (RuntimeException e) {
+            call.reject("Failed to stop voice capture service", e);
+        }
+    }
+
+    @PluginMethod
+    public void setMode(PluginCall call) {
+        String mode = call.getString("mode");
+        if (mode == null || mode.isEmpty()) {
+            call.reject("mode is required");
+            return;
+        }
+        ElizaVoiceCaptureService.setMode(getContext(), mode);
+        JSObject result = new JSObject();
+        result.put("ok", true);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void isCaptureSupported(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("granted", hasRecordAudio(getContext()));
+        call.resolve(result);
+    }
+
+    /**
+     * Request RECORD_AUDIO via the host activity. Resolves immediately with
+     * the pre-request state; the OS dialog result is observed on the next
+     * {@link #isCaptureSupported} read. Must be invoked from a user gesture.
+     */
+    @PluginMethod
+    public void requestMicPermission(PluginCall call) {
+        Context context = getContext();
+        boolean granted = hasRecordAudio(context);
+        if (!granted) {
+            Activity activity = getActivity();
+            if (activity != null) {
+                activity.requestPermissions(
+                    new String[] { Manifest.permission.RECORD_AUDIO },
+                    REQUEST_CODE_RECORD_AUDIO
+                );
+            }
+        }
+        JSObject result = new JSObject();
+        result.put("granted", granted);
+        call.resolve(result);
+    }
+
+    private static boolean hasRecordAudio(Context context) {
+        return ContextCompat.checkSelfPermission(context, Manifest.permission.RECORD_AUDIO)
+            == PackageManager.PERMISSION_GRANTED;
+    }
+}

package/platforms/android/app/src/main/res/drawable/eliza_widget_background.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="@color/eliza_orange" />
+    <corners android:radius="8dp" />
+    <padding
+        android:bottom="12dp"
+        android:left="12dp"
+        android:right="12dp"
+        android:top="12dp" />
+</shape>

package/platforms/android/app/src/main/res/drawable/eliza_widget_button_background.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <solid android:color="#1A000000" />
+    <stroke
+        android:width="1dp"
+        android:color="#33FFFFFF" />
+    <corners android:radius="8dp" />
+    <padding
+        android:bottom="8dp"
+        android:left="8dp"
+        android:right="8dp"
+        android:top="8dp" />
+</shape>