kasy-cli 1.13.0 → 1.15.0

package/lib/utils/mobile-identity.js

@@ -0,0 +1,35 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const { readBundleId } = require('./apple-release');
+
+/**
+ * Reads the Android applicationId (package name) of the project.
+ * Source of truth is build.gradle(.kts) — what gets baked into the APK and
+ * what the device sees. kit_setup.json can drift when the user renames the
+ * package manually after `kasy new`, so it's only used as a fallback when
+ * the Android project hasn't been generated yet.
+ */
+async function readPackageName(projectDir) {
+  const candidates = [
+    path.join(projectDir, 'android', 'app', 'build.gradle.kts'),
+    path.join(projectDir, 'android', 'app', 'build.gradle'),
+  ];
+  for (const file of candidates) {
+    if (!(await fs.pathExists(file))) continue;
+    const content = await fs.readFile(file, 'utf8');
+    const m = content.match(/applicationId\s*=?\s*["']([^"']+)["']/);
+    if (m) return m[1];
+  }
+  const kitSetupPath = path.join(projectDir, 'kit_setup.json');
+  if (await fs.pathExists(kitSetupPath)) {
+    try {
+      const kit = await fs.readJson(kitSetupPath);
+      if (kit.bundleId) return kit.bundleId;
+    } catch {
+      // ignore
+    }
+  }
+  return null;
+}
+
+module.exports = { readBundleId, readPackageName };

package/lib/utils/png-padding.js

@@ -0,0 +1,120 @@
+const fsp = require('node:fs/promises');
+const { PNG } = require('pngjs');
+
+const ANDROID12_SAFE_RATIO = 0.5;
+
+async function readPng(filePath) {
+  const buffer = await fsp.readFile(filePath);
+  return new Promise((resolve, reject) => {
+    new PNG().parse(buffer, (err, data) => {
+      if (err) reject(err);
+      else resolve(data);
+    });
+  });
+}
+
+function resizeBilinear(src, dstW, dstH) {
+  const dst = new PNG({ width: dstW, height: dstH });
+  const srcW = src.width;
+  const srcH = src.height;
+  const xRatio = srcW > 1 ? (srcW - 1) / dstW : 0;
+  const yRatio = srcH > 1 ? (srcH - 1) / dstH : 0;
+
+  for (let y = 0; y < dstH; y++) {
+    const sy = (y + 0.5) * yRatio;
+    const y0 = Math.floor(sy);
+    const y1 = Math.min(y0 + 1, srcH - 1);
+    const wy = sy - y0;
+
+    for (let x = 0; x < dstW; x++) {
+      const sx = (x + 0.5) * xRatio;
+      const x0 = Math.floor(sx);
+      const x1 = Math.min(x0 + 1, srcW - 1);
+      const wx = sx - x0;
+
+      const i00 = (y0 * srcW + x0) * 4;
+      const i10 = (y0 * srcW + x1) * 4;
+      const i01 = (y1 * srcW + x0) * 4;
+      const i11 = (y1 * srcW + x1) * 4;
+
+      const dstIdx = (y * dstW + x) * 4;
+      for (let c = 0; c < 4; c++) {
+        const top = src.data[i00 + c] * (1 - wx) + src.data[i10 + c] * wx;
+        const bot = src.data[i01 + c] * (1 - wx) + src.data[i11 + c] * wx;
+        dst.data[dstIdx + c] = Math.round(top * (1 - wy) + bot * wy);
+      }
+    }
+  }
+  return dst;
+}
+
+function compositeOnTransparentSquare(logo, canvasSize) {
+  const canvas = new PNG({ width: canvasSize, height: canvasSize });
+  canvas.data.fill(0);
+
+  const offsetX = Math.floor((canvasSize - logo.width) / 2);
+  const offsetY = Math.floor((canvasSize - logo.height) / 2);
+
+  for (let y = 0; y < logo.height; y++) {
+    for (let x = 0; x < logo.width; x++) {
+      const srcIdx = (y * logo.width + x) * 4;
+      const dstIdx = ((y + offsetY) * canvasSize + (x + offsetX)) * 4;
+      canvas.data[dstIdx] = logo.data[srcIdx];
+      canvas.data[dstIdx + 1] = logo.data[srcIdx + 1];
+      canvas.data[dstIdx + 2] = logo.data[srcIdx + 2];
+      canvas.data[dstIdx + 3] = logo.data[srcIdx + 3];
+    }
+  }
+  return canvas;
+}
+
+async function writePng(png, filePath) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    png.pack()
+      .on('data', (chunk) => chunks.push(chunk))
+      .on('end', async () => {
+        try {
+          await fsp.writeFile(filePath, Buffer.concat(chunks));
+          resolve();
+        } catch (e) {
+          reject(e);
+        }
+      })
+      .on('error', reject);
+  });
+}
+
+/**
+ * Read a PNG and write a new one of the same dimensions, with the source
+ * logo scaled down to fit inside the Android 12+ splash safe area (centered,
+ * transparent padding around it). This is what `windowSplashScreenAnimatedIcon`
+ * needs so the OS-applied circular mask doesn't clip the logo edges.
+ *
+ * @param {string} srcPath
+ * @param {string} dstPath
+ * @param {number} safeRatio fraction of the canvas the logo should occupy (default 0.6)
+ */
+async function writeAndroid12Variant(srcPath, dstPath, safeRatio = ANDROID12_SAFE_RATIO) {
+  const src = await readPng(srcPath);
+  const canvasSize = Math.max(src.width, src.height);
+  const safeSide = Math.round(canvasSize * safeRatio);
+
+  const aspect = src.width / src.height;
+  let logoW;
+  let logoH;
+  if (aspect >= 1) {
+    logoW = safeSide;
+    logoH = Math.round(safeSide / aspect);
+  } else {
+    logoH = safeSide;
+    logoW = Math.round(safeSide * aspect);
+  }
+
+  const resized = resizeBilinear(src, logoW, logoH);
+  const composited = compositeOnTransparentSquare(resized, canvasSize);
+  await writePng(composited, dstPath);
+  return { canvasSize, logoW, logoH };
+}
+
+module.exports = { writeAndroid12Variant, ANDROID12_SAFE_RATIO };

package/lib/utils/ui.js

@@ -13,6 +13,15 @@
  */
 
 const clack = require('@clack/prompts');
+const kleur = require('kleur');
+
+function formatElapsedSeconds(startTime) {
+  const elapsed = Math.floor((Date.now() - startTime) / 1000);
+  if (elapsed < 60) return `${elapsed}s`;
+  const m = Math.floor(elapsed / 60);
+  const s = elapsed % 60;
+  return `${m}m ${s}s`;
+}
 
 function handleCancel(result, onCancel) {
   if (clack.isCancel(result)) {
@@ -85,6 +94,109 @@ function cancel(message) { clack.cancel(message); }
  */
 function spinner() { return clack.spinner(); }
 
+/**
+ * Spinner with an automatic elapsed-time suffix that ticks every second.
+ * Same API as spinner() — useful for operations that take >30s so the user
+ * sees the clock moving even when the underlying tool emits no progress.
+ *
+ *   const s = ui.timedSpinner();
+ *   s.start('Deploying…');          // "Deploying…  [0s]"
+ *   // ... 73 seconds later
+ *   s.stop('Deploy done');          // "Deploy done  [1m 13s]"
+ */
+function timedSpinner() {
+  const s = clack.spinner();
+  let startTime = null;
+  let currentMessage = '';
+  let tick = null;
+
+  const render = (msg) => {
+    if (!msg) return '';
+    if (!startTime) return msg;
+    return `${msg}  ${kleur.dim(`[${formatElapsedSeconds(startTime)}]`)}`;
+  };
+
+  const stopTick = () => {
+    if (tick) { clearInterval(tick); tick = null; }
+  };
+
+  return {
+    start(msg) {
+      startTime = Date.now();
+      currentMessage = msg || '';
+      s.start(render(currentMessage));
+      tick = setInterval(() => {
+        if (currentMessage) s.message(render(currentMessage));
+      }, 1000);
+    },
+    message(msg) {
+      currentMessage = msg || '';
+      s.message(render(currentMessage));
+    },
+    stop(msg, code) {
+      stopTick();
+      const finalMsg = msg != null ? render(msg) : render(currentMessage);
+      s.stop(finalMsg, code);
+    },
+    error(msg) {
+      stopTick();
+      s.error(msg != null ? render(msg) : render(currentMessage));
+    },
+  };
+}
+
+/**
+ * Multi-step spinner where every step shows its own elapsed-time counter.
+ * Use for long sequential flows like Firebase project creation so the user
+ * can tell which steps are slow.
+ */
+function makeTimedStepper() {
+  let current = null;
+  let currentMsg = '';
+  return {
+    next(text) {
+      if (current) current.stop(currentMsg);
+      current = timedSpinner();
+      currentMsg = text;
+      current.start(text);
+    },
+    update(text) {
+      if (current) {
+        currentMsg = text;
+        current.message(text);
+      }
+    },
+    succeed(text) {
+      if (current) {
+        current.stop(text || currentMsg);
+        current = null;
+        currentMsg = '';
+      }
+    },
+    fail(text) {
+      if (current) {
+        current.error(text || currentMsg);
+        current = null;
+        currentMsg = '';
+      }
+    },
+    warn(text) {
+      if (current) {
+        current.stop(`⚠ ${text || currentMsg}`);
+        current = null;
+        currentMsg = '';
+      }
+    },
+    stop() {
+      if (current) {
+        current.stop(currentMsg);
+        current = null;
+        currentMsg = '';
+      }
+    },
+  };
+}
+
 /**
  * Multi-step spinner: each .next(text) succeeds the previous step
  * with the previous message, then starts a new step with `text`.
@@ -166,7 +278,9 @@ module.exports = {
   note,
   cancel,
   spinner,
+  timedSpinner,
   makeStepper,
+  makeTimedStepper,
   taskLog,
   progress,
   log,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kasy-cli",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "CLI for scaffolding production-ready Flutter SaaS apps with Firebase, Supabase, or API REST backends.",
   "bin": {
     "kasy": "./bin/kasy.js"
@@ -39,10 +39,12 @@
     "validate": "node ./bin/kasy.js validate --analyze-only",
     "extract:patch": "node ./scripts/extract_patch.js",
     "check:firebase": "node ./scripts/check-firebase-template.js",
+    "test": "for f in test/*.test.js; do node \"$f\" || exit 1; done",
     "test:google-ios": "node ./test/google-ios-url-scheme.test.js",
     "test:apple-release": "node ./test/apple-release.test.js",
     "test:localize-docs": "node ./test/localize-release-docs.test.js",
-    "test:i18n-accents": "node ./test/i18n-accents.test.js"
+    "test:i18n-accents": "node ./test/i18n-accents.test.js",
+    "lint": "eslint bin lib scripts"
   },
   "dependencies": {
     "@clack/prompts": "^1.4.0",
@@ -51,8 +53,10 @@
     "fs-extra": "^11.2.0",
     "gradient-string": "^1.2.0",
     "kleur": "^4.1.5",
-    "ora": "^8.0.1",
-    "prompts": "^2.4.2",
+    "pngjs": "^7.0.0",
     "yaml": "^2.4.2"
+  },
+  "devDependencies": {
+    "eslint": "^9.39.4"
   }
 }

package/templates/firebase/README.en.md

@@ -1,4 +1,4 @@
-# AppFirebase
+# Kasy App
 
 Flutter app with Firebase backend — generated by kasy.
 

package/templates/firebase/README.es.md

@@ -1,4 +1,4 @@
-# AppFirebase
+# Kasy App
 
 App Flutter con backend Firebase — generado por kasy.
 

package/templates/firebase/README.md

@@ -1,4 +1,4 @@
-# AppFirebase
+# Kasy App
 
 Flutter app com backend Firebase — gerado pelo kasy.
 

package/templates/firebase/android/app/build.gradle.kts

@@ -76,5 +76,14 @@ flutter {
 dependencies {
   coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.5")
   implementation("com.google.android.gms:play-services-ads-identifier:18.1.0")
-  implementation("androidx.glance:glance-appwidget:1.1.1")
+  // strictly() blocks Gradle from upgrading via transitive resolution —
+  // the home_widget plugin declares `1.+` and would otherwise pick the
+  // latest alpha (1.3.0-alpha01 at time of writing), which requires
+  // compileSdk 37 + AGP 9.x and breaks the build.
+  implementation("androidx.glance:glance-appwidget") {
+    version {
+      strictly("1.1.1")
+    }
+  }
+  implementation("androidx.appcompat:appcompat:1.7.0")
 }

package/templates/firebase/android/app/src/main/AndroidManifest.xml

@@ -16,7 +16,7 @@
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
 
     <application
-        android:label="AppFirebase"
+        android:label="Kasy App"
         android:name="${applicationName}"
         android:icon="@mipmap/ic_launcher"
         android:localeConfig="@xml/locales_config">

package/templates/firebase/android/app/src/main/kotlin/com/aicrus/firebase/kit/MainActivity.kt

@@ -1,5 +1,8 @@
 package com.aicrus.firebase.kit
-    
+
+import android.content.Context
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatDelegate
 import com.google.android.gms.ads.identifier.AdvertisingIdClient
 import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
@@ -12,6 +15,27 @@ import kotlinx.coroutines.withContext
 class MainActivity : FlutterActivity() {
   private val CHANNEL = "kasy_kit/advertising_id"
 
+  override fun onCreate(savedInstanceState: Bundle?) {
+    applySavedThemeMode()
+    super.onCreate(savedInstanceState)
+  }
+
+  // Forces the night mode to match the user's saved theme preference (read
+  // from `shared_preferences`) so the native splash drawable selection
+  // (drawable-night vs drawable) follows the in-app choice, not just the OS.
+  private fun applySavedThemeMode() {
+    val prefs = applicationContext.getSharedPreferences(
+      "FlutterSharedPreferences",
+      Context.MODE_PRIVATE,
+    )
+    val mode = when (prefs.getString("flutter.themeMode", null)) {
+      "dark" -> AppCompatDelegate.MODE_NIGHT_YES
+      "light" -> AppCompatDelegate.MODE_NIGHT_NO
+      else -> AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+    }
+    AppCompatDelegate.setDefaultNightMode(mode)
+  }
+
   override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
     super.configureFlutterEngine(flutterEngine)
     

package/templates/firebase/android/app/src/main/kotlin/com/aicrus/firebase/kit/MyWidget.kt

@@ -1,32 +1,50 @@
 package com.aicrus.firebase.kit
 
 import android.content.Context
+import android.content.Intent
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.glance.GlanceId
 import androidx.glance.GlanceModifier
+import androidx.glance.Image
+import androidx.glance.ImageProvider
+import androidx.glance.LocalSize
+import androidx.glance.action.clickable
 import androidx.glance.appwidget.GlanceAppWidget
+import androidx.glance.appwidget.SizeMode
+import androidx.glance.appwidget.action.actionStartActivity
 import androidx.glance.appwidget.provideContent
 import androidx.glance.background
 import androidx.glance.currentState
 import androidx.glance.layout.Alignment
 import androidx.glance.layout.Box
 import androidx.glance.layout.Column
+import androidx.glance.layout.ContentScale
+import androidx.glance.layout.Row
 import androidx.glance.layout.Spacer
 import androidx.glance.layout.fillMaxSize
+import androidx.glance.layout.fillMaxWidth
 import androidx.glance.layout.padding
+import androidx.glance.layout.size
 import androidx.glance.state.GlanceStateDefinition
+import androidx.glance.text.FontStyle
 import androidx.glance.text.FontWeight
 import androidx.glance.text.Text
 import androidx.glance.text.TextStyle
 import androidx.glance.unit.ColorProvider
 import es.antonborri.home_widget.HomeWidgetGlanceState
 import es.antonborri.home_widget.HomeWidgetGlanceStateDefinition
+import java.util.Calendar
+import java.util.Locale
 
 class MyWidgetWidget : GlanceAppWidget() {
 
+  // Recompose when the user resizes the widget so the layout can adapt
+  // between small (no "+", no quote) and large (everything visible).
+  override val sizeMode: SizeMode = SizeMode.Exact
+
   override val stateDefinition: GlanceStateDefinition<*>?
     get() = HomeWidgetGlanceStateDefinition()
 
@@ -39,22 +57,49 @@ class MyWidgetWidget : GlanceAppWidget() {
   @Composable
   private fun GlanceContent(context: Context, currentState: HomeWidgetGlanceState) {
     val prefs = currentState.preferences
-    val greeting = prefs.getString("greeting", "") ?: ""
-    val title = prefs.getString("title", "") ?: ""
+    val storedGreeting = prefs.getString("greeting", "") ?: ""
+    val storedTitle = prefs.getString("title", "") ?: ""
     val planText = prefs.getString("planText", "") ?: ""
     val isPro = prefs.getString("isPro", "false") == "true"
+    val quote = prefs.getString("quote", "") ?: ""
+
+    // Time/locale-based fallback used when Flutter has not pushed data yet —
+    // first install before the app opens. Keeps the widget from rendering
+    // blank in the gallery preview.
+    val defaults = defaultStrings()
+    val greeting = storedGreeting.ifEmpty { defaults.greeting }
+    val title = storedTitle.ifEmpty { defaults.hello }
+
+    val size = LocalSize.current
+    val isSmall = size.width < 200.dp
+    // Heuristic: tall enough to fit greeting + title + quote without crowding.
+    val isLarge = size.height >= 280.dp
 
-    val bgColor = Color(red = 0.08f, green = 0.03f, blue = 0.16f)
     val white = Color.White
     val whiteSubtle = Color(red = 1f, green = 1f, blue = 1f, alpha = 0.55f)
+    val whiteQuote = Color(red = 1f, green = 1f, blue = 1f, alpha = 0.65f)
     val gold = Color(red = 1f, green = 0.84f, blue = 0f)
-    val whiteVerySubtle = Color(red = 1f, green = 1f, blue = 1f, alpha = 0.40f)
+    val whiteVerySubtle = Color(red = 1f, green = 1f, blue = 1f, alpha = 0.45f)
 
+    // The gradient lives in its own Image at the bottom of the stack rather
+    // than as `.background(ImageProvider(...))`, because in some Glance
+    // versions the latter ends up rendered ABOVE the content — the widget
+    // shows just the gradient, no text. The explicit Image+Column layering
+    // here is deterministic.
     Box(
-      modifier = GlanceModifier.fillMaxSize().background(bgColor).padding(16.dp),
-      contentAlignment = Alignment.TopStart,
+      modifier = GlanceModifier
+        .fillMaxSize()
+        .clickable(actionStartActivity(launchAppIntent(context))),
     ) {
-      Column(modifier = GlanceModifier.fillMaxSize()) {
+      Image(
+        provider = ImageProvider(R.drawable.widget_gradient_inner),
+        contentDescription = null,
+        contentScale = ContentScale.FillBounds,
+        modifier = GlanceModifier.fillMaxSize(),
+      )
+      Column(
+        modifier = GlanceModifier.fillMaxSize().padding(16.dp),
+      ) {
         Text(
           text = greeting,
           style = TextStyle(
@@ -67,21 +112,126 @@ class MyWidgetWidget : GlanceAppWidget() {
           text = title,
           style = TextStyle(
             color = ColorProvider(white),
-            fontSize = 22.sp,
+            fontSize = if (isSmall) 20.sp else 24.sp,
             fontWeight = FontWeight.Bold,
           ),
           modifier = GlanceModifier.padding(top = 4.dp),
         )
+        if (isLarge && quote.isNotEmpty()) {
+          Text(
+            text = quote,
+            style = TextStyle(
+              color = ColorProvider(whiteQuote),
+              fontSize = 15.sp,
+              fontWeight = FontWeight.Normal,
+              fontStyle = FontStyle.Italic,
+            ),
+            maxLines = 4,
+            modifier = GlanceModifier.padding(top = 12.dp),
+          )
+        }
         Spacer(modifier = GlanceModifier.defaultWeight())
+        Row(
+          modifier = GlanceModifier.fillMaxWidth(),
+          verticalAlignment = Alignment.CenterVertically,
+        ) {
+          // Empty planText hides the pill (used in logged-out state).
+          if (planText.isNotEmpty()) {
+            PlanPill(
+              isPro = isPro,
+              planText = planText,
+              gold = gold,
+              whiteVerySubtle = whiteVerySubtle,
+            )
+          }
+          // Small intentionally drops the "+" so the layout breathes —
+          // the pill sits flush left like the original design.
+          if (!isSmall) {
+            Spacer(modifier = GlanceModifier.defaultWeight())
+            Image(
+              provider = ImageProvider(R.drawable.widget_add_button),
+              contentDescription = "Add",
+              modifier = GlanceModifier
+                .size(34.dp)
+                .clickable(actionStartActivity(launchAppIntent(context))),
+            )
+          }
+        }
+      }
+    }
+  }
+
+  @Composable
+  private fun PlanPill(
+    isPro: Boolean,
+    planText: String,
+    gold: Color,
+    whiteVerySubtle: Color,
+  ) {
+    if (isPro) {
+      Box(
+        modifier = GlanceModifier
+          .background(ImageProvider(R.drawable.widget_pro_pill_bg))
+          .padding(horizontal = 10.dp, vertical = 5.dp),
+      ) {
+        Text(
+          text = "⭐ $planText",
+          style = TextStyle(
+            color = ColorProvider(gold),
+            fontSize = 11.sp,
+            fontWeight = FontWeight.Bold,
+          ),
+        )
+      }
+    } else {
+      Box(
+        modifier = GlanceModifier
+          .background(ImageProvider(R.drawable.widget_plan_pill_bg))
+          .padding(horizontal = 10.dp, vertical = 5.dp),
+      ) {
         Text(
-          text = if (isPro) "⭐ $planText" else planText,
+          text = planText,
           style = TextStyle(
-            color = ColorProvider(if (isPro) gold else whiteVerySubtle),
+            color = ColorProvider(whiteVerySubtle),
             fontSize = 11.sp,
-            fontWeight = if (isPro) FontWeight.Bold else FontWeight.Medium,
+            fontWeight = FontWeight.Medium,
           ),
         )
       }
     }
   }
+
+  private data class DefaultStrings(val greeting: String, val hello: String)
+
+  private fun defaultStrings(): DefaultStrings {
+    val hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY)
+    val lang = Locale.getDefault().language
+    val morning: String; val afternoon: String; val evening: String; val hello: String
+    when (lang) {
+      "pt" -> { morning = "Bom dia"; afternoon = "Boa tarde"; evening = "Boa noite"; hello = "Olá!" }
+      "es" -> { morning = "Buenos días"; afternoon = "Buenas tardes"; evening = "Buenas noches"; hello = "¡Hola!" }
+      else -> { morning = "Good morning"; afternoon = "Good afternoon"; evening = "Good evening"; hello = "Hi there!" }
+    }
+    val greeting = when {
+      hour < 12 -> morning
+      hour < 18 -> afternoon
+      else -> evening
+    }
+    return DefaultStrings(greeting, hello)
+  }
+
+  /// Builds the exact Intent the system launcher fires when the user taps
+  /// the app icon. We must NOT add extra flags here — getLaunchIntentForPackage
+  /// already returns `FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_RESET_IF_NEEDED`,
+  /// which is the same combo the launcher uses. Adding `CLEAR_TOP` destroys
+  /// go_router's navigation stack on warm starts and lands the user on the
+  /// errorBuilder ("404 - Page not found").
+  private fun launchAppIntent(context: Context): Intent {
+    return context.packageManager.getLaunchIntentForPackage(context.packageName)
+      ?: Intent(context, MainActivity::class.java).apply {
+        action = Intent.ACTION_MAIN
+        addCategory(Intent.CATEGORY_LAUNCHER)
+        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+      }
+  }
 }

package/templates/firebase/android/app/src/main/res/drawable/widget_add_button.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="34dp"
+    android:height="34dp"
+    android:viewportWidth="34"
+    android:viewportHeight="34">
+    <path
+        android:pathData="M17,0 A17,17 0 1,0 17,34 A17,17 0 1,0 17,0 Z"
+        android:fillColor="#2EFFFFFF"/>
+    <path
+        android:pathData="M17,9 L17,25 M9,17 L25,17"
+        android:strokeColor="#FFFFFFFF"
+        android:strokeWidth="2.5"
+        android:strokeLineCap="round"/>
+</vector>

package/templates/firebase/android/app/src/main/res/drawable/widget_gradient_bg.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle">
+    <gradient
+        android:angle="315"
+        android:startColor="#FF140829"
+        android:endColor="#FF33176B"
+        android:type="linear" />
+    <corners android:radius="24dp" />
+</shape>