@parastud/floating-bubble 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# @parastud/floating-bubble
+
+A draggable, circular **"back to Rastaa"** bubble that floats on top of other apps
+(Ola/Porter style), so a driver can tap it to jump straight back into the app while
+a navigation app (e.g. Google Maps) is in the foreground.
+
+- **Android** — a real overlay drawn with `WindowManager`, gated on the
+  `SYSTEM_ALERT_WINDOW` ("Display over other apps") permission.
+- **iOS** — there is no public API to draw over other apps, so the native module is
+  a **no-op stub**. Every method resolves to a safe default; nothing crashes.
+
+This is a native Expo module: it ships native Android/iOS code and **requires a
+native rebuild** (dev client or EAS build). It cannot be delivered as an OTA update.
+
+## Install
+
+```bash
+npm install @parastud/floating-bubble
+```
+
+Then rebuild the native app (autolinking picks the module up automatically):
+
+```bash
+npx expo run:android   # or: eas build
+```
+
+The Android `SYSTEM_ALERT_WINDOW` permission is merged into the host app's manifest
+automatically via this module's `AndroidManifest.xml`.
+
+## Usage
+
+```ts
+import { FloatingBubble } from '@parastud/floating-bubble';
+
+// Is the bubble actually usable here? (Android + native module present)
+if (FloatingBubble.isSupported) {
+  // Has the user granted "Display over other apps"?
+  if (!FloatingBubble.canDrawOverlays()) {
+    FloatingBubble.requestPermission(); // opens the system settings screen
+  }
+
+  FloatingBubble.show();   // float the bubble over other apps
+  FloatingBubble.hide();   // remove it
+  FloatingBubble.isVisible();
+}
+```
+
+Every method is safe to call on any platform — on iOS, or on a build without the
+native module, calls short-circuit to safe defaults instead of throwing.
+
+## API
+
+| Member | Returns | Description |
+| --- | --- | --- |
+| `isSupported` | `boolean` | `true` only on Android with the native module present. |
+| `canDrawOverlays()` | `boolean` | Whether "Display over other apps" is granted. |
+| `requestPermission()` | `void` | Opens the system settings screen to grant the permission. |
+| `isVisible()` | `boolean` | Whether the bubble is currently on screen. |
+| `show()` | `void` | Show the bubble (no-op without permission / if already visible). |
+| `hide()` | `void` | Remove the bubble. |
+
+The raw native surface is also exported as the `FloatingBubbleNativeModule` type for
+advanced use.
+
+## License
+
+UNLICENSED — internal Rastaa package.

package/android/build.gradle

@@ -0,0 +1,19 @@
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+group = 'ai.rastaa.floatingbubble'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useDefaultAndroidSdkVersions()
+useExpoPublishing()
+
+android {
+  namespace "ai.rastaa.floatingbubble"
+  defaultConfig {
+    minSdkVersion 24
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <!-- Lets the app draw the "back to Rastaa" bubble over other apps (e.g. Google Maps). -->
+  <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+</manifest>

package/android/src/main/java/ai/rastaa/floatingbubble/FloatingBubbleModule.kt

@@ -0,0 +1,206 @@
+package ai.rastaa.floatingbubble
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.graphics.Outline
+import android.graphics.PixelFormat
+import android.graphics.drawable.GradientDrawable
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.provider.Settings
+import android.view.Gravity
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewOutlineProvider
+import android.view.WindowManager
+import android.widget.FrameLayout
+import android.widget.ImageView
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlin.math.abs
+
+// Renders a draggable, circular "back to Rastaa" bubble on top of every other app
+// (Ola/Porter style). Android only — iOS has no API to draw over other apps.
+class FloatingBubbleModule : Module() {
+
+  private var bubbleView: View? = null
+  private var windowManager: WindowManager? = null
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  private val appContextOrNull: Context?
+    get() = appContext.reactContext?.applicationContext
+
+  override fun definition() = ModuleDefinition {
+    Name("FloatingBubble")
+
+    // Has the user granted "Display over other apps"?
+    Function("canDrawOverlays") {
+      val ctx = appContextOrNull ?: return@Function false
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) Settings.canDrawOverlays(ctx) else true
+    }
+
+    // Send the user to the system settings screen to grant the overlay permission.
+    Function("requestOverlayPermission") {
+      val ctx = appContextOrNull
+      if (
+        ctx != null &&
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
+        !Settings.canDrawOverlays(ctx)
+      ) {
+        val intent = Intent(
+          Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
+          Uri.parse("package:${ctx.packageName}"),
+        ).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        ctx.startActivity(intent)
+      }
+    }
+
+    Function("isVisible") { bubbleView != null }
+
+    Function("show") {
+      mainHandler.post { showBubble() }
+    }
+
+    Function("hide") {
+      mainHandler.post { hideBubble() }
+    }
+
+    OnDestroy {
+      mainHandler.post { hideBubble() }
+    }
+  }
+
+  private fun showBubble() {
+    val ctx = appContextOrNull ?: return
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !Settings.canDrawOverlays(ctx)) return
+    if (bubbleView != null) return
+
+    val wm = ctx.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+    windowManager = wm
+
+    val density = ctx.resources.displayMetrics.density
+    val sizePx = (60 * density).toInt()
+    val padPx = (8 * density).toInt()
+
+    // Black circle with the app icon centered inside it.
+    val container = FrameLayout(ctx).apply {
+      background = GradientDrawable().apply {
+        shape = GradientDrawable.OVAL
+        setColor(Color.BLACK)
+      }
+      elevation = 12 * density
+      outlineProvider = object : ViewOutlineProvider() {
+        override fun getOutline(view: View, outline: Outline) {
+          outline.setOval(0, 0, view.width, view.height)
+        }
+      }
+      clipToOutline = true
+    }
+
+    val icon = ImageView(ctx).apply {
+      scaleType = ImageView.ScaleType.CENTER_CROP
+      try {
+        setImageDrawable(ctx.packageManager.getApplicationIcon(ctx.packageName))
+      } catch (_: Exception) {
+      }
+    }
+    container.addView(
+      icon,
+      FrameLayout.LayoutParams(sizePx - padPx, sizePx - padPx, Gravity.CENTER),
+    )
+
+    val windowType =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+        WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
+      else
+        @Suppress("DEPRECATION")
+        WindowManager.LayoutParams.TYPE_PHONE
+
+    val params = WindowManager.LayoutParams(
+      sizePx,
+      sizePx,
+      windowType,
+      WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
+      PixelFormat.TRANSLUCENT,
+    ).apply {
+      gravity = Gravity.TOP or Gravity.START
+      x = (16 * density).toInt()
+      y = (140 * density).toInt()
+    }
+
+    container.setOnTouchListener(object : View.OnTouchListener {
+      private var startX = 0
+      private var startY = 0
+      private var touchDownX = 0f
+      private var touchDownY = 0f
+      private var dragging = false
+      private val touchSlop = 8 * density
+
+      override fun onTouch(v: View, e: MotionEvent): Boolean {
+        when (e.action) {
+          MotionEvent.ACTION_DOWN -> {
+            startX = params.x
+            startY = params.y
+            touchDownX = e.rawX
+            touchDownY = e.rawY
+            dragging = false
+            return true
+          }
+          MotionEvent.ACTION_MOVE -> {
+            val dx = e.rawX - touchDownX
+            val dy = e.rawY - touchDownY
+            if (abs(dx) > touchSlop || abs(dy) > touchSlop) dragging = true
+            params.x = startX + dx.toInt()
+            params.y = startY + dy.toInt()
+            try {
+              wm.updateViewLayout(v, params)
+            } catch (_: Exception) {
+            }
+            return true
+          }
+          MotionEvent.ACTION_UP -> {
+            if (!dragging) bringAppToFront()
+            return true
+          }
+        }
+        return false
+      }
+    })
+
+    try {
+      wm.addView(container, params)
+      bubbleView = container
+    } catch (_: Exception) {
+      bubbleView = null
+    }
+  }
+
+  private fun bringAppToFront() {
+    val ctx = appContextOrNull ?: return
+    val launchIntent = ctx.packageManager.getLaunchIntentForPackage(ctx.packageName)
+    launchIntent?.addFlags(
+      Intent.FLAG_ACTIVITY_NEW_TASK or
+        Intent.FLAG_ACTIVITY_REORDER_TO_FRONT or
+        Intent.FLAG_ACTIVITY_SINGLE_TOP,
+    )
+    if (launchIntent != null) {
+      try {
+        ctx.startActivity(launchIntent)
+      } catch (_: Exception) {
+      }
+    }
+    hideBubble()
+  }
+
+  private fun hideBubble() {
+    val view = bubbleView ?: return
+    try {
+      windowManager?.removeView(view)
+    } catch (_: Exception) {
+    }
+    bubbleView = null
+  }
+}

package/build/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The raw native surface registered by the module on each platform.
+ *
+ * On Android these are backed by a real `WindowManager` overlay drawn with the
+ * SYSTEM_ALERT_WINDOW ("Display over other apps") permission. iOS has no public
+ * API to draw over other apps, so the native module there is a no-op stub and
+ * every method returns a safe default.
+ *
+ * Prefer the {@link FloatingBubble} façade below — it guards every call so it is
+ * safe to invoke on any platform.
+ */
+export type FloatingBubbleNativeModule = {
+    /** Whether the user has granted "Display over other apps" (SYSTEM_ALERT_WINDOW). */
+    canDrawOverlays(): boolean;
+    /** Opens the system settings screen to grant the overlay permission. */
+    requestOverlayPermission(): void;
+    /** Whether the bubble is currently on screen. */
+    isVisible(): boolean;
+    /** Show the bubble (no-op without permission, or if already visible). */
+    show(): void;
+    /** Remove the bubble. */
+    hide(): void;
+};
+/**
+ * True only where the bubble can actually render: Android, with the native
+ * module present in the running binary. Everywhere else every call below is a
+ * safe no-op.
+ */
+export declare const isSupported: boolean;
+/**
+ * Cross-platform façade over the native module. Safe to call on any platform —
+ * on iOS, or on a build without the native module, methods short-circuit to safe
+ * defaults instead of throwing.
+ */
+export declare const FloatingBubble: {
+    /** See {@link isSupported}. */
+    isSupported: boolean;
+    /** Whether the user has granted "Display over other apps". `false` if unsupported. */
+    canDrawOverlays(): boolean;
+    /** Send the user to the system settings screen to grant the overlay permission. */
+    requestPermission(): void;
+    /** Whether the bubble is currently on screen. `false` if unsupported. */
+    isVisible(): boolean;
+    /** Show the bubble. No-op without permission, if already visible, or if unsupported. */
+    show(): void;
+    /** Remove the bubble. No-op if unsupported. */
+    hide(): void;
+};
+export default FloatingBubble;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,oFAAoF;IACpF,eAAe,IAAI,OAAO,CAAC;IAC3B,wEAAwE;IACxE,wBAAwB,IAAI,IAAI,CAAC;IACjC,iDAAiD;IACjD,SAAS,IAAI,OAAO,CAAC;IACrB,yEAAyE;IACzE,IAAI,IAAI,IAAI,CAAC;IACb,yBAAyB;IACzB,IAAI,IAAI,IAAI,CAAC;CACd,CAAC;AAWF;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAA8B,CAAC;AAEvD;;;;GAIG;AACH,eAAO,MAAM,cAAc;IACzB,+BAA+B;;IAG/B,sFAAsF;uBACnE,OAAO;IAI1B,mFAAmF;yBAC9D,IAAI;IAIzB,yEAAyE;iBAC5D,OAAO;IAIpB,wFAAwF;YAChF,IAAI;IAIZ,+CAA+C;YACvC,IAAI;CAGb,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/build/index.js

@@ -0,0 +1,48 @@
+import { requireOptionalNativeModule } from 'expo';
+import { Platform } from 'react-native';
+const isAndroid = Platform.OS === 'android';
+// `requireOptionalNativeModule` returns null instead of throwing when the native
+// module isn't in the running binary. That keeps a JS-only/OTA bundle from
+// crashing if it ever lands on an older build that predates this native module —
+// the bubble simply does nothing there. iOS ships a no-op stub of the same name.
+const native = requireOptionalNativeModule('FloatingBubble');
+/**
+ * True only where the bubble can actually render: Android, with the native
+ * module present in the running binary. Everywhere else every call below is a
+ * safe no-op.
+ */
+export const isSupported = isAndroid && native != null;
+/**
+ * Cross-platform façade over the native module. Safe to call on any platform —
+ * on iOS, or on a build without the native module, methods short-circuit to safe
+ * defaults instead of throwing.
+ */
+export const FloatingBubble = {
+    /** See {@link isSupported}. */
+    isSupported,
+    /** Whether the user has granted "Display over other apps". `false` if unsupported. */
+    canDrawOverlays() {
+        return isSupported ? native.canDrawOverlays() : false;
+    },
+    /** Send the user to the system settings screen to grant the overlay permission. */
+    requestPermission() {
+        if (isSupported)
+            native.requestOverlayPermission();
+    },
+    /** Whether the bubble is currently on screen. `false` if unsupported. */
+    isVisible() {
+        return isSupported ? native.isVisible() : false;
+    },
+    /** Show the bubble. No-op without permission, if already visible, or if unsupported. */
+    show() {
+        if (isSupported)
+            native.show();
+    },
+    /** Remove the bubble. No-op if unsupported. */
+    hide() {
+        if (isSupported)
+            native.hide();
+    },
+};
+export default FloatingBubble;
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,MAAM,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AA0BxC,MAAM,SAAS,GAAG,QAAQ,CAAC,EAAE,KAAK,SAAS,CAAC;AAE5C,iFAAiF;AACjF,2EAA2E;AAC3E,iFAAiF;AACjF,iFAAiF;AACjF,MAAM,MAAM,GACV,2BAA2B,CAA6B,gBAAgB,CAAC,CAAC;AAE5E;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,IAAI,MAAM,IAAI,IAAI,CAAC;AAEvD;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,+BAA+B;IAC/B,WAAW;IAEX,sFAAsF;IACtF,eAAe;QACb,OAAO,WAAW,CAAC,CAAC,CAAC,MAAO,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACzD,CAAC;IAED,mFAAmF;IACnF,iBAAiB;QACf,IAAI,WAAW;YAAE,MAAO,CAAC,wBAAwB,EAAE,CAAC;IACtD,CAAC;IAED,yEAAyE;IACzE,SAAS;QACP,OAAO,WAAW,CAAC,CAAC,CAAC,MAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;IACnD,CAAC;IAED,wFAAwF;IACxF,IAAI;QACF,IAAI,WAAW;YAAE,MAAO,CAAC,IAAI,EAAE,CAAC;IAClC,CAAC;IAED,+CAA+C;IAC/C,IAAI;QACF,IAAI,WAAW;YAAE,MAAO,CAAC,IAAI,EAAE,CAAC;IAClC,CAAC;CACF,CAAC;AAEF,eAAe,cAAc,CAAC","sourcesContent":["import { requireOptionalNativeModule } from 'expo';\nimport { Platform } from 'react-native';\n\n/**\n * The raw native surface registered by the module on each platform.\n *\n * On Android these are backed by a real `WindowManager` overlay drawn with the\n * SYSTEM_ALERT_WINDOW (\"Display over other apps\") permission. iOS has no public\n * API to draw over other apps, so the native module there is a no-op stub and\n * every method returns a safe default.\n *\n * Prefer the {@link FloatingBubble} façade below — it guards every call so it is\n * safe to invoke on any platform.\n */\nexport type FloatingBubbleNativeModule = {\n  /** Whether the user has granted \"Display over other apps\" (SYSTEM_ALERT_WINDOW). */\n  canDrawOverlays(): boolean;\n  /** Opens the system settings screen to grant the overlay permission. */\n  requestOverlayPermission(): void;\n  /** Whether the bubble is currently on screen. */\n  isVisible(): boolean;\n  /** Show the bubble (no-op without permission, or if already visible). */\n  show(): void;\n  /** Remove the bubble. */\n  hide(): void;\n};\n\nconst isAndroid = Platform.OS === 'android';\n\n// `requireOptionalNativeModule` returns null instead of throwing when the native\n// module isn't in the running binary. That keeps a JS-only/OTA bundle from\n// crashing if it ever lands on an older build that predates this native module —\n// the bubble simply does nothing there. iOS ships a no-op stub of the same name.\nconst native =\n  requireOptionalNativeModule<FloatingBubbleNativeModule>('FloatingBubble');\n\n/**\n * True only where the bubble can actually render: Android, with the native\n * module present in the running binary. Everywhere else every call below is a\n * safe no-op.\n */\nexport const isSupported = isAndroid && native != null;\n\n/**\n * Cross-platform façade over the native module. Safe to call on any platform —\n * on iOS, or on a build without the native module, methods short-circuit to safe\n * defaults instead of throwing.\n */\nexport const FloatingBubble = {\n  /** See {@link isSupported}. */\n  isSupported,\n\n  /** Whether the user has granted \"Display over other apps\". `false` if unsupported. */\n  canDrawOverlays(): boolean {\n    return isSupported ? native!.canDrawOverlays() : false;\n  },\n\n  /** Send the user to the system settings screen to grant the overlay permission. */\n  requestPermission(): void {\n    if (isSupported) native!.requestOverlayPermission();\n  },\n\n  /** Whether the bubble is currently on screen. `false` if unsupported. */\n  isVisible(): boolean {\n    return isSupported ? native!.isVisible() : false;\n  },\n\n  /** Show the bubble. No-op without permission, if already visible, or if unsupported. */\n  show(): void {\n    if (isSupported) native!.show();\n  },\n\n  /** Remove the bubble. No-op if unsupported. */\n  hide(): void {\n    if (isSupported) native!.hide();\n  },\n};\n\nexport default FloatingBubble;\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["FloatingBubbleModule"]
+  },
+  "android": {
+    "modules": ["ai.rastaa.floatingbubble.FloatingBubbleModule"]
+  }
+}

package/ios/FloatingBubble.podspec

@@ -0,0 +1,20 @@
+Pod::Spec.new do |s|
+  s.name           = 'FloatingBubble'
+  s.version        = '0.1.0'
+  s.summary        = 'Back-to-Rastaa floating bubble (Android-only; iOS no-op stub).'
+  s.description    = 'Expo module that draws a return-to-app bubble over other apps on Android.'
+  s.author         = 'Rastaa <tech@rastaa.ai>'
+  s.homepage       = 'https://github.com/rastaa/floating-bubble'
+  s.platforms      = { :ios => '15.1', :tvos => '15.1' }
+  s.source         = { git: 'https://github.com/rastaa/floating-bubble.git', tag: "v#{s.version}" }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/FloatingBubbleModule.swift

@@ -0,0 +1,30 @@
+import ExpoModulesCore
+
+// iOS cannot draw a widget over other apps (no public API), so this is a no-op
+// stub. It exists only so `requireNativeModule('FloatingBubble')` resolves and
+// the JS layer can call the same API on both platforms without crashing.
+public class FloatingBubbleModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("FloatingBubble")
+
+    Function("canDrawOverlays") { () -> Bool in
+      false
+    }
+
+    Function("requestOverlayPermission") {
+      // No-op on iOS.
+    }
+
+    Function("isVisible") { () -> Bool in
+      false
+    }
+
+    Function("show") {
+      // No-op on iOS.
+    }
+
+    Function("hide") {
+      // No-op on iOS.
+    }
+  }
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@parastud/floating-bubble",
+  "version": "0.1.0",
+  "description": "Back-to-Rastaa floating bubble — a draggable circular overlay to jump back into the app from a navigation app. Android only; iOS is a safe no-op stub.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-module",
+    "floating-bubble",
+    "overlay",
+    "system-alert-window",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/parastud/floating-bubble.git"
+  },
+  "bugs": {
+    "url": "https://github.com/parastud/floating-bubble/issues"
+  },
+  "author": "Rastaa <tech@rastaa.ai>",
+  "license": "UNLICENSED",
+  "homepage": "https://github.com/parastud/floating-bubble#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "build",
+    "android",
+    "ios",
+    "expo-module.config.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@types/react": "~19.2.10",
+    "expo": "~55.0.26",
+    "expo-module-scripts": "^55.0.0",
+    "expo-modules-core": "~55.0.25",
+    "react": "19.2.0",
+    "react-native": "0.83.6",
+    "typescript": "~5.9.2"
+  }
+}