From 874a243e80a220ef8389e0ca427b27add31bdb76 Mon Sep 17 00:00:00 2001 From: jahruz67 Date: Sat, 25 Jul 2026 17:44:27 -0700 Subject: [PATCH] Add new XML layout files for view settings, view settings v2, and voice interface - Created view_settings.xml to define the layout for the settings view. - Added view_settings_v2.xml for an updated version of the settings layout. - Introduced view_voice.xml to establish the layout for the voice interface. --- .gitignore | 1 + app/src/main/AndroidManifest.xml | 19 + .../ambient/launcher/BluetoothController.kt | 179 ++++++ .../com/ambient/launcher/KeepAwakeService.kt | 134 ++++ .../com/ambient/launcher/LauncherViewModel.kt | 85 ++- .../java/com/ambient/launcher/MainActivity.kt | 594 ++++++++++++++---- .../main/java/com/ambient/launcher/Models.kt | 52 +- .../com/ambient/launcher/SettingsStore.kt | 11 +- .../voice/DefaultAssistantLauncher.kt | 21 +- .../launcher/voice/WakeWordController.kt | 23 +- .../ambient/launcher/voice/WakeWordModel.kt | 69 +- .../ambient/launcher/voice/WakeWordService.kt | 51 +- .../main/res/drawable/ambient_fallback.xml | 29 +- app/src/main/res/values-es/strings.xml | 191 ++++++ app/src/main/res/values/strings.xml | 188 ++++++ gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 46175 bytes gradle/wrapper/gradle-wrapper.properties | 7 + gradlew | 248 ++++++++ gradlew.bat | 93 +++ view.xml | 1 + view_home.xml | 1 + view_launcher.xml | 1 + view_launcher_v2.xml | 1 + view_launcher_v3.xml | 1 + view_settings.xml | 1 + view_settings_v2.xml | 1 + view_voice.xml | 1 + 27 files changed, 1793 insertions(+), 210 deletions(-) create mode 100644 app/src/main/java/com/ambient/launcher/BluetoothController.kt create mode 100644 app/src/main/java/com/ambient/launcher/KeepAwakeService.kt create mode 100644 app/src/main/res/values-es/strings.xml create mode 100644 gradle/wrapper/gradle-wrapper.jar create mode 100644 gradle/wrapper/gradle-wrapper.properties create mode 100644 gradlew create mode 100644 gradlew.bat create mode 100644 view.xml create mode 100644 view_home.xml create mode 100644 view_launcher.xml create mode 100644 view_launcher_v2.xml create mode 100644 view_launcher_v3.xml create mode 100644 view_settings.xml create mode 100644 view_settings_v2.xml create mode 100644 view_voice.xml diff --git a/.gitignore b/.gitignore index ee92525..529a458 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ captures/ .externalNativeBuild/ .cxx/ app/release/ +.artifacts \ No newline at end of file diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 1b42ddc..932ead1 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -5,14 +5,23 @@ + + + + + + + + + + + + + diff --git a/app/src/main/java/com/ambient/launcher/BluetoothController.kt b/app/src/main/java/com/ambient/launcher/BluetoothController.kt new file mode 100644 index 0000000..ab7f8c2 --- /dev/null +++ b/app/src/main/java/com/ambient/launcher/BluetoothController.kt @@ -0,0 +1,179 @@ +package com.ambient.launcher + +import android.annotation.SuppressLint +import android.bluetooth.BluetoothAdapter +import android.bluetooth.BluetoothManager +import android.bluetooth.BluetoothProfile +import android.content.BroadcastReceiver +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.media.AudioAttributes +import android.media.AudioFocusRequest +import android.media.AudioManager +import android.media.session.MediaSession +import android.media.session.PlaybackState +import android.util.Log +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +class BluetoothController(private val context: Context) { + private val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager + private val bluetoothAdapter: BluetoothAdapter? = bluetoothManager.adapter + private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager + + private val _status = MutableStateFlow(BluetoothSnapshot()) + val status: StateFlow = _status.asStateFlow() + + private var a2dpSinkProxy: BluetoothProfile? = null + private var avrcpControllerProxy: BluetoothProfile? = null + private var mediaSession: MediaSession? = null + + private val A2DP_SINK = 11 + private val AVRCP_CONTROLLER = 12 + + private fun stateName(state: Int): String = when (state) { + BluetoothProfile.STATE_DISCONNECTED -> "DISCONNECTED" + BluetoothProfile.STATE_CONNECTING -> "CONNECTING" + BluetoothProfile.STATE_CONNECTED -> "CONNECTED" + BluetoothProfile.STATE_DISCONNECTING -> "DISCONNECTING" + else -> "UNKNOWN($state)" + } + + // Track the device that is currently connected so we don't interfere with it + private var lastConnectedDevice: android.bluetooth.BluetoothDevice? = null + + private val profileListener = object : BluetoothProfile.ServiceListener { + override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) { + when (profile) { + A2DP_SINK -> { + a2dpSinkProxy = proxy + Log.d("BluetoothController", "A2DP Sink proxy connected") + updateConnectionState() + } + } + } + + override fun onServiceDisconnected(profile: Int) { + when (profile) { + A2DP_SINK -> { + a2dpSinkProxy = null + Log.d("BluetoothController", "A2DP Sink proxy disconnected") + } + } + updateConnectionState() + } + } + + private val receiver = object : BroadcastReceiver() { + override fun onReceive(context: Context, intent: Intent) { + Log.d("BluetoothController", "Received broadcast: ${intent.action}") + when (intent.action) { + "android.bluetooth.a2dp-sink.profile.action.CONNECTION_STATE_CHANGED" -> { + val state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, -1) + val prevState = intent.getIntExtra(BluetoothProfile.EXTRA_PREVIOUS_STATE, -1) + val device = intent.getParcelableExtra( + BluetoothDeviceExtra + ) + Log.i("BluetoothController", "A2DP Sink ${stateName(prevState)} -> ${stateName(state)} device=$device") + + when (state) { + BluetoothProfile.STATE_CONNECTED -> { + lastConnectedDevice = device + updateConnectionState() + } + BluetoothProfile.STATE_DISCONNECTED -> { + if (device == lastConnectedDevice) { + lastConnectedDevice = null + } + updateConnectionState() + } + else -> updateConnectionState() + } + } + BluetoothAdapter.ACTION_STATE_CHANGED -> { + updateBluetoothState() + } + } + } + } + + init { + setupMediaSession() + if (bluetoothAdapter == null) { + _status.value = _status.value.copy(isSupported = false) + } else { + updateBluetoothState() + bluetoothAdapter.getProfileProxy(context, profileListener, A2DP_SINK) + + val filter = IntentFilter().apply { + addAction("android.bluetooth.a2dp-sink.profile.action.CONNECTION_STATE_CHANGED") + addAction(BluetoothAdapter.ACTION_STATE_CHANGED) + } + context.registerReceiver(receiver, filter) + } + } + + private fun setupMediaSession() { + mediaSession = MediaSession(context, "AmbientLauncher").apply { + setCallback(object : MediaSession.Callback() { + // Diagnostic: Media controls disabled + }) + val state = PlaybackState.Builder() + .setActions(0) + .setState(PlaybackState.STATE_STOPPED, PlaybackState.PLAYBACK_POSITION_UNKNOWN, 1.0f) + .build() + setPlaybackState(state) + isActive = false // Diagnostic: Do not activate by default + } + Log.d("BluetoothController", "MediaSession initialized (inactive)") + } + + private fun updateBluetoothState() { + val enabled = bluetoothAdapter?.isEnabled == true + _status.value = _status.value.copy(isEnabled = enabled) + } + + @SuppressLint("MissingPermission") + private fun updateConnectionState() { + val sinkProxy = a2dpSinkProxy + val devices = sinkProxy?.connectedDevices ?: emptyList() + val device = devices.firstOrNull() + + // Diagnostic build: No audio focus request or media session activation + + _status.value = _status.value.copy( + connectedDeviceName = device?.name ?: device?.address + ) + } + + fun play() { /* Diagnostic stub */ } + fun pause() { /* Diagnostic stub */ } + fun next() { /* Diagnostic stub */ } + fun previous() { /* Diagnostic stub */ } + + fun release() { + runCatching { context.unregisterReceiver(receiver) } + bluetoothAdapter?.closeProfileProxy(A2DP_SINK, a2dpSinkProxy) + mediaSession?.release() + mediaSession = null + Log.d("BluetoothController", "Released resources and media session") + } +} + +/** + * Extra name for the BluetoothDevice parcelable in A2DP Sink broadcasts. + * On older Android versions the extra may use BluetoothDevice.EXTRA_DEVICE; + * this handles both. + */ +private val BluetoothDeviceExtra: String by lazy { + try { + // Use the standard BluetoothDevice.EXTRA_DEVICE constant + android.bluetooth.BluetoothDevice::class.java + .getField("EXTRA_DEVICE") + .get(null) as String + } catch (_: Exception) { + "android.bluetooth.device.extra.DEVICE" + } +} \ No newline at end of file diff --git a/app/src/main/java/com/ambient/launcher/KeepAwakeService.kt b/app/src/main/java/com/ambient/launcher/KeepAwakeService.kt new file mode 100644 index 0000000..2859e0e --- /dev/null +++ b/app/src/main/java/com/ambient/launcher/KeepAwakeService.kt @@ -0,0 +1,134 @@ +package com.ambient.launcher + +import android.app.Notification +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.PendingIntent +import android.app.Service +import android.content.BroadcastReceiver +import android.content.Context +import android.content.Intent +import android.content.IntentFilter +import android.content.pm.ServiceInfo +import android.os.BatteryManager +import android.os.Build +import android.os.IBinder +import android.os.PowerManager +import androidx.core.app.NotificationCompat +import androidx.core.app.ServiceCompat + +class KeepAwakeService : Service() { + private var wakeLock: PowerManager.WakeLock? = null + private var mode: KeepAwakeMode = KeepAwakeMode.SYSTEM_DEFAULT + private var charging: Boolean = false + + private val batteryReceiver = object : BroadcastReceiver() { + override fun onReceive(context: Context?, intent: Intent?) { + val status = intent?.getIntExtra(BatteryManager.EXTRA_STATUS, -1) + charging = status == BatteryManager.BATTERY_STATUS_CHARGING || + status == BatteryManager.BATTERY_STATUS_FULL + updateWakeLock() + } + } + + override fun onCreate() { + super.onCreate() + createNotificationChannel() + val powerManager = getSystemService(POWER_SERVICE) as PowerManager + wakeLock = powerManager.newWakeLock( + PowerManager.SCREEN_BRIGHT_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP, + "AmbientLauncher:KeepAwakeGlobal" + ) + val filter = IntentFilter(Intent.ACTION_BATTERY_CHANGED) + registerReceiver(batteryReceiver, filter) + } + + override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { + val modeName = intent?.getStringExtra(EXTRA_MODE) + mode = KeepAwakeMode.entries.find { it.name == modeName } ?: KeepAwakeMode.SYSTEM_DEFAULT + + if (mode == KeepAwakeMode.SYSTEM_DEFAULT || mode == KeepAwakeMode.WHILE_VISIBLE) { + stopSelf() + return START_NOT_STICKY + } + + promoteToForeground() + updateWakeLock() + return START_STICKY + } + + private fun updateWakeLock() { + val shouldKeep = when (mode) { + KeepAwakeMode.ALWAYS -> true + KeepAwakeMode.WHILE_CHARGING -> charging + else -> false + } + + if (shouldKeep) { + if (wakeLock?.isHeld == false) { + wakeLock?.acquire() + } + } else { + if (wakeLock?.isHeld == true) { + wakeLock?.release() + } + } + } + + private fun promoteToForeground() { + val type = if (Build.VERSION.SDK_INT >= 34) { + ServiceInfo.FOREGROUND_SERVICE_TYPE_SPECIAL_USE + } else 0 + + ServiceCompat.startForeground( + this, + NOTIFICATION_ID, + createNotification(), + type + ) + } + + private fun createNotification(): Notification { + val intent = Intent(this, MainActivity::class.java) + val pendingIntent = PendingIntent.getActivity( + this, 0, intent, + PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT + ) + + return NotificationCompat.Builder(this, CHANNEL_ID) + .setContentTitle(getString(R.string.notification_keep_awake_title)) + .setContentText(getString(R.string.notification_keep_awake_text)) + .setSmallIcon(R.drawable.ic_launcher) + .setContentIntent(pendingIntent) + .setOngoing(true) + .build() + } + + private fun createNotificationChannel() { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { + val channel = NotificationChannel( + CHANNEL_ID, + "Keep Awake Service", + NotificationManager.IMPORTANCE_LOW + ) + val manager = getSystemService(NotificationManager::class.java) + manager.createNotificationChannel(channel) + } + } + + override fun onDestroy() { + unregisterReceiver(batteryReceiver) + if (wakeLock?.isHeld == true) { + wakeLock?.release() + } + super.onDestroy() + } + + override fun onBind(intent: Intent?): IBinder? = null + + companion object { + const val EXTRA_MODE = "mode" + private const val CHANNEL_ID = "keep_awake_channel" + private const val NOTIFICATION_ID = 888 + } +} diff --git a/app/src/main/java/com/ambient/launcher/LauncherViewModel.kt b/app/src/main/java/com/ambient/launcher/LauncherViewModel.kt index 031ee1b..b817c94 100644 --- a/app/src/main/java/com/ambient/launcher/LauncherViewModel.kt +++ b/app/src/main/java/com/ambient/launcher/LauncherViewModel.kt @@ -4,6 +4,7 @@ import android.app.Application import android.content.ComponentName import android.content.Intent import android.content.pm.PackageManager +import android.location.Geocoder import androidx.documentfile.provider.DocumentFile import androidx.lifecycle.AndroidViewModel import androidx.lifecycle.viewModelScope @@ -17,26 +18,22 @@ import kotlinx.coroutines.flow.collectLatest import kotlinx.coroutines.launch import kotlinx.coroutines.withContext -data class LauncherUiState( - val settings: LauncherSettings = LauncherSettings(), - val apps: List = emptyList(), - val localImages: List = emptyList(), - val weather: WeatherNow? = null, - val weatherLoading: Boolean = false, - val weatherError: String? = null, - val wakeWord: WakeWordSnapshot = WakeWordSnapshot() -) - class LauncherViewModel(application: Application) : AndroidViewModel(application) { private val store = SettingsStore(application) private val weatherRepository = WeatherRepository() private val wakeWordController = WakeWordController(application) + // private val bluetoothController = BluetoothController(application) private val _uiState = MutableStateFlow(LauncherUiState()) val uiState: StateFlow = _uiState.asStateFlow() private var settingsLoaded = false init { loadApps() + /* viewModelScope.launch { + bluetoothController.status.collectLatest { status -> + _uiState.value = _uiState.value.copy(bluetooth = status) + } + } */ viewModelScope.launch { wakeWordController.status.collectLatest { status -> _uiState.value = _uiState.value.copy(wakeWord = status) @@ -63,7 +60,10 @@ class LauncherViewModel(application: Application) : AndroidViewModel(application _uiState.value = _uiState.value.copy(settings = settings) wakeWordController.configure( settings.wakeWord.enabled, - settings.wakeWord.sensitivity + settings.wakeWord.sensitivity, + settings.wakeWord.autoCloseSeconds, + settings.wakeWord.toggleClose, + settings.language ) if ( _uiState.value.wakeWord.modelState == ModelInstallState.READY && @@ -111,17 +111,36 @@ class LauncherViewModel(application: Application) : AndroidViewModel(application fun refreshWeather() { val settings = _uiState.value.settings - val lat = settings.latitude.toDoubleOrNull() - val lon = settings.longitude.toDoubleOrNull() - if (lat == null || lon == null || lat !in -90.0..90.0 || lon !in -180.0..180.0) { - _uiState.value = _uiState.value.copy( - weatherLoading = false, - weatherError = "Enter valid latitude and longitude." - ) - return - } viewModelScope.launch { _uiState.value = _uiState.value.copy(weatherLoading = true, weatherError = null) + + val (lat, lon) = withContext(Dispatchers.IO) { + val latD = settings.latitude.toDoubleOrNull() + val lonD = settings.longitude.toDoubleOrNull() + + if (latD != null && lonD != null && latD in -90.0..90.0 && lonD in -180.0..180.0) { + latD to lonD + } else if (settings.locationName.isNotBlank()) { + runCatching { + @Suppress("DEPRECATION") + Geocoder(getApplication()).getFromLocationName(settings.locationName, 1) + ?.firstOrNull() + ?.let { it.latitude to it.longitude } + }.getOrNull() + } else null + } ?: run { + _uiState.value = _uiState.value.copy( + weatherLoading = false, + weatherError = "Enter a city name or valid coordinates." + ) + return@launch + } + + // Update settings with found coordinates if they were missing/different + if (settings.latitude != lat.toString() || settings.longitude != lon.toString()) { + updateSettings { it.copy(latitude = lat.toString(), longitude = lon.toString()) } + } + runCatching { weatherRepository.load(lat, lon, settings.useFahrenheit) } .onSuccess { _uiState.value = _uiState.value.copy( @@ -154,10 +173,31 @@ class LauncherViewModel(application: Application) : AndroidViewModel(application } } + fun setWakeWordAutoClose(seconds: Int) { + updateSettings { settings -> + settings.copy(wakeWord = settings.wakeWord.copy(autoCloseSeconds = seconds)) + } + } + + fun setWakeWordToggleClose(enabled: Boolean) { + updateSettings { settings -> + settings.copy(wakeWord = settings.wakeWord.copy(toggleClose = enabled)) + } + } + + fun setLanguage(language: AppLanguage) { + updateSettings { it.copy(language = language) } + } + fun pauseWakeWord() = wakeWordController.pause() fun resumeWakeWord() = wakeWordController.resume() fun testWakeWord() = wakeWordController.testDetection() + fun bluetoothPlay() { /* bluetoothController.play() */ } + fun bluetoothPause() { /* bluetoothController.pause() */ } + fun bluetoothNext() { /* bluetoothController.next() */ } + fun bluetoothPrevious() { /* bluetoothController.previous() */ } + fun launch(app: LauncherApp): Boolean { val intent = Intent(Intent.ACTION_MAIN) .addCategory(Intent.CATEGORY_LAUNCHER) @@ -168,6 +208,11 @@ class LauncherViewModel(application: Application) : AndroidViewModel(application }.isSuccess } + override fun onCleared() { + // bluetoothController.release() + super.onCleared() + } + private fun loadApps() { viewModelScope.launch { val result = withContext(Dispatchers.IO) { diff --git a/app/src/main/java/com/ambient/launcher/MainActivity.kt b/app/src/main/java/com/ambient/launcher/MainActivity.kt index 608935a..30e7754 100644 --- a/app/src/main/java/com/ambient/launcher/MainActivity.kt +++ b/app/src/main/java/com/ambient/launcher/MainActivity.kt @@ -1,6 +1,8 @@ package com.ambient.launcher import android.Manifest +import android.bluetooth.BluetoothAdapter +import android.bluetooth.BluetoothManager import android.app.role.RoleManager import android.content.BroadcastReceiver import android.content.Context @@ -15,6 +17,7 @@ import android.provider.Settings import android.view.WindowManager import androidx.activity.ComponentActivity import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.compose.setContent import androidx.activity.enableEdgeToEdge import androidx.activity.result.contract.ActivityResultContracts import androidx.activity.viewModels @@ -53,16 +56,25 @@ import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.Add import androidx.compose.material.icons.filled.Apps import androidx.compose.material.icons.filled.ArrowBack +import androidx.compose.material.icons.filled.Bluetooth import androidx.compose.material.icons.filled.Check import androidx.compose.material.icons.filled.Close import androidx.compose.material.icons.filled.Home -import androidx.compose.material.icons.filled.Image as ImageIcon +import androidx.compose.material.icons.filled.Image import androidx.compose.material.icons.filled.Info import androidx.compose.material.icons.filled.Mic +import androidx.compose.material.icons.filled.Pause +import androidx.compose.material.icons.filled.PlayArrow import androidx.compose.material.icons.filled.Refresh import androidx.compose.material.icons.filled.Search import androidx.compose.material.icons.filled.Settings +import androidx.compose.material.icons.filled.SkipNext +import androidx.compose.material.icons.filled.SkipPrevious +import androidx.compose.material.icons.filled.Translate import androidx.compose.material.icons.filled.VolumeUp +import androidx.compose.ui.res.stringResource +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.runtime.staticCompositionLocalOf import androidx.compose.material3.AlertDialog import androidx.compose.material3.Button import androidx.compose.material3.Card @@ -150,13 +162,17 @@ class MainActivity : ComponentActivity() { } setContent { AmbientTheme { - val state by viewModel.uiState.collectAsStateWithLifecycle() - KeepAwakeEffect(state.settings.keepAwakeMode) - AmbientLauncherApp( - state = state, - viewModel = viewModel, - requestHomeRole = ::requestHomeRole - ) + Surface(color = MaterialTheme.colorScheme.background) { + val state by viewModel.uiState.collectAsStateWithLifecycle() + CompositionLocalProvider(LocalAppLanguage provides state.settings.language) { + KeepAwakeEffect(state.settings.keepAwakeMode) + AmbientLauncherApp( + state = state, + viewModel = viewModel, + requestHomeRole = ::requestHomeRole + ) + } + } } } } @@ -190,9 +206,15 @@ private fun AmbientTheme(content: @Composable () -> Unit) { MaterialTheme( colorScheme = androidx.compose.material3.darkColorScheme( primary = Color(0xFFB9D9FF), + onPrimary = Color(0xFF1B2D44), secondary = Color(0xFFB8C8DA), + onSecondary = Color(0xFF233140), surface = Color(0xFF11161D), - surfaceVariant = Color(0xFF202832) + onSurface = Color(0xFFE1E2E8), + surfaceVariant = Color(0xFF202832), + onSurfaceVariant = Color(0xFFC1C7CE), + background = Color(0xFF000000), + onBackground = Color(0xFFE1E2E8) ), content = content ) @@ -203,23 +225,36 @@ private fun KeepAwakeEffect(mode: KeepAwakeMode) { val context = LocalContext.current val view = LocalView.current var charging by remember { mutableStateOf(false) } - DisposableEffect(context) { + DisposableEffect(context, mode) { + val serviceIntent = Intent(context, KeepAwakeService::class.java).apply { + putExtra(KeepAwakeService.EXTRA_MODE, mode.name) + } + + if (mode == KeepAwakeMode.ALWAYS || mode == KeepAwakeMode.WHILE_CHARGING) { + ContextCompat.startForegroundService(context, serviceIntent) + } else { + context.stopService(serviceIntent) + } + fun update(intent: Intent?) { val status = intent?.getIntExtra(BatteryManager.EXTRA_STATUS, -1) charging = status == BatteryManager.BATTERY_STATUS_CHARGING || - status == BatteryManager.BATTERY_STATUS_FULL + status == BatteryManager.BATTERY_STATUS_FULL } val receiver = object : BroadcastReceiver() { override fun onReceive(context: Context?, intent: Intent?) = update(intent) } val filter = IntentFilter(Intent.ACTION_BATTERY_CHANGED) update(context.registerReceiver(receiver, filter)) - onDispose { runCatching { context.unregisterReceiver(receiver) } } + onDispose { + runCatching { context.unregisterReceiver(receiver) } + } } LaunchedEffect(mode, charging, view) { view.keepScreenOn = when (mode) { KeepAwakeMode.WHILE_VISIBLE -> true KeepAwakeMode.WHILE_CHARGING -> charging + KeepAwakeMode.ALWAYS -> true KeepAwakeMode.SYSTEM_DEFAULT -> false } } @@ -241,7 +276,11 @@ private fun AmbientLauncherApp( onSettings = { screen = Screen.SETTINGS }, onRefreshWeather = viewModel::refreshWeather, onTogglePinned = viewModel::togglePinned, - onLaunchApp = viewModel::launch + onLaunchApp = viewModel::launch, + onBluetoothPlay = viewModel::bluetoothPlay, + onBluetoothPause = viewModel::bluetoothPause, + onBluetoothNext = viewModel::bluetoothNext, + onBluetoothPrevious = viewModel::bluetoothPrevious ) Screen.SETTINGS -> SettingsScreen( state = state, @@ -252,6 +291,9 @@ private fun AmbientLauncherApp( requestHomeRole = requestHomeRole, setWakeWordEnabled = viewModel::setWakeWordEnabled, setWakeWordSensitivity = viewModel::setWakeWordSensitivity, + setWakeWordAutoClose = viewModel::setWakeWordAutoClose, + setWakeWordToggleClose = viewModel::setWakeWordToggleClose, + setLanguage = viewModel::setLanguage, pauseWakeWord = viewModel::pauseWakeWord, resumeWakeWord = viewModel::resumeWakeWord, testWakeWord = viewModel::testWakeWord @@ -277,7 +319,11 @@ private fun HomeScreen( onSettings: () -> Unit, onRefreshWeather: () -> Unit, onTogglePinned: (LauncherApp) -> Unit, - onLaunchApp: (LauncherApp) -> Boolean + onLaunchApp: (LauncherApp) -> Boolean, + onBluetoothPlay: () -> Unit, + onBluetoothPause: () -> Unit, + onBluetoothNext: () -> Unit, + onBluetoothPrevious: () -> Unit ) { var trayOpen by remember { mutableStateOf(false) } var photoIndex by rememberSaveable { mutableIntStateOf(0) } @@ -327,13 +373,13 @@ private fun HomeScreen( targetState = if (showWeatherCard) "weather" else "photo-$photoIndex", animationSpec = tween(1_400), label = "slideshow" - ) { - if (showWeatherCard && state.weather != null) { + ) { currentTarget -> + if (currentTarget == "weather" && state.weather != null) { FullWeatherSlide(state.weather, state.settings) } else if (sources.isNotEmpty()) { AsyncImage( model = sources[photoIndex % sources.size], - contentDescription = "Ambient photograph", + contentDescription = appStringResource(R.string.ambient_photograph), placeholder = painterResource(R.drawable.ambient_fallback), error = painterResource(R.drawable.ambient_fallback), contentScale = ContentScale.Crop, @@ -367,14 +413,14 @@ private fun HomeScreen( modifier = Modifier.align(Alignment.TopStart).padding(24.dp), colors = translucentIconColors() ) { - Icon(Icons.Default.Apps, "Open applications") + Icon(Icons.Default.Apps, appStringResource(R.string.open_apps)) } FilledIconButton( onClick = onSettings, modifier = Modifier.align(Alignment.TopEnd).padding(24.dp), colors = translucentIconColors() ) { - Icon(Icons.Default.Settings, "Open settings") + Icon(Icons.Default.Settings, appStringResource(R.string.open_settings)) } if (!showWeatherCard) { @@ -386,6 +432,17 @@ private fun HomeScreen( onRefresh = onRefreshWeather, modifier = clockAlignment(state.settings.clockCorner) ) + + /* if (state.bluetooth.connectedDeviceName != null && !nightActive) { + MediaWidget( + state = state.bluetooth, + onPlay = onBluetoothPlay, + onPause = onBluetoothPause, + onNext = onBluetoothNext, + onPrevious = onBluetoothPrevious, + modifier = mediaAlignment(state.settings.clockCorner) + ) + } */ } } @@ -416,6 +473,90 @@ private fun clockAlignment(corner: ClockCorner): Modifier = when (corner) { ClockCorner.TOP_RIGHT -> Modifier.fillMaxSize().padding(28.dp, 92.dp).wrapContentSize(Alignment.TopEnd) } +private fun mediaAlignment(corner: ClockCorner): Modifier = when (corner) { + ClockCorner.BOTTOM_LEFT -> Modifier.fillMaxSize().padding(28.dp).wrapContentSize(Alignment.BottomEnd) + ClockCorner.BOTTOM_RIGHT -> Modifier.fillMaxSize().padding(28.dp).wrapContentSize(Alignment.BottomStart) + ClockCorner.TOP_LEFT -> Modifier.fillMaxSize().padding(28.dp, 92.dp).wrapContentSize(Alignment.TopEnd) + ClockCorner.TOP_RIGHT -> Modifier.fillMaxSize().padding(28.dp, 92.dp).wrapContentSize(Alignment.TopStart) +} + +@Composable +private fun MediaWidget( + state: BluetoothSnapshot, + onPlay: () -> Unit, + onPause: () -> Unit, + onNext: () -> Unit, + onPrevious: () -> Unit, + modifier: Modifier = Modifier +) { + Surface( + modifier = modifier + .width(280.dp) + .clip(RoundedCornerShape(24.dp)), + color = Color.Black.copy(alpha = .34f) + ) { + Column(Modifier.padding(16.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Icon( + Icons.Default.Bluetooth, + null, + tint = Color(0xFFB9D9FF), + modifier = Modifier.size(16.dp) + ) + Spacer(Modifier.width(8.dp)) + Text( + state.connectedDeviceName ?: "", + fontSize = 12.sp, + color = Color.White.copy(alpha = 0.7f), + maxLines = 1, + overflow = TextOverflow.Ellipsis + ) + } + Spacer(Modifier.height(8.dp)) + Text( + state.title ?: appStringResource(R.string.unknown_track), + fontSize = 18.sp, + fontWeight = FontWeight.Bold, + color = Color.White, + maxLines = 1, + overflow = TextOverflow.Ellipsis + ) + Text( + state.artist ?: appStringResource(R.string.unknown_artist), + fontSize = 14.sp, + color = Color.White.copy(alpha = 0.8f), + maxLines = 1, + overflow = TextOverflow.Ellipsis + ) + Spacer(Modifier.height(12.dp)) + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.Center, + verticalAlignment = Alignment.CenterVertically + ) { + IconButton(onClick = onPrevious) { + Icon(Icons.Default.SkipPrevious, null, tint = Color.White) + } + Spacer(Modifier.width(8.dp)) + FilledIconButton( + onClick = { if (state.isPlaying) onPause() else onPlay() }, + colors = translucentIconColors() + ) { + Icon( + if (state.isPlaying) Icons.Default.Pause else Icons.Default.PlayArrow, + null, + tint = Color.White + ) + } + Spacer(Modifier.width(8.dp)) + IconButton(onClick = onNext) { + Icon(Icons.Default.SkipNext, null, tint = Color.White) + } + } + } + } +} + @Composable private fun ClockWeather( now: LocalDateTime, @@ -453,17 +594,19 @@ private fun ClockWeather( if (weather != null) { Text( "${weatherGlyph(weather.weatherCode)} ${weather.temperature.roundToInt()}° " + - "${weatherDescription(weather.weatherCode)}", + appStringResource(weatherDescription(weather.weatherCode)), fontSize = 20.sp, color = Color.White ) Text( - "${settings.locationName} H ${weather.high.roundToInt()}° L ${weather.low.roundToInt()}°", + "${settings.locationName} " + + appStringResource(R.string.temp_high, weather.high.roundToInt()) + " " + + appStringResource(R.string.temp_low, weather.low.roundToInt()), fontSize = 14.sp, color = Color.White.copy(alpha = .78f) ) } else { - TextButton(onClick = onRefresh) { Text("Weather unavailable · retry") } + TextButton(onClick = onRefresh) { Text(appStringResource(R.string.weather_unavailable) + " · " + appStringResource(R.string.retry)) } } } } @@ -489,31 +632,35 @@ private fun FullWeatherSlide(weather: WeatherNow, settings: LauncherSettings) { Text("${weather.temperature.roundToInt()}°", fontSize = 88.sp, fontWeight = FontWeight.Light) Spacer(Modifier.width(24.dp)) Column { - Text(weatherDescription(weather.weatherCode), fontSize = 28.sp) + Text(appStringResource(weatherDescription(weather.weatherCode)), fontSize = 28.sp) Text( - "Feels ${weather.apparentTemperature.roundToInt()}° · " + - "Humidity ${weather.humidity}% · Wind ${weather.windSpeed.roundToInt()}", + appStringResource(R.string.weather_feels, weather.apparentTemperature.roundToInt()) + " · " + + appStringResource(R.string.weather_humidity, weather.humidity) + " · " + + appStringResource(R.string.weather_wind, weather.windSpeed.roundToInt()), color = Color.White.copy(alpha = .78f) ) } } Spacer(Modifier.height(30.dp)) - Text("Next hours", fontSize = 18.sp, fontWeight = FontWeight.SemiBold) + Text(appStringResource(R.string.next_hours), fontSize = 18.sp, fontWeight = FontWeight.SemiBold) LazyRow( horizontalArrangement = Arrangement.spacedBy(10.dp), contentPadding = PaddingValues(vertical = 12.dp) ) { items(weather.hourly) { hour -> - Column( - Modifier - .clip(RoundedCornerShape(16.dp)) - .background(Color.White.copy(alpha = .11f)) - .padding(16.dp), - horizontalAlignment = Alignment.CenterHorizontally + Surface( + shape = RoundedCornerShape(16.dp), + color = Color.White.copy(alpha = .11f), + contentColor = Color.White ) { - Text(hour.time.takeLast(5)) - Text("${hour.temperature.roundToInt()}°", fontSize = 24.sp) - Text("${hour.precipitationChance}% rain", fontSize = 12.sp) + Column( + Modifier.padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text(hour.time.takeLast(5)) + Text("${hour.temperature.roundToInt()}°", fontSize = 24.sp) + Text(appStringResource(R.string.rain_chance, hour.precipitationChance), fontSize = 12.sp) + } } } } @@ -559,16 +706,17 @@ private fun AppTray( .fillMaxWidth(.78f) .fillMaxHeight(.82f), shape = RoundedCornerShape(28.dp), - color = Color(0xF2181E25) + color = Color(0xF2181E25), + contentColor = Color.White ) { Column(Modifier.padding(24.dp)) { Row(verticalAlignment = Alignment.CenterVertically) { Text( - if (showAll) "All applications" else "Quick launch", + if (showAll) appStringResource(R.string.all_applications) else appStringResource(R.string.quick_launch), style = MaterialTheme.typography.headlineSmall, modifier = Modifier.weight(1f) ) - IconButton(onClick = onDismiss) { Icon(Icons.Default.Close, "Close") } + IconButton(onClick = onDismiss) { Icon(Icons.Default.Close, appStringResource(R.string.close)) } } Row(verticalAlignment = Alignment.CenterVertically) { OutlinedTextField( @@ -576,20 +724,20 @@ private fun AppTray( onValueChange = { query = it }, singleLine = true, leadingIcon = { Icon(Icons.Default.Search, null) }, - placeholder = { Text("Search apps") }, + placeholder = { Text(appStringResource(R.string.search_apps)) }, modifier = Modifier.weight(1f) ) Spacer(Modifier.width(12.dp)) OutlinedButton(onClick = { showAll = !showAll }) { Icon(if (showAll) Icons.Default.Check else Icons.Default.Add, null) Spacer(Modifier.width(6.dp)) - Text(if (showAll) "Done" else "Add app") + Text(if (showAll) appStringResource(R.string.done) else appStringResource(R.string.add_app)) } } Spacer(Modifier.height(18.dp)) if (visible.isEmpty()) { Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { - Text(if (query.isBlank()) "No apps pinned yet." else "No matching apps.") + Text(if (query.isBlank()) appStringResource(R.string.no_apps_pinned) else appStringResource(R.string.no_matching_apps)) } } else { LazyVerticalGrid( @@ -662,7 +810,23 @@ private fun AppTile( } } -private enum class SettingsSection { DISPLAY, WEATHER, ROUTINES, VOICE, APPS, ACCESS } +private enum class SettingsSection { DISPLAY, WEATHER, ROUTINES, VOICE, APPS, LANGUAGE, ACCESS } + +val LocalAppLanguage = staticCompositionLocalOf { AppLanguage.ENGLISH } + +@Composable +private fun appStringResource(id: Int, vararg formatArgs: Any): String { + val language = LocalAppLanguage.current + val context = LocalContext.current + + val targetLocale = when (language) { + AppLanguage.SPANISH, AppLanguage.SPANISH_ENGLISH -> Locale("es") + else -> Locale.ENGLISH + } + + val conf = Configuration(context.resources.configuration).apply { setLocale(targetLocale) } + return context.createConfigurationContext(conf).getString(id, *formatArgs) +} @Composable private fun SettingsScreen( @@ -674,6 +838,9 @@ private fun SettingsScreen( requestHomeRole: () -> Unit, setWakeWordEnabled: (Boolean) -> Unit, setWakeWordSensitivity: (Int) -> Unit, + setWakeWordAutoClose: (Int) -> Unit, + setWakeWordToggleClose: (Boolean) -> Unit, + setLanguage: (AppLanguage) -> Unit, pauseWakeWord: () -> Unit, resumeWakeWord: () -> Unit, testWakeWord: () -> Unit @@ -694,23 +861,36 @@ private fun SettingsScreen( Row(Modifier.fillMaxSize().background(MaterialTheme.colorScheme.background)) { NavigationRail( header = { - IconButton(onClick = onBack) { Icon(Icons.Default.ArrowBack, "Back") } + IconButton(onClick = onBack) { Icon(Icons.Default.ArrowBack, appStringResource(R.string.back)) } } ) { SettingsSection.entries.forEach { item -> val icon = when (item) { - SettingsSection.DISPLAY -> ImageIcon + SettingsSection.DISPLAY -> Icons.Default.Image SettingsSection.WEATHER -> Icons.Default.Refresh SettingsSection.ROUTINES -> Icons.Default.VolumeUp SettingsSection.VOICE -> Icons.Default.Mic SettingsSection.APPS -> Icons.Default.Apps + SettingsSection.LANGUAGE -> Icons.Default.Translate SettingsSection.ACCESS -> Icons.Default.Info } NavigationRailItem( selected = section == item, onClick = { section = item }, icon = { Icon(icon, null) }, - label = { Text(item.name.lowercase().replaceFirstChar(Char::uppercase)) } + label = { + Text( + when (item) { + SettingsSection.DISPLAY -> appStringResource(R.string.display) + SettingsSection.WEATHER -> appStringResource(R.string.weather) + SettingsSection.ROUTINES -> appStringResource(R.string.routines) + SettingsSection.VOICE -> appStringResource(R.string.voice) + SettingsSection.APPS -> appStringResource(R.string.apps) + SettingsSection.LANGUAGE -> appStringResource(R.string.language) + SettingsSection.ACCESS -> appStringResource(R.string.access) + } + ) + } ) } } @@ -731,11 +911,14 @@ private fun SettingsScreen( state = state, setEnabled = setWakeWordEnabled, setSensitivity = setWakeWordSensitivity, + setAutoClose = setWakeWordAutoClose, + setToggleClose = setWakeWordToggleClose, pause = pauseWakeWord, resume = resumeWakeWord, test = testWakeWord ) SettingsSection.APPS -> ApplicationsSettings(state, updateSettings) + SettingsSection.LANGUAGE -> LanguageSettings(state, setLanguage) SettingsSection.ACCESS -> AccessSettings(requestHomeRole) } } @@ -761,21 +944,22 @@ private fun DisplaySettings( settings: LauncherSettings, update: ((LauncherSettings) -> LauncherSettings) -> Unit, onPickFolder: () -> Unit -) = SettingsPage("Display") { - SettingsCard("Keep screen awake", "Only applies while this launcher is visible.") { +) = SettingsPage(appStringResource(R.string.display)) { + SettingsCard(appStringResource(R.string.keep_awake), appStringResource(R.string.keep_awake_detail)) { ChoiceMenu( current = settings.keepAwakeMode, label = { when (it) { - KeepAwakeMode.WHILE_VISIBLE -> "While launcher is visible" - KeepAwakeMode.WHILE_CHARGING -> "Only while charging" - KeepAwakeMode.SYSTEM_DEFAULT -> "Follow Android timeout" + KeepAwakeMode.WHILE_VISIBLE -> appStringResource(R.string.keep_awake_visible) + KeepAwakeMode.WHILE_CHARGING -> appStringResource(R.string.keep_awake_charging) + KeepAwakeMode.ALWAYS -> appStringResource(R.string.keep_awake_always) + KeepAwakeMode.SYSTEM_DEFAULT -> appStringResource(R.string.keep_awake_default) } }, onSelect = { selected -> update { it.copy(keepAwakeMode = selected) } } ) } - SettingsCard("Photo interval", "${settings.intervalSeconds} seconds") { + SettingsCard(appStringResource(R.string.photo_interval), appStringResource(R.string.seconds, settings.intervalSeconds)) { Slider( value = settings.intervalSeconds.toFloat(), onValueChange = { value -> @@ -784,14 +968,14 @@ private fun DisplaySettings( valueRange = 10f..900f ) } - SettingsCard("Image darkening", "${settings.darkenPercent}%") { + SettingsCard(appStringResource(R.string.image_darkening), "${settings.darkenPercent}%") { Slider( value = settings.darkenPercent.toFloat(), onValueChange = { value -> update { it.copy(darkenPercent = value.roundToInt()) } }, valueRange = 0f..70f ) } - SettingsCard("Clock and weather corner", "The panel shifts subtly to reduce burn-in.") { + SettingsCard(appStringResource(R.string.clock_corner), appStringResource(R.string.clock_corner_detail)) { ChoiceMenu( current = settings.clockCorner, label = { it.name.lowercase().replace('_', ' ').replaceFirstChar(Char::uppercase) }, @@ -799,18 +983,18 @@ private fun DisplaySettings( ) } SettingsCard( - "Photo source", + appStringResource(R.string.photo_source), if (settings.localFolderUri.isBlank()) { - "Curated online landscapes, cities, nature, and art." + appStringResource(R.string.photo_source_online) } else { - "Using the selected local folder." + appStringResource(R.string.photo_source_local) } ) { Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { - Button(onClick = onPickFolder) { Text("Choose local folder") } + Button(onClick = onPickFolder) { Text(appStringResource(R.string.choose_local_folder)) } if (settings.localFolderUri.isNotBlank()) { OutlinedButton(onClick = { update { it.copy(localFolderUri = "") } }) { - Text("Use online collection") + Text(appStringResource(R.string.use_online_collection)) } } } @@ -822,25 +1006,27 @@ private fun WeatherSettings( state: LauncherUiState, update: ((LauncherSettings) -> LauncherSettings) -> Unit, refresh: () -> Unit -) = SettingsPage("Weather") { - SettingsCard("Show weather", "Compact conditions and periodic full forecast slides.") { +) = SettingsPage(appStringResource(R.string.weather)) { + SettingsCard(appStringResource(R.string.show_weather), appStringResource(R.string.show_weather_detail)) { Switch( checked = state.settings.showWeather, onCheckedChange = { checked -> update { it.copy(showWeather = checked) } } ) } - SettingsCard("Location", "Coordinates keep location permission unnecessary.") { + SettingsCard(appStringResource(R.string.location), appStringResource(R.string.location_detail)) { OutlinedTextField( value = state.settings.locationName, onValueChange = { value -> update { it.copy(locationName = value) } }, - label = { Text("Location label") }, - singleLine = true + label = { Text(appStringResource(R.string.location_label)) }, + placeholder = { Text(appStringResource(R.string.location_placeholder)) }, + singleLine = true, + modifier = Modifier.fillMaxWidth() ) Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) { OutlinedTextField( value = state.settings.latitude, onValueChange = { value -> update { it.copy(latitude = value) } }, - label = { Text("Latitude") }, + label = { Text(appStringResource(R.string.latitude)) }, keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal), singleLine = true, modifier = Modifier.weight(1f) @@ -848,20 +1034,34 @@ private fun WeatherSettings( OutlinedTextField( value = state.settings.longitude, onValueChange = { value -> update { it.copy(longitude = value) } }, - label = { Text("Longitude") }, + label = { Text(appStringResource(R.string.longitude)) }, keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal), singleLine = true, modifier = Modifier.weight(1f) ) } - Button(onClick = refresh, enabled = !state.weatherLoading) { - Icon(Icons.Default.Refresh, null) - Spacer(Modifier.width(7.dp)) - Text(if (state.weatherLoading) "Refreshing…" else "Refresh weather") + Button( + onClick = refresh, + enabled = !state.weatherLoading, + modifier = Modifier.align(Alignment.End) + ) { + Icon(Icons.Default.Search, null) + Spacer(Modifier.width(8.dp)) + Text(if (state.weatherLoading) appStringResource(R.string.searching) else appStringResource(R.string.search_refresh)) + } + state.weatherError?.let { + Text( + text = it, + color = MaterialTheme.colorScheme.error, + style = MaterialTheme.typography.bodySmall, + modifier = Modifier.padding(top = 4.dp) + ) } - state.weatherError?.let { Text(it, color = MaterialTheme.colorScheme.error) } } - SettingsCard("Temperature unit", if (state.settings.useFahrenheit) "Fahrenheit" else "Celsius") { + SettingsCard( + appStringResource(R.string.temp_unit), + if (state.settings.useFahrenheit) appStringResource(R.string.fahrenheit) else appStringResource(R.string.celsius) + ) { Row(verticalAlignment = Alignment.CenterVertically) { Text("°C") Switch( @@ -875,8 +1075,8 @@ private fun WeatherSettings( } } SettingsCard( - "Full forecast frequency", - "After every ${state.settings.weatherEveryPhotos} photos" + appStringResource(R.string.forecast_frequency), + appStringResource(R.string.after_every_photos, state.settings.weatherEveryPhotos) ) { Slider( value = state.settings.weatherEveryPhotos.toFloat(), @@ -893,10 +1093,10 @@ private fun WeatherSettings( private fun RoutineSettings( settings: LauncherSettings, update: ((LauncherSettings) -> LauncherSettings) -> Unit -) = SettingsPage("Night routine") { +) = SettingsPage(appStringResource(R.string.routines)) { SettingsCard( - "Scheduled ultra-dim", - "Applies whenever the launcher is visible. Android is not awakened by this schedule." + appStringResource(R.string.ultra_dim), + appStringResource(R.string.ultra_dim_detail) ) { Switch( checked = settings.nightRoutineEnabled, @@ -904,17 +1104,17 @@ private fun RoutineSettings( ) } SettingsCard( - "Active hours", + appStringResource(R.string.active_hours), "${formatHour(settings.nightStartHour)} – ${formatHour(settings.nightEndHour)}" ) { - Text("Start") + Text(appStringResource(R.string.start)) Slider( value = settings.nightStartHour.toFloat(), onValueChange = { value -> update { it.copy(nightStartHour = value.roundToInt()) } }, valueRange = 0f..23f, steps = 22 ) - Text("End") + Text(appStringResource(R.string.end)) Slider( value = settings.nightEndHour.toFloat(), onValueChange = { value -> update { it.copy(nightEndHour = value.roundToInt()) } }, @@ -922,13 +1122,13 @@ private fun RoutineSettings( steps = 22 ) } - SettingsCard("Ultra-dim strength", "${settings.nightDimPercent}%") { + SettingsCard(appStringResource(R.string.ultra_dim_strength), "${settings.nightDimPercent}%") { Slider( value = settings.nightDimPercent.toFloat(), onValueChange = { value -> update { it.copy(nightDimPercent = value.roundToInt()) } }, valueRange = 50f..95f ) - Text("Night mode also hides weather, disables image motion, and uses a dark-red clock.") + Text(appStringResource(R.string.night_mode_note)) } } @@ -937,10 +1137,12 @@ private fun VoiceSettings( state: LauncherUiState, setEnabled: (Boolean) -> Unit, setSensitivity: (Int) -> Unit, + setAutoClose: (Int) -> Unit, + setToggleClose: (Boolean) -> Unit, pause: () -> Unit, resume: () -> Unit, test: () -> Unit -) = SettingsPage("Voice assistant") { +) = SettingsPage(appStringResource(R.string.voice)) { val context = LocalContext.current val requiredPermissions = remember { buildList { @@ -958,9 +1160,8 @@ private fun VoiceSettings( } SettingsCard( - "Listen for “Computer”", - "Detection stays on-device. Continued listening in other apps requires a persistent " + - "notification and Android’s microphone privacy indicator." + appStringResource(R.string.voice_listen), + appStringResource(R.string.voice_listen_detail) ) { Switch( checked = state.settings.wakeWord.enabled, @@ -976,14 +1177,14 @@ private fun VoiceSettings( ) Text( when (state.wakeWord.state) { - WakeWordState.DISABLED -> "Disabled" - WakeWordState.DOWNLOADING -> "Downloading model" - WakeWordState.INSTALLING -> "Installing model" - WakeWordState.READY -> "Ready" - WakeWordState.LISTENING -> "Listening" - WakeWordState.PAUSED -> "Paused" - WakeWordState.MICROPHONE_BUSY -> "Microphone busy; retrying" - WakeWordState.ERROR -> "Error" + WakeWordState.DISABLED -> appStringResource(R.string.status_disabled) + WakeWordState.DOWNLOADING -> appStringResource(R.string.status_downloading) + WakeWordState.INSTALLING -> appStringResource(R.string.status_installing) + WakeWordState.READY -> appStringResource(R.string.status_ready) + WakeWordState.LISTENING -> appStringResource(R.string.status_listening) + WakeWordState.PAUSED -> appStringResource(R.string.status_paused) + WakeWordState.MICROPHONE_BUSY -> appStringResource(R.string.status_busy) + WakeWordState.ERROR -> appStringResource(R.string.status_error) }, fontWeight = FontWeight.SemiBold ) @@ -1002,8 +1203,8 @@ private fun VoiceSettings( } } SettingsCard( - "Sensitivity", - "${state.settings.wakeWord.sensitivity}% · Higher values detect more easily but may false-trigger." + appStringResource(R.string.sensitivity), + appStringResource(R.string.sensitivity_detail) ) { Slider( value = state.settings.wakeWord.sensitivity.toFloat(), @@ -1012,17 +1213,46 @@ private fun VoiceSettings( ) } SettingsCard( - "Listening controls", - "Testing releases this launcher’s microphone before opening the selected Android assistant." + appStringResource(R.string.auto_close), + if (state.settings.wakeWord.autoCloseSeconds > 0) { + appStringResource(R.string.auto_close_detail, state.settings.wakeWord.autoCloseSeconds) + } else appStringResource(R.string.auto_close_manual) + ) { + Slider( + value = state.settings.wakeWord.autoCloseSeconds.toFloat(), + onValueChange = { setAutoClose(it.roundToInt()) }, + valueRange = 0f..120f, + steps = 23 + ) + } + SettingsCard( + appStringResource(R.string.toggle_wake), + appStringResource(R.string.toggle_wake_detail) + ) { + Switch( + checked = state.settings.wakeWord.toggleClose, + onCheckedChange = setToggleClose + ) + if (state.settings.wakeWord.toggleClose) { + Text( + appStringResource(R.string.toggle_cooldown_note), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.primary + ) + } + } + SettingsCard( + appStringResource(R.string.listening_controls), + appStringResource(R.string.listening_controls_detail) ) { Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { if (state.wakeWord.state == WakeWordState.PAUSED) { - Button(onClick = resume) { Text("Resume") } + Button(onClick = resume) { Text(appStringResource(R.string.resume)) } } else { OutlinedButton( onClick = pause, enabled = state.settings.wakeWord.enabled - ) { Text("Pause") } + ) { Text(appStringResource(R.string.pause)) } } Button( onClick = test, @@ -1031,7 +1261,7 @@ private fun VoiceSettings( ) { Icon(Icons.Default.Mic, null) Spacer(Modifier.width(7.dp)) - Text("Test assistant") + Text(appStringResource(R.string.test_assistant)) } } OutlinedButton( @@ -1039,14 +1269,122 @@ private fun VoiceSettings( runCatching { context.startActivity(Intent(Settings.ACTION_VOICE_INPUT_SETTINGS)) } } ) { - Text("Open Android voice settings") + Text(appStringResource(R.string.open_voice_settings)) } } SettingsCard( - "Privacy", - "Audio frames are processed locally and are never saved or transmitted." + appStringResource(R.string.privacy), + appStringResource(R.string.privacy_detail) ) { - Text("Only the last detection time and service status are retained for diagnostics.") + Text(appStringResource(R.string.privacy_note)) + } +} + +@Composable +private fun BluetoothSettings(state: BluetoothSnapshot) = SettingsPage(appStringResource(R.string.bluetooth)) { + val context = LocalContext.current + SettingsCard( + appStringResource(R.string.bluetooth_sink), + appStringResource(R.string.bluetooth_sink_detail) + ) { + if (!state.isSupported) { + Text(appStringResource(R.string.bluetooth_not_supported), color = MaterialTheme.colorScheme.error) + } else if (!state.isEnabled) { + Text(appStringResource(R.string.bluetooth_disabled), color = MaterialTheme.colorScheme.error) + Button(onClick = { + runCatching { context.startActivity(Intent(Settings.ACTION_BLUETOOTH_SETTINGS)) } + }) { + Text(appStringResource(R.string.open_bluetooth_settings)) + } + } else { + Text( + if (state.connectedDeviceName != null) { + appStringResource(R.string.bluetooth_connected_to, state.connectedDeviceName) + } else { + appStringResource(R.string.bluetooth_ready) + }, + fontWeight = FontWeight.Bold, + color = if (state.connectedDeviceName != null) Color(0xFF8ED49A) else MaterialTheme.colorScheme.primary + ) + + val bluetoothManager = context.getSystemService(BluetoothManager::class.java) + val bluetoothAdapter = bluetoothManager?.adapter + if (bluetoothAdapter != null) { + val hasPermission = if (Build.VERSION.SDK_INT >= 31) { + ContextCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED + } else true + + val name = if (hasPermission) bluetoothAdapter.name else null + if (name != null) { + Text( + appStringResource(R.string.bluetooth_discoverable, name), + style = MaterialTheme.typography.bodySmall + ) + } + } + + OutlinedButton(onClick = { + runCatching { context.startActivity(Intent(Settings.ACTION_BLUETOOTH_SETTINGS)) } + }) { + Icon(Icons.Default.Bluetooth, null) + Spacer(Modifier.width(8.dp)) + Text(appStringResource(R.string.open_bluetooth_settings)) + } + } + } +} + +@Composable +private fun LanguageSettings( + state: LauncherUiState, + setLanguage: (AppLanguage) -> Unit +) = SettingsPage(appStringResource(R.string.language)) { + val context = LocalContext.current + SettingsCard( + appStringResource(R.string.app_language), + appStringResource(R.string.language_settings_detail) + ) { + ChoiceMenu( + current = state.settings.language, + label = { + when (it) { + AppLanguage.ENGLISH -> appStringResource(R.string.lang_english) + AppLanguage.SPANISH -> appStringResource(R.string.lang_spanish) + AppLanguage.ENGLISH_SPANISH -> appStringResource(R.string.lang_english_spanish) + AppLanguage.SPANISH_ENGLISH -> appStringResource(R.string.lang_spanish_english) + } + }, + onSelect = setLanguage + ) + } + + val systemLanguageMatch = remember(state.settings.language) { + val current = Locale.getDefault().language + when (state.settings.language) { + AppLanguage.SPANISH, AppLanguage.SPANISH_ENGLISH -> current == "es" + else -> current == "en" + } + } + + SettingsCard( + appStringResource(R.string.system_language), + appStringResource(R.string.system_language_detail) + ) { + if (!systemLanguageMatch) { + Text( + text = appStringResource(R.string.system_language_warning), + color = MaterialTheme.colorScheme.error, + style = MaterialTheme.typography.bodySmall, + fontWeight = FontWeight.Bold + ) + } + Button(onClick = { + runCatching { context.startActivity(Intent(Settings.ACTION_LOCALE_SETTINGS)) } + }) { + Icon(Icons.Default.Translate, null) + Spacer(Modifier.width(7.dp)) + Text(appStringResource(R.string.open_system_language)) + } } } @@ -1054,54 +1392,54 @@ private fun VoiceSettings( private fun ApplicationsSettings( state: LauncherUiState, update: ((LauncherSettings) -> LauncherSettings) -> Unit -) = SettingsPage("Applications") { +) = SettingsPage(appStringResource(R.string.apps)) { SettingsCard( - "Quick launch", - "${state.settings.pinnedComponents.size} app(s) pinned" + appStringResource(R.string.quick_launch), + appStringResource(R.string.apps_pinned, state.settings.pinnedComponents.size) ) { - Text("Open the app tray from Home, then choose Add app to pin or remove applications.") + Text(appStringResource(R.string.apps_pinned_detail)) } SettingsCard( - "Privacy", - "Recent-app tracking and usage access are disabled." + appStringResource(R.string.privacy), + appStringResource(R.string.apps_privacy_detail) ) { - Text("This launcher only reads activities that advertise a launchable icon.") + Text(appStringResource(R.string.apps_privacy_note)) } } @Composable -private fun AccessSettings(requestHomeRole: () -> Unit) = SettingsPage("System access") { - SettingsCard("Default Home app", "Required for the hardware Home gesture to return here.") { +private fun AccessSettings(requestHomeRole: () -> Unit) = SettingsPage(appStringResource(R.string.access)) { + SettingsCard(appStringResource(R.string.default_home), appStringResource(R.string.default_home_detail)) { Button(onClick = requestHomeRole) { Icon(Icons.Default.Home, null) Spacer(Modifier.width(7.dp)) - Text("Make default Home app") + Text(appStringResource(R.string.make_default_home)) } } - PermissionStatus("Internet", true, "Used for weather and the built-in online photo collection.") - PermissionStatus("Local photo folder", true, "Granted only to the folder you explicitly select.") - PermissionStatus("Location", false, "Not requested. Weather uses coordinates entered in settings.") + PermissionStatus(appStringResource(R.string.permission_internet), true, appStringResource(R.string.permission_internet_detail)) + PermissionStatus(appStringResource(R.string.permission_local_photo), true, appStringResource(R.string.permission_local_photo_detail)) + PermissionStatus(appStringResource(R.string.permission_location), false, appStringResource(R.string.permission_location_detail)) PermissionStatus( - "Microphone", + appStringResource(R.string.permission_microphone), ContextCompat.checkSelfPermission( LocalContext.current, Manifest.permission.RECORD_AUDIO ) == PackageManager.PERMISSION_GRANTED, - "Requested only when on-device wake-word listening is enabled." + appStringResource(R.string.permission_microphone_detail) ) - PermissionStatus("Display over other apps", false, "Not requested. Ultra-dim only covers this launcher.") - PermissionStatus("Usage access", false, "Not requested. Recent-app history is not collected.") + PermissionStatus(appStringResource(R.string.permission_overlay), false, appStringResource(R.string.permission_overlay_detail)) + PermissionStatus(appStringResource(R.string.permission_usage), false, appStringResource(R.string.permission_usage_detail)) PermissionStatus( - "Notifications", + appStringResource(R.string.permission_notifications), Build.VERSION.SDK_INT < 33 || ContextCompat.checkSelfPermission( LocalContext.current, Manifest.permission.POST_NOTIFICATIONS ) == PackageManager.PERMISSION_GRANTED, - "Used for the visible listening service and assistant fallback action." + appStringResource(R.string.permission_notifications_detail) ) SettingsCard( - "Audio output", - "A normal launcher cannot force other apps to use a specific device." + appStringResource(R.string.audio_output), + appStringResource(R.string.audio_output_detail) ) { val context = LocalContext.current OutlinedButton( @@ -1112,7 +1450,7 @@ private fun AccessSettings(requestHomeRole: () -> Unit) = SettingsPage("System a ) { Icon(Icons.Default.VolumeUp, null) Spacer(Modifier.width(7.dp)) - Text("Open Android sound settings") + Text(appStringResource(R.string.open_sound_settings)) } } } @@ -1121,7 +1459,7 @@ private fun AccessSettings(requestHomeRole: () -> Unit) = SettingsPage("System a private fun PermissionStatus(title: String, enabled: Boolean, detail: String) { SettingsCard(title, detail) { Text( - if (enabled) "Available" else "Not requested", + if (enabled) appStringResource(R.string.available) else appStringResource(R.string.not_requested), color = if (enabled) Color(0xFF8ED49A) else MaterialTheme.colorScheme.onSurfaceVariant, fontWeight = FontWeight.SemiBold ) @@ -1156,7 +1494,7 @@ private fun SettingsCard( @Composable private inline fun > ChoiceMenu( current: T, - noinline label: (T) -> String, + noinline label: @Composable (T) -> String, crossinline onSelect: (T) -> Unit ) { var expanded by remember { mutableStateOf(false) } diff --git a/app/src/main/java/com/ambient/launcher/Models.kt b/app/src/main/java/com/ambient/launcher/Models.kt index 266e77b..22c63b7 100644 --- a/app/src/main/java/com/ambient/launcher/Models.kt +++ b/app/src/main/java/com/ambient/launcher/Models.kt @@ -3,6 +3,26 @@ package com.ambient.launcher import android.content.ComponentName import android.graphics.drawable.Drawable +data class LauncherUiState( + val settings: LauncherSettings = LauncherSettings(), + val apps: List = emptyList(), + val localImages: List = emptyList(), + val weather: WeatherNow? = null, + val weatherLoading: Boolean = false, + val weatherError: String? = null, + val wakeWord: WakeWordSnapshot = WakeWordSnapshot(), + val bluetooth: BluetoothSnapshot = BluetoothSnapshot() +) + +data class BluetoothSnapshot( + val connectedDeviceName: String? = null, + val isPlaying: Boolean = false, + val artist: String? = null, + val title: String? = null, + val isSupported: Boolean = true, + val isEnabled: Boolean = false +) + data class LauncherApp( val label: String, val component: ComponentName, @@ -34,15 +54,18 @@ data class DailyWeather( val weatherCode: Int ) -enum class KeepAwakeMode { WHILE_VISIBLE, WHILE_CHARGING, SYSTEM_DEFAULT } +enum class KeepAwakeMode { WHILE_VISIBLE, WHILE_CHARGING, ALWAYS, SYSTEM_DEFAULT } enum class ClockCorner { BOTTOM_LEFT, BOTTOM_RIGHT, TOP_LEFT, TOP_RIGHT } +enum class AppLanguage { ENGLISH, SPANISH, ENGLISH_SPANISH, SPANISH_ENGLISH } enum class ModelInstallState { NOT_INSTALLED, DOWNLOADING, INSTALLING, READY, FAILED } enum class WakeWordState { DISABLED, DOWNLOADING, INSTALLING, READY, LISTENING, PAUSED, MICROPHONE_BUSY, ERROR } data class WakeWordSettings( val enabled: Boolean = false, val sensitivity: Int = 50, - val installedModelVersion: String = "" + val installedModelVersion: String = "", + val autoCloseSeconds: Int = 60, + val toggleClose: Boolean = false ) data class WakeWordSnapshot( @@ -70,6 +93,7 @@ data class LauncherSettings( val nightStartHour: Int = 23, val nightEndHour: Int = 7, val nightDimPercent: Int = 88, + val language: AppLanguage = AppLanguage.ENGLISH, val wakeWord: WakeWordSettings = WakeWordSettings() ) @@ -78,18 +102,18 @@ sealed interface Slide { data object Weather : Slide } -fun weatherDescription(code: Int): String = when (code) { - 0 -> "Clear" - 1, 2 -> "Partly cloudy" - 3 -> "Overcast" - 45, 48 -> "Fog" - 51, 53, 55, 56, 57 -> "Drizzle" - 61, 63, 65, 66, 67 -> "Rain" - 71, 73, 75, 77 -> "Snow" - 80, 81, 82 -> "Rain showers" - 85, 86 -> "Snow showers" - 95, 96, 99 -> "Thunderstorm" - else -> "Unknown" +fun weatherDescription(code: Int): Int = when (code) { + 0 -> R.string.weather_clear + 1, 2 -> R.string.weather_partly_cloudy + 3 -> R.string.weather_overcast + 45, 48 -> R.string.weather_fog + 51, 53, 55, 56, 57 -> R.string.weather_drizzle + 61, 63, 65, 66, 67 -> R.string.weather_rain + 71, 73, 75, 77 -> R.string.weather_snow + 80, 81, 82 -> R.string.weather_rain_showers + 85, 86 -> R.string.weather_snow_showers + 95, 96, 99 -> R.string.weather_thunderstorm + else -> R.string.weather_unknown } fun weatherGlyph(code: Int): String = when (code) { diff --git a/app/src/main/java/com/ambient/launcher/SettingsStore.kt b/app/src/main/java/com/ambient/launcher/SettingsStore.kt index 95e3967..d7198db 100644 --- a/app/src/main/java/com/ambient/launcher/SettingsStore.kt +++ b/app/src/main/java/com/ambient/launcher/SettingsStore.kt @@ -29,9 +29,12 @@ class SettingsStore(private val context: Context) { val nightStart = intPreferencesKey("night_start") val nightEnd = intPreferencesKey("night_end") val nightDim = intPreferencesKey("night_dim") + val language = stringPreferencesKey("language") val wakeEnabled = booleanPreferencesKey("wake_enabled") val wakeSensitivity = intPreferencesKey("wake_sensitivity") val wakeModelVersion = stringPreferencesKey("wake_model_version") + val wakeAutoClose = intPreferencesKey("wake_auto_close") + val wakeToggleClose = booleanPreferencesKey("wake_toggle_close") } val settings: Flow = context.dataStore.data.map { p -> @@ -56,10 +59,13 @@ class SettingsStore(private val context: Context) { nightStartHour = p[Keys.nightStart] ?: 23, nightEndHour = p[Keys.nightEnd] ?: 7, nightDimPercent = p[Keys.nightDim] ?: 88, + language = enumOrDefault(p[Keys.language], AppLanguage.ENGLISH), wakeWord = WakeWordSettings( enabled = p[Keys.wakeEnabled] ?: false, sensitivity = p[Keys.wakeSensitivity] ?: 50, - installedModelVersion = p[Keys.wakeModelVersion] ?: "" + installedModelVersion = p[Keys.wakeModelVersion] ?: "", + autoCloseSeconds = p[Keys.wakeAutoClose] ?: 60, + toggleClose = p[Keys.wakeToggleClose] ?: false ) ) } @@ -82,9 +88,12 @@ class SettingsStore(private val context: Context) { p[Keys.nightStart] = value.nightStartHour p[Keys.nightEnd] = value.nightEndHour p[Keys.nightDim] = value.nightDimPercent + p[Keys.language] = value.language.name p[Keys.wakeEnabled] = value.wakeWord.enabled p[Keys.wakeSensitivity] = value.wakeWord.sensitivity p[Keys.wakeModelVersion] = value.wakeWord.installedModelVersion + p[Keys.wakeAutoClose] = value.wakeWord.autoCloseSeconds + p[Keys.wakeToggleClose] = value.wakeWord.toggleClose } } diff --git a/app/src/main/java/com/ambient/launcher/voice/DefaultAssistantLauncher.kt b/app/src/main/java/com/ambient/launcher/voice/DefaultAssistantLauncher.kt index cb1b019..eef0908 100644 --- a/app/src/main/java/com/ambient/launcher/voice/DefaultAssistantLauncher.kt +++ b/app/src/main/java/com/ambient/launcher/voice/DefaultAssistantLauncher.kt @@ -4,6 +4,7 @@ import android.app.PendingIntent import android.content.ActivityNotFoundException import android.content.Context import android.content.Intent +import android.provider.Settings enum class AssistLaunchResult { LAUNCHED, NOT_CONFIGURED, BACKGROUND_BLOCKED } @@ -32,6 +33,22 @@ class DefaultAssistantLauncher(private val context: Context) { PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE ) - private fun assistantIntent() = Intent(Intent.ACTION_ASSIST) - .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP) + private fun assistantIntent(): Intent { + val alexaPackage = "com.amazon.dee.app" + val currentAssistant = Settings.Secure.getString(context.contentResolver, "assistant") + + // If Alexa is the default assistant, try to pre-activate it using VOICE_COMMAND + if (currentAssistant?.contains(alexaPackage) == true) { + val voiceCommandIntent = Intent(Intent.ACTION_VOICE_COMMAND) + .setPackage(alexaPackage) + .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP) + + if (voiceCommandIntent.resolveActivity(context.packageManager) != null) { + return voiceCommandIntent + } + } + + return Intent(Intent.ACTION_ASSIST) + .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP) + } } diff --git a/app/src/main/java/com/ambient/launcher/voice/WakeWordController.kt b/app/src/main/java/com/ambient/launcher/voice/WakeWordController.kt index 7e92fdd..a2907f2 100644 --- a/app/src/main/java/com/ambient/launcher/voice/WakeWordController.kt +++ b/app/src/main/java/com/ambient/launcher/voice/WakeWordController.kt @@ -12,6 +12,7 @@ import androidx.work.NetworkType import androidx.work.OneTimeWorkRequestBuilder import androidx.work.WorkInfo import androidx.work.WorkManager +import com.ambient.launcher.AppLanguage import com.ambient.launcher.ModelInstallState import com.ambient.launcher.WakeWordSnapshot import com.ambient.launcher.WakeWordState @@ -46,6 +47,9 @@ class WakeWordController(private val context: Context) { private var enabled = false private var visible = false private var sensitivity = 50 + private var autoCloseSeconds = 0 + private var toggleClose = false + private var language = AppLanguage.ENGLISH init { val lastDetection = context.getSharedPreferences("wake_runtime", Context.MODE_PRIVATE) @@ -96,16 +100,28 @@ class WakeWordController(private val context: Context) { } } - fun configure(isEnabled: Boolean, newSensitivity: Int) { + fun configure( + isEnabled: Boolean, + newSensitivity: Int, + newAutoClose: Int = 0, + newToggleClose: Boolean = false, + newLanguage: AppLanguage = AppLanguage.ENGLISH + ) { enabled = isEnabled sensitivity = newSensitivity.coerceIn(0, 100) + autoCloseSeconds = newAutoClose + toggleClose = newToggleClose + language = newLanguage if (!enabled) disable() else if (visible) enable() } fun setVisible(isVisible: Boolean) { visible = isVisible - if (visible && enabled) enable() + if (visible) { + if (enabled) enable() + sendAction(WakeWordService.ACTION_REPORT_VISIBLE) + } } fun enable() { @@ -139,6 +155,9 @@ class WakeWordController(private val context: Context) { val intent = Intent(context, WakeWordService::class.java) .setAction(WakeWordService.ACTION_START) .putExtra(WakeWordService.EXTRA_SENSITIVITY, sensitivity) + .putExtra(WakeWordService.EXTRA_AUTO_CLOSE, autoCloseSeconds) + .putExtra(WakeWordService.EXTRA_TOGGLE_CLOSE, toggleClose) + .putExtra(WakeWordService.EXTRA_LANGUAGE, language.name) runCatching { ContextCompat.startForegroundService(context, intent) } .onFailure { WakeWordRuntime.update( diff --git a/app/src/main/java/com/ambient/launcher/voice/WakeWordModel.kt b/app/src/main/java/com/ambient/launcher/voice/WakeWordModel.kt index 9bf2001..df06f90 100644 --- a/app/src/main/java/com/ambient/launcher/voice/WakeWordModel.kt +++ b/app/src/main/java/com/ambient/launcher/voice/WakeWordModel.kt @@ -44,6 +44,38 @@ object WakeWordModel { fun path(context: Context, name: String) = File(directory(context), name).absolutePath private fun File.readTextOrNull(): String? = runCatching { readText() }.getOrNull() + + fun createComputerKeyword(tokensFile: File, outputFile: File) { + val tokens = tokensFile.readLines().mapIndexedNotNull { index, line -> + val columns = line.trim().split(Regex("\\s+")) + val piece = columns.firstOrNull()?.takeIf { it.isNotBlank() } ?: return@mapIndexedNotNull null + piece to (columns.getOrNull(1)?.toIntOrNull() ?: index) + } + val target = "▁COMPUTER" + data class Candidate(val pieces: List>, val score: Int) + val best = arrayOfNulls(target.length + 1) + best[0] = Candidate(emptyList(), 0) + for (start in target.indices) { + val current = best[start] ?: continue + tokens.forEach { token -> + val piece = token.first + if (target.startsWith(piece, start)) { + val end = start + piece.length + val candidate = Candidate(current.pieces + token, current.score + token.second) + val previous = best[end] + if ( + previous == null || + candidate.pieces.size < previous.pieces.size || + candidate.pieces.size == previous.pieces.size && candidate.score < previous.score + ) { + best[end] = candidate + } + } + } + } + val pieces = best[target.length]?.pieces ?: error("Model cannot tokenize COMPUTER") + outputFile.writeText(pieces.joinToString(" ") { it.first } + "\n") + } } class WakeWordModelWorker( @@ -72,7 +104,10 @@ class WakeWordModelWorker( staging.deleteRecursively() staging.mkdirs() extractSelected(archive, staging) - createComputerKeyword(File(staging, "tokens.txt"), File(staging, "keywords.txt")) + WakeWordModel.createComputerKeyword( + File(staging, "tokens.txt"), + File(staging, "keywords.txt") + ) if (!WakeWordModel.requiredFiles.all { File(staging, it).isFile }) { error("Model archive is incomplete") } @@ -151,38 +186,6 @@ class WakeWordModelWorker( } } - private fun createComputerKeyword(tokensFile: File, output: File) { - val tokens = tokensFile.readLines().mapIndexedNotNull { index, line -> - val columns = line.trim().split(Regex("\\s+")) - val piece = columns.firstOrNull()?.takeIf { it.isNotBlank() } ?: return@mapIndexedNotNull null - piece to (columns.getOrNull(1)?.toIntOrNull() ?: index) - } - val target = "▁COMPUTER" - data class Candidate(val pieces: List>, val score: Int) - val best = arrayOfNulls(target.length + 1) - best[0] = Candidate(emptyList(), 0) - for (start in target.indices) { - val current = best[start] ?: continue - tokens.forEach { token -> - val piece = token.first - if (target.startsWith(piece, start)) { - val end = start + piece.length - val candidate = Candidate(current.pieces + token, current.score + token.second) - val previous = best[end] - if ( - previous == null || - candidate.pieces.size < previous.pieces.size || - candidate.pieces.size == previous.pieces.size && candidate.score < previous.score - ) { - best[end] = candidate - } - } - } - } - val pieces = best[target.length]?.pieces ?: error("Model cannot tokenize COMPUTER") - output.writeText(pieces.joinToString(" ") { it.first } + "\n") - } - private fun sha256(file: File): String { val digest = MessageDigest.getInstance("SHA-256") file.inputStream().buffered().use { input -> diff --git a/app/src/main/java/com/ambient/launcher/voice/WakeWordService.kt b/app/src/main/java/com/ambient/launcher/voice/WakeWordService.kt index 678338b..f2dfe31 100644 --- a/app/src/main/java/com/ambient/launcher/voice/WakeWordService.kt +++ b/app/src/main/java/com/ambient/launcher/voice/WakeWordService.kt @@ -19,6 +19,7 @@ import android.os.Looper import androidx.core.app.NotificationCompat import androidx.core.app.ServiceCompat import androidx.core.content.ContextCompat +import com.ambient.launcher.AppLanguage import com.ambient.launcher.MainActivity import com.ambient.launcher.R import com.ambient.launcher.SettingsStore @@ -46,7 +47,12 @@ class WakeWordService : Service() { @Volatile private var listening = false @Volatile private var paused = false private var sensitivity = 50 + private var autoCloseSeconds = 0 + private var toggleClose = false + private var language = AppLanguage.ENGLISH + private var isAssistantActive = false private var lastDetection = 0L + private val autoCloseRunnable = Runnable { returnToLauncher() } override fun onCreate() { super.onCreate() @@ -61,6 +67,10 @@ class WakeWordService : Service() { intent.getIntExtra(EXTRA_SENSITIVITY, 50).coerceIn(0, 100) if (requestedSensitivity != sensitivity && listening) stopListening() sensitivity = requestedSensitivity + autoCloseSeconds = intent.getIntExtra(EXTRA_AUTO_CLOSE, 0) + toggleClose = intent.getBooleanExtra(EXTRA_TOGGLE_CLOSE, false) + val langName = intent.getStringExtra(EXTRA_LANGUAGE) + language = AppLanguage.entries.find { it.name == langName } ?: AppLanguage.ENGLISH paused = false startListening() } @@ -77,6 +87,10 @@ class WakeWordService : Service() { stopSelf() } } + ACTION_REPORT_VISIBLE -> { + isAssistantActive = false + mainHandler.removeCallbacks(autoCloseRunnable) + } ACTION_TEST -> handleDetection(force = true) else -> { WakeWordRuntime.update( @@ -214,6 +228,16 @@ class WakeWordService : Service() { private fun handleDetection(force: Boolean) { val now = System.currentTimeMillis() if (!force && now - lastDetection < DETECTION_DEBOUNCE_MS) return + + if (!force && toggleClose && isAssistantActive) { + lastDetection = now + returnToLauncher() + if (!paused) { + mainHandler.postDelayed({ startListening() }, toggleCooldown()) + } + return + } + lastDetection = now getSharedPreferences("wake_runtime", MODE_PRIVATE) .edit() @@ -227,10 +251,29 @@ class WakeWordService : Service() { ) val launcher = DefaultAssistantLauncher(this) val result = launcher.launch() - if (result != AssistLaunchResult.LAUNCHED) showAssistantFallback(launcher) - if (!paused) mainHandler.postDelayed({ startListening() }, ASSISTANT_COOLDOWN_MS) + if (result == AssistLaunchResult.LAUNCHED) { + isAssistantActive = true + if (autoCloseSeconds > 0) { + mainHandler.removeCallbacks(autoCloseRunnable) + mainHandler.postDelayed(autoCloseRunnable, autoCloseSeconds * 1000L) + } + } else { + showAssistantFallback(launcher) + } + if (!paused) mainHandler.postDelayed({ startListening() }, toggleCooldown()) } + private fun returnToLauncher() { + isAssistantActive = false + mainHandler.removeCallbacks(autoCloseRunnable) + val intent = Intent(Intent.ACTION_MAIN) + .addCategory(Intent.CATEGORY_HOME) + .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + runCatching { startActivity(intent) } + } + + private fun toggleCooldown(): Long = if (toggleClose) 2_500L else ASSISTANT_COOLDOWN_MS + private fun pauseListening() { paused = true stopListening() @@ -340,8 +383,12 @@ class WakeWordService : Service() { const val ACTION_PAUSE = "com.ambient.launcher.voice.PAUSE" const val ACTION_RESUME = "com.ambient.launcher.voice.RESUME" const val ACTION_STOP = "com.ambient.launcher.voice.STOP" + const val ACTION_REPORT_VISIBLE = "com.ambient.launcher.voice.REPORT_VISIBLE" const val ACTION_TEST = "com.ambient.launcher.voice.TEST" const val EXTRA_SENSITIVITY = "sensitivity" + const val EXTRA_AUTO_CLOSE = "auto_close" + const val EXTRA_TOGGLE_CLOSE = "toggle_close" + const val EXTRA_LANGUAGE = "language" private const val SAMPLE_RATE = 16_000 private const val DETECTION_DEBOUNCE_MS = 5_000L private const val ASSISTANT_COOLDOWN_MS = 12_000L diff --git a/app/src/main/res/drawable/ambient_fallback.xml b/app/src/main/res/drawable/ambient_fallback.xml index 0e243a0..b0b07ca 100644 --- a/app/src/main/res/drawable/ambient_fallback.xml +++ b/app/src/main/res/drawable/ambient_fallback.xml @@ -1,8 +1,21 @@ - - - + + + + + + + + + + diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml new file mode 100644 index 0000000..e2a4517 --- /dev/null +++ b/app/src/main/res/values-es/strings.xml @@ -0,0 +1,191 @@ + + Ambient Launcher + + + Atrás + Cerrar + Hecho + reintentar + + + Abrir aplicaciones + Abrir ajustes + Clima no disponible + Próximas horas + %1$d%% lluvia + Fotografía de ambiente + + + Todas las aplicaciones + Inicio rápido + Buscar aplicaciones + Añadir aplicación + No hay aplicaciones fijadas. + No hay aplicaciones coincidentes. + + + Pantalla + Clima + Rutina nocturna + Asistente de voz + Aplicaciones + Bluetooth + Acceso al sistema + Idioma + + + Mantener pantalla encendida + Mantiene la pantalla encendida globalmente o según la visibilidad. + Mientras el lanzador sea visible + Solo durante la carga (Global) + Siempre (Global) + Seguir tiempo de espera de Android + Intervalo de fotos + %1$d segundos + Oscurecimiento de imagen + Esquina de reloj y clima + El panel se desplaza sutilmente para reducir el desgaste. + Fuente de fotos + Paisajes, ciudades, naturaleza y arte seleccionados en línea. + Usando la carpeta local seleccionada. + Elegir carpeta local + Usar colección en línea + + + Mostrar clima + Condiciones compactas y diapositivas de pronóstico completo periódicas. + Ubicación + Introduzca el nombre de una ciudad o coordenadas. Las coordenadas se rellenan automáticamente al buscar por ciudad. + Ciudad, Estado/País + ej. Madrid, ES + Latitud + Longitud + Buscando… + Buscar y actualizar + Unidad de temperatura + Frecuencia de pronóstico completo + Después de cada %1$d fotos + + + Atenuación programada + Se aplica siempre que el lanzador es visible. Android no se despierta por este horario. + Horas activas + Inicio + Fin + Fuerza de atenuación + El modo nocturno también oculta el clima, desactiva el movimiento de imagen y usa un reloj rojo oscuro. + + + Escuchar “Computer” + La detección permanece en el dispositivo. Seguir escuchando en otras aplicaciones requiere una notificación persistente y el indicador de privacidad del micrófono de Android. + Desactivado + Descargando modelo + Instalando modelo + Listo + Escuchando + Pausado + Micrófono ocupado; reintentando + Error + Sensibilidad + Valores más altos detectan más fácilmente pero pueden causar activaciones falsas. + Cierre automático del asistente + Regresar automáticamente al lanzador después de %1$d segundos. + El asistente permanecerá abierto hasta que se cierre manualmente. + Alternar con palabra de activación + Si el asistente ya está abierto, decir “Computer” de nuevo lo cerrará y regresará aquí. + El tiempo de espera de escucha se reduce a 2.5s para alternar más rápido. + Controles de escucha + La prueba libera el micrófono de este lanzador antes de abrir el asistente de Android seleccionado. + Reanudar + Pausar + Probar asistente + Abrir ajustes de voz de Android + Privacidad + Los marcos de audio se procesan localmente y nunca se guardan ni transmiten. + Solo se conservan el último tiempo de detección y el estado del servicio para diagnóstico. + + + %1$d aplicación(es) fijada(s) + Abra la bandeja de aplicaciones desde Inicio, luego elija Añadir aplicación para fijar o quitar aplicaciones. + El seguimiento de aplicaciones recientes y el acceso de uso están desactivados. + Este lanzador solo lee las actividades que anuncian un icono ejecutable. + + + Aplicación de inicio predeterminada + Requerido para que el gesto de Inicio del hardware regrese aquí. + Establecer como aplicación de inicio + Internet + Se usa para el clima y la colección de fotos en línea integrada. + Carpeta de fotos local + Concedido solo a la carpeta que seleccione explíitamente. + Ubicación + No se solicita. El clima usa las coordenadas introducidas en los ajustes. + Micrófono + Se solicita solo cuando la escucha de palabra de activación en el dispositivo está habilitada. + Mostrar sobre otras aplicaciones + No se solicita. La atenuación ultra solo cubre este lanzador. + Acceso de uso + No se solicita. No se recoge el historial de aplicaciones recientes. + Notificaciones + Se usa para el servicio de escucha visible y la acción de respaldo del asistente. + Salida de audio + Un lanzador normal no puede forzar a otras aplicaciones a usar un dispositivo específico. + Abrir ajustes de sonido de Android + Disponible + No solicitado + + + Controles de idioma de la aplicación e idioma del sistema. + Idioma de la aplicación + Inglés + Español + Inglés-Español + Español-Inglés + Idioma del sistema + Cambiar los ajustes de idioma del sistema Android. + Abrir ajustes de idioma del sistema + El idioma del sistema no está actualizado + + + Receptor de Audio + Permite que otros dispositivos se conecten y reproduzcan música a través de esta tableta. + Estado de Bluetooth + Bluetooth no es compatible con este dispositivo. + Bluetooth está desactivado. + Listo para conectar. + Conectado a %s + Visible como “%s” + Abrir ajustes de Bluetooth + Reproduciendo ahora + Artista desconocido + Pista desconocida + + + Despejado + Parcialmente nublado + Nublado + Niebla + Llovizna + Lluvia + Nieve + Chubascos + Nevadas + Tormenta + Desconocido + Sensación %1$d° + Humedad %1$d%% + Viento %1$d + Máx %1$d° + Mín %1$d° + Fahrenheit + Celsius + + + Escuchando “Computer” + Toca para volver a Ambient Launcher + Escucha pausada + Palabra de activación detectada + Toca para abrir tu asistente predeterminado + Mantener pantalla encendida activo + Este servicio evita que la pantalla se apague. + diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 04c2798..de7a571 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1,3 +1,191 @@ Ambient Launcher + + + Back + Close + Done + retry + + + Open applications + Open settings + Weather unavailable + Next hours + %1$d%% rain + Ambient photograph + + + All applications + Quick launch + Search apps + Add app + No apps pinned yet. + No matching apps. + + + Display + Weather + Night routine + Voice assistant + Applications + Bluetooth + System access + Language + + + Keep screen awake + Maintains the screen awake state globally or based on visibility. + While launcher is visible + Only while charging (Global) + Always (Global) + Follow Android timeout + Photo interval + %1$d seconds + Image darkening + Clock and weather corner + The panel shifts subtly to reduce burn-in. + Photo source + Curated online landscapes, cities, nature, and art. + Using the selected local folder. + Choose local folder + Use online collection + + + Show weather + Compact conditions and periodic full forecast slides. + Location + Enter a city name or coordinates. Coordinates are auto-filled when searching by city. + City, State/Country + e.g. London, UK + Latitude + Longitude + Searching… + Search & Refresh + Temperature unit + Full forecast frequency + After every %1$d photos + + + Scheduled ultra-dim + Applies whenever the launcher is visible. Android is not awakened by this schedule. + Active hours + Start + End + Ultra-dim strength + Night mode also hides weather, disables image motion, and uses a dark-red clock. + + + Listen for “Computer” + Detection stays on-device. Continued listening in other apps requires a persistent notification and Android’s microphone privacy indicator. + Disabled + Downloading model + Installing model + Ready + Listening + Paused + Microphone busy; retrying + Error + Sensitivity + Higher values detect more easily but may false-trigger. + Auto-close assistant + Automatically return to launcher after %1$d seconds. + Assistant will stay open until manually dismissed. + Toggle with wake word + If the assistant is already open, saying “Computer” again will close it and return here. + Listening cooldown is reduced to 2.5s for faster toggling. + Listening controls + Testing releases this launcher’s microphone before opening the selected Android assistant. + Resume + Pause + Test assistant + Open Android voice settings + Privacy + Audio frames are processed locally and are never saved or transmitted. + Only the last detection time and service status are retained for diagnostics. + + + %1$d app(s) pinned + Open the app tray from Home, then choose Add app to pin or remove applications. + Recent-app tracking and usage access are disabled. + This launcher only reads activities that advertise a launchable icon. + + + Default Home app + Required for the hardware Home gesture to return here. + Make default Home app + Internet + Used for weather and the built-in online photo collection. + Local photo folder + Granted only to the folder you explicitly select. + Location + Not requested. Weather uses coordinates entered in settings. + Microphone + Requested only when on-device wake-word listening is enabled. + Display over other apps + Not requested. Ultra-dim only covers this launcher. + Usage access + Not requested. Recent-app history is not collected. + Notifications + Used for the visible listening service and assistant fallback action. + Audio output + A normal launcher cannot force other apps to use a specific device. + Open Android sound settings + Available + Not requested + + + App language and system language controls. + App Language + English + Spanish + English-Spanish + Spanish-English + System Language + Change Android system language settings. + Open system language settings + System language is not up to date + + + Audio Receiver (Sink) + Allow other devices to connect and play music through this tablet. + Bluetooth Status + Bluetooth is not supported on this device. + Bluetooth is turned off. + Ready to connect. + Connected to %s + Discoverable as “%s” + Open Bluetooth settings + Now Playing + Unknown Artist + Unknown Track + + + Clear + Partly cloudy + Overcast + Fog + Drizzle + Rain + Snow + Rain showers + Snow showers + Thunderstorm + Unknown + Feels %1$d° + Humidity %1$d%% + Wind %1$d + H %1$d° + L %1$d° + Fahrenheit + Celsius + + + Listening for “Computer” + Tap to return to Ambient Launcher + Wake word paused + Wake word detected + Tap to open your default assistant + Keep screen awake active + This service keeps your screen from timing out. diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..61285a659d17295f1de7c53e24fdf13ad755c379 GIT binary patch literal 46175 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

pVX@HRij*jw$g4?}Pn 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 literal 0 HcmV?d00001 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..19a6bde --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,7 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.0-bin.zip +networkTimeout=10000 +validateDistributionUrl=true +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100644 index 0000000..adff685 --- /dev/null +++ b/gradlew @@ -0,0 +1,248 @@ +#!/bin/sh + +# +# Copyright © 2015 the original authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# SPDX-License-Identifier: Apache-2.0 +# + +############################################################################## +# +# Gradle start up script for POSIX generated by Gradle. +# +# Important for running: +# +# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is +# noncompliant, but you have some other compliant shell such as ksh or +# bash, then to run this script, type that shell name before the whole +# command line, like: +# +# ksh Gradle +# +# Busybox and similar reduced shells will NOT work, because this script +# requires all of these POSIX shell features: +# * functions; +# * expansions «$var», «${var}», «${var:-default}», «${var+SET}», +# «${var#prefix}», «${var%suffix}», and «$( cmd )»; +# * compound commands having a testable exit status, especially «case»; +# * various built-in commands including «command», «set», and «ulimit». +# +# Important for patching: +# +# (2) This script targets any POSIX shell, so it avoids extensions provided +# by Bash, Ksh, etc; in particular arrays are avoided. +# +# The "traditional" practice of packing multiple parameters into a +# space-separated string is a well documented source of bugs and security +# problems, so this is (mostly) avoided, by progressively accumulating +# options in "$@", and eventually passing that to Java. +# +# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS, +# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly; +# see the in-line comments for details. +# +# There are tweaks for specific operating systems such as AIX, CygWin, +# Darwin, MinGW, and NonStop. +# +# (3) This script is generated from the Groovy template +# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt +# within the Gradle project. +# +# You can find Gradle at https://github.com/gradle/gradle/. +# +############################################################################## + +# Attempt to set APP_HOME + +# Resolve links: $0 may be a link +app_path=$0 + +# Need this for daisy-chained symlinks. +while + APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path + [ -h "$app_path" ] +do + ls=$( ls -ld "$app_path" ) + link=${ls#*' -> '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..c4bdd3a --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,93 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/view.xml b/view.xml new file mode 100644 index 0000000..2232cfb --- /dev/null +++ b/view.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/view_home.xml b/view_home.xml new file mode 100644 index 0000000..2232cfb --- /dev/null +++ b/view_home.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/view_launcher.xml b/view_launcher.xml new file mode 100644 index 0000000..1935ab2 --- /dev/null +++ b/view_launcher.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/view_launcher_v2.xml b/view_launcher_v2.xml new file mode 100644 index 0000000..037192b --- /dev/null +++ b/view_launcher_v2.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/view_launcher_v3.xml b/view_launcher_v3.xml new file mode 100644 index 0000000..d4a8938 --- /dev/null +++ b/view_launcher_v3.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/view_settings.xml b/view_settings.xml new file mode 100644 index 0000000..d4a8938 --- /dev/null +++ b/view_settings.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/view_settings_v2.xml b/view_settings_v2.xml new file mode 100644 index 0000000..e4a787a --- /dev/null +++ b/view_settings_v2.xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/view_voice.xml b/view_voice.xml new file mode 100644 index 0000000..e4a787a --- /dev/null +++ b/view_voice.xml @@ -0,0 +1 @@ + \ No newline at end of file