TigerHare99/sherpai2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: TigerHare99:1ab69a2b726b0869c167b2cc298de08b87f769ef
Branches Tags
TigerHare99:master TigerHare99:ClaudeCode TigerHare99:autoFR-20260117 TigerHare99:faceripper_v1-20260116 TigerHare99:20260110-FeatureImrpovs TigerHare99:embeddings-person TigerHare99:dev-backend2 TigerHare99:dev_backend_one TigerHare99:dev-dom-dupwork TigerHare99:cleanup_composeTesting TigerHare99:composeTesting
..
compare: TigerHare99:embeddings-person
Branches Tags
TigerHare99:ClaudeCode TigerHare99:master TigerHare99:autoFR-20260117 TigerHare99:faceripper_v1-20260116 TigerHare99:20260110-FeatureImrpovs TigerHare99:embeddings-person TigerHare99:dev-backend2 TigerHare99:dev_backend_one TigerHare99:dev-dom-dupwork TigerHare99:cleanup_composeTesting TigerHare99:composeTesting

1 Commits
1ab69a2b72 ... embeddings

Author SHA1 Message Date
genki
2b5f761d25 Oh yes - Thats how we do 
No default params for KSP complainer fuck

UI sweeps
 2026-01-10 00:08:04 -05:00
60 changed files with 3480 additions and 9515 deletions
Expand all files Collapse all files

2
.idea/deploymentTargetSelector.xml generated
View File

@@ -4,7 +4,7 @@
<selectionStates>
<SelectionState runConfigName="app">
<option name="selectionMode" value="DROPDOWN" />
<DropdownSelection timestamp="2026-01-20T00:30:16.888577418Z">
<DropdownSelection timestamp="2026-01-08T02:44:48.809354959Z">
<Target type="DEFAULT_BOOT">
<handle>
<DeviceId pluginId="LocalEmulator" identifier="path=/home/genki/.android/avd/Medium_Phone.avd" />

37
.idea/deviceManager.xml generated
View File

@@ -1,48 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="DeviceTable">
<option name="collapsedNodes">
<list>
<CategoryListState>
<option name="categories">
<list>
<CategoryState>
<option name="attribute" value="Type" />
<option name="value" value="Physical" />
</CategoryState>
</list>
</option>
</CategoryListState>
</list>
</option>
<option name="columnSorters">
<list>
<ColumnSorterState>
<option name="column" value="Name" />
<option name="order" value="DESCENDING" />
<option name="order" value="ASCENDING" />
</ColumnSorterState>
</list>
</option>
<option name="groupByAttributes">
<list>
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
<option value="Type" />
</list>
</option>
</component>
</project>

12
app/build.gradle.kts
View File

@@ -85,16 +85,4 @@ dependencies {
// Gson for storing FloatArrays in Room
implementation(libs.gson)
// Zoomable
implementation(libs.zoomable)
implementation(libs.vico.compose)
implementation(libs.vico.compose.m3)
implementation(libs.vico.core)
// Workers
implementation(libs.androidx.work.runtime.ktx)
implementation(libs.androidx.hilt.work)
}

BIN
app/src/main/assets/mobilefacenet.tflite
View File

Binary file not shown.

277
app/src/main/java/com/placeholder/sherpai2/MainActivity.kt
View File

@@ -8,42 +8,26 @@ import androidx.activity.ComponentActivity
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.compose.setContent
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.core.content.ContextCompat
import androidx.lifecycle.lifecycleScope
import com.placeholder.sherpai2.domain.repository.ImageRepository
import com.placeholder.sherpai2.domain.usecase.PopulateFaceDetectionCacheUseCase
import com.placeholder.sherpai2.ui.presentation.MainScreen
import com.placeholder.sherpai2.ui.theme.SherpAI2Theme
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import javax.inject.Inject
/**
* MainActivity - TWO-PHASE STARTUP
*
* Phase 1: Image ingestion (fast - just loads URIs)
* Phase 2: Face detection cache (slower - scans for faces)
*
* App is usable immediately, both run in background.
*/
@AndroidEntryPoint
class MainActivity : ComponentActivity() {
@Inject
lateinit var imageRepository: ImageRepository
@Inject
lateinit var populateFaceCache: PopulateFaceDetectionCacheUseCase
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
@@ -62,8 +46,8 @@ class MainActivity : ComponentActivity() {
)
}
var ingestionState by remember { mutableStateOf<IngestionState>(IngestionState.NotStarted) }
var cacheState by remember { mutableStateOf<CacheState>(CacheState.NotStarted) }
var isIngesting by remember { mutableStateOf(false) }
var imagesIngested by remember { mutableStateOf(false) }
val permissionLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission()
@@ -71,250 +55,39 @@ class MainActivity : ComponentActivity() {
hasPermission = granted
}
// Phase 1: Image ingestion
// Logic: Handle the flow of Permission -> Ingestion
LaunchedEffect(hasPermission) {
if (hasPermission && ingestionState is IngestionState.NotStarted) {
ingestionState = IngestionState.InProgress(0, 0)
lifecycleScope.launch(Dispatchers.IO) {
try {
val existingCount = imageRepository.getImageCount()
if (existingCount > 0) {
withContext(Dispatchers.Main) {
ingestionState = IngestionState.Complete(existingCount)
}
} else {
imageRepository.ingestImagesWithProgress { current, total ->
ingestionState = IngestionState.InProgress(current, total)
}
val finalCount = imageRepository.getImageCount()
withContext(Dispatchers.Main) {
ingestionState = IngestionState.Complete(finalCount)
}
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
ingestionState = IngestionState.Error(e.message ?: "Failed to load images")
}
}
if (hasPermission) {
if (!imagesIngested && !isIngesting) {
isIngesting = true
imageRepository.ingestImages()
imagesIngested = true
isIngesting = false
}
} else if (!hasPermission) {
} else {
permissionLauncher.launch(storagePermission)
}
}
// Phase 2: Face detection cache population
LaunchedEffect(ingestionState) {
if (ingestionState is IngestionState.Complete && cacheState is CacheState.NotStarted) {
lifecycleScope.launch(Dispatchers.IO) {
try {
// Check if cache needs population
val stats = populateFaceCache.getCacheStats()
if (stats.needsScanning == 0) {
withContext(Dispatchers.Main) {
cacheState = CacheState.Complete(stats.imagesWithFaces, stats.imagesWithoutFaces)
}
} else {
withContext(Dispatchers.Main) {
cacheState = CacheState.InProgress(0, stats.needsScanning)
}
populateFaceCache.execute { current, total, _ ->
cacheState = CacheState.InProgress(current, total)
}
val finalStats = populateFaceCache.getCacheStats()
withContext(Dispatchers.Main) {
cacheState = CacheState.Complete(
finalStats.imagesWithFaces,
finalStats.imagesWithoutFaces
)
}
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
cacheState = CacheState.Error(e.message ?: "Failed to scan faces")
}
}
}
}
}
// UI
Box(modifier = Modifier.fillMaxSize()) {
// UI State Mapping
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
when {
hasPermission -> {
// Main screen always visible
hasPermission && imagesIngested -> {
MainScreen()
// Progress overlays at bottom with navigation bar clearance
Column(
modifier = Modifier
.fillMaxSize()
.padding(horizontal = 16.dp)
.padding(bottom = 120.dp), // More space for nav bar + gestures
verticalArrangement = Arrangement.Bottom
) {
if (ingestionState is IngestionState.InProgress) {
IngestionProgressCard(ingestionState as IngestionState.InProgress)
Spacer(Modifier.height(8.dp))
}
if (cacheState is CacheState.InProgress) {
FaceCacheProgressCard(cacheState as CacheState.InProgress)
}
}
}
hasPermission && isIngesting -> {
// Show a loader so you know it's working!
CircularProgressIndicator()
}
else -> {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
Text(
"Storage Permission Required",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
"SherpAI needs access to your photos",
style = MaterialTheme.typography.bodyMedium
)
Button(onClick = { permissionLauncher.launch(storagePermission) }) {
Text("Grant Permission")
}
}
}
Text("Please grant storage permission to continue.")
}
}
}
}
}
}
}
sealed class IngestionState {
object NotStarted : IngestionState()
data class InProgress(val current: Int, val total: Int) : IngestionState()
data class Complete(val imageCount: Int) : IngestionState()
data class Error(val message: String) : IngestionState()
}
sealed class CacheState {
object NotStarted : CacheState()
data class InProgress(val current: Int, val total: Int) : CacheState()
data class Complete(val withFaces: Int, val withoutFaces: Int) : CacheState()
data class Error(val message: String) : CacheState()
}
@Composable
fun IngestionProgressCard(state: IngestionState.InProgress) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
),
elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = "Loading photos...",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
if (state.total > 0) {
Text(
text = "${state.current} / ${state.total}",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.primary
)
}
}
if (state.total > 0) {
LinearProgressIndicator(
progress = { state.current.toFloat() / state.total.toFloat() },
modifier = Modifier.fillMaxWidth(),
)
} else {
LinearProgressIndicator(modifier = Modifier.fillMaxWidth())
}
Text(
text = "You can use the app while photos load",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
@Composable
fun FaceCacheProgressCard(state: CacheState.InProgress) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.secondaryContainer
),
elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = "Scanning for faces...",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
if (state.total > 0) {
Text(
text = "${state.current} / ${state.total}",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.secondary
)
}
}
if (state.total > 0) {
LinearProgressIndicator(
progress = { state.current.toFloat() / state.total.toFloat() },
modifier = Modifier.fillMaxWidth(),
)
} else {
LinearProgressIndicator(modifier = Modifier.fillMaxWidth())
}
Text(
text = "Face filters will work once scanning completes",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}

19
app/src/main/java/com/placeholder/sherpai2/SherpAIApplication.kt
View File

@@ -1,24 +1,7 @@
package com.placeholder.sherpai2
import android.app.Application
import androidx.hilt.work.HiltWorkerFactory
import androidx.work.Configuration
import dagger.hilt.android.HiltAndroidApp
import javax.inject.Inject
/**
* SherpAIApplication - ENHANCED with WorkManager support
*
* Now supports background cache population via Hilt Workers
*/
@HiltAndroidApp
class SherpAIApplication : Application(), Configuration.Provider {
@Inject
lateinit var workerFactory: HiltWorkerFactory
override val workManagerConfiguration: Configuration
get() = Configuration.Builder()
.setWorkerFactory(workerFactory)
.build()
}
class SherpAIApplication : Application()

73
app/src/main/java/com/placeholder/sherpai2/data/local/AppDatabase.kt
View File

@@ -8,53 +8,33 @@ import com.placeholder.sherpai2.data.local.entity.*
/**
* AppDatabase - Complete database for SherpAI2
*
* VERSION 7 - Added face detection cache to ImageEntity:
* - hasFaces: Boolean?
* - faceCount: Int?
* - facesLastDetected: Long?
* - faceDetectionVersion: Int?
*
* ENTITIES:
* - YOUR EXISTING: Image, Tag, Event, junction tables
* - NEW: PersonEntity (people in your app)
* - NEW: FaceModelEntity (face embeddings, links to PersonEntity)
* - NEW: PhotoFaceTagEntity (face detections, links to ImageEntity + FaceModelEntity)
*
* DEV MODE: Using destructive migration (fallbackToDestructiveMigration)
* - Fresh install on every schema change
* - No manual migrations needed during development
*
* PRODUCTION MODE: Add proper migrations before release
* - See DatabaseMigration.kt for migration code
* - Remove fallbackToDestructiveMigration()
* - Add .addMigrations(MIGRATION_6_7)
*/
@Database(
entities = [
// ===== CORE ENTITIES =====
// ===== YOUR EXISTING ENTITIES =====
ImageEntity::class,
TagEntity::class,
EventEntity::class,
ImageTagEntity::class,
ImageEventEntity::class,
// ===== FACE RECOGNITION =====
PersonEntity::class,
FaceModelEntity::class,
PhotoFaceTagEntity::class,
// ===== COLLECTIONS =====
CollectionEntity::class,
CollectionImageEntity::class,
CollectionFilterEntity::class
// ===== NEW ENTITIES =====
PersonEntity::class, // NEW: People
FaceModelEntity::class, // NEW: Face embeddings
PhotoFaceTagEntity::class // NEW: Face tags
],
version = 7, // INCREMENTED for face detection cache
version = 5,
exportSchema = false
)
// No TypeConverters needed - embeddings stored as strings
abstract class AppDatabase : RoomDatabase() {
// ===== CORE DAOs =====
// ===== YOUR EXISTING DAOs =====
abstract fun imageDao(): ImageDao
abstract fun tagDao(): TagDao
abstract fun eventDao(): EventDao
@@ -62,37 +42,8 @@ abstract class AppDatabase : RoomDatabase() {
abstract fun imageEventDao(): ImageEventDao
abstract fun imageAggregateDao(): ImageAggregateDao
// ===== FACE RECOGNITION DAOs =====
abstract fun personDao(): PersonDao
abstract fun faceModelDao(): FaceModelDao
abstract fun photoFaceTagDao(): PhotoFaceTagDao
// ===== COLLECTIONS DAO =====
abstract fun collectionDao(): CollectionDao
}
/**
* MIGRATION NOTES FOR PRODUCTION:
*
* When ready to ship to users, replace destructive migration with proper migration:
*
* val MIGRATION_6_7 = object : Migration(6, 7) {
* override fun migrate(database: SupportSQLiteDatabase) {
* // Add face detection cache columns
* database.execSQL("ALTER TABLE images ADD COLUMN hasFaces INTEGER DEFAULT NULL")
* database.execSQL("ALTER TABLE images ADD COLUMN faceCount INTEGER DEFAULT NULL")
* database.execSQL("ALTER TABLE images ADD COLUMN facesLastDetected INTEGER DEFAULT NULL")
* database.execSQL("ALTER TABLE images ADD COLUMN faceDetectionVersion INTEGER DEFAULT NULL")
*
* // Create indices
* database.execSQL("CREATE INDEX IF NOT EXISTS index_images_hasFaces ON images(hasFaces)")
* database.execSQL("CREATE INDEX IF NOT EXISTS index_images_faceCount ON images(faceCount)")
* }
* }
*
* Then in your database builder:
* Room.databaseBuilder(context, AppDatabase::class.java, "database_name")
* .addMigrations(MIGRATION_6_7) // Add this
* // .fallbackToDestructiveMigration() // Remove this
* .build()
*/
// ===== NEW DAOs =====
abstract fun personDao(): PersonDao // NEW: Manage people
abstract fun faceModelDao(): FaceModelDao // NEW: Manage face embeddings
abstract fun photoFaceTagDao(): PhotoFaceTagDao // NEW: Manage face tags
}

216
app/src/main/java/com/placeholder/sherpai2/data/local/dao/Collectiondao.kt
View File

@@ -1,216 +0,0 @@
package com.placeholder.sherpai2.data.local.dao
import androidx.room.*
import com.placeholder.sherpai2.data.local.entity.*
import com.placeholder.sherpai2.data.local.model.CollectionWithDetails
import kotlinx.coroutines.flow.Flow
/**
* CollectionDao - Manage user collections
*/
@Dao
interface CollectionDao {
// ==========================================
// BASIC OPERATIONS
// ==========================================
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insert(collection: CollectionEntity): Long
@Update
suspend fun update(collection: CollectionEntity)
@Delete
suspend fun delete(collection: CollectionEntity)
@Query("DELETE FROM collections WHERE collectionId = :collectionId")
suspend fun deleteById(collectionId: String)
@Query("SELECT * FROM collections WHERE collectionId = :collectionId")
suspend fun getById(collectionId: String): CollectionEntity?
@Query("SELECT * FROM collections WHERE collectionId = :collectionId")
fun getByIdFlow(collectionId: String): Flow<CollectionEntity?>
// ==========================================
// LIST QUERIES
// ==========================================
/**
* Get all collections ordered by pinned, then by creation date
*/
@Query("""
SELECT * FROM collections
ORDER BY isPinned DESC, createdAt DESC
""")
fun getAllCollections(): Flow<List<CollectionEntity>>
@Query("""
SELECT * FROM collections
WHERE type = :type
ORDER BY isPinned DESC, createdAt DESC
""")
fun getCollectionsByType(type: String): Flow<List<CollectionEntity>>
@Query("SELECT * FROM collections WHERE type = 'FAVORITE' LIMIT 1")
suspend fun getFavoriteCollection(): CollectionEntity?
// ==========================================
// COLLECTION WITH DETAILS
// ==========================================
/**
* Get collection with actual photo count
*/
@Transaction
@Query("""
SELECT
c.*,
(SELECT COUNT(*)
FROM collection_images ci
WHERE ci.collectionId = c.collectionId) as actualPhotoCount
FROM collections c
WHERE c.collectionId = :collectionId
""")
fun getCollectionWithDetails(collectionId: String): Flow<CollectionWithDetails?>
// ==========================================
// IMAGE MANAGEMENT
// ==========================================
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun addImage(collectionImage: CollectionImageEntity)
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun addImages(collectionImages: List<CollectionImageEntity>)
@Query("""
DELETE FROM collection_images
WHERE collectionId = :collectionId AND imageId = :imageId
""")
suspend fun removeImage(collectionId: String, imageId: String)
@Query("DELETE FROM collection_images WHERE collectionId = :collectionId")
suspend fun clearAllImages(collectionId: String)
@Query("""
SELECT i.* FROM images i
JOIN collection_images ci ON i.imageId = ci.imageId
WHERE ci.collectionId = :collectionId
ORDER BY ci.sortOrder ASC, ci.addedAt DESC
""")
fun getImagesInCollection(collectionId: String): Flow<List<ImageEntity>>
@Query("""
SELECT i.* FROM images i
JOIN collection_images ci ON i.imageId = ci.imageId
WHERE ci.collectionId = :collectionId
ORDER BY ci.sortOrder ASC, ci.addedAt DESC
LIMIT 4
""")
suspend fun getPreviewImages(collectionId: String): List<ImageEntity>
@Query("""
SELECT COUNT(*) FROM collection_images
WHERE collectionId = :collectionId
""")
suspend fun getPhotoCount(collectionId: String): Int
@Query("""
SELECT EXISTS(
SELECT 1 FROM collection_images
WHERE collectionId = :collectionId AND imageId = :imageId
)
""")
suspend fun containsImage(collectionId: String, imageId: String): Boolean
// ==========================================
// FILTER MANAGEMENT (for SMART collections)
// ==========================================
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertFilter(filter: CollectionFilterEntity)
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertFilters(filters: List<CollectionFilterEntity>)
@Query("DELETE FROM collection_filters WHERE collectionId = :collectionId")
suspend fun clearFilters(collectionId: String)
@Query("""
SELECT * FROM collection_filters
WHERE collectionId = :collectionId
ORDER BY createdAt ASC
""")
suspend fun getFilters(collectionId: String): List<CollectionFilterEntity>
@Query("""
SELECT * FROM collection_filters
WHERE collectionId = :collectionId
ORDER BY createdAt ASC
""")
fun getFiltersFlow(collectionId: String): Flow<List<CollectionFilterEntity>>
// ==========================================
// STATISTICS
// ==========================================
@Query("SELECT COUNT(*) FROM collections")
suspend fun getCollectionCount(): Int
@Query("SELECT COUNT(*) FROM collections WHERE type = 'SMART'")
suspend fun getSmartCollectionCount(): Int
@Query("SELECT COUNT(*) FROM collections WHERE type = 'STATIC'")
suspend fun getStaticCollectionCount(): Int
@Query("""
SELECT SUM(photoCount) FROM collections
""")
suspend fun getTotalPhotosInCollections(): Int?
// ==========================================
// UPDATES
// ==========================================
/**
* Update photo count cache (call after adding/removing images)
*/
@Query("""
UPDATE collections
SET photoCount = (
SELECT COUNT(*) FROM collection_images
WHERE collectionId = :collectionId
),
updatedAt = :updatedAt
WHERE collectionId = :collectionId
""")
suspend fun updatePhotoCount(collectionId: String, updatedAt: Long)
@Query("""
UPDATE collections
SET coverImageUri = :imageUri, updatedAt = :updatedAt
WHERE collectionId = :collectionId
""")
suspend fun updateCoverImage(collectionId: String, imageUri: String?, updatedAt: Long)
@Query("""
UPDATE collections
SET isPinned = :isPinned, updatedAt = :updatedAt
WHERE collectionId = :collectionId
""")
suspend fun updatePinned(collectionId: String, isPinned: Boolean, updatedAt: Long)
@Query("""
UPDATE collections
SET name = :name, description = :description, updatedAt = :updatedAt
WHERE collectionId = :collectionId
""")
suspend fun updateDetails(
collectionId: String,
name: String,
description: String?,
updatedAt: Long
)
}

369
app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageDao.kt
View File

@@ -9,45 +9,6 @@ import com.placeholder.sherpai2.data.local.entity.ImageEntity
import com.placeholder.sherpai2.data.local.model.ImageWithEverything
import kotlinx.coroutines.flow.Flow
/**
* Data classes for statistics queries
*/
data class DateCount(
val date: String, // YYYY-MM-DD format
val count: Int
)
data class MonthCount(
val month: String, // YYYY-MM format
val count: Int
)
data class YearCount(
val year: String, // YYYY format
val count: Int
)
data class DayOfWeekCount(
val dayOfWeek: Int, // 0 = Sunday, 6 = Saturday
val count: Int
)
data class HourCount(
val hour: Int, // 0-23
val count: Int
)
/**
* Face detection cache statistics
*/
data class FaceCacheStats(
val totalImages: Int,
val imagesWithFaceCache: Int,
val imagesWithFaces: Int,
val imagesWithoutFaces: Int,
val needsScanning: Int
)
@Dao
interface ImageDao {
@@ -107,334 +68,8 @@ interface ImageDao {
/**
* Get images by list of IDs.
* FIXED: Changed from List<Long> to List<String> to match ImageEntity.imageId type
*/
@Query("SELECT * FROM images WHERE imageId IN (:imageIds)")
suspend fun getImagesByIds(imageIds: List<String>): List<ImageEntity>
@Query("SELECT COUNT(*) FROM images")
suspend fun getImageCount(): Int
/**
* Get all images (for utilities processing)
*/
@Query("SELECT * FROM images ORDER BY capturedAt DESC")
suspend fun getAllImages(): List<ImageEntity>
/**
* Get all images sorted by time (for burst detection)
*/
@Query("SELECT * FROM images ORDER BY capturedAt ASC")
suspend fun getAllImagesSortedByTime(): List<ImageEntity>
// ==========================================
// FACE DETECTION CACHE QUERIES - CRITICAL FOR OPTIMIZATION
// ==========================================
/**
* Get all images that have faces (cached).
* This is the PRIMARY optimization query.
*
* Use this for person scanning instead of scanning ALL images.
* Estimated speed improvement: 50-70% for typical photo libraries.
*/
@Query("""
SELECT * FROM images
WHERE hasFaces = 1
AND faceDetectionVersion = :currentVersion
ORDER BY capturedAt DESC
""")
suspend fun getImagesWithFaces(currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION): List<ImageEntity>
/**
* Get images with faces, limited (for progressive scanning)
*/
@Query("""
SELECT * FROM images
WHERE hasFaces = 1
AND faceDetectionVersion = :currentVersion
ORDER BY capturedAt DESC
LIMIT :limit
""")
suspend fun getImagesWithFacesLimited(
limit: Int,
currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
): List<ImageEntity>
/**
* Get images with a specific face count.
* Use cases:
* - Solo photos (faceCount = 1)
* - Couple photos (faceCount = 2)
* - Filter out groups (faceCount <= 2)
*/
@Query("""
SELECT * FROM images
WHERE hasFaces = 1
AND faceCount = :count
AND faceDetectionVersion = :currentVersion
ORDER BY capturedAt DESC
""")
suspend fun getImagesByFaceCount(
count: Int,
currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
): List<ImageEntity>
/**
* Get images with face count in range.
* Examples:
* - Solo or couple: minFaces=1, maxFaces=2
* - Groups only: minFaces=3, maxFaces=999
*/
@Query("""
SELECT * FROM images
WHERE hasFaces = 1
AND faceCount BETWEEN :minFaces AND :maxFaces
AND faceDetectionVersion = :currentVersion
ORDER BY capturedAt DESC
""")
suspend fun getImagesByFaceCountRange(
minFaces: Int,
maxFaces: Int,
currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
): List<ImageEntity>
/**
* Get images that need face detection scanning.
* These images have:
* - Never been scanned (hasFaces = null)
* - Old detection version
* - Invalid cache
*/
@Query("""
SELECT * FROM images
WHERE hasFaces IS NULL
OR faceDetectionVersion IS NULL
OR faceDetectionVersion < :currentVersion
ORDER BY capturedAt DESC
""")
suspend fun getImagesNeedingFaceDetection(
currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
): List<ImageEntity>
/**
* Get count of images needing face detection.
*/
@Query("""
SELECT COUNT(*) FROM images
WHERE hasFaces IS NULL
OR faceDetectionVersion IS NULL
OR faceDetectionVersion < :currentVersion
""")
suspend fun getImagesNeedingFaceDetectionCount(
currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
): Int
/**
* Update face detection cache for a single image.
* Called after detecting faces in an image.
*/
@Query("""
UPDATE images
SET hasFaces = :hasFaces,
faceCount = :faceCount,
facesLastDetected = :timestamp,
faceDetectionVersion = :version
WHERE imageId = :imageId
""")
suspend fun updateFaceDetectionCache(
imageId: String,
hasFaces: Boolean,
faceCount: Int,
timestamp: Long = System.currentTimeMillis(),
version: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
)
/**
* Batch update face detection cache.
* More efficient when updating many images at once.
*
* Note: Room doesn't support batch updates directly,
* so this needs to be called multiple times in a transaction.
*/
@Transaction
suspend fun updateFaceDetectionCacheBatch(updates: List<FaceDetectionCacheUpdate>) {
updates.forEach { update ->
updateFaceDetectionCache(
imageId = update.imageId,
hasFaces = update.hasFaces,
faceCount = update.faceCount,
timestamp = update.timestamp,
version = update.version
)
}
}
/**
* Get face detection cache statistics.
* Useful for UI display and determining background scan needs.
*/
@Query("""
SELECT
COUNT(*) as totalImages,
SUM(CASE WHEN hasFaces IS NOT NULL THEN 1 ELSE 0 END) as imagesWithFaceCache,
SUM(CASE WHEN hasFaces = 1 THEN 1 ELSE 0 END) as imagesWithFaces,
SUM(CASE WHEN hasFaces = 0 THEN 1 ELSE 0 END) as imagesWithoutFaces,
SUM(CASE WHEN hasFaces IS NULL OR faceDetectionVersion < :currentVersion THEN 1 ELSE 0 END) as needsScanning
FROM images
""")
suspend fun getFaceCacheStats(
currentVersion: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
): FaceCacheStats?
/**
* Invalidate face detection cache (force re-scan).
* Call this when upgrading face detection algorithm.
*/
@Query("""
UPDATE images
SET faceDetectionVersion = NULL
WHERE faceDetectionVersion < :newVersion
""")
suspend fun invalidateFaceDetectionCache(newVersion: Int)
// ==========================================
// STATISTICS QUERIES
// ==========================================
/**
* Get photo counts by date (daily granularity)
* Returns all days that have at least one photo
*/
@Query("""
SELECT
date(capturedAt/1000, 'unixepoch') as date,
COUNT(*) as count
FROM images
GROUP BY date
ORDER BY date ASC
""")
suspend fun getPhotoCountsByDate(): List<DateCount>
/**
* Get photo counts by month (monthly granularity)
*/
@Query("""
SELECT
strftime('%Y-%m', capturedAt/1000, 'unixepoch') as month,
COUNT(*) as count
FROM images
GROUP BY month
ORDER BY month ASC
""")
suspend fun getPhotoCountsByMonth(): List<MonthCount>
/**
* Get photo counts by year (yearly granularity)
*/
@Query("""
SELECT
strftime('%Y', capturedAt/1000, 'unixepoch') as year,
COUNT(*) as count
FROM images
GROUP BY year
ORDER BY year DESC
""")
suspend fun getPhotoCountsByYear(): List<YearCount>
/**
* Get photo counts by year (Flow version for reactive UI)
*/
@Query("""
SELECT
strftime('%Y', capturedAt/1000, 'unixepoch') as year,
COUNT(*) as count
FROM images
GROUP BY year
ORDER BY year DESC
""")
fun getPhotoCountsByYearFlow(): Flow<List<YearCount>>
/**
* Get photo counts by day of week (0 = Sunday, 6 = Saturday)
* Shows which days you take the most photos
*/
@Query("""
SELECT
CAST(strftime('%w', capturedAt/1000, 'unixepoch') AS INTEGER) as dayOfWeek,
COUNT(*) as count
FROM images
GROUP BY dayOfWeek
ORDER BY dayOfWeek ASC
""")
suspend fun getPhotoCountsByDayOfWeek(): List<DayOfWeekCount>
/**
* Get photo counts by hour of day (0-23)
* Shows when you take the most photos
*/
@Query("""
SELECT
CAST(strftime('%H', capturedAt/1000, 'unixepoch') AS INTEGER) as hour,
COUNT(*) as count
FROM images
GROUP BY hour
ORDER BY hour ASC
""")
suspend fun getPhotoCountsByHour(): List<HourCount>
/**
* Get earliest and latest photo timestamps
* Used for date range calculations
*/
@Query("""
SELECT
MIN(capturedAt) as earliest,
MAX(capturedAt) as latest
FROM images
""")
suspend fun getPhotoDateRange(): PhotoDateRange?
/**
* Get photo count for a specific year
*/
@Query("""
SELECT COUNT(*) FROM images
WHERE strftime('%Y', capturedAt/1000, 'unixepoch') = :year
""")
suspend fun getPhotoCountForYear(year: String): Int
/**
* Get average photos per day (for stats display)
*/
@Query("""
SELECT
CAST(COUNT(*) AS REAL) /
CAST((MAX(capturedAt) - MIN(capturedAt)) / 86400000 AS REAL) as avgPerDay
FROM images
WHERE (SELECT COUNT(*) FROM images) > 0
""")
suspend fun getAveragePhotosPerDay(): Float?
@Query("SELECT * FROM images WHERE hasFaces = 1 ORDER BY faceCount DESC")
suspend fun getImagesWithFaces(): List<ImageEntity>
}
/**
* Data class for date range result
*/
data class PhotoDateRange(
val earliest: Long,
val latest: Long
)
/**
* Data class for batch face detection cache updates
*/
data class FaceDetectionCacheUpdate(
val imageId: String,
val hasFaces: Boolean,
val faceCount: Int,
val timestamp: Long = System.currentTimeMillis(),
val version: Int = ImageEntity.CURRENT_FACE_DETECTION_VERSION
)
}

95
app/src/main/java/com/placeholder/sherpai2/data/local/dao/ImageTagDao.kt
View File

@@ -9,15 +9,6 @@ import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
import com.placeholder.sherpai2.data.local.entity.TagEntity
import kotlinx.coroutines.flow.Flow
/**
* Data class for burst statistics
*/
data class BurstStats(
val totalBurstPhotos: Int,
val estimatedBurstGroups: Int,
val burstRepresentatives: Int
)
@Dao
interface ImageTagDao {
@@ -53,90 +44,4 @@ interface ImageTagDao {
WHERE it.imageId = :imageId AND it.visibility = 'PUBLIC'
""")
fun getTagsForImage(imageId: String): Flow<List<TagEntity>>
/**
* Insert image tag (for utilities tagging)
*/
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insert(imageTag: ImageTagEntity): Long
// ==========================================
// BURST STATISTICS - ADDED FOR STATS SECTION
// ==========================================
/**
* Get comprehensive burst statistics
* Returns total burst photos, estimated groups, and representative count
*/
@Query("""
SELECT
(SELECT COUNT(DISTINCT it.imageId)
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst') as totalBurstPhotos,
(SELECT COUNT(DISTINCT it.imageId) / 3
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst') as estimatedBurstGroups,
(SELECT COUNT(DISTINCT it.imageId)
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst_representative') as burstRepresentatives
""")
suspend fun getBurstStats(): BurstStats?
/**
* Get burst statistics (Flow version for reactive UI)
*/
@Query("""
SELECT
(SELECT COUNT(DISTINCT it.imageId)
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst') as totalBurstPhotos,
(SELECT COUNT(DISTINCT it.imageId) / 3
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst') as estimatedBurstGroups,
(SELECT COUNT(DISTINCT it.imageId)
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst_representative') as burstRepresentatives
""")
fun getBurstStatsFlow(): Flow<BurstStats?>
/**
* Get count of burst photos
*/
@Query("""
SELECT COUNT(DISTINCT it.imageId)
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst'
""")
suspend fun getBurstPhotoCount(): Int
/**
* Get count of burst representative photos
* (photos marked as the best in each burst sequence)
*/
@Query("""
SELECT COUNT(DISTINCT it.imageId)
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst_representative'
""")
suspend fun getBurstRepresentativeCount(): Int
/**
* Get estimated number of burst groups
* Assumes average of 3 photos per burst
*/
@Query("""
SELECT COUNT(DISTINCT it.imageId) / 3
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = 'burst'
""")
suspend fun getEstimatedBurstGroupCount(): Int
}

76
app/src/main/java/com/placeholder/sherpai2/data/local/dao/TagDao.kt
View File

@@ -9,16 +9,6 @@ import com.placeholder.sherpai2.data.local.entity.TagEntity
import com.placeholder.sherpai2.data.local.entity.TagWithUsage
import kotlinx.coroutines.flow.Flow
/**
* Data class for tag statistics
*/
data class TagStat(
val tagValue: String,
val tagType: String,
val imageCount: Int,
val tagId: String
)
/**
* TagDao - Tag management with face recognition integration
*
@@ -228,70 +218,4 @@ interface TagDao {
LIMIT :limit
""")
suspend fun searchTagsWithUsage(query: String, limit: Int): List<TagWithUsage>
// ==========================================
// STATISTICS QUERIES - ADDED FOR STATS SECTION
// ==========================================
/**
* Get system tag statistics (for utilities stats display)
* Returns tag value, type, and count of tagged images
*/
@Query("""
SELECT
t.value as tagValue,
t.type as tagType,
COUNT(DISTINCT it.imageId) as imageCount,
t.tagId as tagId
FROM tags t
INNER JOIN image_tags it ON t.tagId = it.tagId
WHERE t.type = 'SYSTEM'
GROUP BY t.tagId
ORDER BY imageCount DESC
""")
suspend fun getSystemTagStats(): List<TagStat>
/**
* Get system tag statistics (Flow version for reactive UI)
*/
@Query("""
SELECT
t.value as tagValue,
t.type as tagType,
COUNT(DISTINCT it.imageId) as imageCount,
t.tagId as tagId
FROM tags t
INNER JOIN image_tags it ON t.tagId = it.tagId
WHERE t.type = 'SYSTEM'
GROUP BY t.tagId
ORDER BY imageCount DESC
""")
fun getSystemTagStatsFlow(): Flow<List<TagStat>>
/**
* Get count of photos with a specific system tag
*/
@Query("""
SELECT COUNT(DISTINCT it.imageId)
FROM image_tags it
INNER JOIN tags t ON it.tagId = t.tagId
WHERE t.value = :tagValue AND t.type = 'SYSTEM'
""")
suspend fun getSystemTagCount(tagValue: String): Int
/**
* Get all tag types with counts
* Shows breakdown of SYSTEM vs USER vs GENERIC tags
*/
@Query("""
SELECT
t.type as tagValue,
t.type as tagType,
COUNT(DISTINCT t.tagId) as imageCount,
'' as tagId
FROM tags t
GROUP BY t.type
ORDER BY imageCount DESC
""")
suspend fun getTagTypeBreakdown(): List<TagStat>
}

107
app/src/main/java/com/placeholder/sherpai2/data/local/entity/Collectionentity.kt
View File

@@ -1,107 +0,0 @@
package com.placeholder.sherpai2.data.local.entity
import androidx.room.Entity
import androidx.room.Index
import androidx.room.PrimaryKey
import java.util.UUID
/**
* CollectionEntity - User-created photo collections
*
* Types:
* - SMART: Dynamic collection based on filters (re-evaluated)
* - STATIC: Fixed snapshot of photos
* - FAVORITE: Special favorites collection
*/
@Entity(
tableName = "collections",
indices = [
Index(value = ["name"]),
Index(value = ["type"]),
Index(value = ["createdAt"])
]
)
data class CollectionEntity(
@PrimaryKey
val collectionId: String,
val name: String,
val description: String?,
/**
* Cover image (auto-selected or user-chosen)
*/
val coverImageUri: String?,
/**
* SMART | STATIC | FAVORITE
*/
val type: String,
/**
* Cached photo count for performance
*/
val photoCount: Int,
val createdAt: Long,
val updatedAt: Long,
/**
* Pinned to top of collections list
*/
val isPinned: Boolean
) {
companion object {
fun createSmart(
name: String,
description: String? = null
): CollectionEntity {
val now = System.currentTimeMillis()
return CollectionEntity(
collectionId = UUID.randomUUID().toString(),
name = name,
description = description,
coverImageUri = null,
type = "SMART",
photoCount = 0,
createdAt = now,
updatedAt = now,
isPinned = false
)
}
fun createStatic(
name: String,
description: String? = null,
photoCount: Int = 0
): CollectionEntity {
val now = System.currentTimeMillis()
return CollectionEntity(
collectionId = UUID.randomUUID().toString(),
name = name,
description = description,
coverImageUri = null,
type = "STATIC",
photoCount = photoCount,
createdAt = now,
updatedAt = now,
isPinned = false
)
}
fun createFavorite(): CollectionEntity {
val now = System.currentTimeMillis()
return CollectionEntity(
collectionId = "favorites",
name = "Favorites",
description = "Your favorite photos",
coverImageUri = null,
type = "FAVORITE",
photoCount = 0,
createdAt = now,
updatedAt = now,
isPinned = true
)
}
}
}

70
app/src/main/java/com/placeholder/sherpai2/data/local/entity/Collectionfilterentity.kt
View File

@@ -1,70 +0,0 @@
package com.placeholder.sherpai2.data.local.entity
import androidx.room.Entity
import androidx.room.ForeignKey
import androidx.room.Index
import androidx.room.PrimaryKey
import java.util.UUID
/**
* CollectionFilterEntity - Filters for SMART collections
*
* Filter Types:
* - PERSON_INCLUDE: Person must be in photo
* - PERSON_EXCLUDE: Person must NOT be in photo
* - TAG_INCLUDE: Tag must be present
* - TAG_EXCLUDE: Tag must NOT be present
* - DATE_RANGE: Date filter (TODAY, THIS_WEEK, etc)
*/
@Entity(
tableName = "collection_filters",
foreignKeys = [
ForeignKey(
entity = CollectionEntity::class,
parentColumns = ["collectionId"],
childColumns = ["collectionId"],
onDelete = ForeignKey.CASCADE
)
],
indices = [
Index("collectionId"),
Index("filterType")
]
)
data class CollectionFilterEntity(
@PrimaryKey
val filterId: String,
val collectionId: String,
/**
* PERSON_INCLUDE | PERSON_EXCLUDE | TAG_INCLUDE | TAG_EXCLUDE | DATE_RANGE
*/
val filterType: String,
/**
* The filter value:
* - For PERSON_*: personId
* - For TAG_*: tag value
* - For DATE_RANGE: "TODAY", "THIS_WEEK", etc
*/
val filterValue: String,
val createdAt: Long
) {
companion object {
fun create(
collectionId: String,
filterType: String,
filterValue: String
): CollectionFilterEntity {
return CollectionFilterEntity(
filterId = UUID.randomUUID().toString(),
collectionId = collectionId,
filterType = filterType,
filterValue = filterValue,
createdAt = System.currentTimeMillis()
)
}
}
}

50
app/src/main/java/com/placeholder/sherpai2/data/local/entity/Collectionimageentity.kt
View File

@@ -1,50 +0,0 @@
package com.placeholder.sherpai2.data.local.entity
import androidx.room.Entity
import androidx.room.ForeignKey
import androidx.room.Index
/**
* CollectionImageEntity - Join table linking collections to images
*
* Supports:
* - Custom sort order
* - Timestamp when added
*/
@Entity(
tableName = "collection_images",
primaryKeys = ["collectionId", "imageId"],
foreignKeys = [
ForeignKey(
entity = CollectionEntity::class,
parentColumns = ["collectionId"],
childColumns = ["collectionId"],
onDelete = ForeignKey.CASCADE
),
ForeignKey(
entity = ImageEntity::class,
parentColumns = ["imageId"],
childColumns = ["imageId"],
onDelete = ForeignKey.CASCADE
)
],
indices = [
Index("collectionId"),
Index("imageId"),
Index("addedAt")
]
)
data class CollectionImageEntity(
val collectionId: String,
val imageId: String,
/**
* When this image was added to the collection
*/
val addedAt: Long,
/**
* Custom sort order (lower = earlier)
*/
val sortOrder: Int
)

130
app/src/main/java/com/placeholder/sherpai2/data/local/entity/ImageEntity.kt
View File

@@ -7,31 +7,19 @@ import androidx.room.PrimaryKey
/**
* Represents a single image on the device.
*
* This entity is intentionally immutable (mostly):
* This entity is intentionally immutable:
* - imageUri identifies where the image lives
* - sha256 prevents duplicates
* - capturedAt is the EXIF timestamp
*
* FACE DETECTION CACHE (mutable for performance):
* - hasFaces: Boolean flag to skip images without faces
* - faceCount: Number of faces detected (0 if no faces)
* - facesLastDetected: Timestamp of last face detection
* - faceDetectionVersion: Version number for cache invalidation
*
* These fields are populated during:
* 1. Initial model training (already detecting faces)
* 2. Utility scans (burst detection, quality analysis)
* 3. Any face detection operation
* 4. Background maintenance scans
* This table should be append-only.
*/
@Entity(
tableName = "images",
indices = [
Index(value = ["imageUri"], unique = true),
Index(value = ["sha256"], unique = true),
Index(value = ["capturedAt"]),
Index(value = ["hasFaces"]), // NEW: For fast filtering
Index(value = ["faceCount"]) // NEW: For range queries (singles, couples, groups)
Index(value = ["capturedAt"])
]
)
data class ImageEntity(
@@ -63,113 +51,5 @@ data class ImageEntity(
/**
* CAMERA | SCREENSHOT | IMPORTED
*/
val source: String,
// ============================================================================
// FACE DETECTION CACHE - Populated asynchronously
// ============================================================================
/**
* Whether this image contains any faces.
* - true: At least one face detected
* - false: No faces detected
* - null: Not yet scanned (default for newly ingested images)
*
* Use this to skip images without faces during person scanning.
*/
val hasFaces: Boolean? = null,
/**
* Number of faces detected in this image.
* - 0: No faces
* - 1: Solo person (useful for filtering)
* - 2: Couple (useful for filtering)
* - 3+: Group photo (useful for filtering)
* - null: Not yet scanned
*
* Use this for:
* - Finding solo photos of a person
* - Identifying couple photos
* - Filtering out group photos if needed
*/
val faceCount: Int? = null,
/**
* Timestamp when faces were last detected in this image.
* Used for cache invalidation logic.
*
* Invalidate cache if:
* - Image modified date > facesLastDetected
* - faceDetectionVersion < current version
*/
val facesLastDetected: Long? = null,
/**
* Face detection algorithm version.
* Increment this when improving face detection to invalidate old cache.
*
* Current version: 1
* - If detection algorithm improves, increment to 2
* - Query will re-scan images with version < 2
*/
val faceDetectionVersion: Int? = null
) {
companion object {
/**
* Current face detection algorithm version.
* Increment when making significant improvements to face detection.
*/
const val CURRENT_FACE_DETECTION_VERSION = 1
/**
* Check if face detection cache is valid.
* Invalid if:
* - Never scanned (hasFaces == null)
* - Old detection version
* - Image modified after detection (would need file system check)
*/
fun isFaceDetectionCacheValid(image: ImageEntity): Boolean {
return image.hasFaces != null &&
image.faceDetectionVersion == CURRENT_FACE_DETECTION_VERSION
}
}
/**
* Check if this image needs face detection scanning.
*/
fun needsFaceDetection(): Boolean {
return hasFaces == null ||
faceDetectionVersion == null ||
faceDetectionVersion < CURRENT_FACE_DETECTION_VERSION
}
/**
* Check if this image definitely has faces (cached).
*/
fun hasCachedFaces(): Boolean {
return hasFaces == true && !needsFaceDetection()
}
/**
* Check if this image definitely has no faces (cached).
*/
fun hasCachedNoFaces(): Boolean {
return hasFaces == false && !needsFaceDetection()
}
/**
* Get a copy with updated face detection cache.
*/
fun withFaceDetectionCache(
hasFaces: Boolean,
faceCount: Int,
timestamp: Long = System.currentTimeMillis()
): ImageEntity {
return copy(
hasFaces = hasFaces,
faceCount = faceCount,
facesLastDetected = timestamp,
faceDetectionVersion = CURRENT_FACE_DETECTION_VERSION
)
}
}
val source: String
)

18
app/src/main/java/com/placeholder/sherpai2/data/local/model/Collectionwithdetails.kt
View File

@@ -1,18 +0,0 @@
package com.placeholder.sherpai2.data.local.model
import androidx.room.ColumnInfo
import androidx.room.Embedded
import com.placeholder.sherpai2.data.local.entity.CollectionEntity
/**
* CollectionWithDetails - Collection with computed preview data
*
* Room maps this directly from query results
*/
data class CollectionWithDetails(
@Embedded
val collection: CollectionEntity,
@ColumnInfo(name = "actualPhotoCount")
val actualPhotoCount: Int
)

41
app/src/main/java/com/placeholder/sherpai2/data/local/model/ImageWithEverything.kt
View File

@@ -1,46 +1,23 @@
package com.placeholder.sherpai2.data.local.model
import androidx.room.Embedded
import androidx.room.Junction
import androidx.room.Relation
import com.placeholder.sherpai2.data.local.entity.*
/**
* ImageWithEverything - Fully hydrated image with ALL relationships
*
* Room loads this in ONE query using @Transaction!
* NO N+1 problem - all tags and face tags loaded together
*
* Usage:
* - ImageAggregateDao.observeAllImagesWithEverything()
* - Search, Explore, Albums
*/
data class ImageWithEverything(
@Embedded
val image: ImageEntity,
/**
* Tags for this image (via image_tags join table)
* Room automatically joins through ImageTagEntity
*/
@Relation(
parentColumn = "imageId",
entityColumn = "tagId",
associateBy = Junction(
value = ImageTagEntity::class,
parentColumn = "imageId",
entityColumn = "tagId"
)
)
val tags: List<TagEntity>,
/**
* Face tags for this image
* Room automatically loads all PhotoFaceTagEntity for this imageId
*/
@Relation(
parentColumn = "imageId",
entityColumn = "imageId"
)
val faceTags: List<PhotoFaceTagEntity>
)
val tags: List<ImageTagEntity>,
@Relation(
parentColumn = "imageId",
entityColumn = "imageId"
)
val events: List<ImageEventEntity>
)

327
app/src/main/java/com/placeholder/sherpai2/data/repository/Collectionrepository.kt
View File

@@ -1,327 +0,0 @@
package com.placeholder.sherpai2.data.repository
import com.placeholder.sherpai2.data.local.dao.CollectionDao
import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
import com.placeholder.sherpai2.data.local.entity.*
import com.placeholder.sherpai2.data.local.model.CollectionWithDetails
import com.placeholder.sherpai2.ui.search.DateRange
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.first
import javax.inject.Inject
import javax.inject.Singleton
/**
* CollectionRepository - Business logic for collections
*
* Handles:
* - Creating smart/static collections
* - Evaluating smart collection filters
* - Managing photos in collections
* - Export functionality
*/
@Singleton
class CollectionRepository @Inject constructor(
private val collectionDao: CollectionDao,
private val imageAggregateDao: ImageAggregateDao
) {
// ==========================================
// COLLECTION OPERATIONS
// ==========================================
suspend fun createSmartCollection(
name: String,
description: String?,
includedPeople: Set<String>,
excludedPeople: Set<String>,
includedTags: Set<String>,
excludedTags: Set<String>,
dateRange: DateRange
): String {
// Create collection
val collection = CollectionEntity.createSmart(name, description)
collectionDao.insert(collection)
// Save filters
val filters = mutableListOf<CollectionFilterEntity>()
includedPeople.forEach {
filters.add(
CollectionFilterEntity.create(
collection.collectionId,
"PERSON_INCLUDE",
it
)
)
}
excludedPeople.forEach {
filters.add(
CollectionFilterEntity.create(
collection.collectionId,
"PERSON_EXCLUDE",
it
)
)
}
includedTags.forEach {
filters.add(
CollectionFilterEntity.create(
collection.collectionId,
"TAG_INCLUDE",
it
)
)
}
excludedTags.forEach {
filters.add(
CollectionFilterEntity.create(
collection.collectionId,
"TAG_EXCLUDE",
it
)
)
}
if (dateRange != DateRange.ALL_TIME) {
filters.add(
CollectionFilterEntity.create(
collection.collectionId,
"DATE_RANGE",
dateRange.name
)
)
}
if (filters.isNotEmpty()) {
collectionDao.insertFilters(filters)
}
// Evaluate and populate
evaluateSmartCollection(collection.collectionId)
return collection.collectionId
}
suspend fun createStaticCollection(
name: String,
description: String?,
imageIds: List<String>
): String {
val collection = CollectionEntity.createStatic(name, description, imageIds.size)
collectionDao.insert(collection)
// Add images
val now = System.currentTimeMillis()
val collectionImages = imageIds.mapIndexed { index, imageId ->
CollectionImageEntity(
collectionId = collection.collectionId,
imageId = imageId,
addedAt = now,
sortOrder = index
)
}
collectionDao.addImages(collectionImages)
collectionDao.updatePhotoCount(collection.collectionId, now)
// Set cover image to first image
if (imageIds.isNotEmpty()) {
val firstImage = imageAggregateDao.observeAllImagesWithEverything()
.first()
.find { it.image.imageId == imageIds.first() }
if (firstImage != null) {
collectionDao.updateCoverImage(collection.collectionId, firstImage.image.imageUri, now)
}
}
return collection.collectionId
}
suspend fun deleteCollection(collectionId: String) {
collectionDao.deleteById(collectionId)
}
fun getAllCollections(): Flow<List<CollectionEntity>> {
return collectionDao.getAllCollections()
}
fun getCollection(collectionId: String): Flow<CollectionEntity?> {
return collectionDao.getByIdFlow(collectionId)
}
fun getCollectionWithDetails(collectionId: String): Flow<CollectionWithDetails?> {
return collectionDao.getCollectionWithDetails(collectionId)
}
// ==========================================
// IMAGE MANAGEMENT
// ==========================================
suspend fun addImageToCollection(collectionId: String, imageId: String) {
val now = System.currentTimeMillis()
val count = collectionDao.getPhotoCount(collectionId)
collectionDao.addImage(
CollectionImageEntity(
collectionId = collectionId,
imageId = imageId,
addedAt = now,
sortOrder = count
)
)
collectionDao.updatePhotoCount(collectionId, now)
// Update cover image if this is the first photo
if (count == 0) {
val images = collectionDao.getPreviewImages(collectionId)
if (images.isNotEmpty()) {
collectionDao.updateCoverImage(collectionId, images.first().imageUri, now)
}
}
}
suspend fun removeImageFromCollection(collectionId: String, imageId: String) {
collectionDao.removeImage(collectionId, imageId)
collectionDao.updatePhotoCount(collectionId, System.currentTimeMillis())
}
suspend fun toggleFavorite(imageId: String) {
val favCollection = collectionDao.getFavoriteCollection()
?: run {
// Create favorites collection if it doesn't exist
val fav = CollectionEntity.createFavorite()
collectionDao.insert(fav)
fav
}
val isFavorite = collectionDao.containsImage(favCollection.collectionId, imageId)
if (isFavorite) {
removeImageFromCollection(favCollection.collectionId, imageId)
} else {
addImageToCollection(favCollection.collectionId, imageId)
}
}
suspend fun isFavorite(imageId: String): Boolean {
val favCollection = collectionDao.getFavoriteCollection() ?: return false
return collectionDao.containsImage(favCollection.collectionId, imageId)
}
fun getImagesInCollection(collectionId: String): Flow<List<ImageEntity>> {
return collectionDao.getImagesInCollection(collectionId)
}
// ==========================================
// SMART COLLECTION EVALUATION
// ==========================================
/**
* Re-evaluate a SMART collection's filters and update its images
*/
suspend fun evaluateSmartCollection(collectionId: String) {
val collection = collectionDao.getById(collectionId) ?: return
if (collection.type != "SMART") return
val filters = collectionDao.getFilters(collectionId)
if (filters.isEmpty()) return
// Get all images
val allImages = imageAggregateDao.observeAllImagesWithEverything().first()
// Parse filters
val includedPeople = filters
.filter { it.filterType == "PERSON_INCLUDE" }
.map { it.filterValue }
.toSet()
val excludedPeople = filters
.filter { it.filterType == "PERSON_EXCLUDE" }
.map { it.filterValue }
.toSet()
val includedTags = filters
.filter { it.filterType == "TAG_INCLUDE" }
.map { it.filterValue }
.toSet()
val excludedTags = filters
.filter { it.filterType == "TAG_EXCLUDE" }
.map { it.filterValue }
.toSet()
// Filter images (same logic as SearchViewModel)
val matchingImages = allImages.filter { imageWithEverything ->
// TODO: Apply same Boolean logic as SearchViewModel
// For now, simple tag matching
val imageTags = imageWithEverything.tags.map { it.value }.toSet()
val hasIncludedTags = includedTags.isEmpty() || includedTags.all { it in imageTags }
val hasNoExcludedTags = excludedTags.isEmpty() || excludedTags.none { it in imageTags }
hasIncludedTags && hasNoExcludedTags
}.map { it.image.imageId }
// Update collection
collectionDao.clearAllImages(collectionId)
val now = System.currentTimeMillis()
val collectionImages = matchingImages.mapIndexed { index, imageId ->
CollectionImageEntity(
collectionId = collectionId,
imageId = imageId,
addedAt = now,
sortOrder = index
)
}
if (collectionImages.isNotEmpty()) {
collectionDao.addImages(collectionImages)
// Set cover image to first image
val firstImageId = matchingImages.first()
val firstImage = allImages.find { it.image.imageId == firstImageId }
if (firstImage != null) {
collectionDao.updateCoverImage(collectionId, firstImage.image.imageUri, now)
}
}
collectionDao.updatePhotoCount(collectionId, now)
}
/**
* Re-evaluate all SMART collections
*/
suspend fun evaluateAllSmartCollections() {
val collections = collectionDao.getCollectionsByType("SMART").first()
collections.forEach { collection ->
evaluateSmartCollection(collection.collectionId)
}
}
// ==========================================
// UPDATES
// ==========================================
suspend fun updateCollectionDetails(
collectionId: String,
name: String,
description: String?
) {
collectionDao.updateDetails(collectionId, name, description, System.currentTimeMillis())
}
suspend fun togglePinned(collectionId: String) {
val collection = collectionDao.getById(collectionId) ?: return
collectionDao.updatePinned(
collectionId,
!collection.isPinned,
System.currentTimeMillis()
)
}
}

23
app/src/main/java/com/placeholder/sherpai2/data/repository/Facerecognitionrepository.kt
View File

@@ -146,8 +146,6 @@ class FaceRecognitionRepository @Inject constructor(
/**
* Scan an image for faces and tag recognized persons.
*
* ALSO UPDATES FACE DETECTION CACHE for optimization.
*
* @param imageId String (from ImageEntity.imageId)
*/
suspend fun scanImage(
@@ -156,16 +154,6 @@ class FaceRecognitionRepository @Inject constructor(
threshold: Float = FaceNetModel.SIMILARITY_THRESHOLD_HIGH
): List<PhotoFaceTagEntity> = withContext(Dispatchers.Default) {
// OPTIMIZATION: Update face detection cache
// This makes future scans faster by skipping images without faces
withContext(Dispatchers.IO) {
imageDao.updateFaceDetectionCache(
imageId = imageId,
hasFaces = detectedFaces.isNotEmpty(),
faceCount = detectedFaces.size
)
}
val faceModels = faceModelDao.getAllActiveFaceModels()
if (faceModels.isEmpty()) {
@@ -388,14 +376,6 @@ class FaceRecognitionRepository @Inject constructor(
photoFaceTagDao.deleteTagsForImage(imageId)
}
/**
* Get all image IDs that have been tagged with this face model
* Used for scan optimization (skip already-tagged images)
*/
suspend fun getImageIdsForFaceModel(faceModelId: String): List<String> = withContext(Dispatchers.IO) {
photoFaceTagDao.getImageIdsForFaceModel(faceModelId)
}
fun cleanup() {
faceNetModel.close()
}
@@ -416,4 +396,5 @@ data class PersonFaceStats(
val taggedPhotoCount: Int,
val averageConfidence: Float,
val lastDetectedAt: Long?
)
)

5
app/src/main/java/com/placeholder/sherpai2/di/DatabaseModule.kt
View File

@@ -76,9 +76,4 @@ object DatabaseModule {
@Provides
fun providePhotoFaceTagDao(db: AppDatabase): PhotoFaceTagDao =
db.photoFaceTagDao()
// ===== COLLECTIONS DAOs =====
@Provides
fun provideCollectionDao(db: AppDatabase): CollectionDao =
db.collectionDao()
}

56
app/src/main/java/com/placeholder/sherpai2/domain/repository/ImageRepository.kt
View File

@@ -1,10 +1,5 @@
package com.placeholder.sherpai2.domain.repository
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.net.Uri
import com.placeholder.sherpai2.data.local.dao.FaceCacheStats
import com.placeholder.sherpai2.data.local.entity.ImageEntity
import com.placeholder.sherpai2.data.local.model.ImageWithEverything
import kotlinx.coroutines.flow.Flow
@@ -28,60 +23,11 @@ interface ImageRepository {
* This function:
* - deduplicates
* - assigns events automatically
* - BLOCKS until complete (old behavior)
*/
suspend fun ingestImages()
/**
* Ingest images with progress callback (NEW!)
*
* @param onProgress Called with (current, total) for progress updates
*/
suspend fun ingestImagesWithProgress(onProgress: (current: Int, total: Int) -> Unit)
/**
* Get total image count (NEW!)
* Fast query to check if images already loaded
*/
suspend fun getImageCount(): Int
fun getAllImages(): Flow<List<ImageWithEverything>>
fun findImagesByTag(tag: String): Flow<List<ImageWithEverything>>
fun getRecentImages(limit: Int): Flow<List<ImageWithEverything>>
// ==========================================
// FACE DETECTION CACHE - NEW METHODS
// ==========================================
/**
* Update face detection cache for a single image
* Called after detecting faces in an image
*/
suspend fun updateFaceDetectionCache(
imageId: String,
hasFaces: Boolean,
faceCount: Int
)
/**
* Get cache statistics
* Useful for displaying cache coverage in UI
*/
suspend fun getFaceCacheStats(): FaceCacheStats?
/**
* Get images that need face detection
* For background maintenance tasks
*/
suspend fun getImagesNeedingFaceDetection(): List<ImageEntity>
/**
* Load bitmap from URI with optional BitmapFactory.Options
* Used for face detection and other image processing
*/
suspend fun loadBitmap(
uri: Uri,
options: BitmapFactory.Options? = null
): Bitmap?
}
}

182
app/src/main/java/com/placeholder/sherpai2/domain/repository/ImageRepositoryImpl.kt
View File

@@ -2,13 +2,10 @@ package com.placeholder.sherpai2.domain.repository
import android.content.ContentUris
import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.net.Uri
import android.provider.MediaStore
import android.util.Log
import com.placeholder.sherpai2.data.local.dao.EventDao
import com.placeholder.sherpai2.data.local.dao.FaceCacheStats
import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
import com.placeholder.sherpai2.data.local.dao.ImageDao
import com.placeholder.sherpai2.data.local.dao.ImageEventDao
@@ -18,20 +15,11 @@ import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.withContext
import kotlinx.coroutines.yield
import java.security.MessageDigest
import java.util.*
import javax.inject.Inject
import javax.inject.Singleton
/**
* ImageRepositoryImpl - SUPER FAST ingestion
*
* OPTIMIZATIONS:
* - Skip SHA256 computation entirely (use URI as unique key)
* - Larger batch sizes (200 instead of 100)
* - Less frequent progress updates
* - No unnecessary string operations
*/
@Singleton
class ImageRepositoryImpl @Inject constructor(
private val imageDao: ImageDao,
@@ -45,57 +33,25 @@ class ImageRepositoryImpl @Inject constructor(
return aggregateDao.observeImageWithEverything(imageId)
}
override suspend fun getImageCount(): Int = withContext(Dispatchers.IO) {
return@withContext imageDao.getImageCount()
}
override suspend fun ingestImages(): Unit = withContext(Dispatchers.IO) {
ingestImagesWithProgress { _, _ -> }
}
/**
* OPTIMIZED ingestion - 2-3x faster than before!
* Ingest all images from MediaStore.
* Uses _ID and DATE_ADDED to ensure no image is skipped, even if DATE_TAKEN is identical.
*/
override suspend fun ingestImagesWithProgress(
onProgress: (current: Int, total: Int) -> Unit
): Unit = withContext(Dispatchers.IO) {
override suspend fun ingestImages(): Unit = withContext(Dispatchers.IO) {
try {
val imageList = mutableListOf<ImageEntity>()
val projection = arrayOf(
MediaStore.Images.Media._ID,
MediaStore.Images.Media.DISPLAY_NAME,
MediaStore.Images.Media.DATE_TAKEN,
MediaStore.Images.Media.DATE_ADDED,
MediaStore.Images.Media.WIDTH,
MediaStore.Images.Media.HEIGHT,
MediaStore.Images.Media.DATA
MediaStore.Images.Media.HEIGHT
)
val sortOrder = "${MediaStore.Images.Media.DATE_ADDED} ASC"
// Count total images
var totalImages = 0
context.contentResolver.query(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
arrayOf(MediaStore.Images.Media._ID),
null,
null,
null
)?.use { cursor ->
totalImages = cursor.count
}
if (totalImages == 0) {
Log.i("ImageRepository", "No images found")
return@withContext
}
Log.i("ImageRepository", "Found $totalImages images")
onProgress(0, totalImages)
// LARGER batches for speed
val batchSize = 200
var processed = 0
val ingestTime = System.currentTimeMillis()
context.contentResolver.query(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
projection,
@@ -103,86 +59,77 @@ class ImageRepositoryImpl @Inject constructor(
null,
sortOrder
)?.use { cursor ->
val idCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media._ID)
val nameCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME)
val dateTakenCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_TAKEN)
val dateAddedCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATE_ADDED)
val widthCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.WIDTH)
val heightCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.HEIGHT)
val dataCol = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA)
val batch = mutableListOf<ImageEntity>()
while (cursor.moveToNext()) {
val id = cursor.getLong(idCol)
val displayName = cursor.getString(nameCol)
val dateTaken = cursor.getLong(dateTakenCol)
val dateAdded = cursor.getLong(dateAddedCol)
val width = cursor.getInt(widthCol)
val height = cursor.getInt(heightCol)
val filePath = cursor.getString(dataCol) ?: ""
val contentUri = ContentUris.withAppendedId(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
id
val contentUri: Uri = ContentUris.withAppendedId(
MediaStore.Images.Media.EXTERNAL_CONTENT_URI, id
)
// OPTIMIZATION: Use URI as SHA256 (skip expensive hash computation)
val uriString = contentUri.toString()
val sha256 = computeSHA256(contentUri)
if (sha256 == null) {
Log.w("ImageRepository", "Skipped image: $displayName (cannot read bytes)")
continue
}
val imageEntity = ImageEntity(
imageId = UUID.randomUUID().toString(),
imageUri = uriString,
sha256 = uriString, // Fast! No file I/O
imageUri = contentUri.toString(),
sha256 = sha256,
capturedAt = if (dateTaken > 0) dateTaken else dateAdded * 1000,
ingestedAt = ingestTime,
ingestedAt = System.currentTimeMillis(),
width = width,
height = height,
source = determineSourceFast(filePath)
source = "CAMERA" // or SCREENSHOT / IMPORTED
)
batch.add(imageEntity)
processed++
// Insert batch
if (batch.size >= batchSize) {
imageDao.insertImages(batch)
batch.clear()
// Update progress less frequently (every 200 images)
withContext(Dispatchers.Main) {
onProgress(processed, totalImages)
}
yield()
}
}
// Insert remaining
if (batch.isNotEmpty()) {
imageDao.insertImages(batch)
withContext(Dispatchers.Main) {
onProgress(processed, totalImages)
}
imageList += imageEntity
Log.i("ImageRepository", "Processing image: $displayName, SHA256: $sha256")
}
}
Log.i("ImageRepository", "Ingestion complete: $processed images")
if (imageList.isNotEmpty()) {
imageDao.insertImages(imageList)
Log.i("ImageRepository", "Ingested ${imageList.size} images")
} else {
Log.i("ImageRepository", "No images found on device")
}
} catch (e: Exception) {
Log.e("ImageRepository", "Error ingesting images", e)
throw e
}
}
/**
* FAST source determination - no regex, just contains checks
* Compute SHA256 from a MediaStore Uri safely.
*/
private fun determineSourceFast(filePath: String): String {
return when {
filePath.contains("DCIM", ignoreCase = true) -> "CAMERA"
filePath.contains("Screenshot", ignoreCase = true) -> "SCREENSHOT"
filePath.contains("Download", ignoreCase = true) -> "IMPORTED"
filePath.contains("WhatsApp", ignoreCase = true) -> "IMPORTED"
else -> "CAMERA"
private fun computeSHA256(uri: Uri): String? {
return try {
val digest = MessageDigest.getInstance("SHA-256")
context.contentResolver.openInputStream(uri)?.use { input ->
val buffer = ByteArray(8192)
var read: Int
while (input.read(buffer).also { read = it } > 0) {
digest.update(buffer, 0, read)
}
} ?: return null
digest.digest().joinToString("") { "%02x".format(it) }
} catch (e: Exception) {
Log.e("ImageRepository", "Failed SHA256 for $uri", e)
null
}
}
@@ -197,41 +144,4 @@ class ImageRepositoryImpl @Inject constructor(
override fun getRecentImages(limit: Int): Flow<List<ImageWithEverything>> {
return imageDao.getRecentImages(limit)
}
// Face detection cache methods
override suspend fun updateFaceDetectionCache(
imageId: String,
hasFaces: Boolean,
faceCount: Int
) = withContext(Dispatchers.IO) {
imageDao.updateFaceDetectionCache(
imageId = imageId,
hasFaces = hasFaces,
faceCount = faceCount,
timestamp = System.currentTimeMillis(),
version = ImageEntity.CURRENT_FACE_DETECTION_VERSION
)
}
override suspend fun getFaceCacheStats(): FaceCacheStats? = withContext(Dispatchers.IO) {
imageDao.getFaceCacheStats()
}
override suspend fun getImagesNeedingFaceDetection(): List<ImageEntity> = withContext(Dispatchers.IO) {
imageDao.getImagesNeedingFaceDetection()
}
override suspend fun loadBitmap(
uri: Uri,
options: BitmapFactory.Options?
): Bitmap? = withContext(Dispatchers.IO) {
try {
context.contentResolver.openInputStream(uri)?.use { stream ->
BitmapFactory.decodeStream(stream, null, options)
}
} catch (e: Exception) {
Log.e("ImageRepository", "Failed to load bitmap from $uri", e)
null
}
}
}
}

124
app/src/main/java/com/placeholder/sherpai2/domain/repository/Imagerepositoryextensions.kt
View File

@@ -1,124 +0,0 @@
package com.placeholder.sherpai2.domain.repository
import com.placeholder.sherpai2.data.local.dao.ImageDao
import com.placeholder.sherpai2.data.local.entity.ImageEntity
/**
* Extension functions for ImageRepository to support face detection cache
*
* Add these methods to your ImageRepository interface or implementation
*/
/**
* Update face detection cache for a single image
* Called after detecting faces in an image
*/
suspend fun ImageRepository.updateFaceDetectionCache(
imageId: String,
hasFaces: Boolean,
faceCount: Int
) {
// Assuming you have access to ImageDao in your repository
// Adjust based on your actual repository structure
getImageDao().updateFaceDetectionCache(
imageId = imageId,
hasFaces = hasFaces,
faceCount = faceCount,
timestamp = System.currentTimeMillis(),
version = ImageEntity.CURRENT_FACE_DETECTION_VERSION
)
}
/**
* Get cache statistics
* Useful for displaying cache coverage in UI
*/
suspend fun ImageRepository.getFaceCacheStats() =
getImageDao().getFaceCacheStats()
/**
* Get images that need face detection
* For background maintenance tasks
*/
suspend fun ImageRepository.getImagesNeedingFaceDetection() =
getImageDao().getImagesNeedingFaceDetection()
/**
* Batch populate face detection cache
* For initial cache population or maintenance
*/
suspend fun ImageRepository.populateFaceDetectionCache(
onProgress: (current: Int, total: Int) -> Unit = { _, _ -> }
) {
val imagesToProcess = getImageDao().getImagesNeedingFaceDetection()
val total = imagesToProcess.size
imagesToProcess.forEachIndexed { index, image ->
try {
// Detect faces (implement based on your face detection logic)
val faceCount = detectFaceCount(image.imageUri)
updateFaceDetectionCache(
imageId = image.imageId,
hasFaces = faceCount > 0,
faceCount = faceCount
)
if (index % 10 == 0) {
onProgress(index, total)
}
} catch (e: Exception) {
// Skip errors, continue with next image
}
}
onProgress(total, total)
}
/**
* Helper to get ImageDao from repository
* Adjust based on your actual repository structure
*/
private fun ImageRepository.getImageDao(): ImageDao {
// This assumes your ImageRepository has a reference to ImageDao
// Adjust based on your actual implementation:
// Option 1: If ImageRepository is an interface, add this as a method
// Option 2: If it's a class, access the dao directly
// Option 3: Pass ImageDao as a parameter to these functions
throw NotImplementedError("Implement based on your repository structure")
}
/**
* Helper to detect face count
* Implement based on your face detection logic
*/
private suspend fun ImageRepository.detectFaceCount(imageUri: String): Int {
// Implement your face detection logic here
// This is a placeholder - adjust based on your FaceDetectionHelper
throw NotImplementedError("Implement based on your face detection logic")
}
/**
* ALTERNATIVE: If you prefer to add methods directly to ImageRepository,
* add these to your ImageRepository interface:
*
* interface ImageRepository {
* // ... existing methods
*
* suspend fun updateFaceDetectionCache(
* imageId: String,
* hasFaces: Boolean,
* faceCount: Int
* )
*
* suspend fun getFaceCacheStats(): FaceCacheStats?
*
* suspend fun getImagesNeedingFaceDetection(): List<ImageEntity>
*
* suspend fun populateFaceDetectionCache(
* onProgress: (current: Int, total: Int) -> Unit = { _, _ -> }
* )
* }
*
* Then implement these in your ImageRepositoryImpl class.
*/

221
app/src/main/java/com/placeholder/sherpai2/domain/usecase/Populatefacedetectioncacheusecase.kt
View File

@@ -1,221 +0,0 @@
package com.placeholder.sherpai2.domain.usecase
import android.content.Context
import com.placeholder.sherpai2.data.local.dao.ImageDao
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.tasks.await
import kotlinx.coroutines.withContext
import java.util.concurrent.atomic.AtomicInteger
import javax.inject.Inject
import javax.inject.Singleton
/**
* PopulateFaceDetectionCache - HYPER-PARALLEL face scanning
*
* STRATEGY: Use ACCURATE mode BUT with MASSIVE parallelization
* - 50 concurrent detections (not 10!)
* - Semaphore limits to prevent OOM
* - Atomic counters for thread-safe progress
* - Smaller images (768px) for speed without quality loss
*
* RESULT: ~2000-3000 images/minute on modern phones
*/
@Singleton
class PopulateFaceDetectionCacheUseCase @Inject constructor(
@ApplicationContext private val context: Context,
private val imageDao: ImageDao
) {
// Limit concurrent operations to prevent OOM
private val semaphore = Semaphore(50) // 50 concurrent detections!
/**
* HYPER-PARALLEL face detection with ACCURATE mode
*/
suspend fun execute(
onProgress: (Int, Int, String?) -> Unit = { _, _, _ -> }
): Int = withContext(Dispatchers.IO) {
// Create detector with ACCURATE mode but optimized settings
val detector = com.google.mlkit.vision.face.FaceDetection.getClient(
com.google.mlkit.vision.face.FaceDetectorOptions.Builder()
.setPerformanceMode(com.google.mlkit.vision.face.FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
.setLandmarkMode(com.google.mlkit.vision.face.FaceDetectorOptions.LANDMARK_MODE_NONE) // Don't need landmarks for cache
.setClassificationMode(com.google.mlkit.vision.face.FaceDetectorOptions.CLASSIFICATION_MODE_NONE) // Don't need classification
.setMinFaceSize(0.1f) // Detect smaller faces
.build()
)
try {
val imagesToScan = imageDao.getImagesNeedingFaceDetection()
if (imagesToScan.isEmpty()) {
return@withContext 0
}
val total = imagesToScan.size
val scanned = AtomicInteger(0)
val pendingUpdates = mutableListOf<CacheUpdate>()
val updatesMutex = kotlinx.coroutines.sync.Mutex()
// Process ALL images in parallel with semaphore control
coroutineScope {
val jobs = imagesToScan.map { image ->
async(Dispatchers.Default) {
semaphore.acquire()
try {
// Load bitmap with medium downsampling (768px = good balance)
val bitmap = loadBitmapOptimized(android.net.Uri.parse(image.imageUri))
if (bitmap == null) {
return@async CacheUpdate(image.imageId, false, 0, image.imageUri)
}
// Detect faces
val inputImage = com.google.mlkit.vision.common.InputImage.fromBitmap(bitmap, 0)
val faces = detector.process(inputImage).await()
bitmap.recycle()
CacheUpdate(
imageId = image.imageId,
hasFaces = faces.isNotEmpty(),
faceCount = faces.size,
imageUri = image.imageUri
)
} catch (e: Exception) {
CacheUpdate(image.imageId, false, 0, image.imageUri)
} finally {
semaphore.release()
// Update progress
val current = scanned.incrementAndGet()
if (current % 50 == 0 || current == total) {
onProgress(current, total, image.imageUri)
}
}
}
}
// Wait for all to complete and collect results
jobs.awaitAll().forEach { update ->
updatesMutex.withLock {
pendingUpdates.add(update)
// Batch write to DB every 100 updates
if (pendingUpdates.size >= 100) {
flushUpdates(pendingUpdates.toList())
pendingUpdates.clear()
}
}
}
// Flush remaining
updatesMutex.withLock {
if (pendingUpdates.isNotEmpty()) {
flushUpdates(pendingUpdates)
}
}
}
scanned.get()
} finally {
detector.close()
}
}
/**
* Optimized bitmap loading with configurable max dimension
*/
private fun loadBitmapOptimized(uri: android.net.Uri, maxDim: Int = 768): android.graphics.Bitmap? {
return try {
// Get dimensions
val options = android.graphics.BitmapFactory.Options().apply {
inJustDecodeBounds = true
}
context.contentResolver.openInputStream(uri)?.use { stream ->
android.graphics.BitmapFactory.decodeStream(stream, null, options)
}
// Calculate sample size
var sampleSize = 1
while (options.outWidth / sampleSize > maxDim ||
options.outHeight / sampleSize > maxDim) {
sampleSize *= 2
}
// Load with sample size
val finalOptions = android.graphics.BitmapFactory.Options().apply {
inSampleSize = sampleSize
inPreferredConfig = android.graphics.Bitmap.Config.ARGB_8888 // Better quality
}
context.contentResolver.openInputStream(uri)?.use { stream ->
android.graphics.BitmapFactory.decodeStream(stream, null, finalOptions)
}
} catch (e: Exception) {
null
}
}
/**
* Batch DB update
*/
private suspend fun flushUpdates(updates: List<CacheUpdate>) = withContext(Dispatchers.IO) {
updates.forEach { update ->
try {
imageDao.updateFaceDetectionCache(
imageId = update.imageId,
hasFaces = update.hasFaces,
faceCount = update.faceCount
)
} catch (e: Exception) {
// Skip failed updates
}
}
}
suspend fun getUncachedImageCount(): Int = withContext(Dispatchers.IO) {
imageDao.getImagesNeedingFaceDetectionCount()
}
suspend fun getCacheStats(): CacheStats = withContext(Dispatchers.IO) {
val stats = imageDao.getFaceCacheStats()
CacheStats(
totalImages = stats?.totalImages ?: 0,
imagesWithFaceCache = stats?.imagesWithFaceCache ?: 0,
imagesWithFaces = stats?.imagesWithFaces ?: 0,
imagesWithoutFaces = stats?.imagesWithoutFaces ?: 0,
needsScanning = stats?.needsScanning ?: 0
)
}
}
private data class CacheUpdate(
val imageId: String,
val hasFaces: Boolean,
val faceCount: Int,
val imageUri: String
)
data class CacheStats(
val totalImages: Int,
val imagesWithFaceCache: Int,
val imagesWithFaces: Int,
val imagesWithoutFaces: Int,
val needsScanning: Int
) {
val cacheProgress: Float
get() = if (totalImages > 0) {
imagesWithFaceCache.toFloat() / totalImages.toFloat()
} else 0f
val isComplete: Boolean
get() = needsScanning == 0
}

26
app/src/main/java/com/placeholder/sherpai2/ui/album/Albumviewmodel.kt
View File

@@ -12,6 +12,7 @@ import com.placeholder.sherpai2.data.local.entity.PersonEntity
import com.placeholder.sherpai2.data.local.entity.PhotoFaceTagEntity
import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
import com.placeholder.sherpai2.ui.search.DateRange
import com.placeholder.sherpai2.ui.search.DisplayMode
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
@@ -24,8 +25,8 @@ import javax.inject.Inject
* Features:
* - Search within album
* - Date filtering
* - Simple/Verbose toggle
* - Album stats
* - Export functionality
*/
@HiltViewModel
class AlbumViewModel @Inject constructor(
@@ -53,6 +54,10 @@ class AlbumViewModel @Inject constructor(
private val _dateRange = MutableStateFlow(DateRange.ALL_TIME)
val dateRange: StateFlow<DateRange> = _dateRange.asStateFlow()
// Display mode
private val _displayMode = MutableStateFlow(DisplayMode.SIMPLE)
val displayMode: StateFlow<DisplayMode> = _displayMode.asStateFlow()
init {
loadAlbumData()
}
@@ -88,7 +93,7 @@ class AlbumViewModel @Inject constructor(
combine(
_searchQuery,
_dateRange
) { query: String, dateRange: DateRange ->
) { query, dateRange ->
Pair(query, dateRange)
}.collectLatest { (query, dateRange) ->
val imageIds = imageTagDao.findImagesByTag(tag.tagId, 0.5f)
@@ -114,7 +119,7 @@ class AlbumViewModel @Inject constructor(
.distinctBy { it.id }
_uiState.value = AlbumUiState.Success(
albumName = tag.value.replace("_", " ").replaceFirstChar { it.uppercase() },
albumName = tag.value.replace("_", " ").capitalize(),
albumType = "Tag",
photos = imagesWithFaces,
personCount = uniquePersons.size,
@@ -133,7 +138,7 @@ class AlbumViewModel @Inject constructor(
combine(
_searchQuery,
_dateRange
) { query: String, dateRange: DateRange ->
) { query, dateRange ->
Pair(query, dateRange)
}.collectLatest { (query, dateRange) ->
val images = faceRecognitionRepository.getImagesForPerson(albumId)
@@ -179,7 +184,7 @@ class AlbumViewModel @Inject constructor(
combine(
_searchQuery,
_dateRange
) { query: String, _: DateRange ->
) { query, _ ->
query
}.collectLatest { query ->
val images = imageDao.getImagesInRange(startTime, endTime)
@@ -219,6 +224,13 @@ class AlbumViewModel @Inject constructor(
_dateRange.value = range
}
fun toggleDisplayMode() {
_displayMode.value = when (_displayMode.value) {
DisplayMode.SIMPLE -> DisplayMode.VERBOSE
DisplayMode.VERBOSE -> DisplayMode.SIMPLE
}
}
private fun isInDateRange(timestamp: Long, range: DateRange): Boolean {
return when (range) {
DateRange.ALL_TIME -> true
@@ -299,6 +311,10 @@ class AlbumViewModel @Inject constructor(
set(Calendar.MILLISECOND, 0)
}.timeInMillis
}
private fun String.capitalize(): String {
return this.replaceFirstChar { it.uppercase() }
}
}
sealed class AlbumUiState {

299
app/src/main/java/com/placeholder/sherpai2/ui/album/Albumviewscreen.kt
View File

@@ -1,9 +1,10 @@
package com.placeholder.sherpai2.ui.album
import androidx.compose.foundation.clickable
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.grid.*
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
@@ -11,24 +12,25 @@ import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import coil.compose.AsyncImage
import com.placeholder.sherpai2.ui.search.DateRange
import com.placeholder.sherpai2.ui.search.DisplayMode
import com.placeholder.sherpai2.ui.search.components.ImageGridItem
/**
* AlbumViewScreen - CLEAN VERSION with Export
* AlbumViewScreen - Beautiful album detail view
*
* REMOVED:
* - DisplayMode toggle
* - Verbose person tags
*
* ADDED:
* - Export menu (Folder, Zip, Collage)
* - Clean simple layout
* Features:
* - Album stats
* - Search within album
* - Date filtering
* - Simple/Verbose toggle
* - Clean person display
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -40,8 +42,7 @@ fun AlbumViewScreen(
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
val searchQuery by viewModel.searchQuery.collectAsStateWithLifecycle()
val dateRange by viewModel.dateRange.collectAsStateWithLifecycle()
var showExportMenu by remember { mutableStateOf(false) }
val displayMode by viewModel.displayMode.collectAsStateWithLifecycle()
Scaffold(
topBar = {
@@ -73,9 +74,15 @@ fun AlbumViewScreen(
}
},
actions = {
// Export button
IconButton(onClick = { showExportMenu = true }) {
Icon(Icons.Default.FileDownload, "Export")
IconButton(onClick = { viewModel.toggleDisplayMode() }) {
Icon(
imageVector = if (displayMode == DisplayMode.SIMPLE) {
Icons.Default.ViewList
} else {
Icons.Default.ViewModule
},
contentDescription = "Toggle view"
)
}
}
)
@@ -121,6 +128,7 @@ fun AlbumViewScreen(
state = state,
searchQuery = searchQuery,
dateRange = dateRange,
displayMode = displayMode,
onSearchChange = { viewModel.setSearchQuery(it) },
onDateRangeChange = { viewModel.setDateRange(it) },
onImageClick = onImageClick,
@@ -129,33 +137,6 @@ fun AlbumViewScreen(
}
}
}
// Export menu dialog
if (showExportMenu) {
ExportDialog(
albumName = when (val state = uiState) {
is AlbumUiState.Success -> state.albumName
else -> "Album"
},
photoCount = when (val state = uiState) {
is AlbumUiState.Success -> state.photos.size
else -> 0
},
onDismiss = { showExportMenu = false },
onExportToFolder = {
// TODO: Implement folder export
showExportMenu = false
},
onExportToZip = {
// TODO: Implement zip export
showExportMenu = false
},
onExportToCollage = {
// TODO: Implement collage export
showExportMenu = false
}
)
}
}
@Composable
@@ -163,6 +144,7 @@ private fun AlbumContent(
state: AlbumUiState.Success,
searchQuery: String,
dateRange: DateRange,
displayMode: DisplayMode,
onSearchChange: (String) -> Unit,
onDateRangeChange: (DateRange) -> Unit,
onImageClick: (String) -> Unit,
@@ -225,8 +207,7 @@ private fun AlbumContent(
.padding(horizontal = 16.dp),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
items(DateRange.entries.size) { index ->
val range = DateRange.entries[index]
items(DateRange.entries) { range ->
val isActive = dateRange == range
FilterChip(
selected = isActive,
@@ -264,6 +245,7 @@ private fun AlbumContent(
) { photo ->
PhotoCard(
photo = photo,
displayMode = displayMode,
onImageClick = onImageClick
)
}
@@ -273,11 +255,7 @@ private fun AlbumContent(
}
@Composable
private fun StatItem(
icon: androidx.compose.ui.graphics.vector.ImageVector,
label: String,
value: String
) {
private fun StatItem(icon: androidx.compose.ui.graphics.vector.ImageVector, label: String, value: String) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(4.dp)
@@ -301,180 +279,79 @@ private fun StatItem(
}
}
/**
* PhotoCard - CLEAN VERSION: Simple image + person names
*/
@Composable
private fun PhotoCard(
photo: AlbumPhoto,
displayMode: DisplayMode,
onImageClick: (String) -> Unit
) {
Card(
modifier = Modifier
.fillMaxWidth()
.aspectRatio(1f)
.clickable { onImageClick(photo.image.imageUri) },
modifier = Modifier.fillMaxWidth(),
shape = RoundedCornerShape(12.dp)
) {
Box {
// Image
AsyncImage(
model = photo.image.imageUri,
contentDescription = null,
modifier = Modifier.fillMaxSize(),
contentScale = androidx.compose.ui.layout.ContentScale.Crop
Column {
ImageGridItem(
image = photo.image,
onClick = { onImageClick(photo.image.imageUri) }
)
// Person names overlay (if any)
if (photo.persons.isNotEmpty()) {
Surface(
color = MaterialTheme.colorScheme.surface.copy(alpha = 0.9f),
modifier = Modifier
.align(Alignment.BottomCenter)
.fillMaxWidth()
) {
Text(
text = photo.persons.take(2).joinToString(", ") { it.name },
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.padding(8.dp),
maxLines = 1,
overflow = TextOverflow.Ellipsis,
fontWeight = FontWeight.Medium
)
}
}
}
}
}
/**
* Export Dialog
*/
@Composable
private fun ExportDialog(
albumName: String,
photoCount: Int,
onDismiss: () -> Unit,
onExportToFolder: () -> Unit,
onExportToZip: () -> Unit,
onExportToCollage: () -> Unit
) {
AlertDialog(
onDismissRequest = onDismiss,
icon = { Icon(Icons.Default.FileDownload, null) },
title = { Text("Export Album") },
text = {
Column(
modifier = Modifier.fillMaxWidth(),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Text(
"$photoCount photos from \"$albumName\"",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
// Export to Folder
ExportOption(
icon = Icons.Default.Folder,
title = "Export to Folder",
description = "Save all photos to a folder",
onClick = onExportToFolder
)
// Export to Zip
ExportOption(
icon = Icons.Default.FolderZip,
title = "Export as ZIP",
description = "Create a compressed archive",
onClick = onExportToZip
)
// Export to Collage (placeholder)
ExportOption(
icon = Icons.Default.GridView,
title = "Create Collage",
description = "Coming soon!",
onClick = onExportToCollage,
enabled = false
)
}
},
confirmButton = {
TextButton(onClick = onDismiss) {
Text("Cancel")
}
}
)
}
@Composable
private fun ExportOption(
icon: androidx.compose.ui.graphics.vector.ImageVector,
title: String,
description: String,
onClick: () -> Unit,
enabled: Boolean = true
) {
Surface(
modifier = Modifier
.fillMaxWidth()
.clickable(enabled = enabled, onClick = onClick),
shape = RoundedCornerShape(12.dp),
color = if (enabled) {
MaterialTheme.colorScheme.surfaceVariant
} else {
MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
}
) {
Row(
modifier = Modifier.padding(16.dp),
horizontalArrangement = Arrangement.spacedBy(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
Surface(
shape = RoundedCornerShape(8.dp),
color = MaterialTheme.colorScheme.primary.copy(
alpha = if (enabled) 1f else 0.5f
),
modifier = Modifier.size(40.dp)
) {
Box(contentAlignment = Alignment.Center) {
Icon(
icon,
contentDescription = null,
modifier = Modifier.size(24.dp),
tint = MaterialTheme.colorScheme.onPrimary
)
}
}
Column(modifier = Modifier.weight(1f)) {
Text(
title,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.SemiBold,
color = if (enabled) {
MaterialTheme.colorScheme.onSurface
} else {
MaterialTheme.colorScheme.onSurface.copy(alpha = 0.5f)
when (displayMode) {
DisplayMode.SIMPLE -> {
Surface(
color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f),
modifier = Modifier.fillMaxWidth()
) {
Text(
text = photo.persons.take(3).joinToString(", ") { it.name },
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.padding(8.dp),
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
}
}
)
Text(
description,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant.copy(
alpha = if (enabled) 1f else 0.5f
)
)
}
if (enabled) {
Icon(
Icons.Default.ChevronRight,
contentDescription = null,
tint = MaterialTheme.colorScheme.onSurfaceVariant
)
DisplayMode.VERBOSE -> {
Surface(
color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f),
modifier = Modifier.fillMaxWidth()
) {
Column(
modifier = Modifier.padding(8.dp),
verticalArrangement = Arrangement.spacedBy(4.dp)
) {
photo.persons.take(3).forEachIndexed { index, person ->
Row(
horizontalArrangement = Arrangement.spacedBy(6.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.Face,
null,
Modifier.size(14.dp),
MaterialTheme.colorScheme.primary
)
Text(
text = person.name,
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.weight(1f),
maxLines = 1,
overflow = TextOverflow.Ellipsis
)
if (index < photo.faceTags.size) {
val confidence = (photo.faceTags[index].confidence * 100).toInt()
Text(
text = "$confidence%",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.primary
)
}
}
}
}
}
}
}
}
}
}

389
app/src/main/java/com/placeholder/sherpai2/ui/collections/Collectionsscreen.kt
View File

@@ -1,389 +0,0 @@
package com.placeholder.sherpai2.ui.collections
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.grid.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import coil.compose.AsyncImage
/**
* CollectionsScreen - Main collections list
*
* Features:
* - Grid of collection cards
* - Create new collection button
* - Filter by type (all, smart, static)
* - Collection details on click
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun CollectionsScreen(
onCollectionClick: (String) -> Unit,
onCreateClick: () -> Unit,
viewModel: CollectionsViewModel = hiltViewModel()
) {
val collections by viewModel.collections.collectAsStateWithLifecycle()
val creationState by viewModel.creationState.collectAsStateWithLifecycle()
Scaffold(
topBar = {
TopAppBar(
title = {
Column {
Text(
"Collections",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
viewModel.getCollectionSummary(),
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
},
actions = {
IconButton(onClick = { viewModel.refreshSmartCollections() }) {
Icon(Icons.Default.Refresh, "Refresh smart collections")
}
}
)
},
floatingActionButton = {
ExtendedFloatingActionButton(
onClick = onCreateClick,
icon = { Icon(Icons.Default.Add, null) },
text = { Text("New Collection") }
)
}
) { paddingValues ->
if (collections.isEmpty()) {
EmptyState(
onCreateClick = onCreateClick,
modifier = Modifier
.fillMaxSize()
.padding(paddingValues)
)
} else {
LazyVerticalGrid(
columns = GridCells.Adaptive(160.dp),
modifier = Modifier
.fillMaxSize()
.padding(paddingValues),
contentPadding = PaddingValues(16.dp),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
items(
items = collections,
key = { it.collectionId }
) { collection ->
CollectionCard(
collection = collection,
onClick = { onCollectionClick(collection.collectionId) },
onPinToggle = { viewModel.togglePinned(collection.collectionId) },
onDelete = { viewModel.deleteCollection(collection.collectionId) }
)
}
}
}
}
// Creation dialog (shown from SearchScreen or other places)
when (val state = creationState) {
is CreationState.SmartFromSearch -> {
CreateCollectionDialog(
title = "Smart Collection",
subtitle = "${state.photoCount} photos matching filters",
onConfirm = { name, description ->
viewModel.createSmartCollection(name, description)
},
onDismiss = { viewModel.cancelCreation() }
)
}
is CreationState.StaticFromImages -> {
CreateCollectionDialog(
title = "Static Collection",
subtitle = "${state.photoCount} photos selected",
onConfirm = { name, description ->
viewModel.createStaticCollection(name, description)
},
onDismiss = { viewModel.cancelCreation() }
)
}
CreationState.None -> { /* No dialog */ }
}
}
@Composable
private fun CollectionCard(
collection: com.placeholder.sherpai2.data.local.entity.CollectionEntity,
onClick: () -> Unit,
onPinToggle: () -> Unit,
onDelete: () -> Unit
) {
var showMenu by remember { mutableStateOf(false) }
Card(
modifier = Modifier
.fillMaxWidth()
.aspectRatio(0.75f)
.clickable(onClick = onClick),
shape = RoundedCornerShape(16.dp)
) {
Box(modifier = Modifier.fillMaxSize()) {
// Cover image or placeholder
if (collection.coverImageUri != null) {
AsyncImage(
model = collection.coverImageUri,
contentDescription = null,
modifier = Modifier.fillMaxSize(),
contentScale = androidx.compose.ui.layout.ContentScale.Crop
)
} else {
// Placeholder
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.surfaceVariant
) {
Icon(
Icons.Default.Photo,
contentDescription = null,
modifier = Modifier
.fillMaxSize()
.padding(48.dp),
tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.3f)
)
}
}
// Gradient overlay for text
Surface(
modifier = Modifier
.fillMaxWidth()
.align(Alignment.BottomCenter),
color = Color.Black.copy(alpha = 0.6f)
) {
Column(
modifier = Modifier.padding(12.dp),
verticalArrangement = Arrangement.spacedBy(4.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
collection.name,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold,
color = Color.White,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f)
)
Box {
IconButton(
onClick = { showMenu = true },
modifier = Modifier.size(24.dp)
) {
Icon(
Icons.Default.MoreVert,
null,
tint = Color.White
)
}
DropdownMenu(
expanded = showMenu,
onDismissRequest = { showMenu = false }
) {
DropdownMenuItem(
text = { Text(if (collection.isPinned) "Unpin" else "Pin") },
onClick = {
onPinToggle()
showMenu = false
},
leadingIcon = {
Icon(
if (collection.isPinned) Icons.Default.PushPin else Icons.Default.PushPin,
null
)
}
)
DropdownMenuItem(
text = { Text("Delete") },
onClick = {
onDelete()
showMenu = false
},
leadingIcon = {
Icon(Icons.Default.Delete, null)
}
)
}
}
}
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Type badge
Surface(
color = when (collection.type) {
"SMART" -> Color(0xFF2196F3)
"FAVORITE" -> Color(0xFFF44336)
else -> Color(0xFF4CAF50)
}.copy(alpha = 0.9f),
shape = RoundedCornerShape(4.dp)
) {
Text(
when (collection.type) {
"SMART" -> "Smart"
"FAVORITE" -> "Fav"
else -> "Static"
},
modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
style = MaterialTheme.typography.labelSmall,
color = Color.White
)
}
// Photo count
Text(
"${collection.photoCount} photos",
style = MaterialTheme.typography.bodySmall,
color = Color.White.copy(alpha = 0.9f)
)
}
}
}
// Pinned indicator
if (collection.isPinned) {
Icon(
Icons.Default.PushPin,
contentDescription = "Pinned",
modifier = Modifier
.align(Alignment.TopEnd)
.padding(8.dp)
.size(20.dp),
tint = Color.White
)
}
}
}
}
@Composable
private fun EmptyState(
onCreateClick: () -> Unit,
modifier: Modifier = Modifier
) {
Box(
modifier = modifier,
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
Icon(
Icons.Default.Collections,
contentDescription = null,
modifier = Modifier.size(72.dp),
tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
)
Text(
"No Collections Yet",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
"Create collections from searches or manually select photos",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
Button(onClick = onCreateClick) {
Icon(Icons.Default.Add, null, Modifier.size(18.dp))
Spacer(Modifier.width(8.dp))
Text("Create Collection")
}
}
}
}
@Composable
private fun CreateCollectionDialog(
title: String,
subtitle: String,
onConfirm: (name: String, description: String?) -> Unit,
onDismiss: () -> Unit
) {
var name by remember { mutableStateOf("") }
var description by remember { mutableStateOf("") }
AlertDialog(
onDismissRequest = onDismiss,
icon = { Icon(Icons.Default.Collections, null) },
title = {
Column {
Text(title)
Text(
subtitle,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
},
text = {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
OutlinedTextField(
value = name,
onValueChange = { name = it },
label = { Text("Collection Name") },
singleLine = true,
modifier = Modifier.fillMaxWidth()
)
OutlinedTextField(
value = description,
onValueChange = { description = it },
label = { Text("Description (optional)") },
maxLines = 3,
modifier = Modifier.fillMaxWidth()
)
}
},
confirmButton = {
Button(
onClick = {
if (name.isNotBlank()) {
onConfirm(name.trim(), description.trim().ifBlank { null })
}
},
enabled = name.isNotBlank()
) {
Text("Create")
}
},
dismissButton = {
TextButton(onClick = onDismiss) {
Text("Cancel")
}
}
)
}

159
app/src/main/java/com/placeholder/sherpai2/ui/collections/Collectionsviewmodel.kt
View File

@@ -1,159 +0,0 @@
package com.placeholder.sherpai2.ui.collections
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.placeholder.sherpai2.data.local.entity.CollectionEntity
import com.placeholder.sherpai2.data.repository.CollectionRepository
import com.placeholder.sherpai2.ui.search.DateRange
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
import javax.inject.Inject
/**
* CollectionsViewModel - Manages collections list and creation
*/
@HiltViewModel
class CollectionsViewModel @Inject constructor(
private val collectionRepository: CollectionRepository
) : ViewModel() {
// All collections
val collections: StateFlow<List<CollectionEntity>> = collectionRepository
.getAllCollections()
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5000),
initialValue = emptyList()
)
// UI state for creation dialog
private val _creationState = MutableStateFlow<CreationState>(CreationState.None)
val creationState: StateFlow<CreationState> = _creationState.asStateFlow()
// ==========================================
// COLLECTION CREATION
// ==========================================
fun startSmartCollectionFromSearch(
includedPeople: Set<String>,
excludedPeople: Set<String>,
includedTags: Set<String>,
excludedTags: Set<String>,
dateRange: DateRange,
photoCount: Int
) {
_creationState.value = CreationState.SmartFromSearch(
includedPeople = includedPeople,
excludedPeople = excludedPeople,
includedTags = includedTags,
excludedTags = excludedTags,
dateRange = dateRange,
photoCount = photoCount
)
}
fun startStaticCollectionFromImages(imageIds: List<String>) {
_creationState.value = CreationState.StaticFromImages(
imageIds = imageIds,
photoCount = imageIds.size
)
}
fun cancelCreation() {
_creationState.value = CreationState.None
}
fun createSmartCollection(name: String, description: String?) {
val state = _creationState.value as? CreationState.SmartFromSearch ?: return
viewModelScope.launch {
collectionRepository.createSmartCollection(
name = name,
description = description,
includedPeople = state.includedPeople,
excludedPeople = state.excludedPeople,
includedTags = state.includedTags,
excludedTags = state.excludedTags,
dateRange = state.dateRange
)
_creationState.value = CreationState.None
}
}
fun createStaticCollection(name: String, description: String?) {
val state = _creationState.value as? CreationState.StaticFromImages ?: return
viewModelScope.launch {
collectionRepository.createStaticCollection(
name = name,
description = description,
imageIds = state.imageIds
)
_creationState.value = CreationState.None
}
}
// ==========================================
// COLLECTION MANAGEMENT
// ==========================================
fun deleteCollection(collectionId: String) {
viewModelScope.launch {
collectionRepository.deleteCollection(collectionId)
}
}
fun togglePinned(collectionId: String) {
viewModelScope.launch {
collectionRepository.togglePinned(collectionId)
}
}
fun refreshSmartCollections() {
viewModelScope.launch {
collectionRepository.evaluateAllSmartCollections()
}
}
// ==========================================
// STATISTICS
// ==========================================
fun getCollectionSummary(): String {
val count = collections.value.size
val smartCount = collections.value.count { it.type == "SMART" }
val staticCount = collections.value.count { it.type == "STATIC" }
return when {
count == 0 -> "No collections yet"
smartCount > 0 && staticCount > 0 -> "$smartCount smart • $staticCount static"
smartCount > 0 -> "$smartCount smart collections"
staticCount > 0 -> "$staticCount static collections"
else -> "$count collections"
}
}
}
/**
* Creation state for dialogs
*/
sealed class CreationState {
object None : CreationState()
data class SmartFromSearch(
val includedPeople: Set<String>,
val excludedPeople: Set<String>,
val includedTags: Set<String>,
val excludedTags: Set<String>,
val dateRange: DateRange,
val photoCount: Int
) : CreationState()
data class StaticFromImages(
val imageIds: List<String>,
val photoCount: Int
) : CreationState()
}

136
app/src/main/java/com/placeholder/sherpai2/ui/explore/Explorescreen.kt
View File

@@ -23,28 +23,57 @@ import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
/**
* CLEANED ExploreScreen - No gradient header banner
*
* Removed:
* - Gradient header box (lines 46-75) that created banner effect
* - "Explore" title (MainScreen shows it)
* ExploreScreen - REDESIGNED
*
* Features:
* - Rectangular album cards (compact)
* - Rectangular album cards (more compact)
* - Stories section (recent highlights)
* - Clickable navigation to AlbumViewScreen
* - Beautiful gradients and icons
* - Mobile-friendly scrolling
*/
@Composable
fun ExploreScreen(
onAlbumClick: (albumType: String, albumId: String) -> Unit,
viewModel: ExploreViewModel = hiltViewModel(),
modifier: Modifier = Modifier
viewModel: ExploreViewModel = hiltViewModel()
) {
val uiState by viewModel.uiState.collectAsState()
Box(modifier = modifier.fillMaxSize()) {
Column(
modifier = Modifier
.fillMaxSize()
.background(MaterialTheme.colorScheme.surface)
) {
// Header with gradient
Box(
modifier = Modifier
.fillMaxWidth()
.background(
Brush.verticalGradient(
colors = listOf(
MaterialTheme.colorScheme.primaryContainer,
MaterialTheme.colorScheme.surface
)
)
)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
) {
Text(
text = "Explore",
style = MaterialTheme.typography.headlineLarge,
fontWeight = FontWeight.Bold
)
Text(
text = "Your photo collection organized",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
when (val state = uiState) {
is ExploreViewModel.ExploreUiState.Loading -> {
Box(
@@ -54,18 +83,12 @@ fun ExploreScreen(
CircularProgressIndicator()
}
}
is ExploreViewModel.ExploreUiState.Success -> {
if (state.smartAlbums.isEmpty()) {
EmptyExploreView()
} else {
ExploreContent(
smartAlbums = state.smartAlbums,
onAlbumClick = onAlbumClick
)
}
ExploreContent(
smartAlbums = state.smartAlbums,
onAlbumClick = onAlbumClick
)
}
is ExploreViewModel.ExploreUiState.Error -> {
Box(
modifier = Modifier.fillMaxSize(),
@@ -73,25 +96,17 @@ fun ExploreScreen(
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(12.dp),
modifier = Modifier.padding(32.dp)
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Icon(
Icons.Default.Error,
contentDescription = null,
modifier = Modifier.size(64.dp),
modifier = Modifier.size(48.dp),
tint = MaterialTheme.colorScheme.error
)
Text(
text = "Error Loading Albums",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
text = state.message,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = androidx.compose.ui.text.style.TextAlign.Center
color = MaterialTheme.colorScheme.error
)
}
}
@@ -100,9 +115,6 @@ fun ExploreScreen(
}
}
/**
* Main content - scrollable album sections
*/
@Composable
private fun ExploreContent(
smartAlbums: List<SmartAlbum>,
@@ -115,13 +127,10 @@ private fun ExploreContent(
) {
// Stories Section (Recent Highlights)
item {
val storyAlbums = smartAlbums.filter { it.imageCount > 0 }.take(10)
if (storyAlbums.isNotEmpty()) {
StoriesSection(
albums = storyAlbums,
onAlbumClick = onAlbumClick
)
}
StoriesSection(
albums = smartAlbums.filter { it.imageCount > 0 }.take(10),
onAlbumClick = onAlbumClick
)
}
// Time-based Albums
@@ -216,7 +225,7 @@ private fun ExploreContent(
}
/**
* Stories section - circular album previews
* Stories section - Instagram-style circular highlights
*/
@Composable
private fun StoriesSection(
@@ -285,8 +294,7 @@ private fun StoryCircle(
style = MaterialTheme.typography.labelSmall,
maxLines = 2,
modifier = Modifier.width(80.dp),
fontWeight = FontWeight.Medium,
textAlign = androidx.compose.ui.text.style.TextAlign.Center
fontWeight = FontWeight.Medium
)
Text(
@@ -334,7 +342,7 @@ private fun AlbumSection(
}
/**
* Rectangular album card - compact design
* Rectangular album card - more compact than square
*/
@Composable
private fun AlbumCard(
@@ -390,44 +398,6 @@ private fun AlbumCard(
}
}
/**
* Empty state
*/
@Composable
private fun EmptyExploreView() {
Box(
modifier = Modifier
.fillMaxSize()
.padding(32.dp),
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
Icon(
Icons.Default.PhotoAlbum,
contentDescription = null,
modifier = Modifier.size(80.dp),
tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
)
Text(
"No Albums Yet",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
"Add photos to your collection to see smart albums",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = androidx.compose.ui.text.style.TextAlign.Center
)
}
}
}
/**
* Get navigation parameters for album
*/

333
app/src/main/java/com/placeholder/sherpai2/ui/imagedetail/ImageDetailScreen.kt
View File

@@ -1,323 +1,86 @@
package com.placeholder.sherpai2.ui.imagedetail
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavController
import coil.compose.AsyncImage
import com.placeholder.sherpai2.data.local.entity.TagEntity
import com.placeholder.sherpai2.ui.imagedetail.viewmodel.ImageDetailViewModel
import net.engawapg.lib.zoomable.rememberZoomState
import net.engawapg.lib.zoomable.zoomable
import java.net.URLEncoder
/**
* ImageDetailScreen - COMPLETE with navigation and tags
* ImageDetailScreen
*
* Features:
* - Full-screen zoomable image
* - Previous/Next navigation buttons
* - Image counter (3/45)
* - Tags button (toggle show/hide)
* - Shows all tags on photo
* Purpose:
* - Add tags
* - Remove tags
* - Validate write propagation
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ImageDetailScreen(
modifier: Modifier = Modifier,
imageUri: String,
onBack: () -> Unit,
navController: NavController? = null,
allImageUris: List<String> = emptyList(), // Pass from caller
viewModel: ImageDetailViewModel = hiltViewModel() // ✅ FIXED: Use hiltViewModel
onBack: () -> Unit
) {
val viewModel: ImageDetailViewModel = androidx.lifecycle.viewmodel.compose.viewModel()
LaunchedEffect(imageUri) {
viewModel.loadImage(imageUri)
}
val tags by viewModel.tags.collectAsStateWithLifecycle()
var showTags by remember { mutableStateOf(false) }
// Navigation state
val currentIndex = if (allImageUris.isNotEmpty()) allImageUris.indexOf(imageUri) else -1
val hasNavigation = allImageUris.isNotEmpty() && currentIndex >= 0
val canGoPrevious = hasNavigation && currentIndex > 0
val canGoNext = hasNavigation && currentIndex < allImageUris.size - 1
var newTag by remember { mutableStateOf("") }
Scaffold(
topBar = {
TopAppBar(
title = {
if (hasNavigation) {
Text(
"${currentIndex + 1} / ${allImageUris.size}",
style = MaterialTheme.typography.titleMedium
)
} else {
Text("Photo")
}
},
navigationIcon = {
IconButton(onClick = onBack) {
Icon(Icons.Default.ArrowBack, "Back")
}
},
actions = {
// Tags toggle button
IconButton(onClick = { showTags = !showTags }) {
Row(
horizontalArrangement = Arrangement.spacedBy(4.dp),
verticalAlignment = Alignment.CenterVertically
) {
if (tags.isNotEmpty()) {
Badge(
containerColor = if (showTags)
MaterialTheme.colorScheme.primary
else
MaterialTheme.colorScheme.surfaceVariant
) {
Text(
tags.size.toString(),
color = if (showTags)
MaterialTheme.colorScheme.onPrimary
else
MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
Icon(
if (showTags) Icons.Default.Label else Icons.Default.LocalOffer,
"Show Tags",
tint = if (showTags)
MaterialTheme.colorScheme.primary
else
MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
// Previous button (only show if has navigation)
if (hasNavigation && navController != null) {
IconButton(
onClick = {
if (canGoPrevious) {
val prevUri = allImageUris[currentIndex - 1]
val encoded = URLEncoder.encode(prevUri, "UTF-8")
navController.navigate("image_detail/$encoded") {
popUpTo("image_detail/${URLEncoder.encode(imageUri, "UTF-8")}") {
inclusive = true
}
}
}
},
enabled = canGoPrevious
) {
Icon(Icons.Default.KeyboardArrowLeft, "Previous")
}
// Next button (only show if has navigation)
IconButton(
onClick = {
if (canGoNext) {
val nextUri = allImageUris[currentIndex + 1]
val encoded = URLEncoder.encode(nextUri, "UTF-8")
navController.navigate("image_detail/$encoded") {
popUpTo("image_detail/${URLEncoder.encode(imageUri, "UTF-8")}") {
inclusive = true
}
}
}
},
enabled = canGoNext
) {
Icon(Icons.Default.KeyboardArrowRight, "Next")
}
}
}
)
}
) { paddingValues ->
Column(
modifier = modifier
.fillMaxSize()
.padding(paddingValues)
) {
// Zoomable image
Box(
modifier = Modifier
.fillMaxWidth()
.weight(1f)
.background(Color.Black)
) {
val zoomState = rememberZoomState()
AsyncImage(
model = imageUri,
contentDescription = "Photo",
modifier = Modifier
.fillMaxSize()
.zoomable(zoomState),
contentScale = ContentScale.Fit
)
}
// Tags panel (slides up when enabled)
if (showTags) {
Surface(
modifier = Modifier
.fillMaxWidth()
.heightIn(max = 300.dp),
color = MaterialTheme.colorScheme.surfaceVariant,
tonalElevation = 3.dp
) {
LazyColumn(
contentPadding = PaddingValues(16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
item {
Text(
"Tags (${tags.size})",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
}
if (tags.isEmpty()) {
item {
Text(
"No tags yet",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
items(tags, key = { it.tagId }) { tag ->
TagCard(
tag = tag,
onRemove = { viewModel.removeTag(tag) }
)
}
}
}
}
}
}
}
@Composable
private fun TagCard(
tag: TagEntity,
onRemove: () -> Unit
) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = when (tag.type) {
"PERSON" -> MaterialTheme.colorScheme.primaryContainer
"SYSTEM" -> MaterialTheme.colorScheme.secondaryContainer
else -> MaterialTheme.colorScheme.tertiaryContainer
}
),
shape = RoundedCornerShape(8.dp)
Column(
modifier = modifier
.fillMaxSize()
.padding(12.dp)
) {
Row(
AsyncImage(
model = imageUri,
contentDescription = null,
modifier = Modifier
.fillMaxWidth()
.padding(12.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
.aspectRatio(1f)
)
Spacer(modifier = Modifier.height(12.dp))
OutlinedTextField(
value = newTag,
onValueChange = { newTag = it },
label = { Text("Add tag") },
modifier = Modifier.fillMaxWidth()
)
Button(
onClick = {
viewModel.addTag(newTag)
newTag = ""
},
modifier = Modifier.padding(top = 8.dp)
) {
Column(modifier = Modifier.weight(1f)) {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
imageVector = when (tag.type) {
"PERSON" -> Icons.Default.Face
"SYSTEM" -> Icons.Default.AutoAwesome
else -> Icons.Default.Label
},
contentDescription = null,
modifier = Modifier.size(20.dp),
tint = when (tag.type) {
"PERSON" -> MaterialTheme.colorScheme.primary
"SYSTEM" -> MaterialTheme.colorScheme.secondary
else -> MaterialTheme.colorScheme.tertiary
}
)
Text(
text = tag.getDisplayValue(), // Uses TagEntity's built-in method
style = MaterialTheme.typography.bodyLarge,
fontWeight = FontWeight.SemiBold
)
}
Text("Add Tag")
}
Row(
horizontalArrangement = Arrangement.spacedBy(4.dp),
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = tag.type.lowercase().replaceFirstChar { it.uppercase() },
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
Text(
text = "•",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
Text(
text = formatTimestamp(tag.createdAt),
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
Spacer(modifier = Modifier.height(16.dp))
// Remove button (only for user-created tags)
if (tag.isUserTag()) {
IconButton(
onClick = onRemove,
colors = IconButtonDefaults.iconButtonColors(
contentColor = MaterialTheme.colorScheme.error
)
) {
Icon(Icons.Default.Delete, "Remove tag")
tags.forEach { tag ->
Row(
horizontalArrangement = Arrangement.SpaceBetween,
modifier = Modifier.fillMaxWidth()
) {
Text(tag.value)
TextButton(onClick = { viewModel.removeTag(tag) }) {
Text("Remove")
}
}
}
}
}
/**
* Format timestamp to relative time
*/
private fun formatTimestamp(timestamp: Long): String {
val now = System.currentTimeMillis()
val diff = now - timestamp
return when {
diff < 60_000 -> "Just now"
diff < 3600_000 -> "${diff / 60_000}m ago"
diff < 86400_000 -> "${diff / 3600_000}h ago"
diff < 604800_000 -> "${diff / 86400_000}d ago"
else -> "${diff / 604800_000}w ago"
}
}

911
app/src/main/java/com/placeholder/sherpai2/ui/modelinventory/Personinventoryscreen.kt
View File

File diff suppressed because it is too large Load Diff

511
app/src/main/java/com/placeholder/sherpai2/ui/modelinventory/Personinventoryviewmodel.kt
View File

@@ -1,288 +1,349 @@
package com.placeholder.sherpai2.ui.modelinventory
import android.content.Context
import android.app.Application
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.net.Uri
import androidx.lifecycle.ViewModel
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.face.FaceDetection
import com.google.mlkit.vision.face.FaceDetectorOptions
import com.placeholder.sherpai2.data.local.dao.FaceModelDao
import com.placeholder.sherpai2.data.local.dao.ImageDao
import com.placeholder.sherpai2.data.local.dao.PersonDao
import com.placeholder.sherpai2.data.local.dao.PhotoFaceTagDao
import com.placeholder.sherpai2.data.local.entity.FaceModelEntity
import com.placeholder.sherpai2.data.local.entity.ImageEntity
import com.placeholder.sherpai2.data.local.entity.PersonEntity
import com.placeholder.sherpai2.data.local.entity.PhotoFaceTagEntity
import com.placeholder.sherpai2.ml.FaceNetModel
import com.placeholder.sherpai2.data.repository.DetectedFace
import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
import com.placeholder.sherpai2.data.repository.PersonFaceStats
import com.placeholder.sherpai2.domain.repository.ImageRepository
import com.placeholder.sherpai2.ml.ThresholdStrategy
import com.placeholder.sherpai2.ml.ImageQuality
import com.placeholder.sherpai2.ml.DetectionContext
import com.placeholder.sherpai2.util.DebugFlags
import com.placeholder.sherpai2.util.DiagnosticLogger
import dagger.hilt.android.lifecycle.HiltViewModel
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.Semaphore
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.sync.withPermit
import kotlinx.coroutines.withContext
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.tasks.await
import javax.inject.Inject
/**
* SPEED OPTIMIZED - Realistic 3-4x improvement
* PersonInventoryViewModel - Enhanced with smart threshold strategy
*
* KEY OPTIMIZATIONS:
* ✅ Semaphore(12) - Balanced (was 5, can't do 50 = ANR)
* ✅ Downsample to 512px for detection (4x fewer pixels)
* ✅ RGB_565 for detection (2x less memory)
* ✅ Load only face regions for embedding (not full images)
* ✅ Reuse single FaceNetModel (no init overhead)
* ✅ No chunking (parallel processing)
* ✅ Batch DB writes (100 at once)
* ✅ Keep ACCURATE mode (need quality)
* ✅ Leverage face cache (populated on startup)
*
* RESULT: 119 images in ~90sec (was ~5min)
* Toggle diagnostics in DebugFlags.kt:
* - ENABLE_FACE_RECOGNITION_LOGGING = true/false
* - USE_LIBERAL_THRESHOLDS = true/false
*/
@HiltViewModel
class PersonInventoryViewModel @Inject constructor(
@ApplicationContext private val context: Context,
private val personDao: PersonDao,
private val faceModelDao: FaceModelDao,
private val photoFaceTagDao: PhotoFaceTagDao,
private val imageDao: ImageDao
) : ViewModel() {
application: Application,
private val faceRecognitionRepository: FaceRecognitionRepository,
private val imageRepository: ImageRepository
) : AndroidViewModel(application) {
private val _personsWithModels = MutableStateFlow<List<PersonWithModelInfo>>(emptyList())
val personsWithModels: StateFlow<List<PersonWithModelInfo>> = _personsWithModels.asStateFlow()
private val _uiState = MutableStateFlow<InventoryUiState>(InventoryUiState.Loading)
val uiState: StateFlow<InventoryUiState> = _uiState.asStateFlow()
private val _scanningState = MutableStateFlow<ScanningState>(ScanningState.Idle)
val scanningState: StateFlow<ScanningState> = _scanningState.asStateFlow()
private val semaphore = Semaphore(12) // Sweet spot
private val batchUpdateMutex = Mutex()
private val BATCH_DB_SIZE = 100
private val faceDetector by lazy {
val options = FaceDetectorOptions.Builder()
.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
.setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
.setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
.setMinFaceSize(0.10f)
.build()
FaceDetection.getClient(options)
}
data class PersonWithStats(
val person: PersonEntity,
val stats: PersonFaceStats
)
sealed class InventoryUiState {
object Loading : InventoryUiState()
data class Success(val persons: List<PersonWithStats>) : InventoryUiState()
data class Error(val message: String) : InventoryUiState()
}
sealed class ScanningState {
object Idle : ScanningState()
data class Scanning(
val personId: String,
val personName: String,
val progress: Int,
val total: Int,
val facesFound: Int,
val facesDetected: Int = 0
) : ScanningState()
data class Complete(
val personName: String,
val facesFound: Int,
val imagesScanned: Int,
val totalFacesDetected: Int = 0
) : ScanningState()
}
init {
loadPersons()
}
private fun loadPersons() {
fun loadPersons() {
viewModelScope.launch {
try {
val persons = personDao.getAllPersons()
val personsWithInfo = persons.map { person ->
val faceModel = faceModelDao.getFaceModelByPersonId(person.id)
val tagCount = faceModel?.let { model ->
photoFaceTagDao.getImageIdsForFaceModel(model.id).size
} ?: 0
PersonWithModelInfo(person = person, faceModel = faceModel, taggedPhotoCount = tagCount)
}
_personsWithModels.value = personsWithInfo
} catch (e: Exception) {
_personsWithModels.value = emptyList()
}
}
}
_uiState.value = InventoryUiState.Loading
fun deletePerson(personId: String) {
viewModelScope.launch(Dispatchers.IO) {
try {
val faceModel = faceModelDao.getFaceModelByPersonId(personId)
if (faceModel != null) {
photoFaceTagDao.deleteTagsForFaceModel(faceModel.id)
faceModelDao.deleteFaceModelById(faceModel.id)
}
personDao.deleteById(personId)
loadPersons()
} catch (e: Exception) {}
}
}
val persons = faceRecognitionRepository.getPersonsWithFaceModels()
fun scanForPerson(personId: String) {
viewModelScope.launch(Dispatchers.IO) {
try {
val person = personDao.getPersonById(personId) ?: return@launch
val faceModel = faceModelDao.getFaceModelByPersonId(personId) ?: return@launch
_scanningState.value = ScanningState.Scanning(person.name, 0, 0, 0, 0.0)
val imagesToScan = imageDao.getImagesWithFaces()
val alreadyTaggedImageIds = photoFaceTagDao.getImageIdsForFaceModel(faceModel.id).toSet()
val untaggedImages = imagesToScan.filter { it.imageId !in alreadyTaggedImageIds }
val totalToScan = untaggedImages.size
_scanningState.value = ScanningState.Scanning(person.name, 0, totalToScan, 0, 0.0)
if (totalToScan == 0) {
_scanningState.value = ScanningState.Complete(person.name, 0)
return@launch
}
val detectorOptions = FaceDetectorOptions.Builder()
.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
.setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
.setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
.setMinFaceSize(0.15f)
.build()
val detector = FaceDetection.getClient(detectorOptions)
val modelEmbedding = faceModel.getEmbeddingArray()
val faceNetModel = FaceNetModel(context)
val trainingCount = faceModel.trainingImageCount
val baseThreshold = ThresholdStrategy.getLiberalThreshold(trainingCount)
val completed = AtomicInteger(0)
val facesFound = AtomicInteger(0)
val startTime = System.currentTimeMillis()
val batchMatches = mutableListOf<Triple<String, String, Float>>()
// ALL PARALLEL
withContext(Dispatchers.Default) {
val jobs = untaggedImages.map { image ->
async {
semaphore.withPermit {
processImage(image, detector, faceNetModel, modelEmbedding, trainingCount, baseThreshold, personId, faceModel.id, batchMatches, batchUpdateMutex, completed, facesFound, startTime, totalToScan, person.name)
}
}
val personsWithStats = persons.mapNotNull { person ->
val stats = faceRecognitionRepository.getPersonFaceStats(person.id)
if (stats != null) {
PersonWithStats(person, stats)
} else {
null
}
jobs.awaitAll()
}
}.sortedByDescending { it.stats.taggedPhotoCount }
batchUpdateMutex.withLock {
if (batchMatches.isNotEmpty()) {
saveBatchMatches(batchMatches, faceModel.id)
batchMatches.clear()
}
}
detector.close()
faceNetModel.close()
_scanningState.value = ScanningState.Complete(person.name, facesFound.get())
loadPersons()
_uiState.value = InventoryUiState.Success(personsWithStats)
} catch (e: Exception) {
_scanningState.value = ScanningState.Error(e.message ?: "Scanning failed")
_uiState.value = InventoryUiState.Error(
e.message ?: "Failed to load persons"
)
}
}
}
private suspend fun processImage(
image: ImageEntity, detector: com.google.mlkit.vision.face.FaceDetector, faceNetModel: FaceNetModel,
modelEmbedding: FloatArray, trainingCount: Int, baseThreshold: Float, personId: String, faceModelId: String,
batchMatches: MutableList<Triple<String, String, Float>>, batchUpdateMutex: Mutex,
completed: AtomicInteger, facesFound: AtomicInteger, startTime: Long, totalToScan: Int, personName: String
) {
try {
val uri = Uri.parse(image.imageUri)
// Get dimensions
val sizeOpts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, sizeOpts) }
// Load downsampled for detection (512px, RGB_565)
val detectionBitmap = loadDownsampled(uri, 512, Bitmap.Config.RGB_565) ?: return
val mlImage = InputImage.fromBitmap(detectionBitmap, 0)
val faces = com.google.android.gms.tasks.Tasks.await(detector.process(mlImage))
if (faces.isEmpty()) {
detectionBitmap.recycle()
return
fun deletePerson(personId: String, faceModelId: String) {
viewModelScope.launch {
try {
faceRecognitionRepository.deleteFaceModel(faceModelId)
loadPersons()
} catch (e: Exception) {
_uiState.value = InventoryUiState.Error(
"Failed to delete: ${e.message}"
)
}
}
}
val scaleX = sizeOpts.outWidth.toFloat() / detectionBitmap.width
val scaleY = sizeOpts.outHeight.toFloat() / detectionBitmap.height
/**
* Scan library with SMART threshold selection
*/
fun scanLibraryForPerson(personId: String, faceModelId: String) {
viewModelScope.launch {
try {
if (DebugFlags.ENABLE_FACE_RECOGNITION_LOGGING) {
DiagnosticLogger.i("=== STARTING LIBRARY SCAN (ENHANCED) ===")
DiagnosticLogger.i("PersonId: $personId")
DiagnosticLogger.i("FaceModelId: $faceModelId")
}
val imageQuality = ThresholdStrategy.estimateImageQuality(sizeOpts.outWidth, sizeOpts.outHeight)
val detectionContext = ThresholdStrategy.estimateDetectionContext(faces.size)
val threshold = ThresholdStrategy.getOptimalThreshold(trainingCount, imageQuality, detectionContext).coerceAtMost(baseThreshold)
val currentState = _uiState.value
val person = if (currentState is InventoryUiState.Success) {
currentState.persons.find { it.person.id == personId }?.person
} else null
for (face in faces) {
val scaledBounds = android.graphics.Rect(
(face.boundingBox.left * scaleX).toInt(),
(face.boundingBox.top * scaleY).toInt(),
(face.boundingBox.right * scaleX).toInt(),
(face.boundingBox.bottom * scaleY).toInt()
val personName = person?.name ?: "Unknown"
// Get face model to determine training count
val faceModel = faceRecognitionRepository.getFaceModelById(faceModelId)
val trainingCount = faceModel?.trainingImageCount ?: 15
DiagnosticLogger.i("Training count: $trainingCount")
val allImages = imageRepository.getAllImages().first()
val totalImages = allImages.size
DiagnosticLogger.i("Total images in library: $totalImages")
_scanningState.value = ScanningState.Scanning(
personId = personId,
personName = personName,
progress = 0,
total = totalImages,
facesFound = 0,
facesDetected = 0
)
val faceBitmap = loadFaceRegion(uri, scaledBounds) ?: continue
val faceEmbedding = faceNetModel.generateEmbedding(faceBitmap)
val similarity = faceNetModel.calculateSimilarity(faceEmbedding, modelEmbedding)
faceBitmap.recycle()
var facesFound = 0
var totalFacesDetected = 0
if (similarity >= threshold) {
batchUpdateMutex.withLock {
batchMatches.add(Triple(personId, image.imageId, similarity))
facesFound.incrementAndGet()
if (batchMatches.size >= BATCH_DB_SIZE) {
saveBatchMatches(batchMatches.toList(), faceModelId)
batchMatches.clear()
allImages.forEachIndexed { index, imageWithEverything ->
val image = imageWithEverything.image
DiagnosticLogger.d("--- Image ${index + 1}/$totalImages ---")
DiagnosticLogger.d("ImageId: ${image.imageId}")
// Detect faces with ML Kit
val detectedFaces = detectFacesInImage(image.imageUri)
totalFacesDetected += detectedFaces.size
DiagnosticLogger.d("Faces detected: ${detectedFaces.size}")
if (detectedFaces.isNotEmpty()) {
// ENHANCED: Calculate image quality
val imageQuality = ThresholdStrategy.estimateImageQuality(
width = image.width,
height = image.height
)
// ENHANCED: Estimate detection context
val detectionContext = ThresholdStrategy.estimateDetectionContext(
faceCount = detectedFaces.size,
faceAreaRatio = if (detectedFaces.isNotEmpty()) {
calculateFaceAreaRatio(detectedFaces[0], image.width, image.height)
} else 0f
)
// ENHANCED: Get smart threshold
val scanThreshold = if (DebugFlags.USE_LIBERAL_THRESHOLDS) {
ThresholdStrategy.getLiberalThreshold(trainingCount)
} else {
ThresholdStrategy.getOptimalThreshold(
trainingCount = trainingCount,
imageQuality = imageQuality,
detectionContext = detectionContext
)
}
DiagnosticLogger.d("Quality: $imageQuality, Context: $detectionContext")
DiagnosticLogger.d("Using threshold: $scanThreshold")
// Scan image with smart threshold
val tags = faceRecognitionRepository.scanImage(
imageId = image.imageId,
detectedFaces = detectedFaces,
threshold = scanThreshold
)
DiagnosticLogger.d("Tags created: ${tags.size}")
tags.forEach { tag ->
DiagnosticLogger.d(" Tag: model=${tag.faceModelId.take(8)}, conf=${String.format("%.3f", tag.confidence)}")
}
val matchingTags = tags.filter { it.faceModelId == faceModelId }
DiagnosticLogger.d("Matching tags for target: ${matchingTags.size}")
facesFound += matchingTags.size
}
_scanningState.value = ScanningState.Scanning(
personId = personId,
personName = personName,
progress = index + 1,
total = totalImages,
facesFound = facesFound,
facesDetected = totalFacesDetected
)
}
DiagnosticLogger.i("=== SCAN COMPLETE ===")
DiagnosticLogger.i("Images scanned: $totalImages")
DiagnosticLogger.i("Faces detected: $totalFacesDetected")
DiagnosticLogger.i("Faces matched: $facesFound")
DiagnosticLogger.i("Hit rate: ${if (totalFacesDetected > 0) (facesFound * 100 / totalFacesDetected) else 0}%")
_scanningState.value = ScanningState.Complete(
personName = personName,
facesFound = facesFound,
imagesScanned = totalImages,
totalFacesDetected = totalFacesDetected
)
loadPersons()
delay(3000)
_scanningState.value = ScanningState.Idle
} catch (e: Exception) {
DiagnosticLogger.e("Scan failed", e)
_scanningState.value = ScanningState.Idle
_uiState.value = InventoryUiState.Error(
"Scan failed: ${e.message}"
)
}
}
}
private suspend fun detectFacesInImage(imageUri: String): List<DetectedFace> = withContext(Dispatchers.Default) {
try {
val uri = Uri.parse(imageUri)
val inputStream = getApplication<Application>().contentResolver.openInputStream(uri)
val bitmap = BitmapFactory.decodeStream(inputStream)
inputStream?.close()
if (bitmap == null) {
DiagnosticLogger.w("Failed to load bitmap from: $imageUri")
return@withContext emptyList()
}
DiagnosticLogger.d("Bitmap: ${bitmap.width}x${bitmap.height}")
val image = InputImage.fromBitmap(bitmap, 0)
val faces = faceDetector.process(image).await()
DiagnosticLogger.d("ML Kit found ${faces.size} faces")
faces.mapNotNull { face ->
val boundingBox = face.boundingBox
val croppedFace = try {
val left = boundingBox.left.coerceAtLeast(0)
val top = boundingBox.top.coerceAtLeast(0)
val width = boundingBox.width().coerceAtMost(bitmap.width - left)
val height = boundingBox.height().coerceAtMost(bitmap.height - top)
if (width > 0 && height > 0) {
Bitmap.createBitmap(bitmap, left, top, width, height)
} else {
null
}
} catch (e: Exception) {
DiagnosticLogger.e("Face crop failed", e)
null
}
if (croppedFace != null) {
DetectedFace(
croppedBitmap = croppedFace,
boundingBox = boundingBox
)
} else {
null
}
}
detectionBitmap.recycle()
} catch (e: Exception) {
} finally {
val curr = completed.incrementAndGet()
val elapsed = (System.currentTimeMillis() - startTime) / 1000.0
_scanningState.value = ScanningState.Scanning(personName, curr, totalToScan, facesFound.get(), if (elapsed > 0) curr / elapsed else 0.0)
DiagnosticLogger.e("Face detection failed: $imageUri", e)
emptyList()
}
}
private fun loadDownsampled(uri: Uri, maxDim: Int, format: Bitmap.Config): Bitmap? {
return try {
val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, opts) }
var sample = 1
while (opts.outWidth / sample > maxDim || opts.outHeight / sample > maxDim) sample *= 2
val finalOpts = BitmapFactory.Options().apply { inSampleSize = sample; inPreferredConfig = format }
context.contentResolver.openInputStream(uri)?.use { BitmapFactory.decodeStream(it, null, finalOpts) }
} catch (e: Exception) { null }
/**
* Calculate face area ratio (for context detection)
*/
private fun calculateFaceAreaRatio(
face: DetectedFace,
imageWidth: Int,
imageHeight: Int
): Float {
val faceArea = face.boundingBox.width() * face.boundingBox.height()
val imageArea = imageWidth * imageHeight
return faceArea.toFloat() / imageArea.toFloat()
}
private fun loadFaceRegion(uri: Uri, bounds: android.graphics.Rect): Bitmap? {
return try {
val full = context.contentResolver.openInputStream(uri)?.use {
BitmapFactory.decodeStream(it, null, BitmapFactory.Options().apply { inPreferredConfig = Bitmap.Config.ARGB_8888 })
} ?: return null
suspend fun getPersonImages(personId: String) =
faceRecognitionRepository.getImagesForPerson(personId)
val safeLeft = bounds.left.coerceIn(0, full.width - 1)
val safeTop = bounds.top.coerceIn(0, full.height - 1)
val safeWidth = bounds.width().coerceAtMost(full.width - safeLeft)
val safeHeight = bounds.height().coerceAtMost(full.height - safeTop)
val cropped = Bitmap.createBitmap(full, safeLeft, safeTop, safeWidth, safeHeight)
full.recycle()
cropped
} catch (e: Exception) { null }
override fun onCleared() {
super.onCleared()
faceDetector.close()
}
private suspend fun saveBatchMatches(matches: List<Triple<String, String, Float>>, faceModelId: String) {
val tags = matches.map { (_, imageId, confidence) ->
PhotoFaceTagEntity.create(imageId, faceModelId, android.graphics.Rect(0, 0, 100, 100), confidence, FloatArray(128))
}
photoFaceTagDao.insertTags(tags)
}
fun resetScanningState() { _scanningState.value = ScanningState.Idle }
fun refresh() { loadPersons() }
}
sealed class ScanningState {
object Idle : ScanningState()
data class Scanning(val personName: String, val completed: Int, val total: Int, val facesFound: Int, val speed: Double) : ScanningState()
data class Complete(val personName: String, val facesFound: Int) : ScanningState()
data class Error(val message: String) : ScanningState()
}
data class PersonWithModelInfo(val person: PersonEntity, val faceModel: FaceModelEntity?, val taggedPhotoCount: Int)
}

33
app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppDestinations.kt
View File

@@ -40,14 +40,7 @@ sealed class AppDestinations(
description = "Browse smart albums"
)
data object Collections : AppDestinations(
route = AppRoutes.COLLECTIONS,
icon = Icons.Default.Collections,
label = "Collections",
description = "Your photo collections"
)
// ImageDetail is not in draw er (internal navigation only)
// ImageDetail is not in drawer (internal navigation only)
// ==================
// FACE RECOGNITION
@@ -56,22 +49,22 @@ sealed class AppDestinations(
data object Inventory : AppDestinations(
route = AppRoutes.INVENTORY,
icon = Icons.Default.Face,
label = "People Models",
description = "Existing Face Detection Models"
label = "People",
description = "Trained face models"
)
data object Train : AppDestinations(
route = AppRoutes.TRAIN,
icon = Icons.Default.ModelTraining,
label = "Create Model",
description = "Create a new Person Model"
label = "Train",
description = "Train new person"
)
data object Models : AppDestinations(
route = AppRoutes.MODELS,
icon = Icons.Default.SmartToy,
label = "Generative",
description = "AI Creation"
label = "Models",
description = "AI model management"
)
// ==================
@@ -85,8 +78,8 @@ sealed class AppDestinations(
description = "Manage photo tags"
)
data object UTILITIES : AppDestinations(
route = AppRoutes.UTILITIES,
data object Upload : AppDestinations(
route = AppRoutes.UPLOAD,
icon = Icons.Default.UploadFile,
label = "Upload",
description = "Add new photos"
@@ -111,8 +104,7 @@ sealed class AppDestinations(
// Photo browsing section
val photoDestinations = listOf(
AppDestinations.Search,
AppDestinations.Explore,
AppDestinations.Collections
AppDestinations.Explore
)
// Face recognition section
@@ -125,7 +117,7 @@ val faceRecognitionDestinations = listOf(
// Organization section
val organizationDestinations = listOf(
AppDestinations.Tags,
AppDestinations.UTILITIES
AppDestinations.Upload
)
// Settings (separate, pinned to bottom)
@@ -144,12 +136,11 @@ fun getDestinationByRoute(route: String?): AppDestinations? {
return when (route) {
AppRoutes.SEARCH -> AppDestinations.Search
AppRoutes.EXPLORE -> AppDestinations.Explore
AppRoutes.COLLECTIONS -> AppDestinations.Collections
AppRoutes.INVENTORY -> AppDestinations.Inventory
AppRoutes.TRAIN -> AppDestinations.Train
AppRoutes.MODELS -> AppDestinations.Models
AppRoutes.TAGS -> AppDestinations.Tags
AppRoutes.UTILITIES -> AppDestinations.UTILITIES
AppRoutes.UPLOAD -> AppDestinations.Upload
AppRoutes.SETTINGS -> AppDestinations.Settings
else -> null
}

176
app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppNavHost.kt
View File

@@ -7,40 +7,41 @@ import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.Modifier
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.NavHostController
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.navArgument
import com.placeholder.sherpai2.ui.devscreens.DummyScreen
import com.placeholder.sherpai2.ui.album.AlbumViewScreen
import com.placeholder.sherpai2.ui.album.AlbumViewModel
import com.placeholder.sherpai2.ui.collections.CollectionsScreen
import com.placeholder.sherpai2.ui.collections.CollectionsViewModel
import com.placeholder.sherpai2.ui.explore.ExploreScreen
import com.placeholder.sherpai2.ui.imagedetail.ImageDetailScreen
import com.placeholder.sherpai2.ui.modelinventory.PersonInventoryScreen
import com.placeholder.sherpai2.ui.search.SearchScreen
import com.placeholder.sherpai2.ui.search.SearchViewModel
import com.placeholder.sherpai2.ui.tags.TagManagementScreen
import com.placeholder.sherpai2.ui.trainingprep.ImageSelectorScreen
import com.placeholder.sherpai2.ui.trainingprep.ScanResultsScreen
import com.placeholder.sherpai2.ui.trainingprep.ScanningState
import com.placeholder.sherpai2.ui.trainingprep.TrainViewModel
import com.placeholder.sherpai2.ui.trainingprep.TrainingScreen
import com.placeholder.sherpai2.ui.trainingprep.TrainingPhotoSelectorScreen
import com.placeholder.sherpai2.ui.utilities.PhotoUtilitiesScreen
import java.net.URLDecoder
import java.net.URLEncoder
/**
* AppNavHost - UPDATED with TrainingPhotoSelector integration
* AppNavHost - Main navigation graph
* UPDATED: Added Explore and Tags screens
*
* Changes:
* - Replaced ImageSelectorScreen with TrainingPhotoSelectorScreen
* - Shows ONLY photos with faces (hasFaces=true)
* - Multi-select photo gallery for training
* - Filters 10,000 photos → ~500 with faces for fast selection
* Complete flow:
* - Photo browsing (Search, Explore, Detail)
* - Face recognition (Inventory, Train)
* - Organization (Tags, Upload)
* - Settings
*
* Features:
* - URL encoding for safe navigation
* - Proper back stack management
* - State preservation
* - Beautiful placeholders
*/
@Composable
fun AppNavHost(
@@ -59,64 +60,37 @@ fun AppNavHost(
/**
* SEARCH SCREEN
* Main photo browser with face tag search
*/
composable(AppRoutes.SEARCH) {
val searchViewModel: SearchViewModel = hiltViewModel()
val collectionsViewModel: CollectionsViewModel = hiltViewModel()
SearchScreen(
searchViewModel = searchViewModel,
onImageClick = { imageUri ->
ImageListHolder.clear()
val encodedUri = URLEncoder.encode(imageUri, "UTF-8")
navController.navigate("${AppRoutes.IMAGE_DETAIL}/$encodedUri")
},
onAlbumClick = { tagValue ->
navController.navigate("album/tag/$tagValue")
},
onSaveToCollection = { includedPeople, excludedPeople, includedTags, excludedTags, dateRange, photoCount ->
collectionsViewModel.startSmartCollectionFromSearch(
includedPeople = includedPeople,
excludedPeople = excludedPeople,
includedTags = includedTags,
excludedTags = excludedTags,
dateRange = dateRange,
photoCount = photoCount
)
}
)
}
/**
* EXPLORE SCREEN
* Browse smart albums (auto-generated from tags)
*/
composable(AppRoutes.EXPLORE) {
ExploreScreen(
onAlbumClick = { albumType, albumId ->
navController.navigate("album/$albumType/$albumId")
}
)
}
println("Album clicked: type=$albumType id=$albumId")
/**
* COLLECTIONS SCREEN
*/
composable(AppRoutes.COLLECTIONS) {
val collectionsViewModel: CollectionsViewModel = hiltViewModel()
CollectionsScreen(
viewModel = collectionsViewModel,
onCollectionClick = { collectionId ->
navController.navigate("album/collection/$collectionId")
},
onCreateClick = {
navController.navigate(AppRoutes.SEARCH)
// Example future navigation
// navController.navigate("${AppRoutes.ALBUM}/$albumType/$albumId")
}
)
}
/**
* IMAGE DETAIL SCREEN
* Single photo view with metadata
*/
composable(
route = "${AppRoutes.IMAGE_DETAIL}/{imageUri}",
@@ -130,54 +104,9 @@ fun AppNavHost(
?.let { URLDecoder.decode(it, "UTF-8") }
?: error("imageUri missing from navigation")
val allImageUris = ImageListHolder.getImageList()
ImageDetailScreen(
imageUri = imageUri,
onBack = {
ImageListHolder.clear()
navController.popBackStack()
},
navController = navController,
allImageUris = allImageUris
)
}
/**
* ALBUM VIEW SCREEN
*/
composable(
route = "album/{albumType}/{albumId}",
arguments = listOf(
navArgument("albumType") {
type = NavType.StringType
},
navArgument("albumId") {
type = NavType.StringType
}
)
) {
val albumViewModel: AlbumViewModel = hiltViewModel()
val uiState by albumViewModel.uiState.collectAsStateWithLifecycle()
AlbumViewScreen(
onBack = {
navController.popBackStack()
},
onImageClick = { imageUri ->
val allImageUris = if (uiState is com.placeholder.sherpai2.ui.album.AlbumUiState.Success) {
(uiState as com.placeholder.sherpai2.ui.album.AlbumUiState.Success)
.photos
.map { it.image.imageUri }
} else {
emptyList()
}
ImageListHolder.setImageList(allImageUris)
val encodedUri = URLEncoder.encode(imageUri, "UTF-8")
navController.navigate("${AppRoutes.IMAGE_DETAIL}/$encodedUri")
}
onBack = { navController.popBackStack() }
)
}
@@ -187,24 +116,42 @@ fun AppNavHost(
/**
* PERSON INVENTORY SCREEN
* View all trained face models
*
* Features:
* - List all trained people
* - Show stats (training count, tagged photos, confidence)
* - Delete models
* - View photos containing each person
*/
composable(AppRoutes.INVENTORY) {
PersonInventoryScreen(
onNavigateToPersonDetail = { personId ->
onViewPersonPhotos = { personId ->
// Navigate back to search
// TODO: In future, add person filter to search screen
navController.navigate(AppRoutes.SEARCH)
}
)
}
/**
* TRAINING FLOW - UPDATED with TrainingPhotoSelector
* TRAINING FLOW
* Train new face recognition model
*
* Flow:
* 1. TrainingScreen (select images button)
* 2. ImageSelectorScreen (pick 15-50 photos)
* 3. ScanResultsScreen (validation + name input)
* 4. Training completes → navigate to Inventory
*/
composable(AppRoutes.TRAIN) { entry ->
val trainViewModel: TrainViewModel = hiltViewModel()
val uiState by trainViewModel.uiState.collectAsState()
// Get images selected from ImageSelector
val selectedUris = entry.savedStateHandle.get<List<Uri>>("selected_image_uris")
// Start scanning when new images are selected
LaunchedEffect(selectedUris) {
if (selectedUris != null && uiState is ScanningState.Idle) {
trainViewModel.scanAndTagFaces(selectedUris)
@@ -214,17 +161,19 @@ fun AppNavHost(
when (uiState) {
is ScanningState.Idle -> {
// Show start screen with "Select Images" button
TrainingScreen(
onSelectImages = {
// Navigate to custom photo selector (shows only faces!)
navController.navigate(AppRoutes.TRAINING_PHOTO_SELECTOR)
navController.navigate(AppRoutes.IMAGE_SELECTOR)
}
)
}
else -> {
// Show validation results and training UI
ScanResultsScreen(
state = uiState,
onFinish = {
// After training, go to inventory to see new person
navController.navigate(AppRoutes.INVENTORY) {
popUpTo(AppRoutes.TRAIN) { inclusive = true }
}
@@ -235,23 +184,13 @@ fun AppNavHost(
}
/**
* TRAINING PHOTO SELECTOR - NEW: Custom gallery with face filtering
*
* Replaces native photo picker with custom selector that:
* - Shows ONLY photos with hasFaces=true
* - Multi-select with visual feedback
* - Face count badges on each photo
* - Enforces minimum 15 photos
*
* Result: User browses ~500 photos instead of 10,000!
* IMAGE SELECTOR SCREEN
* Pick images for training (internal screen)
*/
composable(AppRoutes.TRAINING_PHOTO_SELECTOR) {
TrainingPhotoSelectorScreen(
onBack = {
navController.popBackStack()
},
onPhotosSelected = { uris ->
// Pass selected URIs back to training flow
composable(AppRoutes.IMAGE_SELECTOR) {
ImageSelectorScreen(
onImagesSelected = { uris ->
// Pass selected URIs back to Train screen
navController.previousBackStackEntry
?.savedStateHandle
?.set("selected_image_uris", uris)
@@ -262,6 +201,7 @@ fun AppNavHost(
/**
* MODELS SCREEN
* AI model management (placeholder)
*/
composable(AppRoutes.MODELS) {
DummyScreen(
@@ -276,16 +216,21 @@ fun AppNavHost(
/**
* TAGS SCREEN
* Manage photo tags with auto-tagging features
*/
composable(AppRoutes.TAGS) {
TagManagementScreen()
}
/**
* UTILITIES SCREEN
* UPLOAD SCREEN
* Import new photos (placeholder)
*/
composable(AppRoutes.UTILITIES) {
PhotoUtilitiesScreen()
composable(AppRoutes.UPLOAD) {
DummyScreen(
title = "Upload",
subtitle = "Add photos to your library"
)
}
// ==========================================
@@ -294,6 +239,7 @@ fun AppNavHost(
/**
* SETTINGS SCREEN
* App preferences (placeholder)
*/
composable(AppRoutes.SETTINGS) {
DummyScreen(

14
app/src/main/java/com/placeholder/sherpai2/ui/navigation/AppRoutes.kt
View File

@@ -13,7 +13,7 @@ package com.placeholder.sherpai2.ui.navigation
object AppRoutes {
// Photo browsing
const val SEARCH = "search"
const val EXPLORE = "explore"
const val EXPLORE = "explore" // UPDATED: Changed from TOUR
const val IMAGE_DETAIL = "IMAGE_DETAIL"
// Face recognition
@@ -23,22 +23,14 @@ object AppRoutes {
// Organization
const val TAGS = "tags"
const val UTILITIES = "utilities"
const val UPLOAD = "upload"
// Settings
const val SETTINGS = "settings"
// Internal training flow screens
const val IMAGE_SELECTOR = "Image Selection" // DEPRECATED - kept for reference only
const val TRAINING_PHOTO_SELECTOR = "training_photo_selector" // NEW: Face-filtered gallery
const val IMAGE_SELECTOR = "Image Selection"
const val CROP_SCREEN = "CROP_SCREEN"
const val TRAINING_SCREEN = "TRAINING_SCREEN"
const val ScanResultsScreen = "First Scan Results"
// Album view
const val ALBUM_VIEW = "album/{albumType}/{albumId}"
fun albumRoute(albumType: String, albumId: String) = "album/$albumType/$albumId"
// Collections
const val COLLECTIONS = "collections"
}

21
app/src/main/java/com/placeholder/sherpai2/ui/navigation/Imagelistholder.kt
View File

@@ -1,21 +0,0 @@
package com.placeholder.sherpai2.ui.navigation
/**
* Simple holder for passing image lists between screens
* Used for prev/next navigation in ImageDetailScreen
*/
object ImageListHolder {
private var imageUris: List<String> = emptyList()
fun setImageList(uris: List<String>) {
imageUris = uris
}
fun getImageList(): List<String> {
return imageUris
}
fun clear() {
imageUris = emptyList()
}
}

130
app/src/main/java/com/placeholder/sherpai2/ui/presentation/AppDrawerContent.kt
View File

@@ -2,9 +2,7 @@ package com.placeholder.sherpai2.ui.presentation
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
@@ -20,8 +18,8 @@ import androidx.compose.material.icons.filled.*
import com.placeholder.sherpai2.ui.navigation.AppRoutes
/**
* SLIMMED DOWN AppDrawer - 280dp width, inline logo, cleaner sections
* NOW WITH: Scrollable support for small phones + Collections item
* Beautiful app drawer with sections, gradient header, and polish
* UPDATED: Tour → Explore
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -30,17 +28,12 @@ fun AppDrawerContent(
onDestinationClicked: (String) -> Unit
) {
ModalDrawerSheet(
modifier = Modifier.width(280.dp), // SLIMMER (was 300dp)
modifier = Modifier.width(300.dp),
drawerContainerColor = MaterialTheme.colorScheme.surface
) {
// SCROLLABLE Column - works on small phones!
Column(
modifier = Modifier
.fillMaxSize()
.verticalScroll(rememberScrollState())
) {
Column(modifier = Modifier.fillMaxSize()) {
// ===== COMPACT HEADER - Icon + Text Inline =====
// ===== BEAUTIFUL GRADIENT HEADER =====
Box(
modifier = Modifier
.fillMaxWidth()
@@ -52,64 +45,60 @@ fun AppDrawerContent(
)
)
)
.padding(20.dp) // Reduced padding
.padding(24.dp)
) {
Row(
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
Column(
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
// App icon - smaller
// App icon/logo area
Surface(
modifier = Modifier.size(48.dp), // Smaller (was 56dp)
shape = RoundedCornerShape(14.dp),
modifier = Modifier.size(56.dp),
shape = RoundedCornerShape(16.dp),
color = MaterialTheme.colorScheme.primary,
shadowElevation = 4.dp
) {
Box(contentAlignment = Alignment.Center) {
Icon(
Icons.Default.Terrain, // Mountain theme!
Icons.Default.Face,
contentDescription = null,
modifier = Modifier.size(28.dp),
modifier = Modifier.size(32.dp),
tint = MaterialTheme.colorScheme.onPrimary
)
}
}
// Text next to icon
Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
Text(
"SherpAI",
style = MaterialTheme.typography.titleLarge, // Smaller (was headlineMedium)
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.onSurface
)
Text(
"SherpAI",
style = MaterialTheme.typography.headlineMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.onSurface
)
Text(
"Face Recognition",
style = MaterialTheme.typography.bodySmall, // Smaller
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
Text(
"Face Recognition System",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
Spacer(modifier = Modifier.height(4.dp)) // Reduced spacing
Spacer(modifier = Modifier.height(8.dp))
// ===== NAVIGATION SECTIONS =====
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 8.dp), // Reduced padding
verticalArrangement = Arrangement.spacedBy(2.dp) // Tighter spacing
.weight(1f)
.padding(horizontal = 12.dp),
verticalArrangement = Arrangement.spacedBy(4.dp)
) {
// Photos Section
DrawerSection(title = "Photos")
val photoItems = listOf(
DrawerItem(AppRoutes.SEARCH, "Search", Icons.Default.Search),
DrawerItem(AppRoutes.EXPLORE, "Explore", Icons.Default.Explore),
DrawerItem(AppRoutes.COLLECTIONS, "Collections", Icons.Default.Collections) // NEW!
DrawerItem(AppRoutes.SEARCH, "Search", Icons.Default.Search, "Find photos by tag or person"),
DrawerItem(AppRoutes.EXPLORE, "Explore", Icons.Default.Explore, "Browse smart albums")
)
photoItems.forEach { item ->
@@ -120,15 +109,15 @@ fun AppDrawerContent(
)
}
Spacer(modifier = Modifier.height(4.dp))
Spacer(modifier = Modifier.height(8.dp))
// Face Recognition Section
DrawerSection(title = "Face Recognition")
val faceItems = listOf(
DrawerItem(AppRoutes.INVENTORY, "People", Icons.Default.Face),
DrawerItem(AppRoutes.TRAIN, "Create Person", Icons.Default.ModelTraining),
DrawerItem(AppRoutes.MODELS, "Models", Icons.Default.SmartToy)
DrawerItem(AppRoutes.INVENTORY, "People", Icons.Default.Face, "Trained face models"),
DrawerItem(AppRoutes.TRAIN, "Train", Icons.Default.ModelTraining, "Train new person"),
DrawerItem(AppRoutes.MODELS, "Models", Icons.Default.SmartToy, "AI model management")
)
faceItems.forEach { item ->
@@ -139,14 +128,14 @@ fun AppDrawerContent(
)
}
Spacer(modifier = Modifier.height(4.dp))
Spacer(modifier = Modifier.height(8.dp))
// Organization Section
DrawerSection(title = "Organization")
val orgItems = listOf(
DrawerItem(AppRoutes.TAGS, "Tags", Icons.AutoMirrored.Filled.Label),
DrawerItem(AppRoutes.UTILITIES, "Utilities", Icons.Default.Build)
DrawerItem(AppRoutes.TAGS, "Tags", Icons.AutoMirrored.Filled.Label, "Manage photo tags"),
DrawerItem(AppRoutes.UPLOAD, "Upload", Icons.Default.UploadFile, "Add new photos")
)
orgItems.forEach { item ->
@@ -157,11 +146,11 @@ fun AppDrawerContent(
)
}
Spacer(modifier = Modifier.height(8.dp))
Spacer(modifier = Modifier.weight(1f))
// Settings at bottom
HorizontalDivider(
modifier = Modifier.padding(vertical = 6.dp),
modifier = Modifier.padding(vertical = 8.dp),
color = MaterialTheme.colorScheme.outlineVariant
)
@@ -169,34 +158,35 @@ fun AppDrawerContent(
item = DrawerItem(
AppRoutes.SETTINGS,
"Settings",
Icons.Default.Settings
Icons.Default.Settings,
"App preferences"
),
selected = AppRoutes.SETTINGS == currentRoute,
onClick = { onDestinationClicked(AppRoutes.SETTINGS) }
)
Spacer(modifier = Modifier.height(16.dp)) // Bottom padding for scroll
Spacer(modifier = Modifier.height(8.dp))
}
}
}
}
/**
* Section header - more compact
* Section header in drawer
*/
@Composable
private fun DrawerSection(title: String) {
Text(
text = title,
style = MaterialTheme.typography.labelSmall, // Smaller
style = MaterialTheme.typography.labelMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.primary,
modifier = Modifier.padding(horizontal = 16.dp, vertical = 6.dp) // Reduced padding
modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp)
)
}
/**
* Navigation item - cleaner, no subtitle
* Individual navigation item with icon, label, and subtitle
*/
@Composable
private fun DrawerNavigationItem(
@@ -206,24 +196,33 @@ private fun DrawerNavigationItem(
) {
NavigationDrawerItem(
label = {
Text(
text = item.label,
style = MaterialTheme.typography.bodyMedium, // Slightly smaller
fontWeight = if (selected) FontWeight.SemiBold else FontWeight.Normal
)
Column(verticalArrangement = Arrangement.spacedBy(2.dp)) {
Text(
text = item.label,
style = MaterialTheme.typography.bodyLarge,
fontWeight = if (selected) FontWeight.SemiBold else FontWeight.Normal
)
item.subtitle?.let {
Text(
text = it,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.7f)
)
}
}
},
icon = {
Icon(
item.icon,
contentDescription = item.label,
modifier = Modifier.size(22.dp) // Slightly smaller
modifier = Modifier.size(24.dp)
)
},
selected = selected,
onClick = onClick,
modifier = Modifier
.padding(NavigationDrawerItemDefaults.ItemPadding)
.clip(RoundedCornerShape(10.dp)), // Slightly smaller radius
.clip(RoundedCornerShape(12.dp)),
colors = NavigationDrawerItemDefaults.colors(
selectedContainerColor = MaterialTheme.colorScheme.primaryContainer,
selectedIconColor = MaterialTheme.colorScheme.primary,
@@ -234,10 +233,11 @@ private fun DrawerNavigationItem(
}
/**
* Simplified drawer item (no subtitle)
* Data class for drawer items
*/
private data class DrawerItem(
val route: String,
val label: String,
val icon: androidx.compose.ui.graphics.vector.ImageVector
val icon: androidx.compose.ui.graphics.vector.ImageVector,
val subtitle: String? = null
)

81
app/src/main/java/com/placeholder/sherpai2/ui/presentation/MainScreen.kt
View File

@@ -1,5 +1,10 @@
package com.placeholder.sherpai2.ui.presentation
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.animation.slideInVertically
import androidx.compose.animation.slideOutVertically
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.padding
import androidx.compose.material.icons.Icons
@@ -15,7 +20,7 @@ import com.placeholder.sherpai2.ui.navigation.AppRoutes
import kotlinx.coroutines.launch
/**
* Clean main screen - NO duplicate FABs, Collections support
* Beautiful main screen with gradient header, dynamic actions, and polish
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -98,7 +103,15 @@ fun MainScreen() {
)
}
}
// NOTE: Removed TAGS action - TagManagementScreen has its own inline FAB
AppRoutes.TAGS -> {
IconButton(onClick = { /* TODO: Add tag */ }) {
Icon(
Icons.Default.Add,
contentDescription = "Add Tag",
tint = MaterialTheme.colorScheme.primary
)
}
}
}
},
colors = TopAppBarDefaults.topAppBarColors(
@@ -108,8 +121,50 @@ fun MainScreen() {
actionIconContentColor = MaterialTheme.colorScheme.primary
)
)
},
floatingActionButton = {
// Dynamic FAB based on screen
AnimatedVisibility(
visible = shouldShowFab(currentRoute),
enter = slideInVertically(initialOffsetY = { it }) + fadeIn(),
exit = slideOutVertically(targetOffsetY = { it }) + fadeOut()
) {
when (currentRoute) {
AppRoutes.SEARCH -> {
ExtendedFloatingActionButton(
onClick = { /* TODO: Advanced search */ },
icon = {
Icon(Icons.Default.Tune, "Advanced Search")
},
text = { Text("Filters") },
containerColor = MaterialTheme.colorScheme.primaryContainer,
contentColor = MaterialTheme.colorScheme.onPrimaryContainer
)
}
AppRoutes.TAGS -> {
FloatingActionButton(
onClick = { /* TODO: Add new tag */ },
containerColor = MaterialTheme.colorScheme.primaryContainer,
contentColor = MaterialTheme.colorScheme.onPrimaryContainer
) {
Icon(Icons.Default.Add, "Add Tag")
}
}
AppRoutes.UPLOAD -> {
ExtendedFloatingActionButton(
onClick = { /* TODO: Select photos */ },
icon = { Icon(Icons.Default.CloudUpload, "Upload") },
text = { Text("Select Photos") },
containerColor = MaterialTheme.colorScheme.primary,
contentColor = MaterialTheme.colorScheme.onPrimary
)
}
else -> {
// No FAB for other screens
}
}
}
}
// NOTE: NO floatingActionButton here - individual screens manage their own FABs inline
) { paddingValues ->
AppNavHost(
navController = navController,
@@ -125,13 +180,12 @@ fun MainScreen() {
private fun getScreenTitle(route: String): String {
return when (route) {
AppRoutes.SEARCH -> "Search"
AppRoutes.EXPLORE -> "Explore"
AppRoutes.COLLECTIONS -> "Collections" // NEW!
AppRoutes.EXPLORE -> "Explore" // Will be renamed to EXPLORE
AppRoutes.INVENTORY -> "People"
AppRoutes.TRAIN -> "Train New Person"
AppRoutes.MODELS -> "AI Models"
AppRoutes.TAGS -> "Tag Management"
AppRoutes.UTILITIES -> "Photo Util."
AppRoutes.UPLOAD -> "Upload Photos"
AppRoutes.SETTINGS -> "Settings"
else -> "SherpAI"
}
@@ -144,11 +198,22 @@ private fun getScreenSubtitle(route: String): String? {
return when (route) {
AppRoutes.SEARCH -> "Find photos by tags, people, or date"
AppRoutes.EXPLORE -> "Browse your collection"
AppRoutes.COLLECTIONS -> "Your photo collections" // NEW!
AppRoutes.INVENTORY -> "Trained face models"
AppRoutes.TRAIN -> "Add a new person to recognize"
AppRoutes.TAGS -> "Organize your photo collection"
AppRoutes.UTILITIES -> "Tools for managing collection"
AppRoutes.UPLOAD -> "Add photos to your library"
else -> null
}
}
/**
* Determine if FAB should be shown for current screen
*/
private fun shouldShowFab(route: String): Boolean {
return when (route) {
AppRoutes.SEARCH,
AppRoutes.TAGS,
AppRoutes.UPLOAD -> true
else -> false
}
}

962
app/src/main/java/com/placeholder/sherpai2/ui/search/SearchScreen.kt
View File

File diff suppressed because it is too large Load Diff

396
app/src/main/java/com/placeholder/sherpai2/ui/search/SearchViewModel.kt
View File

@@ -2,280 +2,233 @@ package com.placeholder.sherpai2.ui.search
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.placeholder.sherpai2.data.local.dao.ImageAggregateDao
import com.placeholder.sherpai2.data.local.dao.PersonDao
import com.placeholder.sherpai2.data.local.dao.TagDao
import com.placeholder.sherpai2.data.local.entity.ImageEntity
import com.placeholder.sherpai2.data.local.entity.PersonEntity
import com.placeholder.sherpai2.data.local.entity.PhotoFaceTagEntity
import com.placeholder.sherpai2.data.local.entity.TagEntity
import com.placeholder.sherpai2.data.repository.FaceRecognitionRepository
import com.placeholder.sherpai2.domain.repository.ImageRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch
import java.util.Calendar
import javax.inject.Inject
@OptIn(ExperimentalCoroutinesApi::class)
/**
* SearchViewModel - COMPLETE REDESIGN
*
* Features:
* - Near-match search ("low" → "low_res", "gro" → "group_photo")
* - Date range filtering
* - Quick tag filters
* - Clean person-only display
* - Simple/Verbose toggle
*/
@HiltViewModel
class SearchViewModel @Inject constructor(
private val imageAggregateDao: ImageAggregateDao,
private val imageRepository: ImageRepository,
private val faceRecognitionRepository: FaceRecognitionRepository,
private val personDao: PersonDao,
private val tagDao: TagDao
) : ViewModel() {
// Search query with near-match support
private val _searchQuery = MutableStateFlow("")
val searchQuery: StateFlow<String> = _searchQuery.asStateFlow()
private val _includedPeople = MutableStateFlow<Set<String>>(emptySet())
val includedPeople: StateFlow<Set<String>> = _includedPeople.asStateFlow()
private val _excludedPeople = MutableStateFlow<Set<String>>(emptySet())
val excludedPeople: StateFlow<Set<String>> = _excludedPeople.asStateFlow()
private val _includedTags = MutableStateFlow<Set<String>>(emptySet())
val includedTags: StateFlow<Set<String>> = _includedTags.asStateFlow()
private val _excludedTags = MutableStateFlow<Set<String>>(emptySet())
val excludedTags: StateFlow<Set<String>> = _excludedTags.asStateFlow()
// Active tag filters (quick chips)
private val _activeTagFilters = MutableStateFlow<Set<String>>(emptySet())
val activeTagFilters: StateFlow<Set<String>> = _activeTagFilters.asStateFlow()
// Date range filter
private val _dateRange = MutableStateFlow(DateRange.ALL_TIME)
val dateRange: StateFlow<DateRange> = _dateRange.asStateFlow()
private val _faceFilter = MutableStateFlow(FaceFilter.ALL)
val faceFilter: StateFlow<FaceFilter> = _faceFilter.asStateFlow()
// Display mode (simple = names only, verbose = icons + percentages)
private val _displayMode = MutableStateFlow(DisplayMode.SIMPLE)
val displayMode: StateFlow<DisplayMode> = _displayMode.asStateFlow()
private val _availablePeople = MutableStateFlow<List<PersonEntity>>(emptyList())
val availablePeople: StateFlow<List<PersonEntity>> = _availablePeople.asStateFlow()
private val _availableTags = MutableStateFlow<List<String>>(emptyList())
val availableTags: StateFlow<List<String>> = _availableTags.asStateFlow()
private val personCache = mutableMapOf<String, String>()
// Available system tags for quick filters
private val _systemTags = MutableStateFlow<List<TagEntity>>(emptyList())
val systemTags: StateFlow<List<TagEntity>> = _systemTags.asStateFlow()
init {
loadAvailableFilters()
buildPersonCache()
}
private fun buildPersonCache() {
viewModelScope.launch {
val people = personDao.getAllPersons()
people.forEach { person ->
val stats = faceRecognitionRepository.getPersonFaceStats(person.id)
if (stats != null) {
personCache[stats.faceModelId] = person.id
}
}
}
loadSystemTags()
}
/**
* Main search flow - combines query, tag filters, and date range
*/
fun searchImages(): Flow<List<ImageWithFaceTags>> {
return combine(
_searchQuery,
_includedPeople,
_excludedPeople,
_includedTags,
_excludedTags,
_dateRange,
_faceFilter
) { values: Array<*> ->
@Suppress("UNCHECKED_CAST")
SearchCriteria(
query = values[0] as String,
includedPeople = values[1] as Set<String>,
excludedPeople = values[2] as Set<String>,
includedTags = values[3] as Set<String>,
excludedTags = values[4] as Set<String>,
dateRange = values[5] as DateRange,
faceFilter = values[6] as FaceFilter
)
}.flatMapLatest { criteria ->
imageAggregateDao.observeAllImagesWithEverything()
.map { imagesList ->
imagesList.mapNotNull { imageWithEverything ->
// Apply date filter
if (!isInDateRange(imageWithEverything.image.capturedAt, criteria.dateRange)) {
return@mapNotNull null
_activeTagFilters,
_dateRange
) { query, tagFilters, dateRange ->
Triple(query, tagFilters, dateRange)
}.flatMapLatest { (query, tagFilters, dateRange) ->
channelFlow {
// Get matching tags FIRST (suspend call)
val matchingTags = if (query.isNotBlank()) {
findMatchingTags(query)
} else {
emptyList()
}
// Get base images
val imagesFlow = when {
matchingTags.isNotEmpty() -> {
// Search by all matching tags
combine(matchingTags.map { tag ->
imageRepository.findImagesByTag(tag.value)
}) { results ->
results.flatMap { it }.distinctBy { it.image.imageId }
}
// Apply face filter - ONLY when cache is explicitly set
when (criteria.faceFilter) {
FaceFilter.HAS_FACES -> {
// Only show images where hasFaces is EXPLICITLY true
if (imageWithEverything.image.hasFaces != true) {
return@mapNotNull null
}
}
FaceFilter.NO_FACES -> {
// Only show images where hasFaces is EXPLICITLY false
if (imageWithEverything.image.hasFaces != false) {
return@mapNotNull null
}
}
FaceFilter.ALL -> {
// Show all images (null, true, or false)
}
}
tagFilters.isNotEmpty() -> {
// Filter by active tags
combine(tagFilters.map { tagValue ->
imageRepository.findImagesByTag(tagValue)
}) { results ->
results.flatMap { it }.distinctBy { it.image.imageId }
}
}
else -> imageRepository.getAllImages()
}
val personIds = imageWithEverything.faceTags
.mapNotNull { faceTag -> personCache[faceTag.faceModelId] }
.toSet()
val imageTags = imageWithEverything.tags
.map { it.value }
.toSet()
val passesFilter = applyBooleanLogic(
personIds = personIds,
imageTags = imageTags,
criteria = criteria
)
if (passesFilter) {
val persons = personIds.mapNotNull { personId ->
_availablePeople.value.find { it.id == personId }
}
// Apply date filtering and add face data
imagesFlow.collect { imagesList ->
val filtered = imagesList
.filter { imageWithEverything ->
isInDateRange(imageWithEverything.image.capturedAt, dateRange)
}
.map { imageWithEverything ->
// Get face tags with person info
val tagsWithPersons = faceRecognitionRepository.getFaceTagsWithPersons(
imageWithEverything.image.imageId
)
ImageWithFaceTags(
image = imageWithEverything.image,
faceTags = imageWithEverything.faceTags,
persons = persons
faceTags = tagsWithPersons.map { it.first },
persons = tagsWithPersons.map { it.second }
)
} else {
null
}
}.sortedByDescending { it.image.capturedAt }
.sortedByDescending { it.image.capturedAt }
send(filtered)
}
}
}
}
private fun applyBooleanLogic(
personIds: Set<String>,
imageTags: Set<String>,
criteria: SearchCriteria
): Boolean {
val hasAllIncludedPeople = if (criteria.includedPeople.isNotEmpty()) {
criteria.includedPeople.all { it in personIds }
} else true
/**
* Near-match search: "low" matches "low_res", "gro" matches "group_photo"
*/
private suspend fun findMatchingTags(query: String): List<TagEntity> {
val normalizedQuery = query.trim().lowercase()
val hasNoExcludedPeople = if (criteria.excludedPeople.isNotEmpty()) {
criteria.excludedPeople.none { it in personIds }
} else true
// Get all system tags
val allTags = tagDao.getByType("SYSTEM")
val hasAllIncludedTags = if (criteria.includedTags.isNotEmpty()) {
criteria.includedTags.all { it in imageTags }
} else true
// Find tags that contain the query or match it closely
return allTags.filter { tag ->
val tagValue = tag.value.lowercase()
val hasNoExcludedTags = if (criteria.excludedTags.isNotEmpty()) {
criteria.excludedTags.none { it in imageTags }
} else true
val matchesTextSearch = if (criteria.query.isNotBlank()) {
val normalizedQuery = criteria.query.trim().lowercase()
imageTags.any { tag -> tag.lowercase().contains(normalizedQuery) }
} else true
return hasAllIncludedPeople && hasNoExcludedPeople &&
hasAllIncludedTags && hasNoExcludedTags &&
matchesTextSearch
// Exact match
tagValue == normalizedQuery ||
// Contains match
tagValue.contains(normalizedQuery) ||
// Starts with match
tagValue.startsWith(normalizedQuery) ||
// Fuzzy match (remove underscores and compare)
tagValue.replace("_", "").contains(normalizedQuery.replace("_", ""))
}.sortedBy { tag ->
// Sort by relevance: exact > starts with > contains
when {
tag.value.lowercase() == normalizedQuery -> 0
tag.value.lowercase().startsWith(normalizedQuery) -> 1
else -> 2
}
}
}
private fun loadAvailableFilters() {
/**
* Load available system tags for quick filters
*/
private fun loadSystemTags() {
viewModelScope.launch {
val people = personDao.getAllPersons()
_availablePeople.value = people.sortedBy { it.name }
val tags = tagDao.getByType("SYSTEM")
// Get usage counts for all tags
val tagsWithUsage = tags.map { tag ->
tag to tagDao.getTagUsageCount(tag.tagId)
}
_availableTags.value = tagsWithUsage
// Sort by most commonly used
val sortedTags = tagsWithUsage
.sortedByDescending { (_, usageCount) -> usageCount }
.take(30)
.map { (tag, _) -> tag.value }
.take(12) // Show top 12 most used tags
.map { (tag, _) -> tag }
_systemTags.value = sortedTags
}
}
fun includePerson(personId: String) {
_includedPeople.value = _includedPeople.value + personId
_excludedPeople.value = _excludedPeople.value - personId
}
fun excludePerson(personId: String) {
_excludedPeople.value = _excludedPeople.value + personId
_includedPeople.value = _includedPeople.value - personId
}
fun removePersonFilter(personId: String) {
_includedPeople.value = _includedPeople.value - personId
_excludedPeople.value = _excludedPeople.value - personId
}
fun includeTag(tagValue: String) {
_includedTags.value = _includedTags.value + tagValue
_excludedTags.value = _excludedTags.value - tagValue
}
fun excludeTag(tagValue: String) {
_excludedTags.value = _excludedTags.value + tagValue
_includedTags.value = _includedTags.value - tagValue
}
fun removeTagFilter(tagValue: String) {
_includedTags.value = _includedTags.value - tagValue
_excludedTags.value = _excludedTags.value - tagValue
}
/**
* Update search query
*/
fun setSearchQuery(query: String) {
_searchQuery.value = query
}
/**
* Toggle a tag filter
*/
fun toggleTagFilter(tagValue: String) {
_activeTagFilters.value = if (tagValue in _activeTagFilters.value) {
_activeTagFilters.value - tagValue
} else {
_activeTagFilters.value + tagValue
}
}
/**
* Clear all tag filters
*/
fun clearTagFilters() {
_activeTagFilters.value = emptySet()
}
/**
* Set date range filter
*/
fun setDateRange(range: DateRange) {
_dateRange.value = range
}
fun setFaceFilter(filter: FaceFilter) {
_faceFilter.value = filter
/**
* Toggle display mode (simple/verbose)
*/
fun toggleDisplayMode() {
_displayMode.value = when (_displayMode.value) {
DisplayMode.SIMPLE -> DisplayMode.VERBOSE
DisplayMode.VERBOSE -> DisplayMode.SIMPLE
}
}
fun clearAllFilters() {
_searchQuery.value = ""
_includedPeople.value = emptySet()
_excludedPeople.value = emptySet()
_includedTags.value = emptySet()
_excludedTags.value = emptySet()
_dateRange.value = DateRange.ALL_TIME
_faceFilter.value = FaceFilter.ALL
}
fun hasActiveFilters(): Boolean {
return _searchQuery.value.isNotBlank() ||
_includedPeople.value.isNotEmpty() ||
_excludedPeople.value.isNotEmpty() ||
_includedTags.value.isNotEmpty() ||
_excludedTags.value.isNotEmpty() ||
_dateRange.value != DateRange.ALL_TIME ||
_faceFilter.value != FaceFilter.ALL
}
fun getSearchSummary(): String {
val parts = mutableListOf<String>()
if (_includedPeople.value.isNotEmpty()) parts.add("WITH: ${_includedPeople.value.size} people")
if (_excludedPeople.value.isNotEmpty()) parts.add("WITHOUT: ${_excludedPeople.value.size} people")
if (_includedTags.value.isNotEmpty()) parts.add("HAS: ${_includedTags.value.size} tags")
if (_excludedTags.value.isNotEmpty()) parts.add("NOT: ${_excludedTags.value.size} tags")
if (_dateRange.value != DateRange.ALL_TIME) parts.add(_dateRange.value.displayName)
return parts.joinToString(" • ")
}
private fun isInDateRange(timestamp: Long, range: DateRange): Boolean = when (range) {
DateRange.ALL_TIME -> true
DateRange.TODAY -> isToday(timestamp)
DateRange.THIS_WEEK -> isThisWeek(timestamp)
DateRange.THIS_MONTH -> isThisMonth(timestamp)
DateRange.THIS_YEAR -> isThisYear(timestamp)
/**
* Check if timestamp is in date range
*/
private fun isInDateRange(timestamp: Long, range: DateRange): Boolean {
return when (range) {
DateRange.ALL_TIME -> true
DateRange.TODAY -> isToday(timestamp)
DateRange.THIS_WEEK -> isThisWeek(timestamp)
DateRange.THIS_MONTH -> isThisMonth(timestamp)
DateRange.THIS_YEAR -> isThisYear(timestamp)
}
}
private fun isToday(timestamp: Long): Boolean {
@@ -306,22 +259,18 @@ class SearchViewModel @Inject constructor(
}
}
private data class SearchCriteria(
val query: String,
val includedPeople: Set<String>,
val excludedPeople: Set<String>,
val includedTags: Set<String>,
val excludedTags: Set<String>,
val dateRange: DateRange,
val faceFilter: FaceFilter
)
/**
* Data class containing image with face recognition data
*/
data class ImageWithFaceTags(
val image: ImageEntity,
val faceTags: List<PhotoFaceTagEntity>,
val persons: List<PersonEntity>
)
/**
* Date range filters
*/
enum class DateRange(val displayName: String) {
ALL_TIME("All Time"),
TODAY("Today"),
@@ -330,11 +279,10 @@ enum class DateRange(val displayName: String) {
THIS_YEAR("This Year")
}
enum class FaceFilter(val displayName: String) {
ALL("All Photos"),
HAS_FACES("Has Faces"),
NO_FACES("No Faces")
}
@Deprecated("No longer used")
enum class DisplayMode { SIMPLE, VERBOSE }
/**
* Display modes for photo tags
*/
enum class DisplayMode {
SIMPLE, // Just person names
VERBOSE // Names + icons + confidence percentages
}

788
app/src/main/java/com/placeholder/sherpai2/ui/tags/Tagmanagementscreen.kt
View File

@@ -24,24 +24,9 @@ import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import com.placeholder.sherpai2.data.local.entity.TagWithUsage
/**
* CLEANED TagManagementScreen - No Scaffold wrapper
*
* Removed:
* - Scaffold wrapper (line 38)
* - Moved FAB inline as part of content
*
* Features:
* - Tag list with usage counts
* - Search functionality
* - Scanning progress
* - Delete tags
* - System/User tag distinction
*/
@Composable
fun TagManagementScreen(
viewModel: TagManagementViewModel = hiltViewModel(),
modifier: Modifier = Modifier
viewModel: TagManagementViewModel = hiltViewModel()
) {
val uiState by viewModel.uiState.collectAsState()
val scanningState by viewModel.scanningState.collectAsState()
@@ -50,8 +35,105 @@ fun TagManagementScreen(
var showScanMenu by remember { mutableStateOf(false) }
var searchQuery by remember { mutableStateOf("") }
Box(modifier = modifier.fillMaxSize()) {
Column(modifier = Modifier.fillMaxSize()) {
Scaffold(
floatingActionButton = {
// Single extended FAB with dropdown menu
var showMenu by remember { mutableStateOf(false) }
Column(
horizontalAlignment = Alignment.End,
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
// Dropdown menu for scan options
if (showMenu) {
Card(
modifier = Modifier.width(180.dp),
elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
) {
Column {
ListItem(
headlineContent = { Text("Scan All", style = MaterialTheme.typography.bodyMedium) },
leadingContent = {
Icon(
Icons.Default.AutoFixHigh,
null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(20.dp)
)
},
modifier = Modifier.clickable {
viewModel.scanForAllTags()
showMenu = false
}
)
ListItem(
headlineContent = { Text("Base Tags", style = MaterialTheme.typography.bodyMedium) },
leadingContent = {
Icon(
Icons.Default.PhotoCamera,
null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(20.dp)
)
},
modifier = Modifier.clickable {
viewModel.scanForBaseTags()
showMenu = false
}
)
ListItem(
headlineContent = { Text("Relationships", style = MaterialTheme.typography.bodyMedium) },
leadingContent = {
Icon(
Icons.Default.People,
null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(20.dp)
)
},
modifier = Modifier.clickable {
viewModel.scanForRelationshipTags()
showMenu = false
}
)
ListItem(
headlineContent = { Text("Birthdays", style = MaterialTheme.typography.bodyMedium) },
leadingContent = {
Icon(
Icons.Default.Cake,
null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(20.dp)
)
},
modifier = Modifier.clickable {
viewModel.scanForBirthdayTags()
showMenu = false
}
)
}
}
}
// Main FAB
ExtendedFloatingActionButton(
onClick = { showMenu = !showMenu },
icon = {
Icon(
if (showMenu) Icons.Default.Close else Icons.Default.AutoFixHigh,
"Scan"
)
},
text = { Text(if (showMenu) "Close" else "Scan Tags") }
)
}
}
) { paddingValues ->
Column(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues)
) {
// Stats Bar
StatsBar(uiState)
@@ -84,60 +166,24 @@ fun TagManagementScreen(
}
}
is TagManagementViewModel.TagUiState.Success -> {
if (state.tags.isEmpty()) {
EmptyTagsView()
} else {
TagList(
tags = state.tags,
onDeleteTag = { viewModel.deleteTag(it) }
)
}
TagList(
tags = state.tags,
onDeleteTag = { viewModel.deleteTag(it) }
)
}
is TagManagementViewModel.TagUiState.Error -> {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Icon(
Icons.Default.Error,
contentDescription = null,
modifier = Modifier.size(48.dp),
tint = MaterialTheme.colorScheme.error
)
Text(
text = state.message,
color = MaterialTheme.colorScheme.error
)
}
Text(
text = state.message,
color = MaterialTheme.colorScheme.error
)
}
}
}
}
// FAB (inline, positioned over content)
ScanFAB(
showMenu = showScanMenu,
onToggleMenu = { showScanMenu = !showScanMenu },
onScanAll = {
viewModel.scanForAllTags()
showScanMenu = false
},
onScanBase = {
viewModel.scanForBaseTags()
showScanMenu = false
},
onScanRelationships = {
viewModel.scanForRelationshipTags()
showScanMenu = false
},
modifier = Modifier
.align(Alignment.BottomEnd)
.padding(16.dp)
)
}
// Add Tag Dialog
@@ -150,77 +196,73 @@ fun TagManagementScreen(
}
)
}
// Scan Menu
if (showScanMenu) {
ScanMenuDialog(
onDismiss = { showScanMenu = false },
onScanSelected = { scanType ->
when (scanType) {
TagManagementViewModel.ScanType.BASE_TAGS -> viewModel.scanForBaseTags()
TagManagementViewModel.ScanType.RELATIONSHIP_TAGS -> viewModel.scanForRelationshipTags()
TagManagementViewModel.ScanType.BIRTHDAY_TAGS -> viewModel.scanForBirthdayTags()
TagManagementViewModel.ScanType.SCENE_TAGS -> viewModel.scanForSceneTags()
TagManagementViewModel.ScanType.ALL -> viewModel.scanForAllTags()
}
showScanMenu = false
}
)
}
}
/**
* Stats bar at top
*/
@Composable
private fun StatsBar(uiState: TagManagementViewModel.TagUiState) {
val (totalTags, totalPhotos) = when (uiState) {
is TagManagementViewModel.TagUiState.Success -> {
val photoCount: Int = uiState.tags.sumOf { it.usageCount }
uiState.tags.size to photoCount
}
else -> 0 to 0
}
Surface(
modifier = Modifier.fillMaxWidth(),
color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
) {
Row(
if (uiState is TagManagementViewModel.TagUiState.Success) {
Card(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceEvenly
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
)
) {
StatItem(
icon = Icons.Default.Label,
value = totalTags.toString(),
label = "Tags"
)
VerticalDivider(
modifier = Modifier.height(48.dp),
color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)
)
StatItem(
icon = Icons.Default.Photo,
value = totalPhotos.toString(),
label = "Tagged Photos"
)
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceAround
) {
StatItem("Total", uiState.totalTags.toString(), Icons.Default.Label)
StatItem("System", uiState.systemTags.toString(), Icons.Default.AutoAwesome)
StatItem("User", uiState.userTags.toString(), Icons.Default.PersonOutline)
}
}
}
}
@Composable
private fun StatItem(icon: ImageVector, value: String, label: String) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(4.dp)
) {
private fun StatItem(label: String, value: String, icon: ImageVector) {
Column(horizontalAlignment = Alignment.CenterHorizontally) {
Icon(
icon,
imageVector = icon,
contentDescription = null,
modifier = Modifier.size(24.dp),
tint = MaterialTheme.colorScheme.primary
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(24.dp)
)
Spacer(modifier = Modifier.height(4.dp))
Text(
value,
text = value,
style = MaterialTheme.typography.headlineSmall,
fontWeight = FontWeight.Bold
)
Text(
label,
style = MaterialTheme.typography.labelMedium,
text = label,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
/**
* Search bar
*/
@Composable
private fun SearchBar(
searchQuery: String,
@@ -231,9 +273,9 @@ private fun SearchBar(
onValueChange = onSearchChange,
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
.padding(horizontal = 16.dp),
placeholder = { Text("Search tags...") },
leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) },
leadingIcon = { Icon(Icons.Default.Search, "Search") },
trailingIcon = {
if (searchQuery.isNotEmpty()) {
IconButton(onClick = { onSearchChange("") }) {
@@ -241,124 +283,96 @@ private fun SearchBar(
}
}
},
singleLine = true,
shape = RoundedCornerShape(16.dp)
singleLine = true
)
}
/**
* Scanning progress indicator
*/
@Composable
private fun ScanningProgress(
scanningState: TagManagementViewModel.TagScanningState,
viewModel: TagManagementViewModel
) {
when (scanningState) {
is TagManagementViewModel.TagScanningState.Scanning -> {
Card(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 8.dp),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f)
)
) {
Column(
modifier = Modifier.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Card(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.secondaryContainer
)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp)
) {
when (scanningState) {
is TagManagementViewModel.TagScanningState.Scanning -> {
Text(
text = "Scanning: ${scanningState.scanType.name.replace("_", " ")}",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
Spacer(modifier = Modifier.height(8.dp))
LinearProgressIndicator(
progress = { scanningState.progress.toFloat() / scanningState.total.toFloat() },
modifier = Modifier.fillMaxWidth(),
)
Spacer(modifier = Modifier.height(4.dp))
Text(
text = "${scanningState.progress} / ${scanningState.total} images",
style = MaterialTheme.typography.bodySmall
)
Text(
text = "Tags applied: ${scanningState.tagsApplied}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.primary
)
}
is TagManagementViewModel.TagScanningState.Complete -> {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Column {
Text(
text = "✓ Scan Complete",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.primary
)
Text(
text = "${scanningState.tagsApplied} tags applied to ${scanningState.imagesProcessed} images",
style = MaterialTheme.typography.bodySmall
)
}
IconButton(onClick = { viewModel.resetScanningState() }) {
Icon(Icons.Default.Close, "Close")
}
}
}
is TagManagementViewModel.TagScanningState.Error -> {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
"Scanning: ${scanningState.scanType}",
style = MaterialTheme.typography.titleSmall,
fontWeight = FontWeight.SemiBold
text = "Error: ${scanningState.message}",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.error
)
Text(
"${scanningState.progress}/${scanningState.total}",
style = MaterialTheme.typography.bodySmall
)
}
LinearProgressIndicator(
progress = {
if (scanningState.total > 0) {
scanningState.progress.toFloat() / scanningState.total.toFloat()
} else {
0f
}
},
modifier = Modifier.fillMaxWidth()
)
Text(
"Tags applied: ${scanningState.tagsApplied}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.primary
)
if (scanningState.currentImage.isNotEmpty()) {
Text(
"Current: ${scanningState.currentImage}",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
}
is TagManagementViewModel.TagScanningState.Complete -> {
Card(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp, vertical = 8.dp),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
)
) {
Row(
modifier = Modifier.padding(16.dp),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.CheckCircle,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary
)
Column {
Text(
"Scan Complete!",
style = MaterialTheme.typography.titleSmall,
fontWeight = FontWeight.Bold
)
Text(
"Processed: ${scanningState.imagesProcessed} images",
style = MaterialTheme.typography.bodySmall
)
Text(
"Applied: ${scanningState.tagsApplied} tags",
style = MaterialTheme.typography.bodySmall
)
if (scanningState.newTagsCreated > 0) {
Text(
"Created: ${scanningState.newTagsCreated} new tags",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.primary
)
IconButton(onClick = { viewModel.resetScanningState() }) {
Icon(Icons.Default.Close, "Close")
}
}
}
else -> { /* Idle - don't show */ }
}
}
else -> {}
}
}
/**
* Tag list
*/
@Composable
private fun TagList(
tags: List<TagWithUsage>,
@@ -369,238 +383,114 @@ private fun TagList(
contentPadding = PaddingValues(16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
items(tags) { tagWithUsage ->
TagCard(
tagWithUsage = tagWithUsage,
onDelete = { onDeleteTag(tagWithUsage.tagId) }
)
items(tags, key = { it.tagId }) { tag ->
TagListItem(tag, onDeleteTag)
}
}
}
/**
* Individual tag card
*/
@Composable
private fun TagCard(
tagWithUsage: TagWithUsage,
onDelete: () -> Unit
private fun TagListItem(
tag: TagWithUsage,
onDeleteTag: (String) -> Unit
) {
val isSystemTag = tagWithUsage.type == "SYSTEM"
var showDeleteConfirm by remember { mutableStateOf(false) }
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
onClick = { /* TODO: Navigate to images with this tag */ }
) {
Row(
modifier = Modifier.padding(16.dp),
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Row(
modifier = Modifier.weight(1f),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Tag icon
Surface(
modifier = Modifier.size(40.dp),
shape = RoundedCornerShape(8.dp),
color = if (isSystemTag)
MaterialTheme.colorScheme.primaryContainer
// Tag type icon
Icon(
imageVector = if (tag.type == "SYSTEM") Icons.Default.AutoAwesome else Icons.Default.Label,
contentDescription = null,
tint = if (tag.type == "SYSTEM")
MaterialTheme.colorScheme.secondary
else
MaterialTheme.colorScheme.secondaryContainer
) {
Box(contentAlignment = Alignment.Center) {
Icon(
if (isSystemTag) Icons.Default.AutoAwesome else Icons.Default.Label,
contentDescription = null,
modifier = Modifier.size(20.dp),
tint = if (isSystemTag)
MaterialTheme.colorScheme.onPrimaryContainer
else
MaterialTheme.colorScheme.onSecondaryContainer
)
}
}
MaterialTheme.colorScheme.primary
)
// Tag info
Column {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = tagWithUsage.value,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.SemiBold
)
if (isSystemTag) {
Surface(
shape = RoundedCornerShape(4.dp),
color = MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
) {
Text(
"SYSTEM",
modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.primary
)
}
}
}
Text(
text = "${tagWithUsage.usageCount} ${if (tagWithUsage.usageCount == 1) "photo" else "photos"}",
text = tag.value,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Medium
)
Text(
text = if (tag.type == "SYSTEM") "System tag" else "User tag",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
// Delete button (only for user tags)
if (!isSystemTag) {
IconButton(onClick = onDelete) {
Icon(
Icons.Default.Delete,
contentDescription = "Delete",
tint = MaterialTheme.colorScheme.error
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Usage count badge
Surface(
shape = RoundedCornerShape(12.dp),
color = MaterialTheme.colorScheme.primaryContainer
) {
Text(
text = tag.usageCount.toString(),
modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
style = MaterialTheme.typography.labelMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.onPrimaryContainer
)
}
// Delete button (only for user tags)
if (tag.type == "GENERIC") {
IconButton(onClick = { showDeleteConfirm = true }) {
Icon(
Icons.Default.Delete,
contentDescription = "Delete tag",
tint = MaterialTheme.colorScheme.error
)
}
}
}
}
}
}
/**
* Empty state
*/
@Composable
private fun EmptyTagsView() {
Box(
modifier = Modifier
.fillMaxSize()
.padding(32.dp),
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
Icon(
Icons.Default.LabelOff,
contentDescription = null,
modifier = Modifier.size(64.dp),
tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f)
)
Text(
"No Tags Yet",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
"Scan your photos to generate tags automatically",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = androidx.compose.ui.text.style.TextAlign.Center
)
}
}
}
/**
* Floating Action Button with scan menu
*/
@Composable
private fun ScanFAB(
showMenu: Boolean,
onToggleMenu: () -> Unit,
onScanAll: () -> Unit,
onScanBase: () -> Unit,
onScanRelationships: () -> Unit,
modifier: Modifier = Modifier
) {
Column(
modifier = modifier,
horizontalAlignment = Alignment.End,
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
// Menu options
AnimatedVisibility(visible = showMenu) {
Column(
horizontalAlignment = Alignment.End,
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
SmallFAB(
icon = Icons.Default.AutoFixHigh,
text = "Scan All",
onClick = onScanAll
)
SmallFAB(
icon = Icons.Default.PhotoCamera,
text = "Base Tags",
onClick = onScanBase
)
SmallFAB(
icon = Icons.Default.People,
text = "Relationships",
onClick = onScanRelationships
)
}
}
// Main FAB
ExtendedFloatingActionButton(
onClick = onToggleMenu,
icon = {
Icon(
if (showMenu) Icons.Default.Close else Icons.Default.AutoFixHigh,
"Scan"
)
if (showDeleteConfirm) {
AlertDialog(
onDismissRequest = { showDeleteConfirm = false },
title = { Text("Delete Tag?") },
text = { Text("Are you sure you want to delete '${tag.value}'? This will remove it from ${tag.usageCount} images.") },
confirmButton = {
TextButton(
onClick = {
onDeleteTag(tag.tagId)
showDeleteConfirm = false
}
) {
Text("Delete", color = MaterialTheme.colorScheme.error)
}
},
text = { Text(if (showMenu) "Close" else "Scan Tags") },
containerColor = MaterialTheme.colorScheme.primaryContainer,
contentColor = MaterialTheme.colorScheme.onPrimaryContainer
dismissButton = {
TextButton(onClick = { showDeleteConfirm = false }) {
Text("Cancel")
}
}
)
}
}
@Composable
private fun SmallFAB(
icon: ImageVector,
text: String,
onClick: () -> Unit
) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
Surface(
shape = RoundedCornerShape(8.dp),
color = MaterialTheme.colorScheme.surface,
shadowElevation = 2.dp
) {
Text(
text,
modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp),
style = MaterialTheme.typography.bodySmall,
fontWeight = FontWeight.Medium
)
}
FloatingActionButton(
onClick = onClick,
modifier = Modifier.size(48.dp),
containerColor = MaterialTheme.colorScheme.secondaryContainer,
contentColor = MaterialTheme.colorScheme.onSecondaryContainer
) {
Icon(icon, contentDescription = text, modifier = Modifier.size(20.dp))
}
}
}
/**
* Add tag dialog
*/
@Composable
private fun AddTagDialog(
onDismiss: () -> Unit,
@@ -610,19 +500,18 @@ private fun AddTagDialog(
AlertDialog(
onDismissRequest = onDismiss,
icon = { Icon(Icons.Default.Add, contentDescription = null) },
title = { Text("Add Custom Tag") },
title = { Text("Add New Tag") },
text = {
OutlinedTextField(
value = tagName,
onValueChange = { tagName = it },
label = { Text("Tag Name") },
label = { Text("Tag name") },
singleLine = true,
modifier = Modifier.fillMaxWidth()
)
},
confirmButton = {
Button(
TextButton(
onClick = { onConfirm(tagName) },
enabled = tagName.isNotBlank()
) {
@@ -635,4 +524,101 @@ private fun AddTagDialog(
}
}
)
}
@Composable
private fun ScanMenuDialog(
onDismiss: () -> Unit,
onScanSelected: (TagManagementViewModel.ScanType) -> Unit
) {
AlertDialog(
onDismissRequest = onDismiss,
title = { Text("Scan for Tags") },
text = {
Column(
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
ScanOption(
title = "Base Tags",
description = "Face count, orientation, time, quality",
icon = Icons.Default.PhotoCamera,
onClick = { onScanSelected(TagManagementViewModel.ScanType.BASE_TAGS) }
)
ScanOption(
title = "Relationship Tags",
description = "Family, friends, colleagues",
icon = Icons.Default.People,
onClick = { onScanSelected(TagManagementViewModel.ScanType.RELATIONSHIP_TAGS) }
)
ScanOption(
title = "Birthday Tags",
description = "Photos near birthdays",
icon = Icons.Default.Cake,
onClick = { onScanSelected(TagManagementViewModel.ScanType.BIRTHDAY_TAGS) }
)
ScanOption(
title = "Scene Tags",
description = "Indoor/outdoor detection",
icon = Icons.Default.Landscape,
onClick = { onScanSelected(TagManagementViewModel.ScanType.SCENE_TAGS) }
)
Divider()
ScanOption(
title = "Scan All",
description = "Run all scans",
icon = Icons.Default.AutoFixHigh,
onClick = { onScanSelected(TagManagementViewModel.ScanType.ALL) }
)
}
},
confirmButton = {
TextButton(onClick = onDismiss) {
Text("Cancel")
}
}
)
}
@Composable
private fun ScanOption(
title: String,
description: String,
icon: ImageVector,
onClick: () -> Unit
) {
Card(
modifier = Modifier
.fillMaxWidth()
.clickable(onClick = onClick),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant
)
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
imageVector = icon,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(32.dp)
)
Column {
Text(
text = title,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Medium
)
Text(
text = description,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
}

197
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Beautifulpersoninfodialog.kt
View File

@@ -1,197 +0,0 @@
package com.placeholder.sherpai2.ui.trainingprep
import android.os.Build
import android.view.View
import android.view.autofill.AutofillManager
import androidx.annotation.RequiresApi
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalView
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.KeyboardCapitalization
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.compose.ui.window.DialogProperties
import java.text.SimpleDateFormat
import java.util.*
@RequiresApi(Build.VERSION_CODES.O)
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun BeautifulPersonInfoDialog(
onDismiss: () -> Unit,
onConfirm: (name: String, dateOfBirth: Long?, relationship: String) -> Unit
) {
var name by remember { mutableStateOf("") }
var dateOfBirth by remember { mutableStateOf<Long?>(null) }
var selectedRelationship by remember { mutableStateOf("Other") }
var showDatePicker by remember { mutableStateOf(false) }
// ✅ Disable autofill for this dialog
val view = LocalView.current
DisposableEffect(Unit) {
val autofillManager = view.context.getSystemService(AutofillManager::class.java)
view.importantForAutofill = View.IMPORTANT_FOR_AUTOFILL_NO_EXCLUDE_DESCENDANTS
onDispose {
view.importantForAutofill = View.IMPORTANT_FOR_AUTOFILL_AUTO
}
}
val relationships = listOf(
"Family" to "👨‍👩‍👧‍👦",
"Friend" to "🤝",
"Partner" to "❤️",
"Parent" to "👪",
"Sibling" to "👫",
"Colleague" to "💼"
)
Dialog(
onDismissRequest = onDismiss,
properties = DialogProperties(usePlatformDefaultWidth = false)
) {
Card(
modifier = Modifier.fillMaxWidth(0.92f).fillMaxHeight(0.85f),
shape = RoundedCornerShape(28.dp),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
) {
Column(modifier = Modifier.fillMaxSize()) {
Row(
modifier = Modifier.fillMaxWidth().padding(24.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Row(horizontalArrangement = Arrangement.spacedBy(16.dp), verticalAlignment = Alignment.CenterVertically) {
Surface(shape = RoundedCornerShape(16.dp), color = MaterialTheme.colorScheme.primaryContainer, modifier = Modifier.size(64.dp)) {
Box(contentAlignment = Alignment.Center) {
Icon(Icons.Default.Person, contentDescription = null, modifier = Modifier.size(36.dp), tint = MaterialTheme.colorScheme.primary)
}
}
Column {
Text("Person Details", style = MaterialTheme.typography.headlineMedium, fontWeight = FontWeight.Bold)
Text("Help us organize your photos", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
}
}
IconButton(onClick = onDismiss) {
Icon(Icons.Default.Close, contentDescription = "Close", modifier = Modifier.size(24.dp))
}
}
HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
Column(modifier = Modifier.weight(1f).verticalScroll(rememberScrollState()).padding(24.dp), verticalArrangement = Arrangement.spacedBy(24.dp)) {
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text("Name *", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.primary)
OutlinedTextField(
value = name,
onValueChange = { name = it },
placeholder = { Text("e.g., John Doe") },
leadingIcon = { Icon(Icons.Default.Face, contentDescription = null) },
modifier = Modifier.fillMaxWidth(),
singleLine = true,
shape = RoundedCornerShape(16.dp),
keyboardOptions = androidx.compose.foundation.text.KeyboardOptions(
capitalization = KeyboardCapitalization.Words,
autoCorrect = false
)
)
}
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text("Birthday", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.primary)
OutlinedTextField(
value = dateOfBirth?.let { SimpleDateFormat("MMM d, yyyy", Locale.getDefault()).format(Date(it)) } ?: "",
onValueChange = {},
readOnly = true,
placeholder = { Text("Select birthday") },
leadingIcon = { Icon(Icons.Default.Cake, contentDescription = null) },
trailingIcon = {
IconButton(onClick = { showDatePicker = true }) {
Icon(Icons.Default.CalendarToday, contentDescription = "Select date")
}
},
modifier = Modifier.fillMaxWidth(),
singleLine = true,
shape = RoundedCornerShape(16.dp)
)
}
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text("Relationship", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold, color = MaterialTheme.colorScheme.primary)
var expanded by remember { mutableStateOf(false) }
ExposedDropdownMenuBox(expanded = expanded, onExpandedChange = { expanded = it }) {
OutlinedTextField(
value = selectedRelationship,
onValueChange = {},
readOnly = true,
leadingIcon = { Icon(Icons.Default.People, contentDescription = null) },
trailingIcon = { ExposedDropdownMenuDefaults.TrailingIcon(expanded = expanded) },
modifier = Modifier.fillMaxWidth().menuAnchor(),
singleLine = true,
shape = RoundedCornerShape(16.dp),
colors = ExposedDropdownMenuDefaults.outlinedTextFieldColors()
)
ExposedDropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
relationships.forEach { (relationship, emoji) ->
DropdownMenuItem(text = { Text("$emoji $relationship") }, onClick = { selectedRelationship = relationship; expanded = false })
}
}
}
}
Card(colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.3f)), shape = RoundedCornerShape(12.dp)) {
Row(modifier = Modifier.padding(16.dp), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
Icon(Icons.Default.Lock, contentDescription = null, tint = MaterialTheme.colorScheme.tertiary, modifier = Modifier.size(20.dp))
Text("All information stays private on your device", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onTertiaryContainer)
}
}
}
HorizontalDivider(color = MaterialTheme.colorScheme.outlineVariant)
Row(modifier = Modifier.fillMaxWidth().padding(24.dp), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
OutlinedButton(onClick = onDismiss, modifier = Modifier.weight(1f).height(56.dp), shape = RoundedCornerShape(16.dp)) {
Text("Cancel", style = MaterialTheme.typography.titleMedium)
}
Button(
onClick = { onConfirm(name.trim(), dateOfBirth, selectedRelationship) },
enabled = name.trim().isNotEmpty(),
modifier = Modifier.weight(1f).height(56.dp),
shape = RoundedCornerShape(16.dp)
) {
Icon(Icons.Default.Check, contentDescription = null, modifier = Modifier.size(20.dp))
Spacer(Modifier.width(8.dp))
Text("Continue", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
}
}
}
}
}
if (showDatePicker) {
val datePickerState = rememberDatePickerState(initialSelectedDateMillis = dateOfBirth ?: System.currentTimeMillis())
DatePickerDialog(
onDismissRequest = { showDatePicker = false },
confirmButton = { TextButton(onClick = { dateOfBirth = datePickerState.selectedDateMillis; showDatePicker = false }) { Text("OK") } },
dismissButton = { TextButton(onClick = { showDatePicker = false }) { Text("Cancel") } }
) {
DatePicker(state = datePickerState)
}
}
}

360
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Duplicateimagehighlighter.kt
View File

@@ -1,360 +0,0 @@
package com.placeholder.sherpai2.ui.trainingprep
import android.net.Uri
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyRow
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import coil.compose.AsyncImage
/**
* DuplicateImageHighlighter - Enhanced duplicate detection UI
*
* FEATURES:
* - Visual highlighting of duplicate groups
* - Shows thumbnail previews of duplicates
* - One-click "Remove Duplicate" button
* - Keeps best image automatically
* - Warning badge with count
*
* GENTLE UX:
* - Non-intrusive warning color (amber, not red)
* - Clear visual grouping
* - Simple action ("Remove" vs "Keep")
* - Automatic selection of which to remove
*/
@Composable
fun DuplicateImageHighlighter(
duplicateGroups: List<DuplicateImageDetector.DuplicateGroup>,
allImageUris: List<Uri>,
onRemoveDuplicate: (Uri) -> Unit,
modifier: Modifier = Modifier
) {
if (duplicateGroups.isEmpty()) return
Column(
modifier = modifier
.fillMaxWidth()
.padding(vertical = 8.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
// Header with count
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.Warning,
contentDescription = null,
tint = MaterialTheme.colorScheme.tertiary, // Amber, not red
modifier = Modifier.size(20.dp)
)
Text(
"${duplicateGroups.size} duplicate ${if (duplicateGroups.size == 1) "group" else "groups"} found",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
}
// Total duplicates badge
Surface(
shape = RoundedCornerShape(12.dp),
color = MaterialTheme.colorScheme.tertiaryContainer
) {
Text(
"${duplicateGroups.sumOf { it.images.size - 1 }} to remove",
modifier = Modifier.padding(horizontal = 12.dp, vertical = 4.dp),
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onTertiaryContainer,
fontWeight = FontWeight.Bold
)
}
}
// Each duplicate group
duplicateGroups.forEachIndexed { groupIndex, group ->
DuplicateGroupCard(
groupIndex = groupIndex + 1,
duplicateGroup = group,
onRemove = onRemoveDuplicate
)
}
}
}
/**
* Card showing one duplicate group with thumbnails
*/
@Composable
private fun DuplicateGroupCard(
groupIndex: Int,
duplicateGroup: DuplicateImageDetector.DuplicateGroup,
onRemove: (Uri) -> Unit
) {
var expanded by remember { mutableStateOf(false) }
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.3f)
),
border = BorderStroke(1.dp, MaterialTheme.colorScheme.tertiary.copy(alpha = 0.3f)),
shape = RoundedCornerShape(12.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(12.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
// Header row
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Group number badge
Surface(
shape = RoundedCornerShape(8.dp),
color = MaterialTheme.colorScheme.tertiary
) {
Text(
"#$groupIndex",
modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onTertiary,
fontWeight = FontWeight.Bold
)
}
Text(
"${duplicateGroup.images.size} identical images",
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.SemiBold
)
}
// Expand/collapse button
IconButton(
onClick = { expanded = !expanded },
modifier = Modifier.size(32.dp)
) {
Icon(
if (expanded) Icons.Default.ExpandLess else Icons.Default.ExpandMore,
contentDescription = if (expanded) "Collapse" else "Expand"
)
}
}
// Thumbnail row (always visible)
LazyRow(
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
items(duplicateGroup.images.take(3)) { uri ->
DuplicateThumbnail(
uri = uri,
similarity = duplicateGroup.similarity
)
}
if (duplicateGroup.images.size > 3) {
item {
Surface(
modifier = Modifier
.size(80.dp),
shape = RoundedCornerShape(8.dp),
color = MaterialTheme.colorScheme.surfaceVariant
) {
Box(contentAlignment = Alignment.Center) {
Text(
"+${duplicateGroup.images.size - 3}",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
}
}
}
}
}
// Action buttons
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
// Keep first, remove rest
Button(
onClick = {
// Remove all but the first image
duplicateGroup.images.drop(1).forEach { uri ->
onRemove(uri)
}
},
modifier = Modifier.weight(1f),
colors = ButtonDefaults.buttonColors(
containerColor = MaterialTheme.colorScheme.tertiary
)
) {
Icon(
Icons.Default.DeleteSweep,
contentDescription = null,
modifier = Modifier.size(18.dp)
)
Spacer(Modifier.width(6.dp))
Text("Remove ${duplicateGroup.images.size - 1} Duplicates")
}
}
// Expanded info (optional)
if (expanded) {
HorizontalDivider(color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f))
Column(
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Text(
"Individual actions:",
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
duplicateGroup.images.forEachIndexed { index, uri ->
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.weight(1f)
) {
AsyncImage(
model = uri,
contentDescription = null,
modifier = Modifier
.size(40.dp)
.background(
MaterialTheme.colorScheme.surfaceVariant,
RoundedCornerShape(6.dp)
),
contentScale = ContentScale.Crop
)
Text(
uri.lastPathSegment?.take(20) ?: "Image ${index + 1}",
style = MaterialTheme.typography.bodySmall,
modifier = Modifier.weight(1f)
)
}
if (index == 0) {
// First image - will be kept
Surface(
shape = RoundedCornerShape(8.dp),
color = MaterialTheme.colorScheme.primaryContainer
) {
Row(
modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
horizontalArrangement = Arrangement.spacedBy(4.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.CheckCircle,
contentDescription = null,
modifier = Modifier.size(14.dp),
tint = MaterialTheme.colorScheme.primary
)
Text(
"Keep",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.primary,
fontWeight = FontWeight.Bold
)
}
}
} else {
// Duplicate - will be removed
TextButton(
onClick = { onRemove(uri) },
colors = ButtonDefaults.textButtonColors(
contentColor = MaterialTheme.colorScheme.error
)
) {
Icon(
Icons.Default.Delete,
contentDescription = null,
modifier = Modifier.size(16.dp)
)
Spacer(Modifier.width(4.dp))
Text("Remove", style = MaterialTheme.typography.labelMedium)
}
}
}
}
}
}
}
}
}
/**
* Thumbnail with similarity badge
*/
@Composable
private fun DuplicateThumbnail(
uri: Uri,
similarity: Double
) {
Box {
AsyncImage(
model = uri,
contentDescription = null,
modifier = Modifier
.size(80.dp)
.background(
MaterialTheme.colorScheme.surfaceVariant,
RoundedCornerShape(8.dp)
),
contentScale = ContentScale.Crop
)
// Similarity badge
Surface(
modifier = Modifier
.align(Alignment.BottomEnd)
.padding(4.dp),
shape = RoundedCornerShape(4.dp),
color = MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.9f)
) {
Text(
"${(similarity * 100).toInt()}%",
modifier = Modifier.padding(horizontal = 4.dp, vertical = 2.dp),
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onTertiaryContainer,
fontWeight = FontWeight.Bold
)
}
}
}

421
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/FacePickerDialog.kt
View File

@@ -5,105 +5,65 @@ import android.graphics.BitmapFactory
import android.graphics.Rect
import android.net.Uri
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.Image
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material.icons.filled.CheckCircle
import androidx.compose.material.icons.filled.Close
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.geometry.Size
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.graphics.drawscope.Stroke
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
import androidx.compose.ui.window.DialogProperties
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.face.FaceDetection
import androidx.compose.ui.graphics.Color
import com.google.mlkit.vision.face.FaceDetectorOptions
import coil.compose.AsyncImage
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.tasks.await
import kotlinx.coroutines.withContext
/**
* MINIMAL FacePickerDialog - Optimized for batch processing 30-50 photos
*
* REMOVED CLUTTER:
* - "Preview (tap to select)" header
* - "Face will be used for training" info box
* - "Face #" labels covering previews
* - Original image preview
*
* IMPROVED:
* - Larger face previews (1:1 aspect ratio)
* - Clean checkmark overlay only
* - Minimal text
* - Fast workflow
* Dialog for selecting a face from multiple detected faces
*/
@Composable
fun FacePickerDialog(
result: FaceDetectionHelper.FaceDetectionResult,
onDismiss: () -> Unit,
onFaceSelected: (Int, Bitmap) -> Unit
onFaceSelected: (Int, Bitmap) -> Unit // faceIndex, croppedFaceBitmap
) {
val context = LocalContext.current
var selectedFaceIndex by remember { mutableStateOf(0) }
var selectedFaceIndex by remember { mutableStateOf<Int?>(null) }
var croppedFaces by remember { mutableStateOf<List<Bitmap>>(emptyList()) }
var isLoading by remember { mutableStateOf(true) }
var errorMessage by remember { mutableStateOf<String?>(null) }
// Load and crop all faces - RE-DETECT to get accurate bounds
// Load and crop all faces
LaunchedEffect(result) {
isLoading = true
errorMessage = null
try {
croppedFaces = withContext(Dispatchers.IO) {
// Load the FULL resolution bitmap (no downsampling)
val fullBitmap = loadFullResolutionBitmap(context, result.uri)
if (fullBitmap == null) {
errorMessage = "Failed to load image"
return@withContext emptyList()
croppedFaces = withContext(Dispatchers.IO) {
val bitmap = loadBitmapFromUri(context, result.uri)
bitmap?.let { bmp ->
result.faceBounds.map { bounds ->
cropFaceFromBitmap(bmp, bounds)
}
// Re-detect faces on the full resolution bitmap to get accurate bounds
val accurateFaceBounds = detectFacesOnBitmap(fullBitmap)
if (accurateFaceBounds.isEmpty()) {
// Fallback: try to use the original bounds with scaling
val scaledBounds = result.faceBounds.map { originalBounds ->
cropFaceFromBitmap(fullBitmap, originalBounds)
}
fullBitmap.recycle()
return@withContext scaledBounds
}
// Crop faces using accurate bounds
val croppedList = accurateFaceBounds.map { bounds ->
cropFaceFromBitmap(fullBitmap, bounds)
}
// CRITICAL: Recycle AFTER all cropping is done
fullBitmap.recycle()
croppedList
}
if (croppedFaces.isEmpty() && errorMessage == null) {
errorMessage = "No faces found in full resolution image"
}
} catch (e: Exception) {
errorMessage = "Error processing faces: ${e.message}"
} finally {
isLoading = false
} ?: emptyList()
}
isLoading = false
// Auto-select the first (largest) face
if (croppedFaces.isNotEmpty()) {
selectedFaceIndex = 0
}
}
@@ -113,62 +73,96 @@ fun FacePickerDialog(
) {
Card(
modifier = Modifier
.fillMaxWidth(0.92f)
.wrapContentHeight(),
shape = RoundedCornerShape(20.dp),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surface
)
.fillMaxWidth(0.95f)
.fillMaxHeight(0.9f),
shape = RoundedCornerShape(16.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.fillMaxSize()
.padding(20.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Minimal header - just close button
// Header
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = "${result.faceCount} faces",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Column {
Text(
text = "Pick a Face",
style = MaterialTheme.typography.headlineSmall,
fontWeight = FontWeight.Bold
)
Text(
text = "${result.faceCount} faces detected",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
IconButton(onClick = onDismiss) {
Icon(Icons.Default.Close, contentDescription = "Close")
Icon(Icons.Default.Close, "Close")
}
}
// Instruction
Text(
text = "Tap a face below to select it for training:",
style = MaterialTheme.typography.bodyMedium
)
if (isLoading) {
// Loading state - minimal
// Loading state
Box(
modifier = Modifier
.fillMaxWidth()
.height(180.dp),
.weight(1f),
contentAlignment = Alignment.Center
) {
CircularProgressIndicator()
}
} else if (errorMessage != null) {
// Error state - minimal
Text(
text = errorMessage!!,
color = MaterialTheme.colorScheme.error,
style = MaterialTheme.typography.bodyMedium
)
} else {
// CLEAN face grid - NO labels, NO text
// Original image with face boxes overlay
Card(
modifier = Modifier
.fillMaxWidth()
.weight(1f),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant
)
) {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
FaceOverlayImage(
imageUri = result.uri,
faceBounds = result.faceBounds,
selectedFaceIndex = selectedFaceIndex,
onFaceClick = { index ->
selectedFaceIndex = index
}
)
}
}
// Face previews grid
Text(
text = "Preview (tap to select):",
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.SemiBold
)
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(10.dp)
horizontalArrangement = Arrangement.spacedBy(12.dp)
) {
croppedFaces.forEachIndexed { index, faceBitmap ->
CleanFaceCard(
FacePreviewCard(
faceBitmap = faceBitmap,
index = index,
isSelected = selectedFaceIndex == index,
onClick = { selectedFaceIndex = index },
modifier = Modifier.weight(1f)
@@ -177,34 +171,32 @@ fun FacePickerDialog(
}
}
// Action buttons - minimal
// Action buttons
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(10.dp)
horizontalArrangement = Arrangement.spacedBy(12.dp)
) {
TextButton(
OutlinedButton(
onClick = onDismiss,
modifier = Modifier.weight(1f)
) {
Text("Skip")
Text("Cancel")
}
Button(
onClick = {
if (selectedFaceIndex < croppedFaces.size) {
onFaceSelected(selectedFaceIndex, croppedFaces[selectedFaceIndex])
selectedFaceIndex?.let { index ->
if (index < croppedFaces.size) {
onFaceSelected(index, croppedFaces[index])
}
}
},
enabled = !isLoading && croppedFaces.isNotEmpty(),
modifier = Modifier.weight(1f)
modifier = Modifier.weight(1f),
enabled = selectedFaceIndex != null && !isLoading
) {
Icon(
Icons.Default.Check,
contentDescription = null,
modifier = Modifier.size(18.dp)
)
Spacer(modifier = Modifier.width(6.dp))
Text("Use")
Icon(Icons.Default.CheckCircle, contentDescription = null)
Spacer(modifier = Modifier.width(8.dp))
Text("Use This Face")
}
}
}
@@ -213,75 +205,204 @@ fun FacePickerDialog(
}
/**
* ULTRA-CLEAN face card - NO TEXT, just image + checkmark
*
* CHANGES:
* - 1:1 aspect ratio (bigger!)
* - NO "Face #" label
* - Checkmark in corner only
* - Minimal border
* Image with interactive face boxes overlay
*/
@Composable
private fun CleanFaceCard(
private fun FaceOverlayImage(
imageUri: Uri,
faceBounds: List<Rect>,
selectedFaceIndex: Int?,
onFaceClick: (Int) -> Unit
) {
var imageSize by remember { mutableStateOf(Size.Zero) }
var imageBounds by remember { mutableStateOf(Rect()) }
Box(
modifier = Modifier.fillMaxSize()
) {
// Original image
AsyncImage(
model = imageUri,
contentDescription = "Original image",
modifier = Modifier
.fillMaxSize()
.padding(8.dp),
contentScale = ContentScale.Fit,
onSuccess = { state ->
val drawable = state.result.drawable
imageBounds = Rect(0, 0, drawable.intrinsicWidth, drawable.intrinsicHeight)
}
)
// Face boxes overlay
Canvas(
modifier = Modifier
.fillMaxSize()
.padding(8.dp)
) {
if (imageBounds.width() > 0 && imageBounds.height() > 0) {
// Calculate scale to fit image in canvas
val scaleX = size.width / imageBounds.width()
val scaleY = size.height / imageBounds.height()
val scale = minOf(scaleX, scaleY)
// Calculate offset to center image
val scaledWidth = imageBounds.width() * scale
val scaledHeight = imageBounds.height() * scale
val offsetX = (size.width - scaledWidth) / 2
val offsetY = (size.height - scaledHeight) / 2
faceBounds.forEachIndexed { index, bounds ->
val isSelected = selectedFaceIndex == index
// Scale and position the face box
val left = bounds.left * scale + offsetX
val top = bounds.top * scale + offsetY
val width = bounds.width() * scale
val height = bounds.height() * scale
// Draw box
drawRect(
color = if (isSelected) Color(0xFF4CAF50) else Color(0xFF2196F3),
topLeft = Offset(left, top),
size = Size(width, height),
style = Stroke(width = if (isSelected) 6f else 4f)
)
// Draw semi-transparent fill for selected
if (isSelected) {
drawRect(
color = Color(0xFF4CAF50).copy(alpha = 0.2f),
topLeft = Offset(left, top),
size = Size(width, height)
)
}
// Draw face number label
drawCircle(
color = if (isSelected) Color(0xFF4CAF50) else Color(0xFF2196F3),
radius = 20f * scale,
center = Offset(left + 20f * scale, top + 20f * scale)
)
}
}
}
// Clickable areas for each face
faceBounds.forEachIndexed { index, bounds ->
if (imageBounds.width() > 0 && imageBounds.height() > 0) {
val scaleX = imageSize.width / imageBounds.width()
val scaleY = imageSize.height / imageBounds.height()
val scale = minOf(scaleX, scaleY)
val scaledWidth = imageBounds.width() * scale
val scaledHeight = imageBounds.height() * scale
val offsetX = (imageSize.width - scaledWidth) / 2
val offsetY = (imageSize.height - scaledHeight) / 2
Box(
modifier = Modifier
.fillMaxSize()
.clickable { onFaceClick(index) }
)
}
}
}
// Update image size
BoxWithConstraints {
LaunchedEffect(constraints) {
imageSize = Size(constraints.maxWidth.toFloat(), constraints.maxHeight.toFloat())
}
}
}
/**
* Individual face preview card
*/
@Composable
private fun FacePreviewCard(
faceBitmap: Bitmap,
index: Int,
isSelected: Boolean,
onClick: () -> Unit,
modifier: Modifier = Modifier
) {
Card(
modifier = modifier
.aspectRatio(1f) // SQUARE = bigger previews!
.aspectRatio(1f)
.clickable(onClick = onClick),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant
containerColor = if (isSelected)
MaterialTheme.colorScheme.primaryContainer
else
MaterialTheme.colorScheme.surface
),
border = if (isSelected)
BorderStroke(3.dp, MaterialTheme.colorScheme.primary)
else
BorderStroke(1.dp, MaterialTheme.colorScheme.outline.copy(alpha = 0.3f)),
shape = RoundedCornerShape(12.dp),
elevation = CardDefaults.cardElevation(
defaultElevation = if (isSelected) 4.dp else 1.dp
)
BorderStroke(1.dp, MaterialTheme.colorScheme.outline)
) {
Box(modifier = Modifier.fillMaxSize()) {
// Face image - FULL SIZE
Image(
Box(
modifier = Modifier.fillMaxSize()
) {
androidx.compose.foundation.Image(
bitmap = faceBitmap.asImageBitmap(),
contentDescription = null,
contentDescription = "Face ${index + 1}",
modifier = Modifier.fillMaxSize(),
contentScale = ContentScale.Crop
)
// Checkmark in corner - ONLY if selected
// Selected checkmark (only show when selected)
if (isSelected) {
Surface(
modifier = Modifier
.align(Alignment.TopEnd)
.padding(6.dp)
.size(32.dp),
.align(Alignment.Center),
shape = CircleShape,
color = MaterialTheme.colorScheme.primary,
shadowElevation = 4.dp
color = MaterialTheme.colorScheme.primary.copy(alpha = 0.9f)
) {
Icon(
Icons.Default.CheckCircle,
contentDescription = "Selected",
modifier = Modifier
.padding(6.dp)
.size(20.dp),
.padding(12.dp)
.size(32.dp),
tint = MaterialTheme.colorScheme.onPrimary
)
}
}
// Face number badge (always in top-right, small)
Surface(
modifier = Modifier
.align(Alignment.TopEnd)
.padding(4.dp),
shape = CircleShape,
color = if (isSelected)
MaterialTheme.colorScheme.primary
else
MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.9f),
shadowElevation = 2.dp
) {
Text(
text = "${index + 1}",
modifier = Modifier.padding(6.dp),
style = MaterialTheme.typography.labelSmall,
fontWeight = FontWeight.Bold,
color = if (isSelected)
MaterialTheme.colorScheme.onPrimary
else
MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
}
/**
* Load full resolution bitmap WITHOUT downsampling
* Helper function to load bitmap from URI
*/
private suspend fun loadFullResolutionBitmap(
private suspend fun loadBitmapFromUri(
context: android.content.Context,
uri: Uri
): Bitmap? = withContext(Dispatchers.IO) {
@@ -296,33 +417,7 @@ private suspend fun loadFullResolutionBitmap(
}
/**
* Re-detect faces on full resolution bitmap to get accurate bounds
*/
private suspend fun detectFacesOnBitmap(bitmap: Bitmap): List<Rect> = withContext(Dispatchers.Default) {
try {
val options = FaceDetectorOptions.Builder()
.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
.setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_NONE)
.setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_NONE)
.setMinFaceSize(0.10f)
.build()
val detector = FaceDetection.getClient(options)
val image = InputImage.fromBitmap(bitmap, 0)
val faces = detector.process(image).await()
// Sort by size (largest first)
faces.sortedByDescending { face ->
face.boundingBox.width() * face.boundingBox.height()
}.map { it.boundingBox }
} catch (e: Exception) {
emptyList()
}
}
/**
* Crop face from bitmap with padding
* Helper function to crop face from bitmap
*/
private fun cropFaceFromBitmap(bitmap: Bitmap, faceBounds: Rect): Bitmap {
// Add 20% padding around the face

139
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Facedetectionhelper.kt
View File

@@ -8,29 +8,19 @@ import android.net.Uri
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.face.FaceDetection
import com.google.mlkit.vision.face.FaceDetectorOptions
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.tasks.await
import kotlinx.coroutines.withContext
import java.io.InputStream
/**
* FIXED FaceDetectionHelper with parallel processing
*
* FIXES:
* - Removed bitmap.recycle() that broke face cropping
* - Proper memory management with downsampling
* - Parallel processing for speed
* Helper class for detecting faces in images using ML Kit Face Detection
*/
class FaceDetectionHelper(private val context: Context) {
private val faceDetectorOptions = FaceDetectorOptions.Builder()
.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE) // ACCURATE for quality
.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
.setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL)
.setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL)
.setMinFaceSize(0.15f)
.setMinFaceSize(0.15f) // Detect faces that are at least 15% of image
.build()
private val detector = FaceDetection.getClient(faceDetectorOptions)
@@ -40,7 +30,7 @@ class FaceDetectionHelper(private val context: Context) {
val hasFace: Boolean,
val faceCount: Int,
val faceBounds: List<Rect> = emptyList(),
val croppedFaceBitmap: Bitmap? = null, // Only largest face
val croppedFaceBitmap: Bitmap? = null,
val errorMessage: String? = null
)
@@ -48,77 +38,48 @@ class FaceDetectionHelper(private val context: Context) {
* Detect faces in a single image
*/
suspend fun detectFacesInImage(uri: Uri): FaceDetectionResult {
return withContext(Dispatchers.IO) {
var bitmap: Bitmap? = null
try {
bitmap = loadBitmap(uri)
if (bitmap == null) {
return@withContext FaceDetectionResult(
uri = uri,
hasFace = false,
faceCount = 0,
errorMessage = "Failed to load image"
)
}
val inputImage = InputImage.fromBitmap(bitmap, 0)
val faces = detector.process(inputImage).await()
// Sort by face size (area) to get the largest face
val sortedFaces = faces.sortedByDescending { face ->
face.boundingBox.width() * face.boundingBox.height()
}
val croppedFace = if (sortedFaces.isNotEmpty()) {
// Crop the LARGEST detected face (most likely the subject)
cropFaceFromBitmap(bitmap, sortedFaces[0].boundingBox)
} else null
FaceDetectionResult(
uri = uri,
hasFace = faces.isNotEmpty(),
faceCount = faces.size,
faceBounds = faces.map { it.boundingBox },
croppedFaceBitmap = croppedFace
)
} catch (e: Exception) {
FaceDetectionResult(
return try {
val bitmap = loadBitmap(uri)
if (bitmap == null) {
return FaceDetectionResult(
uri = uri,
hasFace = false,
faceCount = 0,
errorMessage = e.message ?: "Unknown error"
errorMessage = "Failed to load image"
)
} finally {
// NOW we can recycle after we're completely done
bitmap?.recycle()
}
val inputImage = InputImage.fromBitmap(bitmap, 0)
val faces = detector.process(inputImage).await()
val croppedFace = if (faces.isNotEmpty()) {
// Crop the first detected face with some padding
cropFaceFromBitmap(bitmap, faces[0].boundingBox)
} else null
FaceDetectionResult(
uri = uri,
hasFace = faces.isNotEmpty(),
faceCount = faces.size,
faceBounds = faces.map { it.boundingBox },
croppedFaceBitmap = croppedFace
)
} catch (e: Exception) {
FaceDetectionResult(
uri = uri,
hasFace = false,
faceCount = 0,
errorMessage = e.message ?: "Unknown error"
)
}
}
/**
* PARALLEL face detection in multiple images - 10x FASTER!
*
* @param onProgress Callback with (current, total)
* Detect faces in multiple images
*/
suspend fun detectFacesInImages(
uris: List<Uri>,
onProgress: ((Int, Int) -> Unit)? = null
): List<FaceDetectionResult> = coroutineScope {
val total = uris.size
var completed = 0
// Process in parallel batches of 5 to avoid overwhelming the system
uris.chunked(5).flatMap { batch ->
batch.map { uri ->
async(Dispatchers.IO) {
val result = detectFacesInImage(uri)
synchronized(this@FaceDetectionHelper) {
completed++
onProgress?.invoke(completed, total)
}
result
}
}.awaitAll()
suspend fun detectFacesInImages(uris: List<Uri>): List<FaceDetectionResult> {
return uris.map { uri ->
detectFacesInImage(uri)
}
}
@@ -141,35 +102,13 @@ class FaceDetectionHelper(private val context: Context) {
}
/**
* Load bitmap from URI with downsampling for memory efficiency
* Load bitmap from URI
*/
private fun loadBitmap(uri: Uri): Bitmap? {
return try {
val inputStream: InputStream? = context.contentResolver.openInputStream(uri)
// First decode with inJustDecodeBounds to get dimensions
val options = BitmapFactory.Options().apply {
inJustDecodeBounds = true
}
BitmapFactory.decodeStream(inputStream, null, options)
inputStream?.close()
// Calculate sample size to limit max dimension to 1024px
val maxDimension = 1024
var sampleSize = 1
while (options.outWidth / sampleSize > maxDimension ||
options.outHeight / sampleSize > maxDimension) {
sampleSize *= 2
}
// Now decode with sample size
val inputStream2 = context.contentResolver.openInputStream(uri)
val finalOptions = BitmapFactory.Options().apply {
inSampleSize = sampleSize
}
BitmapFactory.decodeStream(inputStream2, null, finalOptions)?.also {
inputStream2?.close()
BitmapFactory.decodeStream(inputStream)?.also {
inputStream?.close()
}
} catch (e: Exception) {
null

93
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/ImageSelectorScreen.kt
View File

@@ -4,58 +4,45 @@ import android.net.Uri
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.lazy.grid.GridCells
import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
import androidx.compose.foundation.lazy.grid.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.placeholder.sherpai2.data.local.dao.ImageDao
import com.placeholder.sherpai2.data.local.entity.ImageEntity
import kotlinx.coroutines.launch
/**
* OPTIMIZED ImageSelectorScreen
* Enhanced ImageSelectorScreen
*
* 🎯 NEW FEATURE: Filter to only show face-tagged images!
* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
* - Uses face detection cache to pre-filter
* - Shows "Only photos with faces" toggle
* - Dramatically faster photo selection
* - Better training quality (no manual filtering needed)
* Changes:
* - NO LIMIT on photo count (was 10)
* - Recommends 20-30 photos
* - Real-time progress feedback
* - Quality indicators
* - Training tips
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ImageSelectorScreen(
onImagesSelected: (List<Uri>) -> Unit
) {
// Inject ImageDao via Hilt ViewModel pattern
val viewModel: ImageSelectorViewModel = hiltViewModel()
val faceTaggedUris by viewModel.faceTaggedImageUris.collectAsStateWithLifecycle()
var selectedImages by remember { mutableStateOf<List<Uri>>(emptyList()) }
var onlyShowFaceImages by remember { mutableStateOf(true) } // Default: smart filtering
val scrollState = rememberScrollState()
val photoPicker = rememberLauncherForActivityResult(
contract = ActivityResultContracts.GetMultipleContents()
) { uris ->
if (uris.isNotEmpty()) {
// Filter to only face-tagged images if toggle is on
selectedImages = if (onlyShowFaceImages && faceTaggedUris.isNotEmpty()) {
uris.filter { it.toString() in faceTaggedUris }
} else {
uris
}
selectedImages = uris
}
}
@@ -73,59 +60,10 @@ fun ImageSelectorScreen(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues)
.verticalScroll(scrollState)
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Smart filtering card
if (faceTaggedUris.isNotEmpty()) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.tertiaryContainer
),
shape = RoundedCornerShape(16.dp)
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Column(modifier = Modifier.weight(1f)) {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.AutoFixHigh,
contentDescription = null,
tint = MaterialTheme.colorScheme.tertiary
)
Text(
"Smart Filtering",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
}
Spacer(Modifier.height(4.dp))
Text(
"Only show photos with detected faces (${faceTaggedUris.size} available)",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onTertiaryContainer.copy(alpha = 0.8f)
)
}
Switch(
checked = onlyShowFaceImages,
onCheckedChange = { onlyShowFaceImages = it }
)
}
}
}
// Gradient header with tips
Card(
modifier = Modifier.fillMaxWidth(),
@@ -186,6 +124,8 @@ fun ImageSelectorScreen(
ProgressCard(selectedImages.size)
}
Spacer(Modifier.weight(1f))
// Select photos button
Button(
onClick = { photoPicker.launch("image/*") },
@@ -260,9 +200,6 @@ fun ImageSelectorScreen(
}
}
}
// Bottom spacing to ensure last item is visible
Spacer(Modifier.height(32.dp))
}
}
}

42
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/ImageSelectorViewModel.kt
View File

@@ -1,42 +0,0 @@
package com.placeholder.sherpai2.ui.trainingprep
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.placeholder.sherpai2.data.local.dao.ImageDao
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
/**
* ImageSelectorViewModel
*
* Provides face-tagged image URIs for smart filtering
* during training photo selection
*/
@HiltViewModel
class ImageSelectorViewModel @Inject constructor(
private val imageDao: ImageDao
) : ViewModel() {
private val _faceTaggedImageUris = MutableStateFlow<List<String>>(emptyList())
val faceTaggedImageUris: StateFlow<List<String>> = _faceTaggedImageUris.asStateFlow()
init {
loadFaceTaggedImages()
}
private fun loadFaceTaggedImages() {
viewModelScope.launch {
try {
val imagesWithFaces = imageDao.getImagesWithFaces()
_faceTaggedImageUris.value = imagesWithFaces.map { it.imageUri }
} catch (e: Exception) {
// If cache not available, just use empty list (filter disabled)
_faceTaggedImageUris.value = emptyList()
}
}
}
}

231
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Improvednameinputdialog.kt
View File

@@ -1,231 +0,0 @@
package com.placeholder.sherpai2.ui.trainingprep
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardCapitalization
import androidx.compose.ui.unit.dp
import androidx.compose.ui.window.Dialog
/**
* IMPROVED NameInputDialog - Better centered, cleaner layout
*
* Fixes:
* - Centered dialog with proper constraints
* - Better spacing and padding
* - Clearer visual hierarchy
* - Improved error state handling
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ImprovedNameInputDialog(
onDismiss: () -> Unit,
onConfirm: (String) -> Unit,
trainingState: TrainingState
) {
var personName by remember { mutableStateOf("") }
val isError = trainingState is TrainingState.Error
val isProcessing = trainingState is TrainingState.Processing
Dialog(
onDismissRequest = {
if (!isProcessing) {
onDismiss()
}
}
) {
Card(
modifier = Modifier
.fillMaxWidth(0.9f) // 90% of screen width
.wrapContentHeight(),
shape = RoundedCornerShape(24.dp),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surface
),
elevation = CardDefaults.cardElevation(defaultElevation = 8.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(24.dp),
verticalArrangement = Arrangement.spacedBy(20.dp),
horizontalAlignment = Alignment.CenterHorizontally
) {
// Icon
Surface(
shape = RoundedCornerShape(16.dp),
color = if (isError) {
MaterialTheme.colorScheme.errorContainer
} else {
MaterialTheme.colorScheme.primaryContainer
},
modifier = Modifier.size(72.dp)
) {
Box(contentAlignment = Alignment.Center) {
Icon(
if (isError) Icons.Default.Warning else Icons.Default.Face,
contentDescription = null,
modifier = Modifier.size(40.dp),
tint = if (isError) {
MaterialTheme.colorScheme.error
} else {
MaterialTheme.colorScheme.primary
}
)
}
}
// Title
Text(
text = if (isError) "Training Error" else "Who is this?",
style = MaterialTheme.typography.headlineSmall,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.onSurface
)
// Error message or description
if (isError) {
val error = trainingState as TrainingState.Error
Card(
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.errorContainer
),
shape = RoundedCornerShape(12.dp)
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.Error,
contentDescription = null,
tint = MaterialTheme.colorScheme.error
)
Text(
text = error.message,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onErrorContainer
)
}
}
} else {
Text(
text = "Enter the name of the person in these training images. This will help you find their photos later.",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
// Name input field
OutlinedTextField(
value = personName,
onValueChange = { personName = it },
label = { Text("Person's Name") },
placeholder = { Text("e.g., John Doe") },
singleLine = true,
enabled = !isProcessing,
keyboardOptions = KeyboardOptions(
capitalization = KeyboardCapitalization.Words,
imeAction = ImeAction.Done
),
keyboardActions = KeyboardActions(
onDone = {
if (personName.isNotBlank() && !isProcessing) {
onConfirm(personName.trim())
}
}
),
modifier = Modifier.fillMaxWidth(),
shape = RoundedCornerShape(12.dp),
colors = OutlinedTextFieldDefaults.colors(
focusedBorderColor = MaterialTheme.colorScheme.primary,
unfocusedBorderColor = MaterialTheme.colorScheme.outline
)
)
// Action buttons
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(12.dp)
) {
// Cancel button
if (!isProcessing) {
OutlinedButton(
onClick = onDismiss,
modifier = Modifier.weight(1f),
shape = RoundedCornerShape(12.dp),
contentPadding = PaddingValues(vertical = 14.dp)
) {
Text("Cancel")
}
}
// Confirm button
Button(
onClick = { onConfirm(personName.trim()) },
enabled = personName.isNotBlank() && !isProcessing,
modifier = Modifier.weight(if (isProcessing) 1f else 1f),
shape = RoundedCornerShape(12.dp),
contentPadding = PaddingValues(vertical = 14.dp),
colors = ButtonDefaults.buttonColors(
containerColor = if (isError) {
MaterialTheme.colorScheme.error
} else {
MaterialTheme.colorScheme.primary
}
)
) {
if (isProcessing) {
CircularProgressIndicator(
modifier = Modifier.size(20.dp),
strokeWidth = 2.dp,
color = MaterialTheme.colorScheme.onPrimary
)
Spacer(modifier = Modifier.width(12.dp))
Text("Training...")
} else {
Icon(
if (isError) Icons.Default.Refresh else Icons.Default.Check,
contentDescription = null,
modifier = Modifier.size(20.dp)
)
Spacer(modifier = Modifier.width(8.dp))
Text(if (isError) "Try Again" else "Start Training")
}
}
}
}
}
}
}
/**
* Alternative: Use this version in ScanResultsScreen.kt
*
* Replace the existing NameInputDialog function (lines 154-257) with:
*
* @Composable
* private fun NameInputDialog(
* onDismiss: () -> Unit,
* onConfirm: (String) -> Unit,
* trainingState: TrainingState
* ) {
* ImprovedNameInputDialog(
* onDismiss = onDismiss,
* onConfirm = onConfirm,
* trainingState = trainingState
* )
* }
*/

626
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/ScanResultsScreen.kt
View File

@@ -13,6 +13,8 @@ import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.itemsIndexed
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
@@ -24,12 +26,13 @@ import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.asImageBitmap
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardCapitalization
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import coil.compose.AsyncImage
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ScanResultsScreen(
@@ -38,23 +41,33 @@ fun ScanResultsScreen(
trainViewModel: TrainViewModel = hiltViewModel()
) {
var showFacePickerDialog by remember { mutableStateOf<FaceDetectionHelper.FaceDetectionResult?>(null) }
var showNameInputDialog by remember { mutableStateOf(false) }
// Observe training state
val trainingState by trainViewModel.trainingState.collectAsState()
// Handle training state changes
LaunchedEffect(trainingState) {
when (trainingState) {
is TrainingState.Success -> {
// Training completed successfully
val success = trainingState as TrainingState.Success
// You can show a success message or navigate away
// For now, we'll just reset and finish
trainViewModel.resetTrainingState()
onFinish()
}
is TrainingState.Error -> {}
else -> {}
is TrainingState.Error -> {
// Error will be shown in dialog, no action needed here
}
else -> { /* Idle or Processing */ }
}
}
Scaffold(
topBar = {
TopAppBar(
title = { Text("Train New Person") },
title = { Text("Training Image Analysis") },
colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
)
@@ -67,21 +80,23 @@ fun ScanResultsScreen(
.padding(paddingValues)
) {
when (state) {
is ScanningState.Idle -> {}
is ScanningState.Idle -> {
// Should not happen
}
is ScanningState.Processing -> {
ProcessingView(progress = state.progress, total = state.total)
ProcessingView(
progress = state.progress,
total = state.total
)
}
is ScanningState.Success -> {
ImprovedResultsView(
result = state.sanityCheckResult,
onContinue = {
// PersonInfo already captured in TrainingScreen!
// Just start training with stored info
trainViewModel.createFaceModel(
trainViewModel.getPersonInfo()?.name ?: "Unknown"
)
// Show name input dialog instead of immediately finishing
showNameInputDialog = true
},
onRetry = onFinish,
onReplaceImage = { oldUri, newUri ->
@@ -89,22 +104,26 @@ fun ScanResultsScreen(
},
onSelectFaceFromMultiple = { result ->
showFacePickerDialog = result
},
trainViewModel = trainViewModel
}
)
}
is ScanningState.Error -> {
ErrorView(message = state.message, onRetry = onFinish)
ErrorView(
message = state.message,
onRetry = onFinish
)
}
}
// Show training overlay if processing
if (trainingState is TrainingState.Processing) {
TrainingOverlay(trainingState = trainingState as TrainingState.Processing)
}
}
}
// Face Picker Dialog
showFacePickerDialog?.let { result ->
FacePickerDialog(
result = result,
@@ -115,32 +134,181 @@ fun ScanResultsScreen(
}
)
}
// Name Input Dialog
if (showNameInputDialog) {
NameInputDialog(
onDismiss = { showNameInputDialog = false },
onConfirm = { name ->
showNameInputDialog = false
trainViewModel.createFaceModel(name)
},
trainingState = trainingState
)
}
}
/**
* Dialog for entering person's name before training
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun NameInputDialog(
onDismiss: () -> Unit,
onConfirm: (String) -> Unit,
trainingState: TrainingState
) {
var personName by remember { mutableStateOf("") }
val isError = trainingState is TrainingState.Error
AlertDialog(
onDismissRequest = {
if (trainingState !is TrainingState.Processing) {
onDismiss()
}
},
title = {
Text(
text = if (isError) "Training Error" else "Who is this?",
style = MaterialTheme.typography.headlineSmall
)
},
text = {
Column(
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
if (isError) {
// Show error message
val error = trainingState as TrainingState.Error
Surface(
color = MaterialTheme.colorScheme.errorContainer,
shape = RoundedCornerShape(8.dp)
) {
Row(
modifier = Modifier.padding(12.dp),
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.Warning,
contentDescription = null,
tint = MaterialTheme.colorScheme.error
)
Text(
text = error.message,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onErrorContainer
)
}
}
} else {
Text(
text = "Enter the name of the person in these training images. This will help you find their photos later.",
style = MaterialTheme.typography.bodyMedium
)
}
OutlinedTextField(
value = personName,
onValueChange = { personName = it },
label = { Text("Person's Name") },
placeholder = { Text("e.g., John Doe") },
singleLine = true,
enabled = trainingState !is TrainingState.Processing,
keyboardOptions = KeyboardOptions(
capitalization = KeyboardCapitalization.Words,
imeAction = ImeAction.Done
),
keyboardActions = KeyboardActions(
onDone = {
if (personName.isNotBlank()) {
onConfirm(personName.trim())
}
}
),
modifier = Modifier.fillMaxWidth()
)
}
},
confirmButton = {
Button(
onClick = { onConfirm(personName.trim()) },
enabled = personName.isNotBlank() && trainingState !is TrainingState.Processing
) {
if (trainingState is TrainingState.Processing) {
CircularProgressIndicator(
modifier = Modifier.size(16.dp),
strokeWidth = 2.dp,
color = MaterialTheme.colorScheme.onPrimary
)
Spacer(modifier = Modifier.width(8.dp))
}
Text(if (isError) "Try Again" else "Start Training")
}
},
dismissButton = {
if (trainingState !is TrainingState.Processing) {
TextButton(onClick = onDismiss) {
Text("Cancel")
}
}
}
)
}
/**
* Overlay shown during training process
*/
@Composable
private fun TrainingOverlay(trainingState: TrainingState.Processing) {
Box(
modifier = Modifier.fillMaxSize().background(Color.Black.copy(alpha = 0.7f)),
modifier = Modifier
.fillMaxSize()
.background(Color.Black.copy(alpha = 0.7f)),
contentAlignment = Alignment.Center
) {
Card(
modifier = Modifier.padding(32.dp).fillMaxWidth(0.9f),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface)
modifier = Modifier
.padding(32.dp)
.fillMaxWidth(0.9f),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surface
)
) {
Column(
modifier = Modifier.padding(24.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
CircularProgressIndicator(modifier = Modifier.size(64.dp), strokeWidth = 6.dp)
Text("Creating Face Model", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
Text(trainingState.stage, style = MaterialTheme.typography.bodyMedium, textAlign = TextAlign.Center, color = MaterialTheme.colorScheme.onSurfaceVariant)
CircularProgressIndicator(
modifier = Modifier.size(64.dp),
strokeWidth = 6.dp
)
Text(
text = "Creating Face Model",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
text = trainingState.stage,
style = MaterialTheme.typography.bodyMedium,
textAlign = TextAlign.Center,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
if (trainingState.total > 0) {
LinearProgressIndicator(
progress = { (trainingState.progress.toFloat() / trainingState.total.toFloat()).coerceIn(0f, 1f) },
modifier = Modifier.fillMaxWidth()
)
Text("${trainingState.progress} / ${trainingState.total}", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
Text(
text = "${trainingState.progress} / ${trainingState.total}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
@@ -154,18 +322,31 @@ private fun ProcessingView(progress: Int, total: Int) {
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
CircularProgressIndicator(modifier = Modifier.size(64.dp), strokeWidth = 6.dp)
CircularProgressIndicator(
modifier = Modifier.size(64.dp),
strokeWidth = 6.dp
)
Spacer(modifier = Modifier.height(24.dp))
Text("Analyzing images...", style = MaterialTheme.typography.titleMedium)
Text(
text = "Analyzing images...",
style = MaterialTheme.typography.titleMedium
)
Spacer(modifier = Modifier.height(8.dp))
Text("Detecting faces and checking for duplicates", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
Text(
text = "Detecting faces and checking for duplicates",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
if (total > 0) {
Spacer(modifier = Modifier.height(16.dp))
LinearProgressIndicator(
progress = { (progress.toFloat() / total.toFloat()).coerceIn(0f, 1f) },
modifier = Modifier.width(200.dp)
)
Text("$progress / $total", style = MaterialTheme.typography.bodySmall)
Text(
text = "$progress / $total",
style = MaterialTheme.typography.bodySmall
)
}
}
}
@@ -176,24 +357,32 @@ private fun ImprovedResultsView(
onContinue: () -> Unit,
onRetry: () -> Unit,
onReplaceImage: (Uri, Uri) -> Unit,
onSelectFaceFromMultiple: (FaceDetectionHelper.FaceDetectionResult) -> Unit,
trainViewModel: TrainViewModel
onSelectFaceFromMultiple: (FaceDetectionHelper.FaceDetectionResult) -> Unit
) {
LazyColumn(
modifier = Modifier.fillMaxSize(),
contentPadding = PaddingValues(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Welcome Header
item {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.secondaryContainer)
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.secondaryContainer
)
) {
Column(modifier = Modifier.padding(16.dp)) {
Text("Analysis Complete!", style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold)
Column(
modifier = Modifier.padding(16.dp)
) {
Text(
text = "Analysis Complete!",
style = MaterialTheme.typography.headlineSmall,
fontWeight = FontWeight.Bold
)
Spacer(modifier = Modifier.height(4.dp))
Text(
"Review your images below. Tap 'Pick Face' on group photos to choose which person to train on, or 'Replace' to swap out any image.",
text = "Review your images below. Tap 'Pick Face' on group photos to choose which person to train on, or 'Replace' to swap out any image.",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSecondaryContainer.copy(alpha = 0.8f)
)
@@ -201,6 +390,7 @@ private fun ImprovedResultsView(
}
}
// Progress Summary
item {
ProgressSummaryCard(
totalImages = result.faceDetectionResults.size,
@@ -210,28 +400,38 @@ private fun ImprovedResultsView(
)
}
// Image List Header
item {
Text("Your Images (${result.faceDetectionResults.size})", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
Text(
text = "Your Images (${result.faceDetectionResults.size})",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
}
// Image List with Actions
itemsIndexed(result.faceDetectionResults) { index, imageResult ->
ImageResultCard(
index = index + 1,
result = imageResult,
onReplace = { newUri -> onReplaceImage(imageResult.uri, newUri) },
onSelectFace = if (imageResult.faceCount > 1) { { onSelectFaceFromMultiple(imageResult) } } else null,
trainViewModel = trainViewModel,
isExcluded = trainViewModel.isImageExcluded(imageResult.uri)
onReplace = { newUri ->
onReplaceImage(imageResult.uri, newUri)
},
onSelectFace = if (imageResult.faceCount > 1) {
{ onSelectFaceFromMultiple(imageResult) }
} else null
)
}
// Validation Issues (if any)
if (result.validationErrors.isNotEmpty()) {
item {
Spacer(modifier = Modifier.height(8.dp))
ValidationIssuesCard(errors = result.validationErrors, trainViewModel = trainViewModel)
ValidationIssuesCard(errors = result.validationErrors)
}
}
// Action Button
item {
Spacer(modifier = Modifier.height(8.dp))
Button(
@@ -239,10 +439,16 @@ private fun ImprovedResultsView(
modifier = Modifier.fillMaxWidth(),
enabled = result.isValid,
colors = ButtonDefaults.buttonColors(
containerColor = if (result.isValid) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error.copy(alpha = 0.5f)
containerColor = if (result.isValid)
MaterialTheme.colorScheme.primary
else
MaterialTheme.colorScheme.error.copy(alpha = 0.5f)
)
) {
Icon(if (result.isValid) Icons.Default.CheckCircle else Icons.Default.Warning, contentDescription = null)
Icon(
if (result.isValid) Icons.Default.CheckCircle else Icons.Default.Warning,
contentDescription = null
)
Spacer(modifier = Modifier.width(8.dp))
Text(
if (result.isValid)
@@ -259,11 +465,19 @@ private fun ImprovedResultsView(
color = MaterialTheme.colorScheme.tertiaryContainer,
shape = RoundedCornerShape(8.dp)
) {
Row(modifier = Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
Icon(Icons.Default.Info, contentDescription = null, tint = MaterialTheme.colorScheme.onTertiaryContainer, modifier = Modifier.size(20.dp))
Row(
modifier = Modifier.padding(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.Info,
contentDescription = null,
tint = MaterialTheme.colorScheme.onTertiaryContainer,
modifier = Modifier.size(20.dp)
)
Spacer(modifier = Modifier.width(8.dp))
Text(
"Tip: Use 'Replace' to swap problematic images, or 'Pick Face' to choose from group photos",
text = "Tip: Use 'Replace' to swap problematic images, or 'Pick Face' to choose from group photos",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onTertiaryContainer
)
@@ -275,30 +489,74 @@ private fun ImprovedResultsView(
}
@Composable
private fun ProgressSummaryCard(totalImages: Int, validImages: Int, requiredImages: Int, isValid: Boolean) {
private fun ProgressSummaryCard(
totalImages: Int,
validImages: Int,
requiredImages: Int,
isValid: Boolean
) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = if (isValid) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f) else MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
containerColor = if (isValid)
MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f)
else
MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
)
) {
Column(modifier = Modifier.padding(16.dp)) {
Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
Text("Progress", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
Column(
modifier = Modifier.padding(16.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = "Progress",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
Icon(
imageVector = if (isValid) Icons.Default.CheckCircle else Icons.Default.Warning,
contentDescription = null,
tint = if (isValid) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error,
tint = if (isValid)
MaterialTheme.colorScheme.primary
else
MaterialTheme.colorScheme.error,
modifier = Modifier.size(32.dp)
)
}
Spacer(modifier = Modifier.height(12.dp))
Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceEvenly) {
StatItem("Total", totalImages.toString(), MaterialTheme.colorScheme.onSurface)
StatItem("Valid", validImages.toString(), if (validImages >= requiredImages) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error)
StatItem("Need", requiredImages.toString(), MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f))
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceEvenly
) {
StatItem(
label = "Total",
value = totalImages.toString(),
color = MaterialTheme.colorScheme.onSurface
)
StatItem(
label = "Valid",
value = validImages.toString(),
color = if (validImages >= requiredImages)
MaterialTheme.colorScheme.primary
else
MaterialTheme.colorScheme.error
)
StatItem(
label = "Need",
value = requiredImages.toString(),
color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f)
)
}
Spacer(modifier = Modifier.height(12.dp))
LinearProgressIndicator(
progress = { (validImages.toFloat() / requiredImages.toFloat()).coerceIn(0f, 1f) },
modifier = Modifier.fillMaxWidth(),
@@ -311,8 +569,17 @@ private fun ProgressSummaryCard(totalImages: Int, validImages: Int, requiredImag
@Composable
private fun StatItem(label: String, value: String, color: Color) {
Column(horizontalAlignment = Alignment.CenterHorizontally) {
Text(value, style = MaterialTheme.typography.headlineMedium, fontWeight = FontWeight.Bold, color = color)
Text(label, style = MaterialTheme.typography.bodySmall, color = color.copy(alpha = 0.7f))
Text(
text = value,
style = MaterialTheme.typography.headlineMedium,
fontWeight = FontWeight.Bold,
color = color
)
Text(
text = label,
style = MaterialTheme.typography.bodySmall,
color = color.copy(alpha = 0.7f)
)
}
}
@@ -321,14 +588,15 @@ private fun ImageResultCard(
index: Int,
result: FaceDetectionHelper.FaceDetectionResult,
onReplace: (Uri) -> Unit,
onSelectFace: (() -> Unit)?,
trainViewModel: TrainViewModel,
isExcluded: Boolean
onSelectFace: (() -> Unit)?
) {
val photoPickerLauncher = rememberLauncherForActivityResult(contract = ActivityResultContracts.PickVisualMedia()) { uri -> uri?.let { onReplace(it) } }
val photoPickerLauncher = rememberLauncherForActivityResult(
contract = ActivityResultContracts.PickVisualMedia()
) { uri ->
uri?.let { onReplace(it) }
}
val status = when {
isExcluded -> ImageStatus.EXCLUDED
result.errorMessage != null -> ImageStatus.ERROR
!result.hasFace -> ImageStatus.NO_FACE
result.faceCount > 1 -> ImageStatus.MULTIPLE_FACES
@@ -342,60 +610,86 @@ private fun ImageResultCard(
containerColor = when (status) {
ImageStatus.VALID -> MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiaryContainer.copy(alpha = 0.4f)
ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
else -> MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
}
)
) {
Row(modifier = Modifier.fillMaxWidth().padding(12.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp)) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(12.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(12.dp)
) {
// Image Number Badge
Box(
modifier = Modifier.size(40.dp).background(
color = when (status) {
ImageStatus.VALID -> MaterialTheme.colorScheme.primary
ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.outline
else -> MaterialTheme.colorScheme.error
},
shape = CircleShape
),
modifier = Modifier
.size(40.dp)
.background(
color = when (status) {
ImageStatus.VALID -> MaterialTheme.colorScheme.primary
ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
else -> MaterialTheme.colorScheme.error
},
shape = CircleShape
),
contentAlignment = Alignment.Center
) {
Text(index.toString(), style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold, color = Color.White)
Text(
text = index.toString(),
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold,
color = Color.White
)
}
// Thumbnail
if (result.croppedFaceBitmap != null) {
Image(
bitmap = result.croppedFaceBitmap.asImageBitmap(),
contentDescription = "Face",
modifier = Modifier.size(64.dp).clip(RoundedCornerShape(8.dp)).border(
BorderStroke(2.dp, when (status) {
ImageStatus.VALID -> MaterialTheme.colorScheme.primary
ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.outline
else -> MaterialTheme.colorScheme.error
}),
RoundedCornerShape(8.dp)
),
modifier = Modifier
.size(64.dp)
.clip(RoundedCornerShape(8.dp))
.border(
BorderStroke(
2.dp,
when (status) {
ImageStatus.VALID -> MaterialTheme.colorScheme.primary
ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
else -> MaterialTheme.colorScheme.error
}
),
RoundedCornerShape(8.dp)
),
contentScale = ContentScale.Crop
)
} else {
AsyncImage(model = result.uri, contentDescription = "Original image", modifier = Modifier.size(64.dp).clip(RoundedCornerShape(8.dp)), contentScale = ContentScale.Crop)
AsyncImage(
model = result.uri,
contentDescription = "Original image",
modifier = Modifier
.size(64.dp)
.clip(RoundedCornerShape(8.dp)),
contentScale = ContentScale.Crop
)
}
Column(modifier = Modifier.weight(1f)) {
// Status and Info
Column(
modifier = Modifier.weight(1f)
) {
Row(verticalAlignment = Alignment.CenterVertically) {
Icon(
imageVector = when (status) {
ImageStatus.VALID -> Icons.Default.CheckCircle
ImageStatus.MULTIPLE_FACES -> Icons.Default.Info
ImageStatus.EXCLUDED -> Icons.Default.RemoveCircle
else -> Icons.Default.Warning
},
contentDescription = null,
tint = when (status) {
ImageStatus.VALID -> MaterialTheme.colorScheme.primary
ImageStatus.MULTIPLE_FACES -> MaterialTheme.colorScheme.tertiary
ImageStatus.EXCLUDED -> MaterialTheme.colorScheme.outline
else -> MaterialTheme.colorScheme.error
},
modifier = Modifier.size(20.dp)
@@ -406,55 +700,64 @@ private fun ImageResultCard(
ImageStatus.VALID -> "Face Detected"
ImageStatus.MULTIPLE_FACES -> "Multiple Faces (${result.faceCount})"
ImageStatus.NO_FACE -> "No Face Detected"
ImageStatus.EXCLUDED -> "Excluded"
ImageStatus.ERROR -> "Error"
},
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.SemiBold
)
}
Text(result.uri.lastPathSegment ?: "Unknown", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1)
Text(
text = result.uri.lastPathSegment ?: "Unknown",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
maxLines = 1
)
}
Column(horizontalAlignment = Alignment.End, verticalArrangement = Arrangement.spacedBy(4.dp)) {
if (onSelectFace != null && !isExcluded) {
// Action Buttons
Column(
horizontalAlignment = Alignment.End,
verticalArrangement = Arrangement.spacedBy(4.dp)
) {
// Select Face button (for multiple faces)
if (onSelectFace != null) {
OutlinedButton(
onClick = onSelectFace,
modifier = Modifier.height(32.dp),
contentPadding = PaddingValues(horizontal = 12.dp, vertical = 0.dp),
colors = ButtonDefaults.outlinedButtonColors(contentColor = MaterialTheme.colorScheme.tertiary),
colors = ButtonDefaults.outlinedButtonColors(
contentColor = MaterialTheme.colorScheme.tertiary
),
border = BorderStroke(1.dp, MaterialTheme.colorScheme.tertiary)
) {
Icon(Icons.Default.Face, contentDescription = null, modifier = Modifier.size(16.dp))
Icon(
Icons.Default.Face,
contentDescription = null,
modifier = Modifier.size(16.dp)
)
Spacer(modifier = Modifier.width(4.dp))
Text("Pick Face", style = MaterialTheme.typography.bodySmall)
}
}
if (!isExcluded) {
OutlinedButton(
onClick = { photoPickerLauncher.launch(PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly)) },
modifier = Modifier.height(32.dp),
contentPadding = PaddingValues(horizontal = 12.dp, vertical = 0.dp)
) {
Icon(Icons.Default.Refresh, contentDescription = null, modifier = Modifier.size(16.dp))
Spacer(modifier = Modifier.width(4.dp))
Text("Replace", style = MaterialTheme.typography.bodySmall)
}
}
// Replace button
OutlinedButton(
onClick = {
if (isExcluded) trainViewModel.includeImage(result.uri) else trainViewModel.excludeImage(result.uri)
photoPickerLauncher.launch(
PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly)
)
},
modifier = Modifier.height(32.dp),
contentPadding = PaddingValues(horizontal = 12.dp, vertical = 0.dp),
colors = ButtonDefaults.outlinedButtonColors(contentColor = if (isExcluded) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error),
border = BorderStroke(1.dp, if (isExcluded) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error)
contentPadding = PaddingValues(horizontal = 12.dp, vertical = 0.dp)
) {
Icon(if (isExcluded) Icons.Default.Add else Icons.Default.Close, contentDescription = null, modifier = Modifier.size(16.dp))
Icon(
Icons.Default.Refresh,
contentDescription = null,
modifier = Modifier.size(16.dp)
)
Spacer(modifier = Modifier.width(4.dp))
Text(if (isExcluded) "Include" else "Exclude", style = MaterialTheme.typography.bodySmall)
Text("Replace", style = MaterialTheme.typography.bodySmall)
}
}
}
@@ -462,16 +765,30 @@ private fun ImageResultCard(
}
@Composable
private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationError>, trainViewModel: TrainViewModel) {
private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationError>) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f))
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.errorContainer.copy(alpha = 0.3f)
)
) {
Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
Column(
modifier = Modifier.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Row(verticalAlignment = Alignment.CenterVertically) {
Icon(Icons.Default.Warning, contentDescription = null, tint = MaterialTheme.colorScheme.error)
Icon(
Icons.Default.Warning,
contentDescription = null,
tint = MaterialTheme.colorScheme.error
)
Spacer(modifier = Modifier.width(8.dp))
Text("Issues Found (${errors.size})", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold, color = MaterialTheme.colorScheme.error)
Text(
text = "Issues Found (${errors.size})",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.error
)
}
HorizontalDivider(color = MaterialTheme.colorScheme.error.copy(alpha = 0.3f))
@@ -479,41 +796,35 @@ private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationEr
errors.forEach { error ->
when (error) {
is TrainingSanityChecker.ValidationError.NoFaceDetected -> {
Text("• ${error.uris.size} image(s) without detected faces - use Replace button", style = MaterialTheme.typography.bodyMedium)
Text(
text = "• ${error.uris.size} image(s) without detected faces - use Replace button",
style = MaterialTheme.typography.bodyMedium
)
}
is TrainingSanityChecker.ValidationError.MultipleFacesDetected -> {
Text("• ${error.uri.lastPathSegment} has ${error.faceCount} faces - use Pick Face button", style = MaterialTheme.typography.bodyMedium)
Text(
text = "• ${error.uri.lastPathSegment} has ${error.faceCount} faces - use Pick Face button",
style = MaterialTheme.typography.bodyMedium
)
}
is TrainingSanityChecker.ValidationError.DuplicateImages -> {
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
Text("• ${error.groups.size} duplicate group(s) found", style = MaterialTheme.typography.bodyMedium, modifier = Modifier.weight(1f))
Button(
onClick = {
error.groups.forEach { group ->
group.images.drop(1).forEach { uri ->
trainViewModel.excludeImage(uri)
}
}
},
colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.tertiary),
modifier = Modifier.height(36.dp)
) {
Icon(Icons.Default.DeleteSweep, contentDescription = null, modifier = Modifier.size(16.dp))
Spacer(Modifier.width(4.dp))
Text("Drop All", style = MaterialTheme.typography.labelMedium)
}
}
Text("${error.groups.sumOf { it.images.size - 1 }} duplicate images will be excluded", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.6f))
}
Text(
text = "• ${error.groups.size} duplicate image group(s) - replace duplicates",
style = MaterialTheme.typography.bodyMedium
)
}
is TrainingSanityChecker.ValidationError.InsufficientImages -> {
Text("• Need ${error.required} valid images, currently have ${error.available}", style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.Bold)
Text(
text = "• Need ${error.required} valid images, currently have ${error.available}",
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Bold
)
}
is TrainingSanityChecker.ValidationError.ImageLoadError -> {
Text("• Failed to load ${error.uri.lastPathSegment} - use Replace button", style = MaterialTheme.typography.bodyMedium)
Text(
text = "• Failed to load ${error.uri.lastPathSegment} - use Replace button",
style = MaterialTheme.typography.bodyMedium
)
}
}
}
@@ -522,13 +833,35 @@ private fun ValidationIssuesCard(errors: List<TrainingSanityChecker.ValidationEr
}
@Composable
private fun ErrorView(message: String, onRetry: () -> Unit) {
Column(modifier = Modifier.fillMaxSize().padding(16.dp), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.Center) {
Icon(imageVector = Icons.Default.Close, contentDescription = null, modifier = Modifier.size(64.dp), tint = MaterialTheme.colorScheme.error)
private fun ErrorView(
message: String,
onRetry: () -> Unit
) {
Column(
modifier = Modifier
.fillMaxSize()
.padding(16.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Center
) {
Icon(
imageVector = Icons.Default.Close,
contentDescription = null,
modifier = Modifier.size(64.dp),
tint = MaterialTheme.colorScheme.error
)
Spacer(modifier = Modifier.height(16.dp))
Text("Error", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
Text(
text = "Error",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Spacer(modifier = Modifier.height(8.dp))
Text(message, style = MaterialTheme.typography.bodyMedium, textAlign = TextAlign.Center)
Text(
text = message,
style = MaterialTheme.typography.bodyMedium,
textAlign = TextAlign.Center
)
Spacer(modifier = Modifier.height(24.dp))
Button(onClick = onRetry) {
Icon(Icons.Default.Refresh, contentDescription = null)
@@ -542,6 +875,5 @@ private enum class ImageStatus {
VALID,
MULTIPLE_FACES,
NO_FACE,
ERROR,
EXCLUDED
ERROR
}

144
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/TrainViewModel.kt
View File

@@ -44,9 +44,6 @@ data class PersonInfo(
val relationship: String
)
/**
* FIXED TrainViewModel with proper exclude functionality and efficient replace
*/
@HiltViewModel
class TrainViewModel @Inject constructor(
application: Application,
@@ -69,9 +66,6 @@ class TrainViewModel @Inject constructor(
private var currentImageUris: List<Uri> = emptyList()
private val manualFaceSelections = mutableMapOf<Uri, ManualFaceSelection>()
// Track excluded images
private val excludedImages = mutableSetOf<Uri>()
data class ManualFaceSelection(
val faceIndex: Int,
val croppedFaceBitmap: Bitmap
@@ -84,44 +78,6 @@ class TrainViewModel @Inject constructor(
personInfo = PersonInfo(name, dateOfBirth, relationship)
}
/**
* Get stored person info
*/
fun getPersonInfo(): PersonInfo? = personInfo
/**
* Exclude an image from training
*/
fun excludeImage(uri: Uri) {
excludedImages.add(uri)
val currentState = _uiState.value
if (currentState is ScanningState.Success) {
val updatedResult = applyManualSelections(currentState.sanityCheckResult)
_uiState.value = ScanningState.Success(updatedResult)
}
}
/**
* Include a previously excluded image
*/
fun includeImage(uri: Uri) {
excludedImages.remove(uri)
val currentState = _uiState.value
if (currentState is ScanningState.Success) {
val updatedResult = applyManualSelections(currentState.sanityCheckResult)
_uiState.value = ScanningState.Success(updatedResult)
}
}
/**
* Check if an image is excluded
*/
fun isImageExcluded(uri: Uri): Boolean {
return uri in excludedImages
}
/**
* Create face model with captured person info
*/
@@ -133,7 +89,7 @@ class TrainViewModel @Inject constructor(
}
val validImages = currentState.sanityCheckResult.validImagesWithFaces
if (validImages.size < 15) {
if (validImages.size < 15) { // Updated minimum
_trainingState.value = TrainingState.Error(
"Need at least 15 valid images, have ${validImages.size}"
)
@@ -148,14 +104,16 @@ class TrainViewModel @Inject constructor(
total = validImages.size
)
// Create person with captured info
val person = PersonEntity.create(
name = personName,
dateOfBirth = personInfo?.dateOfBirth,
relationship = personInfo?.relationship
)
// Create person with face model
val personId = faceRecognitionRepository.createPersonWithFaceModel(
person = person,
person = person, // Pass full PersonEntity now
validImages = validImages,
onProgress = { current, total ->
_trainingState.value = TrainingState.Processing(
@@ -187,61 +145,25 @@ class TrainViewModel @Inject constructor(
fun scanAndTagFaces(imageUris: List<Uri>) {
currentImageUris = imageUris
manualFaceSelections.clear()
excludedImages.clear()
performScan(imageUris)
}
/**
* FIXED: Replace image - only rescan the ONE new image, not all images!
*/
fun replaceImage(oldUri: Uri, newUri: Uri) {
viewModelScope.launch {
try {
val currentState = _uiState.value
if (currentState !is ScanningState.Success) return@launch
// Update the URI list
val updatedUris = currentImageUris.toMutableList()
val index = updatedUris.indexOf(oldUri)
if (index == -1) return@launch
val updatedUris = currentImageUris.toMutableList()
val index = updatedUris.indexOf(oldUri)
if (index != -1) {
updatedUris[index] = newUri
currentImageUris = updatedUris
// Clean up old selections/exclusions
manualFaceSelections.remove(oldUri)
excludedImages.remove(oldUri)
// Only scan the NEW image
val newResult = faceDetectionHelper.detectFacesInImage(newUri)
// Update the results list
val updatedFaceResults = currentState.sanityCheckResult.faceDetectionResults.toMutableList()
updatedFaceResults[index] = newResult
// Create updated SanityCheckResult
val updatedSanityResult = currentState.sanityCheckResult.copy(
faceDetectionResults = updatedFaceResults
)
// Apply manual selections and exclusions
val finalResult = applyManualSelections(updatedSanityResult)
_uiState.value = ScanningState.Success(finalResult)
} catch (e: Exception) {
_uiState.value = ScanningState.Error(
e.message ?: "Failed to replace image"
)
performScan(currentImageUris)
}
}
}
/**
* Select face and auto-include the image
*/
fun selectFaceFromImage(imageUri: Uri, faceIndex: Int, croppedFaceBitmap: Bitmap) {
manualFaceSelections[imageUri] = ManualFaceSelection(faceIndex, croppedFaceBitmap)
excludedImages.remove(imageUri) // Auto-include
val currentState = _uiState.value
if (currentState is ScanningState.Success) {
@@ -250,9 +172,6 @@ class TrainViewModel @Inject constructor(
}
}
/**
* Perform full scan with exclusions and progress tracking
*/
private fun performScan(imageUris: List<Uri>) {
viewModelScope.launch {
try {
@@ -260,13 +179,9 @@ class TrainViewModel @Inject constructor(
val result = sanityChecker.performSanityChecks(
imageUris = imageUris,
minImagesRequired = 15,
minImagesRequired = 15, // Updated minimum
allowMultipleFaces = true,
duplicateSimilarityThreshold = 0.95,
excludedImages = excludedImages,
onProgress = { stage, current, total ->
_uiState.value = ScanningState.Processing(current, total)
}
duplicateSimilarityThreshold = 0.95
)
val finalResult = applyManualSelections(result)
@@ -280,14 +195,11 @@ class TrainViewModel @Inject constructor(
}
}
/**
* Apply manual selections with exclusion filtering
*/
private fun applyManualSelections(
result: TrainingSanityChecker.SanityCheckResult
): TrainingSanityChecker.SanityCheckResult {
if (manualFaceSelections.isEmpty() && excludedImages.isEmpty()) {
if (manualFaceSelections.isEmpty()) {
return result
}
@@ -304,36 +216,26 @@ class TrainViewModel @Inject constructor(
}
val updatedValidImages = updatedFaceResults
.filter { it.uri !in excludedImages } // Filter excluded
.filter { it.hasFace }
.filter { it.croppedFaceBitmap != null }
.filter { it.errorMessage == null }
.filter { it.faceCount >= 1 }
.map { faceResult ->
.map { result ->
TrainingSanityChecker.ValidTrainingImage(
uri = faceResult.uri,
croppedFaceBitmap = faceResult.croppedFaceBitmap!!,
faceCount = faceResult.faceCount
uri = result.uri,
croppedFaceBitmap = result.croppedFaceBitmap!!,
faceCount = result.faceCount
)
}
val updatedErrors = result.validationErrors.toMutableList()
// Remove errors for manually selected faces or excluded images
updatedErrors.removeAll { error ->
when (error) {
is TrainingSanityChecker.ValidationError.MultipleFacesDetected ->
manualFaceSelections.containsKey(error.uri) || excludedImages.contains(error.uri)
is TrainingSanityChecker.ValidationError.NoFaceDetected ->
error.uris.any { excludedImages.contains(it) }
is TrainingSanityChecker.ValidationError.ImageLoadError ->
excludedImages.contains(error.uri)
else -> false
}
error is TrainingSanityChecker.ValidationError.MultipleFacesDetected &&
manualFaceSelections.containsKey(error.uri)
}
// Update insufficient images error
if (updatedValidImages.size < 15) {
if (updatedValidImages.size < 15) { // Updated minimum
if (updatedErrors.none { it is TrainingSanityChecker.ValidationError.InsufficientImages }) {
updatedErrors.add(
TrainingSanityChecker.ValidationError.InsufficientImages(
@@ -352,8 +254,7 @@ class TrainViewModel @Inject constructor(
isValid = isValid,
faceDetectionResults = updatedFaceResults,
validationErrors = updatedErrors,
validImagesWithFaces = updatedValidImages,
excludedImages = excludedImages
validImagesWithFaces = updatedValidImages
)
}
@@ -366,7 +267,6 @@ class TrainViewModel @Inject constructor(
_trainingState.value = TrainingState.Idle
currentImageUris = emptyList()
manualFaceSelections.clear()
excludedImages.clear()
personInfo = null
}
@@ -403,8 +303,7 @@ private fun TrainingSanityChecker.SanityCheckResult.copy(
duplicateCheckResult: DuplicateImageDetector.DuplicateCheckResult = this.duplicateCheckResult,
validationErrors: List<TrainingSanityChecker.ValidationError> = this.validationErrors,
warnings: List<String> = this.warnings,
validImagesWithFaces: List<TrainingSanityChecker.ValidTrainingImage> = this.validImagesWithFaces,
excludedImages: Set<Uri> = this.excludedImages
validImagesWithFaces: List<TrainingSanityChecker.ValidTrainingImage> = this.validImagesWithFaces
): TrainingSanityChecker.SanityCheckResult {
return TrainingSanityChecker.SanityCheckResult(
isValid = isValid,
@@ -412,7 +311,6 @@ private fun TrainingSanityChecker.SanityCheckResult.copy(
duplicateCheckResult = duplicateCheckResult,
validationErrors = validationErrors,
warnings = warnings,
validImagesWithFaces = validImagesWithFaces,
excludedImages = excludedImages
validImagesWithFaces = validImagesWithFaces
)
}

495
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/TrainingScreen.kt
View File

@@ -1,5 +1,6 @@
package com.placeholder.sherpai2.ui.trainingprep
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
@@ -12,58 +13,97 @@ import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import java.text.SimpleDateFormat
import java.util.*
/**
* Beautiful TrainingScreen with person info capture
*
* Features:
* - Name input
* - Date of birth picker
* - Relationship selector
* - Onboarding cards
* - Beautiful gradient design
* - Clear call to action
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun TrainingScreen(
onSelectImages: () -> Unit,
modifier: Modifier = Modifier,
trainViewModel: TrainViewModel = hiltViewModel()
modifier: Modifier = Modifier
) {
var showInfoDialog by remember { mutableStateOf(false) }
Column(
modifier = modifier
.fillMaxSize()
.verticalScroll(rememberScrollState())
.padding(20.dp),
verticalArrangement = Arrangement.spacedBy(20.dp)
) {
// ✅ TIGHTENED Hero section
CompactHeroCard()
HowItWorksSection()
RequirementsCard()
Spacer(Modifier.weight(1f))
// Main CTA
Button(
onClick = { showInfoDialog = true },
modifier = Modifier.fillMaxWidth().height(60.dp),
colors = ButtonDefaults.buttonColors(containerColor = MaterialTheme.colorScheme.primary),
shape = RoundedCornerShape(16.dp)
) {
Icon(Icons.Default.PersonAdd, contentDescription = null, modifier = Modifier.size(24.dp))
Spacer(Modifier.width(12.dp))
Text("Start Training", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
Scaffold(
topBar = {
TopAppBar(
title = { Text("Train New Person") },
colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
)
)
}
) { paddingValues ->
Column(
modifier = modifier
.fillMaxSize()
.padding(paddingValues)
.verticalScroll(rememberScrollState())
.padding(20.dp),
verticalArrangement = Arrangement.spacedBy(20.dp)
) {
Spacer(Modifier.height(8.dp))
// Hero section with gradient
HeroCard()
// How it works section
HowItWorksSection()
// Requirements section
RequirementsCard()
Spacer(Modifier.weight(1f))
// Main CTA button
Button(
onClick = { showInfoDialog = true },
modifier = Modifier
.fillMaxWidth()
.height(60.dp),
colors = ButtonDefaults.buttonColors(
containerColor = MaterialTheme.colorScheme.primary
),
shape = RoundedCornerShape(16.dp)
) {
Icon(
Icons.Default.PersonAdd,
contentDescription = null,
modifier = Modifier.size(24.dp)
)
Spacer(Modifier.width(12.dp))
Text(
"Start Training",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
}
Spacer(Modifier.height(8.dp))
}
}
// ✅ PersonInfo dialog BEFORE photo selection (CORRECT!)
// Person info dialog
if (showInfoDialog) {
BeautifulPersonInfoDialog(
PersonInfoDialog(
onDismiss = { showInfoDialog = false },
onConfirm = { name, dob, relationship ->
showInfoDialog = false
trainViewModel.setPersonInfo(name, dob, relationship)
// TODO: Store this info before photo selection
// For now, just proceed to photo selection
onSelectImages()
}
)
@@ -71,54 +111,58 @@ fun TrainingScreen(
}
@Composable
private fun CompactHeroCard() {
private fun HeroCard() {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.primaryContainer),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
),
shape = RoundedCornerShape(20.dp)
) {
Row(
Box(
modifier = Modifier
.fillMaxWidth()
.background(
Brush.horizontalGradient(
Brush.verticalGradient(
colors = listOf(
MaterialTheme.colorScheme.primaryContainer,
MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.7f)
)
)
)
.padding(20.dp),
horizontalArrangement = Arrangement.spacedBy(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Compact icon
Surface(
shape = RoundedCornerShape(16.dp),
color = MaterialTheme.colorScheme.primary,
shadowElevation = 6.dp,
modifier = Modifier.size(56.dp)
Column(
modifier = Modifier.padding(24.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
Box(contentAlignment = Alignment.Center) {
Icon(
Icons.Default.Face,
contentDescription = null,
modifier = Modifier.size(32.dp),
tint = MaterialTheme.colorScheme.onPrimary
)
Surface(
shape = RoundedCornerShape(20.dp),
color = MaterialTheme.colorScheme.primary,
shadowElevation = 8.dp,
modifier = Modifier.size(80.dp)
) {
Box(contentAlignment = Alignment.Center) {
Icon(
Icons.Default.Face,
contentDescription = null,
modifier = Modifier.size(48.dp),
tint = MaterialTheme.colorScheme.onPrimary
)
}
}
}
// Text inline
Column(modifier = Modifier.weight(1f)) {
Text(
"Face Recognition",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
"Face Recognition Training",
style = MaterialTheme.typography.headlineMedium,
fontWeight = FontWeight.Bold,
textAlign = TextAlign.Center
)
Text(
"Train AI to find someone in your photos",
style = MaterialTheme.typography.bodyMedium,
"Train the AI to recognize someone in your photos",
style = MaterialTheme.typography.bodyLarge,
textAlign = TextAlign.Center,
color = MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
)
}
@@ -129,43 +173,100 @@ private fun CompactHeroCard() {
@Composable
private fun HowItWorksSection() {
Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
Text("How It Works", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold)
Text(
"How It Works",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
StepCard(1, Icons.Default.Info, "Enter Person Details", "Name, birthday, and relationship")
StepCard(2, Icons.Default.PhotoLibrary, "Select Training Photos", "Choose 20-30 photos of the person")
StepCard(3, Icons.Default.SmartToy, "AI Training", "We'll create a recognition model")
StepCard(4, Icons.Default.AutoFixHigh, "Auto-Tag Photos", "Find this person across your library")
StepCard(
number = 1,
icon = Icons.Default.Info,
title = "Enter Person Details",
description = "Name, birthday, and relationship"
)
StepCard(
number = 2,
icon = Icons.Default.PhotoLibrary,
title = "Select Training Photos",
description = "Choose 20-30 photos of the person"
)
StepCard(
number = 3,
icon = Icons.Default.ModelTraining,
title = "AI Learns Their Face",
description = "Takes ~30 seconds to train"
)
StepCard(
number = 4,
icon = Icons.Default.Search,
title = "Auto-Tag Your Library",
description = "Find them in all your photos"
)
}
}
@Composable
private fun StepCard(number: Int, icon: ImageVector, title: String, description: String) {
private fun StepCard(
number: Int,
icon: androidx.compose.ui.graphics.vector.ImageVector,
title: String,
description: String
) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)),
shape = RoundedCornerShape(16.dp)
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant
),
shape = RoundedCornerShape(12.dp)
) {
Row(
modifier = Modifier.padding(16.dp),
horizontalArrangement = Arrangement.spacedBy(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
// Number badge
Surface(
modifier = Modifier.size(48.dp),
shape = RoundedCornerShape(12.dp),
color = MaterialTheme.colorScheme.primary
color = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(48.dp)
) {
Box(contentAlignment = Alignment.Center) {
Text("$number", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Bold, color = MaterialTheme.colorScheme.onPrimary)
Text(
text = number.toString(),
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.onPrimary
)
}
}
Column(modifier = Modifier.weight(1f)) {
Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {
Icon(icon, contentDescription = null, modifier = Modifier.size(20.dp), tint = MaterialTheme.colorScheme.primary)
Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
icon,
contentDescription = null,
modifier = Modifier.size(20.dp),
tint = MaterialTheme.colorScheme.primary
)
Text(
title,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.SemiBold
)
}
Text(description, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
Spacer(Modifier.height(4.dp))
Text(
description,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
@@ -175,31 +276,241 @@ private fun StepCard(number: Int, icon: ImageVector, title: String, description:
private fun RequirementsCard() {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.3f)),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.secondaryContainer
),
shape = RoundedCornerShape(16.dp)
) {
Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {
Icon(Icons.Default.CheckCircle, contentDescription = null, tint = MaterialTheme.colorScheme.primary, modifier = Modifier.size(24.dp))
Text("Best Results", style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.Bold)
Column(
modifier = Modifier.padding(20.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.CheckCircle,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary
)
Text(
"What You'll Need",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
}
RequirementItem(Icons.Default.PhotoCamera, "20-30 photos minimum")
RequirementItem(Icons.Default.Face, "Clear, well-lit face photos")
RequirementItem(Icons.Default.Diversity1, "Variety of angles & expressions")
RequirementItem(Icons.Default.HighQuality, "Good quality images")
RequirementItem("20-30 photos of the person", true)
RequirementItem("Different angles and lighting", true)
RequirementItem("Clear face visibility", true)
RequirementItem("Mix of expressions", true)
RequirementItem("2-3 minutes of your time", true)
}
}
}
@Composable
private fun RequirementItem(icon: ImageVector, text: String) {
private fun RequirementItem(text: String, isMet: Boolean) {
Row(
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.padding(vertical = 4.dp)
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(icon, contentDescription = null, modifier = Modifier.size(20.dp), tint = MaterialTheme.colorScheme.onSecondaryContainer)
Text(text, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSecondaryContainer)
Icon(
if (isMet) Icons.Default.Check else Icons.Default.Close,
contentDescription = null,
modifier = Modifier.size(18.dp),
tint = if (isMet) {
MaterialTheme.colorScheme.primary
} else {
MaterialTheme.colorScheme.error
}
)
Text(
text = text,
style = MaterialTheme.typography.bodyMedium
)
}
}
@OptIn(ExperimentalMaterial3Api::class)
@Composable
private fun PersonInfoDialog(
onDismiss: () -> Unit,
onConfirm: (name: String, dateOfBirth: Long?, relationship: String) -> Unit
) {
var name by remember { mutableStateOf("") }
var dateOfBirth by remember { mutableStateOf<Long?>(null) }
var selectedRelationship by remember { mutableStateOf("Other") }
var showDatePicker by remember { mutableStateOf(false) }
val relationships = listOf(
"Family" to "👨‍👩‍👧‍👦",
"Friend" to "🤝",
"Partner" to "❤️",
"Child" to "👶",
"Parent" to "👪",
"Sibling" to "👫",
"Colleague" to "💼",
"Other" to "👤"
)
AlertDialog(
onDismissRequest = onDismiss,
title = {
Column {
Text("Person Details")
Text(
"Help us organize your photos",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
},
text = {
Column(
modifier = Modifier.fillMaxWidth(),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Name field
OutlinedTextField(
value = name,
onValueChange = { name = it },
label = { Text("Name *") },
placeholder = { Text("e.g., John Doe") },
leadingIcon = {
Icon(Icons.Default.Person, contentDescription = null)
},
modifier = Modifier.fillMaxWidth(),
singleLine = true
)
// Date of birth
OutlinedButton(
onClick = { showDatePicker = true },
modifier = Modifier.fillMaxWidth()
) {
Icon(Icons.Default.Cake, contentDescription = null)
Spacer(Modifier.width(8.dp))
Text(
if (dateOfBirth != null) {
"Birthday: ${formatDate(dateOfBirth!!)}"
} else {
"Add Birthday (Optional)"
}
)
}
// Relationship selector
Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
Text(
"Relationship",
style = MaterialTheme.typography.labelMedium
)
// Relationship chips
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
relationships.take(4).forEach { (rel, emoji) ->
FilterChip(
selected = selectedRelationship == rel,
onClick = { selectedRelationship = rel },
label = { Text("$emoji $rel") }
)
}
}
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
relationships.drop(4).forEach { (rel, emoji) ->
FilterChip(
selected = selectedRelationship == rel,
onClick = { selectedRelationship = rel },
label = { Text("$emoji $rel") }
)
}
}
}
// Privacy note
Card(
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant
)
) {
Row(
modifier = Modifier.padding(12.dp),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
Icon(
Icons.Default.Lock,
contentDescription = null,
modifier = Modifier.size(16.dp),
tint = MaterialTheme.colorScheme.primary
)
Text(
"All data stays on your device",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
},
confirmButton = {
Button(
onClick = {
if (name.isNotBlank()) {
onConfirm(name, dateOfBirth, selectedRelationship)
}
},
enabled = name.isNotBlank()
) {
Text("Continue")
}
},
dismissButton = {
TextButton(onClick = onDismiss) {
Text("Cancel")
}
}
)
// Date picker dialog
if (showDatePicker) {
DatePickerDialog(
onDismissRequest = { showDatePicker = false },
confirmButton = {
TextButton(
onClick = {
// Get selected date from date picker
// For now, set to current date as placeholder
dateOfBirth = System.currentTimeMillis()
showDatePicker = false
}
) {
Text("OK")
}
},
dismissButton = {
TextButton(onClick = { showDatePicker = false }) {
Text("Cancel")
}
}
) {
// Material3 DatePicker
DatePicker(
state = rememberDatePickerState(),
modifier = Modifier.padding(16.dp)
)
}
}
}
private fun formatDate(timestamp: Long): String {
val formatter = SimpleDateFormat("MMM dd, yyyy", Locale.getDefault())
return formatter.format(Date(timestamp))
}

353
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Trainingphotoselectorscreen.kt
View File

@@ -1,353 +0,0 @@
package com.placeholder.sherpai2.ui.trainingprep
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.ExperimentalFoundationApi
import androidx.compose.foundation.background
import androidx.compose.foundation.combinedClickable
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.grid.*
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import coil.compose.AsyncImage
import com.placeholder.sherpai2.data.local.entity.ImageEntity
/**
* TrainingPhotoSelectorScreen - Smart photo selector for face training
*
* SOLVES THE PROBLEM:
* - User has 10,000 photos total
* - Only ~500 have faces (hasFaces=true)
* - Shows ONLY photos with faces
* - Multi-select mode for quick selection
* - Face count badges on each photo
* - Minimum 15 photos enforced
*
* REUSES:
* - Existing ImageDao.getImagesWithFaces()
* - Existing face detection cache
* - Proven album grid layout
*/
@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
@Composable
fun TrainingPhotoSelectorScreen(
onBack: () -> Unit,
onPhotosSelected: (List<android.net.Uri>) -> Unit,
viewModel: TrainingPhotoSelectorViewModel = hiltViewModel()
) {
val photos by viewModel.photosWithFaces.collectAsStateWithLifecycle()
val selectedPhotos by viewModel.selectedPhotos.collectAsStateWithLifecycle()
val isLoading by viewModel.isLoading.collectAsStateWithLifecycle()
Scaffold(
topBar = {
TopAppBar(
title = {
Column {
Text(
if (selectedPhotos.isEmpty()) {
"Select Training Photos"
} else {
"${selectedPhotos.size} selected"
},
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
"Showing ${photos.size} photos with faces",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
},
navigationIcon = {
IconButton(onClick = onBack) {
Icon(Icons.Default.ArrowBack, "Back")
}
},
actions = {
if (selectedPhotos.isNotEmpty()) {
TextButton(onClick = { viewModel.clearSelection() }) {
Text("Clear")
}
}
},
colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primaryContainer
)
)
},
bottomBar = {
AnimatedVisibility(visible = selectedPhotos.isNotEmpty()) {
SelectionBottomBar(
selectedCount = selectedPhotos.size,
onClear = { viewModel.clearSelection() },
onContinue = {
val uris = selectedPhotos.map { android.net.Uri.parse(it.imageUri) }
onPhotosSelected(uris)
}
)
}
}
) { paddingValues ->
Box(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues)
) {
when {
isLoading -> {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
CircularProgressIndicator()
}
}
photos.isEmpty() -> {
EmptyState(onBack)
}
else -> {
PhotoGrid(
photos = photos,
selectedPhotos = selectedPhotos,
onPhotoClick = { photo -> viewModel.toggleSelection(photo) }
)
}
}
}
}
}
@Composable
private fun SelectionBottomBar(
selectedCount: Int,
onClear: () -> Unit,
onContinue: () -> Unit
) {
Surface(
modifier = Modifier.fillMaxWidth(),
color = MaterialTheme.colorScheme.primaryContainer,
shadowElevation = 8.dp
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Column {
Text(
"$selectedCount photos selected",
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
Text(
when {
selectedCount < 15 -> "Need ${15 - selectedCount} more"
selectedCount < 20 -> "Good start!"
selectedCount < 30 -> "Great selection!"
else -> "Excellent coverage!"
},
style = MaterialTheme.typography.bodySmall,
color = when {
selectedCount < 15 -> MaterialTheme.colorScheme.error
else -> MaterialTheme.colorScheme.onPrimaryContainer.copy(alpha = 0.8f)
}
)
}
Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
OutlinedButton(onClick = onClear) {
Text("Clear")
}
Button(
onClick = onContinue,
enabled = selectedCount >= 15
) {
Icon(
Icons.Default.Check,
contentDescription = null,
modifier = Modifier.size(20.dp)
)
Spacer(Modifier.width(8.dp))
Text("Continue")
}
}
}
}
}
@OptIn(ExperimentalFoundationApi::class)
@Composable
private fun PhotoGrid(
photos: List<ImageEntity>,
selectedPhotos: Set<ImageEntity>,
onPhotoClick: (ImageEntity) -> Unit
) {
LazyVerticalGrid(
columns = GridCells.Fixed(3),
contentPadding = PaddingValues(
start = 4.dp,
end = 4.dp,
bottom = 100.dp // Space for bottom bar
),
horizontalArrangement = Arrangement.spacedBy(4.dp),
verticalArrangement = Arrangement.spacedBy(4.dp)
) {
items(
items = photos,
key = { it.imageId }
) { photo ->
PhotoThumbnail(
photo = photo,
isSelected = photo in selectedPhotos,
onClick = { onPhotoClick(photo) }
)
}
}
}
@OptIn(ExperimentalFoundationApi::class)
@Composable
private fun PhotoThumbnail(
photo: ImageEntity,
isSelected: Boolean,
onClick: () -> Unit
) {
Card(
modifier = Modifier
.fillMaxWidth()
.aspectRatio(1f)
.combinedClickable(onClick = onClick),
shape = RoundedCornerShape(4.dp),
border = if (isSelected) {
BorderStroke(4.dp, MaterialTheme.colorScheme.primary)
} else null
) {
Box {
// Photo
AsyncImage(
model = photo.imageUri,
contentDescription = null,
modifier = Modifier.fillMaxSize(),
contentScale = ContentScale.Crop
)
// Face count badge (top-left)
if (photo.faceCount != null && photo.faceCount!! > 0) {
Surface(
modifier = Modifier
.align(Alignment.TopStart)
.padding(4.dp),
shape = CircleShape,
color = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.95f)
) {
Row(
modifier = Modifier.padding(horizontal = 6.dp, vertical = 2.dp),
horizontalArrangement = Arrangement.spacedBy(2.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.Face,
contentDescription = null,
modifier = Modifier.size(12.dp),
tint = MaterialTheme.colorScheme.onPrimaryContainer
)
Text(
"${photo.faceCount}",
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onPrimaryContainer,
fontWeight = FontWeight.Bold
)
}
}
}
// Selection checkmark (top-right)
if (isSelected) {
Surface(
modifier = Modifier
.align(Alignment.TopEnd)
.padding(4.dp)
.size(28.dp),
shape = CircleShape,
color = MaterialTheme.colorScheme.primary,
shadowElevation = 4.dp
) {
Box(contentAlignment = Alignment.Center) {
Icon(
Icons.Default.CheckCircle,
contentDescription = "Selected",
modifier = Modifier.size(20.dp),
tint = MaterialTheme.colorScheme.onPrimary
)
}
}
}
// Dim overlay when selected
if (isSelected) {
Box(
modifier = Modifier
.fillMaxSize()
.background(Color.Black.copy(alpha = 0.2f))
)
}
}
}
}
@Composable
private fun EmptyState(onBack: () -> Unit) {
Box(
modifier = Modifier.fillMaxSize(),
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp),
modifier = Modifier.padding(32.dp)
) {
Icon(
Icons.Default.SearchOff,
contentDescription = null,
modifier = Modifier.size(72.dp),
tint = MaterialTheme.colorScheme.outline
)
Text(
"No Photos with Faces Found",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
"Make sure the face detection cache has scanned your library",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
Button(onClick = onBack) {
Icon(Icons.Default.ArrowBack, null)
Spacer(Modifier.width(8.dp))
Text("Go Back")
}
}
}
}

116
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Trainingphotoselectorviewmodel.kt
View File

@@ -1,116 +0,0 @@
package com.placeholder.sherpai2.ui.trainingprep
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.placeholder.sherpai2.data.local.dao.ImageDao
import com.placeholder.sherpai2.data.local.entity.ImageEntity
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
/**
* TrainingPhotoSelectorViewModel - Smart photo selector for training
*
* KEY OPTIMIZATION:
* - Only loads images with hasFaces=true from database
* - Result: 10,000 photos → ~500 with faces
* - User can quickly select 20-30 good ones
* - Multi-select state management
*/
@HiltViewModel
class TrainingPhotoSelectorViewModel @Inject constructor(
private val imageDao: ImageDao
) : ViewModel() {
// Photos with faces (hasFaces=true)
private val _photosWithFaces = MutableStateFlow<List<ImageEntity>>(emptyList())
val photosWithFaces: StateFlow<List<ImageEntity>> = _photosWithFaces.asStateFlow()
// Selected photos (multi-select)
private val _selectedPhotos = MutableStateFlow<Set<ImageEntity>>(emptySet())
val selectedPhotos: StateFlow<Set<ImageEntity>> = _selectedPhotos.asStateFlow()
// Loading state
private val _isLoading = MutableStateFlow(true)
val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
init {
loadPhotosWithFaces()
}
/**
* Load ONLY photos with hasFaces=true
*
* Uses indexed query: SELECT * FROM images WHERE hasFaces = 1
* Fast! (~10ms for 10k photos)
*/
private fun loadPhotosWithFaces() {
viewModelScope.launch {
try {
_isLoading.value = true
// ✅ CRITICAL: Only get images with faces!
val photos = imageDao.getImagesWithFaces()
// Sort by most faces first (better for training)
val sorted = photos.sortedByDescending { it.faceCount ?: 0 }
_photosWithFaces.value = sorted
} catch (e: Exception) {
// If face cache not populated, empty list
_photosWithFaces.value = emptyList()
} finally {
_isLoading.value = false
}
}
}
/**
* Toggle photo selection
*/
fun toggleSelection(photo: ImageEntity) {
val current = _selectedPhotos.value.toMutableSet()
if (photo in current) {
current.remove(photo)
} else {
current.add(photo)
}
_selectedPhotos.value = current
}
/**
* Clear all selections
*/
fun clearSelection() {
_selectedPhotos.value = emptySet()
}
/**
* Auto-select first N photos (quick start)
*/
fun autoSelect(count: Int = 25) {
val photos = _photosWithFaces.value.take(count)
_selectedPhotos.value = photos.toSet()
}
/**
* Select photos with single face only (best for training)
*/
fun selectSingleFacePhotos(count: Int = 25) {
val singleFacePhotos = _photosWithFaces.value
.filter { it.faceCount == 1 }
.take(count)
_selectedPhotos.value = singleFacePhotos.toSet()
}
/**
* Refresh data (call after face detection cache updates)
*/
fun refresh() {
loadPhotosWithFaces()
}
}

59
app/src/main/java/com/placeholder/sherpai2/ui/trainingprep/Trainingsanitychecker.kt
View File

@@ -5,12 +5,7 @@ import android.graphics.Bitmap
import android.net.Uri
/**
* ENHANCED TrainingSanityChecker
*
* New features:
* - Progress callbacks
* - Exclude functionality
* - Faster processing
* Coordinates sanity checks for training images
*/
class TrainingSanityChecker(private val context: Context) {
@@ -23,8 +18,7 @@ class TrainingSanityChecker(private val context: Context) {
val duplicateCheckResult: DuplicateImageDetector.DuplicateCheckResult,
val validationErrors: List<ValidationError>,
val warnings: List<String>,
val validImagesWithFaces: List<ValidTrainingImage>,
val excludedImages: Set<Uri> = emptySet() // NEW: Track excluded images
val validImagesWithFaces: List<ValidTrainingImage>
)
data class ValidTrainingImage(
@@ -42,42 +36,30 @@ class TrainingSanityChecker(private val context: Context) {
}
/**
* Perform comprehensive sanity checks with PROGRESS tracking
* Perform comprehensive sanity checks on training images
*/
suspend fun performSanityChecks(
imageUris: List<Uri>,
minImagesRequired: Int = 15,
minImagesRequired: Int = 10,
allowMultipleFaces: Boolean = false,
duplicateSimilarityThreshold: Double = 0.95,
excludedImages: Set<Uri> = emptySet(), // NEW: Allow excluding images
onProgress: ((String, Int, Int) -> Unit)? = null // NEW: Progress callback
duplicateSimilarityThreshold: Double = 0.95
): SanityCheckResult {
val validationErrors = mutableListOf<ValidationError>()
val warnings = mutableListOf<String>()
// Filter out excluded images
val activeImages = imageUris.filter { it !in excludedImages }
// Check minimum image count (AFTER exclusions)
if (activeImages.size < minImagesRequired) {
// Check minimum image count
if (imageUris.size < minImagesRequired) {
validationErrors.add(
ValidationError.InsufficientImages(
required = minImagesRequired,
available = activeImages.size
available = imageUris.size
)
)
}
// Step 1: Detect faces in all images (WITH PROGRESS)
onProgress?.invoke("Detecting faces...", 0, activeImages.size)
val faceDetectionResults = faceDetectionHelper.detectFacesInImages(
uris = activeImages,
onProgress = { current, total ->
onProgress?.invoke("Detecting faces...", current, total)
}
)
// Step 1: Detect faces in all images
val faceDetectionResults = faceDetectionHelper.detectFacesInImages(imageUris)
// Check for images without faces
val imagesWithoutFaces = faceDetectionResults.filter { !it.hasFace }
@@ -116,10 +98,8 @@ class TrainingSanityChecker(private val context: Context) {
}
// Step 2: Check for duplicate images
onProgress?.invoke("Checking for duplicates...", activeImages.size, activeImages.size)
val duplicateCheckResult = duplicateDetector.checkForDuplicates(
uris = activeImages,
uris = imageUris,
similarityThreshold = duplicateSimilarityThreshold
)
@@ -158,16 +138,13 @@ class TrainingSanityChecker(private val context: Context) {
val isValid = validationErrors.isEmpty() && validImagesWithFaces.size >= minImagesRequired
onProgress?.invoke("Analysis complete", activeImages.size, activeImages.size)
return SanityCheckResult(
isValid = isValid,
faceDetectionResults = faceDetectionResults,
duplicateCheckResult = duplicateCheckResult,
validationErrors = validationErrors,
warnings = warnings,
validImagesWithFaces = validImagesWithFaces,
excludedImages = excludedImages
validImagesWithFaces = validImagesWithFaces
)
}
@@ -179,20 +156,24 @@ class TrainingSanityChecker(private val context: Context) {
when (error) {
is ValidationError.NoFaceDetected -> {
val count = error.uris.size
"No face detected in $count image(s)"
val images = error.uris.joinToString(", ") { it.lastPathSegment ?: "Unknown" }
"No face detected in $count image(s): $images"
}
is ValidationError.MultipleFacesDetected -> {
"Multiple faces (${error.faceCount}) detected in: ${error.uri.lastPathSegment}"
}
is ValidationError.DuplicateImages -> {
val count = error.groups.size
"Found $count duplicate group(s)"
val details = error.groups.joinToString("\n") { group ->
" - ${group.images.size} duplicates: ${group.images.joinToString(", ") { it.lastPathSegment ?: "Unknown" }}"
}
"Found $count duplicate group(s):\n$details"
}
is ValidationError.InsufficientImages -> {
"Need ${error.required} images, have ${error.available}"
"Insufficient images: need ${error.required}, but only ${error.available} valid images available"
}
is ValidationError.ImageLoadError -> {
"Failed to load image: ${error.uri.lastPathSegment}"
"Failed to load image ${error.uri.lastPathSegment}: ${error.error}"
}
}
}

430
app/src/main/java/com/placeholder/sherpai2/ui/utilities/Photoutilitiesscreen.kt
View File

@@ -1,430 +0,0 @@
package com.placeholder.sherpai2.ui.utilities
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.placeholder.sherpai2.ui.utilities.stats.StatsScreen
/**
* CLEANED PhotoUtilitiesScreen - No duplicate header
*
* Removed:
* - Scaffold wrapper (lines 36-74)
* - TopAppBar (was creating banner)
* - "Photo Utilities" title (MainScreen shows it)
*
* Features:
* - Stats tab (photo statistics and analytics)
* - Tools tab (scan, duplicates, bursts, quality)
* - Clean TabRow navigation
*/
@Composable
fun PhotoUtilitiesScreen(
viewModel: PhotoUtilitiesViewModel = hiltViewModel(),
modifier: Modifier = Modifier
) {
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
val scanProgress by viewModel.scanProgress.collectAsStateWithLifecycle()
var selectedTab by remember { mutableStateOf(0) }
Column(modifier = modifier.fillMaxSize()) {
// TabRow for Stats/Tools
TabRow(
selectedTabIndex = selectedTab,
containerColor = MaterialTheme.colorScheme.surface,
contentColor = MaterialTheme.colorScheme.primary
) {
Tab(
selected = selectedTab == 0,
onClick = { selectedTab = 0 },
text = { Text("Stats") },
icon = { Icon(Icons.Default.BarChart, "Statistics") }
)
Tab(
selected = selectedTab == 1,
onClick = { selectedTab = 1 },
text = { Text("Tools") },
icon = { Icon(Icons.Default.Build, "Tools") }
)
}
// Tab content
when (selectedTab) {
0 -> {
// Stats tab
StatsScreen()
}
1 -> {
// Tools tab
ToolsTabContent(
uiState = uiState,
scanProgress = scanProgress,
onScanPhotos = { viewModel.scanForPhotos() },
onDetectDuplicates = { viewModel.detectDuplicates() },
onDetectBursts = { viewModel.detectBursts() },
onAnalyzeQuality = { viewModel.analyzeQuality() }
)
}
}
}
}
@Composable
private fun ToolsTabContent(
uiState: UtilitiesUiState,
scanProgress: ScanProgress?,
onScanPhotos: () -> Unit,
onDetectDuplicates: () -> Unit,
onDetectBursts: () -> Unit,
onAnalyzeQuality: () -> Unit,
modifier: Modifier = Modifier
) {
LazyColumn(
modifier = modifier.fillMaxSize(),
contentPadding = PaddingValues(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Section: Scan & Import
item {
SectionHeader(
title = "Scan & Import",
icon = Icons.Default.Scanner
)
}
item {
UtilityCard(
title = "Scan for Photos",
description = "Search your device for new photos",
icon = Icons.Default.PhotoLibrary,
buttonText = "Scan Now",
enabled = uiState !is UtilitiesUiState.Scanning,
onClick = onScanPhotos
)
}
// Section: Organization
item {
Spacer(Modifier.height(8.dp))
SectionHeader(
title = "Organization",
icon = Icons.Default.Folder
)
}
item {
UtilityCard(
title = "Detect Duplicates",
description = "Find and tag duplicate photos",
icon = Icons.Default.FileCopy,
buttonText = "Find Duplicates",
enabled = uiState !is UtilitiesUiState.Scanning,
onClick = onDetectDuplicates
)
}
item {
UtilityCard(
title = "Detect Bursts",
description = "Group photos taken in rapid succession (3+ in 2 seconds)",
icon = Icons.Default.BurstMode,
buttonText = "Find Bursts",
enabled = uiState !is UtilitiesUiState.Scanning,
onClick = onDetectBursts
)
}
// Section: Quality
item {
Spacer(Modifier.height(8.dp))
SectionHeader(
title = "Quality Analysis",
icon = Icons.Default.HighQuality
)
}
item {
UtilityCard(
title = "Find Screenshots & Blurry",
description = "Identify screenshots and low-quality photos",
icon = Icons.Default.PhoneAndroid,
buttonText = "Analyze",
enabled = uiState !is UtilitiesUiState.Scanning,
onClick = onAnalyzeQuality
)
}
// Progress indicator
if (scanProgress != null) {
item {
ProgressCard(scanProgress)
}
}
// Results
when (val state = uiState) {
is UtilitiesUiState.ScanComplete -> {
item {
ResultCard(
title = "Scan Complete",
message = state.message,
icon = Icons.Default.CheckCircle,
iconTint = MaterialTheme.colorScheme.primary
)
}
}
is UtilitiesUiState.DuplicatesFound -> {
item {
ResultCard(
title = "Duplicates Found",
message = "Found ${state.groups.size} groups of duplicates (${state.groups.sumOf { it.images.size - 1 }} duplicate photos)",
icon = Icons.Default.Info,
iconTint = MaterialTheme.colorScheme.tertiary
)
}
}
is UtilitiesUiState.BurstsFound -> {
item {
ResultCard(
title = "Bursts Found",
message = "Found ${state.groups.size} burst sequences (${state.groups.sumOf { it.images.size }} photos total)",
icon = Icons.Default.Info,
iconTint = MaterialTheme.colorScheme.tertiary
)
}
}
is UtilitiesUiState.QualityAnalysisComplete -> {
item {
ResultCard(
title = "Analysis Complete",
message = "Screenshots: ${state.screenshots}\nBlurry: ${state.blurry}",
icon = Icons.Default.CheckCircle,
iconTint = MaterialTheme.colorScheme.primary
)
}
}
is UtilitiesUiState.Error -> {
item {
ResultCard(
title = "Error",
message = state.message,
icon = Icons.Default.Error,
iconTint = MaterialTheme.colorScheme.error
)
}
}
else -> {}
}
// Info card
item {
Spacer(Modifier.height(8.dp))
InfoCard()
}
}
}
@Composable
private fun SectionHeader(
title: String,
icon: ImageVector
) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(8.dp),
modifier = Modifier.padding(vertical = 4.dp)
) {
Icon(
icon,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(20.dp)
)
Text(
text = title,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.primary
)
}
}
@Composable
private fun UtilityCard(
title: String,
description: String,
icon: ImageVector,
buttonText: String,
enabled: Boolean,
onClick: () -> Unit
) {
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)
)
) {
Column(
modifier = Modifier.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Row(
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
Surface(
modifier = Modifier.size(48.dp),
shape = RoundedCornerShape(12.dp),
color = MaterialTheme.colorScheme.primaryContainer
) {
Box(contentAlignment = Alignment.Center) {
Icon(
icon,
contentDescription = null,
tint = MaterialTheme.colorScheme.onPrimaryContainer,
modifier = Modifier.size(24.dp)
)
}
}
Column(modifier = Modifier.weight(1f)) {
Text(
text = title,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.SemiBold
)
Text(
text = description,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
Button(
onClick = onClick,
modifier = Modifier.fillMaxWidth(),
enabled = enabled,
shape = RoundedCornerShape(12.dp)
) {
Text(buttonText)
}
}
}
}
@Composable
private fun ProgressCard(progress: ScanProgress) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.3f)
)
) {
Column(
modifier = Modifier.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Text(
text = progress.message,
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Medium
)
Text(
text = "${progress.current}/${progress.total}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
LinearProgressIndicator(
progress = { progress.current.toFloat() / progress.total.toFloat() },
modifier = Modifier.fillMaxWidth(),
)
}
}
}
@Composable
private fun ResultCard(
title: String,
message: String,
icon: ImageVector,
iconTint: androidx.compose.ui.graphics.Color
) {
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
) {
Row(
modifier = Modifier.padding(16.dp),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
icon,
contentDescription = null,
tint = iconTint,
modifier = Modifier.size(32.dp)
)
Column {
Text(
text = title,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
Text(
text = message,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
}
@Composable
private fun InfoCard() {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.secondaryContainer.copy(alpha = 0.3f)
)
) {
Row(
modifier = Modifier.padding(12.dp),
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.Info,
contentDescription = null,
tint = MaterialTheme.colorScheme.onSecondaryContainer,
modifier = Modifier.size(20.dp)
)
Text(
text = "These tools help you organize and maintain your photo collection",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSecondaryContainer
)
}
}
}

455
app/src/main/java/com/placeholder/sherpai2/ui/utilities/Photoutilitiesviewmodel.kt
View File

@@ -1,455 +0,0 @@
package com.placeholder.sherpai2.ui.utilities
import android.graphics.Bitmap
import android.net.Uri
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.face.FaceDetection
import com.google.mlkit.vision.face.FaceDetectorOptions
import com.placeholder.sherpai2.data.local.dao.ImageDao
import com.placeholder.sherpai2.data.local.dao.ImageTagDao
import com.placeholder.sherpai2.data.local.dao.TagDao
import com.placeholder.sherpai2.data.local.entity.ImageEntity
import com.placeholder.sherpai2.data.local.entity.ImageTagEntity
import com.placeholder.sherpai2.data.local.entity.TagEntity
import com.placeholder.sherpai2.domain.repository.ImageRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.tasks.await
import kotlinx.coroutines.withContext
import java.util.UUID
import javax.inject.Inject
import kotlin.math.abs
/**
* PhotoUtilitiesViewModel - Photo collection management
*
* Features:
* 1. Manual photo scan/rescan
* 2. Duplicate detection (SHA256 + perceptual hash)
* 3. Burst detection (photos within 2 seconds)
* 4. Quality analysis (blurry, screenshots)
*/
@HiltViewModel
class PhotoUtilitiesViewModel @Inject constructor(
private val imageRepository: ImageRepository,
private val imageDao: ImageDao,
private val tagDao: TagDao,
private val imageTagDao: ImageTagDao
) : ViewModel() {
private val _uiState = MutableStateFlow<UtilitiesUiState>(UtilitiesUiState.Idle)
val uiState: StateFlow<UtilitiesUiState> = _uiState.asStateFlow()
private val _scanProgress = MutableStateFlow<ScanProgress?>(null)
val scanProgress: StateFlow<ScanProgress?> = _scanProgress.asStateFlow()
/**
* Manual scan for new photos
*/
fun scanForPhotos() {
viewModelScope.launch(Dispatchers.IO) {
try {
_uiState.value = UtilitiesUiState.Scanning("photos")
_scanProgress.value = ScanProgress("Scanning device...", 0, 0)
val beforeCount = imageDao.getImageCount()
imageRepository.ingestImagesWithProgress { current, total ->
_scanProgress.value = ScanProgress(
"Found $current photos...",
current,
total
)
}
val afterCount = imageDao.getImageCount()
val newPhotos = afterCount - beforeCount
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.ScanComplete(
"Found $newPhotos new photos",
newPhotos
)
_scanProgress.value = null
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.Error(
e.message ?: "Failed to scan photos"
)
_scanProgress.value = null
}
}
}
}
/**
* Detect duplicate photos
*/
fun detectDuplicates() {
viewModelScope.launch(Dispatchers.IO) {
try {
_uiState.value = UtilitiesUiState.Scanning("duplicates")
_scanProgress.value = ScanProgress("Analyzing photos...", 0, 0)
val allImages = imageDao.getAllImages()
val duplicateGroups = mutableListOf<DuplicateGroup>()
// Group by SHA256
val sha256Groups = allImages.groupBy { it.sha256 }
var processed = 0
sha256Groups.forEach { (sha256, images) ->
if (images.size > 1) {
// Found duplicates!
duplicateGroups.add(
DuplicateGroup(
images = images,
reason = "Exact duplicate (same file content)",
confidence = 1.0f
)
)
}
processed++
if (processed % 100 == 0) {
_scanProgress.value = ScanProgress(
"Checked $processed photos...",
processed,
sha256Groups.size
)
}
}
// Tag duplicates
val duplicateTag = getOrCreateTag("duplicate", "SYSTEM")
duplicateGroups.forEach { group ->
// Tag all but the first image (keep one, mark rest as dupes)
group.images.drop(1).forEach { image ->
tagImage(image.imageId, duplicateTag.tagId)
}
}
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.DuplicatesFound(duplicateGroups)
_scanProgress.value = null
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.Error(
e.message ?: "Failed to detect duplicates"
)
_scanProgress.value = null
}
}
}
}
/**
* Detect burst photos (rapid succession)
* ALSO POPULATES FACE DETECTION CACHE for optimization
*/
fun detectBursts() {
viewModelScope.launch(Dispatchers.IO) {
try {
_uiState.value = UtilitiesUiState.Scanning("bursts")
_scanProgress.value = ScanProgress("Analyzing timestamps...", 0, 0)
val allImages = imageDao.getAllImagesSortedByTime()
val burstGroups = mutableListOf<BurstGroup>()
// Group photos taken within 2 seconds of each other
val burstThresholdMs = 2000L
var currentBurst = mutableListOf<ImageEntity>()
allImages.forEachIndexed { index, image ->
if (currentBurst.isEmpty()) {
currentBurst.add(image)
} else {
val lastImage = currentBurst.last()
val timeDiff = abs(image.capturedAt - lastImage.capturedAt)
if (timeDiff <= burstThresholdMs) {
// Part of current burst
currentBurst.add(image)
} else {
// End of burst
if (currentBurst.size >= 3) {
// Only consider bursts with 3+ photos
burstGroups.add(
BurstGroup(
images = currentBurst.toList(),
burstId = UUID.randomUUID().toString(),
representativeIndex = currentBurst.size / 2 // Middle photo
)
)
}
currentBurst = mutableListOf(image)
}
}
if (index % 100 == 0) {
_scanProgress.value = ScanProgress(
"Checked $index photos...",
index,
allImages.size
)
}
}
// Check last burst
if (currentBurst.size >= 3) {
burstGroups.add(
BurstGroup(
images = currentBurst,
burstId = UUID.randomUUID().toString(),
representativeIndex = currentBurst.size / 2
)
)
}
// Tag bursts
val burstTag = getOrCreateTag("burst", "SYSTEM")
burstGroups.forEach { group ->
group.images.forEach { image ->
tagImage(image.imageId, burstTag.tagId)
// Tag the representative photo specially
if (image == group.images[group.representativeIndex]) {
val burstRepTag = getOrCreateTag("burst_representative", "SYSTEM")
tagImage(image.imageId, burstRepTag.tagId)
}
}
}
// OPTIMIZATION: Populate face detection cache for burst photos
// Burst photos often contain people, so cache this for future scans
_scanProgress.value = ScanProgress("Caching face detection data...", 0, 0)
val faceDetector = FaceDetection.getClient(
FaceDetectorOptions.Builder()
.setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_FAST)
.setMinFaceSize(0.15f)
.build()
)
var cached = 0
burstGroups.forEach { group ->
group.images.forEach { imageEntity ->
// Only populate cache if not already cached
if (imageEntity.needsFaceDetection()) {
try {
val uri = Uri.parse(imageEntity.imageUri)
val faceCount = detectFaceCountQuick(uri, faceDetector)
imageDao.updateFaceDetectionCache(
imageId = imageEntity.imageId,
hasFaces = faceCount > 0,
faceCount = faceCount
)
cached++
} catch (e: Exception) {
// Skip on error
}
}
}
}
faceDetector.close()
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.BurstsFound(burstGroups)
_scanProgress.value = null
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.Error(
e.message ?: "Failed to detect bursts"
)
_scanProgress.value = null
}
}
}
}
/**
* Quick face count detection (lightweight, doesn't extract faces)
* Used for populating cache during utility scans
*/
private suspend fun detectFaceCountQuick(
uri: Uri,
detector: com.google.mlkit.vision.face.FaceDetector
): Int = withContext(Dispatchers.IO) {
var bitmap: Bitmap? = null
try {
// Load bitmap at lower resolution for quick detection
val options = android.graphics.BitmapFactory.Options().apply {
inSampleSize = 4 // Quarter resolution for speed
inPreferredConfig = android.graphics.Bitmap.Config.RGB_565
}
bitmap = imageRepository.loadBitmap(uri, options)
if (bitmap == null) return@withContext 0
val image = InputImage.fromBitmap(bitmap, 0)
val faces = detector.process(image).await()
faces.size
} catch (e: Exception) {
0
} finally {
bitmap?.recycle()
}
}
/**
* Detect screenshots and low quality photos
*/
fun analyzeQuality() {
viewModelScope.launch(Dispatchers.IO) {
try {
_uiState.value = UtilitiesUiState.Scanning("quality")
_scanProgress.value = ScanProgress("Analyzing quality...", 0, 0)
val allImages = imageDao.getAllImages()
val screenshotTag = getOrCreateTag("screenshot", "SYSTEM")
val blurryTag = getOrCreateTag("blurry", "SYSTEM")
var screenshotCount = 0
var blurryCount = 0
allImages.forEachIndexed { index, image ->
// Detect screenshots by dimensions (screen-sized)
val isScreenshot = isLikelyScreenshot(image.width, image.height)
if (isScreenshot) {
tagImage(image.imageId, screenshotTag.tagId)
screenshotCount++
}
// TODO: Detect blurry photos (requires bitmap analysis)
// For now, skip blur detection
if (index % 50 == 0) {
_scanProgress.value = ScanProgress(
"Analyzed $index photos...",
index,
allImages.size
)
}
}
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.QualityAnalysisComplete(
screenshots = screenshotCount,
blurry = blurryCount
)
_scanProgress.value = null
}
} catch (e: Exception) {
withContext(Dispatchers.Main) {
_uiState.value = UtilitiesUiState.Error(
e.message ?: "Failed to analyze quality"
)
_scanProgress.value = null
}
}
}
}
/**
* Detect screenshots by common screen dimensions
*/
private fun isLikelyScreenshot(width: Int, height: Int): Boolean {
val commonScreenRatios = listOf(
16.0 / 9.0, // 1080x1920, 1440x2560
19.5 / 9.0, // 1080x2340 (iPhone X)
20.0 / 9.0, // 1080x2400
18.5 / 9.0, // 1080x2220
19.0 / 9.0 // 1080x2280
)
val imageRatio = if (width > height) {
width.toDouble() / height.toDouble()
} else {
height.toDouble() / width.toDouble()
}
return commonScreenRatios.any { screenRatio ->
abs(imageRatio - screenRatio) < 0.1
}
}
private suspend fun getOrCreateTag(value: String, type: String): TagEntity {
return tagDao.getByValue(value) ?: run {
val tag = TagEntity(
tagId = UUID.randomUUID().toString(),
type = type,
value = value,
createdAt = System.currentTimeMillis()
)
tagDao.insert(tag)
tag
}
}
private suspend fun tagImage(imageId: String, tagId: String) {
val imageTag = ImageTagEntity(
imageId = imageId,
tagId = tagId,
source = "AUTO",
confidence = 1.0f,
visibility = "PUBLIC",
createdAt = System.currentTimeMillis()
)
imageTagDao.insert(imageTag)
}
fun resetState() {
_uiState.value = UtilitiesUiState.Idle
_scanProgress.value = null
}
}
/**
* UI State
*/
sealed class UtilitiesUiState {
object Idle : UtilitiesUiState()
data class Scanning(val type: String) : UtilitiesUiState()
data class ScanComplete(val message: String, val count: Int) : UtilitiesUiState()
data class DuplicatesFound(val groups: List<DuplicateGroup>) : UtilitiesUiState()
data class BurstsFound(val groups: List<BurstGroup>) : UtilitiesUiState()
data class QualityAnalysisComplete(
val screenshots: Int,
val blurry: Int
) : UtilitiesUiState()
data class Error(val message: String) : UtilitiesUiState()
}
data class ScanProgress(
val message: String,
val current: Int,
val total: Int
)
data class DuplicateGroup(
val images: List<ImageEntity>,
val reason: String,
val confidence: Float
)
data class BurstGroup(
val images: List<ImageEntity>,
val burstId: String,
val representativeIndex: Int // Which photo to show in albums
)

635
app/src/main/java/com/placeholder/sherpai2/ui/utilities/stats/Statsscreen.kt
View File

@@ -1,635 +0,0 @@
package com.placeholder.sherpai2.ui.utilities.stats
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.patrykandpatrick.vico.compose.cartesian.CartesianChartHost
import com.patrykandpatrick.vico.compose.cartesian.axis.rememberBottomAxis
import com.patrykandpatrick.vico.compose.cartesian.axis.rememberStartAxis
import com.patrykandpatrick.vico.compose.cartesian.layer.rememberColumnCartesianLayer
import com.patrykandpatrick.vico.compose.cartesian.layer.rememberLineCartesianLayer
import com.patrykandpatrick.vico.compose.cartesian.rememberCartesianChart
import com.patrykandpatrick.vico.compose.common.component.rememberLineComponent
import com.patrykandpatrick.vico.compose.common.component.rememberShapeComponent
import com.patrykandpatrick.vico.compose.common.component.rememberTextComponent
import com.patrykandpatrick.vico.compose.common.of
import com.patrykandpatrick.vico.core.cartesian.data.CartesianChartModelProducer
import com.patrykandpatrick.vico.core.cartesian.data.columnSeries
import com.patrykandpatrick.vico.core.cartesian.data.lineSeries
import com.patrykandpatrick.vico.core.common.shape.Shape
import java.text.SimpleDateFormat
import java.util.*
/**
* StatsScreen - Beautiful statistics dashboard
*
* Features:
* - Photo count timeline (with granularity toggle)
* - Year-by-year breakdown
* - System tag statistics
* - Burst detection stats
* - Usage patterns (day of week, time of day)
* - Face recognition stats
*/
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun StatsScreen(
viewModel: StatsViewModel = hiltViewModel()
) {
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
val granularity by viewModel.timelineGranularity.collectAsStateWithLifecycle()
Scaffold(
topBar = {
TopAppBar(
title = {
Column {
Text(
"Photo Statistics",
style = MaterialTheme.typography.titleLarge,
fontWeight = FontWeight.Bold
)
Text(
"Your collection insights",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
},
actions = {
IconButton(onClick = { viewModel.refresh() }) {
Icon(Icons.Default.Refresh, "Refresh")
}
},
colors = TopAppBarDefaults.topAppBarColors(
containerColor = MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.5f)
)
)
}
) { paddingValues ->
when (val state = uiState) {
is StatsUiState.Loading -> {
Box(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues),
contentAlignment = Alignment.Center
) {
CircularProgressIndicator()
}
}
is StatsUiState.Error -> {
Box(
modifier = Modifier
.fillMaxSize()
.padding(paddingValues),
contentAlignment = Alignment.Center
) {
Column(
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
Icon(
Icons.Default.Error,
contentDescription = null,
modifier = Modifier.size(64.dp),
tint = MaterialTheme.colorScheme.error
)
Text(
state.message,
style = MaterialTheme.typography.bodyLarge,
color = MaterialTheme.colorScheme.error
)
Button(onClick = { viewModel.refresh() }) {
Text("Retry")
}
}
}
}
is StatsUiState.Success -> {
StatsContent(
state = state,
granularity = granularity,
onGranularityChange = { viewModel.setTimelineGranularity(it) },
modifier = Modifier.padding(paddingValues)
)
}
}
}
}
@Composable
private fun StatsContent(
state: StatsUiState.Success,
granularity: TimelineGranularity,
onGranularityChange: (TimelineGranularity) -> Unit,
modifier: Modifier = Modifier
) {
LazyColumn(
modifier = modifier.fillMaxSize(),
contentPadding = PaddingValues(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Overview stats cards
item {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(12.dp)
) {
StatCard(
title = "Total Photos",
value = state.totalPhotos.toString(),
icon = Icons.Default.Photo,
color = MaterialTheme.colorScheme.primary,
modifier = Modifier.weight(1f)
)
StatCard(
title = "Per Day",
value = String.format("%.1f", state.averagePerDay),
icon = Icons.Default.CalendarToday,
color = MaterialTheme.colorScheme.tertiary,
modifier = Modifier.weight(1f)
)
}
}
item {
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(12.dp)
) {
StatCard(
title = "People",
value = state.personCount.toString(),
icon = Icons.Default.Face,
color = MaterialTheme.colorScheme.secondary,
modifier = Modifier.weight(1f)
)
state.burstStats?.let { burst ->
StatCard(
title = "Burst Groups",
value = burst.estimatedBurstGroups.toString(),
icon = Icons.Default.BurstMode,
color = MaterialTheme.colorScheme.error,
modifier = Modifier.weight(1f)
)
}
}
}
// Timeline chart
item {
SectionHeader("Photo Timeline")
}
item {
TimelineChart(
state = state,
granularity = granularity,
onGranularityChange = onGranularityChange
)
}
// Year breakdown
item {
Spacer(Modifier.height(8.dp))
SectionHeader("Photos by Year")
}
items(state.yearCounts) { yearCount ->
YearStatRow(
year = yearCount.year,
count = yearCount.count,
totalPhotos = state.totalPhotos
)
}
// System tags
if (state.systemTagStats.isNotEmpty()) {
item {
Spacer(Modifier.height(8.dp))
SectionHeader("System Tags")
}
items(state.systemTagStats) { tagStat ->
TagStatRow(tagStat)
}
}
// Usage patterns
if (state.dayOfWeekCounts.isNotEmpty()) {
item {
Spacer(Modifier.height(8.dp))
SectionHeader("When You Shoot")
}
item {
DayOfWeekChart(state.dayOfWeekCounts)
}
}
// Date range info
state.dateRange?.let { range ->
item {
Spacer(Modifier.height(8.dp))
DateRangeCard(range)
}
}
}
}
@Composable
private fun SectionHeader(title: String) {
Text(
text = title,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.primary,
modifier = Modifier.padding(vertical = 8.dp)
)
}
@Composable
private fun StatCard(
title: String,
value: String,
icon: ImageVector,
color: Color,
modifier: Modifier = Modifier
) {
Card(
modifier = modifier,
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
colors = CardDefaults.cardColors(
containerColor = color.copy(alpha = 0.1f)
)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
Icon(
icon,
contentDescription = null,
modifier = Modifier.size(32.dp),
tint = color
)
Text(
value,
style = MaterialTheme.typography.headlineMedium,
fontWeight = FontWeight.Bold,
color = color
)
Text(
title,
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
textAlign = TextAlign.Center
)
}
}
}
@Composable
private fun TimelineChart(
state: StatsUiState.Success,
granularity: TimelineGranularity,
onGranularityChange: (TimelineGranularity) -> Unit
) {
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(16.dp)
) {
// Granularity selector
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(8.dp)
) {
TimelineGranularity.entries.forEach { g ->
FilterChip(
selected = granularity == g,
onClick = { onGranularityChange(g) },
label = {
Text(
when (g) {
TimelineGranularity.DAILY -> "Daily"
TimelineGranularity.MONTHLY -> "Monthly"
TimelineGranularity.YEARLY -> "Yearly"
}
)
}
)
}
}
// Chart
val modelProducer = remember { CartesianChartModelProducer.build() }
LaunchedEffect(granularity, state) {
val data = when (granularity) {
TimelineGranularity.DAILY -> state.dailyCounts.map { it.count.toFloat() }
TimelineGranularity.MONTHLY -> state.monthlyCounts.map { it.count.toFloat() }
TimelineGranularity.YEARLY -> state.yearCounts.reversed().map { it.count.toFloat() }
}
if (data.isNotEmpty()) {
modelProducer.tryRunTransaction {
lineSeries { series(data) }
}
}
}
if (state.dailyCounts.isNotEmpty()) {
CartesianChartHost(
chart = rememberCartesianChart(
rememberLineCartesianLayer(),
startAxis = rememberStartAxis(),
bottomAxis = rememberBottomAxis()
),
modelProducer = modelProducer,
modifier = Modifier
.fillMaxWidth()
.height(200.dp)
)
} else {
Text(
"No data available",
modifier = Modifier
.fillMaxWidth()
.padding(32.dp),
textAlign = TextAlign.Center,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
}
}
@Composable
private fun YearStatRow(
year: String,
count: Int,
totalPhotos: Int
) {
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 1.dp)
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
Text(
year,
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold
)
val percentage = if (totalPhotos > 0) {
(count.toFloat() / totalPhotos * 100).toInt()
} else 0
Text(
"$percentage% of collection",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
}
Surface(
shape = RoundedCornerShape(8.dp),
color = MaterialTheme.colorScheme.primaryContainer
) {
Text(
count.toString(),
modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
style = MaterialTheme.typography.titleMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.primary
)
}
}
}
}
@Composable
private fun TagStatRow(tagStat: com.placeholder.sherpai2.data.local.dao.TagStat) {
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 1.dp)
) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
horizontalArrangement = Arrangement.SpaceBetween,
verticalAlignment = Alignment.CenterVertically
) {
Row(
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically,
modifier = Modifier.weight(1f)
) {
Icon(
getTagIcon(tagStat.tagValue),
contentDescription = null,
tint = MaterialTheme.colorScheme.primary,
modifier = Modifier.size(24.dp)
)
Text(
tagStat.tagValue.replace("_", " ").capitalize(),
style = MaterialTheme.typography.bodyLarge
)
}
Surface(
shape = RoundedCornerShape(8.dp),
color = MaterialTheme.colorScheme.secondaryContainer
) {
Text(
tagStat.imageCount.toString(),
modifier = Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Bold,
color = MaterialTheme.colorScheme.secondary
)
}
}
}
}
@Composable
private fun DayOfWeekChart(counts: List<com.placeholder.sherpai2.data.local.dao.DayOfWeekCount>) {
Card(
modifier = Modifier.fillMaxWidth(),
elevation = CardDefaults.cardElevation(defaultElevation = 2.dp)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(8.dp)
) {
val days = listOf("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat")
val maxCount = counts.maxOfOrNull { it.count } ?: 1
counts.forEach { dayCount ->
val dayName = days.getOrNull(dayCount.dayOfWeek) ?: "?"
val percentage = (dayCount.count.toFloat() / maxCount)
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(12.dp),
verticalAlignment = Alignment.CenterVertically
) {
Text(
dayName,
modifier = Modifier.width(50.dp),
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Medium
)
Box(
modifier = Modifier
.weight(1f)
.height(32.dp)
.background(
MaterialTheme.colorScheme.surfaceVariant,
RoundedCornerShape(4.dp)
)
) {
Box(
modifier = Modifier
.fillMaxHeight()
.fillMaxWidth(percentage)
.background(
MaterialTheme.colorScheme.primary,
RoundedCornerShape(4.dp)
)
)
Text(
dayCount.count.toString(),
modifier = Modifier
.align(Alignment.CenterEnd)
.padding(end = 8.dp),
style = MaterialTheme.typography.bodySmall,
fontWeight = FontWeight.Bold
)
}
}
}
}
}
}
@Composable
private fun DateRangeCard(range: com.placeholder.sherpai2.data.local.dao.PhotoDateRange) {
Card(
modifier = Modifier.fillMaxWidth(),
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceVariant
)
) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp)
) {
Row(
horizontalArrangement = Arrangement.spacedBy(8.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
Icons.Default.DateRange,
contentDescription = null,
tint = MaterialTheme.colorScheme.primary
)
Text(
"Collection Date Range",
style = MaterialTheme.typography.titleSmall,
fontWeight = FontWeight.Bold
)
}
val dateFormat = SimpleDateFormat("MMM dd, yyyy", Locale.getDefault())
val earliest = dateFormat.format(Date(range.earliest))
val latest = dateFormat.format(Date(range.latest))
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.SpaceBetween
) {
Column {
Text(
"Earliest",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
Text(
earliest,
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Medium
)
}
Column(horizontalAlignment = Alignment.End) {
Text(
"Latest",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant
)
Text(
latest,
style = MaterialTheme.typography.bodyMedium,
fontWeight = FontWeight.Medium
)
}
}
}
}
}
private fun getTagIcon(tagValue: String): ImageVector {
return when (tagValue) {
"burst" -> Icons.Default.BurstMode
"duplicate" -> Icons.Default.FileCopy
"screenshot" -> Icons.Default.Screenshot
"blurry" -> Icons.Default.BlurOn
"low_quality" -> Icons.Default.LowPriority
else -> Icons.Default.LocalOffer
}
}
private fun String.capitalize(): String {
return this.split("_").joinToString(" ") { word ->
word.replaceFirstChar { it.uppercase() }
}
}

127
app/src/main/java/com/placeholder/sherpai2/ui/utilities/stats/Statsviewmodel.kt
View File

@@ -1,127 +0,0 @@
package com.placeholder.sherpai2.ui.utilities.stats
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.placeholder.sherpai2.data.local.dao.*
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import javax.inject.Inject
/**
* StatsViewModel - Photo collection statistics
*
* Features:
* 1. Photo count timeline (daily/monthly/yearly)
* 2. Year-by-year breakdown
* 3. System tag statistics
* 4. Burst detection stats
* 5. Usage patterns (day of week, hour of day)
*/
@HiltViewModel
class StatsViewModel @Inject constructor(
private val imageDao: ImageDao,
private val tagDao: TagDao,
private val imageTagDao: ImageTagDao,
private val personDao: PersonDao,
private val photoFaceTagDao: PhotoFaceTagDao
) : ViewModel() {
private val _uiState = MutableStateFlow<StatsUiState>(StatsUiState.Loading)
val uiState: StateFlow<StatsUiState> = _uiState.asStateFlow()
private val _timelineGranularity = MutableStateFlow(TimelineGranularity.MONTHLY)
val timelineGranularity: StateFlow<TimelineGranularity> = _timelineGranularity.asStateFlow()
init {
loadStats()
}
fun loadStats() {
viewModelScope.launch(Dispatchers.IO) {
try {
_uiState.value = StatsUiState.Loading
// Load all stats in parallel
val totalCount = imageDao.getImageCount()
val yearCounts = imageDao.getPhotoCountsByYear()
val monthlyCounts = imageDao.getPhotoCountsByMonth()
val dailyCounts = imageDao.getPhotoCountsByDate()
val systemTagStats = tagDao.getSystemTagStats()
val burstStats = imageTagDao.getBurstStats()
val dateRange = imageDao.getPhotoDateRange()
val avgPerDay = imageDao.getAveragePhotosPerDay()
val dayOfWeekCounts = imageDao.getPhotoCountsByDayOfWeek()
val hourCounts = imageDao.getPhotoCountsByHour()
// Face recognition stats
val personCount = personDao.getPersonCount()
val taggedFaceCount = photoFaceTagDao.getUnverifiedTagCount()
_uiState.value = StatsUiState.Success(
totalPhotos = totalCount,
yearCounts = yearCounts,
monthlyCounts = monthlyCounts,
dailyCounts = dailyCounts,
systemTagStats = systemTagStats,
burstStats = burstStats,
dateRange = dateRange,
averagePerDay = avgPerDay ?: 0f,
dayOfWeekCounts = dayOfWeekCounts,
hourCounts = hourCounts,
personCount = personCount,
taggedFaceCount = taggedFaceCount
)
} catch (e: Exception) {
_uiState.value = StatsUiState.Error(
e.message ?: "Failed to load statistics"
)
}
}
}
fun setTimelineGranularity(granularity: TimelineGranularity) {
_timelineGranularity.value = granularity
}
fun refresh() {
loadStats()
}
}
/**
* UI State for stats screen
*/
sealed class StatsUiState {
object Loading : StatsUiState()
data class Success(
val totalPhotos: Int,
val yearCounts: List<YearCount>,
val monthlyCounts: List<MonthCount>,
val dailyCounts: List<DateCount>,
val systemTagStats: List<TagStat>,
val burstStats: BurstStats?,
val dateRange: PhotoDateRange?,
val averagePerDay: Float,
val dayOfWeekCounts: List<DayOfWeekCount>,
val hourCounts: List<HourCount>,
val personCount: Int,
val taggedFaceCount: Int
) : StatsUiState()
data class Error(val message: String) : StatsUiState()
}
/**
* Timeline granularity options
*/
enum class TimelineGranularity {
DAILY,
MONTHLY,
YEARLY
}

148
app/src/main/java/com/placeholder/sherpai2/workers/Cachepopulationworker.kt
View File

@@ -1,148 +0,0 @@
package com.placeholder.sherpai2.workers
import android.content.Context
import android.net.Uri
import androidx.hilt.work.HiltWorker
import androidx.work.*
import com.placeholder.sherpai2.data.local.dao.ImageDao
import com.placeholder.sherpai2.data.local.entity.ImageEntity
import com.placeholder.sherpai2.ui.trainingprep.FaceDetectionHelper
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import kotlinx.coroutines.*
/**
* CachePopulationWorker - Background face detection cache builder
*
* 🎯 Purpose: One-time scan to mark which photos contain faces
* ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
* Strategy:
* 1. Use ML Kit FAST detector (speed over accuracy)
* 2. Scan ALL photos in library that need caching
* 3. Store: hasFaces (boolean) + faceCount (int) + version
* 4. Result: Future person scans only check ~30% of photos
*
* Performance:
* • FAST detector: ~100-200ms per image
* • 10,000 photos: ~5-10 minutes total
* • Cache persists forever (until version upgrade)
* • Saves 70% of work on every future scan
*
* Scheduling:
* • Preferred: When device is idle + charging
* • Alternative: User can force immediate run
* • Batched processing: 50 images per batch
* • Supports pause/resume via WorkManager
*/
@HiltWorker
class CachePopulationWorker @AssistedInject constructor(
@Assisted private val context: Context,
@Assisted workerParams: WorkerParameters,
private val imageDao: ImageDao
) : CoroutineWorker(context, workerParams) {
companion object {
const val WORK_NAME = "face_cache_population"
const val KEY_PROGRESS_CURRENT = "progress_current"
const val KEY_PROGRESS_TOTAL = "progress_total"
const val KEY_CACHED_COUNT = "cached_count"
private const val BATCH_SIZE = 50 // Smaller batches for stability
private const val MAX_RETRIES = 3
}
private val faceDetectionHelper = FaceDetectionHelper(context)
override suspend fun doWork(): Result = withContext(Dispatchers.Default) {
try {
// Check if we should stop (work cancelled)
if (isStopped) {
return@withContext Result.failure()
}
// Get all images that need face detection caching
val needsCaching = imageDao.getImagesNeedingFaceDetection()
if (needsCaching.isEmpty()) {
// Already fully cached!
val totalImages = imageDao.getImageCount()
return@withContext Result.success(
workDataOf(KEY_CACHED_COUNT to totalImages)
)
}
var processedCount = 0
var successCount = 0
val totalCount = needsCaching.size
try {
// Process in batches
needsCaching.chunked(BATCH_SIZE).forEach { batch ->
// Check for cancellation
if (isStopped) {
return@forEach
}
// Process batch in parallel using FaceDetectionHelper
val uris = batch.map { Uri.parse(it.imageUri) }
val results = faceDetectionHelper.detectFacesInImages(uris) { current, total ->
// Inner progress for this batch
}
// Update database with results
results.zip(batch).forEach { (result, image) ->
try {
imageDao.updateFaceDetectionCache(
imageId = image.imageId,
hasFaces = result.hasFace,
faceCount = result.faceCount,
timestamp = System.currentTimeMillis(),
version = ImageEntity.CURRENT_FACE_DETECTION_VERSION
)
successCount++
} catch (e: Exception) {
// Skip failed updates, continue with next
}
}
processedCount += batch.size
// Update progress
setProgress(
workDataOf(
KEY_PROGRESS_CURRENT to processedCount,
KEY_PROGRESS_TOTAL to totalCount
)
)
// Give system a breather between batches
delay(200)
}
// Success!
Result.success(
workDataOf(
KEY_CACHED_COUNT to successCount,
KEY_PROGRESS_CURRENT to processedCount,
KEY_PROGRESS_TOTAL to totalCount
)
)
} finally {
// Clean up detector
faceDetectionHelper.cleanup()
}
} catch (e: Exception) {
// Clean up on error
faceDetectionHelper.cleanup()
// Handle failure
if (runAttemptCount < MAX_RETRIES) {
Result.retry()
} else {
Result.failure(
workDataOf("error" to (e.message ?: "Unknown error"))
)
}
}
}
}

29
gradle/libs.versions.toml
View File

@@ -28,18 +28,6 @@ tensorflow-lite = "2.14.0"
tensorflow-lite-support = "0.4.4"
gson = "2.10.1"
#Album/Image View Tools
zoomable = "1.6.1"
#Charting Lib
vico = "2.0.0-alpha.28"
#workers
work = "2.9.0"
hilt-work = "1.1.0"
mlkit-face = "16.1.6"
[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
@@ -80,23 +68,6 @@ tensorflow-lite-gpu = { group = "org.tensorflow", name = "tensorflow-lite-gpu",
gson = { group = "com.google.code.gson", name = "gson", version.ref = "gson" }
#Album/Image View Tools
zoomable = { group = "net.engawapg.lib", name = "zoomable", version.ref = "zoomable" }
vico-compose = { module = "com.patrykandpatrick.vico:compose", version.ref = "vico" }
vico-compose-m3 = { module = "com.patrykandpatrick.vico:compose-m3", version.ref = "vico" }
vico-core = { module = "com.patrykandpatrick.vico:core", version.ref = "vico" }
#workers
androidx-work-runtime-ktx = { module = "androidx.work:work-runtime-ktx", version.ref = "work" }
androidx-hilt-work = { module = "androidx.hilt:hilt-work", version.ref = "hilt-work" }
androidx-hilt-compiler = { module = "androidx.hilt:hilt-compiler", version.ref = "hilt-work" }
[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }