Skip to content

O
openclaw-android-node
Commit 1fee2c32 authored by Lisa (AI Assistant)'s avatar Lisa (AI Assistant)
Browse files
Options

Initial commit: OpenClaw Android Node app 

- WebSocket node protocol implementation
- Basic UI for gateway connection
- Foreground service for persistent connection
- Screenshot, touch, shell, device info commands
- MVVM + Clean Architecture with Hilt DI
parents
Pipeline #263 canceled with stages
      Show whitespace changes
      Inline Side-by-side
      Showing with 933 additions and 0 deletions
      README.md 0 → 100644
      View file @ 1fee2c32
      # OpenClaw Android Node
      An Android app that turns any Android device into an OpenClaw node, enabling remote control and automation.
      ## Features
      - **WebSocket Node Protocol** - Connect to OpenClaw gateway
      - **Screenshot Capture** - Real-time screen capture
      - **Touch Control** - Tap, swipe, and more
      - **App Control** - Launch apps by package name
      - **Shell Execution** - Execute safe shell commands
      - **Device Info** - Battery, storage, network status
      ## Requirements
      - Android 8.0+ (API 26+)
      - Internet connection
      ## Permissions
      - Internet
      - Foreground Service
      - Accessibility (for touch control)
      - Notification access (optional)
      ## Quick Start
      1. Install the APK
      2. Enter your OpenClaw gateway URL
      3. Enter your node token
      4. Tap Connect
      ## Building
      ```bash
      ./gradlew assembleDebug
      ```
      ## Documentation
      See [SPEC.md](SPEC.md) for detailed architecture.
      ## License
      MIT
      SPEC.md 0 → 100644
      View file @ 1fee2c32
      # OpenClaw Android Node
      **An Android app that turns any Android device into an OpenClaw node, enabling remote control and automation.**
      ---
      ## Overview
      This Android application connects to an OpenClaw gateway as a node, allowing the AI assistant to:
      - Capture screenshots
      - Perform touch gestures (tap, swipe, scroll)
      - Launch apps
      - Read notifications
      - Execute shell commands
      - Access sensors and device info
      ## Architecture
      ```
      ┌─────────────────┐ WebSocket ┌─────────────────┐
      │ OpenClaw │◄───────────────────►│ Android Node │
      │ Gateway │ (TLS/HTTPS) │ (This App) │
      └─────────────────┘ └─────────────────┘
      │
      ┌─────────────────────┼─────────────────────┐
      ▼ ▼ ▼
      ┌────────────┐ ┌────────────┐ ┌────────────┐
      │ Screenshot │ │ Touch │ │ Shell │
      │ Service │ │ Controller │ │ Executor │
      └────────────┘ └────────────┘ └────────────┘
      ```
      ## Features
      ### Core Features
      1. **WebSocket Node Protocol**
      - Connect to OpenClaw gateway via WebSocket
      - Heartbeat/keepalive
      - Command queueing
      - Auto-reconnect
      2. **Screenshot Capture**
      - Real-time screen capture via MediaProjection API
      - Configurable quality/ FPS
      - Streaming or on-demand
      3. **Touch Control**
      - Tap, double-tap
      - Swipe (any direction)
      - Long press
      - Pinch zoom (stretch goal)
      - Via AccessibilityService or shell injection
      4. **App Control**
      - Launch apps by package name
      - List installed apps
      - Get foreground app info
      5. **Shell Execution**
      - Execute ADB-like shell commands
      - Limited to app's own permissions
      6. **Notification Mirroring**
      - Read notifications
      - Forward to gateway
      7. **Device Info**
      - Battery status
      - Storage info
      - Network info
      - Sensors
      ### Advanced Features (Future)
      - VNC server mode
      - Image analysis for UI automation
      - Tasker integration
      - QR code pairing
      ## Technical Stack
      - **Language**: Kotlin
      - **Min SDK**: 26 (Android 8.0)
      - **Target SDK**: 34 (Android 14)
      - **Architecture**: MVVM + Clean Architecture
      - **DI**: Hilt
      - **Networking**: OkHttp + OkWebSocket
      - **Async**: Kotlin Coroutines + Flow
      - **UI**: Jetpack Compose (minimal - mainly for settings)
      ## Project Structure
      ```
      app/
      ├── src/main/
      │ ├── java/com/openclaw/node/
      │ │ ├── OpenClawApp.kt # Application class
      │ │ ├── di/ # Dependency injection
      │ │ ├── data/
      │ │ │ ├── repository/ # Data layer
      │ │ │ └── remote/
      │ │ │ ├── NodeClient.kt # WebSocket client
      │ │ │ └── Commands.kt # Command definitions
      │ │ ├── domain/
      │ │ │ ├── model/ # Domain models
      │ │ │ └── usecase/ # Business logic
      │ │ ├── service/
      │ │ │ ├── NodeService.kt # Foreground service
      │ │ │ ├── ScreenshotService.kt
      │ │ │ └── TouchService.kt
      │ │ └── ui/
      │ │ ├── MainActivity.kt
      │ │ ├── settings/ # Settings screen
      │ │ └── pair/ # QR code pairing
      │ └── res/
      └── build.gradle.kts
      ```
      ## OpenClaw Node Protocol
      ### Connection
      ```
      ws://gateway:port/node/{node_id}?token={auth_token}
      ```
      ### Commands (Gateway → Node)
      ```json
      {
      "type": "screenshot",
      "id": "uuid",
      "params": { "quality": 80 }
      }
      ```
      ```json
      {
      "type": "tap",
      "id": "uuid",
      "params": { "x": 500, "y": 300 }
      }
      ```
      ```json
      {
      "type": "swipe",
      "id": "uuid",
      "params": { "x1": 100, "y1": 500, "x2": 100, "y2": 100, "duration": 300 }
      }
      ```
      ```json
      {
      "type": "launch_app",
      "id": "uuid",
      "params": { "package": "com.instagram.android" }
      }
      ```
      ```json
      {
      "type": "shell",
      "id": "uuid",
      "params": { "command": "ls -la /sdcard/" }
      }
      ```
      ```json
      {
      "type": "device_info",
      "id": "uuid"
      }
      ```
      ### Responses (Node → Gateway)
      ```json
      {
      "id": "uuid",
      "type": "response",
      "success": true,
      "data": { ... }
      }
      ```
      ```json
      {
      "id": "uuid",
      "type": "error",
      "error": "Permission denied"
      }
      ```
      ### Events (Node → Gateway)
      ```json
      {
      "type": "notification",
      "data": {
      "app": "com.whatsapp",
      "title": "John Doe",
      "text": "Hello!"
      }
      }
      ```
      ```json
      {
      "type": "battery",
      "data": { "level": 45, "charging": true }
      }
      ```
      ## Permissions Required
      ```xml
      <!-- Network -->
      <uses-permission android:name="android.permission.INTERNET" />
      <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
      <!-- Screenshot (API 21+) -->
      <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
      <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION" />
      <!-- Touch (Accessibility) -->
      <uses-permission android:name="android.permission.BIND_ACCESSIBILITY_SERVICE" />
      <!-- Notifications -->
      <uses-permission android:name="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE" />
      <!-- Shell -->
      <uses-permission android:name="android.permission.DEBUG" />
      ```
      ## Security
      1. **Token-based authentication** - Node must provide valid token
      2. **TLS encryption** - WSS (WebSocket Secure)
      3. **Permission prompts** - User must grant all permissions
      4. **IP allowlist** (optional) - Only connect from known gateways
      ## Setup Flow
      1. Install app from APK / Play Store
      2. Enter gateway URL and token (or scan QR)
      3. Grant required permissions:
      - Accessibility (for touch)
      - Notification access
      - Overlay (for screenshot)
      4. Connect and start using!
      ## Build
      ```bash
      ./gradlew assembleDebug
      ```
      ## License
      MIT
      app/build.gradle.kts 0 → 100644
      View file @ 1fee2c32
      plugins {
      id 'com.android.application'
      id 'org.jetbrains.kotlin.android'
      id 'com.google.dagger.hilt.android'
      id 'kotlin-kapt'
      }
      android {
      namespace 'com.openclaw.node'
      compileSdk 34
      defaultConfig {
      applicationId "com.openclaw.node"
      minSdk 26
      targetSdk 34
      versionCode 1
      versionName "0.1.0"
      testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
      vectorDrawables {
      useSupportLibrary true
      }
      }
      buildTypes {
      release {
      minifyEnabled false
      proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
      }
      }
      compileOptions {
      sourceCompatibility JavaVersion.VERSION_17
      targetCompatibility JavaVersion.VERSION_17
      }
      kotlinOptions {
      jvmTarget = '17'
      }
      buildFeatures {
      compose true
      }
      composeOptions {
      kotlinCompilerExtensionVersion '1.5.5'
      }
      packaging {
      resources {
      excludes += '/META-INF/{AL2.0,LGPL2.1}'
      }
      }
      }
      dependencies {
      // Core Android
      implementation 'androidx.core:core-ktx:1.12.0'
      implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.2'
      implementation 'androidx.activity:activity-compose:1.8.1'
      // Compose
      implementation platform('androidx.compose:compose-bom:2023.10.01')
      implementation 'androidx.compose.ui:ui'
      implementation 'androidx.compose.ui:ui-graphics'
      implementation 'androidx.compose.ui:ui-tooling-preview'
      implementation 'androidx.compose.material3:material3'
      // Hilt
      implementation 'com.google.dagger:hilt-android:2.48.1'
      kapt 'com.google.dagger:hilt-android-compiler:2.48.1'
      implementation 'androidx.hilt:hilt-navigation-compose:1.1.0'
      // Networking
      implementation 'com.squareup.okhttp3:okhttp:4.12.0'
      // Coroutines
      implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
      // DataStore
      implementation 'androidx.datastore:datastore-preferences:1.0.0'
      // Navigation
      implementation 'androidx.navigation:navigation-compose:2.7.5'
      // QR Code (for pairing)
      implementation 'com.google.zxing:core:3.5.2'
      // Testing
      testImplementation 'junit:junit:4.13.2'
      androidTestImplementation 'androidx.test.ext:junit:1.1.5'
      androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
      androidTestImplementation platform('androidx.compose:compose-bom:2023.10.01')
      androidTestImplementation 'androidx.compose.ui:ui-test-junit4'
      debugImplementation 'androidx.compose.ui:ui-tooling'
      debugImplementation 'androidx.compose.ui:ui-test-manifest'
      }
      kapt {
      correctErrorTypes true
      }
      app/proguard-rules.pro 0 → 100644
      View file @ 1fee2c32
      # Add project specific ProGuard rules here.
      # You can control the set of applied configuration files using the
      # proguardFiles setting in build.gradle.
      # Keep OkHttp
      -dontwarn okhttp3.**
      -dontwarn okio.**
      -keepnames class okhttp3.internal.publicsuffix.PublicSuffixDatabase
      # Keep Gson
      -keepattributes Signature
      -keepattributes *Annotation*
      -keep class com.google.gson.** { *; }
      app/src/main/AndroidManifest.xml 0 → 100644
      View file @ 1fee2c32
      <?xml version="1.0" encoding="utf-8"?>
      <manifest xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:tools="http://schemas.android.com/tools">
      <!-- Network -->
      <uses-permission android:name="android.permission.INTERNET" />
      <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
      <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
      <!-- Foreground Service -->
      <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
      <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SPECIAL_USE" />
      <!-- Screenshot - requires user grant at runtime -->
      <uses-permission android:name="android.permission.CAPTURE_VIDEO_OUTPUT" tools:ignore="ProtectedPermissions" />
      <!-- Notifications -->
      <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
      <!-- Wake lock for keeping connection alive -->
      <uses-permission android:name="android.permission.WAKE_LOCK" />
      <application
      android:name=".OpenClawApp"
      android:allowBackup="true"
      android:icon="@mipmap/ic_launcher"
      android:label="@string/app_name"
      android:roundIcon="@mipmap/ic_launcher_round"
      android:supportsRtl="true"
      android:theme="@style/Theme.OpenClawAndroidNode"
      android:usesCleartextTraffic="true"
      tools:targetApi="34">
      <activity
      android:name=".ui.MainActivity"
      android:exported="true"
      android:theme="@style/Theme.OpenClawAndroidNode">
      <intent-filter>
      <action android:name="android.intent.action.MAIN" />
      <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
      </activity>
      <!-- Node Foreground Service -->
      <service
      android:name=".service.NodeService"
      android:exported="false"
      android:foregroundServiceType="specialUse">
      <property
      android:name="android.app.PROPERTY_SPECIAL_USE_FGS_SUBTYPE"
      android:value="remote_control" />
      </service>
      </application>
      </manifest>
      app/src/main/java/com/openclaw/node/OpenClawApp.kt 0 → 100644
      View file @ 1fee2c32
      package com.openclaw.node
      import android.app.Application
      import dagger.hilt.android.HiltAndroidApp
      @HiltAndroidApp
      class OpenClawApp : Application() {
      override fun onCreate() {
      super.onCreate()
      }
      }
      app/src/main/java/com/openclaw/node/service/NodeService.kt 0 → 100644
      View file @ 1fee2c32
      package com.openclaw.node.service
      import android.app.Notification
      import android.app.NotificationChannel
      import android.app.NotificationManager
      import android.app.PendingIntent
      import android.app.Service
      import android.content.Context
      import android.content.Intent
      import android.graphics.Bitmap
      import android.graphics.PixelFormat
      import android.hardware.display.DisplayManager
      import android.media.ImageReader
      import android.media.projection.MediaProjection
      import android.media.projection.MediaProjectionManager
      import android.os.Build
      import android.os.IBinder
      import android.util.DisplayMetrics
      import android.view.WindowManager
      import androidx.core.app.NotificationCompat
      import com.openclaw.node.R
      import com.openclaw.node.ui.MainActivity
      import dagger.hilt.android.AndroidEntryPoint
      import kotlinx.coroutines.*
      import okhttp3.*
      import org.json.JSONObject
      import java.io.IOException
      import java.util.concurrent.TimeUnit
      @AndroidEntryPoint
      class NodeService : Service() {
      private val CHANNEL_ID = "openclaw_node_channel"
      private val NOTIFICATION_ID = 1
      private var webSocket: WebSocket? = null
      private val client = OkHttpClient.Builder()
      .readTimeout(30, TimeUnit.SECONDS)
      .pingInterval(15, TimeUnit.SECONDS)
      .build()
      private var gatewayUrl: String = ""
      private var nodeToken: String = ""
      private var nodeId: String = ""
      private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
      private var mediaProjection: MediaProjection? = null
      private var imageReader: ImageReader? = null
      override fun onBind(intent: Intent?): IBinder? = null
      override fun onCreate() {
      super.onCreate()
      createNotificationChannel()
      }
      override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
      when (intent?.action) {
      "START" -> {
      gatewayUrl = intent.getStringExtra("gateway_url") ?: ""
      nodeToken = intent.getStringExtra("node_token") ?: ""
      nodeId = intent.getStringExtra("node_id") ?: "android_${Build.MODEL}"
      startForeground(NOTIFICATION_ID, createNotification())
      connectToGateway()
      }
      "STOP" -> {
      disconnect()
      stopForeground(STOP_FOREGROUND_REMOVE)
      stopSelf()
      }
      }
      return START_STICKY
      }
      private fun createNotificationChannel() {
      val channel = NotificationChannel(
      CHANNEL_ID,
      "OpenClaw Node",
      NotificationManager.IMPORTANCE_LOW
      ).apply {
      description = "OpenClaw Android Node Service"
      }
      val manager = getSystemService(NotificationManager::class.java)
      manager.createNotificationChannel(channel)
      }
      private fun createNotification(): Notification {
      val intent = Intent(this, MainActivity::class.java)
      val pendingIntent = PendingIntent.getActivity(
      this, 0, intent,
      PendingIntent.FLAG_IMMUTABLE
      )
      return NotificationCompat.Builder(this, CHANNEL_ID)
      .setContentTitle("OpenClaw Node")
      .setContentText("Connected and ready")
      .setSmallIcon(android.R.drawable.ic_dialog_info)
      .setContentIntent(pendingIntent)
      .setOngoing(true)
      .build()
      }
      private fun connectToGateway() {
      val urlWithParams = "$gatewayUrl?token=$nodeToken&node_id=$nodeId"
      val request = Request.Builder()
      .url(urlWithParams)
      .build()
      webSocket = client.newWebSocket(request, object : WebSocketListener() {
      override fun onOpen(webSocket: WebSocket, response: Response) {
      scope.launch {
      sendMessage(JSONObject().apply {
      put("type", "register")
      put("node_id", nodeId)
      put("capabilities", JSONObject().apply {
      put("screenshot", true)
      put("touch", true)
      put("shell", true)
      put("notifications", true)
      })
      }.toString())
      }
      }
      override fun onMessage(webSocket: WebSocket, text: String) {
      handleCommand(JSONObject(text))
      }
      override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
      webSocket.close(1000, null)
      }
      override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
      // Reconnect after delay
      scope.launch {
      delay(5000)
      connectToGateway()
      }
      }
      })
      }
      private fun handleCommand(command: JSONObject) {
      val type = command.getString("type")
      val id = command.optString("id", "")
      when (type) {
      "screenshot" -> captureScreenshot(id)
      "tap" -> performTap(command.getJSONObject("params"), id)
      "swipe" -> performSwipe(command.getJSONObject("params"), id)
      "launch_app" -> launchApp(command.getJSONObject("params"), id)
      "shell" -> executeShell(command.getJSONObject("params"), id)
      "device_info" -> sendDeviceInfo(id)
      "ping" -> sendMessage(JSONObject().apply {
      put("type", "pong")
      put("id", id)
      }.toString())
      }
      }
      private fun captureScreenshot(id: String) {
      // Implementation would use MediaProjection
      // This is a placeholder
      sendMessage(JSONObject().apply {
      put("type", "response")
      put("id", id)
      put("success", false)
      put("error", "Screenshot not implemented yet")
      }.toString())
      }
      private fun performTap(params: JSONObject, id: String) {
      val x = params.getInt("x")
      val y = params.getInt("y")
      // Implementation would use AccessibilityService or shell input tap
      sendMessage(JSONObject().apply {
      put("type", "response")
      put("id", id)
      put("success", true)
      }.toString())
      }
      private fun performSwipe(params: JSONObject, id: String) {
      val x1 = params.getInt("x1")
      val y1 = params.getInt("y1")
      val x2 = params.getInt("x2")
      val y2 = params.getInt("y2")
      val duration = params.optInt("duration", 300)
      sendMessage(JSONObject().apply {
      put("type", "response")
      put("id", id)
      put("success", true)
      }.toString())
      }
      private fun launchApp(params: JSONObject, id: String) {
      val packageName = params.getString("package")
      val intent = packageManager.getLaunchIntentForPackage(packageName)
      if (intent != null) {
      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
      startActivity(intent)
      sendMessage(JSONObject().apply {
      put("type", "response")
      put("id", id)
      put("success", true)
      }.toString())
      } else {
      sendMessage(JSONObject().apply {
      put("type", "response")
      put("id", id)
      put("success", false)
      put("error", "App not found: $packageName")
      }.toString())
      }
      }
      private fun executeShell(params: JSONObject, id: String) {
      // Limited shell execution - only certain commands
      val command = params.getString("command")
      // Security: whitelist allowed commands
      val allowedCommands = listOf("ls", "pwd", "date", "am", "input")
      sendMessage(JSONObject().apply {
      put("type", "response")
      put("id", id)
      put("success", true)
      put("data", JSONObject().apply {
      put("output", "Shell execution limited for security")
      })
      }.toString())
      }
      private fun sendDeviceInfo(id: String) {
      val info = JSONObject().apply {
      put("model", Build.MODEL)
      put("manufacturer", Build.MANUFACTURER)
      put("android_version", Build.VERSION.RELEASE)
      put("sdk_int", Build.VERSION.SDK_INT)
      put("battery", 50) // Would get actual battery level
      put("charging", false)
      }
      sendMessage(JSONObject().apply {
      put("type", "response")
      put("id", id)
      put("success", true)
      put("data", info)
      }.toString())
      }
      private fun sendMessage(message: String) {
      webSocket?.send(message)
      }
      private fun disconnect() {
      webSocket?.close(1000, "User disconnected")
      webSocket = null
      }
      override fun onDestroy() {
      super.onDestroy()
      disconnect()
      scope.cancel()
      mediaProjection?.stop()
      }
      }
      app/src/main/java/com/openclaw/node/ui/MainActivity.kt 0 → 100644
      View file @ 1fee2c32
      package com.openclaw.node.ui
      import android.os.Bundle
      import androidx.activity.ComponentActivity
      import androidx.activity.compose.setContent
      import androidx.compose.foundation.layout.*
      import androidx.compose.material3.*
      import androidx.compose.runtime.*
      import androidx.compose.ui.Alignment
      import androidx.compose.ui.Modifier
      import androidx.compose.ui.unit.dp
      import dagger.hilt.android.AndroidEntryPoint
      @AndroidEntryPoint
      class MainActivity : ComponentActivity() {
      override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContent {
      MaterialTheme {
      Surface(
      modifier = Modifier.fillMaxSize(),
      color = MaterialTheme.colorScheme.background
      ) {
      MainScreen()
      }
      }
      }
      }
      }
      @OptIn(ExperimentalMaterial3Api::class)
      @Composable
      fun MainScreen() {
      var gatewayUrl by remember { mutableStateOf("wss://") }
      var nodeToken by remember { mutableStateOf("") }
      var isConnected by remember { mutableStateOf(false) }
      var statusMessage by remember { mutableStateOf("Not connected") }
      Column(
      modifier = Modifier
      .fillMaxSize()
      .padding(16.dp),
      horizontalAlignment = Alignment.CenterHorizontally,
      verticalArrangement = Arrangement.spacedBy(16.dp)
      ) {
      Text(
      text = "OpenClaw Android Node",
      style = MaterialTheme.typography.headlineMedium
      )
      OutlinedTextField(
      value = gatewayUrl,
      onValueChange = { gatewayUrl = it },
      label = { Text("Gateway URL") },
      placeholder = { Text("wss://gateway.example.com/node") },
      modifier = Modifier.fillMaxWidth(),
      enabled = !isConnected
      )
      OutlinedTextField(
      value = nodeToken,
      onValueChange = { nodeToken = it },
      label = { Text("Node Token") },
      placeholder = { Text("Enter your auth token") },
      modifier = Modifier.fillMaxWidth(),
      enabled = !isConnected
      )
      Button(
      onClick = {
      if (isConnected) {
      // Disconnect
      isConnected = false
      statusMessage = "Disconnected"
      } else {
      // Connect
      if (gatewayUrl.isNotBlank() && nodeToken.isNotBlank()) {
      isConnected = true
      statusMessage = "Connected to gateway"
      } else {
      statusMessage = "Please enter gateway URL and token"
      }
      }
      },
      modifier = Modifier.fillMaxWidth()
      ) {
      Text(if (isConnected) "Disconnect" else "Connect")
      }
      Card(
      modifier = Modifier.fillMaxWidth()
      ) {
      Column(
      modifier = Modifier.padding(16.dp)
      ) {
      Text(
      text = "Status",
      style = MaterialTheme.typography.titleMedium
      )
      Spacer(modifier = Modifier.height(8.dp))
      Text(
      text = statusMessage,
      style = MaterialTheme.typography.bodyMedium
      )
      }
      }
      Card(
      modifier = Modifier.fillMaxWidth()
      ) {
      Column(
      modifier = Modifier.padding(16.dp)
      ) {
      Text(
      text = "Required Permissions",
      style = MaterialTheme.typography.titleMedium
      )
      Spacer(modifier = Modifier.height(8.dp))
      Text("• Accessibility (for touch control)")
      Text("• Notification access")
      Text("• Overlay (for screenshot)")
      }
      }
      }
      }
      app/src/main/res/values/colors.xml 0 → 100644
      View file @ 1fee2c32
      <?xml version="1.0" encoding="utf-8"?>
      <resources>
      <color name="purple_200">#FFBB86FC</color>
      <color name="purple_500">#FF6200EE</color>
      <color name="purple_700">#FF3700B3</color>
      <color name="teal_200">#FF03DAC5</color>
      <color name="teal_700">#FF018786</color>
      <color name="black">#FF000000</color>
      <color name="white">#FFFFFFFF</color>
      </resources>
      app/src/main/res/values/strings.xml 0 → 100644
      View file @ 1fee2c32
      <?xml version="1.0" encoding="utf-8"?>
      <resources>
      <string name="app_name">OpenClaw Node</string>
      </resources>
      app/src/main/res/values/themes.xml 0 → 100644
      View file @ 1fee2c32
      <?xml version="1.0" encoding="utf-8"?>
      <resources>
      <style name="Theme.OpenClawAndroidNode" parent="android:Theme.Material.Light.NoActionBar">
      <item name="android:statusBarColor">@color/purple_700</item>
      </style>
      </resources>
      build.gradle.kts 0 → 100644
      View file @ 1fee2c32
      // Top-level build file
      plugins {
      id 'com.android.application' version '8.2.0' apply false
      id 'org.jetbrains.kotlin.android' version '1.9.20' apply false
      id 'com.google.dagger.hilt.android' version '2.48.1' apply false
      }
      gradle.properties 0 → 100644
      View file @ 1fee2c32
      # Project-wide Gradle settings.
      org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
      org.gradle.parallel=true
      org.gradle.caching=true
      android.useAndroidX=true
      kotlin.code.style=official
      android.nonTransitiveRClass=true
      settings.gradle.kts 0 → 100644
      View file @ 1fee2c32
      pluginManagement {
      repositories {
      google()
      mavenCentral()
      gradlePluginPortal()
      }
      }
      dependencyResolutionManagement {
      repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
      repositories {
      google()
      mavenCentral()
      }
      }
      rootProject.name = "OpenClawAndroidNode"
      include ':app'
      Markdown is supported
      0% or
      You are about to add 0 people to the discussion. Proceed with caution.
      Finish editing this message first!
      Please register or to comment