@shaykec/app-agent 1.0.0

package/templates/shared/android/ChartsLibrary/ChartsLibraryScreen.kt

@@ -0,0 +1,540 @@
+package com.appship.shared.chartslibrary
+
+import androidx.compose.animation.core.*
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.*
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.unit.dp
+import kotlin.math.*
+
+/**
+ * Displays a line chart with data points connected by lines.
+ */
+@Composable
+fun LineChartView(
+    dataPoints: List<ChartDataPoint>,
+    config: ChartConfig = ChartConfig.Default,
+    modifier: Modifier = Modifier
+) {
+    val calculationManager = ChartCalculationManager
+    val normalizedData = calculationManager.normalizeData(
+        dataPoints,
+        minValue = config.minValue,
+        maxValue = config.maxValue
+    )
+
+    val animationProgress by animateFloatAsState(
+        targetValue = if (config.animated) 1f else 1f,
+        animationSpec = tween(durationMillis = 1000, easing = FastOutSlowInEasing)
+    )
+
+    Box(
+        modifier = modifier
+            .height(200.dp)
+            .testTag("chart_line")
+    ) {
+        Canvas(modifier = Modifier.fillMaxSize()) {
+            val width = size.width
+            val height = size.height
+
+            // Draw grid
+            if (config.showGrid) {
+                drawGrid(
+                    width, height,
+                    horizontalLines = 5,
+                    verticalLines = dataPoints.size,
+                    gridColor = MaterialTheme.colorScheme.outlineVariant
+                )
+            }
+
+            // Draw line
+            if (normalizedData.isNotEmpty()) {
+                drawLine(
+                    normalizedData = normalizedData,
+                    width = width,
+                    height = height,
+                    progress = animationProgress,
+                    color = dataPoints.firstOrNull()?.color ?: MaterialTheme.colorScheme.primary
+                )
+            }
+
+            // Draw points
+            if (config.showLabels && normalizedData.isNotEmpty()) {
+                drawPoints(
+                    normalizedData = normalizedData,
+                    width = width,
+                    height = height,
+                    progress = animationProgress,
+                    color = dataPoints.firstOrNull()?.color ?: MaterialTheme.colorScheme.primary
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Displays a bar chart with vertical bars.
+ */
+@Composable
+fun BarChartView(
+    dataPoints: List<ChartDataPoint>,
+    config: ChartConfig = ChartConfig.Default,
+    modifier: Modifier = Modifier
+) {
+    val calculationManager = ChartCalculationManager
+    val colors = calculationManager.interpolateColors(
+        count = dataPoints.size,
+        baseColors = config.colors
+    )
+
+    val animationProgress by animateFloatAsState(
+        targetValue = if (config.animated) 1f else 1f,
+        animationSpec = tween(durationMillis = 1000, easing = FastOutSlowInEasing)
+    )
+
+    Row(
+        modifier = modifier
+            .height(200.dp)
+            .testTag("chart_bar"),
+        horizontalArrangement = Arrangement.spacing(4.dp)
+    ) {
+        dataPoints.forEachIndexed { index, point ->
+            val normalized = calculationManager.normalizeData(
+                listOf(point),
+                minValue = config.minValue,
+                maxValue = config.maxValue
+            ).firstOrNull() ?: 0.0
+
+            Box(
+                modifier = Modifier
+                    .weight(1f)
+                    .fillMaxHeight()
+            ) {
+                Canvas(
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .testTag("chart_bar_$index")
+                ) {
+                    val barWidth = size.width
+                    val barHeight = size.height * normalized.toFloat() * animationProgress
+
+                    drawRoundRect(
+                        color = point.color ?: colors[index],
+                        topLeft = Offset(0f, size.height - barHeight),
+                        size = Size(barWidth, barHeight),
+                        cornerRadius = androidx.compose.ui.geometry.CornerRadius(4f, 4f)
+                    )
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Displays a pie chart with segments.
+ */
+@Composable
+fun PieChartView(
+    dataPoints: List<ChartDataPoint>,
+    config: ChartConfig = ChartConfig.Default,
+    modifier: Modifier = Modifier
+) {
+    val calculationManager = ChartCalculationManager
+    val percentages = calculationManager.calculatePercentages(dataPoints)
+    val angles = calculationManager.calculateAngles(percentages)
+    val colors = calculationManager.interpolateColors(
+        count = dataPoints.size,
+        baseColors = config.colors
+    )
+
+    val animationProgress by animateFloatAsState(
+        targetValue = if (config.animated) 1f else 1f,
+        animationSpec = tween(durationMillis = 1000, easing = FastOutSlowInEasing)
+    )
+
+    Box(
+        modifier = modifier
+            .size(200.dp)
+            .testTag("chart_pie")
+    ) {
+        Canvas(modifier = Modifier.fillMaxSize()) {
+            val center = Offset(size.width / 2, size.height / 2)
+            val radius = min(size.width, size.height) / 2
+
+            angles.forEachIndexed { index, (startAngle, endAngle) ->
+                val animatedEndAngle = startAngle + (endAngle - startAngle) * animationProgress.toDouble()
+                drawPieSegment(
+                    center = center,
+                    radius = radius,
+                    startAngle = startAngle,
+                    endAngle = animatedEndAngle,
+                    color = dataPoints[index].color ?: colors[index]
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Displays a donut chart (pie chart with center cutout).
+ */
+@Composable
+fun DonutChartView(
+    dataPoints: List<ChartDataPoint>,
+    config: ChartConfig = ChartConfig.Default,
+    innerRadiusRatio: Float = 0.6f,
+    modifier: Modifier = Modifier
+) {
+    val calculationManager = ChartCalculationManager
+    val percentages = calculationManager.calculatePercentages(dataPoints)
+    val angles = calculationManager.calculateAngles(percentages)
+    val colors = calculationManager.interpolateColors(
+        count = dataPoints.size,
+        baseColors = config.colors
+    )
+
+    val animationProgress by animateFloatAsState(
+        targetValue = if (config.animated) 1f else 1f,
+        animationSpec = tween(durationMillis = 1000, easing = FastOutSlowInEasing)
+    )
+
+    Box(
+        modifier = modifier
+            .size(200.dp)
+            .testTag("chart_donut")
+    ) {
+        Canvas(modifier = Modifier.fillMaxSize()) {
+            val center = Offset(size.width / 2, size.height / 2)
+            val outerRadius = min(size.width, size.height) / 2
+            val innerRadius = outerRadius * innerRadiusRatio
+
+            angles.forEachIndexed { index, (startAngle, endAngle) ->
+                val animatedEndAngle = startAngle + (endAngle - startAngle) * animationProgress.toDouble()
+                drawDonutSegment(
+                    center = center,
+                    outerRadius = outerRadius,
+                    innerRadius = innerRadius,
+                    startAngle = startAngle,
+                    endAngle = animatedEndAngle,
+                    color = dataPoints[index].color ?: colors[index]
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Displays a circular progress ring.
+ */
+@Composable
+fun ProgressRingView(
+    progress: Double, // 0.0 to 1.0
+    color: Color = MaterialTheme.colorScheme.primary,
+    lineWidth: Float = 12f,
+    modifier: Modifier = Modifier
+) {
+    val animationProgress by animateFloatAsState(
+        targetValue = 1f,
+        animationSpec = tween(durationMillis = 1000, easing = FastOutSlowInEasing)
+    )
+
+    Box(
+        modifier = modifier.testTag("chart_progress_ring")
+    ) {
+        Canvas(modifier = Modifier.fillMaxSize()) {
+            val size = min(size.width, size.height)
+            val radius = (size - lineWidth) / 2
+            val center = Offset(size / 2, size / 2)
+
+            // Background ring
+            val backgroundColor = MaterialTheme.colorScheme.surfaceVariant
+            drawCircle(
+                color = backgroundColor,
+                radius = radius,
+                center = center,
+                style = Stroke(width = lineWidth)
+            )
+
+            // Progress ring
+            drawArc(
+                color = color,
+                startAngle = -90f,
+                sweepAngle = (progress * 360 * animationProgress).toFloat(),
+                useCenter = false,
+                topLeft = Offset(center.x - radius, center.y - radius),
+                size = Size(radius * 2, radius * 2),
+                style = Stroke(width = lineWidth, cap = StrokeCap.Round)
+            )
+        }
+    }
+}
+
+/**
+ * Displays a minimal line chart without axes (sparkline).
+ */
+@Composable
+fun SparklineView(
+    dataPoints: List<ChartDataPoint>,
+    color: Color = MaterialTheme.colorScheme.primary,
+    modifier: Modifier = Modifier
+) {
+    val calculationManager = ChartCalculationManager
+    val normalizedData = calculationManager.normalizeData(dataPoints)
+
+    val animationProgress by animateFloatAsState(
+        targetValue = 1f,
+        animationSpec = tween(durationMillis = 500, easing = FastOutSlowInEasing)
+    )
+
+    Box(
+        modifier = modifier
+            .height(40.dp)
+            .testTag("chart_sparkline")
+    ) {
+        Canvas(modifier = Modifier.fillMaxSize()) {
+            if (normalizedData.isNotEmpty()) {
+                drawLine(
+                    normalizedData = normalizedData,
+                    width = size.width,
+                    height = size.height,
+                    progress = animationProgress,
+                    color = color
+                )
+            }
+        }
+    }
+}
+
+/**
+ * Displays a gauge/speedometer-style chart.
+ */
+@Composable
+fun GaugeView(
+    value: Double,
+    minValue: Double = 0.0,
+    maxValue: Double = 100.0,
+    color: Color = MaterialTheme.colorScheme.primary,
+    modifier: Modifier = Modifier
+) {
+    val normalizedValue = ((value.coerceIn(minValue, maxValue) - minValue) / (maxValue - minValue))
+
+    val animationProgress by animateFloatAsState(
+        targetValue = 1f,
+        animationSpec = tween(durationMillis = 1000, easing = FastOutSlowInEasing)
+    )
+
+    Box(
+        modifier = modifier.testTag("chart_gauge")
+    ) {
+        Canvas(modifier = Modifier.fillMaxSize()) {
+            val size = min(size.width, size.height)
+            val radius = size / 2
+            val center = Offset(size / 2, size / 2)
+
+            // Background arc
+            val backgroundColor = MaterialTheme.colorScheme.surfaceVariant
+            drawGaugeArc(
+                center = center,
+                radius = radius,
+                startAngle = 180f,
+                endAngle = 0f,
+                lineWidth = 20f,
+                color = backgroundColor
+            )
+
+            // Value arc
+            val sweepAngle = 180 * normalizedValue * animationProgress
+            drawGaugeArc(
+                center = center,
+                radius = radius,
+                startAngle = 180f,
+                endAngle = 180f - sweepAngle.toFloat(),
+                lineWidth = 20f,
+                color = color
+            )
+        }
+    }
+}
+
+// MARK: - Drawing Helpers
+
+private fun DrawScope.drawGrid(
+    width: Float,
+    height: Float,
+    horizontalLines: Int,
+    verticalLines: Int,
+    gridColor: Color
+) {
+    // Horizontal lines
+    for (i in 0..horizontalLines) {
+        val y = (height / horizontalLines) * i
+        drawLine(
+            color = gridColor,
+            start = Offset(0f, y),
+            end = Offset(width, y),
+            strokeWidth = 0.5f
+        )
+    }
+
+    // Vertical lines
+    for (i in 0..verticalLines) {
+        val x = (width / verticalLines) * i
+        drawLine(
+            color = gridColor,
+            start = Offset(x, 0f),
+            end = Offset(x, height),
+            strokeWidth = 0.5f
+        )
+    }
+}
+
+private fun DrawScope.drawLine(
+    normalizedData: List<Double>,
+    width: Float,
+    height: Float,
+    progress: Float,
+    color: Color
+) {
+    if (normalizedData.isEmpty()) return
+
+    val stepX = width / (normalizedData.size - 1).coerceAtLeast(1)
+    val path = Path()
+
+    normalizedData.forEachIndexed { index, value ->
+        val x = index * stepX
+        val y = height - (value.toFloat() * height * progress)
+
+        if (index == 0) {
+            path.moveTo(x, y)
+        } else {
+            path.lineTo(x, y)
+        }
+    }
+
+    drawPath(
+        path = path,
+        color = color,
+        style = Stroke(width = 2f, cap = StrokeCap.Round, join = StrokeJoin.Round)
+    )
+}
+
+private fun DrawScope.drawPoints(
+    normalizedData: List<Double>,
+    width: Float,
+    height: Float,
+    progress: Float,
+    color: Color
+) {
+    val stepX = width / (normalizedData.size - 1).coerceAtLeast(1)
+
+    normalizedData.forEachIndexed { index, value ->
+        val x = index * stepX
+        val y = height - (value.toFloat() * height * progress)
+
+        drawCircle(
+            color = color,
+            radius = 3f,
+            center = Offset(x, y)
+        )
+    }
+}
+
+private fun DrawScope.drawPieSegment(
+    center: Offset,
+    radius: Float,
+    startAngle: Double,
+    endAngle: Double,
+    color: Color
+) {
+    val path = Path().apply {
+        moveTo(center.x, center.y)
+        arcTo(
+            rect = androidx.compose.ui.geometry.Rect(
+                center.x - radius,
+                center.y - radius,
+                center.x + radius,
+                center.y + radius
+            ),
+            startAngleDegrees = Math.toDegrees(startAngle).toFloat(),
+            sweepAngleDegrees = Math.toDegrees(endAngle - startAngle).toFloat(),
+            forceMoveTo = false
+        )
+        close()
+    }
+
+    drawPath(path = path, color = color)
+}
+
+private fun DrawScope.drawDonutSegment(
+    center: Offset,
+    outerRadius: Float,
+    innerRadius: Float,
+    startAngle: Double,
+    endAngle: Double,
+    color: Color
+) {
+    val path = Path().apply {
+        // Outer arc
+        arcTo(
+            rect = androidx.compose.ui.geometry.Rect(
+                center.x - outerRadius,
+                center.y - outerRadius,
+                center.x + outerRadius,
+                center.y + outerRadius
+            ),
+            startAngleDegrees = Math.toDegrees(startAngle).toFloat(),
+            sweepAngleDegrees = Math.toDegrees(endAngle - startAngle).toFloat(),
+            forceMoveTo = false
+        )
+
+        // Line to inner arc
+        val innerEndX = center.x + cos(endAngle).toFloat() * innerRadius
+        val innerEndY = center.y + sin(endAngle).toFloat() * innerRadius
+        lineTo(innerEndX, innerEndY)
+
+        // Inner arc (reverse)
+        arcTo(
+            rect = androidx.compose.ui.geometry.Rect(
+                center.x - innerRadius,
+                center.y - innerRadius,
+                center.x + innerRadius,
+                center.y + innerRadius
+            ),
+            startAngleDegrees = Math.toDegrees(endAngle).toFloat(),
+            sweepAngleDegrees = -Math.toDegrees(endAngle - startAngle).toFloat(),
+            forceMoveTo = false
+        )
+
+        close()
+    }
+
+    drawPath(path = path, color = color)
+}
+
+private fun DrawScope.drawGaugeArc(
+    center: Offset,
+    radius: Float,
+    startAngle: Float,
+    endAngle: Float,
+    lineWidth: Float,
+    color: Color
+) {
+    val sweepAngle = endAngle - startAngle
+    drawArc(
+        color = color,
+        startAngle = startAngle,
+        sweepAngle = sweepAngle,
+        useCenter = false,
+        topLeft = Offset(center.x - radius, center.y - radius),
+        size = Size(radius * 2, radius * 2),
+        style = Stroke(width = lineWidth, cap = StrokeCap.Round)
+    )
+}

package/templates/shared/android/ChartsLibrary/strings.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Charts Library Module -->
+    <string name="chart_line_chart">Line Chart</string>
+    <string name="chart_bar_chart">Bar Chart</string>
+    <string name="chart_pie_chart">Pie Chart</string>
+    <string name="chart_donut_chart">Donut Chart</string>
+    <string name="chart_progress_ring">Progress Ring</string>
+    <string name="chart_sparkline">Sparkline</string>
+    <string name="chart_gauge">Gauge</string>
+    <string name="chart_value_label">Value</string>
+    <string name="chart_percentage_label">Percentage</string>
+    <string name="chart_no_data">No data available</string>
+    <string name="chart_description">Chart displaying data visualization</string>
+    <string name="chart_data_point_description">Data point</string>
+</resources>

package/templates/shared/android/CloudSync/CloudSyncManager.kt

@@ -0,0 +1,84 @@
+package com.appship.shared.cloudsync
+
+import android.content.Context
+import android.content.SharedPreferences
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Manages cloud sync status, timestamps, and conflict resolution.
+ */
+class CloudSyncManager(private val context: Context) {
+    private val _syncState = MutableStateFlow<SyncState>(SyncState.OFFLINE)
+    val syncState: StateFlow<SyncState> = _syncState.asStateFlow()
+    
+    private val _lastSyncedTimestamp = MutableStateFlow<Long?>(null)
+    val lastSyncedTimestamp: StateFlow<Long?> = _lastSyncedTimestamp.asStateFlow()
+    
+    private val _hasConflicts = MutableStateFlow<Boolean>(false)
+    val hasConflicts: StateFlow<Boolean> = _hasConflicts.asStateFlow()
+    
+    var showConflictResolution = false
+    
+    private val prefs: SharedPreferences = context.getSharedPreferences("cloud_sync", Context.MODE_PRIVATE)
+    
+    init {
+        loadLastSyncedTimestamp()
+        checkSyncStatus()
+    }
+    
+    /**
+     * Performs cloud sync
+     */
+    fun sync() {
+        _syncState.value = SyncState.SYNCING
+        
+        // CUSTOMIZE:API - Implement actual sync logic
+        // apiClient.sync()
+        
+        // Simulate sync
+        android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            _syncState.value = SyncState.SYNCED
+            _lastSyncedTimestamp.value = System.currentTimeMillis()
+            saveLastSyncedTimestamp()
+        }, 2000)
+    }
+    
+    /**
+     * Resolves a sync conflict
+     */
+    fun resolveConflict(conflictId: String, resolution: ConflictResolution) {
+        // CUSTOMIZE:API - Apply resolution
+        // apiClient.resolveConflict(conflictId, resolution)
+        
+        _hasConflicts.value = false // Simplified - in real app, track conflicts list
+    }
+    
+    /**
+     * Checks current sync status
+     */
+    fun checkSyncStatus() {
+        // CUSTOMIZE:API - Check sync status with backend
+        // val status = apiClient.getSyncStatus()
+        // _syncState.value = status.state
+        // _hasConflicts.value = status.hasConflicts
+    }
+    
+    private fun loadLastSyncedTimestamp() {
+        val timestamp = prefs.getLong("lastSynced", 0)
+        if (timestamp > 0) {
+            _lastSyncedTimestamp.value = timestamp
+        }
+    }
+    
+    private fun saveLastSyncedTimestamp() {
+        _lastSyncedTimestamp.value?.let {
+            prefs.edit().putLong("lastSynced", it).apply()
+        }
+    }
+}
+
+enum class ConflictResolution {
+    USE_LOCAL, USE_CLOUD
+}